This is an automated email from the git hooks/post-receive script. New commit to branch feature/refactor_reference in repository tutti. See http://git.codelutin.com/tutti.git commit 6122469796670997cf4ab59982315d471c79abd9 Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Nov 12 09:44:07 2015 +0100 Ajout d'un service pour récupérer des referecne set (à finir) --- .../v1/ReferenceSetServiceController.java | 28 ++++ .../services/service/ReferenceSetService.java | 24 +++ .../fr/ird/observe/services/dto/ReferenceDto.java | 9 +- .../dto/referential/ReferentialReferenceDto.java | 6 + .../EntityToReferentialReferenceDtoBuilder.java | 113 +++++++++++++- .../services/service/ReferenceSetServiceTopia.java | 162 +++++++++++++++++++++ 6 files changed, 339 insertions(+), 3 deletions(-) diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/ReferenceSetServiceController.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/ReferenceSetServiceController.java new file mode 100644 index 0000000..7dcc967 --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/ReferenceSetServiceController.java @@ -0,0 +1,28 @@ +package fr.ird.observe.application.web.controller.v1; + +import fr.ird.observe.services.service.ReferenceSetRequest; +import fr.ird.observe.services.service.ReferenceSetService; +import fr.ird.observe.services.service.ReferentialReferenceSetResult; + +/** + * Created on 11/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferenceSetServiceController extends ObserveAuthenticatedServiceControllerSupport<ReferenceSetService> implements ReferenceSetService { + + public ReferenceSetServiceController() { + super(ReferenceSetService.class); + } + + @Override + public ReferentialReferenceSetResult loadDataReferenceSets(ReferenceSetRequest request) { + return service.loadDataReferenceSets(request); + } + + @Override + public ReferentialReferenceSetResult loadReferentialReferenceSets(ReferenceSetRequest request) { + return service.loadReferentialReferenceSets(request); + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetService.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetService.java new file mode 100644 index 0000000..36f7d0e --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/ReferenceSetService.java @@ -0,0 +1,24 @@ +package fr.ird.observe.services.service; + +import fr.ird.observe.services.ObserveService; +import fr.ird.observe.services.dto.ReferenceSetDto; +import fr.ird.observe.services.spi.ReadDataPermission; +import fr.ird.observe.services.spi.ReadReferentialPermission; + +/** + * Pour gérer les {@link ReferenceSetDto}. + * + * Created on 11/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public interface ReferenceSetService extends ObserveService { + + @ReadDataPermission + ReferentialReferenceSetResult loadDataReferenceSets(ReferenceSetRequest request); + + @ReadReferentialPermission + ReferentialReferenceSetResult loadReferentialReferenceSets(ReferenceSetRequest request); + + +} diff --git a/observe-services-model/src/main/java/fr/ird/observe/services/dto/ReferenceDto.java b/observe-services-model/src/main/java/fr/ird/observe/services/dto/ReferenceDto.java index 607195d..7301ecf 100644 --- a/observe-services-model/src/main/java/fr/ird/observe/services/dto/ReferenceDto.java +++ b/observe-services-model/src/main/java/fr/ird/observe/services/dto/ReferenceDto.java @@ -66,7 +66,14 @@ public class ReferenceDto<D extends IdDto> extends AbstractReferenceDto { init(type, false, labelPropertyNames); } - public void init(Class<D> type, boolean convertToReference,Iterable<String> labelPropertyNames) { + public void init(Class<D> type, String[] labelPropertyNames, Class[] labelPropertyTypes, Serializable... labelPropertyValues) { + this.type = type; + this.labelPropertyNames = Arrays.asList(labelPropertyNames); + this.labelPropertyValues = labelPropertyValues; + this.labelPropertyTypes = labelPropertyTypes; + } + + public void init(Class<D> type, boolean convertToReference, Iterable<String> labelPropertyNames) { this.type = type; this.labelPropertyNames = Lists.newArrayList(labelPropertyNames); this.labelPropertyValues = new Serializable[this.labelPropertyNames.size()]; diff --git a/observe-services-model/src/main/java/fr/ird/observe/services/dto/referential/ReferentialReferenceDto.java b/observe-services-model/src/main/java/fr/ird/observe/services/dto/referential/ReferentialReferenceDto.java index 982bc41..b594ae4 100644 --- a/observe-services-model/src/main/java/fr/ird/observe/services/dto/referential/ReferentialReferenceDto.java +++ b/observe-services-model/src/main/java/fr/ird/observe/services/dto/referential/ReferentialReferenceDto.java @@ -53,6 +53,12 @@ public class ReferentialReferenceDto<D extends ReferentialDto> extends AbstractR return super.getType(); } + @Override + public void init(Class type, String[] labelPropertyNames, Class[] labelPropertyTypes, Serializable... labelPropertyValues) { + + super.init(type, labelPropertyNames, labelPropertyTypes, labelPropertyValues); + } + public void setPropertyValue(ReferentialLocale referentialLocale, String propertyName, Serializable propertyValue) { Preconditions.checkNotNull(referentialLocale, "referentialLocale parameter can't be null"); Preconditions.checkNotNull(propertyName, "propertyName parameter can't be null"); diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferentialReferenceDtoBuilder.java b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferentialReferenceDtoBuilder.java index 2283ad3..25148fe 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferentialReferenceDtoBuilder.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/builder/EntityToReferentialReferenceDtoBuilder.java @@ -24,6 +24,7 @@ package fr.ird.observe.services.builder; import com.google.common.base.Function; import com.google.common.base.Preconditions; +import fr.ird.observe.entities.referentiel.ReferenceEntities; import fr.ird.observe.entities.referentiel.ReferenceEntity; import fr.ird.observe.services.ObserveServiceTopia; import fr.ird.observe.services.dto.ObserveDtoBinders; @@ -32,12 +33,16 @@ import fr.ird.observe.services.dto.constants.ReferentialLocale; 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 fr.ird.observe.services.service.ReferenceSetRequestKeyDefinition; import org.hibernate.Hibernate; import org.hibernate.proxy.HibernateProxy; import org.nuiton.topia.persistence.TopiaEntity; import org.nuiton.util.beans.Binder; +import org.nuiton.util.beans.BinderFactory; import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; import java.util.Map; import java.util.Set; @@ -50,6 +55,110 @@ import java.util.Set; */ public class EntityToReferentialReferenceDtoBuilder<E extends ReferenceEntity, D extends ReferentialDto> { + private Class<D> type; + + private Binder<E, E> binder; + + private String[] propertyNames; + + private String[] entityPropertyNames; + + private Class<?>[] propertyTypes; + + private int referentialLocaleOrdinal; + + public static <E extends ReferenceEntity, D extends ReferentialDto> EntityToReferentialReferenceDtoBuilder<E, D> of(ReferentialLocale referentialLocale, ReferenceSetRequestKeyDefinition<D> requestKeyDefinition, Class<E> entityType) { + + EntityToReferentialReferenceDtoBuilder<E, D> referenceDtoBuilder = new EntityToReferentialReferenceDtoBuilder<>(); + + referenceDtoBuilder.type = requestKeyDefinition.getType(); + referenceDtoBuilder.referentialLocaleOrdinal = referentialLocale.ordinal(); + referenceDtoBuilder.binder = BinderFactory.newBinder(entityType); + referenceDtoBuilder.propertyNames = requestKeyDefinition.getPropertyNames(); + + List<String> entityPropertyNames = new ArrayList<>(); + + for (String propertyName : referenceDtoBuilder.propertyNames) { + + if (ReferentialReferenceDto.PROPERTY_LABEL.contains(propertyName)) { + propertyName = referentialLocale.getLibelle(); + } + entityPropertyNames.add(propertyName); + } + referenceDtoBuilder.entityPropertyNames = entityPropertyNames.toArray(new String[entityPropertyNames.size()]); + referenceDtoBuilder.propertyTypes = requestKeyDefinition.getPropertyTypes(); + + return referenceDtoBuilder; + + } + + public ReferentialReferenceDto<D> build(E entity) { + + Preconditions.checkNotNull(entity, "'entity' can't be null"); + + // on extrait l' entité du proxy hibernate + if (entity instanceof HibernateProxy) { + Hibernate.initialize(entity); + entity = (E) ((HibernateProxy) entity).getHibernateLazyInitializer().getImplementation(); + } + + Map<String, Object> entityProperties = binder.obtainProperties(entity, true, entityPropertyNames); + + Serializable[] propertyValues = new Serializable[propertyTypes.length]; + for (int i = 0; i < propertyTypes.length; i++) { + String propertyName = propertyNames[i]; + + Serializable propertyValue = (Serializable) entityProperties.get(propertyName); + if (propertyValue != null) { + + Class<?> propertyType = propertyTypes[i]; + + if (propertyValue instanceof ReferenceEntity) { + + ReferenceEntity referentialEntity = (ReferenceEntity) propertyValue; + if (String.class.equals(propertyType)) { + + // Conversion + + propertyValue = ReferenceEntities.toString(referentialLocaleOrdinal, referentialEntity); + + } else { + + // on veut récupérer une référence + //TODO + + } + + } else { + + propertyValue = transform(propertyValue); + + } + + Preconditions.checkState(propertyType.isAssignableFrom(propertyValue.getClass()), "Le type de la propriété " + propertyName + " devrait être du type " + propertyType.getName() + " mais vaut: " + propertyValue); + + } + + propertyValues[i] = propertyValue; + + } + + ReferentialReferenceDto<D> result = new ReferentialReferenceDto<>(); + result.init(type, propertyNames, propertyTypes, propertyValues); + + result.setId(entity.getTopiaId()); + result.setEnabled(entity.isEnabled()); + result.setNeedComment(entity.isNeedComment()); + + result.setVersion(entity.getTopiaVersion()); + result.setCreateDate(entity.getTopiaCreateDate()); + result.setLastUpdate(entity.getLastUpdate()); + result.setEnabled(fr.ird.observe.entities.constants.ReferenceStatus.enabled == entity.getStatus()); + + return result; + + } + public static <E extends ReferenceEntity, D extends ReferentialDto> ReferentialReferenceDto<D> build(Class<D> dtoType, ReferentialLocale referentialLocale, E entity) { Preconditions.checkNotNull(dtoType, "'dtoType' can't be null"); @@ -110,12 +219,12 @@ public class EntityToReferentialReferenceDtoBuilder<E extends ReferenceEntity, D } - protected static Object transform(Object propertyValue) { + protected static Serializable transform(Object propertyValue) { Function function = ObserveDtosInitializer.getEntityToDtoFunction(propertyValue); if (function != null) { propertyValue = function.apply(propertyValue); } - return propertyValue; + return (Serializable) propertyValue; } diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/ReferenceSetServiceTopia.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/ReferenceSetServiceTopia.java new file mode 100644 index 0000000..3178da1 --- /dev/null +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/ReferenceSetServiceTopia.java @@ -0,0 +1,162 @@ +package fr.ird.observe.services.service; + +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableMap; +import fr.ird.observe.entities.referentiel.ReferenceEntity; +import fr.ird.observe.services.ObserveServiceTopia; +import fr.ird.observe.services.builder.EntityToReferentialReferenceDtoBuilder; +import fr.ird.observe.services.dto.IdDto; +import fr.ird.observe.services.dto.ReferenceSetDto; +import fr.ird.observe.services.dto.ReferenceSetDtos; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReferenceDto; +import fr.ird.observe.services.entity.EntitiesExtractor; +import org.nuiton.topia.persistence.TopiaEntity; + +import java.util.Collections; +import java.util.Date; +import java.util.LinkedHashSet; +import java.util.Map; + +/** + * Created on 11/11/15. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferenceSetServiceTopia extends ObserveServiceTopia implements ReferenceSetService { + + @Override + public ReferentialReferenceSetResult loadDataReferenceSets(ReferenceSetRequest request) { + String requestName = request.getRequestName(); + ReferenceSetRequestDefinitions requestDefinitions = ReferenceSetRequestDefinitions.valueOf(requestName); + if (requestDefinitions == null) { + throw new IllegalArgumentException("No request with name " + requestName + "registred"); + } + + ReferenceSetRequestDefinition requestDefinition = requestDefinitions.getDefinition(); + + ReferentialReferenceSetResult.Builder resultBuilder = new ReferentialReferenceSetResult.Builder(request); + + for (ReferenceSetRequestKeyDefinition requestKeyDefinition : requestDefinition.getKeys()) { + + boolean referential = requestKeyDefinition.isReferential(); + Preconditions.checkArgument(!referential, "Can't obtain referenceSet of referential here, but try with " + requestKeyDefinition); + + String name = requestKeyDefinition.getName(); + + ReferenceSetDto referenceSet = loadDataReferenceSet(requestKeyDefinition); + resultBuilder.addKey(name, referenceSet); + + } + + return resultBuilder.build(); + + } + + @Override + public ReferentialReferenceSetResult loadReferentialReferenceSets(ReferenceSetRequest request) { + + String requestName = request.getRequestName(); + ReferenceSetRequestDefinitions requestDefinitions = ReferenceSetRequestDefinitions.valueOf(requestName); + if (requestDefinitions == null) { + throw new IllegalArgumentException("No request with name " + requestName + "registred"); + } + + ReferenceSetRequestDefinition requestDefinition = requestDefinitions.getDefinition(); + + ReferentialReferenceSetResult.Builder resultBuilder = new ReferentialReferenceSetResult.Builder(request); + ImmutableMap<String, Date> lastUpdateDates = request.getLastUpdateDates(); + + for (ReferenceSetRequestKeyDefinition requestKeyDefinition : requestDefinition.getKeys()) { + + boolean referential = requestKeyDefinition.isReferential(); + Preconditions.checkArgument(referential, "Can't obtain referenceSet of data here, but try with " + requestKeyDefinition); + + String name = requestKeyDefinition.getName(); + Date lastUpdateDate = lastUpdateDates.get(name); + + ReferenceSetDto referenceSet = loadReferentialReferenceSet(requestKeyDefinition, lastUpdateDate); + resultBuilder.addKey(name, referenceSet); + } + + return resultBuilder.build(); + + } + + protected <D extends IdDto> ReferenceSetDto<D> loadDataReferenceSet(ReferenceSetRequestKeyDefinition<D> requestKeyDefinition) { + + Class<D> type = requestKeyDefinition.getType(); + Class<TopiaEntity> entityType = getEntityType(type); + String name = requestKeyDefinition.getName(); + + Iterable<TopiaEntity> entitiesExtractor = getEntities(requestKeyDefinition, Collections.<String, Object>emptyMap()); + + //TODO + ReferenceSetDto<D> referenceSet = null; + + return referenceSet; + } + + protected <D extends ReferentialDto, E extends ReferenceEntity> ReferenceSetDto<D> loadReferentialReferenceSet(ReferenceSetRequestKeyDefinition<D> requestKeyDefinition, Date lastUpdateDate) { + + Class<D> type = requestKeyDefinition.getType(); + Class<E> entityType = getEntityType(type); + String name = requestKeyDefinition.getName(); + + Optional<Date> lastUpdateOptional = getLastUpdate(entityType); + + ReferenceSetDto<D> referenceSet; + if (lastUpdateOptional.isPresent() && lastUpdateOptional.get().after(lastUpdateDate)) { + + EntityToReferentialReferenceDtoBuilder<E, D> referenceBuilder = EntityToReferentialReferenceDtoBuilder.of(serviceContext.getReferentialLocale(), requestKeyDefinition, entityType); + + Iterable<E> entities = getEntities(requestKeyDefinition, Collections.<String, Object>emptyMap()); + + LinkedHashSet<ReferentialReferenceDto<D>> labels = new LinkedHashSet<>(); + for (E entity : entities) { + + ReferentialReferenceDto<D> dto = referenceBuilder.build(entity); + labels.add(dto); + + } + referenceSet = ReferenceSetDtos.newReferenceSetDto(type, name, labels, lastUpdateOptional.get()); + + + } else { + + referenceSet = null; + + } + + return referenceSet; + } + + + protected <E extends TopiaEntity, D extends IdDto> Iterable<E> getEntities(ReferenceSetRequestKeyDefinition<D> requestKeyDefinition, + Map<String, Object> dataContext) { + + + Class<D> type = requestKeyDefinition.getType(); + Class<E> entityType = getEntityType(type); + Class<TopiaEntity> entityParentType = getEntityType(requestKeyDefinition.getParentType()); + String name = requestKeyDefinition.getName(); + + Iterable<E> entities; + + EntitiesExtractor<E> entitiesExtractor = serviceContext.getEntitiesSetFactory().newEntitiesSet(entityParentType, + entityType, + name); + + if (entitiesExtractor == null) { + + entities = loadEntities(entityType); + + } else { + entities = entitiesExtractor.getEntities(serviceContext.getTopiaPersistenceContext(), dataContext); + } + + return entities; + } + +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.