Añade eventos para crear/editar/borrar capas (7fb4d55d) · Commits · REDMIC Project / Server / Atlas

atlas-lib/src/main/java/es/redmic/atlaslib/events/layer/LayerEventFactory.java

0 → 100644

+198 −0

Original line number	Diff line number	Diff line
		package es.redmic.atlaslib.events.layer;

		/*-
		* #%L
		* Atlas-lib
		* %%
		* Copyright (C) 2019 REDMIC Project / Server
		* %%
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		* #L%
		*/

		import java.util.Map;

		import org.apache.logging.log4j.LogManager;
		import org.apache.logging.log4j.Logger;

		import es.redmic.atlaslib.dto.layer.LayerDTO;
		import es.redmic.atlaslib.events.layer.common.LayerCancelledEvent;
		import es.redmic.atlaslib.events.layer.common.LayerEvent;
		import es.redmic.atlaslib.events.layer.create.CreateLayerCancelledEvent;
		import es.redmic.atlaslib.events.layer.create.CreateLayerConfirmedEvent;
		import es.redmic.atlaslib.events.layer.create.CreateLayerFailedEvent;
		import es.redmic.atlaslib.events.layer.create.LayerCreatedEvent;
		import es.redmic.atlaslib.events.layer.delete.DeleteLayerCancelledEvent;
		import es.redmic.atlaslib.events.layer.delete.DeleteLayerCheckFailedEvent;
		import es.redmic.atlaslib.events.layer.delete.DeleteLayerCheckedEvent;
		import es.redmic.atlaslib.events.layer.delete.DeleteLayerConfirmedEvent;
		import es.redmic.atlaslib.events.layer.delete.DeleteLayerEvent;
		import es.redmic.atlaslib.events.layer.delete.DeleteLayerFailedEvent;
		import es.redmic.atlaslib.events.layer.delete.LayerDeletedEvent;
		import es.redmic.atlaslib.events.layer.update.LayerUpdatedEvent;
		import es.redmic.atlaslib.events.layer.update.UpdateLayerCancelledEvent;
		import es.redmic.atlaslib.events.layer.update.UpdateLayerConfirmedEvent;
		import es.redmic.atlaslib.events.layer.update.UpdateLayerFailedEvent;
		import es.redmic.brokerlib.avro.common.Event;
		import es.redmic.brokerlib.avro.common.EventError;
		import es.redmic.exception.common.ExceptionType;
		import es.redmic.exception.common.InternalException;

		public class LayerEventFactory {

		private static Logger logger = LogManager.getLogger();

		public static Event getEvent(Event source, String type) {

		if (type.equals(LayerEventTypes.DELETE)) {

		logger.debug("Creando evento DeleteLayerEvent para: " + source.getAggregateId());
		return new DeleteLayerEvent().buildFrom(source);
		}

		if (type.equals(LayerEventTypes.DELETE_CHECKED)) {

		logger.debug("Creando evento DeleteLayerCheckedEvent para: " + source.getAggregateId());
		return new DeleteLayerCheckedEvent().buildFrom(source);
		}

		if (type.equals(LayerEventTypes.CREATE_CONFIRMED)) {

		logger.debug("Creando evento CreateLayerConfirmedEvent para: " + source.getAggregateId());

		return new CreateLayerConfirmedEvent().buildFrom(source);
		}

		if (type.equals(LayerEventTypes.UPDATE_CONFIRMED)) {

		logger.debug("Creando evento UpdateLayerConfirmedEvent para: " + source.getAggregateId());

		return new UpdateLayerConfirmedEvent().buildFrom(source);
		}

		if (type.equals(LayerEventTypes.DELETE_CONFIRMED)) {

		logger.debug("Creando evento DeleteLayerConfirmedEvent para: " + source.getAggregateId());

		return new DeleteLayerConfirmedEvent().buildFrom(source);
		}

		if (type.equals(LayerEventTypes.DELETED)) {

		logger.debug("Creando evento LayerDeletedEvent para: " + source.getAggregateId());
		return new LayerDeletedEvent().buildFrom(source);
		}

		logger.error("Tipo de evento no soportado");
		throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);
		}

		public static Event getEvent(Event source, String type, LayerDTO layer) {

		LayerEvent successfulEvent = null;

		if (type.equals(LayerEventTypes.CREATED)) {
		logger.debug("Creando evento LayerCreatedEvent para: " + source.getAggregateId());
		successfulEvent = new LayerCreatedEvent().buildFrom(source);
		}

		if (type.equals(LayerEventTypes.UPDATED)) {
		logger.debug("Creando evento LayerUpdatedEvent para: " + source.getAggregateId());
		successfulEvent = new LayerUpdatedEvent().buildFrom(source);
		}

		if (successfulEvent != null) {
		successfulEvent.setLayer(layer);
		return successfulEvent;
		} else {
		logger.error("Tipo de evento no soportado");
		throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);
		}
		}

		public static Event getEvent(Event source, String type, String exceptionType,
		Map<String, String> exceptionArguments) {

		EventError failedEvent = null;

		if (type.equals(LayerEventTypes.CREATE_FAILED)) {

		logger.debug("No se pudo crear Atlas type en la vista");
		failedEvent = new CreateLayerFailedEvent().buildFrom(source);
		}
		if (type.equals(LayerEventTypes.UPDATE_FAILED)) {

		logger.debug("No se pudo modificar Atlas type en la vista");
		failedEvent = new UpdateLayerFailedEvent().buildFrom(source);
		}
		if (type.equals(LayerEventTypes.DELETE_FAILED)) {

		logger.debug("No se pudo eliminar Atlas type de la vista");
		failedEvent = new DeleteLayerFailedEvent().buildFrom(source);
		}

		if (type.equals(LayerEventTypes.DELETE_CHECK_FAILED)) {

		logger.debug("Checkeo de eliminación fallido, el item está referenciado");
		failedEvent = new DeleteLayerCheckFailedEvent().buildFrom(source);
		}

		if (type.equals(LayerEventTypes.CREATE_CANCELLED)) {

		logger.debug("Enviando evento CreateLayerCancelledEvent para: " + source.getAggregateId());
		failedEvent = new CreateLayerCancelledEvent().buildFrom(source);
		}

		if (failedEvent != null) {

		failedEvent.setExceptionType(exceptionType);
		failedEvent.setArguments(exceptionArguments);
		return failedEvent;

		} else {
		logger.error("Tipo de evento no soportado");
		throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);
		}
		}

		public static Event getEvent(Event source, String type, LayerDTO layer, String exceptionType,
		Map<String, String> exceptionArguments) {

		LayerCancelledEvent cancelledEvent = null;

		if (type.equals(LayerEventTypes.UPDATE_CANCELLED)) {

		logger.debug("Creando evento UpdateLayerCancelledEvent para: " + source.getAggregateId());
		cancelledEvent = new UpdateLayerCancelledEvent().buildFrom(source);
		}

		if (type.equals(LayerEventTypes.DELETE_CANCELLED)) {

		logger.debug("Creando evento DeleteLayerCancelledEvent para: " + source.getAggregateId());
		cancelledEvent = new DeleteLayerCancelledEvent().buildFrom(source);
		}

		if (cancelledEvent != null) {

		cancelledEvent.setLayer(layer);
		cancelledEvent.setExceptionType(exceptionType);
		cancelledEvent.setArguments(exceptionArguments);
		return cancelledEvent;

		} else {

		logger.error("Tipo de evento no soportado");
		throw new InternalException(ExceptionType.INTERNAL_EXCEPTION);
		}
		}
		}

