This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository observe. See http://git.codelutin.com/observe.git commit bd5b868e25ff6701fda79304400ca9b168bfcd59 Author: Tony CHEMIT <chemit@codelutin.com> Date: Wed Aug 19 14:04:15 2015 +0200 Création d'un paquetage builder pour y mettre tous les types de builders --- .../services/builder/DtoToEntityBuilder.java | 222 +++++++++++++++++++++ .../{dto => builder}/EntityToDtoBuilder.java | 109 ++++++---- .../builder/EntityToReferenceDtoBuilder.java | 49 +++++ .../EntityToReferentialReferenceDtoBuilder.java} | 32 +-- .../services/builder/DtoToEntityBuilderTest.java | 117 +++++++++++ .../dto => builder}/EntityToDtoBuilderTest.java | 3 +- 6 files changed, 469 insertions(+), 63 deletions(-) diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/builder/DtoToEntityBuilder.java b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/DtoToEntityBuilder.java new file mode 100644 index 0000000..b6a04b4 --- /dev/null +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/DtoToEntityBuilder.java @@ -0,0 +1,222 @@ +package fr.ird.observe.services.builder; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Iterables; +import fr.ird.observe.entities.Set; +import fr.ird.observe.services.ObserveServiceTopia; +import fr.ird.observe.services.dto.IdDto; +import fr.ird.observe.services.dto.ObserveDtoBinders; +import fr.ird.observe.services.dto.ReferenceDto; +import fr.ird.observe.services.dto.constants.GearType; +import fr.ird.observe.services.dto.constants.ReferenceStatus; +import fr.ird.observe.services.dto.constants.seine.NonTargetCatchComputedValueSource; +import fr.ird.observe.services.dto.constants.seine.Ownership; +import fr.ird.observe.services.dto.constants.seine.SchoolType; +import fr.ird.observe.services.dto.constants.seine.TypeTransmittingBuoyOperation; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import org.nuiton.topia.persistence.TopiaEntity; +import org.nuiton.util.beans.Binder; + +import java.io.Closeable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; + +/** + * Created on 19/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class DtoToEntityBuilder<D extends IdDto, E extends TopiaEntity> implements Closeable { + + protected final Binder<D, E> binder; + + private final ObserveServiceTopia serviceTopia; + + public static <E extends TopiaEntity, D extends IdDto> DtoToEntityBuilder<D, E> create(Class<D> dtoType, Class<E> entityType, ObserveServiceTopia serviceTopia) { + + Preconditions.checkNotNull(dtoType, "'dtoType' can't be null."); + Preconditions.checkNotNull(entityType, "'entityType' can't be null."); + Preconditions.checkNotNull(serviceTopia, "'serviceTopia' can't be null."); + + Binder<D, E> binder = ObserveDtoBinders.newDtoToEntityBinder(dtoType, entityType); + + Preconditions.checkNotNull(binder, "DtoToEntityBinder<" + dtoType.getName() + ", " + entityType.getName() + "> not found."); + + DtoToEntityBuilder<D, E> builder = new DtoToEntityBuilder<>(binder, serviceTopia); + return builder; + + } + + public void build(D dto, E entity) { + + Preconditions.checkNotNull(dto, "'dto' can't be null."); + Preconditions.checkNotNull(entity, "'entity' can't be null."); + + Map<String, Object> dtoProperties = binder.obtainProperties(dto); + + ImmutableMap.Builder<String, Object> entityProperties = new ImmutableMap.Builder<>(); + + for (Map.Entry<String, Object> entry : dtoProperties.entrySet()) { + + String propertyName = entry.getKey(); + Object propertyValue = entry.getValue(); + + if (isCollectionProperty(propertyValue)) { + + Class<?> collectionType = binder.getTargetPropertyType(propertyName); + + Collection<Object> entityCollection = newCollection(collectionType); + + Collection collection = (Collection) propertyValue; + + if (!collection.isEmpty()) { + + Object o1 = Iterables.get(collection, 0); + + if (o1 instanceof ReferenceDto) { + + Collection<ReferenceDto> referenceDtos = (Collection<ReferenceDto>) collection; + + for (ReferenceDto referenceDto : referenceDtos) { + + TopiaEntity propertyEntity = toEntity(referenceDto); + entityCollection.add(propertyEntity); + } + + } else if (o1 instanceof IdDto) { + + Collection<IdDto> idDtos = (Collection<IdDto>) collection; + + for (IdDto idDto : idDtos) { + + TopiaEntity propertyEntity = toEntity(idDto); + entityCollection.add(propertyEntity); + } + + } else { + + entityCollection.addAll(collection); + + } + + } + + entityProperties.put(propertyName, entityCollection); + continue; + + } + + if (propertyValue instanceof ReferenceDto) { + + propertyValue = toEntity((ReferenceDto) propertyValue); + entityProperties.put(propertyName, propertyValue); + continue; + + } + + if (propertyValue instanceof IdDto) { + + propertyValue = toEntity((IdDto) propertyValue); + entityProperties.put(propertyName, propertyValue); + continue; + + } + + // simple property + addProperty(propertyName, propertyValue, entityProperties); + + } + + binder.injectProperties(entityProperties.build(), entity); + + } + + protected TopiaEntity toEntity(ReferenceDto referenceDto) { + return serviceTopia.getEntityFromReference(referenceDto); + } + + protected TopiaEntity toEntity(IdDto idDto) { + + Class<IdDto> aClass = (Class<IdDto>) idDto.getClass(); + Class<TopiaEntity> entityType = ObserveServiceTopia.getEntityType(aClass); + TopiaEntity entity = serviceTopia.newEntity(entityType); + + DtoToEntityBuilder<IdDto, TopiaEntity> builder = create(aClass, entityType, serviceTopia); + builder.build(idDto, entity); + + return entity; + } + + @Override + public void close() { + + } + + protected DtoToEntityBuilder(Binder<D, E> binder, ObserveServiceTopia serviceTopia) { + this.binder = binder; + this.serviceTopia = serviceTopia; + } + + protected boolean isCollectionProperty(Object propertyValue) { + return propertyValue instanceof Collection; + } + + protected Collection<Object> newCollection(Object propertyValue) { + + Collection<Object> propertyValueCollection = null; + if (propertyValue instanceof Set) { + propertyValueCollection = new LinkedHashSet<>(); + } else + if (propertyValue instanceof Collection) { + propertyValueCollection = new LinkedHashSet<>(); + } + if (propertyValue instanceof List) { + propertyValueCollection = new ArrayList<>(); + } + return propertyValueCollection; + } + + protected void addProperty(String propertyName, Object propertyValue, ImmutableMap.Builder<String, Object> entitiesPropertiesBuilder) { + + if (ReferentialDto.PROPERTY_ID.equals(propertyName)) { + propertyName = TopiaEntity.TOPIA_ID; + } else if (propertyValue instanceof GearType) { + + GearType entityGearType = (GearType) propertyValue; + propertyValue = fr.ird.observe.entities.constants.GearType.valueOf(entityGearType.name()); + + } else if (propertyValue instanceof ReferenceStatus) { + + ReferenceStatus referenceStatus = (ReferenceStatus) propertyValue; + propertyValue = fr.ird.observe.entities.constants.ReferenceStatus.valueOf(referenceStatus.name()); + + } else if (propertyValue instanceof Ownership) { + + Ownership ownership = (Ownership) propertyValue; + propertyValue = Ownership.valueOf(ownership.name()); + + } else if (propertyValue instanceof SchoolType) { + + SchoolType schoolType = (SchoolType) propertyValue; + propertyValue = fr.ird.observe.entities.constants.seine.SchoolType.valueOf(schoolType.name()); + + } else if (propertyValue instanceof TypeTransmittingBuoyOperation) { + + TypeTransmittingBuoyOperation typeTransmittingBuoyOperation = (TypeTransmittingBuoyOperation) propertyValue; + propertyValue = fr.ird.observe.entities.constants.seine.TypeTransmittingBuoyOperation.valueOf(typeTransmittingBuoyOperation.name()); + + } else if (propertyValue instanceof NonTargetCatchComputedValueSource) { + + NonTargetCatchComputedValueSource nonTargetCatchComputedValueSource = (NonTargetCatchComputedValueSource) propertyValue; + propertyValue = fr.ird.observe.entities.constants.seine.NonTargetCatchComputedValueSource.valueOf(nonTargetCatchComputedValueSource.name()); + + } + + entitiesPropertiesBuilder.put(propertyName, propertyValue); + + } +} diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/dto/EntityToDtoBuilder.java b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToDtoBuilder.java similarity index 67% rename from observe-services-topia/src/main/java/fr/ird/observe/services/dto/EntityToDtoBuilder.java rename to observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToDtoBuilder.java index 7f7d2d2..8ce3a8e 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/dto/EntityToDtoBuilder.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToDtoBuilder.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.dto; +package fr.ird.observe.services.builder; import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableMap; @@ -13,15 +13,19 @@ import fr.ird.observe.entities.constants.seine.Ownership; import fr.ird.observe.entities.constants.seine.SchoolType; import fr.ird.observe.entities.constants.seine.TypeTransmittingBuoyOperation; import fr.ird.observe.services.ObserveServiceTopia; +import fr.ird.observe.services.dto.IdDto; +import fr.ird.observe.services.dto.ObserveDtoBinders; +import fr.ird.observe.services.dto.ReferenceDto; import fr.ird.observe.services.dto.constants.ReferentialLocale; import fr.ird.observe.services.dto.referential.ReferentialDto; import org.nuiton.topia.persistence.TopiaEntity; import org.nuiton.util.beans.Binder; import java.io.Closeable; +import java.util.ArrayList; import java.util.Collection; +import java.util.HashSet; import java.util.LinkedHashSet; -import java.util.LinkedList; import java.util.Map; /** @@ -37,15 +41,11 @@ public class EntityToDtoBuilder<E extends TopiaEntity, D extends IdDto> implemen private ImmutableSet<Class<? extends IdDto>> referencesTypes; - public EntityToDtoBuilder(D result, Binder<E, D> binder) { - this.result = result; - this.binder = binder; - } - public static <E extends TopiaEntity, D extends ReferentialDto> EntityToDtoBuilder<E, D> create(Class<E> entityType, Class<D> dtoType) { - Preconditions.checkNotNull(entityType, "entityType can't be null."); - Preconditions.checkNotNull(dtoType, "dtoType can't be null."); + Preconditions.checkNotNull(entityType, "'entityType' can't be null."); + Preconditions.checkNotNull(dtoType, "'dtoType' can't be null."); + D result; try { result = dtoType.newInstance(); @@ -54,12 +54,19 @@ public class EntityToDtoBuilder<E extends TopiaEntity, D extends IdDto> implemen } Binder<E, D> binder = ObserveDtoBinders.newEntityToDtoBinder(entityType, dtoType); + + Preconditions.checkNotNull(binder, "EntityToDtoBinder<" + entityType.getName() + ", " + dtoType.getName() + "> not found."); + EntityToDtoBuilder<E, D> builder = new EntityToDtoBuilder<>(result, binder); return builder; + } public D build(ReferentialLocale referentialLocale, E entity) { + Preconditions.checkNotNull(referentialLocale, "'referentialLocale' can't be null."); + Preconditions.checkNotNull(entity, "'entity' can't be null."); + ImmutableSet.Builder<Class<? extends IdDto>> referenceTypesBuilder = new ImmutableSet.Builder<>(); Map<String, Object> entityProperties = binder.obtainProperties(entity, false); @@ -67,47 +74,46 @@ public class EntityToDtoBuilder<E extends TopiaEntity, D extends IdDto> implemen ImmutableMap.Builder<String, Object> dtoPropertiesBuilder = new ImmutableMap.Builder<>(); for (Map.Entry<String, Object> entry : entityProperties.entrySet()) { + String propertyName = entry.getKey(); Object propertyValue = entry.getValue(); - Collection<Object> propertyValueCollection = null; - if (propertyValue instanceof Set) { + if (isCollectionProperty(propertyValue)) { - propertyValueCollection = new LinkedHashSet<>(); - } - if (propertyValue instanceof Collection) { - propertyValueCollection = new LinkedList<>(); - } + Collection collection = (Collection) propertyValue; - if (propertyValueCollection != null) { + Class<?> collectionType = binder.getTargetPropertyType(propertyName); - Collection collection = (Collection) propertyValue; - if (collection.isEmpty()) { - continue; - } - Object valueToAdd = collection; + Collection<Object> dtoCollection = newCollection(collectionType); + + if (!collection.isEmpty()) { - Object o1 = Iterables.get(collection, 0); + Object o1 = Iterables.get(collection, 0); - if (o1 instanceof TopiaEntity) { + if (o1 instanceof TopiaEntity) { - Class<? extends TopiaEntity> entityType = ObserveEntityEnum.valueOf((TopiaEntity)o1).getContract(); + Class<? extends TopiaEntity> entityType = ObserveEntityEnum.valueOf((TopiaEntity) o1).getContract(); - Class dtoType = ObserveServiceTopia.getDtoType(entityType); + Class dtoType = ObserveServiceTopia.getDtoType(entityType); - Collection<? extends TopiaEntity> topiaEntities = (Collection<? extends TopiaEntity>) collection; - LinkedHashSet<ReferenceDto> references = new LinkedHashSet<>(topiaEntities.size()); - for (TopiaEntity entityValue : topiaEntities) { + Collection<? extends TopiaEntity> topiaEntities = (Collection<? extends TopiaEntity>) collection; + + for (TopiaEntity entityValue : topiaEntities) { + + dtoCollection.add(entityToRef(referentialLocale, dtoType, entityValue, referenceTypesBuilder)); + } + + } else { + + dtoCollection.addAll(collection); - references.add(entityToRef(referentialLocale, dtoType, entityValue, referenceTypesBuilder)); } - valueToAdd = references; } - addProperty(propertyName, valueToAdd, dtoPropertiesBuilder); - + addProperty(propertyName, dtoCollection, dtoPropertiesBuilder); continue; + } if (propertyValue instanceof TopiaEntity) { @@ -117,9 +123,12 @@ public class EntityToDtoBuilder<E extends TopiaEntity, D extends IdDto> implemen Class<? extends TopiaEntity> entityType = ObserveEntityEnum.valueOf(entityValue).getContract(); Class dtoType = ObserveServiceTopia.getDtoType(entityType); propertyValue = entityToRef(referentialLocale, dtoType, entityValue, referenceTypesBuilder); + addProperty(propertyName, propertyValue, dtoPropertiesBuilder); + continue; } + // simple property addProperty(propertyName, propertyValue, dtoPropertiesBuilder); } @@ -133,7 +142,33 @@ public class EntityToDtoBuilder<E extends TopiaEntity, D extends IdDto> implemen } - private void addProperty(String propertyName, Object propertyValue, ImmutableMap.Builder<String, Object> dtoPropertiesBuilder) { + public ImmutableSet<Class<? extends IdDto>> getReferenceTypes() { + return referencesTypes; + } + + protected EntityToDtoBuilder(D result, Binder<E, D> binder) { + this.result = result; + this.binder = binder; + } + + protected boolean isCollectionProperty(Object propertyValue) { + return propertyValue instanceof Collection; + } + + protected Collection<Object> newCollection(Class<?> collectionType) { + + Collection<Object> propertyValueCollection = null; + if (LinkedHashSet.class.isAssignableFrom(collectionType)) { + propertyValueCollection = new LinkedHashSet<>(); + } else if (Set.class.isAssignableFrom(collectionType)) { + propertyValueCollection = new HashSet<>(); + } else if (Collection.class.isAssignableFrom(collectionType)) { + propertyValueCollection = new ArrayList<>(); + } + return propertyValueCollection; + } + + protected void addProperty(String propertyName, Object propertyValue, ImmutableMap.Builder<String, Object> dtoPropertiesBuilder) { if (TopiaEntity.TOPIA_ID.equals(propertyName)) { propertyName = ReferentialDto.PROPERTY_ID; @@ -180,7 +215,7 @@ public class EntityToDtoBuilder<E extends TopiaEntity, D extends IdDto> implemen ReferenceDto<R> label; if (ReferentialDto.class.isAssignableFrom(dtoType)) { - label = EntityToReferenceDtoBuilder.buildReferential((Class) dtoType, referentialLocale, entityValue); + label = EntityToReferentialReferenceDtoBuilder.build((Class) dtoType, referentialLocale, entityValue); } else { label = EntityToReferenceDtoBuilder.build(dtoType, entityValue); @@ -195,8 +230,4 @@ public class EntityToDtoBuilder<E extends TopiaEntity, D extends IdDto> implemen public void close() { } - - public ImmutableSet<Class<? extends IdDto>> getReferenceTypes() { - return referencesTypes; - } } diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferenceDtoBuilder.java b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferenceDtoBuilder.java new file mode 100644 index 0000000..a9e9cc2 --- /dev/null +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferenceDtoBuilder.java @@ -0,0 +1,49 @@ +package fr.ird.observe.services.builder; + +import com.google.common.base.Preconditions; +import fr.ird.observe.ObserveEntityEnum; +import fr.ird.observe.services.dto.IdDto; +import fr.ird.observe.services.dto.ObserveDtoBinders; +import fr.ird.observe.services.dto.ReferenceDto; +import fr.ird.observe.services.dto.ReferenceDtos; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import org.nuiton.topia.persistence.TopiaEntity; +import org.nuiton.util.beans.Binder; + +import java.io.Serializable; +import java.util.Map; +import java.util.Set; + +/** + * Created on 19/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class EntityToReferenceDtoBuilder<E extends TopiaEntity, D extends IdDto> { + + public static <E extends TopiaEntity, D extends IdDto> ReferenceDto<D> build(Class<D> dtoType, E entity) { + + Preconditions.checkNotNull(dtoType, "'dtoType' can't be null"); + Preconditions.checkArgument(ReferentialDto.class.isAssignableFrom(dtoType), "'dtoType' can't be of type ReferentialDto, use the method buildReferential insteadnull"); + Preconditions.checkNotNull(entity, "'entity' can't be null"); + + Class<E> entityType = (Class<E>) ObserveEntityEnum.valueOf(entity).getContract(); + Binder<E, D> binder = ObserveDtoBinders.newEntityToReferenceBinder(entityType, dtoType); + + Preconditions.checkNotNull(binder, "EntityToReferenceBinder<" + entityType.getName() + ", " + dtoType.getName() + "> not found."); + + Map<String, Object> entityProperties = binder.obtainProperties(entity); + Set<String> propertyNames = entityProperties.keySet(); + + ReferenceDto<D> result = ReferenceDtos.newReferenceDto(dtoType, propertyNames); + + for (Map.Entry<String, Object> entry : entityProperties.entrySet()) { + String propertyName = entry.getKey(); + Object propertyValue = entry.getValue(); + result.setPropertyValue(propertyName, (Serializable) propertyValue); + } + return result; + + } + +} diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/dto/EntityToReferenceDtoBuilder.java b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferentialReferenceDtoBuilder.java similarity index 53% rename from observe-services-topia/src/main/java/fr/ird/observe/services/dto/EntityToReferenceDtoBuilder.java rename to observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferentialReferenceDtoBuilder.java index 0c8d288..4b9d625 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/dto/EntityToReferenceDtoBuilder.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferentialReferenceDtoBuilder.java @@ -1,6 +1,8 @@ -package fr.ird.observe.services.dto; +package fr.ird.observe.services.builder; +import com.google.common.base.Preconditions; import fr.ird.observe.ObserveEntityEnum; +import fr.ird.observe.services.dto.ObserveDtoBinders; import fr.ird.observe.services.dto.constants.ReferentialLocale; import fr.ird.observe.services.dto.referential.ReferentialDto; import fr.ird.observe.services.dto.referential.ReferentialReferenceDto; @@ -17,31 +19,17 @@ import java.util.Set; * * @author Tony Chemit - chemit@codelutin.com */ -public class EntityToReferenceDtoBuilder<E extends TopiaEntity, D extends IdDto> { +public class EntityToReferentialReferenceDtoBuilder<E extends TopiaEntity, D extends ReferentialDto> { - public static <E extends TopiaEntity, D extends IdDto> ReferenceDto<D> build(Class<D> dtoType, E entity) { + public static <E extends TopiaEntity, D extends ReferentialDto> ReferentialReferenceDto<D> build(Class<D> dtoType, ReferentialLocale referentialLocale, E entity) { - Class<E> entityType = (Class<E>) ObserveEntityEnum.valueOf(entity).getContract(); - Binder<E, E> binder = ObserveDtoBinders.newEntityToReferenceBinder(entityType); - - Map<String, Object> entityProperties = binder.obtainProperties(entity); - Set<String> propertyNames = entityProperties.keySet(); - - ReferenceDto<D> result = ReferenceDtos.newReferenceDto(dtoType, propertyNames); - - for (Map.Entry<String, Object> entry : entityProperties.entrySet()) { - String propertyName = entry.getKey(); - Object propertyValue = entry.getValue(); - result.setPropertyValue(propertyName, (Serializable) propertyValue); - } - return result; - - } - - public static <E extends TopiaEntity, D extends ReferentialDto> ReferentialReferenceDto<D> buildReferential(Class<D> dtoType, ReferentialLocale referentialLocale, E entity) { + Preconditions.checkNotNull(dtoType, "'dtoType' can't be null"); + Preconditions.checkNotNull(referentialLocale, "'referentialLocale' can't be null"); + Preconditions.checkNotNull(entity, "'entity' can't be null"); Class<E> entityType = (Class<E>) ObserveEntityEnum.valueOf(entity).getContract(); - Binder<E, E> binder = ObserveDtoBinders.newEntityToReferenceBinder(entityType); + Binder<E, D> binder = ObserveDtoBinders.newEntityToReferenceBinder(entityType, dtoType); + Preconditions.checkNotNull(binder, "EntityToReferenceBinder<" + entityType.getName() + ", " + dtoType.getName() + "> not found."); Map<String, Object> entityProperties = binder.obtainProperties(entity); Set<String> propertyNames = entityProperties.keySet(); diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/builder/DtoToEntityBuilderTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/builder/DtoToEntityBuilderTest.java new file mode 100644 index 0000000..72ca1a0 --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/builder/DtoToEntityBuilderTest.java @@ -0,0 +1,117 @@ +package fr.ird.observe.services.builder; + +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.ObserveEntityEnum; +import fr.ird.observe.entities.referentiel.Organism; +import fr.ird.observe.entities.referentiel.Program; +import fr.ird.observe.services.ObserveServiceTopia; +import fr.ird.observe.services.dto.constants.GearType; +import fr.ird.observe.services.dto.constants.ReferenceStatus; +import fr.ird.observe.services.dto.constants.ReferentialLocale; +import fr.ird.observe.services.dto.referential.I18nReferentialDto; +import fr.ird.observe.services.dto.referential.OrganismDto; +import fr.ird.observe.services.dto.referential.ProgramDto; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReferenceDto; +import fr.ird.observe.services.dto.referential.ReferentialReferenceDtos; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.nuiton.topia.persistence.TopiaEntity; +import org.nuiton.util.DateUtil; + +/** + * Created on 19/08/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class DtoToEntityBuilderTest { + + @BeforeClass + public static void setUp() throws Exception { + ObserveServiceTopia.init(); + } + + @Test + public void testCopy() { + + ObserveServiceTopia service = new ObserveServiceTopia() { + + @Override + protected <D extends ReferentialDto, E extends TopiaEntity> E loadEntity(Class<D> dtoType, Class<E> entityType, String id) { + E e = newEntity(entityType); + e.setTopiaId(id); + return e; + } + + @Override + public <E extends TopiaEntity> E newEntity(Class<E> entityType) { + + try { + return (E) ObserveEntityEnum.valueOf(entityType).getImplementation().newInstance(); + } catch (InstantiationException | IllegalAccessException e) { + throw new IllegalStateException("could not create instance of " + entityType.getName()); + } + } + }; + + ProgramDto programDto = new ProgramDto(); + programDto.setCode("code"); + programDto.setNeedComment(true); + programDto.setStatus(ReferenceStatus.enabled); + programDto.setLabel1("label1"); + programDto.setLabel2("label2"); + programDto.setLabel3("label3"); + programDto.setLabel4("label4"); + programDto.setLabel5("label5"); + programDto.setLabel6("label6"); + programDto.setLabel7("label7"); + programDto.setLabel8("label8"); + programDto.setId("Program1"); + programDto.setStartDate(DateUtil.createDate(1, 1, 1)); + programDto.setEndDate(DateUtil.createDate(1, 1, 2)); + programDto.setGearType(GearType.seine); + programDto.setTargetDiscardsObservation(1); + + ReferentialReferenceDto organismDto = ReferentialReferenceDtos.newReferentialReferenceDto(OrganismDto.class, ReferentialLocale.FR, + ImmutableSet.of( + I18nReferentialDto.PROPERTY_LABEL2, + I18nReferentialDto.PROPERTY_CODE + )); + organismDto.setId("Organism1"); + organismDto.setPropertyValue(ReferentialLocale.FR, I18nReferentialDto.PROPERTY_LABEL2, "organism2"); + organismDto.setPropertyValue(I18nReferentialDto.PROPERTY_CODE, "organismCode"); + programDto.setOrganism(organismDto); + + DtoToEntityBuilder<ProgramDto, Program> builder = DtoToEntityBuilder.create(ProgramDto.class, Program.class, service); + + Program program = service.newEntity(Program.class); + builder.build(programDto, program); + + // On vérife que le program a bien été copié + Assert.assertEquals(programDto.getCode(), program.getCode()); + Assert.assertEquals(programDto.isNeedComment(), program.isNeedComment()); + Assert.assertNotNull(program.getStatus()); + Assert.assertEquals(programDto.getStatus().name(), program.getStatus().name()); + + Assert.assertEquals(programDto.getLabel1(), program.getLabel1()); + Assert.assertEquals(programDto.getLabel2(), program.getLabel2()); + Assert.assertEquals(programDto.getLabel3(), program.getLabel3()); + Assert.assertEquals(programDto.getLabel4(), program.getLabel4()); + Assert.assertEquals(programDto.getLabel5(), program.getLabel5()); + Assert.assertEquals(programDto.getLabel6(), program.getLabel6()); + Assert.assertEquals(programDto.getLabel7(), program.getLabel7()); + Assert.assertEquals(programDto.getLabel8(), program.getLabel8()); + Assert.assertEquals(programDto.getId(), program.getTopiaId()); + Assert.assertNotNull(program.getGearType()); + Assert.assertEquals(programDto.getGearType().name(), program.getGearType().name()); + Assert.assertEquals(programDto.getTargetDiscardsObservation(), program.getTargetDiscardsObservation()); + + // On vérife que la référence sur l'organisme a bien été trouvée + Organism organism = program.getOrganism(); + Assert.assertNotNull(organism); + Assert.assertEquals(organismDto.getId(), organism.getTopiaId()); + + } + +} \ No newline at end of file diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/dto/EntityToDtoBuilderTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/builder/EntityToDtoBuilderTest.java similarity index 98% rename from observe-services-topia/src/test/java/fr/ird/observe/services/service/dto/EntityToDtoBuilderTest.java rename to observe-services-topia/src/test/java/fr/ird/observe/services/builder/EntityToDtoBuilderTest.java index c587a10..1005eef 100644 --- a/observe-services-topia/src/test/java/fr/ird/observe/services/service/dto/EntityToDtoBuilderTest.java +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/builder/EntityToDtoBuilderTest.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.dto; +package fr.ird.observe.services.builder; import com.google.common.collect.ImmutableSet; import fr.ird.observe.entities.constants.GearType; @@ -8,7 +8,6 @@ import fr.ird.observe.entities.referentiel.OrganismImpl; import fr.ird.observe.entities.referentiel.Program; import fr.ird.observe.entities.referentiel.ProgramImpl; import fr.ird.observe.services.ObserveServiceTopia; -import fr.ird.observe.services.dto.EntityToDtoBuilder; import fr.ird.observe.services.dto.IdDto; import fr.ird.observe.services.dto.ReferenceDto; import fr.ird.observe.services.dto.ReferenceValueNotFoundException; -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.