This is an automated email from the git hooks/post-receive script. New commit to branch feature/7739 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 feature/7739 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 feature/7739 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 feature/7739 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 feature/7739 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 feature/7739 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>.