atlas-lib/src/main/java/es/redmic/atlaslib/events/layer/LayerEventTypes.java

0 → 100644

+41 −0

Original line number	Diff line number	Diff line
		package es.redmic.atlaslib.events.layer;

		/*-
		* #%L
		* Atlas-lib
		* %%
		* Copyright (C) 2019 REDMIC Project / Server
		* %%
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		* #L%
		*/

		import es.redmic.brokerlib.avro.common.EventTypes;

		public abstract class LayerEventTypes extends EventTypes {

		public static boolean isLocked(String eventType) {

		return EventTypes.isLocked(eventType);
		}

		public static boolean isSnapshot(String eventType) {

		return EventTypes.isSnapshot(eventType);
		}

		public static boolean isUpdatable(String eventType) {

		return EventTypes.isUpdatable(eventType);
		}
		}

atlas-lib/src/main/java/es/redmic/atlaslib/events/layer/common/LayerCancelledEvent.java

0 → 100644

+122 −0

Original line number	Diff line number	Diff line
		package es.redmic.atlaslib.events.layer.common;

		/*-
		* #%L
		* Atlas-lib
		* %%
		* Copyright (C) 2019 REDMIC Project / Server
		* %%
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		* #L%
		*/

		import java.util.Map;

		import org.joda.time.DateTime;
		import org.joda.time.DateTimeZone;

		import com.fasterxml.jackson.annotation.JsonIgnore;

		import es.redmic.atlaslib.dto.layer.LayerDTO;
		import es.redmic.brokerlib.avro.common.EventError;

		public abstract class LayerCancelledEvent extends EventError {

		private LayerDTO layer;

		public LayerCancelledEvent(String type) {
		super(type);
		this.setLayer(layer);
		}

		public LayerDTO getLayer() {
		return layer;
		}

		public void setLayer(LayerDTO layer) {
		this.layer = layer;
		}

		@Override
		public Object get(int field$) {
		switch (field$) {
		case 0:
		return getLayer();
		case 1:
		return getExceptionType();
		case 2:
		return getArguments();
		case 3:
		return getAggregateId();
		case 4:
		return getVersion();
		case 5:
		return getType();
		case 6:
		return getDate().getMillis();
		case 7:
		return getSessionId();
		case 8:
		return getUserId();
		case 9:
		return getId();
		default:
		throw new org.apache.avro.AvroRuntimeException("Bad index");
		}
		}

		@SuppressWarnings("rawtypes")
		@Override
		public void put(int field$, Object value$) {
		switch (field$) {
		case 0:
		layer = (LayerDTO) value$;
		break;
		case 1:
		setExceptionType(value$.toString());
		break;
		case 2:
		setArguments((Map) value$);
		break;
		case 3:
		setAggregateId(value$.toString());
		break;
		case 4:
		setVersion((java.lang.Integer) value$);
		break;
		case 5:
		setType(value$.toString());
		break;
		case 6:
		setDate(new DateTime(value$, DateTimeZone.UTC));
		break;
		case 7:
		setSessionId(value$.toString());
		break;
		case 8:
		setUserId(value$.toString());
		break;
		case 9:
		setId(value$.toString());
		break;
		default:
		throw new org.apache.avro.AvroRuntimeException("Bad index");
		}
		}

		@JsonIgnore
		public static String getLayerEventSchema() {

		return "{\"name\":\"layer\", \"type\": " + LayerDTO.SCHEMA$.toString() + "}";
		}
		}

