This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository tutti. See https://gitlab.nuiton.org/codelutin/tutti.git commit f89492829439b9a5a6d1e6d79ebaf1c8a2096f53 Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Jun 28 18:31:08 2016 +0200 Introduction du moteur de synchronisation (reste plus qu'à générer le code sql à partir de la requète produite (See #7739) --- .../actions/synchro/RemoteReferentialDiff.java | 39 +++-- ...UnidirectionalReferentialSynchronizeEngine.java | 177 +++++++++++++++++++++ ...ectionalReferentialSynchronizeLocalService.java | 10 -- ...ctionalReferentialSynchronizeRemoteService.java | 11 ++ ...nidirectionalReferentialSynchronizeRequest.java | 106 ++++++++++++ ...nalReferentialSynchronizeLocalServiceTopia.java | 55 ++++--- ...alReferentialSynchronizeRemoteServiceTopia.java | 35 ++++ 7 files changed, 388 insertions(+), 45 deletions(-) diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/RemoteReferentialDiff.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/RemoteReferentialDiff.java index 2aa4b8d..83787d2 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/RemoteReferentialDiff.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/RemoteReferentialDiff.java @@ -7,6 +7,8 @@ import fr.ird.observe.services.dto.referential.ReferentialReference; import java.io.Serializable; import java.util.Collection; +import java.util.LinkedHashSet; +import java.util.Set; /** * Contient le différentiel de référentiels calculé sur la source centrale à partir des états de la source à synchroniser. @@ -20,6 +22,7 @@ public class RemoteReferentialDiff implements Serializable { private static final long serialVersionUID = 1L; + private final Set<String> referentialNames; /** * Les référentiels à ajouter (indexé par nom de référentiel). */ @@ -38,41 +41,57 @@ public class RemoteReferentialDiff implements Serializable { private final Multimap<String, ReferentialReference> referentialsToFix; public RemoteReferentialDiff() { + referentialNames = new LinkedHashSet<>(); referentialsToAdd = ArrayListMultimap.create(); referentialsToUpdate = ArrayListMultimap.create(); referentialsToRemove = ArrayListMultimap.create(); referentialsToFix = ArrayListMultimap.create(); } - public Collection<ReferentialDto> getReferentialsToAdd(String referentialName) { - return referentialsToAdd.get(referentialName); + public boolean isReferentialUsed(String referentialName) { + return referentialsToAdd.containsKey(referentialName) + || referentialsToUpdate.containsKey(referentialName) + || referentialsToRemove.containsKey(referentialName) + || referentialsToFix.containsKey(referentialName); + + } + public <R extends ReferentialDto> Collection<R> getReferentialsToAdd(String referentialName) { + return (Collection) referentialsToAdd.get(referentialName); + } + + public <R extends ReferentialDto> Collection<R> getReferentialsToUpdate(String referentialName) { + return (Collection) referentialsToUpdate.get(referentialName); } - public Collection<ReferentialDto> getReferentialsToUpdate(String referentialName) { - return referentialsToUpdate.get(referentialName); + public <R extends ReferentialDto> Collection<ReferentialReference<R>> getReferentialsToRemove(String referentialName) { + return (Collection)referentialsToRemove.get(referentialName); } - public Collection<ReferentialReference> getReferentialsToRemove(String referentialName) { - return referentialsToRemove.get(referentialName); + public <R extends ReferentialDto> Collection<ReferentialReference<R>> getReferentialsToFix(String referentialName) { + return (Collection)referentialsToFix.get(referentialName); } - public Collection<ReferentialReference> getReferentialsToFix(String referentialName) { - return referentialsToFix.get(referentialName); + public Set<String> getReferentialNames() { + return referentialNames; } void addReferentialToAdd(String referentialName, ReferentialDto referentialDto) { + referentialNames.add(referentialName); referentialsToAdd.put(referentialName, referentialDto); } void addReferentialToUpdate(String referentialName, ReferentialDto referentialDto) { + referentialNames.add(referentialName); referentialsToUpdate.put(referentialName, referentialDto); } void addReferentialToDelete(String referentialName, ReferentialReference referentialReference) { + referentialNames.add(referentialName); referentialsToRemove.put(referentialName, referentialReference); } - void addReferentialToFix(String entityName, ReferentialReference referentialReference) { - referentialsToFix.put(entityName, referentialReference); + void addReferentialToFix(String referentialName, ReferentialReference referentialReference) { + referentialNames.add(referentialName); + referentialsToFix.put(referentialName, referentialReference); } } diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeEngine.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeEngine.java new file mode 100644 index 0000000..9df5e43 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeEngine.java @@ -0,0 +1,177 @@ +package fr.ird.observe.services.service.actions.synchro; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.services.dto.referential.ReferentialReferenceSet; +import org.apache.commons.collections.CollectionUtils; + +import java.util.Collection; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; + +/** + * Created on 28/06/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class UnidirectionalReferentialSynchronizeEngine { + + private final UnidirectionalReferentialSynchronizeLocalService localService; + private final UnidirectionalReferentialSynchronizeRemoteService remoteService; + + public UnidirectionalReferentialSynchronizeEngine(UnidirectionalReferentialSynchronizeLocalService localService, + UnidirectionalReferentialSynchronizeRemoteService remoteService) { + this.localService = localService; + this.remoteService = remoteService; + } + + public void run(Callback callback) { + + LocalReferentialStates localReferentialStates = localService.getLocalSourceReferentialStates(); + RemoteReferentialDiff remoteReferentialDiff = remoteService.getReferentialDifferential(localReferentialStates); + + for (String referentialName : remoteReferentialDiff.getReferentialNames()) { + + UnidirectionalReferentialSynchronizeRequest referentialSynchronizeRequest = buildReferentialSynchronizeRequest(callback, referentialName, remoteReferentialDiff); + + } + + } + + private <R extends ReferentialDto> UnidirectionalReferentialSynchronizeRequest buildReferentialSynchronizeRequest(Callback callback, String referentialName, RemoteReferentialDiff remoteReferentialDiff) { + + UnidirectionalReferentialSynchronizeRequest.Builder builder = UnidirectionalReferentialSynchronizeRequest.builder(referentialName); + + Collection<R> referentialsToAdd = remoteReferentialDiff.getReferentialsToAdd(referentialName); + if (CollectionUtils.isNotEmpty(referentialsToAdd)) { + referentialsToAdd.forEach(builder::entityToAdd); + } + + Collection<R> referentialsToUpdate = remoteReferentialDiff.getReferentialsToUpdate(referentialName); + if (CollectionUtils.isNotEmpty(referentialsToUpdate)) { + referentialsToUpdate.forEach(builder::entityToUpdate); + } + + Collection<ReferentialReference<R>> referentialsToRemove = remoteReferentialDiff.getReferentialsToRemove(referentialName); + Collection<ReferentialReference<R>> blockingReferentialsToRemove = null; + if (CollectionUtils.isNotEmpty(referentialsToRemove)) { + + Set<String> idsToRemove = referentialsToRemove.stream() + .map(ReferentialReference::getId) + .collect(Collectors.toCollection(LinkedHashSet::new)); + + Set<String> blockingIdsToRemove = localService.filterIdsUsedInLocalSource(referentialName, idsToRemove); + + + blockingReferentialsToRemove = referentialsToRemove + .stream() + .filter(referentialReference -> blockingIdsToRemove.contains(referentialReference.getId())) + .collect(Collectors.toSet()); + + idsToRemove.removeAll(blockingIdsToRemove); + idsToRemove.forEach(builder::entityToRemove); + + } + + Collection<ReferentialReference<R>> referentialsToReplace = remoteReferentialDiff.getReferentialsToFix(referentialName); + Collection<ReferentialReference<R>> blockingReferentialsToReplace = null; + + if (CollectionUtils.isNotEmpty(referentialsToReplace)) { + + Set<String> idsToReplace = referentialsToReplace.stream() + .map(ReferentialReference::getId) + .collect(Collectors.toCollection(LinkedHashSet::new)); + + Set<String> blockingIdsToReplace = localService.filterIdsUsedInLocalSource(referentialName, idsToReplace); + + blockingReferentialsToReplace = referentialsToRemove + .stream() + .filter(referentialReference -> blockingIdsToReplace.contains(referentialReference.getId())) + .collect(Collectors.toSet()); + + } + + boolean needCallbackForRemove = CollectionUtils.isNotEmpty(blockingReferentialsToRemove); + boolean needCallbackToReplace = CollectionUtils.isNotEmpty(blockingReferentialsToReplace); + boolean needCallback = needCallbackForRemove || needCallbackToReplace; + if (needCallback) { + + // calcul de l'univers de référentiels disponibles pour les remplacements + + ReferentialReferenceSet<R> localSourceEnabledReferenceSet = remoteService.getEnabledReferentialReferenceSet(referentialName); + Set<ReferentialReference<R>> availableReferentials = localSourceEnabledReferenceSet.getReferences(); + + if (needCallbackForRemove) { + + CallbackRequest callbackRequest = CallbackRequest.of(referentialName, blockingReferentialsToRemove, availableReferentials); + Map<String, String> referentialsToRemoveIds = callback.askUserToReplaceDisabledReferentials(callbackRequest); + for (Map.Entry<String, String> entry : referentialsToRemoveIds.entrySet()) { + builder.entityToReplace(entry.getKey(), entry.getValue()); + builder.entityToRemove(entry.getKey()); + } + + } + + if (needCallbackToReplace) { + + CallbackRequest callbackRequest = CallbackRequest.of(referentialName, referentialsToReplace, availableReferentials); + Map<String, String> referentialsToReplaceIds = callback.askUserToReplaceDisabledReferentials(callbackRequest); + for (Map.Entry<String, String> entry : referentialsToReplaceIds.entrySet()) { + builder.entityToReplace(entry.getKey(), entry.getValue()); + } + + } + + } + + UnidirectionalReferentialSynchronizeRequest referentialSynchronizeRequest = builder.build(); + return referentialSynchronizeRequest; + + } + + public interface Callback { + + Map<String, String> askUserToReplaceRemovedReferentials(CallbackRequest request); + + Map<String, String> askUserToReplaceDisabledReferentials(CallbackRequest request); + + } + + public static class CallbackRequest<R extends ReferentialDto> { + + public static <R extends ReferentialDto> CallbackRequest<R> of(String referentialName, + Collection<ReferentialReference<R>> referentialsToReplace, + Collection<ReferentialReference<R>> availableReferentials) { + return new CallbackRequest<>(referentialName, referentialsToReplace, availableReferentials); + } + + private final String referentialName; + private final Collection<ReferentialReference<R>> referentialsToReplace; + private final Collection<ReferentialReference<R>> availableReferentials; + + public String getReferentialName() { + return referentialName; + } + + public Collection<ReferentialReference<R>> getReferentialsToReplace() { + return referentialsToReplace; + } + + public Collection<ReferentialReference<R>> getAvailableReferentials() { + return availableReferentials; + } + + private CallbackRequest(String referentialName, + Collection<ReferentialReference<R>> referentialsToReplace, + Collection<ReferentialReference<R>> availableReferentials) { + this.referentialName = referentialName; + this.referentialsToReplace = referentialsToReplace; + this.availableReferentials = availableReferentials; + } + + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeLocalService.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeLocalService.java index 3c3f570..a1b4b22 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeLocalService.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeLocalService.java @@ -1,6 +1,5 @@ package fr.ird.observe.services.service.actions.synchro; -import fr.ird.observe.services.dto.referential.ReferentialReferenceSet; import fr.ird.observe.services.spi.ReadReferentialPermission; import java.util.Collection; @@ -35,13 +34,4 @@ public interface UnidirectionalReferentialSynchronizeLocalService { @ReadReferentialPermission Set<String> filterIdsUsedInLocalSource(String referentialName, Collection<String> ids); - /** - * Pour récupérer un ensemble de référentiels non désactivés pour un type donné (et ceci afin de remplacer - * un référentiel de même type supprimé ou désactivé). - * - * @param referentialName le nom du référentiel - * @return l'ensemble des référentiels non désactivés du type demandé - */ - @ReadReferentialPermission - ReferentialReferenceSet getLocalSourceEnabledReferenceSet(String referentialName); } diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRemoteService.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRemoteService.java index 66983a3..44d15a1 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRemoteService.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRemoteService.java @@ -1,5 +1,7 @@ package fr.ird.observe.services.service.actions.synchro; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReferenceSet; import fr.ird.observe.services.spi.ReadReferentialPermission; /** @@ -21,4 +23,13 @@ public interface UnidirectionalReferentialSynchronizeRemoteService { @ReadReferentialPermission RemoteReferentialDiff getReferentialDifferential(LocalReferentialStates localReferentialStates); + /** + * Pour récupérer un ensemble de référentiels non désactivés pour un type donné (et ceci afin de remplacer + * un référentiel de même type supprimé ou désactivé). + * + * @param referentialName le nom du référentiel + * @return l'ensemble des référentiels non désactivés du type demandé + */ + @ReadReferentialPermission + <R extends ReferentialDto> ReferentialReferenceSet<R> getEnabledReferentialReferenceSet(String referentialName); } diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRequest.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRequest.java new file mode 100644 index 0000000..4cbe9ed --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRequest.java @@ -0,0 +1,106 @@ +package fr.ird.observe.services.service.actions.synchro; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.services.dto.referential.ReferentialDto; + +/** + * Pour un référentiel de type donné, l'ensemble des opérations à effectuer. + * + * À partir de cette demande, on génèrera ensuite le code sql correspondant. + * + * Created on 28/06/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class UnidirectionalReferentialSynchronizeRequest { + + public static Builder builder(String referentialName) { + return new Builder(referentialName); + } + + private final String referentialName; + private final ImmutableSet<ReferentialDto> referentialToAdd; + private final ImmutableSet<ReferentialDto> referentialToUpdate; + private final ImmutableSet<String> referentialToRemove; + private final ImmutableMap<String, String> referentialToReplace; + + public String getReferentialName() { + return referentialName; + } + + public ImmutableSet<ReferentialDto> getReferentialToAdd() { + return referentialToAdd; + } + + public ImmutableSet<ReferentialDto> getReferentialToUpdate() { + return referentialToUpdate; + } + + public ImmutableSet<String> getReferentialToRemove() { + return referentialToRemove; + } + + public ImmutableMap<String, String> getReferentialToReplace() { + return referentialToReplace; + } + + private UnidirectionalReferentialSynchronizeRequest(String referentialName, + ImmutableSet<ReferentialDto> referentialToAdd, + ImmutableSet<ReferentialDto> referentialToUpdate, + ImmutableSet<String> referentialToRemove, + ImmutableMap<String, String> toReplace) { + this.referentialName = referentialName; + this.referentialToAdd = referentialToAdd; + this.referentialToUpdate = referentialToUpdate; + this.referentialToRemove = referentialToRemove; + this.referentialToReplace = toReplace; + } + + public static class Builder { + + private final String referentialName; + private final ImmutableSet.Builder<ReferentialDto> toAddBuilder = ImmutableSet.builder(); + private final ImmutableSet.Builder<ReferentialDto> toUpdateBuilder = ImmutableSet.builder(); + private final ImmutableSet.Builder<String> toRemoveBuilder = ImmutableSet.builder(); + private final ImmutableMap.Builder<String, String> toReplaceBuilder = ImmutableMap.builder(); + + public Builder entityToAdd(ReferentialDto referentialDto) { + toAddBuilder.add(referentialDto); + return this; + } + + public Builder entityToUpdate(ReferentialDto referentialDto) { + toUpdateBuilder.add(referentialDto); + return this; + } + + public Builder entityToRemove(String id) { + toRemoveBuilder.add(id); + return this; + } + + public Builder entityToReplace(String sourceId, String targetId) { + toReplaceBuilder.put(sourceId, targetId); + return this; + } + + public UnidirectionalReferentialSynchronizeRequest build() { + + return new UnidirectionalReferentialSynchronizeRequest( + referentialName, + toAddBuilder.build(), + toUpdateBuilder.build(), + toRemoveBuilder.build(), + toReplaceBuilder.build() + ); + + } + + private Builder(String referentialName) { + this.referentialName = referentialName; + } + + } +} diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeLocalServiceTopia.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeLocalServiceTopia.java index 69c87f7..e9c2245 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeLocalServiceTopia.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeLocalServiceTopia.java @@ -1,20 +1,20 @@ package fr.ird.observe.services.service.actions.synchro; import fr.ird.observe.ObserveEntityEnum; -import fr.ird.observe.ObserveTopiaPersistenceContext; import fr.ird.observe.entities.Entities; -import fr.ird.observe.entities.constants.ReferenceStatusPersist; import fr.ird.observe.entities.referentiel.ObserveReferentialEntity; import fr.ird.observe.services.ObserveServiceTopia; -import fr.ird.observe.services.binder.BinderEngine; import fr.ird.observe.services.dto.referential.ReferentialDto; -import fr.ird.observe.services.dto.referential.ReferentialReferenceSet; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuiton.topia.persistence.TopiaDao; import org.nuiton.topia.persistence.TopiaEntity; +import org.nuiton.topia.persistence.metadata.TopiaMetadataEntity; +import org.nuiton.util.beans.Binder; +import org.nuiton.util.beans.BinderFactory; import java.util.Collection; +import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; @@ -67,19 +67,35 @@ public class UnidirectionalReferentialSynchronizeLocalServiceTopia extends Obser } - @Override - public ReferentialReferenceSet getLocalSourceEnabledReferenceSet(String referentialName) { - - if (log.isTraceEnabled()) { - log.trace("getLocalSourceEnabledReferenceSet(" + referentialName + ")"); + private <E extends ObserveReferentialEntity, R extends ReferentialDto> void generateInsertSqlStatements0(StringBuilder builder, + Class<E> entityType, + Class<R> dtoType, + TopiaMetadataEntity metadataEntity, + Collection<R> referentialsToAdd) { + + Set<String> columnNames = new LinkedHashSet<>(); + columnNames.add(TopiaEntity.PROPERTY_TOPIA_ID); + columnNames.add(TopiaEntity.PROPERTY_TOPIA_VERSION); + columnNames.add(TopiaEntity.PROPERTY_TOPIA_CREATE_DATE); + + Set<String> propertyNamesSet = metadataEntity.getProperties().keySet(); + String[] propertyNames = propertyNamesSet.toArray(new String[propertyNamesSet.size()]); + for (String propertyName : propertyNames) { + columnNames.add(metadataEntity.getDbColumnName(propertyName)); } - ObserveEntityEnum entityEnum = ObserveEntityEnum.valueOf(referentialName); - Class entityType = entityEnum.getContract(); - Class dtoType = BinderEngine.get().getReferentialDtoType(entityType); - ReferentialReferenceSet result = getLocalSourceEnabledReferenceSet0(entityType, dtoType); - return result; + Binder<R, R> binder = BinderFactory.newBinder(dtoType); + for (R referentialToAdd : referentialsToAdd) { + + Map<String,Object> properties = new LinkedHashMap<>(); + properties.put(TopiaEntity.PROPERTY_TOPIA_ID, referentialToAdd.getId()); + properties.put(TopiaEntity.PROPERTY_TOPIA_VERSION, referentialToAdd.getVersion()); + properties.put(TopiaEntity.PROPERTY_TOPIA_CREATE_DATE, referentialToAdd.getCreateDate()); + + Map<String, Object> obtainProperties = binder.obtainProperties(referentialToAdd, true, propertyNames); + properties.putAll(obtainProperties); + } } private <E extends ObserveReferentialEntity> void getLocalSourceReferentialVersions0(String entityName, Class<E> entityType, LocalReferentialStates localReferentialStates) { @@ -104,15 +120,4 @@ public class UnidirectionalReferentialSynchronizeLocalServiceTopia extends Obser } - private <E extends ObserveReferentialEntity, R extends ReferentialDto> ReferentialReferenceSet<R> getLocalSourceEnabledReferenceSet0(Class<E> entityType, Class<R> dtoType) { - - ObserveTopiaPersistenceContext persistenceContext = getTopiaPersistenceContext(); - TopiaDao<E> dao = persistenceContext.getDao(entityType); - List<E> entities = dao.forEquals(ObserveReferentialEntity.PROPERTY_STATUS, ReferenceStatusPersist.enabled).findAll(); - ReferentialReferenceSet<R> result = toReferentialReferenceSet(dtoType, entities, null); - return result; - - } - - } diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRemoteServiceTopia.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRemoteServiceTopia.java index 3d9cba1..9f65167 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRemoteServiceTopia.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRemoteServiceTopia.java @@ -1,13 +1,18 @@ package fr.ird.observe.services.service.actions.synchro; import fr.ird.observe.ObserveEntityEnum; +import fr.ird.observe.ObserveTopiaPersistenceContext; import fr.ird.observe.entities.Entities; +import fr.ird.observe.entities.constants.ReferenceStatusPersist; import fr.ird.observe.entities.referentiel.ObserveReferentialEntity; import fr.ird.observe.services.ObserveServiceTopia; import fr.ird.observe.services.binder.BinderEngine; import fr.ird.observe.services.dto.constants.ReferentialLocale; import fr.ird.observe.services.dto.referential.ReferentialDto; import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.services.dto.referential.ReferentialReferenceSet; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; import org.nuiton.topia.persistence.TopiaDao; import java.util.Collection; @@ -24,6 +29,9 @@ import java.util.Set; */ public class UnidirectionalReferentialSynchronizeRemoteServiceTopia extends ObserveServiceTopia implements UnidirectionalReferentialSynchronizeRemoteService { + /** Logger. */ + private static final Log log = LogFactory.getLog(UnidirectionalReferentialSynchronizeRemoteServiceTopia.class); + @Override public RemoteReferentialDiff getReferentialDifferential(LocalReferentialStates localReferentialStates) { @@ -36,6 +44,22 @@ public class UnidirectionalReferentialSynchronizeRemoteServiceTopia extends Obse } + @Override + public <R extends ReferentialDto> ReferentialReferenceSet<R> getEnabledReferentialReferenceSet(String referentialName) { + + if (log.isTraceEnabled()) { + log.trace("getEnabledReferentialReferenceSet(" + referentialName + ")"); + } + + ObserveEntityEnum entityEnum = ObserveEntityEnum.valueOf(referentialName); + Class entityType = entityEnum.getContract(); + Class dtoType = BinderEngine.get().getReferentialDtoType(entityType); + ReferentialReferenceSet<R> result = getLocalSourceEnabledReferenceSet0(entityType, dtoType); + return result; + + } + + private <E extends ObserveReferentialEntity> void getReferentialDifferential0(String entityName, Class<E> entityType, LocalReferentialStates localReferentialStates, RemoteReferentialDiff result) { ReferentialLocale referentialLocale = getReferentialLocale(); @@ -89,4 +113,15 @@ public class UnidirectionalReferentialSynchronizeRemoteServiceTopia extends Obse } + private <E extends ObserveReferentialEntity, R extends ReferentialDto> ReferentialReferenceSet<R> getLocalSourceEnabledReferenceSet0(Class<E> entityType, Class<R> dtoType) { + + ObserveTopiaPersistenceContext persistenceContext = getTopiaPersistenceContext(); + TopiaDao<E> dao = persistenceContext.getDao(entityType); + List<E> entities = dao.forEquals(ObserveReferentialEntity.PROPERTY_STATUS, ReferenceStatusPersist.enabled).findAll(); + ReferentialReferenceSet<R> result = toReferentialReferenceSet(dtoType, entities, null); + return result; + + } + + } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.