[Observe-commits] 02/26: Review package for all synchros + continue referential synchro dev

This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository observe. See https://gitlab.nuiton.org/codelutin/observe.git commit a8cb47d14aa3eee11d5a7cfba404399b559eedac Author: Tony CHEMIT <chemit@codelutin.com> Date: Wed Aug 10 19:06:14 2016 +0200 Review package for all synchros + continue referential synchro dev --- .../data}/DataSynchroModel.java | 3 +- .../data}/DataSynchroUI.jaxx | 0 .../data}/DataSynchroUI.jcss | 22 +- .../data}/DataSynchroUIHandler.java | 64 ++-- .../data}/DataSynchronizeTaskListCellRenderer.java | 4 +- .../data/task}/CopyToLeftDataSynchronizeTask.java | 4 +- .../data/task}/CopyToRightDataSynchronizeTask.java | 4 +- .../data/task}/DataSynchronizeTaskSupport.java | 2 +- .../task}/DeleteFromLeftDataSynchronizeTask.java | 4 +- .../task}/DeleteFromRightDataSynchronizeTask.java | 4 +- .../legacy}/ObsoleteReferentialReference.java | 2 +- ...soleteReferentialReferenceListCellRenderer.java | 2 +- .../{ => referential/legacy}/SynchronizeModel.java | 10 +- .../{ => referential/legacy}/SynchronizeUI.jaxx | 4 +- .../{ => referential/legacy}/SynchronizeUI.jcss | 2 +- .../legacy}/SynchronizeUIHandler.java | 32 +- .../referential/ng/ReferentialSelectionModel.java | 358 ++++++++++++++++++ .../referential/ng/ReferentialSynchroConfigUI.jaxx | 80 ++++ .../referential/ng/ReferentialSynchroConfigUI.jcss | 54 +++ .../referential/ng/ReferentialSynchroModel.java | 123 ++++++ .../referential/ng/ReferentialSynchroUI.jaxx} | 48 +-- .../referential/ng/ReferentialSynchroUI.jcss | 150 ++++++++ .../ng/ReferentialSynchroUIHandler.java | 311 ++++++++++++++++ ...eferentialSynchronizeTaskListCellRenderer.java} | 8 +- .../task/CopyToLeftReferentialSynchronizeTask.java | 25 ++ .../CopyToRightReferentialSynchronizeTask.java | 25 ++ .../DeleteFromLeftReferentialSynchronizeTask.java | 25 ++ .../DeleteFromRightReferentialSynchronizeTask.java | 25 ++ ...activateFromLeftReferentialSynchronizeTask.java | 25 ++ ...mLeftWithReplaceReferentialSynchronizeTask.java | 25 ++ ...ctivateFromRightReferentialSynchronizeTask.java | 25 ++ ...RightWithReplaceReferentialSynchronizeTask.java | 25 ++ .../ng/task/ReferentialSynchronizeTaskSupport.java | 48 +++ .../RevertFromLeftReferentialSynchronizeTask.java | 25 ++ .../RevertFromRightReferentialSynchronizeTask.java | 25 ++ .../SkipFromLeftReferentialSynchronizeTask.java | 25 ++ .../SkipFromRightReferentialSynchronizeTask.java | 25 ++ .../ReferentialSynchronizeTreeCellRenderer.java | 141 +++++++ .../ng/tree/ReferentialSynchronizeTreeModel.java | 411 +++++++++++++++++++++ .../tree/node/ReferenceReferentialSynchroNode.java | 91 +++++ .../node/ReferenceReferentialSynchroNodeType.java | 70 ++++ .../tree/node/ReferentialSynchroNodeSupport.java | 53 +++ .../ng/tree/node/ReferentialSynchroNodeType.java | 13 + .../ng/tree/node/RootReferentialSynchroNode.java | 82 ++++ .../ng/tree/node/TypeReferentialSynchroNode.java | 107 ++++++ .../data}/DataSynchronizeServiceController.java | 6 +- ...eferentialSynchronizeDiffServiceController.java | 34 ++ ...ferentialSynchronizeLocalServiceController.java | 8 +- ...erentialSynchronizeRemoteServiceController.java | 8 +- .../ReferentialSynchronizeServiceController.java | 32 ++ .../observe/services/ObserveServicesProvider.java | 12 +- .../datasynchro/DataSynchronizeCopyTask.java | 27 -- .../datasynchro/DataSynchronizeDeleteTask.java | 27 -- .../datasynchro/DataSyncrhonizeTaskSupport.java | 26 -- .../data}/DataSynchronizeRequest.java | 4 +- .../data}/DataSynchronizeService.java | 2 +- .../synchro/data/task/DataSynchronizeCopyTask.java | 14 + .../data/task/DataSynchronizeDeleteTask.java | 14 + .../data/task/DataSynchronizeTaskSupport.java | 44 +++ .../referential/ReferentialSynchronizeMode.java | 69 ++++ .../diff/ReferentialDataSourceState.java | 65 ++++ .../diff/ReferentialDataSourceStates.java | 47 +++ .../diff/ReferentialSynchronizeDiff.java | 97 +++++ .../diff/ReferentialSynchronizeDiffService.java | 30 ++ .../diff/ReferentialSynchronizeDiffState.java | 67 ++++ .../diff/ReferentialSynchronizeDiffStateType.java | 15 + .../diff/ReferentialSynchronizeDiffs.java | 125 +++++++ .../diff/ReferentialSynchronizeDiffsEngine.java | 111 ++++++ .../legacy}/LocalReferentialStates.java | 2 +- .../legacy}/RemoteReferentialDiff.java | 2 +- ...ionalReferentialSynchronizeCallbackRequest.java | 2 +- ...onalReferentialSynchronizeCallbackRequests.java | 2 +- ...tionalReferentialSynchronizeCallbackResult.java | 2 +- ...ionalReferentialSynchronizeCallbackResults.java | 2 +- ...nidirectionalReferentialSynchronizeContext.java | 2 +- ...UnidirectionalReferentialSynchronizeEngine.java | 2 +- ...ectionalReferentialSynchronizeLocalService.java | 2 +- ...ctionalReferentialSynchronizeRemoteService.java | 2 +- ...nidirectionalReferentialSynchronizeRequest.java | 2 +- ...UnidirectionalReferentialSynchronizeResult.java | 2 +- .../ng/ReferentialSynchronizeRequest.java | 146 ++++++++ .../ng/ReferentialSynchronizeService.java} | 10 +- .../ng/task/ReferentialSynchronizeCopyTask.java | 17 + .../ng/task/ReferentialSynchronizeDeleteTask.java | 17 + .../ReferentialSynchronizeDesactivateTask.java | 17 + ...ntialSynchronizeDesactivateWithReplaceTask.java | 17 + .../ng/task/ReferentialSynchronizeTaskSupport.java | 38 ++ .../i18n/observe-services-api_en_GB.properties | 6 + .../i18n/observe-services-api_es_ES.properties | 6 + .../i18n/observe-services-api_fr_FR.properties | 6 + .../data}/DataSynchronizeServiceTopia.java | 39 +- .../ReferentialSynchronizeDiffServiceTopia.java | 108 ++++++ .../legacy}/DeleteSqlStatementGenerator.java | 2 +- .../legacy}/InsertSqlStatementGenerator.java | 2 +- .../legacy}/ReplaceSqlStatementGenerator.java | 2 +- ...nalReferentialSynchronizeLocalServiceTopia.java | 2 +- ...alReferentialSynchronizeRemoteServiceTopia.java | 2 +- .../legacy}/UpdateSqlStatementGenerator.java | 2 +- .../ng/ReferentialSynchronizeServiceTopia.java | 135 +++++++ .../UnidirectionalSynchronizeReferentialTest.java | 6 + 100 files changed, 3846 insertions(+), 253 deletions(-) diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroModel.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroModel.java similarity index 96% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroModel.java rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroModel.java index d41df3c..d77f8d6 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroModel.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroModel.java @@ -1,8 +1,9 @@ -package fr.ird.observe.ui.admin.datasynchro; +package fr.ird.observe.ui.admin.synchronize.data; import fr.ird.observe.db.ObserveSwingDataSource; import fr.ird.observe.ui.admin.AdminActionModel; import fr.ird.observe.ui.admin.AdminStep; +import fr.ird.observe.ui.admin.synchronize.data.task.DataSynchronizeTaskSupport; import fr.ird.observe.ui.storage.tabs.DataSelectionModel; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroUI.jaxx b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroUI.jaxx similarity index 100% copy from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroUI.jaxx copy to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroUI.jaxx diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroUI.jcss b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroUI.jcss similarity index 82% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroUI.jcss rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroUI.jcss index c512d22..5d4d5cd 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroUI.jcss +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroUI.jcss @@ -29,10 +29,6 @@ resizeWeight: 0.8; } -#startAction { - actionIcon:"wizard-start"; -} - #applyAction { actionIcon:accept; text:"observe.action.apply"; @@ -46,7 +42,7 @@ showsRootHandles:false; toggleClickCount:100; selectionModel:{leftSelectionModel}; - cellRenderer:{leftSelectionRenderer}; + cellRenderer:{new DataSelectionTreeCellRenderer()}; } #leftSelectionModel { @@ -66,7 +62,7 @@ showsRootHandles:false; toggleClickCount:100; selectionModel:{rightSelectionModel}; - cellRenderer:{rightSelectionRenderer}; + cellRenderer:{new DataSelectionTreeCellRenderer()}; } #rightSelectionModel { @@ -80,30 +76,30 @@ #copyToLeft { actionIcon:copyToLeft; - toolTipText:"observe.action.copyToLeft.tip"; + toolTipText:"observe.actions.synchro.data.copyToLeft.tip"; enabled:false; } #copyToRight { actionIcon:copyToRight; - toolTipText:"observe.action.copyToRight.tip"; + toolTipText:"observe.actions.synchro.data.copyToRight.tip"; enabled:false; } #deleteFromLeft { - actionIcon:delete; - toolTipText:"observe.action.deleteFromLeft.tip"; + actionIcon:deleteFromLeft; + toolTipText:"observe.actions.synchro.data.deleteFromLeft.tip"; enabled:false; } #deleteFromRight { - actionIcon:delete; - toolTipText:"observe.action.deleteFromRight.tip"; + actionIcon:deleteFromRight; + toolTipText:"observe.actions.synchro.data.deleteFromRight.tip"; enabled:false; } #actionsToConsumePane { - border:{new TitledBorder(t("observe.datasynchro.actionsToPerform"))}; + border:{new TitledBorder(t("observe.actions.synchro.data.actionsToPerform"))}; verticalScrollBarPolicy:{JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED}; } diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroUIHandler.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroUIHandler.java similarity index 83% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroUIHandler.java rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroUIHandler.java index 5629f7b..c44d9fb 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroUIHandler.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroUIHandler.java @@ -1,4 +1,4 @@ -package fr.ird.observe.ui.admin.datasynchro; +package fr.ird.observe.ui.admin.synchronize.data; import fr.ird.observe.application.swing.decoration.DecoratorService; import fr.ird.observe.application.swing.decoration.decorators.ReferentialReferenceDecorator; @@ -7,16 +7,20 @@ import fr.ird.observe.services.configuration.ObserveDataSourceConfigurationTopia import fr.ird.observe.services.dto.DataReference; import fr.ird.observe.services.dto.referential.ProgramDto; import fr.ird.observe.services.dto.referential.ReferentialReference; -import fr.ird.observe.services.service.actions.datasynchro.DataSynchronizeCopyTask; -import fr.ird.observe.services.service.actions.datasynchro.DataSynchronizeDeleteTask; -import fr.ird.observe.services.service.actions.datasynchro.DataSynchronizeRequest; -import fr.ird.observe.services.service.actions.datasynchro.DataSynchronizeService; +import fr.ird.observe.services.service.actions.synchro.data.DataSynchronizeRequest; +import fr.ird.observe.services.service.actions.synchro.data.DataSynchronizeService; +import fr.ird.observe.services.service.actions.synchro.data.task.DataSynchronizeCopyTask; +import fr.ird.observe.services.service.actions.synchro.data.task.DataSynchronizeDeleteTask; +import fr.ird.observe.ui.UIHelper; import fr.ird.observe.ui.admin.AdminTabUI; import fr.ird.observe.ui.admin.AdminTabUIHandler; import fr.ird.observe.ui.admin.AdminUI; +import fr.ird.observe.ui.admin.synchronize.data.task.CopyToLeftDataSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.data.task.CopyToRightDataSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.data.task.DataSynchronizeTaskSupport; +import fr.ird.observe.ui.admin.synchronize.data.task.DeleteFromLeftDataSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.data.task.DeleteFromRightDataSynchronizeTask; import fr.ird.observe.ui.storage.tabs.DataSelectionModel; -import fr.ird.observe.ui.tree.DataSelectionTreeCellRenderer; -import fr.ird.observe.ui.tree.ObserveNode; import fr.ird.observe.ui.tree.ObserveTreeHelper; import jaxx.runtime.swing.wizard.ext.WizardState; import org.apache.commons.logging.Log; @@ -26,7 +30,6 @@ import javax.swing.DefaultListModel; import javax.swing.border.TitledBorder; import java.util.List; import java.util.Map; -import java.util.Set; import static org.nuiton.i18n.I18n.t; @@ -86,8 +89,8 @@ public class DataSynchroUIHandler extends AdminTabUIHandler { }); - DataSelectionTreeCellRenderer.initUI(tabUI.getLeftTreePane(), tabUI.getLeftTree()); - DataSelectionTreeCellRenderer.initUI(tabUI.getRightTreePane(), tabUI.getRightTree()); + UIHelper.initUI(tabUI.getLeftTreePane(), tabUI.getLeftTree()); + UIHelper.initUI(tabUI.getRightTreePane(), tabUI.getRightTree()); getStepModel().addPropertyChangeListener(DataSynchroModel.LEFT_SOURCE_PROPERTY_NAME, evt -> { @@ -97,7 +100,7 @@ public class DataSynchroUIHandler extends AdminTabUIHandler { tabUI.getLeftTreePane().setBorder(new TitledBorder(getModel().getLocalSourceModel().getLabel())); stepModel.populateLeftSelectionModel(); updateSelectionModel(tabUI, tabUI.getLeftTreeHelper(), tabUI.getLeftTree(), dataSource, stepModel.getLeftSelectionDataModel(), tabUI.getLeftSelectionModel()); - sendMessage(t("observe.message.datasynchro.leftData.loaded")); + sendMessage(t("observe.actions.synchro.referential.message.data.leftData.loaded")); }); getStepModel().addPropertyChangeListener(DataSynchroModel.RIGHT_SOURCE_PROPERTY_NAME, evt -> { @@ -108,7 +111,7 @@ public class DataSynchroUIHandler extends AdminTabUIHandler { tabUI.getRightTreePane().setBorder(new TitledBorder(getModel().getCentralSourceModel().getLabel())); stepModel.populateRightSelectionModel(); updateSelectionModel(tabUI, tabUI.getRightTreeHelper(), tabUI.getRightTree(), dataSource, stepModel.getRightSelectionDataModel(), tabUI.getRightSelectionModel()); - sendMessage(t("observe.message.datasynchro.rightData.loaded")); + sendMessage(t("observe.actions.synchro.referential.message.data.rightData.loaded")); }); @@ -225,35 +228,35 @@ public class DataSynchroUIHandler extends AdminTabUIHandler { if (task instanceof DeleteFromLeftDataSynchronizeTask) { - sendMessage(t("observe.datasynchro.prepare.deleteFromLeftTask", programStr, tripStr)); + sendMessage(t("observe.actions.synchro.data.prepare.deleteFromLeftTask", programStr, tripStr)); leftDataSynchronizeRequestBuilder.addDeleteTask(new DataSynchronizeDeleteTask(task.getProgram().getId(), task.getTrip().getId())); continue; } if (task instanceof DeleteFromRightDataSynchronizeTask) { - sendMessage(t("observe.datasynchro.prepare.deleteFromRightTask", programStr, tripStr)); + sendMessage(t("observe.actions.synchro.data.prepare.deleteFromRightTask", programStr, tripStr)); rightDataSynchronizeRequestBuilder.addDeleteTask(new DataSynchronizeDeleteTask(task.getProgram().getId(), task.getTrip().getId())); continue; } if (task instanceof CopyToLeftDataSynchronizeTask) { - CopyToLeftDataSynchronizeTask copyTask = (CopyToLeftDataSynchronizeTask) task; - if (copyTask.isTripExistOnLeft()) { - sendMessage(t("observe.datasynchro.prepare.deleteFromLeftTask", programStr, tripStr)); + CopyToLeftDataSynchronizeTask task1 = (CopyToLeftDataSynchronizeTask) task; + if (task1.isTripExistOnLeft()) { + sendMessage(t("observe.actions.synchro.data.prepare.deleteFromLeftTask", programStr, tripStr)); leftDataSynchronizeRequestBuilder.addDeleteTask(new DataSynchronizeDeleteTask(task.getProgram().getId(), task.getTrip().getId())); } - sendMessage(t("observe.datasynchro.prepare.copyToLeftTask", programStr, tripStr)); + sendMessage(t("observe.actions.synchro.data.prepare.copyToLeftTask", programStr, tripStr)); leftDataSynchronizeRequestBuilder.addCopyTask(new DataSynchronizeCopyTask(task.getProgram().getId(), task.getTrip().getId())); continue; } if (task instanceof CopyToRightDataSynchronizeTask) { - CopyToRightDataSynchronizeTask copyTask = (CopyToRightDataSynchronizeTask) task; - if (copyTask.isTripExistOnRight()) { - sendMessage(t("observe.datasynchro.prepare.deleteFromRightTask", programStr, tripStr)); + CopyToRightDataSynchronizeTask task1 = (CopyToRightDataSynchronizeTask) task; + if (task1.isTripExistOnRight()) { + sendMessage(t("observe.actions.synchro.data.prepare.deleteFromRightTask", programStr, tripStr)); rightDataSynchronizeRequestBuilder.addDeleteTask(new DataSynchronizeDeleteTask(task.getProgram().getId(), task.getTrip().getId())); } - sendMessage(t("observe.datasynchro.prepare.copyToRightTask", programStr, tripStr)); + sendMessage(t("observe.actions.synchro.data.prepare.copyToRightTask", programStr, tripStr)); rightDataSynchronizeRequestBuilder.addCopyTask(new DataSynchronizeCopyTask(task.getProgram().getId(), task.getTrip().getId())); } @@ -280,21 +283,4 @@ public class DataSynchroUIHandler extends AdminTabUIHandler { } - private void adddTripToTree(ReferentialReference<ProgramDto> program, DataReference trip, ObserveTreeHelper treeHelper, DataSelectionModel selectionDataModel) { - - - Set<ReferentialReference<ProgramDto>> programs = selectionDataModel.getPrograms(); - ObserveNode programNode; - if (programs.contains(program)) { - programNode = treeHelper.getChild(treeHelper.getRootNode(), program.getId()); - } else { - programNode = treeHelper.addProgram(programs, program); - } - - selectionDataModel.addData(program, trip); - ObserveNode observeNode = treeHelper.addSimpleTrip(programNode, trip); - treeHelper.selectNode(observeNode); - - } - } \ No newline at end of file diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchronizeTaskListCellRenderer.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchronizeTaskListCellRenderer.java similarity index 84% copy from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchronizeTaskListCellRenderer.java copy to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchronizeTaskListCellRenderer.java index 14e77c9..510dda3 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchronizeTaskListCellRenderer.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchronizeTaskListCellRenderer.java @@ -1,4 +1,6 @@ -package fr.ird.observe.ui.admin.datasynchro; +package fr.ird.observe.ui.admin.synchronize.data; + +import fr.ird.observe.ui.admin.synchronize.data.task.DataSynchronizeTaskSupport; import javax.swing.DefaultListCellRenderer; import javax.swing.JList; diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/CopyToLeftDataSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/CopyToLeftDataSynchronizeTask.java similarity index 84% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/CopyToLeftDataSynchronizeTask.java rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/CopyToLeftDataSynchronizeTask.java index b3478ad..8c6313c 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/CopyToLeftDataSynchronizeTask.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/CopyToLeftDataSynchronizeTask.java @@ -1,4 +1,4 @@ -package fr.ird.observe.ui.admin.datasynchro; +package fr.ird.observe.ui.admin.synchronize.data.task; import fr.ird.observe.services.dto.DataReference; import fr.ird.observe.services.dto.referential.ProgramDto; @@ -23,7 +23,7 @@ public class CopyToLeftDataSynchronizeTask extends DataSynchronizeTaskSupport { @Override public String getLabel() { - return t("observe.datasynchro.copyToLeftTask", decorateProgram(), decorateTrip()); + return t("observe.actions.synchro.data.copyToLeftTask", decorateProgram(), decorateTrip()); } public boolean isTripExistOnLeft() { diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/CopyToRightDataSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/CopyToRightDataSynchronizeTask.java similarity index 84% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/CopyToRightDataSynchronizeTask.java rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/CopyToRightDataSynchronizeTask.java index 46a9067..abf3f53 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/CopyToRightDataSynchronizeTask.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/CopyToRightDataSynchronizeTask.java @@ -1,4 +1,4 @@ -package fr.ird.observe.ui.admin.datasynchro; +package fr.ird.observe.ui.admin.synchronize.data.task; import fr.ird.observe.services.dto.DataReference; import fr.ird.observe.services.dto.referential.ProgramDto; @@ -23,7 +23,7 @@ public class CopyToRightDataSynchronizeTask extends DataSynchronizeTaskSupport { @Override public String getLabel() { - return t("observe.datasynchro.copyToRightTask", decorateProgram(), decorateTrip()); + return t("observe.actions.synchro.data.copyToRightTask", decorateProgram(), decorateTrip()); } public boolean isTripExistOnRight() { diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchronizeTaskSupport.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/DataSynchronizeTaskSupport.java similarity index 96% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchronizeTaskSupport.java rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/DataSynchronizeTaskSupport.java index 8fda9d5..a363c41 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchronizeTaskSupport.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/DataSynchronizeTaskSupport.java @@ -1,4 +1,4 @@ -package fr.ird.observe.ui.admin.datasynchro; +package fr.ird.observe.ui.admin.synchronize.data.task; import fr.ird.observe.ObserveSwingApplicationContext; import fr.ird.observe.application.swing.decoration.DecoratorService; diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DeleteFromLeftDataSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/DeleteFromLeftDataSynchronizeTask.java similarity index 80% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DeleteFromLeftDataSynchronizeTask.java rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/DeleteFromLeftDataSynchronizeTask.java index 02a4b50..267bf77 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DeleteFromLeftDataSynchronizeTask.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/DeleteFromLeftDataSynchronizeTask.java @@ -1,4 +1,4 @@ -package fr.ird.observe.ui.admin.datasynchro; +package fr.ird.observe.ui.admin.synchronize.data.task; import fr.ird.observe.services.dto.DataReference; import fr.ird.observe.services.dto.referential.ProgramDto; @@ -20,6 +20,6 @@ public class DeleteFromLeftDataSynchronizeTask extends DataSynchronizeTaskSuppor @Override public String getLabel() { - return t("observe.datasynchro.deleteFromLeftTask", decorateProgram(), decorateTrip()); + return t("observe.actions.synchro.data.deleteFromLeftTask", decorateProgram(), decorateTrip()); } } diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DeleteFromRightDataSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/DeleteFromRightDataSynchronizeTask.java similarity index 80% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DeleteFromRightDataSynchronizeTask.java rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/DeleteFromRightDataSynchronizeTask.java index 214ff4e..d012850 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DeleteFromRightDataSynchronizeTask.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/task/DeleteFromRightDataSynchronizeTask.java @@ -1,4 +1,4 @@ -package fr.ird.observe.ui.admin.datasynchro; +package fr.ird.observe.ui.admin.synchronize.data.task; import fr.ird.observe.services.dto.DataReference; import fr.ird.observe.services.dto.referential.ProgramDto; @@ -20,6 +20,6 @@ public class DeleteFromRightDataSynchronizeTask extends DataSynchronizeTaskSuppo @Override public String getLabel() { - return t("observe.datasynchro.deleteFromRightTask", decorateProgram(), decorateTrip()); + return t("observe.actions.synchro.data.deleteFromRightTask", decorateProgram(), decorateTrip()); } } 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/referential/legacy/ObsoleteReferentialReference.java similarity index 97% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteReferentialReference.java rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/ObsoleteReferentialReference.java index 98e6259..8573212 100644 --- 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/referential/legacy/ObsoleteReferentialReference.java @@ -1,4 +1,4 @@ -package fr.ird.observe.ui.admin.synchronize; +package fr.ird.observe.ui.admin.synchronize.referential.legacy; /*- * #%L 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/referential/legacy/ObsoleteReferentialReferenceListCellRenderer.java similarity index 97% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/ObsoleteReferentialReferenceListCellRenderer.java rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/ObsoleteReferentialReferenceListCellRenderer.java index 275fdf7..9d50169 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/referential/legacy/ObsoleteReferentialReferenceListCellRenderer.java @@ -19,7 +19,7 @@ * <http://www.gnu.org/licenses/gpl-3.0.html>. * #L% */ -package fr.ird.observe.ui.admin.synchronize; +package fr.ird.observe.ui.admin.synchronize.referential.legacy; import fr.ird.observe.ObserveSwingApplicationContext; import fr.ird.observe.application.swing.decoration.DecoratorService; 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/referential/legacy/SynchronizeModel.java similarity index 89% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeModel.java rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/SynchronizeModel.java index 86a3de7..6314771 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/referential/legacy/SynchronizeModel.java @@ -19,13 +19,13 @@ * <http://www.gnu.org/licenses/gpl-3.0.html>. * #L% */ -package fr.ird.observe.ui.admin.synchronize; +package fr.ird.observe.ui.admin.synchronize.referential.legacy; 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.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeCallbackResults; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeContext; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeEngine; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeResult; import fr.ird.observe.ui.admin.AdminActionModel; import fr.ird.observe.ui.admin.AdminStep; import jaxx.runtime.swing.model.JaxxDefaultListModel; 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/referential/legacy/SynchronizeUI.jaxx similarity index 94% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUI.jaxx rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/SynchronizeUI.jaxx index f0d7696..0bc020c 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/referential/legacy/SynchronizeUI.jaxx @@ -90,11 +90,11 @@ protected void apply() { </JScrollPane> <Table fill='both' constraints='BorderLayout.CENTER' - border='{new TitledBorder(t("observe.synchro.obsolete.entity.fix"))}'> + border='{new TitledBorder(t("observe.actions.synchro.referential.obsolete.entity.fix"))}'> <row> <cell> - <JLabel text='observe.synchro.safe.entity.to.choose.label'/> + <JLabel text='observe.actions.synchro.referential.safe.entity.to.choose.label'/> </cell> <cell weightx='1' fill='both'> 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/referential/legacy/SynchronizeUI.jcss similarity index 93% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUI.jcss rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/SynchronizeUI.jcss index c8327d6..6dfd6e4 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/referential/legacy/SynchronizeUI.jcss @@ -33,7 +33,7 @@ } #errorsPane { - columnHeaderView:{new JLabel(t("observe.synchro.obsolete.entities.list"))}; + columnHeaderView:{new JLabel(t("observe.actions.synchro.referential.obsolete.entities.list"))}; } #obsoleteReferencesList { 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/referential/legacy/SynchronizeUIHandler.java similarity index 86% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/SynchronizeUIHandler.java rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/SynchronizeUIHandler.java index 8ba07a2..ff76fb5 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/referential/legacy/SynchronizeUIHandler.java @@ -19,17 +19,17 @@ * <http://www.gnu.org/licenses/gpl-3.0.html>. * #L% */ -package fr.ird.observe.ui.admin.synchronize; +package fr.ird.observe.ui.admin.synchronize.referential.legacy; import com.google.common.collect.ImmutableSet; import fr.ird.observe.db.ObserveSwingDataSource; 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.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeCallbackRequest; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeCallbackRequests; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeCallbackResults; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeContext; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeEngine; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeResult; import fr.ird.observe.ui.admin.AdminStep; import fr.ird.observe.ui.admin.AdminTabUIHandler; import fr.ird.observe.ui.admin.AdminUI; @@ -88,7 +88,7 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { log.debug(" specialized for [" + tabUI.getStep() + "] for main ui " + ui.getClass().getName() + "@" + System.identityHashCode(ui)); } - tabUI.getStartAction().setText(t("observe.action.synchro.launch.operation", t(tabUI.getStep().getOperationLabel()))); + tabUI.getStartAction().setText(t("observe.actions.synchro.referential.launch.operation", t(tabUI.getStep().getOperationLabel()))); DefaultListSelectionModel obsoleteReferenceSelectionModel = tabUI.getModel().getSynchronizeReferentielModel().getObsoleteReferencesSelectionModel(); obsoleteReferenceSelectionModel.addListSelectionListener(this::updateSelectedObsoleteEntity); @@ -122,7 +122,7 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { openSource(centralSource); // construction du différentiel - sendMessage(t("observe.message.synchro.build.diff", centralSource.getLabel())); + sendMessage(t("observe.actions.synchro.referential.message.build.diff", centralSource.getLabel())); UnidirectionalReferentialSynchronizeEngine engine = new UnidirectionalReferentialSynchronizeEngine( @@ -141,7 +141,7 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { // il existe des références obsolètes à traiter - sendMessage(t("observe.message.synchro.operation.needFix")); + sendMessage(t("observe.actions.operation.message.needFix")); stepModel.setReferentialSynchronizeCallbackResults(new UnidirectionalReferentialSynchronizeCallbackResults()); @@ -291,7 +291,7 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { if (referentialSynchronizeResult.isEmpty()) { - sendMessage(t("observe.message.synchro.ref.is.updtodate")); + sendMessage(t("observe.actions.synchro.referential.message.ref.is.updtodate")); } else { @@ -300,7 +300,7 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { Collection<String> referentialAdded = referentialSynchronizeResult.getReferentialAdded(referentialName); if (CollectionUtils.isNotEmpty(referentialAdded)) { - sendMessage(t("observe.message.synchro.referentiel.was.added", referentialName, referentialAdded.size())); + sendMessage(t("observe.actions.synchro.referential.message.referentiel.was.added", referentialName, referentialAdded.size())); for (String id : referentialAdded) { sendMessage(" - " + id); } @@ -310,7 +310,7 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { Collection<String> referentialUpdated = referentialSynchronizeResult.getReferentialUpdated(referentialName); if (CollectionUtils.isNotEmpty(referentialUpdated)) { - sendMessage(t("observe.message.synchro.referentiel.was.modified", referentialName, referentialUpdated.size())); + sendMessage(t("observe.actions.synchro.referential.message.referentiel.was.modified", referentialName, referentialUpdated.size())); for (String id : referentialUpdated) { sendMessage(" - " + id); } @@ -320,7 +320,7 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { Collection<String> referentialRemoved = referentialSynchronizeResult.getReferentialRemoved(referentialName); if (CollectionUtils.isNotEmpty(referentialRemoved)) { - sendMessage(t("observe.message.synchro.referentiel.was.removed", referentialName, referentialRemoved.size())); + sendMessage(t("observe.actions.synchro.referential.message.referentiel.was.removed", referentialName, referentialRemoved.size())); for (String id : referentialRemoved) { sendMessage(" - " + id); } @@ -330,7 +330,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", referentialName, referentialReplaced.size())); + sendMessage(t("observe.actions.synchro.referential.message.referentiel.was.replaced", referentialName, referentialReplaced.size())); for (Pair<String, String> ids : referentialReplaced) { sendMessage(" - " + ids.getLeft() + " → " + ids.getRight()); } @@ -343,7 +343,7 @@ public class SynchronizeUIHandler extends AdminTabUIHandler { } - sendMessage(t("observe.message.synchro.operation.done", new Date())); + sendMessage(t("observe.actions.operation.message.done", new Date())); } diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSelectionModel.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSelectionModel.java new file mode 100644 index 0000000..86f5698 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSelectionModel.java @@ -0,0 +1,358 @@ +/* + * #%L + * ObServe :: Business + * %% + * 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.referential.ng; + +import com.google.common.base.Preconditions; +import com.google.common.collect.Lists; +import fr.ird.observe.db.ObserveSwingDataSource; +import fr.ird.observe.services.dto.DataReference; +import fr.ird.observe.services.dto.referential.ProgramDto; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.services.service.actions.synchro.referential.ReferentialSynchronizeMode; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffService; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffs; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffsEngine; +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.jdesktop.beans.AbstractSerializableBean; + +import java.beans.PropertyChangeListener; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; + +import static com.google.common.collect.Maps.newHashMap; +import static com.google.common.collect.Sets.newHashSet; + +/** + * Un modèle pour représenter la sélection de données. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.4 + */ +public class ReferentialSelectionModel extends AbstractSerializableBean { + + private ReferentialSynchronizeMode synchronizeMode; + + public static void populate(ReferentialSelectionModel model, ObserveSwingDataSource leftSource, ObserveSwingDataSource rightSource) { + + Preconditions.checkState(leftSource.isOpen()); + Preconditions.checkState(rightSource.isOpen()); + + ReferentialSynchronizeDiffService leftDiffSynchronizeService = leftSource.newReferentialSynchronizeDiffService(); + ReferentialSynchronizeDiffService rightDiffSynchronizeService = rightSource.newReferentialSynchronizeDiffService(); + + ReferentialSynchronizeDiffsEngine engine = new ReferentialSynchronizeDiffsEngine(leftDiffSynchronizeService, rightDiffSynchronizeService); + + ReferentialSynchronizeDiffs synchronizeDiffs = engine.build(model.getSynchronizeMode()); + + + model.setDatas(null); + + } + + protected static void populate(ReferentialReference<ProgramDto> program, + List<DataReference> trips, + Map<ReferentialReference<ProgramDto>, List<DataReference>> datas) { + + if (!trips.isEmpty()) { + + datas.put(program, trips); + if (log.isDebugEnabled()) { + log.debug("Add program " + program.getPropertyValue(ProgramDto.PROPERTY_LABEL1) + " with " + trips.size() + " trip(s)."); + } + + + } + + } + + public static final String PROPERTY_SELECTED_DATA = "selectedData"; + public static final String PROPERTY_DATAS = "datas"; + public static final String PROPERTY_SYNCHRONIZE_MODE = "syncrhronizeMode"; + + /** Logger */ + private static final Log log = LogFactory.getLog(ReferentialSelectionModel.class); + + private static final long serialVersionUID = 2L; + + protected transient Map<Class<? extends ReferentialDto>, List<ReferentialReference<? extends ReferentialDto>>> datas; + + protected transient Set<ReferentialReference> selectedData; + + /** nb marees */ + protected int nbTrips; + + public void populate() { + throw new UnsupportedOperationException(); + } + + public ReferentialSelectionModel() { + + } + + public boolean isEmpty() { + return selectedData == null || selectedData.isEmpty(); + } + + public boolean isFull() { + return selectedData != null && selectedData.size() == nbTrips; + } + + public int selectDataSize() { + return selectedData == null ? 0 : selectedData.size(); + } + + public ReferentialSynchronizeMode getSynchronizeMode() { + return synchronizeMode; + } + + public void setSynchronizeMode(ReferentialSynchronizeMode synchronizeMode) { + ReferentialSynchronizeMode oldValue = getSynchronizeMode(); + this.synchronizeMode = synchronizeMode; + firePropertyChange(PROPERTY_DATAS, oldValue, synchronizeMode); + } + + public Map<Class<? extends ReferentialDto>, List<ReferentialReference<? extends ReferentialDto>>> getDatas() { + if (datas == null) { + datas = newHashMap(); + } + return datas; + } + + public <Type extends ReferentialDto> boolean containsData(Class<Type> program, ReferentialReference<Type> trip) { + List<ReferentialReference<Type>> datas = getDatas(program); + return datas != null && datas.contains(trip); + } + + public Set<ReferentialReference> getSelectedData() { + if (selectedData == null) { + selectedData = newHashSet(); + } + return selectedData; + } + + public Map<Class<? extends ReferentialDto>, List<ReferentialReference<? extends ReferentialDto>>> getSelectedDataByProgram() { + if (datas == null || selectedData == null || selectedData.isEmpty()) { + return Collections.emptyMap(); + } + Map<Class<? extends ReferentialDto>, List<ReferentialReference<? extends ReferentialDto>>> result = new HashMap<>(); + + for (ReferentialReference referenceDto : selectedData) { + + // on recherche son program + for (Class<? extends ReferentialDto> p : datas.keySet()) { + if (datas.get(p).contains(referenceDto)) { + List<ReferentialReference<?>> referenceDtos = result.get(p); + if (referenceDtos == null) { + referenceDtos = Lists.newArrayList(); + result.put(p, referenceDtos); + } + referenceDtos.add(referenceDto); + break; + } + } + } + return result; + } + + public List<Class<? extends ReferentialDto>> getSelectedProgram() { + if (datas == null || selectedData == null || selectedData.isEmpty()) { + return Collections.emptyList(); + } + + Set<Class<? extends ReferentialDto>> result = new HashSet<>(); + + for (ReferentialReference referenceDto : selectedData) { + + // on recherche son program + for (Class<? extends ReferentialDto> p : datas.keySet()) { + if (datas.get(p).contains(referenceDto)) { + result.add(p); + break; + } + } + } + + return result.stream().collect(Collectors.toList()); + } + + + public <Type extends ReferentialDto> List<ReferentialReference<Type>> getSelectedTripsByProgram(Class<Type> program) { + if (datas == null || selectedData == null || selectedData.isEmpty()) { + return Collections.emptyList(); + } + + List<ReferentialReference<Type>> result = getDatas(program).stream() + .filter(trip -> selectedData.contains(trip)) + .collect(Collectors.toList()); + + return result; + } + + public <Type extends ReferentialDto> boolean isSelectedData(ReferentialReference<Type> referenceDto) { + + boolean result; + + List<ReferentialReference<Type>> trips = getDatas(referenceDto.getType()); + result = CollectionUtils.isNotEmpty(trips); + + if (result) { + for (ReferentialReference trip : trips) { + if (!getSelectedData().contains(trip)) { + result = false; + } + } + } + + return result; + + } + + + public void removeAll() { + getSelectedData().clear(); + firePropertyChange(PROPERTY_SELECTED_DATA, selectedData); + } + + public void setDatas(Map<Class<? extends ReferentialDto>, List<ReferentialReference<? extends ReferentialDto>>> datas) { + this.datas = datas; + + // on compte le count de marées totale + int nbTrips = 0; + if (datas != null) { + for (List<ReferentialReference<? extends ReferentialDto>> marees : datas.values()) { + nbTrips += marees.size(); + } + } + this.nbTrips = nbTrips; + + if (log.isDebugEnabled()) { + log.debug("Nb program registred : " + (datas == null ? 0 : datas.size())); + log.debug("Nb trip registred : " + this.nbTrips); + } + firePropertyChange(PROPERTY_DATAS, datas); + } + + public <Type extends ReferentialDto> void addSelectedData(ReferentialReference<Type> referenceDto) { + + if (log.isDebugEnabled()) { + log.debug("Add referential " + referenceDto.getId()); + } + getSelectedData().add((ReferentialReference) referenceDto); + + firePropertyChange(PROPERTY_SELECTED_DATA, selectedData); + } + + public void addAllSelectedData() { + if (log.isDebugEnabled()) { + log.debug("All all data."); + } + for (List<ReferentialReference<? extends ReferentialDto>> p : datas.values()) { + getSelectedData().addAll(p); + } + firePropertyChange(PROPERTY_SELECTED_DATA, selectedData); + } + + public <Type extends ReferentialDto> void removeSelectedData(ReferentialReference<Type> referenceDto) { + + + // ajout d'une marée + if (log.isDebugEnabled()) { + log.debug("Remove maree " + referenceDto); + } + getSelectedData().remove(referenceDto); + + firePropertyChange(PROPERTY_SELECTED_DATA, selectedData); + } + + public void removeAllSelectedData() { + if (selectedData != null) { + selectedData.clear(); + } + firePropertyChange(PROPERTY_SELECTED_DATA, selectedData); + } + + public void destroy() { + removeAll(); + // suppression de tous les listeners + PropertyChangeListener[] listeners = getPropertyChangeListeners(); + for (PropertyChangeListener l : listeners) { + removePropertyChangeListener(l); + } + } + + @Override + protected void finalize() throws Throwable { + super.finalize(); + destroy(); + } + + public <R extends ReferentialDto> List<ReferentialReference<R>> getDatas(Class<R> programId) { + java.util.Optional<Class<? extends ReferentialDto>> programRefOptional = getDatas().keySet().stream().filter(key -> key.equals(programId)).findFirst(); + + List<ReferentialReference<R>> result; + + if (programRefOptional.isPresent()) { + + result = (List) getDatas().get(programRefOptional.get()); + + } else { + + result = Collections.emptyList(); + + } + + return result; + } + + public <R extends ReferentialDto> void addData(Class<R> program, ReferentialReference<R> trip) { + if (!getDatas().containsKey(program)) { + getDatas().put(program, new ArrayList<>()); + } + getDatas(program).add(trip); + firePropertyChange(PROPERTY_DATAS, getDatas()); + } + + public Set<Class<? extends ReferentialDto>> getPrograms() { + return getDatas().keySet(); + } + + public <R extends ReferentialDto> void removeTrip(Class<R> program, ReferentialReference<R> trip) { + List<ReferentialReference<R>> data = getDatas(program); + data.remove(trip); + if (data.isEmpty()) { + getDatas().remove(program); + } + } + + protected void firePropertyChange(String propertyName, Object newValue) { + super.firePropertyChange(propertyName, null, newValue); + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroConfigUI.jaxx b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroConfigUI.jaxx new file mode 100644 index 0000000..6092845 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroConfigUI.jaxx @@ -0,0 +1,80 @@ +<!-- + #%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% + --> +<!-- ************************************************************* --> +<!-- La configuration de l'import GPS --> +<!-- ************************************************************* --> + +<JPanel id="referentialSynchronizeConfig"> + + <import> + fr.ird.observe.configuration.ObserveSwingApplicationConfig + fr.ird.observe.services.service.actions.synchro.referential.ReferentialSynchronizeMode + fr.ird.observe.ui.admin.AdminUIModel + fr.ird.observe.validation.ValidationModelMode + + org.nuiton.validator.NuitonValidatorScope + + java.io.File + + javax.swing.JComboBox + + static fr.ird.observe.ui.UIHelper.getStringValue + </import> + + <ReferentialSynchroUIHandler id='handler' initializer='getContextValue(ReferentialSynchroUIHandler.class)'/> + + <AdminUIModel id='model' initializer='getContextValue(AdminUIModel.class)'/> + + <ReferentialSynchroModel id='stepModel' initializer='model.getReferentialSynchroModel()'/> + + <ButtonGroup id='synchronizeMode' + onStateChanged='stepModel.setSynchronizeMode((ReferentialSynchronizeMode) synchronizeMode.getSelectedValue())'/> + + <script><![CDATA[ +public void destroy() { + model = null; + stepModel = null; +} + +@Override +protected void finalize() throws Throwable { + super.finalize(); + destroy(); +} + +]]> + </script> + + <JPanel id="referentialSynchronizeConfigPanel" constraints='BorderLayout.CENTER' layout='{new GridLayout(0, 1)}'> + <JToggleButton id="LEFT_TO_RIGHT"/> + <JToggleButton id="RIGHT_TO_LEFT"/> + <JToggleButton id="BOTH"/> + </JPanel> + <Table constraints='BorderLayout.SOUTH' weightx='1' weighty='1'> + <row> + <cell> + <JLabel/> + </cell> + </row> + </Table> + +</JPanel> diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroConfigUI.jcss b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroConfigUI.jcss new file mode 100644 index 0000000..3d0ed48 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroConfigUI.jcss @@ -0,0 +1,54 @@ +/* + * #%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% + */ + +#referentialSynchronizeConfig { + layout:{new BorderLayout()}; +} +#referentialSynchronizeConfigPanel { + border:{new TitledBorder(t("observe.actions.synchro.referential.config.mode"))}; +} + +#synchronizeMode { + selectedValue:{stepModel.getSynchronizeMode()}; +} + +#BOTH{ + buttonGroup:"synchronizeMode"; + value:{ReferentialSynchronizeMode.BOTH}; + text:{ReferentialSynchronizeMode.BOTH.getLabel()}; + selected:{ReferentialSynchronizeMode.BOTH == stepModel.getSynchronizeMode()}; +} + +#RIGHT_TO_LEFT { + buttonGroup:"synchronizeMode"; + value:{ReferentialSynchronizeMode.FROM_RIGHT_TO_LEFT}; + text:{ReferentialSynchronizeMode.FROM_RIGHT_TO_LEFT.getLabel()}; + selected:{ReferentialSynchronizeMode.FROM_RIGHT_TO_LEFT == stepModel.getSynchronizeMode()}; +} + +#LEFT_TO_RIGHT { + buttonGroup:"synchronizeMode"; + value:{ReferentialSynchronizeMode.FROM_LEFT_TO_RIGHT}; + text:{ReferentialSynchronizeMode.FROM_LEFT_TO_RIGHT.getLabel()}; + selected:{ReferentialSynchronizeMode.FROM_LEFT_TO_RIGHT == stepModel.getSynchronizeMode()}; +} + diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroModel.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroModel.java new file mode 100644 index 0000000..fa32d20 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroModel.java @@ -0,0 +1,123 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng; + +import fr.ird.observe.db.ObserveSwingDataSource; +import fr.ird.observe.services.service.actions.synchro.referential.ReferentialSynchronizeMode; +import fr.ird.observe.ui.admin.AdminActionModel; +import fr.ird.observe.ui.admin.AdminStep; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.ReferentialSynchronizeTaskSupport; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.ReferentialSynchronizeTreeModel; +import org.apache.commons.lang3.tuple.Pair; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import javax.swing.DefaultListModel; +import java.util.Objects; + +/** + * Created on 02/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferentialSynchroModel extends AdminActionModel { + + /** Logger. */ + private static final Log log = LogFactory.getLog(ReferentialSynchroModel.class); + + public static final String LEFT_SOURCE_PROPERTY_NAME = "leftSource"; + public static final String RIGHT_SOURCE_PROPERTY_NAME = "rightSource"; + public static final String TASKS_PROPERTY_NAME = "tasks"; + public static final String SYNCHRONIZE_MODE_PROPERTY_NAME = "synchronizeMode"; + public static final String RIGHT_TREE_MODEL_PROPERTY_NAME = "rightTreeModel"; + public static final String LEFT_TREE_MODEL_PROPERTY_NAME = "lefttTreeModel"; + + public static final String LEFT_SELECTION_MODEL_CHANGED_PROPERTY_NAME = "leftSelectionModelChanged"; + public static final String RIGHT_SELECTION_MODEL_CHANGED_PROPERTY_NAME = "rightSelectionModelChanged"; + + /** la source sur le panneau de gauche. */ + protected ObserveSwingDataSource leftSource; + + /** la source sur le panneau de droite. */ + protected ObserveSwingDataSource rightSource; + + /** le mode de synchronisation **/ + private ReferentialSynchronizeMode synchronizeMode; + + private ReferentialSynchronizeTreeModel leftTreeModel; + + private ReferentialSynchronizeTreeModel rightTreeModel; + + private final DefaultListModel<ReferentialSynchronizeTaskSupport> tasks; + + public ReferentialSynchroModel() { + super(AdminStep.REFERENTIAL_SYNCHRONIZE); + this.tasks = new DefaultListModel<>(); + } + + public ReferentialSynchronizeMode getSynchronizeMode() { + return synchronizeMode; + } + + public void setSynchronizeMode(ReferentialSynchronizeMode synchronizeMode) { + Object oldValue = getSynchronizeMode(); + this.synchronizeMode = synchronizeMode; + firePropertyChange(SYNCHRONIZE_MODE_PROPERTY_NAME, oldValue, synchronizeMode); + } + + public ObserveSwingDataSource getLeftSource() { + return leftSource; + } + + public void setLeftSource(ObserveSwingDataSource leftSource) { + this.leftSource = leftSource; + firePropertyChange(LEFT_SOURCE_PROPERTY_NAME, leftSource); + } + + public ObserveSwingDataSource getRightSource() { + return rightSource; + } + + public void setRightSource(ObserveSwingDataSource rightSource) { + this.rightSource = rightSource; + firePropertyChange(RIGHT_SOURCE_PROPERTY_NAME, rightSource); + } + + public ReferentialSynchronizeTreeModel getLeftTreeModel() { + return leftTreeModel; + } + + public void setLeftTreeModel(ReferentialSynchronizeTreeModel leftTreeModel) { + Object oldValue = getLeftTreeModel(); + this.leftTreeModel = leftTreeModel; + firePropertyChange(LEFT_TREE_MODEL_PROPERTY_NAME, oldValue, leftTreeModel); + } + + public ReferentialSynchronizeTreeModel getRightTreeModel() { + return rightTreeModel; + } + + public void setRightTreeModel(ReferentialSynchronizeTreeModel rightTreeModel) { + Object oldValue = getRightTreeModel(); + this.rightTreeModel = rightTreeModel; + firePropertyChange(RIGHT_TREE_MODEL_PROPERTY_NAME, oldValue, rightTreeModel); + } + + public DefaultListModel<ReferentialSynchronizeTaskSupport> getTasks() { + return tasks; + } + + public void addTask(ReferentialSynchronizeTaskSupport task) { + tasks.addElement(task); + } + + public void populateTreeModels() { + + Objects.nonNull(leftSource); + Objects.nonNull(rightSource); + + Pair<ReferentialSynchronizeTreeModel, ReferentialSynchronizeTreeModel> treePair = ReferentialSynchronizeTreeModel.buildTreeModels(this); + setLeftTreeModel(treePair.getLeft()); + setRightTreeModel(treePair.getRight()); + + } +} \ No newline at end of file diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroUI.jaxx b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroUI.jaxx similarity index 60% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroUI.jaxx rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroUI.jaxx index fea00d6..8429a6c 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchroUI.jaxx +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroUI.jaxx @@ -30,10 +30,9 @@ fr.ird.observe.ui.UIHelper fr.ird.observe.ui.admin.AdminUI fr.ird.observe.ui.admin.AdminStep + fr.ird.observe.ui.admin.synchronize.referential.ng.tree.ReferentialSynchronizeTreeModel + fr.ird.observe.ui.admin.synchronize.referential.ng.tree.ReferentialSynchronizeTreeCellRenderer fr.ird.observe.ui.tree.ObserveTreeHelper - fr.ird.observe.ui.tree.DataSelectionTreeCellRenderer - fr.ird.observe.ui.tree.DataSelectionTreeSelectionModel - fr.ird.observe.ui.storage.tabs.DataSelectionModel jaxx.runtime.SwingUtil @@ -45,25 +44,19 @@ <ObserveTreeHelper id='leftTreeHelper'/> <ObserveTreeHelper id='rightTreeHelper'/> - <DataSynchroUIHandler id='handler' constructorParams='this'/> + <ReferentialSynchroUIHandler id='handler' constructorParams='this'/> - <DataSynchroModel id='stepModel' initializer='getModel().getDataSynchroModel()'/> + <ReferentialSynchroModel id='stepModel' initializer='getModel().getReferentialSynchroModel()'/> - <DataSelectionModel id='leftSelectDataModel' - initializer='getModel().getDataSynchroModel().getLeftSelectionDataModel()'/> - <DataSelectionTreeSelectionModel id='leftSelectionModel'/> - - <DataSelectionModel id='rightSelectDataModel' - initializer='getModel().getDataSynchroModel().getRightSelectionDataModel()'/> - <DataSelectionTreeSelectionModel id='rightSelectionModel'/> + <ReferentialSynchronizeTreeModel id="leftTreeModel" javaBean="getStepModel().getLeftTreeModel()"/> + <ReferentialSynchronizeTreeModel id="rightTreeModel" javaBean="getStepModel().getRightTreeModel()"/> <JPanel id='invisiblePanel'> - <DataSelectionTreeCellRenderer id='leftSelectionRenderer'/> - <DataSelectionTreeCellRenderer id='rightSelectionRenderer'/> + </JPanel> <script><![CDATA[ -public DataSynchroUI(AdminUI parentContext) { - super(AdminStep.DATA_SYNCHRONIZE, parentContext); +public ReferentialSynchroUI(AdminUI parentContext) { + super(AdminStep.REFERENTIAL_SYNCHRONIZE, parentContext); } public void initUI(AdminUI ui) { @@ -72,8 +65,8 @@ public void initUI(AdminUI ui) { @Override public void destroy() { - leftSelectionModel.clearSelection(); - rightSelectionModel.clearSelection(); + leftTreeModel.clearSelection(); + rightTreeModel.clearSelection(); super.destroy(); } ]]> @@ -91,10 +84,21 @@ public void destroy() { <cell weightx="0.1"> <JPanel layout="{new BorderLayout()}" border='{new TitledBorder(" ")}'> <JPanel id="middleActions" layout="{new GridLayout(0, 2)}" constraints='BorderLayout.CENTER'> - <JButton id="copyToRight" onActionPerformed="getHandler().addCopyToRightTasks()"/> - <JButton id="copyToLeft" onActionPerformed="getHandler().addCopyToLeftTasks()"/> - <JButton id="deleteFromLeft" onActionPerformed="getHandler().addDeleteFromLeftTasks()"/> - <JButton id="deleteFromRight" onActionPerformed="getHandler().addDeleteFromRightTasks()"/> + <JButton id="copyRight" onActionPerformed="getHandler().addCopyRightTasks()"/> + <JButton id="copyLeft" onActionPerformed="getHandler().addCopyLeftTasks()"/> + <JButton id="revertLeft" onActionPerformed="getHandler().addRevertLeftTasks()"/> + <JButton id="revertRight" onActionPerformed="getHandler().addRevertRightTasks()"/> + <JButton id="desactivateLeft" onActionPerformed="getHandler().addDesactivateLeftTasks()"/> + <JButton id="desactivateRight" onActionPerformed="getHandler().addDesactivateRightTasks()"/> + <JButton id="desactivateLeftWithReplace" + onActionPerformed="getHandler().addDesactivateLeftWithReplaceTasks()"/> + <JButton id="desactivateRightWithReplace" + onActionPerformed="getHandler().addDesactivateRightWithReplaceTasks()"/> + <JButton id="deleteLeft" onActionPerformed="getHandler().addDeleteLeftTasks()"/> + <JButton id="deleteRight" onActionPerformed="getHandler().addDeleteRightTasks()"/> + <JButton id="skipLeft" onActionPerformed="getHandler().addSkipLeftTasks()"/> + <JButton id="skipRight" onActionPerformed="getHandler().addSkipRightTasks()"/> + </JPanel> </JPanel> </cell> diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroUI.jcss b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroUI.jcss new file mode 100644 index 0000000..377ac0c --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroUI.jcss @@ -0,0 +1,150 @@ +/* + * #%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% + */ + +#PENDING_content { + layout:{new BorderLayout()}; +} + +#contentSplitPane { + orientation: {JSplitPane.VERTICAL_SPLIT}; + resizeWeight: 0.8; +} + +#applyAction { + actionIcon:accept; + text:"observe.action.apply"; +} + +#leftTree { + rootVisible:false; + largeModel:true; + minimumSize:{UIHelper.newMinDimension()}; + font-size:11; + showsRootHandles:false; + toggleClickCount:100; + model:{getLeftTreeModel()}; + selectionModel:{getLeftTreeModel()}; + cellRenderer:{new ReferentialSynchronizeTreeCellRenderer()}; +} + +#leftTreePane { + verticalScrollBarPolicy:{JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED}; +} + +#rightTree { + rootVisible:false; + largeModel:true; + minimumSize:{UIHelper.newMinDimension()}; + font-size:11; + showsRootHandles:false; + toggleClickCount:100; + model:{getRightTreeModel()}; + selectionModel:{getRightTreeModel()}; + cellRenderer:{new ReferentialSynchronizeTreeCellRenderer()}; +} + +#rightTreePane { + verticalScrollBarPolicy:{JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED}; +} + +#copyLeft { + actionIcon:copyToLeft; + toolTipText:"observe.actions.synchro.referential.copyToLeft.tip"; + enabled:false; +} + +#copyRight { + actionIcon:copyToRight; + toolTipText:"observe.actions.synchro.referential.copyToRight.tip"; + enabled:false; +} + +#revertLeft { + actionIcon:revertToLeft; + toolTipText:"observe.actions.synchro.referential.revertToLeft.tip"; + enabled:false; +} + +#revertRight { + actionIcon:revertToRight; + toolTipText:"observe.actions.synchro.referential.revertToRight.tip"; + enabled:false; +} + +#skipLeft { + actionIcon:skipToLeft; + toolTipText:"observe.actions.synchro.referential.skipToLeft.tip"; + enabled:false; +} + +#skipRight { + actionIcon:skipToRight; + toolTipText:"observe.actions.synchro.referential.skipToRight.tip"; + enabled:false; +} + +#deleteLeft { + actionIcon:deleteFromLeft; + toolTipText:"observe.actions.synchro.referential.deleteFromLeft.tip"; + enabled:false; +} + +#deleteRight { + actionIcon:deleteFromRight; + toolTipText:"observe.actions.synchro.referential.deleteFromRight.tip"; + enabled:false; +} + +#desactivateLeft { + actionIcon:desactivateFromLeft; + toolTipText:"observe.actions.synchro.referential.desactivateFromLeft.tip"; + enabled:false; +} + +#desactivateRight { + actionIcon:desactivateFromRight; + toolTipText:"observe.actions.synchro.referential.desactivateFromRight.tip"; + enabled:false; +} + +#desactivateLeftWithReplace { + actionIcon:desactivateFromLeftWithReplace; + toolTipText:"observe.actions.synchro.referential.desactivateFromLeftWithReplace.tip"; + enabled:false; +} + +#desactivateRightWithReplace { + actionIcon:desactivateFromRightWithReplace; + toolTipText:"observe.actions.synchro.referential.desactivateFromRightWithReplace.tip"; + enabled:false; +} + +#actionsToConsumePane { + border:{new TitledBorder(t("observe.actions.synchro.data.actionsToPerform"))}; + verticalScrollBarPolicy:{JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED}; +} + +#actionsToConsume { + selectionMode:{ListSelectionModel.SINGLE_SELECTION}; + cellRenderer:{new ReferentialSynchronizeTaskListCellRenderer()}; + model:{getStepModel().getTasks()}; +} \ No newline at end of file diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroUIHandler.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroUIHandler.java new file mode 100644 index 0000000..b5d652e --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroUIHandler.java @@ -0,0 +1,311 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng; + +import fr.ird.observe.application.swing.decoration.DecoratorService; +import fr.ird.observe.application.swing.decoration.decorators.ReferentialReferenceDecorator; +import fr.ird.observe.db.ObserveSwingDataSource; +import fr.ird.observe.services.configuration.ObserveDataSourceConfigurationTopiaH2; +import fr.ird.observe.services.dto.referential.ProgramDto; +import fr.ird.observe.services.service.actions.synchro.referential.ng.ReferentialSynchronizeRequest; +import fr.ird.observe.services.service.actions.synchro.referential.ng.ReferentialSynchronizeService; +import fr.ird.observe.services.service.actions.synchro.referential.ng.task.ReferentialSynchronizeCopyTask; +import fr.ird.observe.services.service.actions.synchro.referential.ng.task.ReferentialSynchronizeDeleteTask; +import fr.ird.observe.services.service.actions.synchro.referential.ng.task.ReferentialSynchronizeDesactivateTask; +import fr.ird.observe.services.service.actions.synchro.referential.ng.task.ReferentialSynchronizeDesactivateWithReplaceTask; +import fr.ird.observe.ui.UIHelper; +import fr.ird.observe.ui.admin.AdminStep; +import fr.ird.observe.ui.admin.AdminTabUI; +import fr.ird.observe.ui.admin.AdminTabUIHandler; +import fr.ird.observe.ui.admin.AdminUI; +import fr.ird.observe.ui.admin.config.ConfigUI; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.CopyToLeftReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.CopyToRightReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.DeleteFromLeftReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.DeleteFromRightReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.DesactivateFromLeftReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.DesactivateFromLeftWithReplaceReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.DesactivateFromRightReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.DesactivateFromRightWithReplaceReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.ReferentialSynchronizeTaskSupport; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.SkipFromLeftReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.SkipFromRightReferentialSynchronizeTask; +import jaxx.runtime.context.JAXXInitialContext; +import jaxx.runtime.swing.wizard.ext.WizardState; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import javax.swing.DefaultListModel; +import javax.swing.border.TitledBorder; +import javax.swing.tree.TreeModel; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 02/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferentialSynchroUIHandler extends AdminTabUIHandler { + + /** Logger */ + private static final Log log = LogFactory.getLog(ReferentialSynchroUIHandler.class); + + public ReferentialSynchroUIHandler(ReferentialSynchroUI ui) { + super(ui); + } + + public ReferentialSynchroModel getStepModel() { + return model.getReferentialSynchroModel(); + } + + @Override + public ReferentialSynchroUI getUi() { + return (ReferentialSynchroUI) super.getUi(); + } + + @Override + public void updateState(AdminTabUI ui, WizardState newState) { + super.updateState(ui, newState); + } + + public void initTabUI(AdminUI ui, ReferentialSynchroUI tabUI) { + + super.initTabUI(ui, tabUI); + + if (log.isDebugEnabled()) { + log.debug(" specialized for [" + tabUI.getStep() + "] for main ui " + ui.getClass().getName() + "@" + System.identityHashCode(ui)); + } + + getStepModel().addPropertyChangeListener(ReferentialSynchroModel.LEFT_TREE_MODEL_PROPERTY_NAME, evt -> { + + TreeModel treeModel = (TreeModel) evt.getNewValue(); + + tabUI.getLeftTreePane().setBorder(new TitledBorder(getModel().getLocalSourceModel().getLabel())); + tabUI.getLeftTree().setModel(treeModel); + + UIHelper.initUI(tabUI.getLeftTreePane(), tabUI.getLeftTree()); + + sendMessage(t("observe.actions.synchro.referential.message.referential.leftData.loaded")); + }); + + getStepModel().addPropertyChangeListener(ReferentialSynchroModel.RIGHT_TREE_MODEL_PROPERTY_NAME, evt -> { + + TreeModel treeModel = (TreeModel) evt.getNewValue(); + + tabUI.getRightTreePane().setBorder(new TitledBorder(getModel().getCentralSourceModel().getLabel())); + tabUI.getRightTree().setModel(treeModel); + + UIHelper.initUI(tabUI.getRightTreePane(), tabUI.getRightTree()); + + sendMessage(t("observe.actions.synchro.referential.message.referential.rightData.loaded")); + + }); + + + ConfigUI configUI = (ConfigUI) ui.getStepUI(AdminStep.CONFIG); + JAXXInitialContext tx = new JAXXInitialContext().add(configUI).add(this); + ReferentialSynchroConfigUI extraConfig = new ReferentialSynchroConfigUI(tx); + configUI.getExtraConfig().add(extraConfig); + + } + + public void addCopyLeftTasks() { + +// DataSelectionModel rightSelectionDataModel = getStepModel().getRightSelectionDataModel(); +// DataSelectionModel leftSelectionDataModel = getStepModel().getLeftSelectionDataModel(); +// ObserveTreeHelper rightTreeHelper = getUi().getRightTreeHelper(); +// ObserveTreeHelper leftTreeHelper = getUi().getLeftTreeHelper(); +// Map<ReferentialReference<ProgramDto>, List<DataReference>> selectedDataByProgram = rightSelectionDataModel.getSelectedDataByProgram(); +// rightSelectionDataModel.removeAllSelectedData(); + + } + + public void addCopyRightTasks() { + +// DataSelectionModel leftSelectionDataModel = getStepModel().getLeftSelectionDataModel(); +// DataSelectionModel rightSelectionDataModel = getStepModel().getRightSelectionDataModel(); +// ObserveTreeHelper leftTreeHelper = getUi().getLeftTreeHelper(); +// ObserveTreeHelper rightTreeHelper = getUi().getRightTreeHelper(); +// Map<ReferentialReference<ProgramDto>, List<DataReference>> selectedDataByProgram = leftSelectionDataModel.getSelectedDataByProgram(); +// leftSelectionDataModel.removeAllSelectedData(); + + } + + public void addRevertRightTasks() { + + } + + public void addRevertLeftTasks() { + + } + + public void addSkipRightTasks() { + + } + + public void addSkipLeftTasks() { + + } + + public void addDeleteLeftTasks() { + +// DataSelectionModel selectionDataModel = getStepModel().getLeftSelectionDataModel(); +// ObserveTreeHelper treeHelper = getUi().getLeftTreeHelper(); +// Map<ReferentialReference<ProgramDto>, List<DataReference>> selectedDataByProgram = selectionDataModel.getSelectedDataByProgram(); +// selectionDataModel.removeAllSelectedData(); + + } + + public void addDeleteRightTasks() { + +// DataSelectionModel selectionDataModel = getStepModel().getRightSelectionDataModel(); +// ObserveTreeHelper treeHelper = getUi().getRightTreeHelper(); +// Map<ReferentialReference<ProgramDto>, List<DataReference>> selectedDataByProgram = selectionDataModel.getSelectedDataByProgram(); +// selectionDataModel.removeAllSelectedData(); + + } + + public void addDesactivateLeftTasks() { + +// DataSelectionModel selectionDataModel = getStepModel().getLeftSelectionDataModel(); +// ObserveTreeHelper treeHelper = getUi().getLeftTreeHelper(); +// Map<ReferentialReference<ProgramDto>, List<DataReference>> selectedDataByProgram = selectionDataModel.getSelectedDataByProgram(); +// selectionDataModel.removeAllSelectedData(); + + } + + public void addDesactivateLeftWithReplaceTasks() { + +// DataSelectionModel selectionDataModel = getStepModel().getLeftSelectionDataModel(); +// ObserveTreeHelper treeHelper = getUi().getLeftTreeHelper(); +// Map<ReferentialReference<ProgramDto>, List<DataReference>> selectedDataByProgram = selectionDataModel.getSelectedDataByProgram(); +// selectionDataModel.removeAllSelectedData(); + + } + + public void addDesactivateRightTasks() { + +// DataSelectionModel selectionDataModel = getStepModel().getRightSelectionDataModel(); +// ObserveTreeHelper treeHelper = getUi().getRightTreeHelper(); +// Map<ReferentialReference<ProgramDto>, List<DataReference>> selectedDataByProgram = selectionDataModel.getSelectedDataByProgram(); +// selectionDataModel.removeAllSelectedData(); + + } + + public void addDesactivateRightWithReplaceTasks() { + +// DataSelectionModel selectionDataModel = getStepModel().getRightSelectionDataModel(); +// ObserveTreeHelper treeHelper = getUi().getRightTreeHelper(); +// Map<ReferentialReference<ProgramDto>, List<DataReference>> selectedDataByProgram = selectionDataModel.getSelectedDataByProgram(); +// selectionDataModel.removeAllSelectedData(); + + } + + public void doExecuteAction() { + + ObserveSwingDataSource leftSource = getStepModel().getLeftSource(); + boolean leftSourceIsH2 = leftSource.getConfiguration() instanceof ObserveDataSourceConfigurationTopiaH2; + + ObserveSwingDataSource rightSource = getStepModel().getRightSource(); + boolean rightSourceIsH2 = rightSource.getConfiguration() instanceof ObserveDataSourceConfigurationTopiaH2; + + DefaultListModel<ReferentialSynchronizeTaskSupport> tasks = getStepModel().getTasks(); + int size = tasks.size(); + + DecoratorService decoratorService = getDecoratorService(); + ReferentialReferenceDecorator<ProgramDto> programDecorator = decoratorService.getReferentialReferenceDecorator(ProgramDto.class); + + ReferentialSynchronizeRequest.Builder leftReferentialSynchronizeRequestBuilder = ReferentialSynchronizeRequest.builder(leftSourceIsH2, rightSourceIsH2); + ReferentialSynchronizeRequest.Builder rightReferentialSynchronizeRequestBuilder = ReferentialSynchronizeRequest.builder(rightSourceIsH2, leftSourceIsH2); + for (int i = 0; i < size; i++) { + + ReferentialSynchronizeTaskSupport<?> task = tasks.getElementAt(i); + + String typeStr = task.decorateType(); + String dataStr = task.decorateData(); + + if (task instanceof DeleteFromLeftReferentialSynchronizeTask) { + + sendMessage(t("observe.actions.synchro.referential.prepare.deleteFromLeftTask", typeStr, dataStr)); + leftReferentialSynchronizeRequestBuilder.addDeleteTask(new ReferentialSynchronizeDeleteTask<>(task.getData())); + continue; + } + + if (task instanceof DeleteFromRightReferentialSynchronizeTask) { + sendMessage(t("observe.actions.synchro.referential.prepare.deleteFromRightTask", typeStr, dataStr)); + rightReferentialSynchronizeRequestBuilder.addDeleteTask(new ReferentialSynchronizeDeleteTask<>(task.getData())); + continue; + } + + if (task instanceof DesactivateFromLeftReferentialSynchronizeTask) { + + sendMessage(t("observe.actions.synchro.referential.prepare.desactivateFromLeftTask", typeStr, dataStr)); + leftReferentialSynchronizeRequestBuilder.addDesactivateTask(new ReferentialSynchronizeDesactivateTask<>(task.getData())); + continue; + } + + if (task instanceof DesactivateFromRightReferentialSynchronizeTask) { + sendMessage(t("observe.actions.synchro.referential.prepare.desactivateFromRightTask", typeStr, dataStr)); + rightReferentialSynchronizeRequestBuilder.addDesactivateTask(new ReferentialSynchronizeDesactivateTask<>(task.getData())); + continue; + } + + if (task instanceof DesactivateFromLeftWithReplaceReferentialSynchronizeTask) { + + sendMessage(t("observe.actions.synchro.referential.prepare.desactivateFromLeftWithReplaceTask", typeStr, dataStr)); + leftReferentialSynchronizeRequestBuilder.addDesactivateWithReplaceTask(new ReferentialSynchronizeDesactivateWithReplaceTask<>(task.getData())); + continue; + } + + if (task instanceof DesactivateFromRightWithReplaceReferentialSynchronizeTask) { + sendMessage(t("observe.actions.synchro.referential.prepare.desactivateFromRightWithReplaceTask", typeStr, dataStr)); + rightReferentialSynchronizeRequestBuilder.addDesactivateWithReplaceTask(new ReferentialSynchronizeDesactivateWithReplaceTask<>(task.getData())); + continue; + } + + if (task instanceof CopyToLeftReferentialSynchronizeTask) { + CopyToLeftReferentialSynchronizeTask task1 = (CopyToLeftReferentialSynchronizeTask) task; + sendMessage(t("observe.actions.synchro.referential.prepare.copyToLeftTask", typeStr, dataStr)); + leftReferentialSynchronizeRequestBuilder.addCopyTask(new ReferentialSynchronizeCopyTask<>(task.getData())); + continue; + } + + if (task instanceof CopyToRightReferentialSynchronizeTask) { + CopyToRightReferentialSynchronizeTask task1 = (CopyToRightReferentialSynchronizeTask) task; + sendMessage(t("observe.actions.synchro.referential.prepare.copyToRightTask", typeStr, dataStr)); + rightReferentialSynchronizeRequestBuilder.addCopyTask(new ReferentialSynchronizeCopyTask<>(task.getData())); + continue; + } + + if (task instanceof SkipFromLeftReferentialSynchronizeTask) { + sendMessage(t("observe.actions.synchro.data.prepare.skipFromLeftTask", typeStr, dataStr)); + continue; + } + if (task instanceof SkipFromRightReferentialSynchronizeTask) { + sendMessage(t("observe.actions.synchro.data.prepare.skipFromRightTask", typeStr, dataStr)); + } + + } + + ReferentialSynchronizeService leftReferentialSynchronizeService = leftSource.newReferentialSynchronizeService(); + ReferentialSynchronizeService rightReferentialSynchronizeService = rightSource.newReferentialSynchronizeService(); + + ReferentialSynchronizeRequest leftReferentialSynchronizeRequest = leftReferentialSynchronizeRequestBuilder.build(); + if (leftReferentialSynchronizeRequest.isNotEmpty()) { + rightReferentialSynchronizeService.prepareRequestOnOppositeDataSource(leftReferentialSynchronizeRequest); + leftReferentialSynchronizeService.prepareRequestOnDataSource(leftReferentialSynchronizeRequest); + leftReferentialSynchronizeService.executeRequest(leftReferentialSynchronizeRequest); + } + + ReferentialSynchronizeRequest rightReferentialSynchronizeRequest = rightReferentialSynchronizeRequestBuilder.build(); + if (rightReferentialSynchronizeRequest.isNotEmpty()) { + leftReferentialSynchronizeService.prepareRequestOnOppositeDataSource(rightReferentialSynchronizeRequest); + rightReferentialSynchronizeService.prepareRequestOnDataSource(rightReferentialSynchronizeRequest); + rightReferentialSynchronizeService.executeRequest(rightReferentialSynchronizeRequest); + } + + getModel().setStepState(WizardState.SUCCESSED); + + } + +} \ No newline at end of file diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchronizeTaskListCellRenderer.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchronizeTaskListCellRenderer.java similarity index 62% rename from observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchronizeTaskListCellRenderer.java rename to observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchronizeTaskListCellRenderer.java index 14e77c9..37ec1b9 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/datasynchro/DataSynchronizeTaskListCellRenderer.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchronizeTaskListCellRenderer.java @@ -1,4 +1,6 @@ -package fr.ird.observe.ui.admin.datasynchro; +package fr.ird.observe.ui.admin.synchronize.referential.ng; + +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.ReferentialSynchronizeTaskSupport; import javax.swing.DefaultListCellRenderer; import javax.swing.JList; @@ -10,14 +12,14 @@ import java.awt.Component; * @author Tony Chemit - chemit@codelutin.com * @since 5.0 */ -public class DataSynchronizeTaskListCellRenderer extends DefaultListCellRenderer { +public class ReferentialSynchronizeTaskListCellRenderer extends DefaultListCellRenderer { private static final long serialVersionUID = 1L; @Override public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) { - DataSynchronizeTaskSupport task = (DataSynchronizeTaskSupport) value; + ReferentialSynchronizeTaskSupport task = (ReferentialSynchronizeTaskSupport) value; super.getListCellRendererComponent(list, task.getLabel(), index, isSelected, cellHasFocus); setIcon(task.getIcon()); return this; diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/CopyToLeftReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/CopyToLeftReferentialSynchronizeTask.java new file mode 100644 index 0000000..1b0c340 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/CopyToLeftReferentialSynchronizeTask.java @@ -0,0 +1,25 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class CopyToLeftReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public CopyToLeftReferentialSynchronizeTask(ReferentialReference<R> data) { + super(data, "copyToLeft"); + } + + @Override + public String getLabel() { + return t("observe.actions.synchro.referential.copyToLeftTask", decorateType(), decorateData()); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/CopyToRightReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/CopyToRightReferentialSynchronizeTask.java new file mode 100644 index 0000000..9e6f33b --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/CopyToRightReferentialSynchronizeTask.java @@ -0,0 +1,25 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class CopyToRightReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public CopyToRightReferentialSynchronizeTask(ReferentialReference<R> data) { + super(data, "copyToRight"); + } + + @Override + public String getLabel() { + return t("observe.actions.synchro.referential.copyToRightTask", decorateType(), decorateData()); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DeleteFromLeftReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DeleteFromLeftReferentialSynchronizeTask.java new file mode 100644 index 0000000..15779b5 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DeleteFromLeftReferentialSynchronizeTask.java @@ -0,0 +1,25 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class DeleteFromLeftReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public DeleteFromLeftReferentialSynchronizeTask(ReferentialReference<R> data) { + super(data, "deleteFromLeft"); + } + + @Override + public String getLabel() { + return t("observe.actions.synchro.referential.deleteFromLeftTask", decorateType(), decorateData()); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DeleteFromRightReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DeleteFromRightReferentialSynchronizeTask.java new file mode 100644 index 0000000..bc8806b --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DeleteFromRightReferentialSynchronizeTask.java @@ -0,0 +1,25 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class DeleteFromRightReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public DeleteFromRightReferentialSynchronizeTask(ReferentialReference<R> data) { + super(data, "deleteFromRight"); + } + + @Override + public String getLabel() { + return t("observe.actions.synchro.referential.deleteFromRightTask", decorateType(), decorateData()); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromLeftReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromLeftReferentialSynchronizeTask.java new file mode 100644 index 0000000..eb4325e --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromLeftReferentialSynchronizeTask.java @@ -0,0 +1,25 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class DesactivateFromLeftReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public DesactivateFromLeftReferentialSynchronizeTask(ReferentialReference<R> data) { + super(data, "desactivateFromLeft"); + } + + @Override + public String getLabel() { + return t("observe.actions.synchro.referential.desactivateFromLeftTask", decorateType(), decorateData()); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromLeftWithReplaceReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromLeftWithReplaceReferentialSynchronizeTask.java new file mode 100644 index 0000000..eddf0e9 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromLeftWithReplaceReferentialSynchronizeTask.java @@ -0,0 +1,25 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class DesactivateFromLeftWithReplaceReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public DesactivateFromLeftWithReplaceReferentialSynchronizeTask(ReferentialReference<R> data) { + super(data, "desactivateFromLeftWithReplace"); + } + + @Override + public String getLabel() { + return t("observe.actions.synchro.referential.desactivateFromLeftWithReplaceTask", decorateType(), decorateData()); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromRightReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromRightReferentialSynchronizeTask.java new file mode 100644 index 0000000..ef8a85a --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromRightReferentialSynchronizeTask.java @@ -0,0 +1,25 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class DesactivateFromRightReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public DesactivateFromRightReferentialSynchronizeTask(ReferentialReference<R> data) { + super(data, "desactivateFromRight"); + } + + @Override + public String getLabel() { + return t("observe.actions.synchro.referential.desactivateFromRightTask", decorateType(), decorateData()); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromRightWithReplaceReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromRightWithReplaceReferentialSynchronizeTask.java new file mode 100644 index 0000000..5bfbab8 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromRightWithReplaceReferentialSynchronizeTask.java @@ -0,0 +1,25 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class DesactivateFromRightWithReplaceReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public DesactivateFromRightWithReplaceReferentialSynchronizeTask(ReferentialReference<R> data) { + super(data, "desactivateFromRightWithReplace"); + } + + @Override + public String getLabel() { + return t("observe.actions.synchro.referential.desactivateFromRightWithReplaceTask", decorateType(), decorateData()); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/ReferentialSynchronizeTaskSupport.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/ReferentialSynchronizeTaskSupport.java new file mode 100644 index 0000000..7ca9c2f --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/ReferentialSynchronizeTaskSupport.java @@ -0,0 +1,48 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.ObserveSwingApplicationContext; +import fr.ird.observe.application.swing.decoration.DecoratorService; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import jaxx.runtime.SwingUtil; + +import javax.swing.Icon; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 03/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public abstract class ReferentialSynchronizeTaskSupport<R extends ReferentialDto> { + + private final ReferentialReference<R> data; + private final Icon icon; + + protected ReferentialSynchronizeTaskSupport(ReferentialReference<R> data, String iconName) { + this.data = data; + this.icon = SwingUtil.createActionIcon(iconName); + } + + public abstract String getLabel(); + + public ReferentialReference<R> getData() { + return data; + } + + public Icon getIcon() { + return icon; + } + + public String decorateData() { + DecoratorService decoratorService = ObserveSwingApplicationContext.get().getDecoratorService(); + return decoratorService.getReferentialReferenceDecorator(data.getType()).toString(data); + } + + public String decorateType() { + DecoratorService decoratorService = ObserveSwingApplicationContext.get().getDecoratorService(); + return t(decoratorService.getEntityLabel(data.getType())); + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/RevertFromLeftReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/RevertFromLeftReferentialSynchronizeTask.java new file mode 100644 index 0000000..86290f0 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/RevertFromLeftReferentialSynchronizeTask.java @@ -0,0 +1,25 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class RevertFromLeftReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public RevertFromLeftReferentialSynchronizeTask(ReferentialReference<R> data) { + super(data, "revertFromLeft"); + } + + @Override + public String getLabel() { + return t("observe.actions.synchro.referential.revertFromRightLeft", decorateType(), decorateData()); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/RevertFromRightReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/RevertFromRightReferentialSynchronizeTask.java new file mode 100644 index 0000000..be1568a --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/RevertFromRightReferentialSynchronizeTask.java @@ -0,0 +1,25 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class RevertFromRightReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public RevertFromRightReferentialSynchronizeTask(ReferentialReference<R> data) { + super(data, "revertFromRight"); + } + + @Override + public String getLabel() { + return t("observe.actions.synchro.referential.revertFromRightTask", decorateType(), decorateData()); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/SkipFromLeftReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/SkipFromLeftReferentialSynchronizeTask.java new file mode 100644 index 0000000..8cfb74d --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/SkipFromLeftReferentialSynchronizeTask.java @@ -0,0 +1,25 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class SkipFromLeftReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public SkipFromLeftReferentialSynchronizeTask(ReferentialReference<R> data) { + super(data, "skipFromLeft"); + } + + @Override + public String getLabel() { + return t("observe.actions.synchro.referential.skipFromLeftTask", decorateType(), decorateData()); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/SkipFromRightReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/SkipFromRightReferentialSynchronizeTask.java new file mode 100644 index 0000000..24f5772 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/SkipFromRightReferentialSynchronizeTask.java @@ -0,0 +1,25 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class SkipFromRightReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public SkipFromRightReferentialSynchronizeTask(ReferentialReference<R> data) { + super(data, "skipFromRight"); + } + + @Override + public String getLabel() { + return t("observe.actions.synchro.referential.skipFromRightTask", decorateType(), decorateData()); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/ReferentialSynchronizeTreeCellRenderer.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/ReferentialSynchronizeTreeCellRenderer.java new file mode 100644 index 0000000..843511b --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/ReferentialSynchronizeTreeCellRenderer.java @@ -0,0 +1,141 @@ +/* + * #%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.referential.ng.tree; + +import fr.ird.observe.ObserveSwingApplicationContext; +import fr.ird.observe.application.swing.decoration.DecoratorService; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferenceReferentialSynchroNode; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferentialSynchroNodeSupport; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.TypeReferentialSynchroNode; +import fr.ird.observe.ui.tree.ObserveTreeHelper; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.decorator.Decorator; + +import javax.swing.Icon; +import javax.swing.JComponent; +import javax.swing.JTree; +import javax.swing.UIManager; +import javax.swing.tree.DefaultTreeCellRenderer; +import java.awt.Color; +import java.awt.Component; + +import static org.nuiton.i18n.I18n.t; + +/** + * Le renderer pour décorer l'arbre de sélection des données. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.2 + */ +public class ReferentialSynchronizeTreeCellRenderer extends DefaultTreeCellRenderer { + + /** Logger */ + private static final Log log = LogFactory.getLog(ReferentialSynchronizeTreeCellRenderer.class); + + private static final long serialVersionUID = 1L; + + public ReferentialSynchronizeTreeCellRenderer() { + + setBackgroundNonSelectionColor(null); + setBackgroundSelectionColor(null); + setBackground(null); + + setTextNonSelectionColor(Color.BLACK); + setTextSelectionColor(Color.BLUE); + } + + /** service de décoration */ + protected transient DecoratorService decoratorService; + + public DecoratorService getDecoratorService() { + if (decoratorService == null) { + + // on récupère le service commun + decoratorService = ObserveSwingApplicationContext.get().getDecoratorService(); + } + return decoratorService; + } + + @Override + public Component getTreeCellRendererComponent( + JTree tree, + Object value, + boolean sel, + boolean expanded, + boolean leaf, + int row, + boolean hasFocus) { + + // get the icon to set for the node + ReferentialSynchroNodeSupport node = (ReferentialSynchroNodeSupport) value; + + if (node == null) { + return super.getTreeCellRendererComponent( + tree, + value, + sel, + expanded, + leaf, + row, + hasFocus + ); + } + + String text = null; + Icon icon = null; + if (node instanceof TypeReferentialSynchroNode) { + TypeReferentialSynchroNode node1 = (TypeReferentialSynchroNode) node; + icon = UIManager.getIcon("icon.navigation.sub.referentiel16"); + text = t(DecoratorService.getEntityLabel(ObserveTreeHelper.TREE_NODE_PREFIX, node1.getUserObject())); + } else if (node instanceof ReferenceReferentialSynchroNode) { + ReferenceReferentialSynchroNode node1 = (ReferenceReferentialSynchroNode) node; + + icon = node1.getType().icon(); + ReferentialReference reference = node1.getUserObject(); + Decorator<?> decorator = getDecoratorService().getReferentialReferenceDecorator(reference.getType()); + text = decorator.toString(node); + } + + setIcon(icon); + + Component comp = super.getTreeCellRendererComponent( + tree, + text, + sel, + expanded, + leaf, + row, + hasFocus + ); + + ((JComponent) comp).setToolTipText(text); + return comp; + } + + @Override + public Color getBackgroundNonSelectionColor() { + // Fixes http://forge.codelutin.com/issues/830 for jdk 7 + return Color.WHITE; + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/ReferentialSynchronizeTreeModel.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/ReferentialSynchronizeTreeModel.java new file mode 100644 index 0000000..9a2050f --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/ReferentialSynchronizeTreeModel.java @@ -0,0 +1,411 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.tree; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.db.ObserveSwingDataSource; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.services.dto.referential.ReferentialReferenceSet; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiff; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffService; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffState; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffs; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffsEngine; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchroModel; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferenceReferentialSynchroNode; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferentialSynchroNodeSupport; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.RootReferentialSynchroNode; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.TypeReferentialSynchroNode; +import org.apache.commons.lang3.tuple.Pair; + +import javax.swing.event.TreeModelListener; +import javax.swing.event.TreeSelectionListener; +import javax.swing.tree.DefaultTreeModel; +import javax.swing.tree.DefaultTreeSelectionModel; +import javax.swing.tree.RowMapper; +import javax.swing.tree.TreeModel; +import javax.swing.tree.TreePath; +import javax.swing.tree.TreeSelectionModel; +import java.beans.PropertyChangeListener; +import java.util.Optional; + +/** + * Created on 10/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferentialSynchronizeTreeModel implements TreeSelectionModel, TreeModel { + + private final TreeSelectionModel treeSelectionModel; + private final TreeModel treeModel; + + public static Pair<ReferentialSynchronizeTreeModel, ReferentialSynchronizeTreeModel> buildTreeModels(ReferentialSynchroModel model) { + + ObserveSwingDataSource leftSource = model.getLeftSource(); + Preconditions.checkState(leftSource.isOpen()); + ObserveSwingDataSource rightSource = model.getRightSource(); + Preconditions.checkState(rightSource.isOpen()); + + ReferentialSynchronizeDiffService leftDiffSynchronizeService = leftSource.newReferentialSynchronizeDiffService(); + ReferentialSynchronizeDiffService rightDiffSynchronizeService = rightSource.newReferentialSynchronizeDiffService(); + + ReferentialSynchronizeDiffsEngine engine = new ReferentialSynchronizeDiffsEngine(leftDiffSynchronizeService, rightDiffSynchronizeService); + + ReferentialSynchronizeDiffs synchronizeDiffs = engine.build(model.getSynchronizeMode()); + + ImmutableSet<Class<? extends ReferentialDto>> referentialNames = synchronizeDiffs.getReferentialNames(); + RootReferentialSynchroNode leftRootNode = new RootReferentialSynchroNode(true); + RootReferentialSynchroNode rightRootNode = new RootReferentialSynchroNode(false); + + switch (model.getSynchronizeMode()) { + + case FROM_LEFT_TO_RIGHT: + for (Class<? extends ReferentialDto> referentialName : referentialNames) { + buildFromLeftToRight(engine, referentialName, synchronizeDiffs, leftRootNode, rightRootNode); + } + break; + case FROM_RIGHT_TO_LEFT: + for (Class<? extends ReferentialDto> referentialName : referentialNames) { + buildFromRightToLeft(engine, referentialName, synchronizeDiffs, leftRootNode, rightRootNode); + } + break; + case BOTH: + for (Class<? extends ReferentialDto> referentialName : referentialNames) { + buildFromBoth(engine, referentialName, synchronizeDiffs, leftRootNode, rightRootNode); + } + break; + } + + return Pair.of(new ReferentialSynchronizeTreeModel(leftRootNode), new ReferentialSynchronizeTreeModel(rightRootNode)); + } + + private static <R extends ReferentialDto> void read(ReferentialSynchronizeDiffsEngine engine, + ReferentialSynchronizeDiff synchronizeDiff, + Class<R> referentialName, + RootReferentialSynchroNode rootNode) { + + Optional<ImmutableSet<ReferentialSynchronizeDiffState>> optionalAddedReferentials = synchronizeDiff.getAddedReferentials(referentialName); + Optional<ImmutableSet<ReferentialSynchronizeDiffState>> optionalUpdatedReferentials = synchronizeDiff.getUpdatedReferentials(referentialName); + + boolean withAdd = optionalAddedReferentials.isPresent(); + boolean withUpdate = optionalUpdatedReferentials.isPresent(); + + TypeReferentialSynchroNode typeNode = rootNode.addTypeNode(referentialName); + + if (withAdd) { + + // des référentiels à supprimer + ImmutableSet<ReferentialSynchronizeDiffState> diffStates = optionalAddedReferentials.get(); + ReferentialReferenceSet<R> referenceSet = engine.getRightReferentialReferenceSet(referentialName, diffStates); + + for (ReferentialReference<R> referentialReference : referenceSet.getReferences()) { + + ReferenceReferentialSynchroNode node = typeNode.addDeleteNode(referentialReference); + + } + } + if (withUpdate) { + + // des mises à jour ç annuler + ImmutableSet<ReferentialSynchronizeDiffState> diffStates = optionalUpdatedReferentials.get(); + ReferentialReferenceSet<R> referenceSet = engine.getRightReferentialReferenceSet(referentialName, diffStates); + + for (ReferentialReference<R> referentialReference : referenceSet.getReferences()) { + + ReferenceReferentialSynchroNode node = typeNode.addRevertNode(referentialReference); + + } + + } + + + } + + private static <R extends ReferentialDto> void write(ReferentialSynchronizeDiffsEngine engine, + ReferentialSynchronizeDiff synchronizeDiff, + Class<R> referentialName, + RootReferentialSynchroNode rootNode) { + + Optional<ImmutableSet<ReferentialSynchronizeDiffState>> optionalAddedReferentials = synchronizeDiff.getAddedReferentials(referentialName); + Optional<ImmutableSet<ReferentialSynchronizeDiffState>> optionalUpdatedReferentials = synchronizeDiff.getUpdatedReferentials(referentialName); + + boolean withAdd = optionalAddedReferentials.isPresent(); + boolean withUpdate = optionalUpdatedReferentials.isPresent(); + + TypeReferentialSynchroNode typeNode = rootNode.addTypeNode(referentialName); + + if (withAdd) { + + // des référentiels à ajouter + ImmutableSet<ReferentialSynchronizeDiffState> diffStates = optionalAddedReferentials.get(); + ReferentialReferenceSet<R> referenceSet = engine.getRightReferentialReferenceSet(referentialName, diffStates); + + for (ReferentialReference<R> referentialReference : referenceSet.getReferences()) { + + ReferenceReferentialSynchroNode node = typeNode.addAddNode(referentialReference); + + } + } + if (withUpdate) { + + // des mises à jour + ImmutableSet<ReferentialSynchronizeDiffState> diffStates = optionalUpdatedReferentials.get(); + ReferentialReferenceSet<R> referenceSet = engine.getRightReferentialReferenceSet(referentialName, diffStates); + + for (ReferentialReference<R> referentialReference : referenceSet.getReferences()) { + + ReferenceReferentialSynchroNode node = typeNode.addUpdateNode(referentialReference); + + } + + } + } + + + private static <R extends ReferentialDto> void buildFromLeftToRight(ReferentialSynchronizeDiffsEngine engine, + Class<R> referentialName, + ReferentialSynchronizeDiffs synchronizeDiffs, + RootReferentialSynchroNode leftRootNode, + RootReferentialSynchroNode rightRootNode) { + + boolean inLeft = synchronizeDiffs.isLeftReferentialUsed(referentialName); + boolean inRight = synchronizeDiffs.isRightReferentialUsed(referentialName); + + if (inLeft) { + + read(engine, synchronizeDiffs.getLeftDiff(), referentialName, leftRootNode); + + } + + if (inRight) { + + write(engine, synchronizeDiffs.getRightDiff(), referentialName, rightRootNode); + + } + } + + private static void buildFromRightToLeft(ReferentialSynchronizeDiffsEngine engine, + Class<? extends ReferentialDto> referentialName, + ReferentialSynchronizeDiffs synchronizeDiffs, + RootReferentialSynchroNode leftRootNode, + RootReferentialSynchroNode rightRootNode) { + + boolean inLeft = synchronizeDiffs.isLeftReferentialUsed(referentialName); + boolean inRight = synchronizeDiffs.isRightReferentialUsed(referentialName); + + if (inLeft) { + + write(engine, synchronizeDiffs.getLeftDiff(), referentialName, leftRootNode); + + } + if (inRight) { + + read(engine, synchronizeDiffs.getRightDiff(), referentialName, rightRootNode); + + } + } + + private static void buildFromBoth(ReferentialSynchronizeDiffsEngine engine, + Class<? extends ReferentialDto> referentialName, + ReferentialSynchronizeDiffs synchronizeDiffs, + RootReferentialSynchroNode leftRootNode, + RootReferentialSynchroNode rightRootNode) { + + boolean inLeft = synchronizeDiffs.isLeftReferentialUsed(referentialName); + boolean inRight = synchronizeDiffs.isRightReferentialUsed(referentialName); + + if (inLeft) { + + write(engine, synchronizeDiffs.getLeftDiff(), referentialName, leftRootNode); + read(engine, synchronizeDiffs.getLeftDiff(), referentialName, leftRootNode); + + } + if (inRight) { + + read(engine, synchronizeDiffs.getRightDiff(), referentialName, rightRootNode); + write(engine, synchronizeDiffs.getRightDiff(), referentialName, rightRootNode); + + } + } + + public ReferentialSynchronizeTreeModel(ReferentialSynchroNodeSupport root) { + this.treeModel = new DefaultTreeModel(root); + this.treeSelectionModel = new DefaultTreeSelectionModel(); + setSelectionMode(DISCONTIGUOUS_TREE_SELECTION); + } + + @Override + public ReferentialSynchroNodeSupport getRoot() { + return (ReferentialSynchroNodeSupport) treeModel.getRoot(); + } + + @Override + public Object getChild(Object parent, int index) { + return treeModel.getChild(parent, index); + } + + @Override + public int getChildCount(Object parent) { + return treeModel.getChildCount(parent); + } + + @Override + public boolean isLeaf(Object node) { + return treeModel.isLeaf(node); + } + + @Override + public void valueForPathChanged(TreePath path, Object newValue) { + treeModel.valueForPathChanged(path, newValue); + } + + @Override + public int getIndexOfChild(Object parent, Object child) { + return treeModel.getIndexOfChild(parent, child); + } + + @Override + public void addTreeModelListener(TreeModelListener l) { + treeModel.addTreeModelListener(l); + } + + @Override + public void removeTreeModelListener(TreeModelListener l) { + treeModel.removeTreeModelListener(l); + } + + @Override + public void setSelectionMode(int mode) { + treeSelectionModel.setSelectionMode(mode); + } + + @Override + public int getSelectionMode() { + return treeSelectionModel.getSelectionMode(); + } + + @Override + public void setSelectionPath(TreePath path) { + treeSelectionModel.setSelectionPath(path); + } + + @Override + public void setSelectionPaths(TreePath[] paths) { + treeSelectionModel.setSelectionPaths(paths); + } + + @Override + public void addSelectionPath(TreePath path) { + treeSelectionModel.addSelectionPath(path); + } + + @Override + public void addSelectionPaths(TreePath[] paths) { + treeSelectionModel.addSelectionPaths(paths); + } + + @Override + public void removeSelectionPath(TreePath path) { + treeSelectionModel.removeSelectionPath(path); + } + + @Override + public void removeSelectionPaths(TreePath[] paths) { + treeSelectionModel.removeSelectionPaths(paths); + } + + @Override + public TreePath getSelectionPath() { + return treeSelectionModel.getSelectionPath(); + } + + @Override + public TreePath[] getSelectionPaths() { + return treeSelectionModel.getSelectionPaths(); + } + + @Override + public int getSelectionCount() { + return treeSelectionModel.getSelectionCount(); + } + + @Override + public boolean isPathSelected(TreePath path) { + return treeSelectionModel.isPathSelected(path); + } + + @Override + public boolean isSelectionEmpty() { + return treeSelectionModel.isSelectionEmpty(); + } + + @Override + public void clearSelection() { + treeSelectionModel.clearSelection(); + } + + @Override + public void setRowMapper(RowMapper newMapper) { + treeSelectionModel.setRowMapper(newMapper); + } + + @Override + public RowMapper getRowMapper() { + return treeSelectionModel.getRowMapper(); + } + + @Override + public int[] getSelectionRows() { + return treeSelectionModel.getSelectionRows(); + } + + @Override + public int getMinSelectionRow() { + return treeSelectionModel.getMinSelectionRow(); + } + + @Override + public int getMaxSelectionRow() { + return treeSelectionModel.getMaxSelectionRow(); + } + + @Override + public boolean isRowSelected(int row) { + return treeSelectionModel.isRowSelected(row); + } + + @Override + public void resetRowSelection() { + treeSelectionModel.resetRowSelection(); + } + + @Override + public int getLeadSelectionRow() { + return treeSelectionModel.getLeadSelectionRow(); + } + + @Override + public TreePath getLeadSelectionPath() { + return treeSelectionModel.getLeadSelectionPath(); + } + + @Override + public void addPropertyChangeListener(PropertyChangeListener listener) { + treeSelectionModel.addPropertyChangeListener(listener); + } + + @Override + public void removePropertyChangeListener(PropertyChangeListener listener) { + treeSelectionModel.removePropertyChangeListener(listener); + } + + @Override + public void addTreeSelectionListener(TreeSelectionListener x) { + treeSelectionModel.addTreeSelectionListener(x); + } + + @Override + public void removeTreeSelectionListener(TreeSelectionListener x) { + treeSelectionModel.removeTreeSelectionListener(x); + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNode.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNode.java new file mode 100644 index 0000000..46b6114 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNode.java @@ -0,0 +1,91 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferenceReferentialSynchroNode extends ReferentialSynchroNodeSupport { + + private static final long serialVersionUID = 1L; + + private final ReferenceReferentialSynchroNodeType type; + + public ReferenceReferentialSynchroNode(boolean left, ReferenceReferentialSynchroNodeType type, ReferentialReference<? extends ReferentialDto> referentialReference) { + super(left, ReferentialSynchroNodeType.REFERENCE, referentialReference); + this.type = type; + } + + public ReferenceReferentialSynchroNodeType getType() { + return type; + } + + @Override + public ReferentialReference getUserObject() { + return (ReferentialReference) super.getUserObject(); + } + + @Override + public boolean canRevertToLeft() { + return isLeft() && type.canRevert(); + } + + @Override + public boolean canRevertToRight() { + return isRight() && type.canRevert(); + } + + @Override + public boolean canAddToLeft() { + return isLeft() && type.canAdd(); + } + + @Override + public boolean canAddToRight() { + return isRight() && type.canAdd(); + } + + @Override + public boolean canUpdateToLeft() { + return isLeft() && type.canUpdate(); + } + + @Override + public boolean canUpdateToRight() { + return isRight() && type.canUpdate(); + } + + @Override + public boolean canDeleteFromLeft() { + return isLeft() && type.canDelete(); + } + + @Override + public boolean canDeleteFromRight() { + return isRight() && type.canDelete(); + } + + @Override + public boolean canDesactivateFromLeft() { + return isLeft() && type.canDesactivate(); + } + + @Override + public boolean canDesactivateFromRight() { + return isRight() && type.canDesactivate(); + } + + @Override + public boolean canDesactivateFromLeftWithReplace() { + return isLeft() && type.canDesactivateWithReplace(); + } + + @Override + public boolean canDesactivateFromRightWithReplace() { + return isRight() && type.canDesactivateWithReplace(); + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNodeType.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNodeType.java new file mode 100644 index 0000000..0605f0f --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNodeType.java @@ -0,0 +1,70 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; + +import fr.ird.observe.ui.UIHelper; + +import javax.swing.Icon; + +/** + * Created on 10/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public enum ReferenceReferentialSynchroNodeType { + + ADD(true, false, false, false, false, false, "synchroAdd"), + UPDATE(false, true, false, false, false, false, "synchroUpdate"), + REVERT(false, false, true, false, false, false, "synchroRevert"), + DELETE(false, false, false, true, true, true, "synchroDelete"); + + private final boolean canAdd; + private final boolean canUpdate; + private final boolean canRevert; + private final boolean canDelete; + private final boolean canDesactivate; + private final boolean canDesactivateWithReplace; + private final transient Icon icon; + + ReferenceReferentialSynchroNodeType(boolean canAdd, + boolean canUpdate, + boolean canRevert, + boolean canDelete, + boolean canDesactivate, + boolean canDesactivateWithReplace, + String actionIconName) { + this.canAdd = canAdd; + this.canUpdate = canUpdate; + this.canRevert = canRevert; + this.canDelete = canDelete; + this.canDesactivate = canDesactivate; + this.canDesactivateWithReplace = canDesactivateWithReplace; + this.icon = UIHelper.createActionIcon(actionIconName); + } + + public boolean canAdd() { + return canAdd; + } + + public boolean canUpdate() { + return canUpdate; + } + + public boolean canRevert() { + return canRevert; + } + + public boolean canDelete() { + return canDelete; + } + + public boolean canDesactivate() { + return canDesactivate; + } + + public boolean canDesactivateWithReplace() { + return canDesactivateWithReplace; + } + + public Icon icon() { + return icon; + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferentialSynchroNodeSupport.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferentialSynchroNodeSupport.java new file mode 100644 index 0000000..635643f --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferentialSynchroNodeSupport.java @@ -0,0 +1,53 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; + +import javax.swing.tree.DefaultMutableTreeNode; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public abstract class ReferentialSynchroNodeSupport extends DefaultMutableTreeNode { + + private static final long serialVersionUID = 1L; + + protected ReferentialSynchroNodeSupport(boolean left, ReferentialSynchroNodeType nodeType, Object userObject) { + this.left = left; + this.nodeType = nodeType; + setUserObject(userObject); + } + + private final boolean left; + private final ReferentialSynchroNodeType nodeType; + + public boolean isLeft() { + return left; + } + + public boolean isRight() { + return !left; + } + + public ReferentialSynchroNodeType getNodeType() { + return nodeType; + } + + public abstract boolean canAddToLeft(); + public abstract boolean canAddToRight(); + + public abstract boolean canUpdateToLeft(); + public abstract boolean canUpdateToRight(); + + public abstract boolean canRevertToLeft(); + public abstract boolean canRevertToRight(); + + public abstract boolean canDeleteFromLeft(); + public abstract boolean canDeleteFromRight(); + + public abstract boolean canDesactivateFromLeft(); + public abstract boolean canDesactivateFromRight(); + + public abstract boolean canDesactivateFromLeftWithReplace(); + public abstract boolean canDesactivateFromRightWithReplace(); + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferentialSynchroNodeType.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferentialSynchroNodeType.java new file mode 100644 index 0000000..29be162 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferentialSynchroNodeType.java @@ -0,0 +1,13 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; + +/** + * Created on 10/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public enum ReferentialSynchroNodeType { + ROOT, + TYPE, + REFERENCE +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/RootReferentialSynchroNode.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/RootReferentialSynchroNode.java new file mode 100644 index 0000000..05a0f05 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/RootReferentialSynchroNode.java @@ -0,0 +1,82 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; + +import fr.ird.observe.services.dto.referential.ReferentialDto; + +/** + * Created on 10/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class RootReferentialSynchroNode extends ReferentialSynchroNodeSupport { + private static final long serialVersionUID = 1L; + + public RootReferentialSynchroNode(boolean left) { + super(left, ReferentialSynchroNodeType.ROOT, null); + } + + @Override + public boolean canRevertToLeft() { + return false; + } + + @Override + public boolean canRevertToRight() { + return false; + } + + @Override + public boolean canAddToLeft() { + return false; + } + + @Override + public boolean canAddToRight() { + return false; + } + + @Override + public boolean canUpdateToLeft() { + return false; + } + + @Override + public boolean canUpdateToRight() { + return false; + } + + @Override + public boolean canDeleteFromLeft() { + return false; + } + + @Override + public boolean canDeleteFromRight() { + return false; + } + + @Override + public boolean canDesactivateFromLeft() { + return false; + } + + @Override + public boolean canDesactivateFromRight() { + return false; + } + + @Override + public boolean canDesactivateFromLeftWithReplace() { + return false; + } + + @Override + public boolean canDesactivateFromRightWithReplace() { + return false; + } + + public <R extends ReferentialDto> TypeReferentialSynchroNode addTypeNode(Class<R> referentialName) { + TypeReferentialSynchroNode node = new TypeReferentialSynchroNode(isLeft(), referentialName); + add(node); + return node; + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/TypeReferentialSynchroNode.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/TypeReferentialSynchroNode.java new file mode 100644 index 0000000..ebe382d --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/TypeReferentialSynchroNode.java @@ -0,0 +1,107 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class TypeReferentialSynchroNode extends ReferentialSynchroNodeSupport { + + private static final long serialVersionUID = 1L; + + public TypeReferentialSynchroNode(boolean left, Class<? extends ReferentialDto> type) { + super(left, ReferentialSynchroNodeType.TYPE, type); + } + + @Override + public Class<? extends ReferentialDto> getUserObject() { + return (Class) super.getUserObject(); + } + + @Override + public boolean canRevertToLeft() { + return false; + } + + @Override + public boolean canRevertToRight() { + return false; + } + + @Override + public boolean canAddToLeft() { + return false; + } + + @Override + public boolean canAddToRight() { + return false; + } + + @Override + public boolean canUpdateToLeft() { + return false; + } + + @Override + public boolean canUpdateToRight() { + return false; + } + + @Override + public boolean canDeleteFromLeft() { + return false; + } + + @Override + public boolean canDeleteFromRight() { + return false; + } + + @Override + public boolean canDesactivateFromLeft() { + return false; + } + + @Override + public boolean canDesactivateFromRight() { + return false; + } + + @Override + public boolean canDesactivateFromLeftWithReplace() { + return false; + } + + @Override + public boolean canDesactivateFromRightWithReplace() { + return false; + } + + public <R extends ReferentialDto> ReferenceReferentialSynchroNode addDeleteNode(ReferentialReference<R> referentialReference) { + ReferenceReferentialSynchroNode node = new ReferenceReferentialSynchroNode(isLeft(), ReferenceReferentialSynchroNodeType.DELETE, referentialReference); + add(node); + return node; + } + + public <R extends ReferentialDto> ReferenceReferentialSynchroNode addAddNode(ReferentialReference<R> referentialReference) { + ReferenceReferentialSynchroNode node = new ReferenceReferentialSynchroNode(isLeft(), ReferenceReferentialSynchroNodeType.ADD, referentialReference); + add(node); + return node; + } + + public <R extends ReferentialDto> ReferenceReferentialSynchroNode addUpdateNode(ReferentialReference<R> referentialReference) { + ReferenceReferentialSynchroNode node = new ReferenceReferentialSynchroNode(isLeft(), ReferenceReferentialSynchroNodeType.UPDATE, referentialReference); + add(node); + return node; + } + + public <R extends ReferentialDto> ReferenceReferentialSynchroNode addRevertNode(ReferentialReference<R> referentialReference) { + ReferenceReferentialSynchroNode node = new ReferenceReferentialSynchroNode(isLeft(), ReferenceReferentialSynchroNodeType.REVERT, referentialReference); + add(node); + return node; + } +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/datasynchro/DataSynchronizeServiceController.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/data/DataSynchronizeServiceController.java similarity index 78% rename from observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/datasynchro/DataSynchronizeServiceController.java rename to observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/data/DataSynchronizeServiceController.java index a17ba82..82ea702 100644 --- a/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/datasynchro/DataSynchronizeServiceController.java +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/data/DataSynchronizeServiceController.java @@ -1,8 +1,8 @@ -package fr.ird.observe.application.web.controller.v1.actions.datasynchro; +package fr.ird.observe.application.web.controller.v1.actions.synchro.data; import fr.ird.observe.application.web.controller.v1.ObserveAuthenticatedServiceControllerSupport; -import fr.ird.observe.services.service.actions.datasynchro.DataSynchronizeRequest; -import fr.ird.observe.services.service.actions.datasynchro.DataSynchronizeService; +import fr.ird.observe.services.service.actions.synchro.data.DataSynchronizeRequest; +import fr.ird.observe.services.service.actions.synchro.data.DataSynchronizeService; /** * Created on 09/08/16. diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/referential/diff/ReferentialSynchronizeDiffServiceController.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/referential/diff/ReferentialSynchronizeDiffServiceController.java new file mode 100644 index 0000000..97041b6 --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/referential/diff/ReferentialSynchronizeDiffServiceController.java @@ -0,0 +1,34 @@ +package fr.ird.observe.application.web.controller.v1.actions.synchro.referential.diff; + +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.application.web.controller.v1.ObserveAuthenticatedServiceControllerSupport; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReferenceSet; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialDataSourceStates; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffService; + +/** + * Created on 10/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferentialSynchronizeDiffServiceController extends ObserveAuthenticatedServiceControllerSupport<ReferentialSynchronizeDiffService> implements ReferentialSynchronizeDiffService { + protected ReferentialSynchronizeDiffServiceController() { + super(ReferentialSynchronizeDiffService.class); + } + + @Override + public <R extends ReferentialDto> ReferentialReferenceSet<R> getEnabledReferentialReferenceSet(Class<R> referentialName) { + return service.getEnabledReferentialReferenceSet(referentialName); + } + + @Override + public <R extends ReferentialDto> ReferentialReferenceSet<R> getReferentialReferenceSet(Class<R> referentialName, ImmutableSet<String> ids) { + return service.getReferentialReferenceSet(referentialName, ids); + } + + @Override + public ReferentialDataSourceStates getSourceReferentialStates() { + return service.getSourceReferentialStates(); + } +} diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/UnidirectionalReferentialSynchronizeLocalServiceController.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeLocalServiceController.java similarity index 87% rename from observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/UnidirectionalReferentialSynchronizeLocalServiceController.java rename to observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeLocalServiceController.java index a7ce16d..dc0107b 100644 --- a/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/UnidirectionalReferentialSynchronizeLocalServiceController.java +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeLocalServiceController.java @@ -1,4 +1,4 @@ -package fr.ird.observe.application.web.controller.v1.actions.synchro; +package fr.ird.observe.application.web.controller.v1.actions.synchro.referential.legacy; /*- * #%L @@ -25,9 +25,9 @@ package fr.ird.observe.application.web.controller.v1.actions.synchro; import fr.ird.observe.application.web.controller.v1.ObserveAuthenticatedServiceControllerSupport; import fr.ird.observe.services.dto.referential.ReferentialDto; import fr.ird.observe.services.dto.referential.ReferentialReference; -import fr.ird.observe.services.service.actions.synchro.LocalReferentialStates; -import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeLocalService; -import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeRequest; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.LocalReferentialStates; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeLocalService; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeRequest; import java.util.Set; diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/UnidirectionalReferentialSynchronizeRemoteServiceController.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeRemoteServiceController.java similarity index 85% rename from observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/UnidirectionalReferentialSynchronizeRemoteServiceController.java rename to observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeRemoteServiceController.java index b23d967..0d451fd 100644 --- a/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/UnidirectionalReferentialSynchronizeRemoteServiceController.java +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeRemoteServiceController.java @@ -1,4 +1,4 @@ -package fr.ird.observe.application.web.controller.v1.actions.synchro; +package fr.ird.observe.application.web.controller.v1.actions.synchro.referential.legacy; /*- * #%L @@ -25,9 +25,9 @@ package fr.ird.observe.application.web.controller.v1.actions.synchro; import fr.ird.observe.application.web.controller.v1.ObserveAuthenticatedServiceControllerSupport; import fr.ird.observe.services.dto.referential.ReferentialDto; import fr.ird.observe.services.dto.referential.ReferentialReferenceSet; -import fr.ird.observe.services.service.actions.synchro.LocalReferentialStates; -import fr.ird.observe.services.service.actions.synchro.RemoteReferentialDiff; -import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeRemoteService; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.LocalReferentialStates; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.RemoteReferentialDiff; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeRemoteService; /** * Created on 20/07/16. diff --git a/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/referential/ng/ReferentialSynchronizeServiceController.java b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/referential/ng/ReferentialSynchronizeServiceController.java new file mode 100644 index 0000000..b523601 --- /dev/null +++ b/observe-application-web/src/main/java/fr/ird/observe/application/web/controller/v1/actions/synchro/referential/ng/ReferentialSynchronizeServiceController.java @@ -0,0 +1,32 @@ +package fr.ird.observe.application.web.controller.v1.actions.synchro.referential.ng; + +import fr.ird.observe.application.web.controller.v1.ObserveAuthenticatedServiceControllerSupport; +import fr.ird.observe.services.service.actions.synchro.referential.ng.ReferentialSynchronizeRequest; +import fr.ird.observe.services.service.actions.synchro.referential.ng.ReferentialSynchronizeService; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferentialSynchronizeServiceController extends ObserveAuthenticatedServiceControllerSupport<ReferentialSynchronizeService> implements ReferentialSynchronizeService { + + public ReferentialSynchronizeServiceController() { + super(ReferentialSynchronizeService.class); + } + + @Override + public void prepareRequestOnOppositeDataSource(ReferentialSynchronizeRequest request) { + service.prepareRequestOnOppositeDataSource(request); + } + + @Override + public void prepareRequestOnDataSource(ReferentialSynchronizeRequest request) { + service.prepareRequestOnDataSource(request); + } + + @Override + public void executeRequest(ReferentialSynchronizeRequest request) { + service.executeRequest(request); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/ObserveServicesProvider.java b/observe-services-api/src/main/java/fr/ird/observe/services/ObserveServicesProvider.java index 0a5e627..f349807 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/ObserveServicesProvider.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/ObserveServicesProvider.java @@ -5,11 +5,13 @@ import fr.ird.observe.services.service.PingService; import fr.ird.observe.services.service.ReferentialService; import fr.ird.observe.services.service.SqlScriptProducerService; import fr.ird.observe.services.service.actions.consolidate.ConsolidateDataService; -import fr.ird.observe.services.service.actions.datasynchro.DataSynchronizeService; import fr.ird.observe.services.service.actions.export.ReplicateTripService; import fr.ird.observe.services.service.actions.report.ReportService; -import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeLocalService; -import fr.ird.observe.services.service.actions.synchro.UnidirectionalReferentialSynchronizeRemoteService; +import fr.ird.observe.services.service.actions.synchro.data.DataSynchronizeService; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffService; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeLocalService; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeRemoteService; +import fr.ird.observe.services.service.actions.synchro.referential.ng.ReferentialSynchronizeService; import fr.ird.observe.services.service.actions.validate.ValidateService; import fr.ird.observe.services.service.longline.ActivityLongLineEncounterService; import fr.ird.observe.services.service.longline.ActivityLongLineSensorUsedService; @@ -66,6 +68,10 @@ public interface ObserveServicesProvider { DataSynchronizeService newDataSynchronizeService(); + ReferentialSynchronizeService newReferentialSynchronizeService(); + + ReferentialSynchronizeDiffService newReferentialSynchronizeDiffService(); + DataSourceService newDataSourceService(); ReferentialService newReferentialService(); diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeCopyTask.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeCopyTask.java deleted file mode 100644 index 2217414..0000000 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeCopyTask.java +++ /dev/null @@ -1,27 +0,0 @@ -package fr.ird.observe.services.service.actions.datasynchro; - -/** - * Created on 08/08/16. - * - * @author Tony Chemit - chemit@codelutin.com - * @since 5.0 - */ -public class DataSynchronizeCopyTask extends DataSyncrhonizeTaskSupport { - - /** - * Contient le code sql de la copie de la marée. - */ - private byte[] dataContent; - - public DataSynchronizeCopyTask(String programId, String tripId) { - super(programId, tripId); - } - - public byte[] getDataContent() { - return dataContent; - } - - public void setDataContent(byte[] dataContent) { - this.dataContent = dataContent; - } -} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeDeleteTask.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeDeleteTask.java deleted file mode 100644 index 4b457ef..0000000 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeDeleteTask.java +++ /dev/null @@ -1,27 +0,0 @@ -package fr.ird.observe.services.service.actions.datasynchro; - -/** - * Created on 08/08/16. - * - * @author Tony Chemit - chemit@codelutin.com - * @since 5.0 - */ -public class DataSynchronizeDeleteTask extends DataSyncrhonizeTaskSupport { - - /** - * Contient le code sql de la copie de la marée. - */ - private byte[] dataContent; - - public DataSynchronizeDeleteTask(String programId, String tripId) { - super(programId, tripId); - } - - public byte[] getDataContent() { - return dataContent; - } - - public void setDataContent(byte[] dataContent) { - this.dataContent = dataContent; - } -} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSyncrhonizeTaskSupport.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSyncrhonizeTaskSupport.java deleted file mode 100644 index c90b217..0000000 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSyncrhonizeTaskSupport.java +++ /dev/null @@ -1,26 +0,0 @@ -package fr.ird.observe.services.service.actions.datasynchro; - -/** - * Created on 08/08/16. - * - * @author Tony Chemit - chemit@codelutin.com - * @since 5.0 - */ -public abstract class DataSyncrhonizeTaskSupport { - - private final String programId; - private final String tripId; - - protected DataSyncrhonizeTaskSupport(String programId, String tripId) { - this.programId = programId; - this.tripId = tripId; - } - - public String getProgramId() { - return programId; - } - - public String getTripId() { - return tripId; - } -} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeRequest.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/DataSynchronizeRequest.java similarity index 92% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeRequest.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/DataSynchronizeRequest.java index d5fd59d..6218431 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeRequest.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/DataSynchronizeRequest.java @@ -1,6 +1,8 @@ -package fr.ird.observe.services.service.actions.datasynchro; +package fr.ird.observe.services.service.actions.synchro.data; import com.google.common.collect.ImmutableSet; +import fr.ird.observe.services.service.actions.synchro.data.task.DataSynchronizeCopyTask; +import fr.ird.observe.services.service.actions.synchro.data.task.DataSynchronizeDeleteTask; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeService.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/DataSynchronizeService.java similarity index 96% copy from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeService.java copy to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/DataSynchronizeService.java index 34882b2..ba500a3 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeService.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/DataSynchronizeService.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.datasynchro; +package fr.ird.observe.services.service.actions.synchro.data; import fr.ird.observe.services.ObserveService; import fr.ird.observe.services.spi.PostRequest; diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/task/DataSynchronizeCopyTask.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/task/DataSynchronizeCopyTask.java new file mode 100644 index 0000000..3f18f6d --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/task/DataSynchronizeCopyTask.java @@ -0,0 +1,14 @@ +package fr.ird.observe.services.service.actions.synchro.data.task; + +/** + * Created on 08/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class DataSynchronizeCopyTask extends DataSynchronizeTaskSupport { + + public DataSynchronizeCopyTask(String programId, String tripId) { + super(programId, tripId); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/task/DataSynchronizeDeleteTask.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/task/DataSynchronizeDeleteTask.java new file mode 100644 index 0000000..8701d52 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/task/DataSynchronizeDeleteTask.java @@ -0,0 +1,14 @@ +package fr.ird.observe.services.service.actions.synchro.data.task; + +/** + * Created on 08/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class DataSynchronizeDeleteTask extends DataSynchronizeTaskSupport { + + public DataSynchronizeDeleteTask(String programId, String tripId) { + super(programId, tripId); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/task/DataSynchronizeTaskSupport.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/task/DataSynchronizeTaskSupport.java new file mode 100644 index 0000000..018147e --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/data/task/DataSynchronizeTaskSupport.java @@ -0,0 +1,44 @@ +package fr.ird.observe.services.service.actions.synchro.data.task; + +/** + * Created on 08/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public abstract class DataSynchronizeTaskSupport { + + /** + * Identifiant du programme de la marée. + */ + private final String programId; + /** + * Identifiant de la marée. + */ + private final String tripId; + /** + * Contient le code sql de la tâche. + */ + private byte[] dataContent; + + protected DataSynchronizeTaskSupport(String programId, String tripId) { + this.programId = programId; + this.tripId = tripId; + } + + public String getProgramId() { + return programId; + } + + public String getTripId() { + return tripId; + } + + public byte[] getDataContent() { + return dataContent; + } + + public void setDataContent(byte[] dataContent) { + this.dataContent = dataContent; + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ReferentialSynchronizeMode.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ReferentialSynchronizeMode.java new file mode 100644 index 0000000..3af0bab --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ReferentialSynchronizeMode.java @@ -0,0 +1,69 @@ +package fr.ird.observe.services.service.actions.synchro.referential; + +import static org.nuiton.i18n.I18n.n; +import static org.nuiton.i18n.I18n.t; + +/** + * Type de synchronisation de référentiel. Définit quelles bases sont en écriture. + * + * Created on 10/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public enum ReferentialSynchronizeMode { + + /** + * La base de gauche est en lecture, la base de droite est en écriture. + */ + FROM_LEFT_TO_RIGHT(false, true, + n("observe.synchro.referential.mode.fromLeftToRight"), + n("observe.synchro.referential.mode.fromLeftToRight.description")), + /** + * La base de gauche est en écriture, la base de droite est en lecture. + */ + FROM_RIGHT_TO_LEFT(true, false,n("observe.synchro.referential.mode.fromRightToLeft"), + n("observe.synchro.referential.mode.fromRightToLeft.description")), + /** + * La base de gauche est en écriture, la base de droite est en écriture. + */ + BOTH(true, true, + n("observe.synchro.referential.mode.both"), + n("observe.synchro.referential.mode.both.description")),; + + /** + * Est ce que la source de gauche est en écriture ? + */ + private final boolean leftWrite; + /** + * Est ce que la source de droite est en écriture ? + */ + private final boolean rightWrite; + + private final String label; + + private final String description; + + ReferentialSynchronizeMode(boolean leftWrite, boolean rightWrite, String label, String description) { + this.leftWrite = leftWrite; + this.rightWrite = rightWrite; + this.label = label; + this.description = description; + } + + public boolean isLeftWrite() { + return leftWrite; + } + + public boolean isRightWrite() { + return rightWrite; + } + + public String getLabel() { + return t(label); + } + + public String getDescription() { + return t(description); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialDataSourceState.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialDataSourceState.java new file mode 100644 index 0000000..1cdedb3 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialDataSourceState.java @@ -0,0 +1,65 @@ +package fr.ird.observe.services.service.actions.synchro.referential.diff; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Maps; +import fr.ird.observe.services.dto.referential.ReferentialDto; + +import java.util.Date; +import java.util.LinkedHashSet; +import java.util.Set; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferentialDataSourceState<R extends ReferentialDto> { + + private final Class<R> type; + + private final Set<ReferentialSynchronizeDiffState> diffStates; + + public ReferentialDataSourceState(Class<R> type) { + this.type = type; + this.diffStates = new LinkedHashSet<>(); + } + + public Class<R> getType() { + return type; + } + + public Set<ReferentialSynchronizeDiffState> getDiffStates() { + return diffStates; + } + + public ImmutableMap<String, ReferentialSynchronizeDiffState> getReferentialStatesById() { + return Maps.uniqueIndex(diffStates, ReferentialSynchronizeDiffState::getId); + } + + public ReferentialSynchronizeDiffState getLatestReferentialDiffState() { + ReferentialSynchronizeDiffState result = null; + for (ReferentialSynchronizeDiffState diffState : diffStates) { + if (result == null) { + result = diffState; + continue; + } + if (result.getLastUpdateDate().before(diffState.getLastUpdateDate()) || result.getVersion() < diffState.getVersion()) { + result = diffState; + } + } + return result; + } + + /** + * Pour ajouter un référentiel. + * + * @param id l'identifiant du référentiel à ajouter + * @param lastUpdateDate la date de dernière mise à jour du référentiel à ajouter + * @param version la version du référentiel à ajouter + * @param disabled {@code true} si le référentiel est désactivé + */ + void addReferentialVersion(String id, Date lastUpdateDate, long version, boolean disabled) { + diffStates.add(new ReferentialSynchronizeDiffState(id, lastUpdateDate, version, disabled)); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialDataSourceStates.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialDataSourceStates.java new file mode 100644 index 0000000..b3efb4a --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialDataSourceStates.java @@ -0,0 +1,47 @@ +package fr.ird.observe.services.service.actions.synchro.referential.diff; + +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.services.dto.referential.ReferentialDto; + +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferentialDataSourceStates { + + /** + * Contient pour chaque type de référentiel la version de chaque référentiel indexé par son nom. + */ + private final Map<Class<? extends ReferentialDto>, ReferentialDataSourceState> diffStatesByType; + + public ReferentialDataSourceStates() { + this.diffStatesByType = new LinkedHashMap<>(); + } + + /** + * @param referentialName le nom de référentiel + * @return la collection des versions de référentiel du nom demandé. + */ + public <R extends ReferentialDto> ReferentialDataSourceState<R> getReferentialVersions(Class<R> referentialName) { + return diffStatesByType.get(referentialName); + } + + public ImmutableSet<Class<? extends ReferentialDto>> getReferentialTypes() { + return ImmutableSet.copyOf(diffStatesByType.keySet()); + } + + /** + * Pour ajouter un référentiel. + * + * @param referentialName le nom du référentiel + * @param sourceState les états pour ce type de référentiel + */ + <R extends ReferentialDto> void addReferentialVersion(Class<R> referentialName, ReferentialDataSourceState<R> sourceState) { + diffStatesByType.put(referentialName, sourceState); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiff.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiff.java new file mode 100644 index 0000000..6faf9f0 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiff.java @@ -0,0 +1,97 @@ +package fr.ird.observe.services.service.actions.synchro.referential.diff; + +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.ImmutableSetMultimap; +import fr.ird.observe.services.dto.referential.ReferentialDto; + +import java.util.Optional; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferentialSynchronizeDiff { + + public static Builder builder() { + return new Builder(); + } + + public static class Builder { + + private final ImmutableSetMultimap.Builder<Class<? extends ReferentialDto>, ReferentialSynchronizeDiffState> addedReferentialsBuilder; + + private final ImmutableSetMultimap.Builder<Class<? extends ReferentialDto>, ReferentialSynchronizeDiffState> updatedReferentialsBuilder; + + public Builder() { + + addedReferentialsBuilder = ImmutableSetMultimap.builder(); + updatedReferentialsBuilder = ImmutableSetMultimap.builder(); + } + + <R extends ReferentialDto> Builder addAddedReferential(Class<R> referentialName, ReferentialSynchronizeDiffState referentialDto) { + addedReferentialsBuilder.put(referentialName, referentialDto); + return this; + } + + <R extends ReferentialDto> Builder addUpdatedReferential(Class<R> referentialName, ReferentialSynchronizeDiffState referentialDto) { + updatedReferentialsBuilder.put(referentialName, referentialDto); + return this; + } + + public ReferentialSynchronizeDiff build() { + return new ReferentialSynchronizeDiff(addedReferentialsBuilder.build(), updatedReferentialsBuilder.build()); + } + + } + + /** + * Tous les types de référentiels décrits pour cette source. + */ + private final ImmutableSet<Class<? extends ReferentialDto>> referentialNames; + + /** + * Les référentiels ajoutés dans cette source (indexé par type de référentiel). + */ + private final ImmutableSetMultimap<Class<? extends ReferentialDto>, ReferentialSynchronizeDiffState> addedReferentials; + /** + * Les référentiels mises à jour dans cette source (indexé par type de référentiel). + */ + private final ImmutableSetMultimap<Class<? extends ReferentialDto>, ReferentialSynchronizeDiffState> updatedReferentials; + + public boolean isEmpty() { + return referentialNames.isEmpty(); + } + + public boolean isNotEmpty() { + return !isEmpty(); + } + + public ImmutableSet<Class<? extends ReferentialDto>> getReferentialNames() { + return referentialNames; + } + + public <R extends ReferentialDto> boolean isReferentialUsed(Class<R> referentialName) { + return referentialNames.contains(referentialName); + } + + public <R extends ReferentialDto> Optional<ImmutableSet<ReferentialSynchronizeDiffState>> getAddedReferentials(Class<R> referentialName) { + return Optional.ofNullable(addedReferentials.get(referentialName)); + } + + public <R extends ReferentialDto> Optional<ImmutableSet<ReferentialSynchronizeDiffState>> getUpdatedReferentials(Class<R> referentialName) { + return Optional.ofNullable(updatedReferentials.get(referentialName)); + } + + private ReferentialSynchronizeDiff(ImmutableSetMultimap<Class<? extends ReferentialDto>, ReferentialSynchronizeDiffState> addedReferentials, + ImmutableSetMultimap<Class<? extends ReferentialDto>, ReferentialSynchronizeDiffState> updatedReferentials) { + this.addedReferentials = addedReferentials; + this.updatedReferentials = updatedReferentials; + this.referentialNames = ImmutableSet.<Class<? extends ReferentialDto>>builder() + .addAll(addedReferentials.keySet()) + .addAll(updatedReferentials.keySet()) + .build(); + + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffService.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffService.java new file mode 100644 index 0000000..381dd84 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffService.java @@ -0,0 +1,30 @@ +package fr.ird.observe.services.service.actions.synchro.referential.diff; + +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.services.ObserveService; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReferenceSet; +import fr.ird.observe.services.spi.ReadReferentialPermission; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public interface ReferentialSynchronizeDiffService extends ObserveService { + + @ReadReferentialPermission + <R extends ReferentialDto> ReferentialReferenceSet<R> getEnabledReferentialReferenceSet(Class<R> referentialName); + + @ReadReferentialPermission + <R extends ReferentialDto> ReferentialReferenceSet<R> getReferentialReferenceSet(Class<R> referentialName, ImmutableSet<String> ids); + + /** + * Récupération sur la source à synchroniser des versions de ses référentiels. + * + * @return les versions de tous les référentiels de la base à synchroniser. + */ + @ReadReferentialPermission + ReferentialDataSourceStates getSourceReferentialStates(); + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffState.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffState.java new file mode 100644 index 0000000..50bc0f3 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffState.java @@ -0,0 +1,67 @@ +package fr.ird.observe.services.service.actions.synchro.referential.diff; + +import com.google.common.base.MoreObjects; + +import java.util.Date; +import java.util.Objects; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferentialSynchronizeDiffState implements Comparable<ReferentialSynchronizeDiffState> { + + private final String id; + private final Date lastUpdateDate; + private final long version; + private final boolean disabled; + public static final int EQUALS = 0; + public static final int BEFORE = -1; + public static final int AFTER = 1; + + ReferentialSynchronizeDiffState(String id, Date lastUpdateDate, long version, boolean disabled) { + this.id = id; + this.lastUpdateDate = lastUpdateDate; + this.version = version; + this.disabled = disabled; + } + + public String getId() { + return id; + } + + public boolean isDisabled() { + return disabled; + } + + public boolean isEnabled() { + return !disabled; + } + + public Date getLastUpdateDate() { + return lastUpdateDate; + } + + public long getVersion() { + return version; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(this) + .add("id", id) + .add("lastUpdateDate", lastUpdateDate) + .add("version", version) + .add("disabled", disabled) + .toString(); + } + + @Override + public int compareTo(ReferentialSynchronizeDiffState o) { + if (Objects.equals(lastUpdateDate, o.lastUpdateDate) && Objects.equals(version, o.getVersion())) { + return EQUALS; + } + return lastUpdateDate.before(o.getLastUpdateDate()) || version < o.getVersion() ? BEFORE : AFTER; + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffStateType.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffStateType.java new file mode 100644 index 0000000..e2d5fec --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffStateType.java @@ -0,0 +1,15 @@ +package fr.ird.observe.services.service.actions.synchro.referential.diff; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public enum ReferentialSynchronizeDiffStateType { + + ADDED, + UPDATED, + REMOVED, + DISABLED + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffs.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffs.java new file mode 100644 index 0000000..52bd198 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffs.java @@ -0,0 +1,125 @@ +package fr.ird.observe.services.service.actions.synchro.referential.diff; + +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.service.actions.synchro.referential.ReferentialSynchronizeMode; + +import java.util.Objects; +import java.util.Optional; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferentialSynchronizeDiffs { + + public static Builder builder(ReferentialSynchronizeMode mode) { + return new Builder(mode); + } + + public static class Builder { + + private final ReferentialSynchronizeMode mode; + private final ReferentialSynchronizeDiff.Builder leftBuilder; + private final ReferentialSynchronizeDiff.Builder rightBuilder; + + private Builder(ReferentialSynchronizeMode mode) { + Objects.nonNull(mode); + this.mode = mode; + leftBuilder = ReferentialSynchronizeDiff.builder(); + rightBuilder = ReferentialSynchronizeDiff.builder(); + } + + <R extends ReferentialDto> Builder addLeftAddedReferential(Class<R> referentialName, ReferentialSynchronizeDiffState referentialDto) { + if (mode.isLeftWrite()) { + leftBuilder.addAddedReferential(referentialName, referentialDto); + } + return this; + } + + <R extends ReferentialDto> Builder addLeftUpdatedReferential(Class<R> referentialName, ReferentialSynchronizeDiffState referentialDto) { + if (mode.isLeftWrite()) { + leftBuilder.addUpdatedReferential(referentialName, referentialDto); + } + return this; + } + + <R extends ReferentialDto> Builder addRightAddedReferential(Class<R> referentialName, ReferentialSynchronizeDiffState referentialDto) { + if (mode.isRightWrite()) { + rightBuilder.addAddedReferential(referentialName, referentialDto); + } + return this; + } + + <R extends ReferentialDto> Builder addRightUpdatedReferential(Class<R> referentialName, ReferentialSynchronizeDiffState referentialDto) { + if (mode.isRightWrite()) { + rightBuilder.addUpdatedReferential(referentialName, referentialDto); + } + return this; + } + + public ReferentialSynchronizeDiffs build() { + ReferentialSynchronizeDiff leftDiff = leftBuilder.build(); + ReferentialSynchronizeDiff rightDiff = rightBuilder.build(); + return new ReferentialSynchronizeDiffs( + leftDiff, + rightDiff, + ImmutableSet.<Class<? extends ReferentialDto>>builder() + .addAll(leftDiff.getReferentialNames()) + .addAll(rightDiff.getReferentialNames()) + .build() + ); + } + } + + private final ReferentialSynchronizeDiff leftDiff; + private final ReferentialSynchronizeDiff rightDiff; + /** + * Tous les types de référentiels décrits pour cette source. + */ + private final ImmutableSet<Class<? extends ReferentialDto>> referentialNames; + + public ReferentialSynchronizeDiff getLeftDiff() { + return leftDiff; + } + + public ReferentialSynchronizeDiff getRightDiff() { + return rightDiff; + } + + public ImmutableSet<Class<? extends ReferentialDto>> getReferentialNames() { + return referentialNames; + } + + public <R extends ReferentialDto> boolean isLeftReferentialUsed(Class<R> referentialName) { + return leftDiff.isReferentialUsed(referentialName); + } + + public <R extends ReferentialDto> boolean isRightReferentialUsed(Class<R> referentialName) { + return rightDiff.isReferentialUsed(referentialName); + } + + public <R extends ReferentialDto> Optional<ImmutableSet<ReferentialSynchronizeDiffState>> getLeftAddedReferentials(Class<R> referentialName) { + return leftDiff.getAddedReferentials(referentialName); + } + + public <R extends ReferentialDto> Optional<ImmutableSet<ReferentialSynchronizeDiffState>> getLeftUpdatedReferentials(Class<R> referentialName) { + return leftDiff.getUpdatedReferentials(referentialName); + } + + public <R extends ReferentialDto> Optional<ImmutableSet<ReferentialSynchronizeDiffState>> getRightAddedReferentials(Class<R> referentialName) { + return rightDiff.getAddedReferentials(referentialName); + } + + public <R extends ReferentialDto> Optional<ImmutableSet<ReferentialSynchronizeDiffState>> getRightUpdatedReferentials(Class<R> referentialName) { + return rightDiff.getUpdatedReferentials(referentialName); + } + + private ReferentialSynchronizeDiffs(ReferentialSynchronizeDiff leftDiff, ReferentialSynchronizeDiff rightDiff, ImmutableSet<Class<? extends ReferentialDto>> referentialNames) { + this.leftDiff = leftDiff; + this.rightDiff = rightDiff; + this.referentialNames = referentialNames; + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffsEngine.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffsEngine.java new file mode 100644 index 0000000..f20ffc5 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffsEngine.java @@ -0,0 +1,111 @@ +package fr.ird.observe.services.service.actions.synchro.referential.diff; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReferenceSet; +import fr.ird.observe.services.service.actions.synchro.referential.ReferentialSynchronizeMode; + +import java.util.Set; +import java.util.stream.Collectors; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferentialSynchronizeDiffsEngine { + + private final ReferentialSynchronizeDiffService leftDiffService; + private final ReferentialSynchronizeDiffService rightDiffService; + + public ReferentialSynchronizeDiffsEngine(ReferentialSynchronizeDiffService leftDiffService, ReferentialSynchronizeDiffService rightDiffService) { + this.leftDiffService = leftDiffService; + this.rightDiffService = rightDiffService; + } + + public ReferentialSynchronizeDiffs build(ReferentialSynchronizeMode mode) { + + ReferentialSynchronizeDiffs.Builder result = ReferentialSynchronizeDiffs.builder(mode); + + ReferentialDataSourceStates leftSourceReferentialStates = leftDiffService.getSourceReferentialStates(); + ReferentialDataSourceStates rightSourceReferentialStates = rightDiffService.getSourceReferentialStates(); + + ImmutableSet<Class<? extends ReferentialDto>> leftReferentialTypes = leftSourceReferentialStates.getReferentialTypes(); + ImmutableSet<Class<? extends ReferentialDto>> rightReferentialTypes = rightSourceReferentialStates.getReferentialTypes(); + ImmutableSet<Class<? extends ReferentialDto>> allReferentialTypes = ImmutableSet.<Class<? extends ReferentialDto>>builder().addAll(leftReferentialTypes).addAll(rightReferentialTypes).build(); + + for (Class referentialType : allReferentialTypes) { + + build0(referentialType, result, leftSourceReferentialStates.getReferentialVersions(referentialType), rightSourceReferentialStates.getReferentialVersions(referentialType)); + } + + return result.build(); + } + + public <R extends ReferentialDto> ReferentialReferenceSet<R> getLeftReferentialReferenceSet(Class<R> referentialName, ImmutableSet<ReferentialSynchronizeDiffState> diffStates) { + Set<String> ids = diffStates.stream().map(ReferentialSynchronizeDiffState::getId).collect(Collectors.toSet()); + return leftDiffService.getReferentialReferenceSet(referentialName, ImmutableSet.copyOf(ids)); + } + + public <R extends ReferentialDto> ReferentialReferenceSet<R> getRightReferentialReferenceSet(Class<R> referentialName, ImmutableSet<ReferentialSynchronizeDiffState> diffStates) { + Set<String> ids = diffStates.stream().map(ReferentialSynchronizeDiffState::getId).collect(Collectors.toSet()); + return rightDiffService.getReferentialReferenceSet(referentialName, ImmutableSet.copyOf(ids)); + } + + public <R extends ReferentialDto> ReferentialReferenceSet<R> getLeftEnabledReferentialReferenceSet(Class<R> referentialName) { + return leftDiffService.getEnabledReferentialReferenceSet(referentialName); + } + + public <R extends ReferentialDto> ReferentialReferenceSet<R> getRightEnabledReferentialReferenceSet(Class<R> referentialName) { + return rightDiffService.getEnabledReferentialReferenceSet(referentialName); + } + + private <R extends ReferentialDto> void build0(Class<R> referentialName, ReferentialSynchronizeDiffs.Builder result, ReferentialDataSourceState<R> leftStates, ReferentialDataSourceState<R> rightStates) { + + + ImmutableMap<String, ReferentialSynchronizeDiffState> leftLatestReferentialDiffState = leftStates.getReferentialStatesById(); + ImmutableMap<String, ReferentialSynchronizeDiffState> rightLatestReferentialDiffState = rightStates.getReferentialStatesById(); + + ImmutableSet<String> allIds = ImmutableSet.<String>builder().addAll(leftLatestReferentialDiffState.keySet()).addAll(rightLatestReferentialDiffState.keySet()).build(); + + for (String id : allIds) { + + ReferentialSynchronizeDiffState leftReferentialState = leftLatestReferentialDiffState.get(id); + ReferentialSynchronizeDiffState rightReferentialState = rightLatestReferentialDiffState.get(id); + + if (leftReferentialState == null) { + + // ajouté à droite + result.addRightAddedReferential(referentialName, rightReferentialState); + continue; + } + + if (rightReferentialState == null) { + + // ajouté à gauche + result.addLeftAddedReferential(referentialName, leftReferentialState); + continue; + } + + int order = leftReferentialState.compareTo(rightReferentialState); + switch (order) { + + case ReferentialSynchronizeDiffState.BEFORE: + + // la droite est plus récente + result.addRightUpdatedReferential(referentialName, rightReferentialState); + break; + case ReferentialSynchronizeDiffState.AFTER: + + // la gauche est plus récente + result.addLeftUpdatedReferential(referentialName, leftReferentialState); + break; + } + + } + + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/LocalReferentialStates.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/LocalReferentialStates.java similarity index 97% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/LocalReferentialStates.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/LocalReferentialStates.java index 3414794..6cdf58a 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/LocalReferentialStates.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/LocalReferentialStates.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L 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/referential/legacy/RemoteReferentialDiff.java similarity index 97% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/RemoteReferentialDiff.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/RemoteReferentialDiff.java index 2460dd9..88fa8aa 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/referential/legacy/RemoteReferentialDiff.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L 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/referential/legacy/UnidirectionalReferentialSynchronizeCallbackRequest.java similarity index 96% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackRequest.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeCallbackRequest.java index 335cbc2..359da72 100644 --- 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/referential/legacy/UnidirectionalReferentialSynchronizeCallbackRequest.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L 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/referential/legacy/UnidirectionalReferentialSynchronizeCallbackRequests.java similarity index 97% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackRequests.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeCallbackRequests.java index 63ef003..fa507aa 100644 --- 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/referential/legacy/UnidirectionalReferentialSynchronizeCallbackRequests.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L 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/referential/legacy/UnidirectionalReferentialSynchronizeCallbackResult.java similarity index 95% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackResult.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeCallbackResult.java index c5d59a7..3961ba8 100644 --- 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/referential/legacy/UnidirectionalReferentialSynchronizeCallbackResult.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L 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/referential/legacy/UnidirectionalReferentialSynchronizeCallbackResults.java similarity index 96% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeCallbackResults.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeCallbackResults.java index 26a5244..d3f00c4 100644 --- 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/referential/legacy/UnidirectionalReferentialSynchronizeCallbackResults.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeContext.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeContext.java similarity index 96% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeContext.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeContext.java index 0081a9c..7b2652d 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeContext.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeContext.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L 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/referential/legacy/UnidirectionalReferentialSynchronizeEngine.java similarity index 99% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeEngine.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeEngine.java index 1b7b904..8689492 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/referential/legacy/UnidirectionalReferentialSynchronizeEngine.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L 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/referential/legacy/UnidirectionalReferentialSynchronizeLocalService.java similarity index 98% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeLocalService.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeLocalService.java index 0de372f..0e9f20f 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/referential/legacy/UnidirectionalReferentialSynchronizeLocalService.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRemoteService.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeRemoteService.java similarity index 96% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRemoteService.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeRemoteService.java index c0c2737..849973e 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRemoteService.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeRemoteService.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L 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/referential/legacy/UnidirectionalReferentialSynchronizeRequest.java similarity index 98% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRequest.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeRequest.java index d5b7ece..9054a25 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/referential/legacy/UnidirectionalReferentialSynchronizeRequest.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeResult.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeResult.java similarity index 98% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeResult.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeResult.java index 89e75fb..33f158c 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeResult.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeResult.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/ReferentialSynchronizeRequest.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/ReferentialSynchronizeRequest.java new file mode 100644 index 0000000..7cc78be --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/ReferentialSynchronizeRequest.java @@ -0,0 +1,146 @@ +package fr.ird.observe.services.service.actions.synchro.referential.ng; + +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.services.service.actions.synchro.referential.ng.task.ReferentialSynchronizeCopyTask; +import fr.ird.observe.services.service.actions.synchro.referential.ng.task.ReferentialSynchronizeDeleteTask; +import fr.ird.observe.services.service.actions.synchro.referential.ng.task.ReferentialSynchronizeDesactivateTask; +import fr.ird.observe.services.service.actions.synchro.referential.ng.task.ReferentialSynchronizeDesactivateWithReplaceTask; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * Created on 08/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferentialSynchronizeRequest { + + /** Logger. */ + private static final Log log = LogFactory.getLog(ReferentialSynchronizeRequest.class); + + public static Builder builder(boolean h2, boolean oppositeH2) { + return new Builder(h2, oppositeH2); + } + + /** + * Is data source use h2 ? + */ + private final boolean h2; + /** + * Is opposite data source use h2 ? + */ + private final boolean oppositeH2; + /** + * Copy tasks. + */ + private final ImmutableSet<ReferentialSynchronizeCopyTask> copyTasks; + /** + * Delete tasks. + */ + private final ImmutableSet<ReferentialSynchronizeDeleteTask> deleteTasks; + /** + * Desactivate tasks. + */ + private final ImmutableSet<ReferentialSynchronizeDesactivateTask> desactivateTasks; + /** + * Desactivate with replace tasks. + */ + private final ImmutableSet<ReferentialSynchronizeDesactivateWithReplaceTask> desactivateWithReplaceTasks; + + public static class Builder { + + private final boolean h2; + private final boolean oppositeH2; + private final ImmutableSet.Builder<ReferentialSynchronizeCopyTask> copyTasksBuilder = ImmutableSet.builder(); + private final ImmutableSet.Builder<ReferentialSynchronizeDeleteTask> deleteTasksBuilder = ImmutableSet.builder(); + private final ImmutableSet.Builder<ReferentialSynchronizeDesactivateTask> desactivateTasksBuilder = ImmutableSet.builder(); + private final ImmutableSet.Builder<ReferentialSynchronizeDesactivateWithReplaceTask> desactivateWithReplaceTasksBuilder = ImmutableSet.builder(); + + public Builder(boolean h2, boolean oppositeH2) { + this.h2 = h2; + this.oppositeH2 = oppositeH2; + } + + public ReferentialSynchronizeRequest build() { + return new ReferentialSynchronizeRequest(h2, oppositeH2, copyTasksBuilder.build(), deleteTasksBuilder.build(), desactivateTasksBuilder.build(), desactivateWithReplaceTasksBuilder.build()); + } + + public Builder addDeleteTask(ReferentialSynchronizeDeleteTask<?> task) { + + if (log.isInfoEnabled()) { + log.info("Add delete task for data: " + task.getReferentialType().getName() + " / " + task.getReferentialId()); + } + deleteTasksBuilder.add(task); + return this; + } + + public Builder addDesactivateTask(ReferentialSynchronizeDesactivateTask<?> task) { + + if (log.isInfoEnabled()) { + log.info("Add desactivate (without replacement) task for data: " + task.getReferentialType().getName() + " / " + task.getReferentialId()); + } + desactivateTasksBuilder.add(task); + return this; + } + + public Builder addDesactivateWithReplaceTask(ReferentialSynchronizeDesactivateWithReplaceTask<?> task) { + + if (log.isInfoEnabled()) { + log.info("Add desactivate (with replacement) task for data: " + task.getReferentialType().getName() + " / " + task.getReferentialId()); + } + desactivateWithReplaceTasksBuilder.add(task); + return this; + } + + public Builder addCopyTask(ReferentialSynchronizeCopyTask<?> task) { + if (log.isInfoEnabled()) { + log.info("Add copy task for trip: " + task.getReferentialType().getName() + " / " + task.getReferentialId()); + } + copyTasksBuilder.add(task); + return this; + } + + } + + public ImmutableSet<ReferentialSynchronizeCopyTask> getCopyTasks() { + return copyTasks; + } + + public ImmutableSet<ReferentialSynchronizeDeleteTask> getDeleteTasks() { + return deleteTasks; + } + + public ImmutableSet<ReferentialSynchronizeDesactivateTask> getDesactivateTasks() { + return desactivateTasks; + } + + public ImmutableSet<ReferentialSynchronizeDesactivateWithReplaceTask> getDesactivateWithReplaceTasks() { + return desactivateWithReplaceTasks; + } + + public boolean isNotEmpty() { + return !(copyTasks.isEmpty() && deleteTasks.isEmpty() && desactivateTasks.isEmpty() && desactivateWithReplaceTasks.isEmpty()); + } + + public boolean isOppositeH2() { + return oppositeH2; + } + + public boolean isH2() { + return h2; + } + + private ReferentialSynchronizeRequest(boolean h2, boolean oppositeH2, + ImmutableSet<ReferentialSynchronizeCopyTask> copyTasks, + ImmutableSet<ReferentialSynchronizeDeleteTask> deleteTasks, + ImmutableSet<ReferentialSynchronizeDesactivateTask> desactivateTasks, + ImmutableSet<ReferentialSynchronizeDesactivateWithReplaceTask> desactivateWithReplaceTasks) { + this.h2 = h2; + this.oppositeH2 = oppositeH2; + this.copyTasks = copyTasks; + this.deleteTasks = deleteTasks; + this.desactivateTasks = desactivateTasks; + this.desactivateWithReplaceTasks = desactivateWithReplaceTasks; + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeService.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/ReferentialSynchronizeService.java similarity index 77% rename from observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeService.java rename to observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/ReferentialSynchronizeService.java index 34882b2..f84279a 100644 --- a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeService.java +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/ReferentialSynchronizeService.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.datasynchro; +package fr.ird.observe.services.service.actions.synchro.referential.ng; import fr.ird.observe.services.ObserveService; import fr.ird.observe.services.spi.PostRequest; @@ -12,7 +12,7 @@ import fr.ird.observe.services.spi.WriteDataPermission; * @author Tony Chemit - chemit@codelutin.com * @since 5.0 */ -public interface DataSynchronizeService extends ObserveService { +public interface ReferentialSynchronizeService extends ObserveService { /** * Prépare la demande donnée en paramètre. Par exemple s'il y a des demandes de recopie, on récupère le code sql de recopie. @@ -23,7 +23,7 @@ public interface DataSynchronizeService extends ObserveService { */ @ReadDataPermission @PostRequest - void prepareRequestOnOppositeDataSource(DataSynchronizeRequest request); + void prepareRequestOnOppositeDataSource(ReferentialSynchronizeRequest request); /** * Prépare la demande donnée en paramètre. Par exemple s'il y a des demandes de suppression, on récupère le code sql de suppression. @@ -34,7 +34,7 @@ public interface DataSynchronizeService extends ObserveService { */ @ReadDataPermission @PostRequest - void prepareRequestOnDataSource(DataSynchronizeRequest request); + void prepareRequestOnDataSource(ReferentialSynchronizeRequest request); /** * Exécution de la demande donnée en paramètre. @@ -47,6 +47,6 @@ public interface DataSynchronizeService extends ObserveService { @WriteDataPermission @Write @PostRequest - void executeRequest(DataSynchronizeRequest request); + void executeRequest(ReferentialSynchronizeRequest request); } diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeCopyTask.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeCopyTask.java new file mode 100644 index 0000000..82b91ee --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeCopyTask.java @@ -0,0 +1,17 @@ +package fr.ird.observe.services.service.actions.synchro.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +/** + * Created on 08/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferentialSynchronizeCopyTask<Type extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<Type> { + + public ReferentialSynchronizeCopyTask(ReferentialReference<Type> reference) { + super(reference); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeDeleteTask.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeDeleteTask.java new file mode 100644 index 0000000..b6c0baa --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeDeleteTask.java @@ -0,0 +1,17 @@ +package fr.ird.observe.services.service.actions.synchro.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +/** + * Created on 08/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferentialSynchronizeDeleteTask<Type extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<Type> { + + public ReferentialSynchronizeDeleteTask(ReferentialReference<Type> reference) { + super(reference); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeDesactivateTask.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeDesactivateTask.java new file mode 100644 index 0000000..f55853f --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeDesactivateTask.java @@ -0,0 +1,17 @@ +package fr.ird.observe.services.service.actions.synchro.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +/** + * Created on 08/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferentialSynchronizeDesactivateTask<Type extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<Type> { + + public ReferentialSynchronizeDesactivateTask(ReferentialReference<Type> reference) { + super(reference); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeDesactivateWithReplaceTask.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeDesactivateWithReplaceTask.java new file mode 100644 index 0000000..8a9a7f6 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeDesactivateWithReplaceTask.java @@ -0,0 +1,17 @@ +package fr.ird.observe.services.service.actions.synchro.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +/** + * Created on 08/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferentialSynchronizeDesactivateWithReplaceTask<Type extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<Type> { + + public ReferentialSynchronizeDesactivateWithReplaceTask(ReferentialReference<Type> reference) { + super(reference); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeTaskSupport.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeTaskSupport.java new file mode 100644 index 0000000..9771238 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/task/ReferentialSynchronizeTaskSupport.java @@ -0,0 +1,38 @@ +package fr.ird.observe.services.service.actions.synchro.referential.ng.task; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +/** + * Created on 08/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public abstract class ReferentialSynchronizeTaskSupport<Type extends ReferentialDto> { + + private final Class<Type> referentialType; + private final String referentialId; + private byte[] dataContent; + + protected ReferentialSynchronizeTaskSupport(ReferentialReference<Type> reference) { + this.referentialType = reference.getType(); + this.referentialId = reference.getId(); + } + + public Class<Type> getReferentialType() { + return referentialType; + } + + public String getReferentialId() { + return referentialId; + } + + public byte[] getDataContent() { + return dataContent; + } + + public void setDataContent(byte[] dataContent) { + this.dataContent = dataContent; + } +} diff --git a/observe-services-api/src/main/resources/i18n/observe-services-api_en_GB.properties b/observe-services-api/src/main/resources/i18n/observe-services-api_en_GB.properties index ecc00df..4f7ef34 100644 --- a/observe-services-api/src/main/resources/i18n/observe-services-api_en_GB.properties +++ b/observe-services-api/src/main/resources/i18n/observe-services-api_en_GB.properties @@ -9,6 +9,12 @@ observe.ownership.unknown=Unknown observe.schoolType.libre=Free school type observe.schoolType.objet=Object school type observe.schoolType.undefined=Undefined school type +observe.synchro.referential.mode.both= +observe.synchro.referential.mode.both.description= +observe.synchro.referential.mode.fromLeftToRight= +observe.synchro.referential.mode.fromLeftToRight.description= +observe.synchro.referential.mode.fromRightToLeft= +observe.synchro.referential.mode.fromRightToLeft.description= observe.tripMapPointType.longlineActivity=Activity observe.tripMapPointType.longlineActivityInHarbour=Au Harbour observe.tripMapPointType.longlineActivityWithHaulingEnd=Hauling end diff --git a/observe-services-api/src/main/resources/i18n/observe-services-api_es_ES.properties b/observe-services-api/src/main/resources/i18n/observe-services-api_es_ES.properties index d6b8300..de318fe 100644 --- a/observe-services-api/src/main/resources/i18n/observe-services-api_es_ES.properties +++ b/observe-services-api/src/main/resources/i18n/observe-services-api_es_ES.properties @@ -9,6 +9,12 @@ observe.ownership.unknown=Desconocido observe.schoolType.libre=Banco libre observe.schoolType.objet=Banco a objeto observe.schoolType.undefined=Banco indeterminado +observe.synchro.referential.mode.both= +observe.synchro.referential.mode.both.description= +observe.synchro.referential.mode.fromLeftToRight= +observe.synchro.referential.mode.fromLeftToRight.description= +observe.synchro.referential.mode.fromRightToLeft= +observe.synchro.referential.mode.fromRightToLeft.description= observe.tripMapPointType.longlineActivity=Activity observe.tripMapPointType.longlineActivityInHarbour=Au Harbour observe.tripMapPointType.longlineActivityWithHaulingEnd=Hauling end diff --git a/observe-services-api/src/main/resources/i18n/observe-services-api_fr_FR.properties b/observe-services-api/src/main/resources/i18n/observe-services-api_fr_FR.properties index 193e4e8..a885f63 100644 --- a/observe-services-api/src/main/resources/i18n/observe-services-api_fr_FR.properties +++ b/observe-services-api/src/main/resources/i18n/observe-services-api_fr_FR.properties @@ -9,6 +9,12 @@ observe.ownership.unknown=Inconnue observe.schoolType.libre=Banc libre observe.schoolType.objet=Banc objet observe.schoolType.undefined=Banc indéterminé +observe.synchro.referential.mode.both=Bi-directionnelle +observe.synchro.referential.mode.both.description=Pour autoriser les modifications sur les deux sources. +observe.synchro.referential.mode.fromLeftToRight=Uni-directionnelle de la gauche vers la droite +observe.synchro.referential.mode.fromLeftToRight.description=Pour autoriser les modification que sur la base de droite. +observe.synchro.referential.mode.fromRightToLeft=Uni-directionnelle de la droite vers la gauche +observe.synchro.referential.mode.fromRightToLeft.description=Pour autoriser les modifications que sur la base de gauche. observe.tripMapPointType.longlineActivity=point d'activité observe.tripMapPointType.longlineActivityInHarbour=Au port observe.tripMapPointType.longlineActivityWithHaulingEnd=Fin de virage diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeServiceTopia.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/data/DataSynchronizeServiceTopia.java similarity index 66% rename from observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeServiceTopia.java rename to observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/data/DataSynchronizeServiceTopia.java index b4c6e4e..5f577c7 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/datasynchro/DataSynchronizeServiceTopia.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/data/DataSynchronizeServiceTopia.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.datasynchro; +package fr.ird.observe.services.service.actions.synchro.data; import com.google.common.collect.ImmutableSet; import fr.ird.observe.entities.Entities; @@ -7,6 +7,8 @@ import fr.ird.observe.services.ObserveServiceTopia; import fr.ird.observe.services.service.AddSqlScriptProducerRequest; import fr.ird.observe.services.service.DeleteSqlScriptProducerRequest; import fr.ird.observe.services.service.SqlScriptProducerService; +import fr.ird.observe.services.service.actions.synchro.data.task.DataSynchronizeCopyTask; +import fr.ird.observe.services.service.actions.synchro.data.task.DataSynchronizeDeleteTask; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -32,10 +34,10 @@ public class DataSynchronizeServiceTopia extends ObserveServiceTopia implements @Override public void prepareRequestOnOppositeDataSource(DataSynchronizeRequest request) { - for (DataSynchronizeCopyTask copyTask : request.getCopyTasks()) { + for (DataSynchronizeCopyTask task : request.getCopyTasks()) { if (log.isInfoEnabled()) { - log.info("Obtain trip sql copy content: " + copyTask.getProgramId() + " / " + copyTask.getTripId()); + log.info("Obtain trip sql copy content: " + task.getProgramId() + " / " + task.getTripId()); } // get the data content @@ -46,11 +48,11 @@ public class DataSynchronizeServiceTopia extends ObserveServiceTopia implements } else { sqlRequest = AddSqlScriptProducerRequest.forPostgres(); } - sqlRequest.dataIdsToAdd(ImmutableSet.of(copyTask.getTripId())); + sqlRequest.dataIdsToAdd(ImmutableSet.of(task.getTripId())); byte[] sqlScript = sqlScriptProducerService.produceAddSqlScript(sqlRequest); // store it in task - copyTask.setDataContent(sqlScript); + task.setDataContent(sqlScript); } @@ -59,13 +61,13 @@ public class DataSynchronizeServiceTopia extends ObserveServiceTopia implements @Override public void prepareRequestOnDataSource(DataSynchronizeRequest request) { - for (DataSynchronizeDeleteTask deleteTask : request.getDeleteTasks()) { + for (DataSynchronizeDeleteTask task : request.getDeleteTasks()) { - String tripId = deleteTask.getTripId(); + String tripId = task.getTripId(); boolean longlineId = Entities.isLonglineId(tripId); if (log.isInfoEnabled()) { - log.info("Obtain trip sql delete content: " + deleteTask.getProgramId() + " / " + deleteTask.getTripId()); + log.info("Obtain trip sql delete content: " + task.getProgramId() + " / " + task.getTripId()); } // get the data content @@ -76,11 +78,11 @@ public class DataSynchronizeServiceTopia extends ObserveServiceTopia implements } else { sqlRequest = DeleteSqlScriptProducerRequest.forPostgres(); } - sqlRequest.dataIdsToDelete(ImmutableSet.of(deleteTask.getTripId())); + sqlRequest.dataIdsToDelete(ImmutableSet.of(task.getTripId())); byte[] sqlScript = sqlScriptProducerService.produceDeleteSqlScript(sqlRequest); // store it in task - deleteTask.setDataContent(sqlScript); + task.setDataContent(sqlScript); } } @@ -88,27 +90,24 @@ public class DataSynchronizeServiceTopia extends ObserveServiceTopia implements @Override public void executeRequest(DataSynchronizeRequest request) { - for (DataSynchronizeDeleteTask deleteTask : request.getDeleteTasks()) { + for (DataSynchronizeDeleteTask task : request.getDeleteTasks()) { - String tripId = deleteTask.getTripId(); + String tripId = task.getTripId(); boolean longlineId = Entities.isLonglineId(tripId); if (log.isInfoEnabled()) { - log.info("Delete trip: " + deleteTask.getProgramId() + " / " + deleteTask.getTripId()); + log.info("Delete trip: " + task.getProgramId() + " / " + task.getTripId()); } - serviceContext.getTopiaApplicationContext().executeSqlStatements(deleteTask.getDataContent()); + serviceContext.getTopiaApplicationContext().executeSqlStatements(task.getDataContent()); } - // need to flush to make deletion complete, before to execute the copy sql script - serviceContext.getTopiaPersistenceContext().flush(); - - for (DataSynchronizeCopyTask copyTask : request.getCopyTasks()) { + for (DataSynchronizeCopyTask task : request.getCopyTasks()) { if (log.isInfoEnabled()) { - log.info("Copy trip: " + copyTask.getProgramId() + " / " + copyTask.getTripId()); + log.info("Copy trip: " + task.getProgramId() + " / " + task.getTripId()); } - serviceContext.getTopiaApplicationContext().executeSqlStatements(copyTask.getDataContent()); + serviceContext.getTopiaApplicationContext().executeSqlStatements(task.getDataContent()); } } diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffServiceTopia.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffServiceTopia.java new file mode 100644 index 0000000..4a24685 --- /dev/null +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/diff/ReferentialSynchronizeDiffServiceTopia.java @@ -0,0 +1,108 @@ +package fr.ird.observe.services.service.actions.synchro.referential.diff; + +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.ObserveEntityEnum; +import fr.ird.observe.ObserveTopiaPersistenceContext; +import fr.ird.observe.entities.Entities; +import fr.ird.observe.entities.constants.ReferenceStatusPersist; +import fr.ird.observe.entities.referentiel.ObserveReferentialEntity; +import fr.ird.observe.services.ObserveServiceTopia; +import fr.ird.observe.services.binder.BinderEngine; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReferenceSet; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.topia.persistence.TopiaDao; + +import java.util.List; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferentialSynchronizeDiffServiceTopia extends ObserveServiceTopia implements ReferentialSynchronizeDiffService { + + /** Logger. */ + private static final Log log = LogFactory.getLog(ReferentialSynchronizeDiffServiceTopia.class); + + @Override + public <R extends ReferentialDto> ReferentialReferenceSet<R> getEnabledReferentialReferenceSet(Class<R> referentialName) { + + if (log.isTraceEnabled()) { + log.trace("getEnabledReferentialReferenceSet(" + referentialName + ")"); + } + + ObserveEntityEnum entityEnum = ObserveEntityEnum.valueOf(referentialName); + Class<? extends ObserveReferentialEntity> entityType = (Class) entityEnum.getContract(); + Class<R> dtoType = BinderEngine.get().getReferentialDtoType(entityType); + ReferentialReferenceSet<R> result = getEnabledReferenceSet0(entityType, dtoType); + return result; + } + + @Override + public <R extends ReferentialDto> ReferentialReferenceSet<R> getReferentialReferenceSet(Class<R> referentialName, ImmutableSet<String> ids) { + + if (log.isTraceEnabled()) { + log.trace("getReferentialReferenceSet(" + referentialName + ", " + ids.size() + " element(s)"); + } + Class<? extends ObserveReferentialEntity> entityType = BinderEngine.get().getReferentialEntityType(referentialName); + ObserveEntityEnum entityEnum = ObserveEntityEnum.valueOf(entityType); + return getReferenceSet0(entityType, referentialName, ids); + } + + @Override + public ReferentialDataSourceStates getSourceReferentialStates() { + + if (log.isTraceEnabled()) { + log.trace("getSourceReferentialStates()"); + } + + ReferentialDataSourceStates referentialStates = new ReferentialDataSourceStates(); + for (ObserveEntityEnum referenceEntity : Entities.REFERENCE_ENTITIES) { + if (ObserveEntityEnum.LastUpdateDate.equals(referenceEntity)) { + continue; + } + Class entityType = referenceEntity.getContract(); + Class dtoType = BinderEngine.get().getReferentialDtoType(entityType); + getLocalSourceReferentialVersions0(dtoType, entityType, referentialStates); + } + return referentialStates; + } + + private <E extends ObserveReferentialEntity, R extends ReferentialDto> ReferentialReferenceSet<R> getReferenceSet0(Class<E> entityType, Class<R> dtoType, ImmutableSet<String> ids) { + + ObserveTopiaPersistenceContext persistenceContext = getTopiaPersistenceContext(); + TopiaDao<E> dao = persistenceContext.getDao(entityType); + List<E> entities = dao.forTopiaIdIn(ids).findAll(); + ReferentialReferenceSet<R> result = toReferentialReferenceSet(dtoType, entities, null); + return result; + + } + + private <E extends ObserveReferentialEntity, R extends ReferentialDto> ReferentialReferenceSet<R> getEnabledReferenceSet0(Class<E> entityType, Class<R> dtoType) { + + ObserveTopiaPersistenceContext persistenceContext = getTopiaPersistenceContext(); + TopiaDao<E> dao = persistenceContext.getDao(entityType); + List<E> entities = dao.forEquals(ObserveReferentialEntity.PROPERTY_STATUS, ReferenceStatusPersist.enabled).findAll(); + ReferentialReferenceSet<R> result = toReferentialReferenceSet(dtoType, entities, null); + return result; + + } + + private <E extends ObserveReferentialEntity, R extends ReferentialDto> void getLocalSourceReferentialVersions0(Class<R> referentialName, Class<E> entityType, ReferentialDataSourceStates localReferentialStates) { + + ReferentialDataSourceState<R> referentialDataSourceState = new ReferentialDataSourceState<>(referentialName); + TopiaDao<E> dao = getTopiaPersistenceContext().getDao(entityType); + for (E e : dao) { + + referentialDataSourceState.addReferentialVersion(e.getTopiaId(), e.getLastUpdateDate(), e.getTopiaVersion(), e.isDisabled()); + + + } + localReferentialStates.addReferentialVersion(referentialName, referentialDataSourceState); + + } + +} diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/DeleteSqlStatementGenerator.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/DeleteSqlStatementGenerator.java similarity index 96% rename from observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/DeleteSqlStatementGenerator.java rename to observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/DeleteSqlStatementGenerator.java index 89c8bcb..f589084 100644 --- a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/DeleteSqlStatementGenerator.java +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/DeleteSqlStatementGenerator.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L 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/referential/legacy/InsertSqlStatementGenerator.java similarity index 99% rename from observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/InsertSqlStatementGenerator.java rename to observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/InsertSqlStatementGenerator.java index 8d3b565..d8643c8 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/referential/legacy/InsertSqlStatementGenerator.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L 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/referential/legacy/ReplaceSqlStatementGenerator.java similarity index 98% rename from observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/ReplaceSqlStatementGenerator.java rename to observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/ReplaceSqlStatementGenerator.java index 24fb13b..57973a2 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/referential/legacy/ReplaceSqlStatementGenerator.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L 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/referential/legacy/UnidirectionalReferentialSynchronizeLocalServiceTopia.java similarity index 99% rename from observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeLocalServiceTopia.java rename to observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeLocalServiceTopia.java index 25fb53d..3de581f 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/referential/legacy/UnidirectionalReferentialSynchronizeLocalServiceTopia.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L 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/referential/legacy/UnidirectionalReferentialSynchronizeRemoteServiceTopia.java similarity index 98% rename from observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UnidirectionalReferentialSynchronizeRemoteServiceTopia.java rename to observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UnidirectionalReferentialSynchronizeRemoteServiceTopia.java index b3cc570..1b0f4b2 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/referential/legacy/UnidirectionalReferentialSynchronizeRemoteServiceTopia.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L 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/referential/legacy/UpdateSqlStatementGenerator.java similarity index 99% rename from observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/UpdateSqlStatementGenerator.java rename to observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/legacy/UpdateSqlStatementGenerator.java index e44164a..b2c5089 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/referential/legacy/UpdateSqlStatementGenerator.java @@ -1,4 +1,4 @@ -package fr.ird.observe.services.service.actions.synchro; +package fr.ird.observe.services.service.actions.synchro.referential.legacy; /*- * #%L diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/ReferentialSynchronizeServiceTopia.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/ReferentialSynchronizeServiceTopia.java new file mode 100644 index 0000000..4feb069 --- /dev/null +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/synchro/referential/ng/ReferentialSynchronizeServiceTopia.java @@ -0,0 +1,135 @@ +package fr.ird.observe.services.service.actions.synchro.referential.ng; + +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.entities.Entities; +import fr.ird.observe.services.ObserveServiceContextTopia; +import fr.ird.observe.services.ObserveServiceTopia; +import fr.ird.observe.services.service.AddSqlScriptProducerRequest; +import fr.ird.observe.services.service.DeleteSqlScriptProducerRequest; +import fr.ird.observe.services.service.SqlScriptProducerService; +import fr.ird.observe.services.service.actions.synchro.referential.ng.task.ReferentialSynchronizeCopyTask; +import fr.ird.observe.services.service.actions.synchro.referential.ng.task.ReferentialSynchronizeDeleteTask; +import fr.ird.observe.services.service.actions.synchro.referential.ng.task.ReferentialSynchronizeDesactivateTask; +import fr.ird.observe.services.service.actions.synchro.referential.ng.task.ReferentialSynchronizeDesactivateWithReplaceTask; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * Created on 08/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferentialSynchronizeServiceTopia extends ObserveServiceTopia implements ReferentialSynchronizeService { + + /** Logger. */ + private static final Log log = LogFactory.getLog(ReferentialSynchronizeServiceTopia.class); + + protected SqlScriptProducerService sqlScriptProducerService; + + @Override + public void setServiceContext(ObserveServiceContextTopia serviceContext) { + super.setServiceContext(serviceContext); + sqlScriptProducerService = serviceContext.newService(SqlScriptProducerService.class); + } + + @Override + public void prepareRequestOnOppositeDataSource(ReferentialSynchronizeRequest request) { + + for (ReferentialSynchronizeCopyTask copyTask : request.getCopyTasks()) { + + if (log.isInfoEnabled()) { + log.info("Obtain data sql copy content: " + copyTask.getReferentialType().getName() + " / " + copyTask.getReferentialId()); + } + + // get the data content + + AddSqlScriptProducerRequest sqlRequest; + if (request.isOppositeH2()) { + sqlRequest = AddSqlScriptProducerRequest.forH2(); + } else { + sqlRequest = AddSqlScriptProducerRequest.forPostgres(); + } + sqlRequest.dataIdsToAdd(ImmutableSet.of(copyTask.getReferentialId())); + byte[] sqlScript = sqlScriptProducerService.produceAddSqlScript(sqlRequest); + + // store it in task + copyTask.setDataContent(sqlScript); + + } + + } + + @Override + public void prepareRequestOnDataSource(ReferentialSynchronizeRequest request) { + + for (ReferentialSynchronizeDeleteTask deleteTask : request.getDeleteTasks()) { + + String tripId = deleteTask.getReferentialId(); + boolean longlineId = Entities.isLonglineId(tripId); + + if (log.isInfoEnabled()) { + log.info("Obtain trip sql delete content: " + deleteTask.getReferentialType().getName() + " / " + deleteTask.getReferentialId()); + } + + // get the data content + + DeleteSqlScriptProducerRequest sqlRequest; + if (request.isH2()) { + sqlRequest = DeleteSqlScriptProducerRequest.forH2(); + } else { + sqlRequest = DeleteSqlScriptProducerRequest.forPostgres(); + } + sqlRequest.dataIdsToDelete(ImmutableSet.of(deleteTask.getReferentialId())); + byte[] sqlScript = sqlScriptProducerService.produceDeleteSqlScript(sqlRequest); + + // store it in task + deleteTask.setDataContent(sqlScript); + + } + } + + @Override + public void executeRequest(ReferentialSynchronizeRequest request) { + + for (ReferentialSynchronizeDeleteTask task : request.getDeleteTasks()) { + + String tripId = task.getReferentialId(); + boolean longlineId = Entities.isLonglineId(tripId); + + if (log.isInfoEnabled()) { + log.info("Delete data: " + task.getReferentialType().getName() + " / " + task.getReferentialId()); + } + serviceContext.getTopiaApplicationContext().executeSqlStatements(task.getDataContent()); + + } + + for (ReferentialSynchronizeCopyTask task : request.getCopyTasks()) { + + if (log.isInfoEnabled()) { + log.info("Copy data: " + task.getReferentialType().getName() + " / " + task.getReferentialId()); + } + serviceContext.getTopiaApplicationContext().executeSqlStatements(task.getDataContent()); + + } + + for (ReferentialSynchronizeDesactivateTask task : request.getDesactivateTasks()) { + + if (log.isInfoEnabled()) { + log.info("Desactivate data (without replacement) : " + task.getReferentialType().getName() + " / " + task.getReferentialId()); + } + serviceContext.getTopiaApplicationContext().executeSqlStatements(task.getDataContent()); + + } + + for (ReferentialSynchronizeDesactivateWithReplaceTask task : request.getDesactivateWithReplaceTasks()) { + + if (log.isInfoEnabled()) { + log.info("Desactivate data (with replacement) : " + task.getReferentialType().getName() + " / " + task.getReferentialId()); + } + serviceContext.getTopiaApplicationContext().executeSqlStatements(task.getDataContent()); + + } + } + +} 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 df69110..5d1cbe2 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 @@ -27,6 +27,12 @@ import fr.ird.observe.entities.Entities; import fr.ird.observe.services.ApplicationContextResource; import fr.ird.observe.services.DataSourceResource; import fr.ird.observe.services.service.AbstractServiceTopiaTest; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeCallbackResults; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeContext; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeEngine; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeLocalService; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeRemoteService; +import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeResult; import fr.ird.observe.test.DatabaseName; import fr.ird.observe.test.ObserveFixtures; import fr.ird.observe.test.spi.CopyDatabaseConfiguration; -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.