atlas-lib/src/main/java/es/redmic/atlaslib/events/layer/common/LayerEvent.java

0 → 100644

+109 −0

Original line number	Diff line number	Diff line
		package es.redmic.atlaslib.events.layer.common;

		/*-
		* #%L
		* Atlas-lib
		* %%
		* Copyright (C) 2019 REDMIC Project / Server
		* %%
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		* #L%
		*/

		import org.joda.time.DateTime;
		import org.joda.time.DateTimeZone;

		import com.fasterxml.jackson.annotation.JsonIgnore;

		import es.redmic.atlaslib.dto.layer.LayerDTO;
		import es.redmic.brokerlib.avro.common.Event;

		public abstract class LayerEvent extends Event {

		private LayerDTO layer;

		public LayerEvent(String type) {
		super(type);
		this.setLayer(layer);
		}

		public LayerDTO getLayer() {
		return layer;
		}

		public void setLayer(LayerDTO layer) {
		this.layer = layer;
		}

		@Override
		public Object get(int field$) {
		switch (field$) {
		case 0:
		return getLayer();
		case 1:
		return getAggregateId();
		case 2:
		return getVersion();
		case 3:
		return getType();
		case 4:
		return getDate().getMillis();
		case 5:
		return getSessionId();
		case 6:
		return getUserId();
		case 7:
		return getId();
		default:
		throw new org.apache.avro.AvroRuntimeException("Bad index");
		}
		}

		@Override
		public void put(int field$, Object value$) {
		switch (field$) {
		case 0:
		layer = (LayerDTO) value$;
		break;
		case 1:
		setAggregateId(value$.toString());
		break;
		case 2:
		setVersion((java.lang.Integer) value$);
		break;
		case 3:
		setType(value$.toString());
		break;
		case 4:
		setDate(new DateTime(value$, DateTimeZone.UTC));
		break;
		case 5:
		setSessionId(value$.toString());
		break;
		case 6:
		setUserId(value$.toString());
		break;
		case 7:
		setId(value$.toString());
		break;
		default:
		throw new org.apache.avro.AvroRuntimeException("Bad index");
		}
		}

		@JsonIgnore
		public static String getLayerEventSchema() {

		return "{\"name\":\"layer\", \"type\": " + LayerDTO.SCHEMA$.toString() + "}";
		}
		}

atlas-lib/src/main/java/es/redmic/atlaslib/events/layer/create/CreateLayerCancelledEvent.java

0 → 100644

+54 −0

Original line number	Diff line number	Diff line
		package es.redmic.atlaslib.events.layer.create;

		/*-
		* #%L
		* Atlas-lib
		* %%
		* Copyright (C) 2019 REDMIC Project / Server
		* %%
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		* #L%
		*/

		import org.apache.avro.Schema;

		import es.redmic.atlaslib.dto.layer.LayerDTO;
		import es.redmic.atlaslib.events.layer.LayerEventTypes;
		import es.redmic.brokerlib.avro.common.EventError;

		public class CreateLayerCancelledEvent extends EventError {

		// @formatter:off

		public static final org.apache.avro.Schema SCHEMA$ = new org.apache.avro.Schema.Parser().parse("{"
		+ "\"type\":\"record\",\"name\":\"CreateLayerCancelledEvent\","
		+ "\"namespace\":\"es.redmic.atlaslib.events.layer.create\",\"fields\":["
		+ getFailEventSchema() + ","
		+ getEventBaseSchema() + "]}");
		// @formatter:on

		static String type = LayerEventTypes.CREATE_CANCELLED;

		public CreateLayerCancelledEvent() {
		super(type);
		}

		public CreateLayerCancelledEvent(LayerDTO themeInspireType) {
		super(type);
		}

		@Override
		public Schema getSchema() {
		return SCHEMA$;
		}
		}