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 703305bef1ac09a2bf7550fe090d903992c0e274 Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Jun 28 12:27:24 2016 +0200 Ajout de la configuration pour le plugin processor --- pom.xml | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/pom.xml b/pom.xml index 6780626..c4e1734 100644 --- a/pom.xml +++ b/pom.xml @@ -119,6 +119,7 @@ <signatureVersion>1.0</signatureVersion> <eugenePluginVersion>3.0-alpha-5</eugenePluginVersion> + <processorPluginVersion>1.3</processorPluginVersion> <topiaVersion>3.1.2-SNAPSHOT</topiaVersion> <jaxxVersion>2.29</jaxxVersion> @@ -696,6 +697,28 @@ <doUpdate>false</doUpdate> </configuration> </plugin> + + <plugin> + <groupId>org.nuiton.processor</groupId> + <artifactId>processor-maven-plugin</artifactId> + <version>${processorPluginVersion}</version> + <executions> + <execution> + <phase>generate-sources</phase> + <goals> + <goal>process</goal> + </goals> + </execution> + </executions> + <configuration> + <includes>**/*.java</includes> + <filters> + org.nuiton.processor.filters.GeneratorTemplatesFilter, + org.nuiton.processor.filters.ActiveLogsCodeFilter + </filters> + </configuration> + </plugin> + </plugins> <pluginManagement> -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 e29483113f2a6fca5cbbead039996db280dbf451 Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Jun 28 18:29:32 2016 +0200 Mettre à plat la notion d'héritage pour tout avoir de disponible dans le méta-modèle allégé --- .../persistence/metadata/TopiaMetadataEntity.java | 14 ++++++- .../persistence/metadata/TopiaMetadataModel.java | 4 +- .../templates/TopiaMetadataModelGenerator.java | 43 +++++++++++++++++++++- 3 files changed, 56 insertions(+), 5 deletions(-) diff --git a/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataEntity.java b/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataEntity.java index 02fdd0d..8c16f2c 100644 --- a/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataEntity.java +++ b/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataEntity.java @@ -41,6 +41,10 @@ public class TopiaMetadataEntity { private static final Log log = LogFactory.getLog(TopiaMetadataEntity.class); /** + * L'entité parent (optionnelle). + */ + protected final String parent; + /** * Le nom simple de l'entité (correspond au nom de l'énumération qui caractérise cette entité). */ protected final String type; @@ -80,7 +84,8 @@ public class TopiaMetadataEntity { */ protected final Map<String, String> dbColumnsName = new LinkedHashMap<>(); - public TopiaMetadataEntity(String type, String dbSchemaName, String dbTableName) { + public TopiaMetadataEntity(String parent, String type, String dbSchemaName, String dbTableName) { + this.parent=parent; this.type = type; this.dbSchemaName = dbSchemaName; this.dbTableName = dbTableName; @@ -111,6 +116,11 @@ public class TopiaMetadataEntity { .toString(); } + public boolean withParent() { return parent!=null;} + public String getParent() { + return parent; + } + public String getDbSchemaName() { return dbSchemaName; } @@ -182,7 +192,7 @@ public class TopiaMetadataEntity { } public TopiaMetadataEntity copy() { - TopiaMetadataEntity copy = new TopiaMetadataEntity(type, dbSchemaName, dbTableName); + TopiaMetadataEntity copy = new TopiaMetadataEntity(parent, type, dbSchemaName, dbTableName); copy.associations.putAll(associations); copy.reversedAssociations.putAll(reversedAssociations); copy.nmAssociations.putAll(nmAssociations); diff --git a/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataModel.java b/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataModel.java index 5aef1d1..d4de2b1 100644 --- a/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataModel.java +++ b/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataModel.java @@ -63,9 +63,9 @@ public class TopiaMetadataModel { visitor.visitModelEnd(this); } - public TopiaMetadataEntity newEntity(String type, String dbSchemaName, String dbTableName) { + public TopiaMetadataEntity newEntity(String parent, String type, String dbSchemaName, String dbTableName) { Preconditions.checkState(!entities.containsKey(type), type + " already in cache"); - TopiaMetadataEntity clazz = new TopiaMetadataEntity(type, dbSchemaName, dbTableName); + TopiaMetadataEntity clazz = new TopiaMetadataEntity(parent, type, dbSchemaName, dbTableName); entities.put(type, clazz); log.info(clazz.getType()); return clazz; diff --git a/observe-topia-templates-extension/src/main/java/org/nuiton/topia/templates/TopiaMetadataModelGenerator.java b/observe-topia-templates-extension/src/main/java/org/nuiton/topia/templates/TopiaMetadataModelGenerator.java index fa93caa..4d79925 100644 --- a/observe-topia-templates-extension/src/main/java/org/nuiton/topia/templates/TopiaMetadataModelGenerator.java +++ b/observe-topia-templates-extension/src/main/java/org/nuiton/topia/templates/TopiaMetadataModelGenerator.java @@ -80,10 +80,18 @@ public class TopiaMetadataModelGenerator extends ObjectModelGenerator { List<ObjectModelClass> entityClasses = getTemplateHelper().getEntityClasses(model, true); TopiaMetadataModel metadataModel = new TopiaMetadataModel(); + + // Première passe pour construire toutes les entités for (ObjectModelClass entityClass : entityClasses) { buildMetadataEntity(entityClass, metadataModel); } + // Seconde passe pour aggréger les héritages + for (ObjectModelClass entityClass : entityClasses) { + TopiaMetadataEntity metadataEntity = metadataModel.getEntity(entityClass.getName()); + applyInheritance(metadataEntity, entityClass, metadataModel); + } + if (log.isDebugEnabled()) { TopiaMetadataModelVisitor.PrintVisitor visitor = new TopiaMetadataModelVisitor.PrintVisitor(true, "\n"); metadataModel.accept(visitor); @@ -195,6 +203,32 @@ public class TopiaMetadataModelGenerator extends ObjectModelGenerator { // content.append(" /* ").append(comment).append(" */"); // } + + + + protected void applyInheritance(TopiaMetadataEntity metadataEntity, ObjectModelClass entityClass, TopiaMetadataModel metadataModel) { + + boolean haveSuper = entityClass.getSuperclasses().size() > 0; + if (haveSuper) { + ObjectModelClass superClass = entityClass.getSuperclasses().iterator().next(); + String parentName = superClass.getName(); + Optional<TopiaMetadataEntity> optionalEntity = metadataModel.getOptionalEntity(parentName); + if (optionalEntity.isPresent()) { + + TopiaMetadataEntity parentMetadataEntity = optionalEntity.get(); + metadataEntity.getAssociations().putAll(parentMetadataEntity.getAssociations()); + metadataEntity.getReversedAssociations().putAll(parentMetadataEntity.getReversedAssociations()); + metadataEntity.getNmAssociations().putAll(parentMetadataEntity.getNmAssociations()); + metadataEntity.getRequired().putAll(parentMetadataEntity.getRequired()); + metadataEntity.getProperties().putAll(parentMetadataEntity.getProperties()); + metadataEntity.getDbColumnsName().putAll(parentMetadataEntity.getDbColumnsName()); + + applyInheritance(metadataEntity, superClass, metadataModel); + + } + } + + } protected TopiaMetadataEntity buildMetadataEntity(ObjectModelClass entityClass, TopiaMetadataModel metadataModel) { TopiaMetadataEntity metadataEntity; @@ -213,7 +247,14 @@ public class TopiaMetadataModelGenerator extends ObjectModelGenerator { String dbSchemaName = topiaTagValues.getDbSchemaNameTagValue(entityClass, aPackage, model); String dbTableName = templateHelper.getDbName(entityClass); - metadataEntity = metadataModel.newEntity(entityClassName, dbSchemaName, dbTableName); + boolean haveSuper = entityClass.getSuperclasses().size() > 0; + + String parent = null; + if (haveSuper) { + ObjectModelClass superClass = entityClass.getSuperclasses().iterator().next(); + parent = superClass.getName(); + } + metadataEntity = metadataModel.newEntity(parent, entityClassName, dbSchemaName, dbTableName); Collection<ObjectModelAttribute> attributes = entityClass.getAttributes(); for (ObjectModelAttribute attr : attributes) { -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 acbf463dfae4b2fa6aba567fbf36c80393af71e2 Author: Tony CHEMIT <chemit@codelutin.com> Date: Wed Jun 29 11:58:49 2016 +0200 Ajout du nom des tables pour les associations many-to-many --- .../persistence/metadata/TopiaMetadataEntity.java | 26 ++++++++++++++++++---- .../templates/TopiaMetadataModelGenerator.java | 4 +++- 2 files changed, 25 insertions(+), 5 deletions(-) diff --git a/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataEntity.java b/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataEntity.java index 8c16f2c..6f4b8ba 100644 --- a/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataEntity.java +++ b/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataEntity.java @@ -83,9 +83,14 @@ public class TopiaMetadataEntity { * @see #getDbColumnName(String) */ protected final Map<String, String> dbColumnsName = new LinkedHashMap<>(); + /** + * Le nom des tables utilisées pour les associations nm. + */ + protected final Map<String, String> dbNmAssociationsName = new LinkedHashMap<>(); + public TopiaMetadataEntity(String parent, String type, String dbSchemaName, String dbTableName) { - this.parent=parent; + this.parent = parent; this.type = type; this.dbSchemaName = dbSchemaName; this.dbTableName = dbTableName; @@ -116,7 +121,10 @@ public class TopiaMetadataEntity { .toString(); } - public boolean withParent() { return parent!=null;} + public boolean withParent() { + return parent != null; + } + public String getParent() { return parent; } @@ -161,6 +169,14 @@ public class TopiaMetadataEntity { return dbColumnName; } + public Map<String, String> getDbNmAssociationsName() { + return dbNmAssociationsName; + } + + public String getBdNmAssociationName(String propertyName) { + return dbNmAssociationsName.get(propertyName); + } + public void addAssociation(TopiaMetadataEntity associationClazz, String name, String dbColumnName) { log.info(getType() + "/" + name + "(" + dbColumnName + ") →" + associationClazz.getType()); associations.put(name, associationClazz.getType()); @@ -173,10 +189,11 @@ public class TopiaMetadataEntity { addDbColumnName(name, dbColumnName); } - public void addNmAssociation(TopiaMetadataEntity associationClazz, String name, String dbColumnName) { - log.info(getType() + "/" + name + "(" + dbColumnName + ") →" + associationClazz.getType()); + public void addNmAssociation(TopiaMetadataEntity associationClazz, String name, String dbColumnName, String dbNmAssociationName) { + log.info(getType() + "/" + name + "(" + dbNmAssociationName + ") →" + associationClazz.getType()); nmAssociations.put(name, associationClazz.getType()); addDbColumnName(name, dbColumnName); + dbNmAssociationsName.put(name, dbNmAssociationName); } public void addRequired(TopiaMetadataEntity attributeClazz, String name, String dbColumnName) { @@ -199,6 +216,7 @@ public class TopiaMetadataEntity { copy.required.putAll(required); copy.properties.putAll(properties); copy.dbColumnsName.putAll(dbColumnsName); + copy.dbNmAssociationsName.putAll(dbNmAssociationsName); return copy; } diff --git a/observe-topia-templates-extension/src/main/java/org/nuiton/topia/templates/TopiaMetadataModelGenerator.java b/observe-topia-templates-extension/src/main/java/org/nuiton/topia/templates/TopiaMetadataModelGenerator.java index 4d79925..950ae90 100644 --- a/observe-topia-templates-extension/src/main/java/org/nuiton/topia/templates/TopiaMetadataModelGenerator.java +++ b/observe-topia-templates-extension/src/main/java/org/nuiton/topia/templates/TopiaMetadataModelGenerator.java @@ -222,6 +222,7 @@ public class TopiaMetadataModelGenerator extends ObjectModelGenerator { metadataEntity.getRequired().putAll(parentMetadataEntity.getRequired()); metadataEntity.getProperties().putAll(parentMetadataEntity.getProperties()); metadataEntity.getDbColumnsName().putAll(parentMetadataEntity.getDbColumnsName()); + metadataEntity.getDbColumnsName().putAll(parentMetadataEntity.getDbNmAssociationsName()); applyInheritance(metadataEntity, superClass, metadataModel); @@ -321,7 +322,8 @@ public class TopiaMetadataModelGenerator extends ObjectModelGenerator { if (GeneratorUtil.isNMultiplicity(attr.getReverseMaxMultiplicity()) && !attr.hasAssociationClass()) { // many to many - metadataEntity.addNmAssociation(attributeClazz, name, attrColumn); + String tableName = templateHelper.getManyToManyTableName(attr); + metadataEntity.addNmAssociation(attributeClazz, name, attrColumn, tableName); } else { // one to many -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 472c89862574799bede31d4a61d39c6168873aa8 Author: Tony CHEMIT <chemit@codelutin.com> Date: Wed Jun 29 12:39:49 2016 +0200 Mise en place de la génération des requètes sql et de leur application (See #7739) --- ...UnidirectionalReferentialSynchronizeEngine.java | 15 ++- ...ectionalReferentialSynchronizeLocalService.java | 23 ++++ ...nidirectionalReferentialSynchronizeRequest.java | 57 +++++++--- ...nalReferentialSynchronizeLocalServiceTopia.java | 121 ++++++++++++++++----- 4 files changed, 170 insertions(+), 46 deletions(-) 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 index 9df5e43..44f22f6 100644 --- 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 @@ -33,17 +33,24 @@ public class UnidirectionalReferentialSynchronizeEngine { LocalReferentialStates localReferentialStates = localService.getLocalSourceReferentialStates(); RemoteReferentialDiff remoteReferentialDiff = remoteService.getReferentialDifferential(localReferentialStates); + Set<String> sqlRequests = new LinkedHashSet<>(); for (String referentialName : remoteReferentialDiff.getReferentialNames()) { - UnidirectionalReferentialSynchronizeRequest referentialSynchronizeRequest = buildReferentialSynchronizeRequest(callback, referentialName, remoteReferentialDiff); + UnidirectionalReferentialSynchronizeRequest<?> referentialSynchronizeRequest = + buildReferentialSynchronizeRequest(callback, referentialName, remoteReferentialDiff); + + Set<String> sqlRequestsforReferential = localService.generateSqlRequests(referentialSynchronizeRequest); + sqlRequests.addAll(sqlRequestsforReferential); } + localService.applySqlRequests(sqlRequests); + } private <R extends ReferentialDto> UnidirectionalReferentialSynchronizeRequest buildReferentialSynchronizeRequest(Callback callback, String referentialName, RemoteReferentialDiff remoteReferentialDiff) { - UnidirectionalReferentialSynchronizeRequest.Builder builder = UnidirectionalReferentialSynchronizeRequest.builder(referentialName); + UnidirectionalReferentialSynchronizeRequest.Builder<R> builder = UnidirectionalReferentialSynchronizeRequest.builder(referentialName); Collection<R> referentialsToAdd = remoteReferentialDiff.getReferentialsToAdd(referentialName); if (CollectionUtils.isNotEmpty(referentialsToAdd)) { @@ -101,8 +108,8 @@ public class UnidirectionalReferentialSynchronizeEngine { // calcul de l'univers de référentiels disponibles pour les remplacements - ReferentialReferenceSet<R> localSourceEnabledReferenceSet = remoteService.getEnabledReferentialReferenceSet(referentialName); - Set<ReferentialReference<R>> availableReferentials = localSourceEnabledReferenceSet.getReferences(); + ReferentialReferenceSet<R> availableReferenceSet = remoteService.getEnabledReferentialReferenceSet(referentialName); + Set<ReferentialReference<R>> availableReferentials = availableReferenceSet.getReferences(); if (needCallbackForRemove) { 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 a1b4b22..0c2caa2 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,11 @@ package fr.ird.observe.services.service.actions.synchro; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.spi.NoDataAccess; +import fr.ird.observe.services.spi.PostRequest; import fr.ird.observe.services.spi.ReadReferentialPermission; +import fr.ird.observe.services.spi.Write; +import fr.ird.observe.services.spi.WriteReferentialPermission; import java.util.Collection; import java.util.Set; @@ -34,4 +39,22 @@ public interface UnidirectionalReferentialSynchronizeLocalService { @ReadReferentialPermission Set<String> filterIdsUsedInLocalSource(String referentialName, Collection<String> ids); + /** + * Pour produire le code sql à partir de la demande pour un référentiel donné. + * + * @param request la demande des actions à produire pour un référentiel donné + * @return l'ensemble des requètes sql à appliquer. + */ + @NoDataAccess + <R extends ReferentialDto> Set<String> generateSqlRequests(UnidirectionalReferentialSynchronizeRequest<R> request); + + /** + * Pour appliquer les requètes sql de mise à jour du réferentiel. + * + * @param sqlRequests les requètes sql à appliquer + */ + @WriteReferentialPermission + @Write + @PostRequest + void applySqlRequests(Set<String> sqlRequests); } 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 index 4cbe9ed..d049d04 100644 --- 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 @@ -1,5 +1,6 @@ package fr.ird.observe.services.service.actions.synchro; +import com.google.common.base.MoreObjects; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import fr.ird.observe.services.dto.referential.ReferentialDto; @@ -14,15 +15,15 @@ import fr.ird.observe.services.dto.referential.ReferentialDto; * @author Tony Chemit - chemit@codelutin.com * @since 5.0 */ -public class UnidirectionalReferentialSynchronizeRequest { +public class UnidirectionalReferentialSynchronizeRequest<R extends ReferentialDto> { - public static Builder builder(String referentialName) { - return new Builder(referentialName); + public static <R extends ReferentialDto> Builder<R> builder(String referentialName) { + return new Builder<>(referentialName); } private final String referentialName; - private final ImmutableSet<ReferentialDto> referentialToAdd; - private final ImmutableSet<ReferentialDto> referentialToUpdate; + private final ImmutableSet<R> referentialToAdd; + private final ImmutableSet<R> referentialToUpdate; private final ImmutableSet<String> referentialToRemove; private final ImmutableMap<String, String> referentialToReplace; @@ -30,11 +31,11 @@ public class UnidirectionalReferentialSynchronizeRequest { return referentialName; } - public ImmutableSet<ReferentialDto> getReferentialToAdd() { + public ImmutableSet<R> getReferentialToAdd() { return referentialToAdd; } - public ImmutableSet<ReferentialDto> getReferentialToUpdate() { + public ImmutableSet<R> getReferentialToUpdate() { return referentialToUpdate; } @@ -46,9 +47,33 @@ public class UnidirectionalReferentialSynchronizeRequest { return referentialToReplace; } + public boolean withReferentialToAdd() { + return !referentialToAdd.isEmpty(); + } + public boolean withReferentialToUpdate() { + return !referentialToUpdate.isEmpty(); + } + public boolean withReferentialToRemove() { + return !referentialToRemove.isEmpty(); + } + public boolean withReferentialToReplace() { + return !referentialToReplace.isEmpty(); + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("referentialName", referentialName) + .add("referentialToAdd", referentialToAdd.size()) + .add("referentialToUpdate", referentialToUpdate.size()) + .add("referentialToRemove", referentialToRemove.size()) + .add("referentialToReplace", referentialToReplace.size()) + .toString(); + } + private UnidirectionalReferentialSynchronizeRequest(String referentialName, - ImmutableSet<ReferentialDto> referentialToAdd, - ImmutableSet<ReferentialDto> referentialToUpdate, + ImmutableSet<R> referentialToAdd, + ImmutableSet<R> referentialToUpdate, ImmutableSet<String> referentialToRemove, ImmutableMap<String, String> toReplace) { this.referentialName = referentialName; @@ -58,20 +83,20 @@ public class UnidirectionalReferentialSynchronizeRequest { this.referentialToReplace = toReplace; } - public static class Builder { + public static class Builder<R extends ReferentialDto> { private final String referentialName; - private final ImmutableSet.Builder<ReferentialDto> toAddBuilder = ImmutableSet.builder(); - private final ImmutableSet.Builder<ReferentialDto> toUpdateBuilder = ImmutableSet.builder(); + private final ImmutableSet.Builder<R> toAddBuilder = ImmutableSet.builder(); + private final ImmutableSet.Builder<R> 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) { + public Builder entityToAdd(R referentialDto) { toAddBuilder.add(referentialDto); return this; } - public Builder entityToUpdate(ReferentialDto referentialDto) { + public Builder entityToUpdate(R referentialDto) { toUpdateBuilder.add(referentialDto); return this; } @@ -86,9 +111,9 @@ public class UnidirectionalReferentialSynchronizeRequest { return this; } - public UnidirectionalReferentialSynchronizeRequest build() { + public UnidirectionalReferentialSynchronizeRequest<R> build() { - return new UnidirectionalReferentialSynchronizeRequest( + return new UnidirectionalReferentialSynchronizeRequest<>( referentialName, toAddBuilder.build(), toUpdateBuilder.build(), 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 e9c2245..79ab42f 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 @@ -4,17 +4,19 @@ import fr.ird.observe.ObserveEntityEnum; import fr.ird.observe.entities.Entities; 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 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 org.nuiton.topia.persistence.support.TopiaSqlWork; +import java.sql.Connection; +import java.sql.SQLException; +import java.sql.Statement; import java.util.Collection; -import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; @@ -67,35 +69,71 @@ public class UnidirectionalReferentialSynchronizeLocalServiceTopia extends Obser } - 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)); + @Override + public <R extends ReferentialDto> Set<String> generateSqlRequests(UnidirectionalReferentialSynchronizeRequest<R> request) { + + if (log.isTraceEnabled()) { + log.trace("generateSqlRequests(" + request + ")"); + } + + Set<String> result = new LinkedHashSet<>(); + + String referentialName = request.getReferentialName(); + + ObserveEntityEnum entityEnum = ObserveEntityEnum.valueOf(referentialName); + Class entityType = entityEnum.getContract(); + Class<R> dtoType = BinderEngine.get().getReferentialDtoType(entityType); + + TopiaMetadataEntity metadataEntity = serviceContext.getTopiaApplicationContext().getMetadataModel().getEntity(referentialName); + if (request.withReferentialToAdd()) { + + InsertSqlStatementGenerator<R> sqlStatementGenerator = new InsertSqlStatementGenerator<>(metadataEntity, dtoType); + for (R referentialDto : request.getReferentialToAdd()) { + String sql = sqlStatementGenerator.generateSql(referentialDto); + result.add(sql); + } + } + + if (request.withReferentialToUpdate()) { + + UpdateSqlStatementGenerator<R> sqlStatementGenerator = new UpdateSqlStatementGenerator<R>(metadataEntity, dtoType); + for (R referentialDto : request.getReferentialToUpdate()) { + String sql = sqlStatementGenerator.generateSql(referentialDto); + result.add(sql); + } + + } + + if (request.withReferentialToReplace()) { + + //TODO + + } + if (request.withReferentialToRemove()) { + + DeleteSqlStatementGenerator sqlStatementGenerator = new DeleteSqlStatementGenerator(metadataEntity); + for (String id : request.getReferentialToRemove()) { + String sql = sqlStatementGenerator.generateSql(id); + result.add(sql); + } + } - 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()); + return result; + + } - Map<String, Object> obtainProperties = binder.obtainProperties(referentialToAdd, true, propertyNames); - properties.putAll(obtainProperties); + @Override + public void applySqlRequests(Set<String> sqlRequests) { + if (log.isTraceEnabled()) { + log.trace("applySqlRequests(" + sqlRequests + ")"); } + + TopiaSqlWork applySqlWork = new ApplySqlRequestWork(sqlRequests); + getTopiaPersistenceContext().getSqlSupport().doSqlWork(applySqlWork); + } private <E extends ObserveReferentialEntity> void getLocalSourceReferentialVersions0(String entityName, Class<E> entityType, LocalReferentialStates localReferentialStates) { @@ -120,4 +158,35 @@ public class UnidirectionalReferentialSynchronizeLocalServiceTopia extends Obser } + private static class ApplySqlRequestWork implements TopiaSqlWork { + + private static final int BATCH_SIZE = 100; + + private final Set<String> sqlRequests; + + ApplySqlRequestWork(Set<String> sqlRequests) { + this.sqlRequests = sqlRequests; + } + + @Override + public void execute(Connection connection) throws SQLException { + + Statement statement = connection.createStatement(); + + int count = 0; + for (String sqlRequest : sqlRequests) { + statement.addBatch(sqlRequest); + if ((count % BATCH_SIZE) == 0) { + flush(statement); + } + } + flush(statement); + + } + + private void flush(Statement statement) throws SQLException { + statement.executeBatch(); + statement.clearBatch(); + } + } } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 e5f6f5f1138baf05dfa88a71f31153e427eb9ea6 Author: Tony CHEMIT <chemit@codelutin.com> Date: Mon Jul 4 11:20:50 2016 +0200 Ajout du générateur de reqètes sql de remplacement (See #7739) --- .../synchro/ReplaceSqlStatementGenerator.java | 126 +++++++++++++++++++++ 1 file changed, 126 insertions(+) diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/ReplaceSqlStatementGenerator.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/ReplaceSqlStatementGenerator.java new file mode 100644 index 0000000..68e44ff --- /dev/null +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/ReplaceSqlStatementGenerator.java @@ -0,0 +1,126 @@ +package fr.ird.observe.services.service.actions.synchro; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.topia.persistence.metadata.TopiaMetadataEntity; +import org.nuiton.topia.persistence.metadata.TopiaMetadataModel; + +import java.util.LinkedHashSet; +import java.util.Set; +import java.util.stream.Collectors; + +/** + * Pour générer une requète sql de remplacement à partir d'un référentiel donné. + * Created on 04/07/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReplaceSqlStatementGenerator { + + /** Logger. */ + private static final Log log = LogFactory.getLog(ReplaceSqlStatementGenerator.class); + + private static final String REQUIRED_UPDATE_STATEMENT = "UPDATE %s.%s SET %s = '%s', SET topiaVersion = topiaVersion + 1 WHERE topiaId ='%s';\n"; + private static final String NMASSOCIATION_UPDATE_STATEMENT = "UPDATE %s.%s SET %s = '%s' WHERE topiaId ='%s';\n"; + + private final Set<ReplacementStruct> requiredReplacements; + private final Set<ReplacementStruct> nmAssociationReplacements; + + private static class ReplacementStruct { + + private final String schemaName; + private final String tableName; + private final String columnName; + + private ReplacementStruct(String schemaName, String tableName, String columnName) { + this.schemaName = schemaName; + this.tableName = tableName; + this.columnName = columnName; + } + + } + + public ReplaceSqlStatementGenerator(TopiaMetadataModel topiaMetadataModel, String referentialName) { + this.requiredReplacements = computeRequiredReplacements(referentialName, topiaMetadataModel); + this.nmAssociationReplacements = computeNmAssociationReplacements(referentialName, topiaMetadataModel); + } + + public String generateSql(String sourceId, String replacementId) { + + StringBuilder builder = new StringBuilder(); + + for (ReplacementStruct replacementStruct : requiredReplacements) { + + String sql = generateSqlStatement(REQUIRED_UPDATE_STATEMENT, replacementStruct, sourceId, replacementId); + builder.append(sql); + + } + + for (ReplacementStruct replacementStruct : nmAssociationReplacements) { + + String sql = generateSqlStatement(NMASSOCIATION_UPDATE_STATEMENT, replacementStruct, sourceId, replacementId); + builder.append(sql); + + } + + return builder.toString(); + + } + + private Set<ReplacementStruct> computeRequiredReplacements(String referentialName, TopiaMetadataModel topiaMetadataModel) { + + Set<ReplacementStruct> result = new LinkedHashSet<>(); + + for (TopiaMetadataEntity metadataEntity : topiaMetadataModel) { + + result.addAll(metadataEntity.getRequired().entrySet().stream() + .filter(entry -> entry.getValue().equals(referentialName)) + .map(entry -> new ReplacementStruct(metadataEntity.getDbSchemaName(), + metadataEntity.getDbTableName(), + metadataEntity.getDbColumnName(entry.getValue()))) + .collect(Collectors.toList())); + + } + + return result; + + } + + private Set<ReplacementStruct> computeNmAssociationReplacements(String referentialName, TopiaMetadataModel topiaMetadataModel) { + + Set<ReplacementStruct> result = new LinkedHashSet<>(); + + for (TopiaMetadataEntity metadataEntity : topiaMetadataModel) { + + result.addAll(metadataEntity.getNmAssociations().entrySet().stream() + .filter(entry -> entry.getValue().equals(referentialName)) + .map(entry -> new ReplacementStruct(metadataEntity.getDbSchemaName(), + metadataEntity.getBdNmAssociationName(entry.getValue()), + metadataEntity.getDbColumnName(entry.getValue()))) + .collect(Collectors.toList())); + + } + + return result; + + } + + private String generateSqlStatement(String replacementPattern, ReplacementStruct replacementStruct, String sourceId, String replacementId) { + + String sql = String.format(replacementPattern, + replacementStruct.schemaName, + replacementStruct.tableName, + replacementStruct.columnName, + replacementId, + sourceId); + + if (log.isDebugEnabled()) { + log.debug("sql: " + sql); + } + + return sql; + + } + +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 df3e90931dae509f5b2639a175f0a1cac27973d2 Author: Tony CHEMIT <chemit@codelutin.com> Date: Mon Jul 4 12:14:47 2016 +0200 Meilleur nommage dans le méta-modèle + correction de l'algorithme de remplacement --- .../synchro/InsertSqlStatementGenerator.java | 57 ++++----- .../synchro/ReplaceSqlStatementGenerator.java | 76 ++++++----- .../synchro/UpdateSqlStatementGenerator.java | 142 ++++++++++----------- 3 files changed, 130 insertions(+), 145 deletions(-) diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/InsertSqlStatementGenerator.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/InsertSqlStatementGenerator.java index 65fcac6..312def0 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/InsertSqlStatementGenerator.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/InsertSqlStatementGenerator.java @@ -36,13 +36,13 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { private final String tableName; private final Binder<R, R> binder; private final String[] simplePropertyNames; - private final String[] compositionPropertyNames; - private final Set<NmAssociation> nmAssociations; + private final String[] manyToOneAssociationNames; + private final Set<ManyToManyAssociationStruct> manyToManyAssociations; /** * Pour décrire une association nm. */ - private static class NmAssociation { + private static class ManyToManyAssociationStruct { /** * Le nom de la propriété dans l'objet. @@ -57,23 +57,12 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { */ private final String tableName; - private NmAssociation(String propertyName, String dbColumnName, String tableName) { + private ManyToManyAssociationStruct(String propertyName, String dbColumnName, String tableName) { this.propertyName = propertyName; this.dbColumnName = dbColumnName; this.tableName = tableName; } - public String getPropertyName() { - return propertyName; - } - - public String getDbColumnName() { - return dbColumnName; - } - - public String getTableName() { - return tableName; - } } public InsertSqlStatementGenerator(TopiaMetadataEntity metadataEntity, Class<R> dtoType) { @@ -81,19 +70,19 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { this.tableName = metadataEntity.getDbTableName(); Set<String> propertyNamesSet = metadataEntity.getProperties().keySet(); this.simplePropertyNames = propertyNamesSet.toArray(new String[propertyNamesSet.size()]); - Set<String> compositionPropertyNamesSet = metadataEntity.getRequired().keySet(); - this.compositionPropertyNames = propertyNamesSet.toArray(new String[compositionPropertyNamesSet.size()]); + Set<String> manyToOneAssociationNamesSet = metadataEntity.getManyToOneAssociations().keySet(); + this.manyToOneAssociationNames = propertyNamesSet.toArray(new String[manyToOneAssociationNamesSet.size()]); - Map<String, String> nmAssociationsMap = metadataEntity.getNmAssociations(); - this.nmAssociations = new LinkedHashSet<>(); - for (Map.Entry<String, String> entry : nmAssociationsMap.entrySet()) { + Map<String, String> manyToManyAssociationsMap = metadataEntity.getManyToManyAssociations(); + this.manyToManyAssociations = new LinkedHashSet<>(); + for (Map.Entry<String, String> entry : manyToManyAssociationsMap.entrySet()) { String propertyName = entry.getKey(); String dbColumnName = metadataEntity.getDbColumnName(propertyName); - String tableName = metadataEntity.getBdNmAssociationName(propertyName); - NmAssociation nmAssociation = new NmAssociation(propertyName, dbColumnName, tableName); - nmAssociations.add(nmAssociation); + String tableName = metadataEntity.getBdManyToManyAssociationTableName(propertyName); + ManyToManyAssociationStruct manyToManyAssociation = new ManyToManyAssociationStruct(propertyName, dbColumnName, tableName); + manyToManyAssociations.add(manyToManyAssociation); } - this.columnNames = computeColumnNames(metadataEntity, simplePropertyNames, compositionPropertyNames); + this.columnNames = computeColumnNames(metadataEntity, simplePropertyNames, manyToOneAssociationNames); this.binder = BinderFactory.newBinder(dtoType); } @@ -103,7 +92,7 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { addStringParameter(referentialDto.getId(), parameters); addOtherTypeParameter(referentialDto.getVersion(), parameters); - addOtherTypeParameter(referentialDto.getCreateDate(), parameters); + addDateParameter(referentialDto.getCreateDate(), parameters); Map<String, Object> simpleParameters = binder.obtainProperties(referentialDto, true, simplePropertyNames); for (Object parameterValue : simpleParameters.values()) { @@ -128,7 +117,7 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { } - Map<String, Object> compositionParameters = binder.obtainProperties(referentialDto, true, compositionPropertyNames); + Map<String, Object> compositionParameters = binder.obtainProperties(referentialDto, true, manyToOneAssociationNames); for (Object parameterValue : compositionParameters.values()) { if (parameterValue == null) { @@ -154,8 +143,8 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { if (log.isDebugEnabled()) { log.debug("sql: " + result); } - for (NmAssociation nmAssociation : nmAssociations) { - String nmAssociationSql = generateNmAssociationSql(referentialDto, nmAssociation); + for (ManyToManyAssociationStruct manyToManyAssociation : manyToManyAssociations) { + String nmAssociationSql = generateNmAssociationSql(referentialDto, manyToManyAssociation); result += nmAssociationSql; } @@ -163,18 +152,18 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { } - private String generateNmAssociationSql(R referentialDto, NmAssociation nmAssociation) { + private String generateNmAssociationSql(R referentialDto, ManyToManyAssociationStruct manyToManyAssociationStruct) { StringBuilder builder = new StringBuilder(); - Collection<ReferentialReference<?>> nmAssociationValues = binder.obtainSourceProperty(referentialDto, nmAssociation.getPropertyName()); - if (CollectionUtils.isNotEmpty(nmAssociationValues)) { + Collection<ReferentialReference<?>> manyToManyAssociationValues = binder.obtainSourceProperty(referentialDto, manyToManyAssociationStruct.propertyName); + if (CollectionUtils.isNotEmpty(manyToManyAssociationValues)) { - String nmAssociationTableName = nmAssociation.getTableName(); - String nmAssociationDbColumnName = nmAssociation.getDbColumnName(); + String nmAssociationTableName = manyToManyAssociationStruct.tableName; + String nmAssociationDbColumnName = manyToManyAssociationStruct.dbColumnName; String referentialDtoId = referentialDto.getId(); - for (ReferentialReference<?> nmAssociationValue : nmAssociationValues) { + for (ReferentialReference<?> nmAssociationValue : manyToManyAssociationValues) { String sql = String.format(NM_ASSOCIATION_INSERT_STATEMENT, schemaName, diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/ReplaceSqlStatementGenerator.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/ReplaceSqlStatementGenerator.java index 68e44ff..e0d6e9d 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/ReplaceSqlStatementGenerator.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/ReplaceSqlStatementGenerator.java @@ -21,11 +21,17 @@ public class ReplaceSqlStatementGenerator { /** Logger. */ private static final Log log = LogFactory.getLog(ReplaceSqlStatementGenerator.class); - private static final String REQUIRED_UPDATE_STATEMENT = "UPDATE %s.%s SET %s = '%s', SET topiaVersion = topiaVersion + 1 WHERE topiaId ='%s';\n"; - private static final String NMASSOCIATION_UPDATE_STATEMENT = "UPDATE %s.%s SET %s = '%s' WHERE topiaId ='%s';\n"; - - private final Set<ReplacementStruct> requiredReplacements; - private final Set<ReplacementStruct> nmAssociationReplacements; + private static final String MANY_TO_ONE_ASSOCIATION_UPDATE_STATEMENT = "UPDATE %s.%s SET %s = '%s', SET topiaVersion = topiaVersion + 1 WHERE topiaId = '%s';\n"; + private static final String MANY_TO_MANY_ASSOCIATION_UPDATE_STATEMENT = "UPDATE %s.%s SET %s = '%s' WHERE %s = '%s';\n"; + + /** + * Informations pour remplacer dans une relation many-to-one. + */ + private final Set<ReplacementStruct> manyToOneAssociationReplacements; + /** + * Informations pour remplacer dans une relation many-to-many. + */ + private final Set<ReplacementStruct> manyToManyAssociationReplacements; private static class ReplacementStruct { @@ -42,24 +48,41 @@ public class ReplaceSqlStatementGenerator { } public ReplaceSqlStatementGenerator(TopiaMetadataModel topiaMetadataModel, String referentialName) { - this.requiredReplacements = computeRequiredReplacements(referentialName, topiaMetadataModel); - this.nmAssociationReplacements = computeNmAssociationReplacements(referentialName, topiaMetadataModel); + this.manyToOneAssociationReplacements = computeManyToOneAssociationReplacements(referentialName, topiaMetadataModel); + this.manyToManyAssociationReplacements = computeManyToManyAssociationReplacements(referentialName, topiaMetadataModel); } public String generateSql(String sourceId, String replacementId) { StringBuilder builder = new StringBuilder(); - for (ReplacementStruct replacementStruct : requiredReplacements) { - - String sql = generateSqlStatement(REQUIRED_UPDATE_STATEMENT, replacementStruct, sourceId, replacementId); + for (ReplacementStruct replacementStruct : manyToOneAssociationReplacements) { + + String sql = String.format(MANY_TO_ONE_ASSOCIATION_UPDATE_STATEMENT, + replacementStruct.schemaName, + replacementStruct.tableName, + replacementStruct.columnName, + replacementId, + sourceId); + if (log.isDebugEnabled()) { + log.debug("sql: " + sql); + } builder.append(sql); } - for (ReplacementStruct replacementStruct : nmAssociationReplacements) { - - String sql = generateSqlStatement(NMASSOCIATION_UPDATE_STATEMENT, replacementStruct, sourceId, replacementId); + for (ReplacementStruct replacementStruct : manyToManyAssociationReplacements) { + + String sql = String.format(MANY_TO_MANY_ASSOCIATION_UPDATE_STATEMENT, + replacementStruct.schemaName, + replacementStruct.tableName, + replacementStruct.columnName, + replacementId, + replacementStruct.columnName, + sourceId); + if (log.isDebugEnabled()) { + log.debug("sql: " + sql); + } builder.append(sql); } @@ -68,13 +91,13 @@ public class ReplaceSqlStatementGenerator { } - private Set<ReplacementStruct> computeRequiredReplacements(String referentialName, TopiaMetadataModel topiaMetadataModel) { + private Set<ReplacementStruct> computeManyToOneAssociationReplacements(String referentialName, TopiaMetadataModel topiaMetadataModel) { Set<ReplacementStruct> result = new LinkedHashSet<>(); for (TopiaMetadataEntity metadataEntity : topiaMetadataModel) { - result.addAll(metadataEntity.getRequired().entrySet().stream() + result.addAll(metadataEntity.getManyToOneAssociations().entrySet().stream() .filter(entry -> entry.getValue().equals(referentialName)) .map(entry -> new ReplacementStruct(metadataEntity.getDbSchemaName(), metadataEntity.getDbTableName(), @@ -87,16 +110,16 @@ public class ReplaceSqlStatementGenerator { } - private Set<ReplacementStruct> computeNmAssociationReplacements(String referentialName, TopiaMetadataModel topiaMetadataModel) { + private Set<ReplacementStruct> computeManyToManyAssociationReplacements(String referentialName, TopiaMetadataModel topiaMetadataModel) { Set<ReplacementStruct> result = new LinkedHashSet<>(); for (TopiaMetadataEntity metadataEntity : topiaMetadataModel) { - result.addAll(metadataEntity.getNmAssociations().entrySet().stream() + result.addAll(metadataEntity.getManyToManyAssociations().entrySet().stream() .filter(entry -> entry.getValue().equals(referentialName)) .map(entry -> new ReplacementStruct(metadataEntity.getDbSchemaName(), - metadataEntity.getBdNmAssociationName(entry.getValue()), + metadataEntity.getBdManyToManyAssociationTableName(entry.getValue()), metadataEntity.getDbColumnName(entry.getValue()))) .collect(Collectors.toList())); @@ -106,21 +129,4 @@ public class ReplaceSqlStatementGenerator { } - private String generateSqlStatement(String replacementPattern, ReplacementStruct replacementStruct, String sourceId, String replacementId) { - - String sql = String.format(replacementPattern, - replacementStruct.schemaName, - replacementStruct.tableName, - replacementStruct.columnName, - replacementId, - sourceId); - - if (log.isDebugEnabled()) { - log.debug("sql: " + sql); - } - - return sql; - - } - } diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UpdateSqlStatementGenerator.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UpdateSqlStatementGenerator.java index d238410..365e0f4 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UpdateSqlStatementGenerator.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UpdateSqlStatementGenerator.java @@ -30,21 +30,21 @@ public class UpdateSqlStatementGenerator<R extends ReferentialDto> { private static final Log log = LogFactory.getLog(UpdateSqlStatementGenerator.class); private static final String UPDATE_STATEMENT = "UPDATE %s.%s %s WHERE topiaId ='%s';\n"; - private static final String NM_ASSOCIATION_DELETE_STATEMENT = "DELETE FROM %s.%s WHERE %s = '%s';\n"; - private static final String NM_ASSOCIATION_INSERT_STATEMENT = "INSERT INTO %s.%s(%s, %s) VALUES ('%s', '%s');\n"; + private static final String MANY_TO_MANY_ASSOCIATION_DELETE_STATEMENT = "DELETE FROM %s.%s WHERE %s = '%s';\n"; + private static final String MANY_TO_MANY_ASSOCIATION_INSERT_STATEMENT = "INSERT INTO %s.%s(%s, %s) VALUES ('%s', '%s');\n"; private final Map<String, String> columnNames; private final String schemaName; private final String tableName; private final Binder<R, R> binder; private final String[] simplePropertyNames; - private final String[] compositionPropertyNames; - private final Set<NmAssociation> nmAssociations; + private final String[] manyToOneAssociationNames; + private final Set<ManyToManyAssociationStruct> manyToManyAssociations; /** * Pour décrire une association nm. */ - private static class NmAssociation { + private static class ManyToManyAssociationStruct { /** * Le nom de la propriété dans l'objet. @@ -59,43 +59,32 @@ public class UpdateSqlStatementGenerator<R extends ReferentialDto> { */ private final String tableName; - private NmAssociation(String propertyName, String dbColumnName, String tableName) { + private ManyToManyAssociationStruct(String propertyName, String dbColumnName, String tableName) { this.propertyName = propertyName; this.dbColumnName = dbColumnName; this.tableName = tableName; } - public String getPropertyName() { - return propertyName; - } - - public String getDbColumnName() { - return dbColumnName; - } - - public String getTableName() { - return tableName; - } } public UpdateSqlStatementGenerator(TopiaMetadataEntity metadataEntity, Class<R> dtoType) { this.schemaName = metadataEntity.getDbSchemaName(); this.tableName = metadataEntity.getDbTableName(); - Set<String> propertyNamesSet = metadataEntity.getProperties().keySet(); - this.simplePropertyNames = propertyNamesSet.toArray(new String[propertyNamesSet.size()]); - Set<String> compositionPropertyNamesSet = metadataEntity.getRequired().keySet(); - this.compositionPropertyNames = propertyNamesSet.toArray(new String[compositionPropertyNamesSet.size()]); - - Map<String, String> nmAssociationsMap = metadataEntity.getNmAssociations(); - this.nmAssociations = new LinkedHashSet<>(); - for (Map.Entry<String, String> entry : nmAssociationsMap.entrySet()) { + Set<String> simplePropertyNamesSet = metadataEntity.getProperties().keySet(); + this.simplePropertyNames = simplePropertyNamesSet.toArray(new String[simplePropertyNamesSet.size()]); + Set<String> manyToOneAssociationNamesSet = metadataEntity.getManyToOneAssociations().keySet(); + this.manyToOneAssociationNames = simplePropertyNamesSet.toArray(new String[manyToOneAssociationNamesSet.size()]); + + Map<String, String> manyToManyAssociationsMap = metadataEntity.getManyToManyAssociations(); + this.manyToManyAssociations = new LinkedHashSet<>(); + for (Map.Entry<String, String> entry : manyToManyAssociationsMap.entrySet()) { String propertyName = entry.getKey(); String dbColumnName = metadataEntity.getDbColumnName(propertyName); - String tableName = metadataEntity.getBdNmAssociationName(propertyName); - NmAssociation nmAssociation = new NmAssociation(propertyName, dbColumnName, tableName); - nmAssociations.add(nmAssociation); + String tableName = metadataEntity.getBdManyToManyAssociationTableName(propertyName); + ManyToManyAssociationStruct manyToManyAssociation = new ManyToManyAssociationStruct(propertyName, dbColumnName, tableName); + manyToManyAssociations.add(manyToManyAssociation); } - this.columnNames = computeColumnNames(metadataEntity, simplePropertyNames, compositionPropertyNames); + this.columnNames = computeColumnNames(metadataEntity, simplePropertyNames, manyToOneAssociationNames); this.binder = BinderFactory.newBinder(dtoType); } @@ -105,87 +94,88 @@ public class UpdateSqlStatementGenerator<R extends ReferentialDto> { addStringParameter(TopiaEntity.PROPERTY_TOPIA_ID, referentialDto.getId(), parameters); addOtherTypeParameter(TopiaEntity.PROPERTY_TOPIA_VERSION, referentialDto.getVersion(), parameters); - addOtherTypeParameter(TopiaEntity.PROPERTY_TOPIA_CREATE_DATE, referentialDto.getCreateDate(), parameters); + addDateParameter(TopiaEntity.PROPERTY_TOPIA_CREATE_DATE, referentialDto.getCreateDate(), parameters); - Map<String, Object> simpleParameters = binder.obtainProperties(referentialDto, true, simplePropertyNames); - for (Map.Entry<String, Object> entry : simpleParameters.entrySet()) { + Map<String, Object> simpleProperties = binder.obtainProperties(referentialDto, true, simplePropertyNames); + for (Map.Entry<String, Object> entry : simpleProperties.entrySet()) { - String parameterName = entry.getKey(); - String columnName = columnNames.get(parameterName); - Object parameterValue = entry.getValue(); + String simplePropertyName = entry.getKey(); + String columnName = columnNames.get(simplePropertyName); + Object simplePropertyValue = entry.getValue(); - if (parameterValue == null) { + if (simplePropertyValue == null) { addNullParameter(columnName, parameters); continue; } - if (parameterValue instanceof String) { - addStringParameter(columnName, (String) parameterValue, parameters); + if (simplePropertyValue instanceof String) { + addStringParameter(columnName, (String) simplePropertyValue, parameters); continue; } - if (parameterValue instanceof Date) { - addDateParameter(columnName, (Date) parameterValue, parameters); + if (simplePropertyValue instanceof Date) { + addDateParameter(columnName, (Date) simplePropertyValue, parameters); continue; } - if (parameterValue instanceof Enum) { - addEnumParameter(columnName, (Enum) parameterValue, parameters); + if (simplePropertyValue instanceof Enum) { + addEnumParameter(columnName, (Enum) simplePropertyValue, parameters); continue; } - addOtherTypeParameter(columnName, parameterValue, parameters); + addOtherTypeParameter(columnName, simplePropertyValue, parameters); } + Map<String, Object> manyToOneAssociations = binder.obtainProperties(referentialDto, true, manyToOneAssociationNames); + for (Map.Entry<String, Object> entry : manyToOneAssociations.entrySet()) { - Map<String, Object> compositionParameters = binder.obtainProperties(referentialDto, true, compositionPropertyNames); - for (Map.Entry<String, Object> entry : compositionParameters.entrySet()) { - - String parameterName = entry.getKey(); - String columnName = columnNames.get(parameterName); - Object parameterValue = entry.getValue(); + String manyToOneAssociationName = entry.getKey(); + String columnName = columnNames.get(manyToOneAssociationName); + Object manyToOneAssociationValue = entry.getValue(); - if (parameterValue == null) { + if (manyToOneAssociationValue == null) { addNullParameter(columnName, parameters); continue; } - if (parameterValue instanceof ReferentialDto) { - addReferentialDtoParameter(columnName, (ReferentialDto) parameterValue, parameters); + if (manyToOneAssociationValue instanceof ReferentialDto) { + addReferentialDtoParameter(columnName, (ReferentialDto) manyToOneAssociationValue, parameters); continue; } - if (parameterValue instanceof ReferentialReference) { - addReferentialReferenceParameter(columnName, (ReferentialReference) parameterValue, parameters); + if (manyToOneAssociationValue instanceof ReferentialReference) { + addReferentialReferenceParameter(columnName, (ReferentialReference) manyToOneAssociationValue, parameters); } } - String result = String.format(UPDATE_STATEMENT, - schemaName, - tableName, - parameters.substring(2), - referentialDto.getId()); + StringBuilder result = new StringBuilder(); + String sql = String.format(UPDATE_STATEMENT, + schemaName, + tableName, + parameters.substring(2), + referentialDto.getId()); + result.append(sql); if (log.isDebugEnabled()) { - log.debug("sql: " + result); + log.debug("sql: " + sql); } - for (NmAssociation nmAssociation : nmAssociations) { - String nmAssociationSql = generateNmAssociationSql(referentialDto, nmAssociation); - result += nmAssociationSql; + for (ManyToManyAssociationStruct manyToManyAssociation : manyToManyAssociations) { + String manyToManyAssociationSql = generateManyToManyAssociationSql(referentialDto, manyToManyAssociation); + result.append(manyToManyAssociationSql); } - return result; + return result.toString(); } - private String generateNmAssociationSql(R referentialDto, NmAssociation nmAssociation) { + private String generateManyToManyAssociationSql(R referentialDto, ManyToManyAssociationStruct manyToManyAssociation) { StringBuilder builder = new StringBuilder(); String referentialDtoId = referentialDto.getId(); - String nmAssociationTableName = nmAssociation.getTableName(); + String manyToManyAssociationTableName = manyToManyAssociation.tableName; // On commence toujours par supprimer toutes les anciennes associations, elles seront ré-ajoutées juste après - String deleteSql = String.format(NM_ASSOCIATION_DELETE_STATEMENT, + String deleteSql = String.format(MANY_TO_MANY_ASSOCIATION_DELETE_STATEMENT, schemaName, - nmAssociationTableName, + manyToManyAssociationTableName, tableName, referentialDtoId); builder.append(deleteSql); @@ -193,22 +183,22 @@ public class UpdateSqlStatementGenerator<R extends ReferentialDto> { log.debug("sql: " + deleteSql); } - Collection<ReferentialReference<?>> nmAssociationValues = binder.obtainSourceProperty(referentialDto, nmAssociation.getPropertyName()); - if (CollectionUtils.isNotEmpty(nmAssociationValues)) { + Collection<ReferentialReference<?>> manyToManyAssociationValues = binder.obtainSourceProperty(referentialDto, manyToManyAssociation.propertyName); + if (CollectionUtils.isNotEmpty(manyToManyAssociationValues)) { - String nmAssociationDbColumnName = nmAssociation.getDbColumnName(); + String manyToManyAssociationDbColumnName = manyToManyAssociation.dbColumnName; - for (ReferentialReference<?> nmAssociationValue : nmAssociationValues) { + for (ReferentialReference<?> manyToManyAssociationValue : manyToManyAssociationValues) { - String sql = String.format(NM_ASSOCIATION_INSERT_STATEMENT, + String sql = String.format(MANY_TO_MANY_ASSOCIATION_INSERT_STATEMENT, schemaName, - nmAssociationTableName, + manyToManyAssociationTableName, tableName, - nmAssociationDbColumnName, + manyToManyAssociationDbColumnName, referentialDtoId, - nmAssociationValue.getId()); + manyToManyAssociationValue.getId()); if (log.isDebugEnabled()) { log.debug("sql: " + sql); } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 38022697f1e54f797b5c5767331c0e3a0902125d Author: Tony CHEMIT <chemit@codelutin.com> Date: Mon Jul 4 17:49:04 2016 +0200 Make possible to use multiple database in tests --- .../services/ApplicationContextResource.java | 68 ++++++++++++++++++++-- .../ird/observe/services/DataSourceResource.java | 50 ++++++++++++++-- .../main/java/fr/ird/observe/test/TestHelper.java | 11 ---- 3 files changed, 108 insertions(+), 21 deletions(-) diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/ApplicationContextResource.java b/observe-services-topia/src/test/java/fr/ird/observe/services/ApplicationContextResource.java index 7732a72..cdd3833 100644 --- a/observe-services-topia/src/test/java/fr/ird/observe/services/ApplicationContextResource.java +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/ApplicationContextResource.java @@ -37,6 +37,8 @@ import fr.ird.observe.services.service.DatabaseConnexionNotAuthorizedException; import fr.ird.observe.services.service.DatabaseNotFoundException; import fr.ird.observe.test.ObserveFixtures; import fr.ird.observe.test.TestHelper; +import fr.ird.observe.test.spi.CopyDatabaseConfiguration; +import fr.ird.observe.test.spi.DatabaseClassifier; import fr.ird.observe.test.spi.DatabaseNameConfiguration; import fr.ird.observe.test.spi.DatabaseVersionConfiguration; import org.apache.commons.logging.Log; @@ -51,6 +53,7 @@ import org.nuiton.version.Versions; import java.io.File; import java.io.IOException; +import java.lang.annotation.Annotation; import java.nio.file.Files; import java.nio.file.Path; import java.util.Locale; @@ -77,7 +80,10 @@ public class ApplicationContextResource implements TestRule { protected String dbVersion; - public ApplicationContextResource() { + protected final DatabaseClassifier classifier; + + public ApplicationContextResource(DatabaseClassifier classifier) { + this.classifier = classifier; this.speciesListConfiguration = ObserveSpeciesListConfiguration.newDefaultConfiguration(); this.serviceFactory = new ObserveServiceFactoryTopia() { @@ -90,7 +96,10 @@ public class ApplicationContextResource implements TestRule { serviceFactory.setMainServiceFactory(serviceFactory); dataSourcesForTestManager = new DataSourcesForTestManager(); + } + public ApplicationContextResource() { + this(DatabaseClassifier.DEFAULT); } public ObserveDataSourceConfigurationTopiaH2 createDataSource(Version dbVersion, String dbName, File targetPath) throws DataSourceCreateWithNoReferentialImportException, IOException, IncompatibleDataSourceCreateConfigurationException, DatabaseNotFoundException, DatabaseConnexionNotAuthorizedException, BabModelVersionException { @@ -202,12 +211,12 @@ public class ApplicationContextResource implements TestRule { TestHelper.initTest(testClass); - DatabaseNameConfiguration databaseNameConfiguration = TestHelper.getAnnotation(testClass, DatabaseNameConfiguration.class); + DatabaseNameConfiguration databaseNameConfiguration = getDatabaseNameConfigurationAnnotation(testClass, classifier); if (databaseNameConfiguration != null) { dbName = databaseNameConfiguration.value().name(); } - DatabaseVersionConfiguration databaseVersionConfiguration = TestHelper.getAnnotation(testClass, DatabaseVersionConfiguration.class); + DatabaseVersionConfiguration databaseVersionConfiguration = getDatabaseVersionConfigurationAnnotation(testClass, classifier); if (databaseVersionConfiguration != null) { dbVersion = databaseVersionConfiguration.value(); } @@ -260,7 +269,11 @@ public class ApplicationContextResource implements TestRule { } public File createTemporaryFile(String suffix) { - return temporaryDirectoryRoot.resolve(System.nanoTime()+suffix).toFile(); + return temporaryDirectoryRoot.resolve(System.nanoTime() + suffix).toFile(); + } + + public DatabaseClassifier getClassifier() { + return classifier; } /** @@ -322,4 +335,51 @@ public class ApplicationContextResource implements TestRule { } + private DatabaseNameConfiguration getDatabaseNameConfigurationAnnotation(Class<?> testClass, DatabaseClassifier classifier) { + + DatabaseNameConfiguration[] annotations = getAnnotations(testClass, DatabaseNameConfiguration.class); + + for (DatabaseNameConfiguration annotation : annotations) { + if (classifier.equals(annotation.classifier())) { + return annotation; + } + } + return null; + } + + private DatabaseVersionConfiguration getDatabaseVersionConfigurationAnnotation(Class<?> testClass, DatabaseClassifier classifier) { + + DatabaseVersionConfiguration[] annotations = getAnnotations(testClass, DatabaseVersionConfiguration.class); + + for (DatabaseVersionConfiguration annotation : annotations) { + if (classifier.equals(annotation.classifier())) { + return annotation; + } + } + return null; + } + + private CopyDatabaseConfiguration getCopyDatabaseConfigurationAnnotation(Class<?> testClass, DatabaseClassifier classifier) { + + CopyDatabaseConfiguration[] annotations = getAnnotations(testClass, CopyDatabaseConfiguration.class); + + for (CopyDatabaseConfiguration annotation : annotations) { + if (classifier.equals(annotation.classifier())) { + return annotation; + } + } + return null; + } + + private <E extends Annotation> E[] getAnnotations(Class<?> clazz, Class<E> annotationType) { + + E[] annotations = clazz.getAnnotationsByType(annotationType); + + if (annotations.length == 0 && clazz.getSuperclass() != null) { + annotations = getAnnotations(clazz.getSuperclass(), annotationType); + } + return annotations; + } + + } diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/DataSourceResource.java b/observe-services-topia/src/test/java/fr/ird/observe/services/DataSourceResource.java index 32ec9f1..d6302e1 100644 --- a/observe-services-topia/src/test/java/fr/ird/observe/services/DataSourceResource.java +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/DataSourceResource.java @@ -39,6 +39,7 @@ import fr.ird.observe.services.service.DatabaseNotFoundException; import fr.ird.observe.services.service.ObserveReferentialCache; import fr.ird.observe.test.TestHelper; import fr.ird.observe.test.spi.CopyDatabaseConfiguration; +import fr.ird.observe.test.spi.DatabaseClassifier; import fr.ird.observe.test.spi.DatabaseNameConfiguration; import fr.ird.observe.test.spi.DatabaseVersionConfiguration; import org.apache.commons.logging.Log; @@ -249,7 +250,7 @@ public class DataSourceResource implements TestRule { String dbVersionStr; - DatabaseNameConfiguration databaseNameConfiguration = testClassMethod.getAnnotation(DatabaseNameConfiguration.class); + DatabaseNameConfiguration databaseNameConfiguration = getDatabaseNameConfigurationAnnotation(testClassMethod, applicationContextResource.getClassifier()); if (databaseNameConfiguration != null) { dbName = databaseNameConfiguration.value().name(); } else { @@ -257,7 +258,7 @@ public class DataSourceResource implements TestRule { } Preconditions.checkState(!Strings.isNullOrEmpty(dbName), "Pas de nom de base spécifié"); - DatabaseVersionConfiguration databaseVersionConfiguration = testClassMethod.getAnnotation(DatabaseVersionConfiguration.class); + DatabaseVersionConfiguration databaseVersionConfiguration = getDatabaseVersionConfigurationAnnotation(testClassMethod, applicationContextResource.getClassifier()); if (databaseVersionConfiguration != null) { dbVersionStr = databaseVersionConfiguration.value(); } else { @@ -266,14 +267,14 @@ public class DataSourceResource implements TestRule { Preconditions.checkState(!Strings.isNullOrEmpty(dbVersionStr), "Pas de version de base spécifié"); dbVersion = Versions.valueOf(dbVersionStr); - CopyDatabaseConfiguration copyDatabaseConfiguration = testClassMethod.getAnnotation(CopyDatabaseConfiguration.class); + CopyDatabaseConfiguration copyDatabaseConfiguration = getCopyDatabaseConfigurationAnnotation(testClassMethod, applicationContextResource.getClassifier()); useSharedDatabase = copyDatabaseConfiguration == null; if (log.isDebugEnabled()) { log.debug("Starts " + testClass.getName() + "::" + methodName); } - testDirectory = TestHelper.newFile(methodName); + testDirectory = TestHelper.newFile(methodName + "-" + applicationContextResource.getClassifier()); Path temporaryDirectoryRoot = new File(testDirectory, "tmp").toPath(); @@ -282,8 +283,8 @@ public class DataSourceResource implements TestRule { applicationContextResource.setTemporaryDirectoryRoot(temporaryDirectoryRoot); File databasePath = useSharedDatabase - ? null - : getTestDirectory().toPath().resolve("localDb").toFile(); + ? null + : getTestDirectory().toPath().resolve("localDb").toFile(); dataSourceConfiguration = applicationContextResource.createDataSource(dbVersion, this.dbName, databasePath); @@ -306,4 +307,41 @@ public class DataSourceResource implements TestRule { applicationContextResource.setTemporaryDirectoryRoot(null); } + + private DatabaseNameConfiguration getDatabaseNameConfigurationAnnotation(Method testClassMethod, DatabaseClassifier classifier) { + + DatabaseNameConfiguration[] annotations = testClassMethod.getAnnotationsByType(DatabaseNameConfiguration.class); + + for (DatabaseNameConfiguration annotation : annotations) { + if (classifier.equals(annotation.classifier())) { + return annotation; + } + } + return null; + } + + private DatabaseVersionConfiguration getDatabaseVersionConfigurationAnnotation(Method testClassMethod, DatabaseClassifier classifier) { + + DatabaseVersionConfiguration[] annotations = testClassMethod.getAnnotationsByType(DatabaseVersionConfiguration.class); + + for (DatabaseVersionConfiguration annotation : annotations) { + if (classifier.equals(annotation.classifier())) { + return annotation; + } + } + return null; + } + + private CopyDatabaseConfiguration getCopyDatabaseConfigurationAnnotation(Method testClassMethod, DatabaseClassifier classifier) { + + CopyDatabaseConfiguration[] annotations = testClassMethod.getAnnotationsByType(CopyDatabaseConfiguration.class); + + for (CopyDatabaseConfiguration annotation : annotations) { + if (classifier.equals(annotation.classifier())) { + return annotation; + } + } + return null; + } + } diff --git a/observe-test-data/src/main/java/fr/ird/observe/test/TestHelper.java b/observe-test-data/src/main/java/fr/ird/observe/test/TestHelper.java index e5fd474..867a896 100644 --- a/observe-test-data/src/main/java/fr/ird/observe/test/TestHelper.java +++ b/observe-test-data/src/main/java/fr/ird/observe/test/TestHelper.java @@ -37,7 +37,6 @@ import org.nuiton.version.Versions; import java.io.File; import java.io.IOException; import java.io.InputStream; -import java.lang.annotation.Annotation; import java.lang.reflect.Modifier; import java.net.URL; import java.util.List; @@ -187,14 +186,4 @@ public abstract class TestHelper { } } - - public static <E extends Annotation> E getAnnotation(Class<?> clazz, Class<E> annotationType) { - - E dataSourceTestConfiguration = clazz.getAnnotation(annotationType); - - if (dataSourceTestConfiguration == null && clazz.getSuperclass() != null) { - dataSourceTestConfiguration = getAnnotation(clazz.getSuperclass(), annotationType); - } - return dataSourceTestConfiguration; - } } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 3c8af4b9318c55dbe45efad3a4718a6fc542c3f3 Author: Tony CHEMIT <chemit@codelutin.com> Date: Mon Jul 4 17:51:00 2016 +0200 In sql generator we must to keep same order of parameters values + use default primitive values --- .../synchro/InsertSqlStatementGenerator.java | 34 +++++++++++----------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/InsertSqlStatementGenerator.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/InsertSqlStatementGenerator.java index 312def0..9dcd36c 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/InsertSqlStatementGenerator.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/InsertSqlStatementGenerator.java @@ -13,6 +13,8 @@ import org.nuiton.util.beans.BinderFactory; import java.util.Collection; import java.util.Date; import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.List; import java.util.Map; import java.util.Set; @@ -71,7 +73,7 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { Set<String> propertyNamesSet = metadataEntity.getProperties().keySet(); this.simplePropertyNames = propertyNamesSet.toArray(new String[propertyNamesSet.size()]); Set<String> manyToOneAssociationNamesSet = metadataEntity.getManyToOneAssociations().keySet(); - this.manyToOneAssociationNames = propertyNamesSet.toArray(new String[manyToOneAssociationNamesSet.size()]); + this.manyToOneAssociationNames = manyToOneAssociationNamesSet.toArray(new String[manyToOneAssociationNamesSet.size()]); Map<String, String> manyToManyAssociationsMap = metadataEntity.getManyToManyAssociations(); this.manyToManyAssociations = new LinkedHashSet<>(); @@ -88,15 +90,15 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { public String generateSql(R referentialDto) { - Set<String> parameters = new LinkedHashSet<>(); + List<String> parameters = new LinkedList<>(); addStringParameter(referentialDto.getId(), parameters); addOtherTypeParameter(referentialDto.getVersion(), parameters); addDateParameter(referentialDto.getCreateDate(), parameters); - Map<String, Object> simpleParameters = binder.obtainProperties(referentialDto, true, simplePropertyNames); - for (Object parameterValue : simpleParameters.values()) { - + Map<String, Object> simpleParameters = binder.obtainProperties(referentialDto, true, true, simplePropertyNames); + for (String simplePropertyName : simplePropertyNames) { + Object parameterValue = simpleParameters.get(simplePropertyName); if (parameterValue == null) { addNullParameter(parameters); continue; @@ -114,12 +116,11 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { continue; } addOtherTypeParameter(parameterValue, parameters); - } - Map<String, Object> compositionParameters = binder.obtainProperties(referentialDto, true, manyToOneAssociationNames); - for (Object parameterValue : compositionParameters.values()) { - + Map<String, Object> manyToOneParameters = binder.obtainProperties(referentialDto, true, true, manyToOneAssociationNames); + for (String manyToOneAssociationName : manyToOneAssociationNames) { + Object parameterValue = manyToOneParameters.get(manyToOneAssociationName); if (parameterValue == null) { addNullParameter(parameters); continue; @@ -131,7 +132,6 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { if (parameterValue instanceof ReferentialReference) { addReferentialReferenceParameter((ReferentialReference) parameterValue, parameters); } - } String result = String.format(INSERT_STATEMENT, @@ -201,31 +201,31 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { return columnNames; } - private void addNullParameter(Set<String> parameters) { + private void addNullParameter(List<String> parameters) { parameters.add("NULL"); } - private void addStringParameter(String parameter, Set<String> parameters) { + private void addStringParameter(String parameter, List<String> parameters) { parameters.add("'" + parameter.replaceAll("'", "''") + "'"); } - private void addDateParameter(Date parameter, Set<String> parameters) { + private void addDateParameter(Date parameter, List<String> parameters) { parameters.add("'" + parameter + "'"); } - private void addEnumParameter(Enum parameter, Set<String> parameters) { + private void addEnumParameter(Enum parameter, List<String> parameters) { parameters.add("" + parameter.ordinal()); } - private void addOtherTypeParameter(Object parameter, Set<String> parameters) { + private void addOtherTypeParameter(Object parameter, List<String> parameters) { parameters.add("" + parameter); } - private void addReferentialReferenceParameter(ReferentialReference parameter, Set<String> parameters) { + private void addReferentialReferenceParameter(ReferentialReference parameter, List<String> parameters) { addStringParameter(parameter.getId(), parameters); } - private void addReferentialDtoParameter(ReferentialDto parameter, Set<String> parameters) { + private void addReferentialDtoParameter(ReferentialDto parameter, List<String> parameters) { addStringParameter(parameter.getId(), parameters); } } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 22900a8fdd0e7391fd701baaf1b3b287dca2ecd0 Author: Tony CHEMIT <chemit@codelutin.com> Date: Mon Jul 4 17:52:27 2016 +0200 Do not treat LastUpdateDate entity as an referential one --- ...nidirectionalReferentialSynchronizeRemoteServiceTopia.java | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) 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 9f65167..ce860fc 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 @@ -35,8 +35,15 @@ public class UnidirectionalReferentialSynchronizeRemoteServiceTopia extends Obse @Override public RemoteReferentialDiff getReferentialDifferential(LocalReferentialStates localReferentialStates) { + if (log.isTraceEnabled()) { + log.trace("getReferentialDifferential(" + localReferentialStates + ")"); + } + RemoteReferentialDiff result = new RemoteReferentialDiff(); for (ObserveEntityEnum referenceEntity : Entities.REFERENCE_ENTITIES) { + if (ObserveEntityEnum.LastUpdateDate.equals(referenceEntity)) { + continue; + } Class entityType = referenceEntity.getContract(); getReferentialDifferential0(referenceEntity.name(), entityType, localReferentialStates, result); } @@ -71,7 +78,7 @@ public class UnidirectionalReferentialSynchronizeRemoteServiceTopia extends Obse for (E centralReferentialEntity : dao) { String id = centralReferentialEntity.getTopiaId(); - Long localVersion = localReferentialVersions.get(id); + Long localVersion = localReferentialVersions == null ? null : localReferentialVersions.get(id); if (localVersion == null) { @@ -100,7 +107,7 @@ public class UnidirectionalReferentialSynchronizeRemoteServiceTopia extends Obse } // entités supprimées - Set<String> idsToDelete = new LinkedHashSet<>(localReferentialVersions.keySet()); + Set<String> idsToDelete = localReferentialVersions == null ? new LinkedHashSet<>() : new LinkedHashSet<>(localReferentialVersions.keySet()); List<String> centralIds = dao.findAllIds(); idsToDelete.removeAll(centralIds); -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 6f0d6a0f332dd091c2d0dc6ec60ec7c287322aa4 Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Jul 5 12:45:49 2016 +0200 Quelques corrections suite au test du moteur de synchronisation (See #7739) --- .../actions/synchro/RemoteReferentialDiff.java | 13 ++-- ...UnidirectionalReferentialSynchronizeEngine.java | 37 +++++---- ...ectionalReferentialSynchronizeLocalService.java | 19 ++++- .../synchro/ReplaceSqlStatementGenerator.java | 44 +++++------ ...nalReferentialSynchronizeLocalServiceTopia.java | 23 +++++- ...alReferentialSynchronizeRemoteServiceTopia.java | 6 +- .../synchro/UpdateSqlStatementGenerator.java | 89 ++++++++++++---------- 7 files changed, 133 insertions(+), 98 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 83787d2..8900844 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,7 @@ import fr.ird.observe.services.dto.referential.ReferentialReference; import java.io.Serializable; import java.util.Collection; +import java.util.HashSet; import java.util.LinkedHashSet; import java.util.Set; @@ -32,9 +33,9 @@ public class RemoteReferentialDiff implements Serializable { */ private final Multimap<String, ReferentialDto> referentialsToUpdate; /** - * Les références de référentiels à supprimer (indexé par nom de référentiel). + * Les identifiants de référentiels à supprimer (indexé par nom de référentiel). */ - private final Multimap<String, ReferentialReference> referentialsToRemove; + private final Multimap<String, String> referentialsToRemove; /** * Les références de référentiels à changer (ils sont devenus obsolètes) (indexé par nom de référentiel). */ @@ -63,8 +64,8 @@ public class RemoteReferentialDiff implements Serializable { return (Collection) referentialsToUpdate.get(referentialName); } - public <R extends ReferentialDto> Collection<ReferentialReference<R>> getReferentialsToRemove(String referentialName) { - return (Collection)referentialsToRemove.get(referentialName); + public Set<String> getReferentialsToRemove(String referentialName) { + return new HashSet<>(referentialsToRemove.get(referentialName)); } public <R extends ReferentialDto> Collection<ReferentialReference<R>> getReferentialsToFix(String referentialName) { @@ -85,9 +86,9 @@ public class RemoteReferentialDiff implements Serializable { referentialsToUpdate.put(referentialName, referentialDto); } - void addReferentialToDelete(String referentialName, ReferentialReference referentialReference) { + void addReferentialToDelete(String referentialName, String id) { referentialNames.add(referentialName); - referentialsToRemove.put(referentialName, referentialReference); + referentialsToRemove.put(referentialName, id); } void addReferentialToFix(String referentialName, ReferentialReference 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 index 44f22f6..031241d 100644 --- 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 @@ -62,20 +62,16 @@ public class UnidirectionalReferentialSynchronizeEngine { referentialsToUpdate.forEach(builder::entityToUpdate); } - Collection<ReferentialReference<R>> referentialsToRemove = remoteReferentialDiff.getReferentialsToRemove(referentialName); - Collection<ReferentialReference<R>> blockingReferentialsToRemove = null; - if (CollectionUtils.isNotEmpty(referentialsToRemove)) { + Set<String> idsToRemove = remoteReferentialDiff.getReferentialsToRemove(referentialName); + Set<String> blockingIdsToRemove = null; - Set<String> idsToRemove = referentialsToRemove.stream() - .map(ReferentialReference::getId) - .collect(Collectors.toCollection(LinkedHashSet::new)); + if (CollectionUtils.isNotEmpty(idsToRemove)) { - Set<String> blockingIdsToRemove = localService.filterIdsUsedInLocalSource(referentialName, idsToRemove); + Set<String> blockingIdsToRemoveFromLocal = localService.filterIdsUsedInLocalSource(referentialName, idsToRemove); - - blockingReferentialsToRemove = referentialsToRemove + blockingIdsToRemove = idsToRemove .stream() - .filter(referentialReference -> blockingIdsToRemove.contains(referentialReference.getId())) + .filter(blockingIdsToRemoveFromLocal::contains) .collect(Collectors.toSet()); idsToRemove.removeAll(blockingIdsToRemove); @@ -94,16 +90,16 @@ public class UnidirectionalReferentialSynchronizeEngine { Set<String> blockingIdsToReplace = localService.filterIdsUsedInLocalSource(referentialName, idsToReplace); - blockingReferentialsToReplace = referentialsToRemove + blockingReferentialsToReplace = referentialsToReplace .stream() .filter(referentialReference -> blockingIdsToReplace.contains(referentialReference.getId())) .collect(Collectors.toSet()); } - boolean needCallbackForRemove = CollectionUtils.isNotEmpty(blockingReferentialsToRemove); - boolean needCallbackToReplace = CollectionUtils.isNotEmpty(blockingReferentialsToReplace); - boolean needCallback = needCallbackForRemove || needCallbackToReplace; + boolean needCallbackForRemove = CollectionUtils.isNotEmpty(blockingIdsToRemove); + boolean needCallbackForReplace = CollectionUtils.isNotEmpty(blockingReferentialsToReplace); + boolean needCallback = needCallbackForRemove || needCallbackForReplace; if (needCallback) { // calcul de l'univers de référentiels disponibles pour les remplacements @@ -113,8 +109,9 @@ public class UnidirectionalReferentialSynchronizeEngine { if (needCallbackForRemove) { - CallbackRequest callbackRequest = CallbackRequest.of(referentialName, blockingReferentialsToRemove, availableReferentials); - Map<String, String> referentialsToRemoveIds = callback.askUserToReplaceDisabledReferentials(callbackRequest); + Set<ReferentialReference<R>> blockingReferentialsToRemove = localService.getLocalSourceReferentialToDelete(referentialName, blockingIdsToRemove); + CallbackRequest<R> callbackRequest = CallbackRequest.of(referentialName, blockingReferentialsToRemove, availableReferentials); + Map<String, String> referentialsToRemoveIds = callback.askUserToReplaceRemovedReferentials(callbackRequest); for (Map.Entry<String, String> entry : referentialsToRemoveIds.entrySet()) { builder.entityToReplace(entry.getKey(), entry.getValue()); builder.entityToRemove(entry.getKey()); @@ -122,9 +119,9 @@ public class UnidirectionalReferentialSynchronizeEngine { } - if (needCallbackToReplace) { + if (needCallbackForReplace) { - CallbackRequest callbackRequest = CallbackRequest.of(referentialName, referentialsToReplace, availableReferentials); + CallbackRequest<R> 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()); @@ -141,9 +138,9 @@ public class UnidirectionalReferentialSynchronizeEngine { public interface Callback { - Map<String, String> askUserToReplaceRemovedReferentials(CallbackRequest request); + <R extends ReferentialDto> Map<String, String> askUserToReplaceRemovedReferentials(CallbackRequest<R> request); - Map<String, String> askUserToReplaceDisabledReferentials(CallbackRequest request); + <R extends ReferentialDto> Map<String, String> askUserToReplaceDisabledReferentials(CallbackRequest<R> request); } 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 7a08962..bdc0026 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 @@ -2,13 +2,13 @@ package fr.ird.observe.services.service.actions.synchro; import fr.ird.observe.services.ObserveService; import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; import fr.ird.observe.services.spi.NoDataAccess; import fr.ird.observe.services.spi.PostRequest; import fr.ird.observe.services.spi.ReadReferentialPermission; import fr.ird.observe.services.spi.Write; import fr.ird.observe.services.spi.WriteReferentialPermission; -import java.util.Collection; import java.util.Set; /** @@ -34,16 +34,29 @@ public interface UnidirectionalReferentialSynchronizeLocalService extends Observ * les identifiants sont passés en paramètres qui sont réellement utilisés dans la source locale. * * @param referentialName le nom du référentiel - * @param ids l'identifiant du référentiel dont on recherche le nombre d'utilisation + * @param ids les identifiants du référentiel dont on recherche le nombre d'utilisation * @return les identifiants des référentiels passés en paramètres qui sont réellement utilisés dans la source locale. */ @ReadReferentialPermission - Set<String> filterIdsUsedInLocalSource(String referentialName, Collection<String> ids); + Set<String> filterIdsUsedInLocalSource(String referentialName, Set<String> ids); + + /** + * Pour récupérer les références sur les référentiels d'un certain type à supprimer, + * cet ensemble servira à les afficher dans l'interface graphique pour effectuer le remplacement. + * + * @param ids les identifiants des référentiels à supprimer + * @param referentialName le nom du référentiel à récupérer + * @param <R> type des référentiels à récupérer + * @return l'ensemble des références de référentiel à supprimer. + */ + @ReadReferentialPermission + <R extends ReferentialDto> Set<ReferentialReference<R>> getLocalSourceReferentialToDelete(String referentialName, Set<String> ids); /** * Pour produire le code sql à partir de la demande pour un référentiel donné. * * @param request la demande des actions à produire pour un référentiel donné + * @param <R> type des référentiels à traiter * @return l'ensemble des requètes sql à appliquer. */ @NoDataAccess diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/ReplaceSqlStatementGenerator.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/ReplaceSqlStatementGenerator.java index e0d6e9d..919959a 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/ReplaceSqlStatementGenerator.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/ReplaceSqlStatementGenerator.java @@ -21,7 +21,7 @@ public class ReplaceSqlStatementGenerator { /** Logger. */ private static final Log log = LogFactory.getLog(ReplaceSqlStatementGenerator.class); - private static final String MANY_TO_ONE_ASSOCIATION_UPDATE_STATEMENT = "UPDATE %s.%s SET %s = '%s', SET topiaVersion = topiaVersion + 1 WHERE topiaId = '%s';\n"; + private static final String MANY_TO_ONE_ASSOCIATION_UPDATE_STATEMENT = "UPDATE %s.%s SET %s = '%s', topiaVersion = topiaVersion + 1 WHERE %s = '%s';\n"; private static final String MANY_TO_MANY_ASSOCIATION_UPDATE_STATEMENT = "UPDATE %s.%s SET %s = '%s' WHERE %s = '%s';\n"; /** @@ -58,33 +58,15 @@ public class ReplaceSqlStatementGenerator { for (ReplacementStruct replacementStruct : manyToOneAssociationReplacements) { - String sql = String.format(MANY_TO_ONE_ASSOCIATION_UPDATE_STATEMENT, - replacementStruct.schemaName, - replacementStruct.tableName, - replacementStruct.columnName, - replacementId, - sourceId); - if (log.isDebugEnabled()) { - log.debug("sql: " + sql); - } + String sql = generateSqlStatement(MANY_TO_ONE_ASSOCIATION_UPDATE_STATEMENT, sourceId, replacementId, replacementStruct); builder.append(sql); } for (ReplacementStruct replacementStruct : manyToManyAssociationReplacements) { - String sql = String.format(MANY_TO_MANY_ASSOCIATION_UPDATE_STATEMENT, - replacementStruct.schemaName, - replacementStruct.tableName, - replacementStruct.columnName, - replacementId, - replacementStruct.columnName, - sourceId); - if (log.isDebugEnabled()) { - log.debug("sql: " + sql); - } + String sql = generateSqlStatement(MANY_TO_MANY_ASSOCIATION_UPDATE_STATEMENT, sourceId, replacementId, replacementStruct); builder.append(sql); - } return builder.toString(); @@ -101,7 +83,7 @@ public class ReplaceSqlStatementGenerator { .filter(entry -> entry.getValue().equals(referentialName)) .map(entry -> new ReplacementStruct(metadataEntity.getDbSchemaName(), metadataEntity.getDbTableName(), - metadataEntity.getDbColumnName(entry.getValue()))) + metadataEntity.getDbColumnName(entry.getKey()))) .collect(Collectors.toList())); } @@ -120,7 +102,7 @@ public class ReplaceSqlStatementGenerator { .filter(entry -> entry.getValue().equals(referentialName)) .map(entry -> new ReplacementStruct(metadataEntity.getDbSchemaName(), metadataEntity.getBdManyToManyAssociationTableName(entry.getValue()), - metadataEntity.getDbColumnName(entry.getValue()))) + metadataEntity.getDbColumnName(entry.getKey()))) .collect(Collectors.toList())); } @@ -129,4 +111,20 @@ public class ReplaceSqlStatementGenerator { } + private String generateSqlStatement(String sqlPattern, String sourceId, String replacementId, ReplacementStruct replacementStruct) { + + String sql = String.format(sqlPattern, + replacementStruct.schemaName, + replacementStruct.tableName, + replacementStruct.columnName, + replacementId, + replacementStruct.columnName, + sourceId); + if (log.isDebugEnabled()) { + log.debug("sql: " + sql); + } + return sql; + + } + } 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 7d8a7dc..36b8049 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 @@ -6,6 +6,7 @@ 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.ReferentialReference; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuiton.topia.persistence.TopiaDao; @@ -17,7 +18,7 @@ import org.nuiton.topia.persistence.support.TopiaSqlWork; import java.sql.Connection; import java.sql.SQLException; import java.sql.Statement; -import java.util.Collection; +import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; @@ -54,7 +55,7 @@ public class UnidirectionalReferentialSynchronizeLocalServiceTopia extends Obser } @Override - public Set<String> filterIdsUsedInLocalSource(String referentialName, Collection<String> ids) { + public Set<String> filterIdsUsedInLocalSource(String referentialName, Set<String> ids) { if (log.isTraceEnabled()) { log.trace("filterIdsUsedInLocalSource(" + referentialName + ", " + ids + ")"); @@ -74,6 +75,15 @@ public class UnidirectionalReferentialSynchronizeLocalServiceTopia extends Obser } @Override + public <R extends ReferentialDto> Set<ReferentialReference<R>> getLocalSourceReferentialToDelete(String referentialName, Set<String> ids) { + + ObserveEntityEnum entityEnum = ObserveEntityEnum.valueOf(referentialName); + Class entityType = entityEnum.getContract(); + return getLocalSourceReferentialToDelete0(entityType, ids); + + } + + @Override public <R extends ReferentialDto> Set<String> generateSqlRequests(UnidirectionalReferentialSynchronizeRequest<R> request) { if (log.isTraceEnabled()) { @@ -111,7 +121,7 @@ public class UnidirectionalReferentialSynchronizeLocalServiceTopia extends Obser if (request.withReferentialToReplace()) { - ReplaceSqlStatementGenerator sqlStatementGenerator = new ReplaceSqlStatementGenerator(metadataModel, referentialName); + ReplaceSqlStatementGenerator sqlStatementGenerator = new ReplaceSqlStatementGenerator(metadataModel, referentialName); for (Map.Entry<String, String> entry : request.getReferentialToReplace().entrySet()) { String sql = sqlStatementGenerator.generateSql(entry.getKey(), entry.getValue()); result.add(sql); @@ -167,6 +177,13 @@ public class UnidirectionalReferentialSynchronizeLocalServiceTopia extends Obser } + private <E extends ObserveReferentialEntity> Set<E> getLocalSourceReferentialToDelete0(Class<E> entityType, Set<String> ids) { + + TopiaDao<E> dao = getTopiaPersistenceContext().getDao(entityType); + return new HashSet<>(dao.forTopiaIdIn(ids).findAll()); + + } + private static class ApplySqlRequestWork implements TopiaSqlWork { private static final int BATCH_SIZE = 100; 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 ce860fc..fb2dcc6 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 @@ -113,9 +113,9 @@ public class UnidirectionalReferentialSynchronizeRemoteServiceTopia extends Obse idsToDelete.removeAll(centralIds); for (String id : idsToDelete) { - E e = dao.forTopiaIdEquals(id).findUnique(); - ReferentialReference<ReferentialDto> referentialReference = binderEngine.transformEntityToReferentialReferenceDto(referentialLocale, e); - result.addReferentialToDelete(entityName, referentialReference); + + // entité supprimée, il faudra que l'utilisateur la change + result.addReferentialToDelete(entityName, id); } } diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UpdateSqlStatementGenerator.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UpdateSqlStatementGenerator.java index 365e0f4..ff34ac9 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UpdateSqlStatementGenerator.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UpdateSqlStatementGenerator.java @@ -29,7 +29,7 @@ public class UpdateSqlStatementGenerator<R extends ReferentialDto> { /** Logger. */ private static final Log log = LogFactory.getLog(UpdateSqlStatementGenerator.class); - private static final String UPDATE_STATEMENT = "UPDATE %s.%s %s WHERE topiaId ='%s';\n"; + private static final String UPDATE_STATEMENT = "UPDATE %s.%s SET %s WHERE topiaId ='%s';\n"; private static final String MANY_TO_MANY_ASSOCIATION_DELETE_STATEMENT = "DELETE FROM %s.%s WHERE %s = '%s';\n"; private static final String MANY_TO_MANY_ASSOCIATION_INSERT_STATEMENT = "INSERT INTO %s.%s(%s, %s) VALUES ('%s', '%s');\n"; @@ -70,10 +70,12 @@ public class UpdateSqlStatementGenerator<R extends ReferentialDto> { public UpdateSqlStatementGenerator(TopiaMetadataEntity metadataEntity, Class<R> dtoType) { this.schemaName = metadataEntity.getDbSchemaName(); this.tableName = metadataEntity.getDbTableName(); + Set<String> simplePropertyNamesSet = metadataEntity.getProperties().keySet(); this.simplePropertyNames = simplePropertyNamesSet.toArray(new String[simplePropertyNamesSet.size()]); + Set<String> manyToOneAssociationNamesSet = metadataEntity.getManyToOneAssociations().keySet(); - this.manyToOneAssociationNames = simplePropertyNamesSet.toArray(new String[manyToOneAssociationNamesSet.size()]); + this.manyToOneAssociationNames = manyToOneAssociationNamesSet.toArray(new String[manyToOneAssociationNamesSet.size()]); Map<String, String> manyToManyAssociationsMap = metadataEntity.getManyToManyAssociations(); this.manyToManyAssociations = new LinkedHashSet<>(); @@ -92,54 +94,61 @@ public class UpdateSqlStatementGenerator<R extends ReferentialDto> { StringBuilder parameters = new StringBuilder(); - addStringParameter(TopiaEntity.PROPERTY_TOPIA_ID, referentialDto.getId(), parameters); addOtherTypeParameter(TopiaEntity.PROPERTY_TOPIA_VERSION, referentialDto.getVersion(), parameters); addDateParameter(TopiaEntity.PROPERTY_TOPIA_CREATE_DATE, referentialDto.getCreateDate(), parameters); - Map<String, Object> simpleProperties = binder.obtainProperties(referentialDto, true, simplePropertyNames); - for (Map.Entry<String, Object> entry : simpleProperties.entrySet()) { + if (simplePropertyNames.length > 0) { - String simplePropertyName = entry.getKey(); - String columnName = columnNames.get(simplePropertyName); - Object simplePropertyValue = entry.getValue(); + Map<String, Object> simpleProperties = binder.obtainProperties(referentialDto, true, simplePropertyNames); + for (Map.Entry<String, Object> entry : simpleProperties.entrySet()) { + + String simplePropertyName = entry.getKey(); + String columnName = columnNames.get(simplePropertyName); + Object simplePropertyValue = entry.getValue(); + + if (simplePropertyValue == null) { + addNullParameter(columnName, parameters); + continue; + } + if (simplePropertyValue instanceof String) { + addStringParameter(columnName, (String) simplePropertyValue, parameters); + continue; + } + if (simplePropertyValue instanceof Date) { + addDateParameter(columnName, (Date) simplePropertyValue, parameters); + continue; + } + if (simplePropertyValue instanceof Enum) { + addEnumParameter(columnName, (Enum) simplePropertyValue, parameters); + continue; + } + addOtherTypeParameter(columnName, simplePropertyValue, parameters); - if (simplePropertyValue == null) { - addNullParameter(columnName, parameters); - continue; - } - if (simplePropertyValue instanceof String) { - addStringParameter(columnName, (String) simplePropertyValue, parameters); - continue; - } - if (simplePropertyValue instanceof Date) { - addDateParameter(columnName, (Date) simplePropertyValue, parameters); - continue; - } - if (simplePropertyValue instanceof Enum) { - addEnumParameter(columnName, (Enum) simplePropertyValue, parameters); - continue; } - addOtherTypeParameter(columnName, simplePropertyValue, parameters); } - Map<String, Object> manyToOneAssociations = binder.obtainProperties(referentialDto, true, manyToOneAssociationNames); - for (Map.Entry<String, Object> entry : manyToOneAssociations.entrySet()) { + if (manyToOneAssociationNames.length > 0) { - String manyToOneAssociationName = entry.getKey(); - String columnName = columnNames.get(manyToOneAssociationName); - Object manyToOneAssociationValue = entry.getValue(); + Map<String, Object> manyToOneAssociations = binder.obtainProperties(referentialDto, true, manyToOneAssociationNames); + for (Map.Entry<String, Object> entry : manyToOneAssociations.entrySet()) { + + String manyToOneAssociationName = entry.getKey(); + String columnName = columnNames.get(manyToOneAssociationName); + Object manyToOneAssociationValue = entry.getValue(); + + if (manyToOneAssociationValue == null) { + addNullParameter(columnName, parameters); + continue; + } + if (manyToOneAssociationValue instanceof ReferentialDto) { + addReferentialDtoParameter(columnName, (ReferentialDto) manyToOneAssociationValue, parameters); + continue; + } + if (manyToOneAssociationValue instanceof ReferentialReference) { + addReferentialReferenceParameter(columnName, (ReferentialReference) manyToOneAssociationValue, parameters); + } - if (manyToOneAssociationValue == null) { - addNullParameter(columnName, parameters); - continue; - } - if (manyToOneAssociationValue instanceof ReferentialDto) { - addReferentialDtoParameter(columnName, (ReferentialDto) manyToOneAssociationValue, parameters); - continue; - } - if (manyToOneAssociationValue instanceof ReferentialReference) { - addReferentialReferenceParameter(columnName, (ReferentialReference) manyToOneAssociationValue, parameters); } } @@ -254,6 +263,6 @@ public class UpdateSqlStatementGenerator<R extends ReferentialDto> { } private void addParameter0(String columnName, String value, StringBuilder parameters) { - parameters.append(", SET ").append(columnName).append(" = ").append(value); + parameters.append(", ").append(columnName).append(" = ").append(value); } } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 07f81e08f92b57457f539866370d255c1380c656 Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Jul 5 16:15:24 2016 +0200 Test de syncrhonisation mise en place + correction nom de base de test --- .../UnidirectionalSynchronizeReferentialTest.java | 129 +++++++++++++++++++-- .../java/fr/ird/observe/test/DatabaseName.java | 2 +- .../resources/db/4.903/dataForTestSeine.sql.gz | Bin 440721 -> 441224 bytes ...taForTestUnidirectionalReferentialSyncho.sql.gz | Bin 441281 -> 0 bytes ...aForTestUnidirectionalReferentialSynchro.sql.gz | Bin 0 -> 441247 bytes 5 files changed, 118 insertions(+), 13 deletions(-) diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalSynchronizeReferentialTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalSynchronizeReferentialTest.java index d81e72c..6a00f78 100644 --- a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalSynchronizeReferentialTest.java +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalSynchronizeReferentialTest.java @@ -1,6 +1,8 @@ package fr.ird.observe.services.service.actions.synchro; import com.google.common.collect.ImmutableMap; +import fr.ird.observe.ObserveEntityEnum; +import fr.ird.observe.entities.Entities; import fr.ird.observe.services.ApplicationContextResource; import fr.ird.observe.services.DataSourceResource; import fr.ird.observe.services.dto.referential.ReferentialDto; @@ -11,12 +13,16 @@ import fr.ird.observe.test.spi.CopyDatabaseConfiguration; import fr.ird.observe.test.spi.DatabaseClassifier; import fr.ird.observe.test.spi.DatabaseNameConfiguration; import fr.ird.observe.test.spi.DatabaseVersionConfiguration; +import org.apache.commons.lang3.tuple.Pair; +import org.junit.Assert; import org.junit.Before; import org.junit.ClassRule; import org.junit.Rule; import org.junit.Test; +import java.util.Collection; import java.util.Map; +import java.util.Set; /** * Created on 04/07/16. @@ -31,13 +37,13 @@ public class UnidirectionalSynchronizeReferentialTest extends AbstractServiceTop @Rule public final DataSourceResource dataSourceResourceCentral = new DataSourceResource(applicationContextResourceCentral); - private UnidirectionalReferentialSynchronizeEngine referentialSynchronizeEngine; + private UnidirectionalReferentialSynchronizeLocalService localService; + private UnidirectionalReferentialSynchronizeRemoteService remoteService; @Before public void setUp() throws Exception { - UnidirectionalReferentialSynchronizeLocalService localService = dataSourceResource.newService(UnidirectionalReferentialSynchronizeLocalService.class); - UnidirectionalReferentialSynchronizeRemoteService remoteService = dataSourceResourceCentral.newService(UnidirectionalReferentialSynchronizeRemoteService.class); - referentialSynchronizeEngine = new UnidirectionalReferentialSynchronizeEngine(localService, remoteService); + localService = dataSourceResource.newService(UnidirectionalReferentialSynchronizeLocalService.class); + remoteService = dataSourceResourceCentral.newService(UnidirectionalReferentialSynchronizeRemoteService.class); } @DatabaseNameConfiguration(DatabaseName.empty_h2) @@ -47,7 +53,7 @@ public class UnidirectionalSynchronizeReferentialTest extends AbstractServiceTop @Test public void testSynchronizeFromEmptyDatabase() { - referentialSynchronizeEngine.run(new UnidirectionalReferentialSynchronizeEngine.Callback() { + UnidirectionalReferentialSynchronizeEngine.Callback callback = new UnidirectionalReferentialSynchronizeEngine.Callback() { @Override public Map<String, String> askUserToReplaceRemovedReferentials(UnidirectionalReferentialSynchronizeEngine.CallbackRequest request) { @@ -59,7 +65,27 @@ public class UnidirectionalSynchronizeReferentialTest extends AbstractServiceTop throw new IllegalStateException(); } - }); + }; + UnidirectionalReferentialSynchronizeEngine referentialSynchronizeEngine = new UnidirectionalReferentialSynchronizeEngine(localService, remoteService, callback); + UnidirectionalReferentialSynchronizeResult result = referentialSynchronizeEngine.call(); + + Assert.assertNotNull(result); + Set<String> referentialNames = result.getReferentialNames(); + + Assert.assertNotNull(referentialNames); + Assert.assertFalse(referentialNames.isEmpty()); + + for (ObserveEntityEnum referenceEntity : Entities.REFERENCE_ENTITIES) { + if (ObserveEntityEnum.LastUpdateDate.equals(referenceEntity)) { + continue; + } + Assert.assertTrue(referentialNames.contains(referenceEntity.name())); + Assert.assertTrue(result.getReferentialUpdated(referenceEntity.name()).isEmpty()); + Assert.assertTrue(result.getReferentialRemoved(referenceEntity.name()).isEmpty()); + Assert.assertTrue(result.getReferentialReplaced(referenceEntity.name()).isEmpty()); + Assert.assertFalse(result.getReferentialAdded(referenceEntity.name()).isEmpty()); + } + } @DatabaseNameConfiguration(DatabaseName.dataForTestSeine) @@ -69,7 +95,7 @@ public class UnidirectionalSynchronizeReferentialTest extends AbstractServiceTop @Test public void testSynchronizeWithNochange() { - referentialSynchronizeEngine.run(new UnidirectionalReferentialSynchronizeEngine.Callback() { + UnidirectionalReferentialSynchronizeEngine.Callback callback = new UnidirectionalReferentialSynchronizeEngine.Callback() { @Override public Map<String, String> askUserToReplaceRemovedReferentials(UnidirectionalReferentialSynchronizeEngine.CallbackRequest request) { @@ -81,17 +107,35 @@ public class UnidirectionalSynchronizeReferentialTest extends AbstractServiceTop throw new IllegalStateException(); } - }); + }; + UnidirectionalReferentialSynchronizeEngine referentialSynchronizeEngine = new UnidirectionalReferentialSynchronizeEngine(localService, remoteService, callback); + UnidirectionalReferentialSynchronizeResult result = referentialSynchronizeEngine.call(); + + Assert.assertNotNull(result); + Set<String> referentialNames = result.getReferentialNames(); + Assert.assertNotNull(referentialNames); + Assert.assertTrue(referentialNames.isEmpty()); + + for (ObserveEntityEnum referenceEntity : Entities.REFERENCE_ENTITIES) { + if (ObserveEntityEnum.LastUpdateDate.equals(referenceEntity)) { + continue; + } + Assert.assertTrue(result.getReferentialUpdated(referenceEntity.name()).isEmpty()); + Assert.assertTrue(result.getReferentialRemoved(referenceEntity.name()).isEmpty()); + Assert.assertTrue(result.getReferentialReplaced(referenceEntity.name()).isEmpty()); + Assert.assertTrue(result.getReferentialAdded(referenceEntity.name()).isEmpty()); + } + } @DatabaseNameConfiguration(DatabaseName.dataForTestSeine) @CopyDatabaseConfiguration - @DatabaseNameConfiguration(value = DatabaseName.dataForTestUnidirectionalReferentialSyncho, classifier = DatabaseClassifier.CENTRAL) + @DatabaseNameConfiguration(value = DatabaseName.dataForTestUnidirectionalReferentialSynchro, classifier = DatabaseClassifier.CENTRAL) @DatabaseVersionConfiguration(value = ObserveFixtures.DEFAULT_VERSION, classifier = DatabaseClassifier.CENTRAL) @Test public void testSynchronizeWithAllChanges() { - referentialSynchronizeEngine.run(new UnidirectionalReferentialSynchronizeEngine.Callback() { + UnidirectionalReferentialSynchronizeEngine.Callback callback = new UnidirectionalReferentialSynchronizeEngine.Callback() { @Override public <R extends ReferentialDto> Map<String, String> askUserToReplaceRemovedReferentials(UnidirectionalReferentialSynchronizeEngine.CallbackRequest<R> request) { @@ -108,11 +152,72 @@ public class UnidirectionalSynchronizeReferentialTest extends AbstractServiceTop String referentialName = request.getReferentialName(); switch (referentialName) { case "Vessel": - return ImmutableMap.<String, String>builder().put("fr.ird.observe.entities.referentiel.Vessel#1429515781110#0.833177504362538", "fr.ird.observe.entities.referentiel.Vessel#1429515780436#0.000696399947628379").build(); + return ImmutableMap.<String, String>builder().put("fr.ird.observe.entities.referentiel.Vessel#1306847717532#0.7435948873477364", "fr.ird.observe.entities.referentiel.Vessel#1429515781110#0.833177504362538").build(); } throw new IllegalStateException(); } - }); + }; + + UnidirectionalReferentialSynchronizeEngine referentialSynchronizeEngine = new UnidirectionalReferentialSynchronizeEngine(localService, remoteService, callback); + UnidirectionalReferentialSynchronizeResult result = referentialSynchronizeEngine.call(); + + Assert.assertNotNull(result); + Set<String> referentialNames = result.getReferentialNames(); + Assert.assertNotNull(referentialNames); + Assert.assertFalse(referentialNames.isEmpty()); + { + Assert.assertTrue(referentialNames.contains(ObserveEntityEnum.VesselActivitySeine.name())); + Assert.assertTrue(result.getReferentialAdded(ObserveEntityEnum.VesselActivitySeine.name()).isEmpty()); + Collection<String> referentialUpdated = result.getReferentialUpdated(ObserveEntityEnum.VesselActivitySeine.name()); + Assert.assertFalse(referentialUpdated.isEmpty()); + Assert.assertEquals(1, referentialUpdated.size()); + Assert.assertTrue(referentialUpdated.contains("fr.ird.observe.entities.referentiel.seine.VesselActivitySeine#1239832675369#0.12552908048322586")); + + Assert.assertTrue(result.getReferentialRemoved(ObserveEntityEnum.VesselActivitySeine.name()).isEmpty()); + Assert.assertTrue(result.getReferentialReplaced(ObserveEntityEnum.VesselActivitySeine.name()).isEmpty()); + } + + { + Assert.assertTrue(referentialNames.contains(ObserveEntityEnum.Species.name())); + + Assert.assertTrue(result.getReferentialAdded(ObserveEntityEnum.Species.name()).isEmpty()); + Collection<String> referentialUpdated = result.getReferentialUpdated(ObserveEntityEnum.Species.name()); + Assert.assertFalse(referentialUpdated.isEmpty()); + Assert.assertEquals(1, referentialUpdated.size()); + Assert.assertTrue(referentialUpdated.contains("fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569")); + + Assert.assertTrue(result.getReferentialRemoved(ObserveEntityEnum.Species.name()).isEmpty()); + Assert.assertTrue(result.getReferentialReplaced(ObserveEntityEnum.Species.name()).isEmpty()); + + } + { + Assert.assertTrue(referentialNames.contains(ObserveEntityEnum.Person.name())); + Assert.assertTrue(result.getReferentialAdded(ObserveEntityEnum.Person.name()).isEmpty()); + Assert.assertTrue(result.getReferentialUpdated(ObserveEntityEnum.Person.name()).isEmpty()); + Collection<String> referentialRemoved = result.getReferentialRemoved(ObserveEntityEnum.Person.name()); + Assert.assertFalse(referentialRemoved.isEmpty()); + Assert.assertEquals(1, referentialRemoved.size()); + Assert.assertTrue(referentialRemoved.contains("fr.ird.observe.entities.referentiel.Person#1355399844272#0.32586441962131485")); + Collection<Pair<String, String>> referentialReplaced = result.getReferentialReplaced(ObserveEntityEnum.Person.name()); + Assert.assertFalse(referentialReplaced.isEmpty()); + Assert.assertEquals(1, referentialReplaced.size()); + Assert.assertTrue(referentialReplaced.contains(Pair.of("fr.ird.observe.entities.referentiel.Person#1355399844272#0.32586441962131485","fr.ird.observe.entities.referentiel.Person#1429515754659#0.322074382333085"))); + + } + { + Assert.assertTrue(referentialNames.contains(ObserveEntityEnum.Vessel.name())); + Assert.assertTrue(result.getReferentialAdded(ObserveEntityEnum.Vessel.name()).isEmpty()); + Collection<String> referentialUpdated = result.getReferentialUpdated(ObserveEntityEnum.Vessel.name()); + Assert.assertFalse(referentialUpdated.isEmpty()); + Assert.assertEquals(1, referentialUpdated.size()); + Assert.assertTrue(referentialUpdated.contains("fr.ird.observe.entities.referentiel.Vessel#1306847717532#0.7435948873477364")); + Assert.assertTrue(result.getReferentialRemoved(ObserveEntityEnum.Vessel.name()).isEmpty()); + Collection<Pair<String, String>> referentialReplaced = result.getReferentialReplaced(ObserveEntityEnum.Vessel.name()); + Assert.assertFalse(referentialReplaced.isEmpty()); + Assert.assertEquals(1, referentialReplaced.size()); + Assert.assertTrue(referentialReplaced.contains(Pair.of("fr.ird.observe.entities.referentiel.Vessel#1306847717532#0.7435948873477364", "fr.ird.observe.entities.referentiel.Vessel#1429515781110#0.833177504362538"))); + } + } } diff --git a/observe-test-data/src/main/java/fr/ird/observe/test/DatabaseName.java b/observe-test-data/src/main/java/fr/ird/observe/test/DatabaseName.java index 568d3a5..b31bef4 100644 --- a/observe-test-data/src/main/java/fr/ird/observe/test/DatabaseName.java +++ b/observe-test-data/src/main/java/fr/ird/observe/test/DatabaseName.java @@ -12,5 +12,5 @@ public enum DatabaseName { dataForTestLongline, dataSourceTest, dataForTestSeine, - dataForTestUnidirectionalReferentialSyncho + dataForTestUnidirectionalReferentialSynchro } diff --git a/observe-test-data/src/main/resources/db/4.903/dataForTestSeine.sql.gz b/observe-test-data/src/main/resources/db/4.903/dataForTestSeine.sql.gz index c4a0979..d6749b7 100644 Binary files a/observe-test-data/src/main/resources/db/4.903/dataForTestSeine.sql.gz and b/observe-test-data/src/main/resources/db/4.903/dataForTestSeine.sql.gz differ diff --git a/observe-test-data/src/main/resources/db/4.903/dataForTestUnidirectionalReferentialSyncho.sql.gz b/observe-test-data/src/main/resources/db/4.903/dataForTestUnidirectionalReferentialSyncho.sql.gz deleted file mode 100644 index 1ab852d..0000000 Binary files a/observe-test-data/src/main/resources/db/4.903/dataForTestUnidirectionalReferentialSyncho.sql.gz and /dev/null differ diff --git a/observe-test-data/src/main/resources/db/4.903/dataForTestUnidirectionalReferentialSynchro.sql.gz b/observe-test-data/src/main/resources/db/4.903/dataForTestUnidirectionalReferentialSynchro.sql.gz new file mode 100644 index 0000000..3989582 Binary files /dev/null and b/observe-test-data/src/main/resources/db/4.903/dataForTestUnidirectionalReferentialSynchro.sql.gz differ -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 0ba6c8b488c690c49724527d7a7673c617d29de3 Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Jul 12 14:56:38 2016 +0200 Revue du moteur de synchronisation pour n'effectuer qu'un seule appel au call back utilisateur (See #7739) --- ...idirectionalReferentialSynchronizeCallback.java | 17 +++ ...ionalReferentialSynchronizeCallbackRequest.java | 43 ++++++++ ...onalReferentialSynchronizeCallbackRequests.java | 42 ++++++++ ...tionalReferentialSynchronizeCallbackResult.java | 33 ++++++ ...ionalReferentialSynchronizeCallbackResults.java | 36 +++++++ ...UnidirectionalReferentialSynchronizeEngine.java | 115 ++++++++++----------- ...nidirectionalReferentialSynchronizeRequest.java | 7 ++ .../UnidirectionalSynchronizeReferentialTest.java | 56 ++-------- 8 files changed, 243 insertions(+), 106 deletions(-) diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallback.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallback.java new file mode 100644 index 0000000..638a983 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallback.java @@ -0,0 +1,17 @@ +package fr.ird.observe.services.service.actions.synchro; + +/** + * Le call back utilisateur pour lui permettre d'effectuer les remplacements sur les référentiels qui posent problèmes. + * + * Pour le moment on ne traite ici que les référentiels supprimés à distance et utilisés dans des données locales. + * + * Created on 12/07/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public interface UnidirectionalReferentialSynchronizeCallback { + + UnidirectionalReferentialSynchronizeCallbackResults askUserToReplaceRemovedReferentials(UnidirectionalReferentialSynchronizeCallbackRequests request); + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackRequest.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackRequest.java new file mode 100644 index 0000000..bcfbfbd --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackRequest.java @@ -0,0 +1,43 @@ +package fr.ird.observe.services.service.actions.synchro; + +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import java.util.Collection; + +/** + * Représente une demande du call back utilisateur pour un type de référentiel donné. + * + * Created on 12/07/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class UnidirectionalReferentialSynchronizeCallbackRequest<R extends ReferentialDto> { + + private final String referentialName; + private final ImmutableSet<ReferentialReference<R>> referentialsToReplace; + private final ImmutableSet<ReferentialReference<R>> availableReferentials; + + public String getReferentialName() { + return referentialName; + } + + public ImmutableSet<ReferentialReference<R>> getReferentialsToReplace() { + return referentialsToReplace; + } + + public ImmutableSet<ReferentialReference<R>> getAvailableReferentials() { + return availableReferentials; + } + + UnidirectionalReferentialSynchronizeCallbackRequest(String referentialName, + Collection<ReferentialReference<R>> referentialsToReplace, + Collection<ReferentialReference<R>> availableReferentials) { + this.referentialName = referentialName; + this.referentialsToReplace = ImmutableSet.copyOf(referentialsToReplace); + this.availableReferentials = ImmutableSet.copyOf(availableReferentials); + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackRequests.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackRequests.java new file mode 100644 index 0000000..9f59166 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackRequests.java @@ -0,0 +1,42 @@ +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 java.util.Collection; +import java.util.LinkedHashSet; +import java.util.Set; + +/** + * Représente l'ensemble des demandes au call back utilisateur. + * + * Created on 12/07/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class UnidirectionalReferentialSynchronizeCallbackRequests { + + private final Set<UnidirectionalReferentialSynchronizeCallbackRequest<?>> callbackRequests; + + public UnidirectionalReferentialSynchronizeCallbackRequests() { + callbackRequests = new LinkedHashSet<>(); + } + + public <R extends ReferentialDto> void addCallbackRequest(String referentialName, + Collection<ReferentialReference<R>> referentialsToReplace, + Collection<ReferentialReference<R>> availableReferentials) { + + UnidirectionalReferentialSynchronizeCallbackRequest<R> callbackRequest = new UnidirectionalReferentialSynchronizeCallbackRequest<>(referentialName, referentialsToReplace, availableReferentials); + callbackRequests.add(callbackRequest); + } + + public Set<UnidirectionalReferentialSynchronizeCallbackRequest<?>> getCallbackRequests() { + return callbackRequests; + } + + public boolean isNotEmpty() { + return !callbackRequests.isEmpty(); + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackResult.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackResult.java new file mode 100644 index 0000000..fe49053 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackResult.java @@ -0,0 +1,33 @@ +package fr.ird.observe.services.service.actions.synchro; + +import com.google.common.collect.ImmutableMap; + +import java.util.Map; + +/** + * Contient les résultats du call back utilisateur pour un type de référentiel donné. + * + * Created on 12/07/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class UnidirectionalReferentialSynchronizeCallbackResult { + + private final String referentialName; + private final ImmutableMap<String, String> ids; + + public String getReferentialName() { + return referentialName; + } + + public ImmutableMap<String, String> getIds() { + return ids; + } + + UnidirectionalReferentialSynchronizeCallbackResult(String referentialName, Map<String, String> ids) { + this.referentialName = referentialName; + this.ids = ImmutableMap.copyOf(ids); + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackResults.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackResults.java new file mode 100644 index 0000000..52fcce0 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackResults.java @@ -0,0 +1,36 @@ +package fr.ird.observe.services.service.actions.synchro; + +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * Contient l'ensemble des résultats du call back utilisateur. + * + * Created on 12/07/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class UnidirectionalReferentialSynchronizeCallbackResults { + + private final Map<String, UnidirectionalReferentialSynchronizeCallbackResult> callbackResults; + + public UnidirectionalReferentialSynchronizeCallbackResults() { + callbackResults = new LinkedHashMap<>(); + } + + public void addCallbackResult(String referentialName, Map<String, String> ids) { + + UnidirectionalReferentialSynchronizeCallbackResult callbackResult = new UnidirectionalReferentialSynchronizeCallbackResult(referentialName, ids); + callbackResults.put(callbackResult.getReferentialName(), callbackResult); + + } + + public UnidirectionalReferentialSynchronizeCallbackResult getCallbackResult(String referentialName) { + return callbackResults.get(referentialName); + } + + public boolean containsReferentialName(String referentialName) { + return callbackResults.containsKey(referentialName); + } +} 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 index 5c3b8c5..3ec6089 100644 --- 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 @@ -22,11 +22,11 @@ public class UnidirectionalReferentialSynchronizeEngine implements Callable<Unid private final UnidirectionalReferentialSynchronizeLocalService localService; private final UnidirectionalReferentialSynchronizeRemoteService remoteService; - private final Callback callback; + private final UnidirectionalReferentialSynchronizeCallback callback; public UnidirectionalReferentialSynchronizeEngine(UnidirectionalReferentialSynchronizeLocalService localService, UnidirectionalReferentialSynchronizeRemoteService remoteService, - Callback callback) { + UnidirectionalReferentialSynchronizeCallback callback) { this.localService = localService; this.remoteService = remoteService; this.callback = callback; @@ -40,11 +40,57 @@ public class UnidirectionalReferentialSynchronizeEngine implements Callable<Unid UnidirectionalReferentialSynchronizeResult result = new UnidirectionalReferentialSynchronizeResult(); - Set<String> sqlRequests = new LinkedHashSet<>(); + + Set<UnidirectionalReferentialSynchronizeRequest.Builder<?>> referentialSynchronizeRequestBuilders = new LinkedHashSet<>(); + + UnidirectionalReferentialSynchronizeCallbackRequests callbackRequests = new UnidirectionalReferentialSynchronizeCallbackRequests(); + + + // Première étape pour construire les builder de requète et calculer au passage les ids à faire remplacer + // par l'utilisateur + for (String referentialName : remoteReferentialDiff.getReferentialNames()) { - UnidirectionalReferentialSynchronizeRequest<?> referentialSynchronizeRequest = - buildReferentialSynchronizeRequest(callback, referentialName, remoteReferentialDiff); + UnidirectionalReferentialSynchronizeRequest.Builder<?> referentialSynchronizeRequestBuilder = + computeReferentialSynchronizeRequestBuilder(referentialName, remoteReferentialDiff, callbackRequests); + + referentialSynchronizeRequestBuilders.add(referentialSynchronizeRequestBuilder); + + } + + boolean needCallback = callbackRequests.isNotEmpty(); + + UnidirectionalReferentialSynchronizeCallbackResults callbackResults = null; + + if (needCallback) { + + callbackResults = callback.askUserToReplaceRemovedReferentials(callbackRequests); + + } + + Set<String> sqlRequests = new LinkedHashSet<>(); + + // Second étape pour terminer la construction des builders de requètes et générer le code sql + + for (UnidirectionalReferentialSynchronizeRequest.Builder<?> referentialSynchronizeRequestBuilder : referentialSynchronizeRequestBuilders) { + + String referentialName = referentialSynchronizeRequestBuilder.getReferentialName(); + + if (needCallback && callbackResults.containsReferentialName(referentialName)) { + + // l'utilisateur a agit sur ce référentiel + UnidirectionalReferentialSynchronizeCallbackResult callbackResult = callbackResults.getCallbackResult(referentialName); + + Map<String, String> ids = callbackResult.getIds(); + + for (Map.Entry<String, String> entry : ids.entrySet()) { + referentialSynchronizeRequestBuilder.entityToReplace(entry.getKey(), entry.getValue()); + referentialSynchronizeRequestBuilder.entityToRemove(entry.getKey()); + } + + } + + UnidirectionalReferentialSynchronizeRequest<?> referentialSynchronizeRequest = referentialSynchronizeRequestBuilder.build(); result.flushRequest(referentialSynchronizeRequest); @@ -61,7 +107,7 @@ public class UnidirectionalReferentialSynchronizeEngine implements Callable<Unid } - private <R extends ReferentialDto> UnidirectionalReferentialSynchronizeRequest buildReferentialSynchronizeRequest(Callback callback, String referentialName, RemoteReferentialDiff remoteReferentialDiff) { + private <R extends ReferentialDto> UnidirectionalReferentialSynchronizeRequest.Builder<R> computeReferentialSynchronizeRequestBuilder(String referentialName, RemoteReferentialDiff remoteReferentialDiff, UnidirectionalReferentialSynchronizeCallbackRequests callbackRequests) { UnidirectionalReferentialSynchronizeRequest.Builder<R> builder = UnidirectionalReferentialSynchronizeRequest.builder(referentialName); @@ -92,69 +138,20 @@ public class UnidirectionalReferentialSynchronizeEngine implements Callable<Unid } - boolean needCallback = CollectionUtils.isNotEmpty(blockingIdsToRemove); - if (needCallback) { - // calcul de l'univers de référentiels disponibles pour les remplacements + if (needCallback) { ReferentialReferenceSet<R> availableReferenceSet = remoteService.getEnabledReferentialReferenceSet(referentialName); Set<ReferentialReference<R>> availableReferentials = availableReferenceSet.getReferences(); Set<ReferentialReference<R>> blockingReferentialsToRemove = localService.getLocalSourceReferentialToDelete(referentialName, blockingIdsToRemove); - CallbackRequest<R> callbackRequest = CallbackRequest.of(referentialName, blockingReferentialsToRemove, availableReferentials); - Map<String, String> referentialsToRemoveIds = callback.askUserToReplaceRemovedReferentials(callbackRequest); - for (Map.Entry<String, String> entry : referentialsToRemoveIds.entrySet()) { - builder.entityToReplace(entry.getKey(), entry.getValue()); - builder.entityToRemove(entry.getKey()); - } + + callbackRequests.addCallbackRequest(referentialName, blockingReferentialsToRemove, availableReferentials); } - UnidirectionalReferentialSynchronizeRequest referentialSynchronizeRequest = builder.build(); - return referentialSynchronizeRequest; - - } - - public interface Callback { - - <R extends ReferentialDto> Map<String, String> askUserToReplaceRemovedReferentials(CallbackRequest<R> request); - - <R extends ReferentialDto> Map<String, String> askUserToReplaceDisabledReferentials(CallbackRequest<R> 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; - } + return builder; } 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 index d049d04..fd01d8a 100644 --- 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 @@ -50,12 +50,15 @@ public class UnidirectionalReferentialSynchronizeRequest<R extends ReferentialDt public boolean withReferentialToAdd() { return !referentialToAdd.isEmpty(); } + public boolean withReferentialToUpdate() { return !referentialToUpdate.isEmpty(); } + public boolean withReferentialToRemove() { return !referentialToRemove.isEmpty(); } + public boolean withReferentialToReplace() { return !referentialToReplace.isEmpty(); } @@ -111,6 +114,10 @@ public class UnidirectionalReferentialSynchronizeRequest<R extends ReferentialDt return this; } + public String getReferentialName() { + return referentialName; + } + public UnidirectionalReferentialSynchronizeRequest<R> build() { return new UnidirectionalReferentialSynchronizeRequest<>( diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalSynchronizeReferentialTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalSynchronizeReferentialTest.java index 8ce1b83..a293ebe 100644 --- a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalSynchronizeReferentialTest.java +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalSynchronizeReferentialTest.java @@ -5,7 +5,6 @@ import fr.ird.observe.ObserveEntityEnum; import fr.ird.observe.entities.Entities; import fr.ird.observe.services.ApplicationContextResource; import fr.ird.observe.services.DataSourceResource; -import fr.ird.observe.services.dto.referential.ReferentialDto; import fr.ird.observe.services.service.AbstractServiceTopiaTest; import fr.ird.observe.test.DatabaseName; import fr.ird.observe.test.ObserveFixtures; @@ -21,7 +20,6 @@ import org.junit.Rule; import org.junit.Test; import java.util.Collection; -import java.util.Map; import java.util.Set; /** @@ -53,18 +51,8 @@ public class UnidirectionalSynchronizeReferentialTest extends AbstractServiceTop @Test public void testSynchronizeFromEmptyDatabase() { - UnidirectionalReferentialSynchronizeEngine.Callback callback = new UnidirectionalReferentialSynchronizeEngine.Callback() { - - @Override - public Map<String, String> askUserToReplaceRemovedReferentials(UnidirectionalReferentialSynchronizeEngine.CallbackRequest request) { - throw new IllegalStateException(); - } - - @Override - public Map<String, String> askUserToReplaceDisabledReferentials(UnidirectionalReferentialSynchronizeEngine.CallbackRequest request) { - throw new IllegalStateException(); - } - + UnidirectionalReferentialSynchronizeCallback callback = request -> { + throw new IllegalStateException(); }; UnidirectionalReferentialSynchronizeEngine referentialSynchronizeEngine = new UnidirectionalReferentialSynchronizeEngine(localService, remoteService, callback); UnidirectionalReferentialSynchronizeResult result = referentialSynchronizeEngine.call(); @@ -95,18 +83,8 @@ public class UnidirectionalSynchronizeReferentialTest extends AbstractServiceTop @Test public void testSynchronizeWithNochange() { - UnidirectionalReferentialSynchronizeEngine.Callback callback = new UnidirectionalReferentialSynchronizeEngine.Callback() { - - @Override - public Map<String, String> askUserToReplaceRemovedReferentials(UnidirectionalReferentialSynchronizeEngine.CallbackRequest request) { - throw new IllegalStateException(); - } - - @Override - public Map<String, String> askUserToReplaceDisabledReferentials(UnidirectionalReferentialSynchronizeEngine.CallbackRequest request) { - throw new IllegalStateException(); - } - + UnidirectionalReferentialSynchronizeCallback callback = request -> { + throw new IllegalStateException(); }; UnidirectionalReferentialSynchronizeEngine referentialSynchronizeEngine = new UnidirectionalReferentialSynchronizeEngine(localService, remoteService, callback); UnidirectionalReferentialSynchronizeResult result = referentialSynchronizeEngine.call(); @@ -135,27 +113,11 @@ public class UnidirectionalSynchronizeReferentialTest extends AbstractServiceTop @Test public void testSynchronizeWithAllChanges() { - UnidirectionalReferentialSynchronizeEngine.Callback callback = new UnidirectionalReferentialSynchronizeEngine.Callback() { + UnidirectionalReferentialSynchronizeCallback callback = request -> { - @Override - public <R extends ReferentialDto> Map<String, String> askUserToReplaceRemovedReferentials(UnidirectionalReferentialSynchronizeEngine.CallbackRequest<R> request) { - String referentialName = request.getReferentialName(); - switch (referentialName) { - case "Person": - return ImmutableMap.<String, String>builder().put("fr.ird.observe.entities.referentiel.Person#1355399844272#0.32586441962131485", "fr.ird.observe.entities.referentiel.Person#1429515754659#0.322074382333085").build(); - } - throw new IllegalStateException(); - } - - @Override - public <R extends ReferentialDto> Map<String, String> askUserToReplaceDisabledReferentials(UnidirectionalReferentialSynchronizeEngine.CallbackRequest<R> request) { - String referentialName = request.getReferentialName(); - switch (referentialName) { - case "Vessel": - return ImmutableMap.<String, String>builder().put("fr.ird.observe.entities.referentiel.Vessel#1306847717532#0.7435948873477364", "fr.ird.observe.entities.referentiel.Vessel#1429515781110#0.833177504362538").build(); - } - throw new IllegalStateException(); - } + UnidirectionalReferentialSynchronizeCallbackResults results = new UnidirectionalReferentialSynchronizeCallbackResults(); + results.addCallbackResult(ObserveEntityEnum.Person.name(), ImmutableMap.<String, String>builder().put("fr.ird.observe.entities.referentiel.Person#1355399844272#0.32586441962131485", "fr.ird.observe.entities.referentiel.Person#1429515754659#0.322074382333085").build()); + return results; }; @@ -201,7 +163,7 @@ public class UnidirectionalSynchronizeReferentialTest extends AbstractServiceTop Collection<Pair<String, String>> referentialReplaced = result.getReferentialReplaced(ObserveEntityEnum.Person.name()); Assert.assertFalse(referentialReplaced.isEmpty()); Assert.assertEquals(1, referentialReplaced.size()); - Assert.assertTrue(referentialReplaced.contains(Pair.of("fr.ird.observe.entities.referentiel.Person#1355399844272#0.32586441962131485","fr.ird.observe.entities.referentiel.Person#1429515754659#0.322074382333085"))); + Assert.assertTrue(referentialReplaced.contains(Pair.of("fr.ird.observe.entities.referentiel.Person#1355399844272#0.32586441962131485", "fr.ird.observe.entities.referentiel.Person#1429515754659#0.322074382333085"))); } { Assert.assertTrue(referentialNames.contains(ObserveEntityEnum.Vessel.name())); -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 e04956c1705c3659d4c1fb2be7a29cf5568ff36a Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Jul 12 16:52:41 2016 +0200 Ajout des services de synchonisation (See #7739) --- .../main/java/fr/ird/observe/db/ObserveSwingDataSource.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/observe-application-swing/src/main/java/fr/ird/observe/db/ObserveSwingDataSource.java b/observe-application-swing/src/main/java/fr/ird/observe/db/ObserveSwingDataSource.java index 7c23a14..1129d52 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/db/ObserveSwingDataSource.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/db/ObserveSwingDataSource.java @@ -34,6 +34,8 @@ import fr.ird.observe.services.service.DatabaseNotFoundException; import fr.ird.observe.services.service.ObserveReferentialCache; import fr.ird.observe.services.service.ReferentialService; import fr.ird.observe.services.service.SqlScriptProducerService; +import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeLocalService; +import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeRemoteService; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.jdesktop.beans.AbstractSerializableBean; @@ -314,6 +316,14 @@ public class ObserveSwingDataSource extends AbstractSerializableBean implements return newService(SqlScriptProducerService.class); } + public UnidirectionalReferentialSynchronizeLocalService newUnidirectionalReferentialSynchronizeLocalService() { + return newService(UnidirectionalReferentialSynchronizeLocalService.class); + } + + public UnidirectionalReferentialSynchronizeRemoteService newUnidirectionalReferentialSynchronizeRemoteService() { + return newService(UnidirectionalReferentialSynchronizeRemoteService.class); + } + public <S extends ObserveService> S newService(Class<S> serviceType) { ObserveServiceInitializer observeServiceInitializer = getObserveServiceInitializer(); -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 1c5dda0c1b7dde60e424dea62cd722bc823250c6 Author: Tony CHEMIT <chemit@codelutin.com> Date: Wed Jul 13 12:52:24 2016 +0200 Suppression de la permission d'écrire le référentiel car sinon on est bloqué par le service --- .../synchro/UnidirectionalReferentialSynchronizeLocalService.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) 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 bdc0026..b3d8f98 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 @@ -7,7 +7,6 @@ import fr.ird.observe.services.spi.NoDataAccess; import fr.ird.observe.services.spi.PostRequest; import fr.ird.observe.services.spi.ReadReferentialPermission; import fr.ird.observe.services.spi.Write; -import fr.ird.observe.services.spi.WriteReferentialPermission; import java.util.Set; @@ -67,7 +66,9 @@ public interface UnidirectionalReferentialSynchronizeLocalService extends Observ * * @param sqlRequests les requètes sql à appliquer */ - @WriteReferentialPermission + @ReadReferentialPermission + //tc-20160713 On ne met pas cette permission, car il s'agit d'appliquer un script sql, sans avoir besoin des droits applicatifs +// @WriteReferentialPermission @Write @PostRequest void applySqlRequests(Set<String> sqlRequests); -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 3a9e5d3604305539c34052817b269b4d985bfa97 Author: Tony CHEMIT <chemit@codelutin.com> Date: Wed Jul 13 12:53:10 2016 +0200 Début de migration des interfaces graphiques pour la synchronisation (See #7739) --- .../observe/ui/admin/save/SaveLocalUIHandler.java | 220 +++-- .../synchronize/ObsoleteEntityTableModel.java | 158 ---- .../synchronize/ObsoleteReferentialReference.java | 53 ++ ...oleteReferentialReferenceListCellRenderer.java} | 29 +- .../ui/admin/synchronize/SynchronizeModel.java | 129 ++- .../ui/admin/synchronize/SynchronizeUI.jaxx | 64 +- .../ui/admin/synchronize/SynchronizeUI.jcss | 15 +- .../ui/admin/synchronize/SynchronizeUIHandler.java | 969 ++++++--------------- .../observe-application-swing_en_GB.properties | 1 + .../observe-application-swing_es_ES.properties | 1 + .../observe-application-swing_fr_FR.properties | 1 + 11 files changed, 523 insertions(+), 1117 deletions(-) diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/save/SaveLocalUIHandler.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/save/SaveLocalUIHandler.java index 18219c1..2fd3ece 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/save/SaveLocalUIHandler.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/save/SaveLocalUIHandler.java @@ -28,7 +28,6 @@ import fr.ird.observe.ui.UIHelper; import fr.ird.observe.ui.admin.AdminStep; import fr.ird.observe.ui.admin.AdminTabUIHandler; import fr.ird.observe.ui.admin.AdminUI; -import fr.ird.observe.ui.admin.synchronize.SynchronizeModel; import jaxx.runtime.swing.wizard.ext.WizardState; import org.apache.commons.io.IOUtils; import org.apache.commons.logging.Log; @@ -37,7 +36,6 @@ import org.apache.commons.logging.LogFactory; import java.io.File; import java.io.FileOutputStream; import java.util.Date; -import java.util.List; import java.util.concurrent.Callable; import static org.nuiton.i18n.I18n.t; @@ -171,126 +169,126 @@ public class SaveLocalUIHandler extends AdminTabUIHandler { } - if (stepModel.containsStepForsave(AdminStep.SYNCHRONIZE)) { - - sendMessage("Sauvegarde du référentiel."); - saveReferentiel(); - } +// if (stepModel.containsStepForsave(AdminStep.SYNCHRONIZE)) { +// +// sendMessage("Sauvegarde du référentiel."); +// saveReferentiel(); +// } sendMessage(t("observe.message.synchro.operation.done", new Date())); return WizardState.SUCCESSED; } - public void saveReferentiel() throws Exception { - - List<String> ids; - - SynchronizeModel stepModel = getModel().getSynchronizeReferentielModel(); - - ObserveSwingDataSource referentielSource = stepModel.getTmpSource(); - if (referentielSource == null) { - - // pas de base temporaire - // on travaille directement sur la base central - referentielSource = stepModel.getCentralSource(); - } - ObserveSwingDataSource targetSource = stepModel.getSource(); - - //FIXME -// DiffState.DiffStateMap diff = stepModel.getDiff(); -// -// String txName = "saveReferentiel"; -// TopiaContext targetTx = beginTransaction(targetSource, txName); -// try { -// TopiaContext sourceTx = beginTransaction(referentielSource, txName); -// try { -// // ajout des nouvelles entites du referentiel -// -// ids = diff.get(DiffState.NEW); -// if (CollectionUtils.isNotEmpty(ids)) { -// for (String id : ids) { -// //FIXME on doit s'assurer de l'orde d'injection des entites -// TopiaEntity entity = sourceTx.findByTopiaId(id); -// String message = t("observe.synchro.add.object", id); -// sendMessage(message); -// sourceTx.replicateEntity(targetTx, entity); -// -// // On est obligé de commiter à chaque ajout sinon si -// // une autre entité à ajouter depend de celle là, on -// // ne la retrouve pas -// // -// commitTransaction(targetSource, targetTx, txName); -// if (log.isDebugEnabled()) { -// log.debug("add [" + id + "] : " + targetTx.findByTopiaId(id)); -// } -// } -// } -// -// // mis a jour des entites modifiees -// -// ids = diff.get(DiffState.MODIFIED); -// if (CollectionUtils.isNotEmpty(ids)) { -// -// for (String id : ids) { -// -// copyEntity(stepModel, sourceTx, targetTx, id); -// } -// } -// -// // mise à jour des données utilisateurs (remplacements d'objets obsolètes) -// -// for (SynchronizeUIHandler.ObsoleteRefReplaceAction action : stepModel.getReplaceActions()) { -// -// String message = t("observe.synchro.replaceObsolete.object", action.getObsoleteId()); -// sendMessage(message); +// public void saveReferentiel() throws Exception { // -// action.doAction(targetTx); -// } -// -// // si on ne commite pas ici, les modifications utilisateurs -// // sont perdues -// commitTransaction(targetSource, targetTx, txName); -// -// // suppression des entités obsoletes de la base source +// List<String> ids; // -// ids = diff.get(DiffState.REMOVED); -// if (CollectionUtils.isNotEmpty(ids)) { -// for (String id : ids) { -// String message = t("observe.synchro.remove.object", id); -// sendMessage(message); -// TopiaEntity entity = targetTx.findByTopiaId(id); -// getDAO(targetTx, entity).delete(entity); -// } -// } +// SynchronizeModel stepModel = getModel().getSynchronizeReferentielModel(); // -// Map<TopiaEntity, Long> versionsToUpdate = -// stepModel.getVersionsToUpdate(); +// ObserveSwingDataSource referentielSource = stepModel.getTmpSource(); +// if (referentielSource == null) { // -// if (MapUtils.isNotEmpty(versionsToUpdate)) { -// -// // on applique le patch sur les versions pour bien avoir -// // la bonne version de topiaversion et pas seulement un incrément -// // de 1 puisque ce champs est géré par hibernate et qu'il ne nous laisse -// // pas la possibilité de choisir la valeur qu'on veut attribuer au champs... -// patchTopiaVersions((TopiaContextImplementor) targetTx, versionsToUpdate); -// } -// -// commitTransaction(targetSource, targetTx, txName); -// } finally { -// try { -// rollbackTransaction(referentielSource, sourceTx, txName); -// } finally { -// closeTransaction(referentielSource, sourceTx, txName); -// } -// } -// } catch (Exception e) { -// rollbackTransaction(targetSource, targetTx, txName); -// throw e; -// } finally { -// closeTransaction(targetSource, targetTx, txName); +// // pas de base temporaire +// // on travaille directement sur la base central +// referentielSource = stepModel.getCentralSource(); // } - } +// ObserveSwingDataSource targetSource = stepModel.getSource(); +// +// //FIXME +//// DiffState.DiffStateMap diff = stepModel.getDiff(); +//// +//// String txName = "saveReferentiel"; +//// TopiaContext targetTx = beginTransaction(targetSource, txName); +//// try { +//// TopiaContext sourceTx = beginTransaction(referentielSource, txName); +//// try { +//// // ajout des nouvelles entites du referentiel +//// +//// ids = diff.get(DiffState.NEW); +//// if (CollectionUtils.isNotEmpty(ids)) { +//// for (String id : ids) { +//// //FIXME on doit s'assurer de l'orde d'injection des entites +//// TopiaEntity entity = sourceTx.findByTopiaId(id); +//// String message = t("observe.synchro.add.object", id); +//// sendMessage(message); +//// sourceTx.replicateEntity(targetTx, entity); +//// +//// // On est obligé de commiter à chaque ajout sinon si +//// // une autre entité à ajouter depend de celle là, on +//// // ne la retrouve pas +//// // +//// commitTransaction(targetSource, targetTx, txName); +//// if (log.isDebugEnabled()) { +//// log.debug("add [" + id + "] : " + targetTx.findByTopiaId(id)); +//// } +//// } +//// } +//// +//// // mis a jour des entites modifiees +//// +//// ids = diff.get(DiffState.MODIFIED); +//// if (CollectionUtils.isNotEmpty(ids)) { +//// +//// for (String id : ids) { +//// +//// copyEntity(stepModel, sourceTx, targetTx, id); +//// } +//// } +//// +//// // mise à jour des données utilisateurs (remplacements d'objets obsolètes) +//// +//// for (SynchronizeUIHandler.ObsoleteRefReplaceAction action : stepModel.getReplaceActions()) { +//// +//// String message = t("observe.synchro.replaceObsolete.object", action.getObsoleteId()); +//// sendMessage(message); +//// +//// action.doAction(targetTx); +//// } +//// +//// // si on ne commite pas ici, les modifications utilisateurs +//// // sont perdues +//// commitTransaction(targetSource, targetTx, txName); +//// +//// // suppression des entités obsoletes de la base source +//// +//// ids = diff.get(DiffState.REMOVED); +//// if (CollectionUtils.isNotEmpty(ids)) { +//// for (String id : ids) { +//// String message = t("observe.synchro.remove.object", id); +//// sendMessage(message); +//// TopiaEntity entity = targetTx.findByTopiaId(id); +//// getDAO(targetTx, entity).delete(entity); +//// } +//// } +//// +//// Map<TopiaEntity, Long> versionsToUpdate = +//// stepModel.getVersionsToUpdate(); +//// +//// if (MapUtils.isNotEmpty(versionsToUpdate)) { +//// +//// // on applique le patch sur les versions pour bien avoir +//// // la bonne version de topiaversion et pas seulement un incrément +//// // de 1 puisque ce champs est géré par hibernate et qu'il ne nous laisse +//// // pas la possibilité de choisir la valeur qu'on veut attribuer au champs... +//// patchTopiaVersions((TopiaContextImplementor) targetTx, versionsToUpdate); +//// } +//// +//// commitTransaction(targetSource, targetTx, txName); +//// } finally { +//// try { +//// rollbackTransaction(referentielSource, sourceTx, txName); +//// } finally { +//// closeTransaction(referentielSource, sourceTx, txName); +//// } +//// } +//// } catch (Exception e) { +//// rollbackTransaction(targetSource, targetTx, txName); +//// throw e; +//// } finally { +//// closeTransaction(targetSource, targetTx, txName); +//// } +// } //FIXME // protected <E extends TopiaEntity> void copyEntity(SynchronizeModel synchronizeModel, diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteEntityTableModel.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteEntityTableModel.java deleted file mode 100644 index 0d9fa05..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteEntityTableModel.java +++ /dev/null @@ -1,158 +0,0 @@ -/* - * #%L - * ObServe :: Swing - * %% - * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/gpl-3.0.html>. - * #L% - */ -package fr.ird.observe.ui.admin.synchronize; - -import fr.ird.observe.services.dto.AbstractObserveDto; -import org.nuiton.i18n.I18n; - -import javax.swing.table.AbstractTableModel; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -/** - * @author Tony Chemit - chemit@codelutin.com - * @since 1.0 - */ -public class ObsoleteEntityTableModel extends AbstractTableModel { - - protected static final String[] COLUMN_NAMES = { - I18n.n("observe.synchro.common.select"), - I18n.n("observe.synchro.common.reference") - }; - - protected static final Class<?>[] COLUMN_CLASSES = { - Boolean.class, - AbstractObserveDto.class - }; - - private static final long serialVersionUID = 1L; - -// protected List<TopiaEntityRef> refs; - - protected Set<Integer> selected; - - protected boolean selectAll; - - public ObsoleteEntityTableModel() { - selected = new HashSet<>(); - } - - @Override - public Class<?> getColumnClass(int columnIndex) { - return COLUMN_CLASSES[columnIndex]; - } - - @Override - public boolean isCellEditable(int rowIndex, int columnIndex) { - return columnIndex == 0; - } - - //FIXME -// public void initEntity(List<TopiaEntityRef> refs) { -// // on nettoye toujours le model lors de l'init d'une entité -// this.refs = refs; -// selected.clear(); -// // par defaut, on selectionne toutes les references -// setSelectAll(true); -// //fireTableDataChanged(); -// } - - public List<Integer> getSelectedIndex() { - return new ArrayList<>(selected); - } - - //FIXME -// public List<TopiaEntityRef> getSelectedRefs() { -// List<TopiaEntityRef> result = new ArrayList<TopiaEntityRef>(); -// if (!selected.isEmpty()) { -// for (Integer i : selected) { -// result.add(refs.get(i)); -// } -// } -// return result; -// } - - @Override - public int getRowCount() { - //FIXME -// return refs == null ? 0 : refs.size(); - return -1; - } - - @Override - public int getColumnCount() { - return COLUMN_CLASSES.length; - } - - @Override - public Object getValueAt(int rowIndex, int columnIndex) { - if (columnIndex == 0) { - return selected.contains(rowIndex); - } - if (columnIndex == 1) { - //FIXME -// return refs.get(rowIndex); - return null; - } - throw new IllegalStateException("can not get value for row " + - rowIndex + ", col " + columnIndex); - } - - @Override - public void setValueAt(Object aValue, int rowIndex, int columnIndex) { - if (columnIndex == 0) { - Boolean value = (Boolean) aValue; - if (value) { - selected.add(rowIndex); - if (selected.size() == getRowCount()) { - selectAll = true; - } - } else { - selected.remove(rowIndex); - if (selected.isEmpty()) { - selectAll = false; - } - } - fireTableCellUpdated(rowIndex, columnIndex); - } - - // no edit for others columns - } - - public boolean isSelectAll() { - return selectAll; - } - - public void setSelectAll(boolean selectAll) { - this.selectAll = selectAll; - if (selectAll) { - for (int i = 0, max = getRowCount(); i < max; i++) { - selected.add(i); - } - } else { - selected.clear(); - } - fireTableDataChanged(); - } -} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteReferentialReference.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteReferentialReference.java new file mode 100644 index 0000000..d5e60c5 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteReferentialReference.java @@ -0,0 +1,53 @@ +package fr.ird.observe.ui.admin.synchronize; + +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import java.util.Objects; + +/** + * Représente une référence obsolète à remplacer. + * + * Created on 13/07/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ObsoleteReferentialReference { + + private final String referentialName; + private final ReferentialReference referentialReference; + + public ObsoleteReferentialReference(String referentialName, ReferentialReference referentialReference) { + this.referentialName = referentialName; + this.referentialReference = referentialReference; + } + + public String getReferentialName() { + return referentialName; + } + + public ReferentialReference getReferentialReference() { + return referentialReference; + } + + public String getId() { + return referentialReference.getId(); + } + + public Class getType() { + return referentialReference.getType(); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ObsoleteReferentialReference that = (ObsoleteReferentialReference) o; + return Objects.equals(getReferentialReference(), that.getReferentialReference()); + } + + @Override + public int hashCode() { + return Objects.hash(getReferentialReference()); + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteEntityListCellRenderer.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteReferentialReferenceListCellRenderer.java similarity index 66% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteEntityListCellRenderer.java rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteReferentialReferenceListCellRenderer.java index 462d322..ff15ad6 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteEntityListCellRenderer.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteReferentialReferenceListCellRenderer.java @@ -23,21 +23,19 @@ package fr.ird.observe.ui.admin.synchronize; import fr.ird.observe.ObserveSwingApplicationContext; import fr.ird.observe.ui.DecoratorService; -import fr.ird.observe.services.dto.AbstractObserveDto; import org.nuiton.decorator.Decorator; -import javax.swing.*; -import java.awt.*; -import java.util.List; -import java.util.Map; +import javax.swing.DefaultListCellRenderer; +import javax.swing.JList; +import java.awt.Component; import static org.nuiton.i18n.I18n.t; -public class ObsoleteEntityListCellRenderer extends DefaultListCellRenderer { +public class ObsoleteReferentialReferenceListCellRenderer extends DefaultListCellRenderer { private static final long serialVersionUID = 1L; - protected DecoratorService decoratorService; + protected transient DecoratorService decoratorService; public DecoratorService getDecoratorService() { if (decoratorService == null) { @@ -54,20 +52,15 @@ public class ObsoleteEntityListCellRenderer extends DefaultListCellRenderer { boolean isSelected, boolean cellHasFocus) { - Map.Entry<?, ?> entry = (Map.Entry<?, ?>) value; - AbstractObserveDto id = (AbstractObserveDto) entry.getKey(); - List<?> val = (List<?>) entry.getValue(); + ObsoleteReferentialReference referentialReference = (ObsoleteReferentialReference) value; DecoratorService service = getDecoratorService(); - String type = t(DecoratorService.getEntityLabel(id.getClass())); - Decorator<?> decorator = service.getDecoratorByType(id.getClass()); + Class referentialReferenceType = referentialReference.getReferentialReference().getType(); + String type = t(DecoratorService.getEntityLabel(referentialReferenceType)); + Decorator<?> decorator = service.getReferentialReferenceDecorator(referentialReferenceType); + + String text = type + " " + service.decorate(referentialReference); - String decorated = decorator.toString(id); - if (val.size() == 1) { - value = t("observe.synchro.message.obsolote.entity.ref.found", type, decorated); - } else { - value = t("observe.synchro.message.obsolote.entity.refs.found", type, decorated, val.size()); - } return super.getListCellRendererComponent( list, value, diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeModel.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeModel.java index a3eef7d..86a3de7 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeModel.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeModel.java @@ -22,8 +22,16 @@ package fr.ird.observe.ui.admin.synchronize; import fr.ird.observe.db.ObserveSwingDataSource; +import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeCallbackResults; +import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeContext; +import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeEngine; +import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeResult; import fr.ird.observe.ui.admin.AdminActionModel; import fr.ird.observe.ui.admin.AdminStep; +import jaxx.runtime.swing.model.JaxxDefaultListModel; + +import javax.swing.DefaultListSelectionModel; +import java.util.List; /** * Le modèle de l'opération de synchronization de réferentiel. @@ -33,81 +41,25 @@ import fr.ird.observe.ui.admin.AdminStep; */ public class SynchronizeModel extends AdminActionModel { - /** le dictionnaire des références sur du référentiel */ - //FIXME -// protected SortedMap<TopiaEntity, List<TopiaEntityRef>> obsoleteRefs; - - /** le différentiel de référentiel */ - //FIXME -// protected DiffState.DiffStateMap diff; - - /** liste des actions utilisateurs */ - //FIXME -// protected List<SynchronizeUIHandler.ObsoleteRefReplaceAction> replaceActions; - - /** Universe of entities to update and with their topiaVersion to set. */ - //FIXME -// protected Map<TopiaEntity, Long> versionsToUpdate; - /** data source we want to synchronize. */ protected ObserveSwingDataSource source; /** data source which contains central referentiel. */ protected ObserveSwingDataSource centralSource; - /** temporary source where to make objectOperations. */ - protected ObserveSwingDataSource tmpSource; + /** Le resultat de la synchronisation des référentiels. */ + private UnidirectionalReferentialSynchronizeResult referentialSynchronizeResult; + private UnidirectionalReferentialSynchronizeEngine engine; + private UnidirectionalReferentialSynchronizeContext referentialSynchronizeContext; + private UnidirectionalReferentialSynchronizeCallbackResults referentialSynchronizeCallbackResults; + + private final JaxxDefaultListModel<ObsoleteReferentialReference> obsoleteReferences = new JaxxDefaultListModel<>(); + private final DefaultListSelectionModel obsoleteReferencesSelectionModel = new DefaultListSelectionModel(); public SynchronizeModel() { super(AdminStep.SYNCHRONIZE); } - //FIXME -// public SortedMap<TopiaEntity, List<TopiaEntityRef>> getObsoleteRefs() { -// return obsoleteRefs; -// } - - //FIXME -// public void setObsoleteRefs(SortedMap<TopiaEntity, List<TopiaEntityRef>> obsoleteRefs) { -// this.obsoleteRefs = obsoleteRefs; -// } - - //FIXME -// public DiffState.DiffStateMap getDiff() { -// return diff; -// } - - //FIXME -// public void setDiff(DiffState.DiffStateMap diff) { -// this.diff = diff; -// } - - //FIXME -// public List<SynchronizeUIHandler.ObsoleteRefReplaceAction> getReplaceActions() { -// if (replaceActions == null) { -// replaceActions = new ArrayList<SynchronizeUIHandler.ObsoleteRefReplaceAction>(); -// } -// return replaceActions; -// } - - //FIXME -// public void setReplaceActions(List<SynchronizeUIHandler.ObsoleteRefReplaceAction> replaceActions) { -// this.replaceActions = replaceActions; -// } - - //FIXME -// public Map<TopiaEntity, Long> getVersionsToUpdate() { -// if (versionsToUpdate == null) { -// versionsToUpdate = new HashMap<TopiaEntity, Long>(); -// } -// return versionsToUpdate; -// } - - //FIXME -// public void setVersionsToUpdate(Map<TopiaEntity, Long> versionsToUpdate) { -// this.versionsToUpdate = versionsToUpdate; -// } - public ObserveSwingDataSource getSource() { return source; } @@ -124,11 +76,52 @@ public class SynchronizeModel extends AdminActionModel { this.centralSource = centralSource; } - public ObserveSwingDataSource getTmpSource() { - return tmpSource; + public UnidirectionalReferentialSynchronizeResult getReferentialSynchronizeResult() { + return referentialSynchronizeResult; + } + + public void setReferentialSynchronizeResult(UnidirectionalReferentialSynchronizeResult referentialSynchronizeResult) { + this.referentialSynchronizeResult = referentialSynchronizeResult; + } + + public void setEngine(UnidirectionalReferentialSynchronizeEngine engine) { + this.engine = engine; + } + + public UnidirectionalReferentialSynchronizeEngine getEngine() { + return engine; + } + + public void setReferentialSynchronizeContext(UnidirectionalReferentialSynchronizeContext referentialSynchronizeContext) { + this.referentialSynchronizeContext = referentialSynchronizeContext; + } + + public UnidirectionalReferentialSynchronizeContext getReferentialSynchronizeContext() { + return referentialSynchronizeContext; + } + + public UnidirectionalReferentialSynchronizeCallbackResults getReferentialSynchronizeCallbackResults() { + return referentialSynchronizeCallbackResults; + } + + public void setReferentialSynchronizeCallbackResults(UnidirectionalReferentialSynchronizeCallbackResults referentialSynchronizeCallbackResults) { + this.referentialSynchronizeCallbackResults = referentialSynchronizeCallbackResults; + } + + public JaxxDefaultListModel<ObsoleteReferentialReference> getObsoleteReferences() { + return obsoleteReferences; + } + + public DefaultListSelectionModel getObsoleteReferencesSelectionModel() { + return obsoleteReferencesSelectionModel; + } + + public void destroy() { + obsoleteReferencesSelectionModel.clearSelection(); + obsoleteReferences.clear(); } - public void setTmpSource(ObserveSwingDataSource tmpSource) { - this.tmpSource = tmpSource; + public void setObsoleteReferences(List<ObsoleteReferentialReference> obsoleteReferences) { + this.obsoleteReferences.setAllElements(obsoleteReferences); } } diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUI.jaxx b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUI.jaxx index 557ca32..f0d7696 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUI.jaxx +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUI.jaxx @@ -33,29 +33,14 @@ jaxx.runtime.swing.CardLayout2 jaxx.runtime.swing.wizard.ext.WizardState - java.beans.PropertyChangeEvent - - javax.swing.ListSelectionModel </import> <!-- un etat pour savoir quand on peut activer l'action apply --> <Boolean id='canApply' javaBean='false'/> - <Object id='obsoleteEntity' javaBean='null'/> - <Object id='safeEntity' javaBean='null'/> - <SynchronizeUIHandler id='handler' constructorParams='this'/> - <SynchronizeModel id='stepModel' - initializer='getModel().getSynchronizeReferentielModel()'/> - - <DefaultListModel id='errorsModel'/> - - <ObsoleteEntityTableModel id='obsoleteTableModel' - onTableChanged='getHandler().updateCanApply();'/> - - <DefaultListSelectionModel id='errorsSelectionModel' - onValueChanged='if (!event.getValueIsAdjusting() && !errorsSelectionModel.isSelectionEmpty()) { getHandler().updateSelectedObsoleteEntity(); }'/> + <SynchronizeModel id='stepModel' initializer='getModel().getSynchronizeReferentielModel()'/> <CardLayout2 id='safeRefsPanelLayout'/> @@ -71,11 +56,9 @@ public void initUI(AdminUI ui) { @Override public void destroy() { - errorsSelectionModel.clearSelection(); - errorsModel.removeAllElements(); - //FIXME - //obsoleteTableModel.initEntity(null); + stepModel.destroy(); super.destroy(); + safeRefsPanelLayout.reset(safeRefsPanel); } @Override @@ -83,18 +66,8 @@ public void updateState(WizardState newState) { getHandler().updateState(this, newState); } -@Override -public void propertyChange(PropertyChangeEvent evt) { - super.propertyChange(evt); - getHandler().onPropertyChanged(evt); -} - protected void apply() { - /*getHandler().resolvObsoleteReferences( - (TopiaEntity) obsoleteEntity, - obsoleteTableModel.getSelectedRefs(), - (TopiaEntity) getHandler().getSafeComboBox().getSelectedItem() - );*/ + getHandler().resolveObsoleteReference(); } ]]> @@ -105,8 +78,7 @@ protected void apply() { weighty='1'> <row> <cell> - <JButton id='startAction' - onActionPerformed="getHandler().doStartAction()"/> + <JButton id='startAction' onActionPerformed="getHandler().doStartAction()"/> </cell> </row> </Table> @@ -114,33 +86,12 @@ protected void apply() { <JPanel id='NEED_FIX_content'> <JScrollPane id='errorsPane' constraints='BorderLayout.NORTH'> - <JList id='errors'/> + <JList id='obsoleteReferencesList'/> </JScrollPane> <Table fill='both' constraints='BorderLayout.CENTER' border='{new TitledBorder(t("observe.synchro.obsolete.entity.fix"))}'> - <!-- rappel de l'entité obsolete a traiter --> - <row> - <cell> - <JLabel text='observe.synchro.obsolete.entity.to.change.label'/> - </cell> - <cell weightx='1' fill='both'> - <!-- rappel de l'entité obsolete a traiter --> - <JLabel id='obsoleteRefLabel'/> - </cell> - </row> - - <!-- table des références sur l'entité --> - <row> - <cell fill='both' columns='2' weighty='1'> - - <!-- table des références sur l'entité obsolète --> - <JScrollPane> - <JTable id='obsoleteRefs'/> - </JScrollPane> - </cell> - </row> <row> <cell> <JLabel text='observe.synchro.safe.entity.to.choose.label'/> @@ -159,8 +110,7 @@ protected void apply() { <row> <cell columns='2'> <!-- pour appliquer les remplacements de l'entité obsolète --> - <JButton id='applyAction' - onActionPerformed='apply()'/> + <JButton id='applyAction' onActionPerformed='getHandler().resolveObsoleteReference()'/> </cell> </row> </Table> diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUI.jcss b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUI.jcss index 274ee84..c8327d6 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUI.jcss +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUI.jcss @@ -28,10 +28,6 @@ layout:{new BorderLayout()}; } -#errorsSelectionModel { - selectionMode:{ListSelectionModel.SINGLE_SELECTION}; -} - #startAction { actionIcon:"wizard-start"; } @@ -39,14 +35,11 @@ #errorsPane { columnHeaderView:{new JLabel(t("observe.synchro.obsolete.entities.list"))}; } -#errors { - model:{errorsModel}; - selectionModel:{errorsSelectionModel}; - cellRenderer:{new ObsoleteEntityListCellRenderer()}; -} -#obsoleteRefs { - model:{obsoleteTableModel}; +#obsoleteReferencesList { + model:{getStepModel().getObsoleteReferences()}; + selectionModel:{getStepModel().getObsoleteReferencesSelectionModel()}; + cellRenderer:{new ObsoleteReferentialReferenceListCellRenderer()}; } #safeRefsPanel { diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java index f1d4df6..a1a22ec 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java @@ -21,43 +21,38 @@ */ package fr.ird.observe.ui.admin.synchronize; -import fr.ird.observe.ui.DecoratorService; +import com.google.common.collect.ImmutableSet; import fr.ird.observe.db.ObserveSwingDataSource; -import fr.ird.observe.services.dto.AbstractObserveDto; -import fr.ird.observe.ui.UIHelper; -import fr.ird.observe.ui.admin.AdminStep; -import fr.ird.observe.ui.admin.AdminTabUI; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeCallbackRequest; +import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeCallbackRequests; +import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeCallbackResults; +import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeContext; +import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeEngine; +import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeResult; import fr.ird.observe.ui.admin.AdminTabUIHandler; import fr.ird.observe.ui.admin.AdminUI; +import fr.ird.observe.ui.util.decorator.ReferentialReferenceDecorator; import jaxx.runtime.swing.CardLayout2; -import jaxx.runtime.swing.editor.MyDefaultCellEditor; import jaxx.runtime.swing.editor.bean.BeanComboBox; +import jaxx.runtime.swing.model.JaxxDefaultListModel; import jaxx.runtime.swing.wizard.ext.WizardState; -import org.apache.commons.collections.CollectionUtils; -import org.apache.commons.jxpath.JXPathContext; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang3.tuple.Pair; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.nuiton.decorator.Decorator; -import org.nuiton.decorator.JXPathDecorator; -import javax.swing.DefaultListModel; +import javax.swing.DefaultListSelectionModel; import javax.swing.JPanel; -import javax.swing.JTable; -import javax.swing.table.DefaultTableCellRenderer; -import java.awt.event.MouseAdapter; -import java.awt.event.MouseEvent; -import java.beans.PropertyChangeEvent; -import java.beans.PropertyChangeListener; +import javax.swing.ListSelectionModel; +import javax.swing.event.ListSelectionEvent; import java.util.ArrayList; -import java.util.Collections; +import java.util.Collection; import java.util.Date; -import java.util.Iterator; +import java.util.LinkedList; import java.util.List; -import java.util.Map; -import java.util.SortedMap; -import java.util.concurrent.Callable; +import java.util.stream.Collectors; -import static org.nuiton.i18n.I18n.n; import static org.nuiton.i18n.I18n.t; /** @@ -69,8 +64,7 @@ import static org.nuiton.i18n.I18n.t; public class SynchronizeUIHandler extends AdminTabUIHandler { /** Logger */ - private static final Log log = - LogFactory.getLog(SynchronizeUIHandler.class); + private static final Log log = LogFactory.getLog(SynchronizeUIHandler.class); public SynchronizeUIHandler(SynchronizeUI ui) { super(ui); @@ -90,743 +84,330 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { super.initTabUI(ui, tabUI); if (log.isDebugEnabled()) { - log.debug(" specialized for [" + tabUI.getStep() + - "] for main ui " + ui.getClass().getName() + - "@" + System.identityHashCode(ui)); + log.debug(" specialized for [" + tabUI.getStep() + "] for main ui " + ui.getClass().getName() + "@" + System.identityHashCode(ui)); } - // tableau de la synchronisation des données des references obsoletes - - final JTable table = tabUI.getObsoleteRefs(); - table.setRowHeight(24); - UIHelper.fixTableColumnWidth(table, 0, 20); - - UIHelper.setI18nTableHeaderRenderer( - table, - n("observe.synchro.table.obsolete.entity.select"), - n("observe.synchro.table.obsolete.entity.select.tip"), - n("observe.synchro.table.obsolete.entity.label"), - n("observe.synchro.table.obsolete.entity.label.tip")); - - DefaultTableCellRenderer renderer = new DefaultTableCellRenderer(); - - tabUI.getStartAction().setText( - t("observe.action.synchro.launch.operation", - t(tabUI.getStep().getOperationLabel()))); - - tabUI.setContextValue(renderer, "defaultTableRenderer"); - - UIHelper.setTableColumnRenderer( - table, - 0, - UIHelper.newBooleanTableCellRenderer(renderer)); - //FIXME -// UIHelper.setTableColumnRenderer( -// table, 1, -// UIHelper.newDecorateTableCellRenderer(renderer, -// TopiaEntityRef.class) -// ); - UIHelper.setTableColumnEditor( - table, - 0, - MyDefaultCellEditor.newBooleanEditor(false)); - - // pour tout selectionner - deselectionner dans l'entete du tableau - table.getTableHeader().addMouseListener(new MouseAdapter() { - - @Override - public void mouseClicked(MouseEvent e) { - - int colIndex = - table.getTableHeader().columnAtPoint(e.getPoint()); - colIndex = table.convertColumnIndexToModel(colIndex); - if (colIndex == 0) { - ObsoleteEntityTableModel model = - (ObsoleteEntityTableModel) table.getModel(); - boolean oldValue = model.isSelectAll(); - // toggle selectAll - model.setSelectAll(!oldValue); - } - } - }); + tabUI.getStartAction().setText(t("observe.action.synchro.launch.operation", t(tabUI.getStep().getOperationLabel()))); + + DefaultListSelectionModel obsoleteReferenceSelectionModel = tabUI.getModel().getSynchronizeReferentielModel().getObsoleteReferencesSelectionModel(); + obsoleteReferenceSelectionModel.addListSelectionListener(this::updateSelectedObsoleteEntity); + obsoleteReferenceSelectionModel.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); + } - @Override - public void updateState(AdminTabUI tabUI, WizardState newState) { - super.updateState(tabUI, newState); - if (newState == WizardState.NEED_FIX) { - //FIXME -// setObsoleteRefs(getStepModel().getObsoleteRefs()); - } + public void doStartAction() { + + addAdminWorker(getUi().getStartAction().getToolTipText(), this::doAction); + } - public void onPropertyChanged(PropertyChangeEvent evt) { - - String propertyName = evt.getPropertyName(); - - if ("refsResolved".equals(propertyName)) { - - updateSelectedObsoleteEntity(); - - } else if ("obsoleteResolved".equals(propertyName)) { - SynchronizeUI ui = (SynchronizeUI) evt.getSource(); - SynchronizeModel model = ui.getStepModel(); - AbstractObserveDto entity = (AbstractObserveDto) evt.getNewValue(); - DecoratorService decoratorService = getDecoratorService(); - String type = t(DecoratorService.getEntityLabel(entity.getClass())); - Decorator<?> decorator = - decoratorService.getDecoratorByType(entity.getClass()); - String label = t("observe.synchro.obsolete.entity.label", - type, decorator.toString(entity)); - sendMessage(t("observe.synchro.message.obsolete.entities.fixed", - label)); - - //FIXME -// if (model.getObsoleteRefs().isEmpty()) { -// sendMessage( -// t("observe.synchro.message.all.obsolete.entities.fixed") -// ); -// } else { -// //on recharge le dictionnaire des references -// setObsoleteRefs(model.getObsoleteRefs()); -// } + public WizardState doAction() throws Exception { + + if (log.isDebugEnabled()) { + log.debug(this); } + + SynchronizeModel stepModel = getStepModel(); + + // on cree les sources de données + + ObserveSwingDataSource source = model.getSafeLocalSource(false); + stepModel.setSource(source); + + ObserveSwingDataSource centralSource = model.getSafeCentralSource(false); + stepModel.setCentralSource(centralSource); + + openSource(source); + openSource(centralSource); + + // construction du différentiel + sendMessage(t("observe.message.synchro.build.diff", centralSource.getLabel())); + + + UnidirectionalReferentialSynchronizeEngine engine = new UnidirectionalReferentialSynchronizeEngine( + source.newUnidirectionalReferentialSynchronizeLocalService(), + centralSource.newUnidirectionalReferentialSynchronizeRemoteService()); + + stepModel.setEngine(engine); + + UnidirectionalReferentialSynchronizeContext unidirectionalReferentialSynchronizeContext = engine.prepareContext(); + + stepModel.setReferentialSynchronizeContext(unidirectionalReferentialSynchronizeContext); + + boolean needCallback = unidirectionalReferentialSynchronizeContext.isNeedCallback(); + + if (needCallback) { + + // il existe des références obsolètes à traiter + + sendMessage(t("observe.message.synchro.operation.needFix")); + + stepModel.setReferentialSynchronizeCallbackResults(new UnidirectionalReferentialSynchronizeCallbackResults()); + + // des références obsolètes ont été détectées, on prépare les interfaces graphiques + // avec les données à corriger + + List<ObsoleteReferentialReference> obsoleteReferentialReferences = new LinkedList<>(); + UnidirectionalReferentialSynchronizeCallbackRequests callbackRequests = stepModel.getReferentialSynchronizeContext().getCallbackRequests(); + + for (UnidirectionalReferentialSynchronizeCallbackRequest<?> callbackRequest : callbackRequests) { + + String referentialName = callbackRequest.getReferentialName(); + + obsoleteReferentialReferences.addAll( + callbackRequest.getReferentialsToReplace().stream() + .map(referentialReference -> new ObsoleteReferentialReference(referentialName, referentialReference)) + .collect(Collectors.toList())); + + } + + stepModel.setObsoleteReferences(obsoleteReferentialReferences); + + return WizardState.NEED_FIX; + + } + + // pas de reference obsolete à traiter + + // on termine le traitement + beforeSuccess(); + + return WizardState.SUCCESSED; + } - //FIXME -// public void setObsoleteRefs(SortedMap<AbstractObserveDto, List<TopiaEntityRef>> refs) { -// SynchronizeUI ui = getUi(); -// ui.errorsSelectionModel.clearSelection(); -// ui.errorsModel.removeAllElements(); -// for (Object entry : refs.entrySet()) { -// ui.errorsModel.addElement(entry); -// } -// ui.setCanApply(false); -// ui.errors.setSelectedIndex(0); -// } + public void resolveObsoleteReference() { - @SuppressWarnings({"unchecked"}) - public void updateSelectedObsoleteEntity() { - SynchronizeUI ui = getUi(); + ObsoleteReferentialReference obsoleteRef = (ObsoleteReferentialReference) getUi().getObsoleteReferencesList().getSelectedValue(); - int row = ui.errorsSelectionModel.getMinSelectionIndex(); + BeanComboBox<?> safeComboBox = getSafeComboBox(); + ReferentialReference safeRef = (ReferentialReference) safeComboBox.getSelectedItem(); + + UnidirectionalReferentialSynchronizeCallbackResults referentialSynchronizeCallbackResults = getStepModel().getReferentialSynchronizeCallbackResults(); + referentialSynchronizeCallbackResults.addCallbackResult(obsoleteRef.getReferentialName(), obsoleteRef.getId(), safeRef.getId()); + + // On supprime le référentiel corrigé de la liste des référentiels à corriger + + getStepModel().getObsoleteReferences().removeElement(obsoleteRef); + + // S'il ne reste plus de référentiel à corriger, on peut terminer le traitement + + if (getStepModel().getObsoleteReferences().isEmpty()) { + + beforeSuccess(); + + updateState(getUi(), WizardState.SUCCESSED); + + } - DefaultListModel errorsModel = ui.errorsModel; - //FIXME -// if (row == -1 || errorsModel.getElementAt(row) == null || -// ((Map.Entry<TopiaEntity, List<TopiaEntityRef>>) -// errorsModel.getElementAt(row)).getValue().isEmpty()) { -// // entree supprimee -// -// ui.obsoleteRefLabel.setText(""); -// ui.setObsoleteEntity(null); -// ui.obsoleteTableModel.initEntity(Collections.<TopiaEntityRef>emptyList()); -// } else { -// -// Map.Entry<TopiaEntity, List<TopiaEntityRef>> entry = -// (Map.Entry<TopiaEntity, List<TopiaEntityRef>>) -// errorsModel.getElementAt(row); -// TopiaEntity entity = entry.getKey(); -// ui.setObsoleteEntity(entity); -// -// List<TopiaEntityRef> refs = entry.getValue(); -// -// DecoratorService decoratorService = getDecoratorService(); -// String type = DecoratorService.getEntityLabel(entity.getClass()); -// Decorator<?> decorator = -// decoratorService.getDecoratorByType(entity.getClass()); -// String label = t("observe.synchro.obsolete.entity.label", -// type, -// decorator.toString(entity)); -// ui.obsoleteRefLabel.setText(label); -// -// changeSafeRefsComboBox(entry); -// -// ui.obsoleteTableModel.initEntity(refs); -// } } - public void updateCanApply() { + private void updateSelectedObsoleteEntity(ListSelectionEvent e) { + + if (e.getValueIsAdjusting()) { + return; + } + SynchronizeUI ui = getUi(); - ui.setCanApply(!ui.obsoleteTableModel.getSelectedIndex().isEmpty() && - getSafeComboBox() != null && - getSafeComboBox().getSelectedItem() != null); + int row = getStepModel().getObsoleteReferencesSelectionModel().getMinSelectionIndex(); + + JaxxDefaultListModel<ObsoleteReferentialReference> obsoleteReferences = getStepModel().getObsoleteReferences(); + + if (row != -1 && obsoleteReferences.getElementAt(row) != null) { + + ObsoleteReferentialReference referentialReference = obsoleteReferences.getElementAt(row); + + String key = referentialReference.getReferentialName(); + CardLayout2 safeRefsPanelLayout = ui.getSafeRefsPanelLayout(); + JPanel safeRefsPanel = ui.getSafeRefsPanel(); + if (safeRefsPanelLayout.contains(key)) { + + // la liste déroulante existe deja pour ce type + BeanComboBox<?> list = (BeanComboBox<?>) safeRefsPanelLayout.getComponent(safeRefsPanel, key); + + if (!getSafeComboBox().equals(list)) { + + // on l'affiche + safeRefsPanelLayout.show(safeRefsPanel, key); + + } + + } else { + + ReferentialReferenceDecorator decorator = getDecoratorService().getReferentialReferenceDecorator(referentialReference.getType()); + + UnidirectionalReferentialSynchronizeCallbackRequest<?> callbackRequest = getStepModel().getReferentialSynchronizeContext().getCallbackRequests().getCallbackRequest(key); + ImmutableSet<? extends ReferentialReference<?>> availableReferentials = callbackRequest.getAvailableReferentials(); + + List<ReferentialReference> data = new ArrayList<>(availableReferentials); + + // la liste n'existe pas encore + BeanComboBox<ReferentialReference> box = new BeanComboBox<>(ui); + box.setBean(this); + box.setProperty("safeEntity"); + box.setShowReset(true); + box.addPropertyChangeListener("selectedItem", evt -> updateCanApply()); + safeRefsPanel.add(box, key); + box.init(decorator, data); + + safeRefsPanelLayout.show(safeRefsPanel, key); + + } + + } } - public BeanComboBox<?> getSafeComboBox() { + private BeanComboBox<?> getSafeComboBox() { SynchronizeUI ui = getUi(); - JPanel panel = ui.getSafeRefsPanel(); - return (BeanComboBox<?>) - ui.getSafeRefsPanelLayout().getVisibleComponent(panel); + return (BeanComboBox<?>) ui.getSafeRefsPanelLayout().getVisibleComponent(panel); } - @SuppressWarnings({"unchecked"}) - //FIXME -// public void changeSafeRefsComboBox(Map.Entry<TopiaEntity, List<TopiaEntityRef>> entry) { -// SynchronizeUI ui = getUi(); + private void updateCanApply() { + SynchronizeUI ui = getUi(); + BeanComboBox<?> safeComboBox = getSafeComboBox(); + ui.setCanApply(safeComboBox != null && safeComboBox.getSelectedItem() != null); + } -// TopiaEntity entity = entry.getKey(); -// -// ObserveEntityEnum constant = ObserveEntityEnum.valueOf(entity); -// String key = constant.getContract().getName(); -// CardLayout2 safeRefsPanelLayout = ui.getSafeRefsPanelLayout(); -// JPanel safeRefsPanel = ui.getSafeRefsPanel(); -// if (safeRefsPanelLayout.contains(key)) { -// -// // la liste déroulante existe deja pour ce type -// BeanComboBox<?> list = (BeanComboBox<?>) -// safeRefsPanelLayout.getComponent(safeRefsPanel, key); -// -// if (!getSafeComboBox().equals(list)) { -// // on l'affiche -// safeRefsPanelLayout.show(safeRefsPanel, key); -// } -// return; -// } -// -// Decorator<?> decorator = -// getDecoratorService().getDecoratorByType(entity.getClass()); -// -// List<?> data = getEntityListFromSynchroDB(entity.getClass(), true); -// -// // la liste n'existe pas encore -// BeanComboBox<?> box = new BeanComboBox(ui); -// box.setBean(this); -// box.setProperty("safeEntity"); -// box.setShowReset(true); -// box.addPropertyChangeListener( -// "selectedItem", -// new PropertyChangeListener() { -// @Override -// public void propertyChange(PropertyChangeEvent evt) { -// updateCanApply(); -// } -// }); -// safeRefsPanel.add(box, key); -// box.init((JXPathDecorator) decorator, (List) data); -// -// safeRefsPanelLayout.show(safeRefsPanel, key); -// } + private void beforeSuccess() { - public void doStartAction() { + SynchronizeModel stepModel = getStepModel(); + + UnidirectionalReferentialSynchronizeEngine engine = stepModel.getEngine(); + + UnidirectionalReferentialSynchronizeContext referentialSynchronizeContext = stepModel.getReferentialSynchronizeContext(); + + UnidirectionalReferentialSynchronizeCallbackResults referentialSynchronizeCallbackResults = stepModel.getReferentialSynchronizeCallbackResults(); + + UnidirectionalReferentialSynchronizeResult referentialSynchronizeResult = engine.finish(referentialSynchronizeContext, referentialSynchronizeCallbackResults); + stepModel.setReferentialSynchronizeResult(referentialSynchronizeResult); + + if (referentialSynchronizeResult.isEmpty()) { + + sendMessage(t("observe.message.synchro.ref.is.updtodate")); + + } else { + + for (String referentialName : referentialSynchronizeResult.getReferentialNames()) { + + Collection<String> referentialAdded = referentialSynchronizeResult.getReferentialAdded(referentialName); + if (CollectionUtils.isNotEmpty(referentialAdded)) { - addAdminWorker( - getUi().getStartAction().getToolTipText(), - new Callable<WizardState>() { - @Override - public WizardState call() throws Exception { - return doAction(); + sendMessage(t("observe.message.synchro.referentiel.was.added", referentialAdded.size())); + for (String id : referentialAdded) { + sendMessage(" - " + id); } + } - ); - } - public WizardState doAction() throws Exception { + Collection<String> referentialUpdated = referentialSynchronizeResult.getReferentialUpdated(referentialName); + if (CollectionUtils.isNotEmpty(referentialUpdated)) { - if (log.isDebugEnabled()) { - log.debug(this); - } - - // on cree les sources de données + sendMessage(t("observe.message.synchro.referentiel.was.modified", referentialUpdated.size())); + for (String id : referentialUpdated) { + sendMessage(" - " + id); + } - ObserveSwingDataSource source = model.getSafeLocalSource(false); - getStepModel().setSource(source); - ObserveSwingDataSource centralSource = model.getSafeCentralSource(false); - getStepModel().setCentralSource(centralSource); + } - openSource(source); - openSource(centralSource); + Collection<String> referentialRemoved = referentialSynchronizeResult.getReferentialRemoved(referentialName); + if (CollectionUtils.isNotEmpty(referentialRemoved)) { - // construction du différentiel - sendMessage(t("observe.message.synchro.build.diff", - centralSource.getLabel())); - - //FIXME -// DiffState.DiffStateMap diff = -// getDataService().buildReferentielDifferentiel(centralSource, -// source, -// this -// ); -// getStepModel().setDiff(diff); -// -// if (diff.isEmpty() || -// CollectionUtils.isEmpty(diff.get(DiffState.REMOVED))) { -// -// // aucune modification du référentiel -// // ou aucune entité obsolète -// // aucune intervention requise -// -// reportSuccess(); -// -// // pas de reference obsolete a traiter -// return WizardState.SUCCESSED; -// } -// -// // detection des entités obsoletes -// -// SortedMap<TopiaEntity, List<TopiaEntityRef>> obsoleteRefs = -// detectObsoleteEntities(); -// getStepModel().setObsoleteRefs(obsoleteRefs); -// -// if (obsoleteRefs == null || obsoleteRefs.isEmpty()) { -// -// reportSuccess(); -// -// // pas de reference obsolete a traiter -// return WizardState.SUCCESSED; -// } -// -// // il existe des entités obsolètes utilisées dans la base locale -// -// // on conserve la liste complète des entités qui utilisent des -// // référentiels obsolètes (on va les recopier plus tard) -// -// List<TopiaEntity> obsoleteEntities = -// new ArrayList<TopiaEntity>(obsoleteRefs.keySet()); -// -// // on filtre les entités obsolètes directes (les seuls que l'utilisateur -// // peut changer) -// -// removeUndirectObsoleteRefs(); -// -// if (obsoleteRefs.isEmpty()) { -// -// reportSuccess(); -// -// // pas de reference obsolete directe a traiter -// return WizardState.SUCCESSED; -// } -// -// // dernier cas (le seul demandant une intervention humaine) -// // il y a des références obsolètes directes sur des données observers -// -// // on mets en place une base temporaire pour effectuer les corrections -// -// sendMessage( -// t("observe.message.synchro.create.temporary.db.to.resolve.obsoletes")); -// -// DataSource tmpSource = model.getSafeTmpSource(false); -// getStepModel().setTmpSource(tmpSource); -// openSource(tmpSource); -// -// // duplication du referentiel à jour vers la base temporaire -// replicateReferentiel(centralSource, tmpSource); -// -// // duplication des objets de la base locale qui utilisent les données obsolètes -// replicateObsoletesEntities(obsoleteEntities, source, tmpSource); -// -// // on injecte toutes les donnes utilisateurs dans la base de synchro -// // car on va ensuite remplacer -// replicateData(source, tmpSource); -// -// // la synchronisation demande des modification de la base locale -// // on enregistre cette action aupres de l'action de sauvegarde -// model.getSaveLocalModel().addStepForSave(AdminStep.SYNCHRONIZE); -// -// sendMessage(t("observe.message.synchro.operation.needFix")); + sendMessage(t("observe.message.synchro.referentiel.was.removed", referentialRemoved.size())); + for (String id : referentialRemoved) { + sendMessage(" - " + id); + } - return WizardState.NEED_FIX; - } + } - public void reportSuccess() { - boolean needSave = false; + Collection<Pair<String, String>> referentialReplaced = referentialSynchronizeResult.getReferentialReplaced(referentialName); + if (CollectionUtils.isNotEmpty(referentialReplaced)) { -// DiffState.DiffStateMap diff = getStepModel().getDiff(); -// -// List<String> ids = diff.get(DiffState.REMOVED); -// if (!CollectionUtils.isEmpty(ids)) { -// // des doonées ont ete supprimées du referentiel distant -// needSave = true; -// sendMessage( -// t("observe.message.synchro.referentiel.was.removed", -// ids.size())); -// for (String id : ids) { -// sendMessage(" - " + id); -// } -// } -// -// ids = diff.get(DiffState.NEW); -// if (!CollectionUtils.isEmpty(ids)) { -// // des données ont ete ajoutees au referentiel distant -// needSave = true; -// sendMessage(t("observe.message.synchro.referentiel.was.added", -// ids.size())); -// for (String id : ids) { -// sendMessage(" - " + id); -// } -// } -// -// ids = diff.get(DiffState.MODIFIED); -// if (!CollectionUtils.isEmpty(ids)) { -// // des doonées ont ete modifiees dans le referentiel distant -// needSave = true; -// sendMessage( -// t("observe.message.synchro.referentiel.was.modified", -// ids.size())); -// for (String id : ids) { -// sendMessage(" - " + id); -// } -// } -// -// if (needSave) { -// // des données doivent être transférer vers la base locale -// model.getSaveLocalModel().addStepForSave( -// AdminStep.SYNCHRONIZE); -// sendMessage(t("observe.message.synchro.local.modification")); -// sendMessage( -// t("observe.message.synchro.no.referentiel.conflict")); -// -// } else { -// sendMessage(t("observe.message.synchro.ref.is.updtodate")); -// } + sendMessage(t("observe.message.synchro.referentiel.was.replaced", referentialReplaced.size())); + for (Pair<String, String> ids : referentialReplaced) { + sendMessage(" - " + ids.getLeft() + " → " + ids.getRight()); + } - sendMessage( - t("observe.message.synchro.operation.done", new Date())); - } + } - //FIXME -// protected SortedMap<TopiaEntity, List<TopiaEntityRef>> detectObsoleteEntities() throws Exception { -// -// DiffState.DiffStateMap diff = getStepModel().getDiff(); -// -// DataSource source = getStepModel().getSource(); -// -// // detection des entites obsoletes -// -// List<String> removedList = diff.get(DiffState.REMOVED); -// -// String[] ids = removedList.toArray(new String[removedList.size()]); -// -// TopiaContext tx = beginTransaction(source, "detectObsoleteRefs"); -// -// // detection des entites obsoletes -// -// try { -// // des suppressions ont ete detectees, on doit retrouver -// // dans la base locale les entites utilisant ces entites -// // obsoletes -// List<TripSeine> marees = ObserveDAOHelper.getTripSeineDAO(tx).findAll(); -// -// ObserveEntityEnum[] contracts = ObserveDAOHelper.getContracts(); -// -// SortedMap<TopiaEntity, List<TopiaEntityRef>> result; -// -// result = TopiaEntityHelper.detectReferences(contracts, ids, marees); -// return result; -// } finally { -// closeTransaction(source, tx, "detectObsoleteRefs"); -// } -// } + } - //FIXME -// protected void removeUndirectObsoleteRefs() { -// -// Iterator<Map.Entry<TopiaEntity, List<TopiaEntityRef>>> itr; -// -// SortedMap<TopiaEntity, List<TopiaEntityRef>> obsoleteRefs = -// getStepModel().getObsoleteRefs(); -// -// for (itr = obsoleteRefs.entrySet().iterator(); itr.hasNext(); ) { -// Map.Entry<TopiaEntity, List<TopiaEntityRef>> entry = itr.next(); -// for (Iterator<TopiaEntityRef> itrRef = -// entry.getValue().iterator(); itrRef.hasNext(); ) { -// TopiaEntityRef ref = itrRef.next(); -// TopiaEntity refInvoker = ref.getInvoker(); -// if (refInvoker == null) { -// // on est sur un program -// // et on ne va pas resoudre un program obsolete -// itrRef.remove(); -// if (log.isTraceEnabled()) { -// log.trace("remove ref " + ref); -// } -// continue; -// } -// -// ObserveEntityEnum refConstant = -// ObserveEntityEnum.valueOf(refInvoker); -// if (!Entities.DATA_ENTITIES_LIST.contains( -// refConstant)) { -// // on peut supprimer cette référence -// itrRef.remove(); -// if (log.isTraceEnabled()) { -// log.trace("remove ref " + ref); -// } -// } -// } -// if (entry.getValue().isEmpty()) { -// // on peut supprimer cette entité obsolete car plus de -// // references dessus -// itr.remove(); -// if (log.isDebugEnabled()) { -// log.debug("remove obsolete entity (not direct " + -// "referentiel) : " + -// entry.getKey().getTopiaId()); -// } -// } -// } -// } + } - //FIXME -// protected void replicateObsoletesEntities( -// List<TopiaEntity> obsoleteEntities, -// DataSource source, -// DataSource tmpSource) throws Exception { -// -// String txName = "replicateObsoletesEntities"; -// TopiaContext sourceCtxt = beginTransaction(source, txName); -// try { -// TopiaContext tmpCtxt = beginTransaction(tmpSource, txName); -// try { -// for (ObserveEntityEnum constant : Entities.REFERENCE_ENTITIES) { -// Class<? extends TopiaEntity> contractClass = -// constant.getContract(); -// List<TopiaEntity> toReplicate = new ArrayList<TopiaEntity>(); -// for (Iterator<TopiaEntity> itr = -// obsoleteEntities.iterator(); itr.hasNext(); ) { -// TopiaEntity e = itr.next(); -// if (contractClass.isAssignableFrom(e.getClass())) { -// if (log.isDebugEnabled()) { -// log.debug("obsolete to inject : " + -// e.getTopiaId()); -// } -// itr.remove(); -// -// // cet objet doit etre replique -// toReplicate.add(e); -// -// sendMessage(t("observe.message.synchro.obsolete.data.to.duplicate", e)); -// } -// } -// if (toReplicate.isEmpty()) { -// if (log.isDebugEnabled()) { -// log.debug("no obsolete entity " + constant); -// } -// continue; -// } -// -// if (log.isDebugEnabled()) { -// log.debug("inject obsolete entity " + constant + " (" + -// toReplicate.size() + ")"); -// } -// sourceCtxt.replicateEntities(tmpCtxt, toReplicate); -// commitTransaction(tmpSource, tmpCtxt, txName); -// } -// -// } finally { -// closeTransaction(tmpSource, tmpCtxt, txName); -// } -// } finally { -// closeTransaction(source, sourceCtxt, txName); -// } -// -// if (!obsoleteEntities.isEmpty()) { -// throw new IllegalStateException( -// "there is still obsolete entities to inject in " + -// "synchro db : " + obsoleteEntities); -// } -// } + sendMessage(t("observe.message.synchro.operation.done", new Date())); - public List<?> getEntityListFromSynchroDB(Class<?> type, - boolean removeObsoletes) { - - //FIXME -// DataSource tmpSource = getStepModel().getTmpSource(); -// List<?> list; -// try { -// ObserveEntityEnum constant = ObserveEntityEnum.valueOf(type); -// list = getDataService().getList(tmpSource, constant.getContract()); -// } catch (DataSourceException ex) { -// //TODO should do better... -// if (log.isErrorEnabled()) { -// log.error(ex); -// } -// list = new ArrayList(); -// } -// if (removeObsoletes) { -// -// DiffState.DiffStateMap diff = getStepModel().getDiff(); -// -// List<String> removedList = diff.get(DiffState.REMOVED); -// for (Iterator<?> itr = list.iterator(); itr.hasNext(); ) { -// TopiaEntity e = (TopiaEntity) itr.next(); -// if (removedList.contains(e.getTopiaId())) { -// // c'est une entite qui est obsolete, l'utilisateur -// // ne peut pas l'utiliser -// itr.remove(); -// } -// } -// } -// return list; - return null; } - //FIXME -// public void resolvObsoleteReferences(TopiaEntity obsoleteRef, -// List<TopiaEntityRef> refs, -// TopiaEntity safeRef) { -// -// ObsoleteRefReplaceAction action = new ObsoleteRefReplaceAction( -// obsoleteRef.getTopiaId(), -// safeRef.getTopiaId(), -// refs); -// -// SynchronizeModel stepModel = getStepModel(); -// stepModel.getReplaceActions().add(action); -// -// SortedMap<TopiaEntity, List<TopiaEntityRef>> obsoleteRefs = -// stepModel.getObsoleteRefs(); -// -// List<TopiaEntityRef> globalRefs = obsoleteRefs.get(obsoleteRef); -// -// DataSource tmpSource = stepModel.getTmpSource(); -// -// String txName = "resolvObsoleteReferences"; -// TopiaContext tx = null; -// try { -// tx = beginTransaction(tmpSource, txName); -// -// action.doAction(tx); -// -// commitTransaction(tmpSource, tx, txName); -// -// // on supprime toutes les références traitées -// globalRefs.removeAll(refs); + +// public void changeSafeRefsComboBox(ObsoleteReferentialReference referentialReference) { // -// ui.firePropertyChange("refsResolved", null, obsoleteRef); +// SynchronizeUI ui = getUi(); // -// if (globalRefs.isEmpty()) { +// String key = referentialReference.getReferentialName(); +// CardLayout2 safeRefsPanelLayout = ui.getSafeRefsPanelLayout(); +// JPanel safeRefsPanel = ui.getSafeRefsPanel(); +// if (safeRefsPanelLayout.contains(key)) { // -// // la reference obsolete n'est pas utilisee dans aucune donnee +// // la liste déroulante existe deja pour ce type +// BeanComboBox<?> list = (BeanComboBox<?>) safeRefsPanelLayout.getComponent(safeRefsPanel, key); // -// obsoleteRefs.remove(obsoleteRef); +// if (!getSafeComboBox().equals(list)) { // -// if (log.isDebugEnabled()) { -// log.debug("remove resolved obsolete property from temp " + -// "db : " + obsoleteRef.getTopiaId()); -// } +// // on l'affiche +// safeRefsPanelLayout.show(safeRefsPanel, key); // -// obsoleteRef = tx.findByTopiaId(obsoleteRef.getTopiaId()); +// } // -// // on peut la supprimer de la base temporaire -// getDAO(tx, obsoleteRef).delete(obsoleteRef); +// } else { // -// ui.firePropertyChange("obsoleteResolved", null, obsoleteRef); -// } +// ReferentialReferenceDecorator decorator = getDecoratorService().getReferentialReferenceDecorator(referentialReference.getReferentialReference().getType()); // -// commitTransaction(tmpSource, tx, txName); +// UnidirectionalReferentialSynchronizeCallbackRequest<?> callbackRequest = getStepModel().getReferentialSynchronizeContext().getCallbackRequests().getCallbackRequest(key); +// ImmutableSet<? extends ReferentialReference<?>> availableReferentials = callbackRequest.getAvailableReferentials(); // -// if (obsoleteRefs.isEmpty()) { +// List<ReferentialReference> data = new ArrayList<>(availableReferentials); // -// sendMessage( -// t("observe.message.synchro.operation.done", new Date())); +// // la liste n'existe pas encore +// BeanComboBox<ReferentialReference> box = new BeanComboBox<>(ui); +// box.setBean(this); +// box.setProperty("safeEntity"); +// box.setShowReset(true); +// box.addPropertyChangeListener("selectedItem", evt -> updateCanApply()); +// safeRefsPanel.add(box, key); +// box.init(decorator, data); // -// // plus de references obsoletes a resoudre, l'action est -// // terminée -// model.setStepState(WizardState.SUCCESSED); -// } +// safeRefsPanelLayout.show(safeRefsPanel, key); // -// } catch (Exception e) { -// model.setStepState(onError(e)); -// } finally { -// try { -// if (tx != null) { -// closeTransaction(tmpSource, tx, txName); -// } -// } catch (DataSourceException e) { -// model.setStepState(onError(e)); -// } // } // } - //FIXME -// public class ObsoleteRefReplaceAction { +// @Override +// public void updateState(AdminTabUI tabUI, WizardState newState) { // -// /** l'id de l'entité à remplacer */ -// String obsoleteId; -// -// /** l'id de l'entité de remplacement */ -// String safeId; -// -// /** la liste des références à traiter */ -// TopiaEntityRef[] refs; -// -// ObsoleteRefReplaceAction(String obsoleteId, -// String safeId, -// List<TopiaEntityRef> refs) { -// this.obsoleteId = obsoleteId; -// this.refs = refs.toArray(new TopiaEntityRef[refs.size()]); -// this.safeId = safeId; -// } -// -// public void doAction(TopiaContext tx) throws TopiaException { -// -// if (log.isInfoEnabled()) { -// log.info("load obsolete object " + obsoleteId); -// } -// -// if (log.isInfoEnabled()) { -// log.info("load safe object " + safeId); -// } -// -// TopiaEntity safeRef = tx.findByTopiaId(safeId); -// -// // on remplace les references -// for (TopiaEntityRef ref : refs) { -// TopiaEntity invoker = ref.getInvoker(); -// -// if (invoker == null) { -// throw new NullPointerException( -// "can not have a null invoker in " + ref); -// } -// -// if (log.isInfoEnabled()) { -// log.info("load invoker object " + invoker.getTopiaId()); -// } -// -// invoker = tx.findByTopiaId(invoker.getTopiaId()); -// -// // switch entity -// -// String path = ref.getInvokerProperty(); -// -// JXPathContext jxcontext = JXPathContext.newContext(invoker); +// super.updateState(tabUI, newState); +// SynchronizeModel stepModel = getStepModel(); // -// TopiaEntity oldValue = (TopiaEntity) jxcontext.getValue(path); +// if (WizardState.NEED_FIX == newState) { // -// if (log.isDebugEnabled()) { -// log.debug("property to switch " + path + " old : " + -// oldValue); -// } +// // des références obsolètes ont été détectées, on prépare les interfaces graphiques +// // avec les données à corriger // -// if (log.isInfoEnabled()) { -// log.info("change path : " + path); -// log.info("old value : " + oldValue.getTopiaId()); -// } +// List<ObsoleteReferentialReference> obsoleteReferentialReferences = new LinkedList<>(); +// UnidirectionalReferentialSynchronizeCallbackRequests callbackRequests = stepModel.getReferentialSynchronizeContext().getCallbackRequests(); // -// jxcontext.setValue(path, safeRef); +// for (UnidirectionalReferentialSynchronizeCallbackRequest<?> callbackRequest : callbackRequests) { // -// TopiaEntity newValue = (TopiaEntity) jxcontext.getValue(path); +// String referentialName = callbackRequest.getReferentialName(); // -// if (log.isInfoEnabled()) { -// log.info("new value : " + newValue.getTopiaId()); +// for (ReferentialReference<?> referentialReference : callbackRequest.getReferentialsToReplace()) { +// obsoleteReferentialReferences.add(new ObsoleteReferentialReference(referentialName, referentialReference)); // } -// if (log.isDebugEnabled()) { -// log.debug("property to switch " + path + " new : " + -// safeRef); -// log.debug("property to switch " + path + " new Check : " + -// newValue); -// } -// TopiaDAO<TopiaEntity> dao = getDAO(tx, invoker); -// -// dao.update(invoker); // } -// } // -// public String getObsoleteId() { -// return obsoleteId; +// getStepModel().setObsoleteReferences(obsoleteReferentialReferences); +// // } // } -} +} \ No newline at end of file diff --git a/observe-application-swing/src/main/resources/i18n/observe-application-swing_en_GB.properties b/observe-application-swing/src/main/resources/i18n/observe-application-swing_en_GB.properties index 20cd6a9..89c7d0c 100644 --- a/observe-application-swing/src/main/resources/i18n/observe-application-swing_en_GB.properties +++ b/observe-application-swing/src/main/resources/i18n/observe-application-swing_en_GB.properties @@ -1558,6 +1558,7 @@ observe.message.synchro.ref.is.updtodate= observe.message.synchro.referentiel.was.added= observe.message.synchro.referentiel.was.modified= observe.message.synchro.referentiel.was.removed= +observe.message.synchro.referentiel.was.replaced= observe.message.table.editBean.modified= observe.message.table.editBean.modified.but.invalid= observe.message.updating.floatingObject= diff --git a/observe-application-swing/src/main/resources/i18n/observe-application-swing_es_ES.properties b/observe-application-swing/src/main/resources/i18n/observe-application-swing_es_ES.properties index 91d030e..05b92e9 100644 --- a/observe-application-swing/src/main/resources/i18n/observe-application-swing_es_ES.properties +++ b/observe-application-swing/src/main/resources/i18n/observe-application-swing_es_ES.properties @@ -1560,6 +1560,7 @@ observe.message.synchro.ref.is.updtodate=El referencial de la base local está a observe.message.synchro.referentiel.was.added=Se han añadido los datos al referencial remoto (%1$d objeto(s)) observe.message.synchro.referentiel.was.modified=Se han modificado los datos en el referencial remoto (%1$d objeto(s)) observe.message.synchro.referentiel.was.removed=Se han eliminado datos del referencial remoto (%1$d objeto(s)) +observe.message.synchro.referentiel.was.replaced= observe.message.table.editBean.modified=El registro actual se ha modificado y es válido. observe.message.table.editBean.modified.but.invalid=El registro actual se ha modificado pero no es válido. observe.message.updating.floatingObject= diff --git a/observe-application-swing/src/main/resources/i18n/observe-application-swing_fr_FR.properties b/observe-application-swing/src/main/resources/i18n/observe-application-swing_fr_FR.properties index a4e4ff4..fb8556a 100644 --- a/observe-application-swing/src/main/resources/i18n/observe-application-swing_fr_FR.properties +++ b/observe-application-swing/src/main/resources/i18n/observe-application-swing_fr_FR.properties @@ -1547,6 +1547,7 @@ observe.message.synchro.ref.is.updtodate=Le référentiel de la base locale est observe.message.synchro.referentiel.was.added=Des données ont été ajoutées au référentiel distant (%1$d objet(s)) observe.message.synchro.referentiel.was.modified=Des données ont été modifiées sur le référentiel distant (%1$d objet(s)) observe.message.synchro.referentiel.was.removed=Des données ont été supprimées du réferentiel distant (%1$d objet(s)) +observe.message.synchro.referentiel.was.replaced= observe.message.table.editBean.modified=L'entrée en cours d'édition a été modifiée et est valide. observe.message.table.editBean.modified.but.invalid=L'entrée en cours d'édition a été modifiée, mais n'est pas valide. observe.message.updating.floatingObject=L'objet flottant est en cours de modification. -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 a9db9948012902229886b8b5f812e4efe181fba8 Author: Tony CHEMIT <chemit@codelutin.com> Date: Wed Jul 13 13:32:46 2016 +0200 Amélioration du message de résumé --- .../fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java | 8 ++++---- .../resources/i18n/observe-application-swing_fr_FR.properties | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java index a1a22ec..94fde71 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java @@ -294,7 +294,7 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { Collection<String> referentialAdded = referentialSynchronizeResult.getReferentialAdded(referentialName); if (CollectionUtils.isNotEmpty(referentialAdded)) { - sendMessage(t("observe.message.synchro.referentiel.was.added", referentialAdded.size())); + sendMessage(t("observe.message.synchro.referentiel.was.added", referentialName, referentialAdded.size())); for (String id : referentialAdded) { sendMessage(" - " + id); } @@ -304,7 +304,7 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { Collection<String> referentialUpdated = referentialSynchronizeResult.getReferentialUpdated(referentialName); if (CollectionUtils.isNotEmpty(referentialUpdated)) { - sendMessage(t("observe.message.synchro.referentiel.was.modified", referentialUpdated.size())); + sendMessage(t("observe.message.synchro.referentiel.was.modified", referentialName, referentialUpdated.size())); for (String id : referentialUpdated) { sendMessage(" - " + id); } @@ -314,7 +314,7 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { Collection<String> referentialRemoved = referentialSynchronizeResult.getReferentialRemoved(referentialName); if (CollectionUtils.isNotEmpty(referentialRemoved)) { - sendMessage(t("observe.message.synchro.referentiel.was.removed", referentialRemoved.size())); + sendMessage(t("observe.message.synchro.referentiel.was.removed", referentialName, referentialRemoved.size())); for (String id : referentialRemoved) { sendMessage(" - " + id); } @@ -324,7 +324,7 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { Collection<Pair<String, String>> referentialReplaced = referentialSynchronizeResult.getReferentialReplaced(referentialName); if (CollectionUtils.isNotEmpty(referentialReplaced)) { - sendMessage(t("observe.message.synchro.referentiel.was.replaced", referentialReplaced.size())); + sendMessage(t("observe.message.synchro.referentiel.was.replaced", referentialName, referentialReplaced.size())); for (Pair<String, String> ids : referentialReplaced) { sendMessage(" - " + ids.getLeft() + " → " + ids.getRight()); } diff --git a/observe-application-swing/src/main/resources/i18n/observe-application-swing_fr_FR.properties b/observe-application-swing/src/main/resources/i18n/observe-application-swing_fr_FR.properties index fb8556a..07ae77a 100644 --- a/observe-application-swing/src/main/resources/i18n/observe-application-swing_fr_FR.properties +++ b/observe-application-swing/src/main/resources/i18n/observe-application-swing_fr_FR.properties @@ -1544,10 +1544,10 @@ observe.message.synchro.operation.done=Opération terminée le %1$td/%1$tm/%1$tY observe.message.synchro.operation.failed=L'opération a échouée observe.message.synchro.operation.needFix=L'opération requière des corrections. observe.message.synchro.ref.is.updtodate=Le référentiel de la base locale est à jour, aucune correction requise. -observe.message.synchro.referentiel.was.added=Des données ont été ajoutées au référentiel distant (%1$d objet(s)) -observe.message.synchro.referentiel.was.modified=Des données ont été modifiées sur le référentiel distant (%1$d objet(s)) -observe.message.synchro.referentiel.was.removed=Des données ont été supprimées du réferentiel distant (%1$d objet(s)) -observe.message.synchro.referentiel.was.replaced= +observe.message.synchro.referentiel.was.added=Des données (type %s) ont été ajoutées au référentiel distant (%1$d objet(s)) +observe.message.synchro.referentiel.was.modified=Des données (type %s) ont été modifiées sur le référentiel distant (%1$d objet(s)) +observe.message.synchro.referentiel.was.removed=Des données (type %s) ont été supprimées du réferentiel distant (%1$d objet(s)) +observe.message.synchro.referentiel.was.replaced=Des données (type %s) ont été remplacées dans le référentiel local (%1$d objet(s)) observe.message.table.editBean.modified=L'entrée en cours d'édition a été modifiée et est valide. observe.message.table.editBean.modified.but.invalid=L'entrée en cours d'édition a été modifiée, mais n'est pas valide. observe.message.updating.floatingObject=L'objet flottant est en cours de modification. -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 20af7e1a45e4dfb8379a28a4d7a787a852368045 Author: Tony CHEMIT <chemit@codelutin.com> Date: Mon Jul 18 16:30:31 2016 +0200 Revue de la gestion des valeurs primitives --- .../ui/admin/synchronize/SynchronizeUIHandler.java | 1 - .../synchro/InsertSqlStatementGenerator.java | 43 ++++++++++++++++++++++ .../synchro/UpdateSqlStatementGenerator.java | 42 +++++++++++++++++++++ .../persistence/metadata/TopiaMetadataEntity.java | 28 ++++++++++++++ 4 files changed, 113 insertions(+), 1 deletion(-) diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java index d763900..28aa641 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java @@ -334,7 +334,6 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { } - getModel().getSaveLocalModel().setLocalSourceNeedSave(true); getModel().getSaveLocalModel().addStepForSave(AdminStep.SYNCHRONIZE); } diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/InsertSqlStatementGenerator.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/InsertSqlStatementGenerator.java index 760e993..c63641f 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/InsertSqlStatementGenerator.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/InsertSqlStatementGenerator.java @@ -40,6 +40,10 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { private final String[] simplePropertyNames; private final String[] manyToOneAssociationNames; private final Set<ManyToManyAssociationStruct> manyToManyAssociations; + private final Set<String> primitiveBooleanPropertyNames; + private final Set<String> primitiveIntegerPropertyNames; + private final Set<String> primitiveLongPropertyNames; + private final Set<String> primitiveFloatPropertyNames; /** * Pour décrire une association nm. @@ -72,6 +76,10 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { this.tableName = metadataEntity.getDbTableName(); Set<String> propertyNamesSet = metadataEntity.getProperties().keySet(); this.simplePropertyNames = propertyNamesSet.toArray(new String[propertyNamesSet.size()]); + this.primitiveBooleanPropertyNames = metadataEntity.getPrimitivePropertyNames("boolean"); + this.primitiveIntegerPropertyNames = metadataEntity.getPrimitivePropertyNames("int"); + this.primitiveLongPropertyNames = metadataEntity.getPrimitivePropertyNames("long"); + this.primitiveFloatPropertyNames = metadataEntity.getPrimitivePropertyNames("float"); Set<String> manyToOneAssociationNamesSet = metadataEntity.getManyToOneAssociations().keySet(); this.manyToOneAssociationNames = manyToOneAssociationNamesSet.toArray(new String[manyToOneAssociationNamesSet.size()]); @@ -99,6 +107,25 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { Map<String, Object> simpleParameters = binder.obtainProperties(referentialDto, true, true, simplePropertyNames); for (String simplePropertyName : simplePropertyNames) { Object parameterValue = simpleParameters.get(simplePropertyName); + + if (primitiveBooleanPropertyNames.contains(simplePropertyName)) { + addPrimitiveBooleanParameter((Boolean) parameterValue, parameters); + continue; + } + if (primitiveIntegerPropertyNames.contains(simplePropertyName)) { + addPrimitiveIntegerParameter((Integer) parameterValue, parameters); + continue; + } + if (primitiveLongPropertyNames.contains(simplePropertyName)) { + addPrimitiveLongParameter((Long) parameterValue, parameters); + continue; + } + if (primitiveFloatPropertyNames.contains(simplePropertyName)) { + addPrimitiveFloatParameter((Float) parameterValue, parameters); + continue; + } + + if (parameterValue == null) { addNullParameter(parameters); continue; @@ -213,6 +240,22 @@ public class InsertSqlStatementGenerator<R extends ReferentialDto> { parameters.add("'" + parameter + "'"); } + private void addPrimitiveBooleanParameter(Boolean parameter, List<String> parameters) { + parameters.add("" + (parameter != null && parameter)); + } + + private void addPrimitiveIntegerParameter(Integer parameter, List<String> parameters) { + parameters.add("" + (parameter == null ? 0 : parameter)); + } + + private void addPrimitiveLongParameter(Long parameter, List<String> parameters) { + parameters.add("" + (parameter == null ? 0 : parameter)); + } + + private void addPrimitiveFloatParameter(Float parameter, List<String> parameters) { + parameters.add("" + (parameter == null ? 0f : parameter)); + } + private void addTimestampParameter(Date parameter, List<String> parameters) { parameters.add("'" + parameter + "'::timestamp"); } diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UpdateSqlStatementGenerator.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UpdateSqlStatementGenerator.java index 513a5a2..e59f461 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UpdateSqlStatementGenerator.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UpdateSqlStatementGenerator.java @@ -40,6 +40,10 @@ public class UpdateSqlStatementGenerator<R extends ReferentialDto> { private final String[] simplePropertyNames; private final String[] manyToOneAssociationNames; private final Set<ManyToManyAssociationStruct> manyToManyAssociations; + private final Set<String> primitiveBooleanPropertyNames; + private final Set<String> primitiveIntegerPropertyNames; + private final Set<String> primitiveLongPropertyNames; + private final Set<String> primitiveFloatPropertyNames; /** * Pour décrire une association nm. @@ -73,6 +77,10 @@ public class UpdateSqlStatementGenerator<R extends ReferentialDto> { Set<String> simplePropertyNamesSet = metadataEntity.getProperties().keySet(); this.simplePropertyNames = simplePropertyNamesSet.toArray(new String[simplePropertyNamesSet.size()]); + this.primitiveBooleanPropertyNames = metadataEntity.getPrimitivePropertyNames("boolean"); + this.primitiveIntegerPropertyNames = metadataEntity.getPrimitivePropertyNames("int"); + this.primitiveLongPropertyNames = metadataEntity.getPrimitivePropertyNames("long"); + this.primitiveFloatPropertyNames = metadataEntity.getPrimitivePropertyNames("float"); Set<String> manyToOneAssociationNamesSet = metadataEntity.getManyToOneAssociations().keySet(); this.manyToOneAssociationNames = manyToOneAssociationNamesSet.toArray(new String[manyToOneAssociationNamesSet.size()]); @@ -106,6 +114,23 @@ public class UpdateSqlStatementGenerator<R extends ReferentialDto> { String columnName = columnNames.get(simplePropertyName); Object simplePropertyValue = entry.getValue(); + if (primitiveBooleanPropertyNames.contains(simplePropertyName)) { + addPrimitiveBooleanParameter(columnName, (Boolean) simplePropertyValue, parameters); + continue; + } + if (primitiveIntegerPropertyNames.contains(simplePropertyName)) { + addPrimitiveIntegerParameter(columnName, (Integer) simplePropertyValue, parameters); + continue; + } + if (primitiveFloatPropertyNames.contains(simplePropertyName)) { + addPrimitiveFloatParameter(columnName, (Float) simplePropertyValue, parameters); + continue; + } + if (primitiveLongPropertyNames.contains(simplePropertyName)) { + addPrimitiveLongParameter(columnName, (Long) simplePropertyValue, parameters); + continue; + } + if (simplePropertyValue == null) { addNullParameter(columnName, parameters); continue; @@ -122,6 +147,7 @@ public class UpdateSqlStatementGenerator<R extends ReferentialDto> { addEnumParameter(columnName, (Enum) simplePropertyValue, parameters); continue; } + addOtherTypeParameter(columnName, simplePropertyValue, parameters); } @@ -269,4 +295,20 @@ public class UpdateSqlStatementGenerator<R extends ReferentialDto> { private void addParameter0(String columnName, String value, StringBuilder parameters) { parameters.append(", ").append(columnName).append(" = ").append(value); } + + private void addPrimitiveBooleanParameter(String columnName, Boolean parameter, StringBuilder parameters) { + addParameter0(columnName, "" + (parameter != null && parameter), parameters); + } + + private void addPrimitiveIntegerParameter(String columnName, Integer parameter, StringBuilder parameters) { + addParameter0(columnName, "" + (parameter == null ? 0 : parameter), parameters); + } + + private void addPrimitiveLongParameter(String columnName, Long parameter, StringBuilder parameters) { + addParameter0(columnName, "" + (parameter == null ? 0 : parameter), parameters); + } + + private void addPrimitiveFloatParameter(String columnName, Float parameter, StringBuilder parameters) { + addParameter0(columnName, "" + (parameter == null ? 0f : parameter), parameters); + } } diff --git a/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataEntity.java b/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataEntity.java index 22b89e9..e952710 100644 --- a/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataEntity.java +++ b/observe-topia-extension/src/main/java/org/nuiton/topia/persistence/metadata/TopiaMetadataEntity.java @@ -23,12 +23,15 @@ package org.nuiton.topia.persistence.metadata; */ import com.google.common.base.MoreObjects; +import com.google.common.collect.ImmutableSet; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import java.util.LinkedHashMap; +import java.util.LinkedHashSet; import java.util.Map; import java.util.Objects; +import java.util.Set; /** * Created on 03/01/16. @@ -157,6 +160,31 @@ public class TopiaMetadataEntity { return properties; } + public static final Set<String> PRIMITIVE_TYPES = ImmutableSet.of("byte", "boolean", "char", "int", "long", "float", "double"); + + public Set<String> getPrimitivePropertyNames() { + Set<String> names = new LinkedHashSet<>(); + for (Map.Entry<String, String> entry : properties.entrySet()) { + String propertyType = entry.getValue(); + if (PRIMITIVE_TYPES.contains(propertyType)) { + names.add(entry.getKey()); + } + } + return names; + } + + public Set<String> getPrimitivePropertyNames(String primitiveType) { + Set<String> names = new LinkedHashSet<>(); + for (Map.Entry<String, String> entry : properties.entrySet()) { + String propertyType = entry.getValue(); + if (primitiveType.equals(propertyType)) { + names.add(entry.getKey()); + } + } + return names; + } + + public Map<String, String> getDbColumnsName() { return dbColumnsName; } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 8213590b504ef520445329575bffcc31d131a449 Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Jul 19 12:18:58 2016 +0200 Transformation en référence de référentiel plutôt que de conserver les entitées --- ...rectionalReferentialSynchronizeLocalServiceTopia.java | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) 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 36b8049..bf8456a 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 @@ -5,6 +5,7 @@ import fr.ird.observe.entities.Entities; 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.binder.referential.ReferentialBinderSupport; import fr.ird.observe.services.dto.referential.ReferentialDto; import fr.ird.observe.services.dto.referential.ReferentialReference; import org.apache.commons.logging.Log; @@ -18,7 +19,6 @@ import org.nuiton.topia.persistence.support.TopiaSqlWork; import java.sql.Connection; import java.sql.SQLException; import java.sql.Statement; -import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; @@ -79,7 +79,8 @@ public class UnidirectionalReferentialSynchronizeLocalServiceTopia extends Obser ObserveEntityEnum entityEnum = ObserveEntityEnum.valueOf(referentialName); Class entityType = entityEnum.getContract(); - return getLocalSourceReferentialToDelete0(entityType, ids); + Class dtoType = BinderEngine.get().getReferentialDtoType(entityType); + return getLocalSourceReferentialToDelete0(entityType, dtoType, ids); } @@ -177,10 +178,17 @@ public class UnidirectionalReferentialSynchronizeLocalServiceTopia extends Obser } - private <E extends ObserveReferentialEntity> Set<E> getLocalSourceReferentialToDelete0(Class<E> entityType, Set<String> ids) { + private <E extends ObserveReferentialEntity, R extends ReferentialDto> Set<ReferentialReference<R>> getLocalSourceReferentialToDelete0(Class<E> entityType,Class<R> dtoType, Set<String> ids) { TopiaDao<E> dao = getTopiaPersistenceContext().getDao(entityType); - return new HashSet<>(dao.forTopiaIdIn(ids).findAll()); + List<E> entities = dao.forTopiaIdIn(ids).findAll(); + ReferentialBinderSupport<E, R> referentialBinder = BinderEngine.get().getReferentialBinder(dtoType); + Set<ReferentialReference<R>> result = new LinkedHashSet<>(); + for (E entity : entities) { + ReferentialReference<R> rReferentialReference = referentialBinder.toReferentialReference(getReferentialLocale(), entity); + result.add(rReferentialReference); + } + return result; } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.

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 32ac58a65909308945cedc986a25d2826725fe40 Author: Tony CHEMIT <chemit@codelutin.com> Date: Tue Jul 19 12:19:33 2016 +0200 Dernier ajustement d'interface graphique --- .../src/main/java/fr/ird/observe/ui/admin/AdminUIModel.java | 2 ++ .../synchronize/ObsoleteReferentialReferenceListCellRenderer.java | 4 ++-- .../fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java | 7 ++++++- 3 files changed, 10 insertions(+), 3 deletions(-) diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/AdminUIModel.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/AdminUIModel.java index 4d6c174..d0af9d5 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/AdminUIModel.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/AdminUIModel.java @@ -1208,6 +1208,8 @@ public class AdminUIModel extends WizardExtModel<AdminStep> { validate &= validate(AdminStep.SELECT_DATA); break; case SYNCHRONIZE: + validate = getStepState(s) == WizardState.SUCCESSED; + break; case IMPORT_GPS: //FIXME //validate &= getStepState(s) == diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteReferentialReferenceListCellRenderer.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteReferentialReferenceListCellRenderer.java index ff15ad6..6b1b349 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteReferentialReferenceListCellRenderer.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteReferentialReferenceListCellRenderer.java @@ -59,11 +59,11 @@ public class ObsoleteReferentialReferenceListCellRenderer extends DefaultListCel String type = t(DecoratorService.getEntityLabel(referentialReferenceType)); Decorator<?> decorator = service.getReferentialReferenceDecorator(referentialReferenceType); - String text = type + " " + service.decorate(referentialReference); + String text = type + " : " + decorator.toString(referentialReference.getReferentialReference()); return super.getListCellRendererComponent( list, - value, + text, index, isSelected, cellHasFocus diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java index 28aa641..93b0a6f 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java @@ -191,13 +191,18 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { getStepModel().getObsoleteReferences().removeElement(obsoleteRef); + // on supprime la sélection de la liste des remplacements + + safeComboBox.setSelectedItem(null); + // S'il ne reste plus de référentiel à corriger, on peut terminer le traitement if (getStepModel().getObsoleteReferences().isEmpty()) { beforeSuccess(); - updateState(getUi(), WizardState.SUCCESSED); + getModel().setStepState(WizardState.SUCCESSED); +// updateState(getUi(), WizardState.SUCCESSED); } -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.