[Observe-commits] 11/26: La partie graphique est ok

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 96e26b3eaa92bbda966c39621b94635b8a5dea4c Author: Tony CHEMIT <chemit@codelutin.com> Date: Sat Aug 13 18:00:24 2016 +0200 La partie graphique est ok --- .../src/main/filters/observe-ui.properties | 4 +- .../fr/ird/observe/ui/admin/AdminUIHandler.java | 37 +++ .../java/fr/ird/observe/ui/admin/AdminUIModel.java | 138 ++++++++-- .../fr/ird/observe/ui/admin/config/ConfigUI.jcss | 15 +- .../observe/ui/admin/config/ConfigUIHandler.java | 19 +- .../synchronize/data/DataSynchroUIHandler.java | 9 + .../referential/legacy/SynchronizeModel.java | 27 +- .../referential/legacy/SynchronizeUIHandler.java | 2 +- .../referential/ng/ReferentialReplaceUI.jaxx | 29 ++ .../referential/ng/ReferentialReplaceUI.jcss | 9 + .../ng/ReferentialReplaceUIHandler.java | 41 +++ .../referential/ng/ReferentialSynchroModel.java | 182 +++++++++++-- .../referential/ng/ReferentialSynchroUI.jaxx | 59 ++-- .../referential/ng/ReferentialSynchroUI.jcss | 79 +++--- .../ng/ReferentialSynchroUIHandler.java | 296 +++++---------------- .../ng/ReferentialSynchronizeResources.java | 147 ++++++++++ .../ng/ReferentialSynchronizeTaskListModel.java | 47 ++++ .../referential/ng/action/ApplyAction.java | 114 ++++++++ .../ng/action/RegisterAddTaskAction.java | 40 +++ .../ng/action/RegisterCopyTaskAction.java | 40 +++ .../ng/action/RegisterDeleteTaskAction.java | 33 +++ .../ng/action/RegisterDesactivateTaskAction.java | 33 +++ .../ng/action/RegisterRevertTaskAction.java | 26 ++ .../ng/action/RegisterSkipTaskAction.java | 26 ++ .../ng/action/RegisterTasksActionSupport.java | 189 +++++++++++++ .../ng/action/RegisterUpdateTaskAction.java | 41 +++ .../ng/task/AddToReferentialSynchronizeTask.java | 19 ++ .../task/CopyToLeftReferentialSynchronizeTask.java | 25 -- .../CopyToRightReferentialSynchronizeTask.java | 25 -- .../DeleteFromLeftReferentialSynchronizeTask.java | 25 -- .../DeleteFromRightReferentialSynchronizeTask.java | 25 -- .../ng/task/DeleteReferentialSynchronizeTask.java | 19 ++ ...activateFromLeftReferentialSynchronizeTask.java | 25 -- ...ctivateFromRightReferentialSynchronizeTask.java | 25 -- .../DesactivateReferentialSynchronizeTask.java | 40 +++ ...hReplaceFromLeftReferentialSynchronizeTask.java | 25 -- ...ReplaceFromRightReferentialSynchronizeTask.java | 25 -- .../ng/task/ReferentialSynchronizeTaskSupport.java | 33 ++- ...ferentialSynchronizeTaskWithReplaceSupport.java | 34 +++ .../RevertFromLeftReferentialSynchronizeTask.java | 25 -- .../RevertFromRightReferentialSynchronizeTask.java | 25 -- .../ng/task/RevertReferentialSynchronizeTask.java | 19 ++ .../SkipFromLeftReferentialSynchronizeTask.java | 25 -- .../SkipFromRightReferentialSynchronizeTask.java | 25 -- .../ng/task/SkipReferentialSynchronizeTask.java | 19 ++ .../task/UpdateToReferentialSynchronizeTask.java | 19 ++ .../ReferentialSynchronizeTreeCellRenderer.java | 7 +- .../ng/tree/ReferentialSynchronizeTreeModel.java | 197 +++++++++++--- .../ReferentialSynchronizeTreeModelsBuilder.java | 43 ++- .../node/AddedReferenceReferentialSynchroNode.java | 4 +- .../ReferenceReferentialSynchroNodeSupport.java | 20 +- .../UpdatedReferenceReferentialSynchroNode.java | 4 +- .../fr/ird/observe/ui/storage/StorageUIModel.java | 2 +- .../observe-application-swing_en_GB.properties | 68 ++--- .../observe-application-swing_es_ES.properties | 68 ++--- .../observe-application-swing_fr_FR.properties | 83 +++--- ...g => action-desactivateWithReplaceFromLeft.png} | Bin ... => action-desactivateWithReplaceFromRight.png} | Bin .../main/resources/icons/action-synchroUpdate.png | Bin 698 -> 767 bytes 59 files changed, 1791 insertions(+), 889 deletions(-) diff --git a/observe-application-swing/src/main/filters/observe-ui.properties b/observe-application-swing/src/main/filters/observe-ui.properties index 6891800..84c9f1c 100644 --- a/observe-application-swing/src/main/filters/observe-ui.properties +++ b/observe-application-swing/src/main/filters/observe-ui.properties @@ -113,8 +113,8 @@ icon.action.db-start-server=action-db-start-server.png icon.action.db-stop-server=action-db-stop-server.png icon.action.desactivateFromLeft=action-desactivateFromLeft.png icon.action.desactivateFromRight=action-desactivateFromRight.png -icon.action.desactivateFromLeftWithReplace=action-desactivateFromLeftWithReplace.png -icon.action.desactivateFromRightWithReplace=action-desactivateFromRightWithReplace.png +icon.action.desactivateWithReplaceFromLeft=action-desactivateWithReplaceFromLeft.png +icon.action.desactivateWithReplaceFromRight=action-desactivateWithReplaceFromRight.png icon.action.skipFromLeft=action-skipFromLeft.png icon.action.skipFromRight=action-skipFromRight.png icon.action.synchroAdd=action-synchroAdd.png diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/AdminUIHandler.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/AdminUIHandler.java index 9b12cc9..811fcf7 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/AdminUIHandler.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/AdminUIHandler.java @@ -36,6 +36,7 @@ import org.apache.commons.logging.LogFactory; import javax.swing.Icon; import javax.swing.JCheckBox; import javax.swing.JComponent; +import javax.swing.border.TitledBorder; import java.awt.Component; import java.util.Arrays; import java.util.Date; @@ -177,6 +178,42 @@ public class AdminUIHandler { log.trace(newStep); } AdminTabUI c = ui.getStepUI(newStep); + + AdminUIModel model = ui.getModel(); + + if (oldStep == null + && newStep == AdminStep.CONFIG + && (model.containsOperation(AdminStep.REFERENTIAL_SYNCHRONIZE) || model.containsOperation(AdminStep.DATA_SYNCHRONIZE))) { + + ConfigUI configUI = (ConfigUI) ui.getStepUI(AdminStep.CONFIG); + + model.setLocalSourceLabel(t("observe.storage.config.left.storage")); + model.setCentralSourceLabel(t("observe.storage.config.right.storage")); + + configUI.getLocalSourceConfig().setBorder(new TitledBorder(model.getLocalSourceLabel())); + configUI.getCentralSourceConfig().setBorder(new TitledBorder(model.getCentralSourceLabel())); + + } + + //FIXME-release Remettre ce code avant la release une fois la fonctionnalité bien testé +// if (oldStep == AdminStep.CONFIG) { +// +// if (newStep == AdminStep.REFERENTIAL_SYNCHRONIZE) { +// +// SwingUtilities.invokeLater(() -> c.getHandler().addAdminWorker("Chargement des référentiels.", () -> { +// model.initSynchroReferentialUI(); +// return WizardState.PENDING; +// })); +// } else if (newStep == AdminStep.DATA_SYNCHRONIZE) { +// +// SwingUtilities.invokeLater(() -> c.getHandler().addAdminWorker("Chargement des données.", () -> { +// model.initSynchroDataUI(); +// return WizardState.PENDING; +// })); +// } +// } + + if (c != null && c.getStep() == AdminStep.SAVE_LOCAL) { // on met a jour le descriptif diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/AdminUIModel.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/AdminUIModel.java index 890ab8a..2a6065d 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/AdminUIModel.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/AdminUIModel.java @@ -39,10 +39,12 @@ import fr.ird.observe.services.service.BabModelVersionException; import fr.ird.observe.services.service.DatabaseConnexionNotAuthorizedException; import fr.ird.observe.services.service.DatabaseDestroyNotAuthorizedException; import fr.ird.observe.services.service.DatabaseNotFoundException; +import fr.ird.observe.services.service.actions.synchro.referential.ReferentialSynchronizeMode; import fr.ird.observe.services.service.actions.validate.ValidateService; import fr.ird.observe.services.service.actions.validate.ValidateServiceUtils; import fr.ird.observe.services.service.longline.TripLonglineService; import fr.ird.observe.services.service.seine.TripSeineService; +import fr.ird.observe.ui.admin.config.ConfigUI; import fr.ird.observe.ui.admin.consolidate.ConsolidateModel; import fr.ird.observe.ui.admin.export.ExportModel; import fr.ird.observe.ui.admin.report.ReportModel; @@ -62,6 +64,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuiton.validator.NuitonValidatorScope; +import javax.swing.border.TitledBorder; import java.beans.PropertyChangeListener; import java.io.File; import java.util.ArrayList; @@ -92,6 +95,8 @@ public class AdminUIModel extends WizardExtModel<AdminStep> { /** Logger */ private static final Log log = LogFactory.getLog(AdminUIModel.class); + public static final String PROPERTY_LOCAL_SOURCE_LABEL = "localSourceLabel"; + public static final String PROPERTY_CENTRAL_SOURCE_LABEL = "centralSourceLabel"; /** la source de données en cours d'utilisation par l'application */ protected ObserveSwingDataSource previousSource; @@ -138,6 +143,29 @@ public class AdminUIModel extends WizardExtModel<AdminStep> { private final PropertyChangeListener listenSaveLocalChanged; private final PropertyChangeListener listenReferentialConfigChanged; + private String localSourceLabel = t("observe.storage.config.source.storage"); + private String centralSourceLabel = t("observe.storage.config.referentiel.storage"); + + public String getLocalSourceLabel() { + return localSourceLabel; + } + + public void setLocalSourceLabel(String localSourceLabel) { + Object oldValue = getLocalSourceLabel(); + this.localSourceLabel = localSourceLabel; + firePropertyChange(PROPERTY_LOCAL_SOURCE_LABEL, oldValue, localSourceLabel); + } + + public String getCentralSourceLabel() { + return centralSourceLabel; + } + + public void setCentralSourceLabel(String centralSourceLabel) { + Object oldValue = getCentralSourceLabel(); + this.centralSourceLabel = centralSourceLabel; + firePropertyChange(PROPERTY_CENTRAL_SOURCE_LABEL, oldValue, centralSourceLabel); + } + public AdminUIModel() { super(AdminStep.class); @@ -145,7 +173,12 @@ public class AdminUIModel extends WizardExtModel<AdminStep> { @Override public String getLabel() { - String txt = n("observe.storage.label.synchro.incoming"); + String txt; + if (containsOperation(AdminStep.REFERENTIAL_SYNCHRONIZE)) { + txt = n("observe.storage.label.synchro.leftSource"); + } else { + txt = n("observe.storage.label.synchro.incoming"); + } String params; if (getDbMode() == DbMode.USE_SERVER) { @@ -175,7 +208,11 @@ public class AdminUIModel extends WizardExtModel<AdminStep> { public String getLabel() { String txt; String params; - txt = n("observe.storage.label.synchro.referentiel"); + if (containsOperation(AdminStep.REFERENTIAL_SYNCHRONIZE)) { + txt = n("observe.storage.label.synchro.rightSource"); + } else { + txt = n("observe.storage.label.synchro.referentiel"); + } if (getDbMode() == DbMode.CREATE_LOCAL) { params = getH2Config().getDirectory().getAbsolutePath(); } else { @@ -256,6 +293,13 @@ public class AdminUIModel extends WizardExtModel<AdminStep> { // on repasse sur l'écran de configuration + if (containsOperation(AdminStep.REFERENTIAL_SYNCHRONIZE) || containsOperation(AdminStep.DATA_SYNCHRONIZE)) { + + setLocalSourceLabel(t("observe.storage.config.left.storage")); + setCentralSourceLabel(t("observe.storage.config.right.storage")); + + } + return; } @@ -265,40 +309,48 @@ public class AdminUIModel extends WizardExtModel<AdminStep> { return; } - if (AdminStep.CONFIG == oldStep && AdminStep.DATA_SYNCHRONIZE == newStep) { + if (AdminStep.CONFIG == oldStep) { - // On lance le chargement de la sélection des arbres + if (AdminStep.DATA_SYNCHRONIZE == newStep) { - DataSynchroModel stepModel = getDataSynchroModel(); + setBusy(true); - ObserveSwingDataSource leftSource = getSafeLocalSource(true); - stepModel.setLeftSource(leftSource); + try { - ObserveSwingDataSource rightSource = getSafeCentralSource(true); - stepModel.setRightSource(rightSource); + //FIXME-release Supprimer ce code et remettre le code dans AdminUIHandler qui fait ça en lazy + initSynchroDataUI(); - return; + } finally { + setBusy(false); + } - } + return; - if (AdminStep.CONFIG == oldStep && AdminStep.REFERENTIAL_SYNCHRONIZE == newStep) { + } - // On lance le chargement de la sélection des arbres + if (AdminStep.REFERENTIAL_SYNCHRONIZE == newStep) { - ReferentialSynchroModel stepModel = getReferentialSynchroModel(); + setBusy(true); - ObserveSwingDataSource leftSource = getSafeLocalSource(true); - stepModel.setLeftSource(leftSource); + try { - ObserveSwingDataSource rightSource = getSafeCentralSource(true); - stepModel.setRightSource(rightSource); + //FIXME-release Supprimer ce code et remettre le code dans AdminUIHandler qui fait ça en lazy + initSynchroReferentialUI(); - stepModel.populateTreeModels(); + } finally { + + setBusy(false); + + } - return; + + return; + + } } + // on était sur l'écran de configuration // mise à jour des modèles de sélection si on arrive sur une étape @@ -414,6 +466,32 @@ public class AdminUIModel extends WizardExtModel<AdminStep> { }; } + public void initSynchroDataUI() { + + DataSynchroModel stepModel = getDataSynchroModel(); + + ObserveSwingDataSource leftSource = getSafeLocalSource(true); + stepModel.setLeftSource(leftSource); + + ObserveSwingDataSource rightSource = getSafeCentralSource(true); + stepModel.setRightSource(rightSource); + + } + + public void initSynchroReferentialUI() { + + ReferentialSynchroModel stepModel = getReferentialSynchroModel(); + + ObserveSwingDataSource leftSource = getSafeLocalSource(true); + stepModel.setLeftSource(leftSource); + + ObserveSwingDataSource rightSource = getSafeCentralSource(true); + stepModel.setRightSource(rightSource); + + stepModel.populateTreeModels(); + + } + public DataSelectionModel getSelectionDataModel() { return selectionDataModel; } @@ -621,14 +699,32 @@ public class AdminUIModel extends WizardExtModel<AdminStep> { if (containsOperation(AdminStep.DATA_SYNCHRONIZE)) { - //TODO ? + ConfigUI configUI = (ConfigUI) ui.getStepUI(AdminStep.CONFIG); + + configUI.getLocalSourceConfig().setBorder(new TitledBorder(getLocalSourceLabel())); + configUI.getCentralSourceConfig().setBorder(new TitledBorder(getCentralSourceLabel())); } if (containsOperation(AdminStep.REFERENTIAL_SYNCHRONIZE)) { + //FIXME Remove this after tests + getCentralSourceModel().setRemotePassword('a'); + getReferentialSynchroModel().removePropertyChangeListener(listenReferentialConfigChanged); getReferentialSynchroModel().addPropertyChangeListener(listenReferentialConfigChanged); + getReferentialSynchroModel().addPropertyChangeListener(ReferentialSynchroModel.SYNCHRONIZE_MODE_PROPERTY_NAME, evt -> { + + ReferentialSynchronizeMode newValue = (ReferentialSynchronizeMode) evt.getNewValue(); + + if (ui.getTabs().getComponentCount() > 1 && newValue != null) { + ui.getTabs().setTitleAt(1, t("observe.actions.synchro.referential.withMode", newValue.getLabel())); + } + + }); + + getReferentialSynchroModel().setSynchronizeMode(ReferentialSynchronizeMode.FROM_LEFT_TO_RIGHT); + } // on ecoute les modifications d'étapes pour remplir les modèles de sélection diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/config/ConfigUI.jcss b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/config/ConfigUI.jcss index 44d14bb..eb46511 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/config/ConfigUI.jcss +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/config/ConfigUI.jcss @@ -85,7 +85,7 @@ } #localSourceConfig { - border:{new TitledBorder(t("observe.storage.config.source.storage"))}; + border:{new TitledBorder(model.getLocalSourceLabel())}; visible:{model.isNeedIncomingDataSource()}; } @@ -97,27 +97,20 @@ #configureLocalSource { text:"observe.action.configure"; actionIcon:"config"; + mnemonic:"C"; } #localSourceStatus { icon:{(Icon) getClientProperty(localSourceModel.isValid() ? "successIcon" : "failedIcon")}; - /*icon:{(Icon) getClientProperty(localSourceModel.isValidStep() ? "successIcon" : "failedIcon")};*/ } #localSourcePolicy { text:{getHandler().updateDataSourcePolicy(localSourceModel, localSourceModel.isValid())} } -/*#localSourceInfoLabel { - actionIcon:"information"; - text:"observe.action.config.export.required.read.referentiel"; - visible:{getHandler().isOperationSelected(model.getOperations(), EXPORT_DATA)}; -}*/ - #centralSourceConfig { visible:{model.isNeedReferentielDataSource()}; - /*visible:{getHandler().isNeedReferentiel(model.getOperations())};*/ - border:{new TitledBorder(t("observe.storage.config.referentiel.storage"))}; + border:{new TitledBorder(model.getCentralSourceLabel())}; } #centralSourceLabel { @@ -128,6 +121,8 @@ #configureCentralSource { text:"observe.action.configure"; actionIcon:"config"; + mnemonic:"o"; + } #centralSourceStatus { diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/config/ConfigUIHandler.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/config/ConfigUIHandler.java index 2f66b60..41499aa 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/config/ConfigUIHandler.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/config/ConfigUIHandler.java @@ -137,14 +137,9 @@ public class ConfigUIHandler extends AdminTabUIHandler { public void obtainIncomingConnexion() { StorageUIModel sourceModel = ui.getLocalSourceModel(); - StorageUILauncher.obtainConnexion( - ui, - ui.getParentContainer(Window.class), - sourceModel - ); + StorageUILauncher.obtainConnexion(ui, ui.getParentContainer(Window.class), sourceModel); if (log.isDebugEnabled()) { - log.debug("After modifiy source model isValid : " + - sourceModel.isValid() + " / " + sourceModel.isValidStep()); + log.debug("After modifiy source model isValid : " + sourceModel.isValid() + " / " + sourceModel.isValidStep()); } model.removeLocalSource(); model.getLocalSourceModel().validate(); @@ -152,13 +147,11 @@ public class ConfigUIHandler extends AdminTabUIHandler { } public void obtainRemoteConnexion() { + if (log.isInfoEnabled()) { + log.info("start obtain remote connexion"); + } StorageUIModel sourceModel = ui.getCentralSourceModel(); - StorageUILauncher.obtainConnexion( - ui, - ui.getParentContainer(Window.class), - sourceModel - ); - + StorageUILauncher.obtainConnexion(ui, ui.getParentContainer(Window.class), sourceModel); model.removeCentralSource(); model.getCentralSourceModel().validate(StorageStep.CONFIG); model.validate(); diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroUIHandler.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroUIHandler.java index c44d9fb..36e1fa4 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroUIHandler.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/data/DataSynchroUIHandler.java @@ -12,9 +12,11 @@ import fr.ird.observe.services.service.actions.synchro.data.DataSynchronizeServi 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.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.data.task.CopyToLeftDataSynchronizeTask; import fr.ird.observe.ui.admin.synchronize.data.task.CopyToRightDataSynchronizeTask; import fr.ird.observe.ui.admin.synchronize.data.task.DataSynchronizeTaskSupport; @@ -101,6 +103,10 @@ public class DataSynchroUIHandler extends AdminTabUIHandler { stepModel.populateLeftSelectionModel(); updateSelectionModel(tabUI, tabUI.getLeftTreeHelper(), tabUI.getLeftTree(), dataSource, stepModel.getLeftSelectionDataModel(), tabUI.getLeftSelectionModel()); sendMessage(t("observe.actions.synchro.referential.message.data.leftData.loaded")); + + ConfigUI configUI = (ConfigUI) parentUI.getStepUI(AdminStep.CONFIG); + configUI.getLocalSourceConfig().setBorder(new TitledBorder(getModel().getLocalSourceLabel())); + }); getStepModel().addPropertyChangeListener(DataSynchroModel.RIGHT_SOURCE_PROPERTY_NAME, evt -> { @@ -113,6 +119,9 @@ public class DataSynchroUIHandler extends AdminTabUIHandler { updateSelectionModel(tabUI, tabUI.getRightTreeHelper(), tabUI.getRightTree(), dataSource, stepModel.getRightSelectionDataModel(), tabUI.getRightSelectionModel()); sendMessage(t("observe.actions.synchro.referential.message.data.rightData.loaded")); + ConfigUI configUI = (ConfigUI) parentUI.getStepUI(AdminStep.CONFIG); + configUI.getCentralSourceConfig().setBorder(new TitledBorder(getModel().getCentralSourceLabel())); + }); } diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/SynchronizeModel.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/SynchronizeModel.java index 6314771..883ba83 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/SynchronizeModel.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/SynchronizeModel.java @@ -41,21 +41,18 @@ import java.util.List; */ public class SynchronizeModel extends AdminActionModel { + private final JaxxDefaultListModel<ObsoleteReferentialReference> obsoleteReferences = new JaxxDefaultListModel<>(); + private final DefaultListSelectionModel obsoleteReferencesSelectionModel = new DefaultListSelectionModel(); /** data source we want to synchronize. */ protected ObserveSwingDataSource source; - /** data source which contains central referentiel. */ protected ObserveSwingDataSource centralSource; - /** Le resultat de la synchronisation des référentiels. */ private UnidirectionalReferentialSynchronizeResult referentialSynchronizeResult; private UnidirectionalReferentialSynchronizeEngine engine; private UnidirectionalReferentialSynchronizeContext referentialSynchronizeContext; private UnidirectionalReferentialSynchronizeCallbackResults referentialSynchronizeCallbackResults; - private final JaxxDefaultListModel<ObsoleteReferentialReference> obsoleteReferences = new JaxxDefaultListModel<>(); - private final DefaultListSelectionModel obsoleteReferencesSelectionModel = new DefaultListSelectionModel(); - public SynchronizeModel() { super(AdminStep.SYNCHRONIZE); } @@ -84,22 +81,22 @@ public class SynchronizeModel extends AdminActionModel { this.referentialSynchronizeResult = referentialSynchronizeResult; } - public void setEngine(UnidirectionalReferentialSynchronizeEngine engine) { - this.engine = engine; - } - public UnidirectionalReferentialSynchronizeEngine getEngine() { return engine; } - public void setReferentialSynchronizeContext(UnidirectionalReferentialSynchronizeContext referentialSynchronizeContext) { - this.referentialSynchronizeContext = referentialSynchronizeContext; + public void setEngine(UnidirectionalReferentialSynchronizeEngine engine) { + this.engine = engine; } public UnidirectionalReferentialSynchronizeContext getReferentialSynchronizeContext() { return referentialSynchronizeContext; } + public void setReferentialSynchronizeContext(UnidirectionalReferentialSynchronizeContext referentialSynchronizeContext) { + this.referentialSynchronizeContext = referentialSynchronizeContext; + } + public UnidirectionalReferentialSynchronizeCallbackResults getReferentialSynchronizeCallbackResults() { return referentialSynchronizeCallbackResults; } @@ -112,6 +109,10 @@ public class SynchronizeModel extends AdminActionModel { return obsoleteReferences; } + public void setObsoleteReferences(List<ObsoleteReferentialReference> obsoleteReferences) { + this.obsoleteReferences.setAllElements(obsoleteReferences); + } + public DefaultListSelectionModel getObsoleteReferencesSelectionModel() { return obsoleteReferencesSelectionModel; } @@ -120,8 +121,4 @@ public class SynchronizeModel extends AdminActionModel { obsoleteReferencesSelectionModel.clearSelection(); obsoleteReferences.clear(); } - - public void setObsoleteReferences(List<ObsoleteReferentialReference> obsoleteReferences) { - this.obsoleteReferences.setAllElements(obsoleteReferences); - } } diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/SynchronizeUIHandler.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/SynchronizeUIHandler.java index ff76fb5..d09f583 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/SynchronizeUIHandler.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/legacy/SynchronizeUIHandler.java @@ -22,6 +22,7 @@ package fr.ird.observe.ui.admin.synchronize.referential.legacy; import com.google.common.collect.ImmutableSet; +import fr.ird.observe.application.swing.decoration.decorators.ReferentialReferenceDecorator; import fr.ird.observe.db.ObserveSwingDataSource; import fr.ird.observe.services.dto.referential.ReferentialReference; import fr.ird.observe.services.service.actions.synchro.referential.legacy.UnidirectionalReferentialSynchronizeCallbackRequest; @@ -33,7 +34,6 @@ import fr.ird.observe.services.service.actions.synchro.referential.legacy.Unidir import fr.ird.observe.ui.admin.AdminStep; import fr.ird.observe.ui.admin.AdminTabUIHandler; import fr.ird.observe.ui.admin.AdminUI; -import fr.ird.observe.application.swing.decoration.decorators.ReferentialReferenceDecorator; import jaxx.runtime.swing.CardLayout2; import jaxx.runtime.swing.editor.bean.BeanComboBox; import jaxx.runtime.swing.model.JaxxDefaultListModel; diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialReplaceUI.jaxx b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialReplaceUI.jaxx new file mode 100644 index 0000000..f371b86 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialReplaceUI.jaxx @@ -0,0 +1,29 @@ +<JPanel id="panel" genericType='E extends ReferentialDto'> + + <import> + fr.ird.observe.services.dto.referential.ReferentialDto + fr.ird.observe.services.dto.referential.ReferentialReference + + jaxx.runtime.swing.editor.bean.BeanComboBox + + </import> + + <ReferentialReference id='referenceToReplace' genericType="E" + initializer="getContextValue(ReferentialReference.class)"/> + <ReferentialReference id='replaceReference' genericType="E" javaBean="null"/> + + <ReferentialReplaceUIHandler id='handler' genericType="E" constructorParams="this"/> + + <script><![CDATA[ + +void $afterCompleteSetup() { + handler.init(); +} +]]> + </script> + + <JLabel id='message' constraints='BorderLayout.NORTH'/> + <BeanComboBox id='list' constraints='BorderLayout.CENTER' constructorParams='this' + genericType='ReferentialReference<E>'/> + +</JPanel> \ No newline at end of file diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialReplaceUI.jcss b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialReplaceUI.jcss new file mode 100644 index 0000000..eb77c98 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialReplaceUI.jcss @@ -0,0 +1,9 @@ +#panel{ + layout:{new BorderLayout()}; + +} + +#list { + bean: {this}; + property:replaceReference; +} \ No newline at end of file diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialReplaceUIHandler.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialReplaceUIHandler.java new file mode 100644 index 0000000..661ba8f --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialReplaceUIHandler.java @@ -0,0 +1,41 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng; + +import com.google.common.collect.Lists; +import fr.ird.observe.ObserveSwingApplicationContext; +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 jaxx.runtime.swing.editor.bean.BeanComboBox; + +import java.awt.Dimension; +import java.beans.PropertyChangeListener; + +/** + * Created on 11/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferentialReplaceUIHandler<R extends ReferentialDto> { + + private final ReferentialReplaceUI<R> ui; + protected PropertyChangeListener listenData; + + public ReferentialReplaceUIHandler(ReferentialReplaceUI<R> ui) { + this.ui = ui; + this.listenData = evt -> ui.setReplaceReference((ReferentialReference) evt.getNewValue()); + } + + public void init() { + BeanComboBox<ReferentialReference<R>> beanComboBox = ui.getList(); + //beanComboBox.removePropertyChangeListener(BeanComboBox.PROPERTY_DATA, listenData); + //beanComboBox.addPropertyChangeListener(BeanComboBox.PROPERTY_DATA, listenData); + + ReferentialReferenceSet<R> referenceSet = ui.getContextValue(ReferentialReferenceSet.class); + beanComboBox.setI18nPrefix("observe.common."); + beanComboBox.setMinimumSize(new Dimension(0, 24)); + beanComboBox.setBeanType((Class) ReferentialReference.class); + beanComboBox.init(ObserveSwingApplicationContext.get().getDecoratorService().getReferentialReferenceDecorator(referenceSet.getType()), + Lists.newArrayList(referenceSet.getReferences())); + } + +} 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 index fa32d20..da64f4b 100644 --- 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 @@ -2,15 +2,16 @@ 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.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffService; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffsEngine; 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 fr.ird.observe.ui.admin.synchronize.referential.ng.tree.ReferentialSynchronizeTreeModelsBuilder; 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; /** @@ -21,37 +22,49 @@ import java.util.Objects; */ 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 **/ + public static final String COPY_RIGHT_PROPERTY_NAME = "copyRight"; + public static final String COPY_LEFT_PROPERTY_NAME = "copyLeft"; + public static final String SKIP_RIGHT_PROPERTY_NAME = "skipRight"; + public static final String SKIP_LEFT_PROPERTY_NAME = "skipLeft"; + public static final String DELETE_RIGHT_PROPERTY_NAME = "deleteRight"; + public static final String DELETE_LEFT_PROPERTY_NAME = "deleteLeft"; + public static final String DESACTIVATE_RIGHT_PROPERTY_NAME = "desactivateRight"; + public static final String DESACTIVATE_LEFT_PROPERTY_NAME = "desactivateLeft"; + public static final String DESACTIVATE_WITH_REPLACE_RIGHT_PROPERTY_NAME = "desactivateWithReplaceRight"; + public static final String DESACTIVATE_WITH_REPLACE_LEFT_PROPERTY_NAME = "desactivateWithReplaceLeft"; + public static final String REVERT_RIGHT_PROPERTY_NAME = "revertRight"; + public static final String REVERT_LEFT_PROPERTY_NAME = "revertLeft"; + /** Logger. */ + private static final Log log = LogFactory.getLog(ReferentialSynchroModel.class); + private final ReferentialSynchronizeTaskListModel tasks; + private ObserveSwingDataSource leftSource; + private ObserveSwingDataSource rightSource; private ReferentialSynchronizeMode synchronizeMode; - private ReferentialSynchronizeTreeModel leftTreeModel; - private ReferentialSynchronizeTreeModel rightTreeModel; - - private final DefaultListModel<ReferentialSynchronizeTaskSupport> tasks; + private ReferentialSynchronizeDiffsEngine engine; + private boolean copyLeft; + private boolean revertLeft; + private boolean skipLeft; + private boolean deleteLeft; + private boolean desactivateLeft; + private boolean desactivateWithReplaceLeft; + private boolean copyRight; + private boolean revertRight; + private boolean skipRight; + private boolean deleteRight; + private boolean desactivateRight; + private boolean desactivateWithReplaceRight; public ReferentialSynchroModel() { super(AdminStep.REFERENTIAL_SYNCHRONIZE); - this.tasks = new DefaultListModel<>(); + this.tasks = new ReferentialSynchronizeTaskListModel(); } public ReferentialSynchronizeMode getSynchronizeMode() { @@ -102,22 +115,141 @@ public class ReferentialSynchroModel extends AdminActionModel { firePropertyChange(RIGHT_TREE_MODEL_PROPERTY_NAME, oldValue, rightTreeModel); } - public DefaultListModel<ReferentialSynchronizeTaskSupport> getTasks() { + public ReferentialSynchronizeTaskListModel getTasks() { return tasks; } - public void addTask(ReferentialSynchronizeTaskSupport task) { - tasks.addElement(task); + public ReferentialSynchronizeDiffsEngine getEngine() { + return engine; } public void populateTreeModels() { Objects.nonNull(leftSource); Objects.nonNull(rightSource); + Objects.nonNull(synchronizeMode); + + ReferentialSynchronizeDiffService leftDiffSynchronizeService = leftSource.newReferentialSynchronizeDiffService(); + ReferentialSynchronizeDiffService rightDiffSynchronizeService = rightSource.newReferentialSynchronizeDiffService(); - Pair<ReferentialSynchronizeTreeModel, ReferentialSynchronizeTreeModel> treePair = ReferentialSynchronizeTreeModel.buildTreeModels(this); + engine = new ReferentialSynchronizeDiffsEngine(leftDiffSynchronizeService, rightDiffSynchronizeService); + + ReferentialSynchronizeTreeModelsBuilder treeModelsBuilder = new ReferentialSynchronizeTreeModelsBuilder(getSynchronizeMode(), engine); + Pair<ReferentialSynchronizeTreeModel, ReferentialSynchronizeTreeModel> treePair = treeModelsBuilder.build(); setLeftTreeModel(treePair.getLeft()); setRightTreeModel(treePair.getRight()); + tasks.removeAllElements(); + + } + + public boolean isCopyRight() { + return copyRight; + } + + public void setCopyRight(boolean copyRight) { + this.copyRight = copyRight; + firePropertyChange(COPY_RIGHT_PROPERTY_NAME, copyRight); + } + + public boolean isCopyLeft() { + return copyLeft; + } + + public void setCopyLeft(boolean copyLeft) { + this.copyLeft = copyLeft; + firePropertyChange(COPY_LEFT_PROPERTY_NAME, copyLeft); + } + + public boolean isRevertRight() { + return revertRight; + } + + public void setRevertRight(boolean revertRight) { + this.revertRight = revertRight; + firePropertyChange(REVERT_RIGHT_PROPERTY_NAME, revertRight); + } + + public boolean isRevertLeft() { + return revertLeft; + } + + public void setRevertLeft(boolean revertLeft) { + this.revertLeft = revertLeft; + firePropertyChange(REVERT_LEFT_PROPERTY_NAME, revertLeft); + } + + public boolean isSkipLeft() { + return skipLeft; } + + public void setSkipLeft(boolean skipLeft) { + this.skipLeft = skipLeft; + firePropertyChange(SKIP_LEFT_PROPERTY_NAME, skipLeft); + } + + public boolean isSkipRight() { + return skipRight; + } + + public void setSkipRight(boolean skipRight) { + this.skipRight = skipRight; + firePropertyChange(SKIP_RIGHT_PROPERTY_NAME, skipRight); + } + + public boolean isDeleteLeft() { + return deleteLeft; + } + + public void setDeleteLeft(boolean deleteLeft) { + this.deleteLeft = deleteLeft; + firePropertyChange(DELETE_LEFT_PROPERTY_NAME, deleteLeft); + } + + public boolean isDeleteRight() { + return deleteRight; + } + + public void setDeleteRight(boolean deleteRight) { + this.deleteRight = deleteRight; + firePropertyChange(DELETE_RIGHT_PROPERTY_NAME, deleteRight); + } + + public boolean isDesactivateRight() { + return desactivateRight; + } + + public void setDesactivateRight(boolean desactivateRight) { + this.desactivateRight = desactivateRight; + firePropertyChange(DESACTIVATE_RIGHT_PROPERTY_NAME, desactivateRight); + } + + public boolean isDesactivateLeft() { + return desactivateLeft; + } + + public void setDesactivateLeft(boolean desactivateLeft) { + this.desactivateLeft = desactivateLeft; + firePropertyChange(DESACTIVATE_LEFT_PROPERTY_NAME, desactivateLeft); + } + + public boolean isDesactivateWithReplaceRight() { + return desactivateWithReplaceRight; + } + + public void setDesactivateWithReplaceRight(boolean desactivateWithReplaceRight) { + this.desactivateWithReplaceRight = desactivateWithReplaceRight; + firePropertyChange(DESACTIVATE_WITH_REPLACE_RIGHT_PROPERTY_NAME, desactivateWithReplaceRight); + } + + public boolean isDesactivateWithReplaceLeft() { + return desactivateWithReplaceLeft; + } + + public void setDesactivateWithReplaceLeft(boolean desactivateWithReplaceLeft) { + this.desactivateWithReplaceLeft = desactivateWithReplaceLeft; + firePropertyChange(DESACTIVATE_WITH_REPLACE_LEFT_PROPERTY_NAME, desactivateWithReplaceLeft); + } + + } \ No newline at end of file diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroUI.jaxx b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroUI.jaxx index 8429a6c..850c655 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroUI.jaxx +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchroUI.jaxx @@ -30,14 +30,19 @@ 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.action.ApplyAction + fr.ird.observe.ui.admin.synchronize.referential.ng.action.RegisterCopyTaskAction + fr.ird.observe.ui.admin.synchronize.referential.ng.action.RegisterDeleteTaskAction + fr.ird.observe.ui.admin.synchronize.referential.ng.action.RegisterDesactivateTaskAction + fr.ird.observe.ui.admin.synchronize.referential.ng.action.RegisterRevertTaskAction + fr.ird.observe.ui.admin.synchronize.referential.ng.action.RegisterSkipTaskAction 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 - jaxx.runtime.SwingUtil - javax.swing.ListSelectionModel - javax.swing.tree.TreeSelectionModel + + static org.nuiton.i18n.I18n.t; </import> @@ -46,7 +51,7 @@ <ReferentialSynchroUIHandler id='handler' constructorParams='this'/> - <ReferentialSynchroModel id='stepModel' initializer='getModel().getReferentialSynchroModel()'/> + <ReferentialSynchroModel id='stepModel' javaBean='getModel().getReferentialSynchroModel()'/> <ReferentialSynchronizeTreeModel id="leftTreeModel" javaBean="getStepModel().getLeftTreeModel()"/> <ReferentialSynchronizeTreeModel id="rightTreeModel" javaBean="getStepModel().getRightTreeModel()"/> @@ -76,34 +81,31 @@ public void destroy() { <JSplitPane id="contentSplitPane" constraints='BorderLayout.CENTER'> <Table id='contentNorth' fill="both" weighty="1"> <row> - <cell weightx="0.45"> - <JScrollPane id='leftTreePane' decorator='boxed'> + <cell weightx="0.5"> + <JScrollPane id='leftTreePane'> <JTree id='leftTree'/> </JScrollPane> </cell> - <cell weightx="0.1"> - <JPanel layout="{new BorderLayout()}" border='{new TitledBorder(" ")}'> - <JPanel id="middleActions" layout="{new GridLayout(0, 2)}" constraints='BorderLayout.CENTER'> - <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> + <cell> + <JPanel layout="{new BorderLayout()}" border='{new TitledBorder("")}'> + <JToolBar id="middleActions" layout="{new GridLayout(0, 2)}" constraints='BorderLayout.CENTER'> + <JButton id="copyLeft" opaque="true"/> + <JButton id="copyRight" opaque="true"/> + <JButton id="revertLeft" opaque="true"/> + <JButton id="revertRight" opaque="true"/> + <JButton id="desactivateLeft" opaque="false"/> + <JButton id="desactivateRight" opaque="false"/> + <JButton id="desactivateWithReplaceLeft" opaque="false"/> + <JButton id="desactivateWithReplaceRight" opaque="false"/> + <JButton id="deleteLeft" opaque="false"/> + <JButton id="deleteRight" opaque="false"/> + <JButton id="skipLeft" opaque="false"/> + <JButton id="skipRight" opaque="false"/> + </JToolBar> </JPanel> </cell> - <cell weightx="0.45"> - <JScrollPane id='rightTreePane' decorator='boxed'> + <cell weightx="0.5"> + <JScrollPane id='rightTreePane'> <JTree id='rightTree'/> </JScrollPane> </cell> @@ -120,8 +122,7 @@ public void destroy() { <row> <cell> <JPanel layout="{new BorderLayout()}"> - <JButton id='applyAction' constraints='BorderLayout.CENTER' - onActionPerformed='getHandler().doExecuteAction()'/> + <JButton id='applyAction' constraints='BorderLayout.CENTER'/> </JPanel> </cell> </row> 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 index 377ac0c..c2aefae 100644 --- 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 @@ -30,8 +30,7 @@ } #applyAction { - actionIcon:accept; - text:"observe.action.apply"; + action: {new ApplyAction(this)}; } #leftTree { @@ -39,10 +38,10 @@ largeModel:true; minimumSize:{UIHelper.newMinDimension()}; font-size:11; - showsRootHandles:false; + /*showsRootHandles:false;*/ toggleClickCount:100; - model:{getLeftTreeModel()}; - selectionModel:{getLeftTreeModel()}; + /*model:{getLeftTreeModel()}; + selectionModel:{getStepModel().getLeftTreeModel()};*/ cellRenderer:{new ReferentialSynchronizeTreeCellRenderer()}; } @@ -55,10 +54,10 @@ largeModel:true; minimumSize:{UIHelper.newMinDimension()}; font-size:11; - showsRootHandles:false; + /*showsRootHandles:false;*/ toggleClickCount:100; - model:{getRightTreeModel()}; - selectionModel:{getRightTreeModel()}; + /*model:{getRightTreeModel()}; + selectionModel:{getStepModel().getRightTreeModel()};*/ cellRenderer:{new ReferentialSynchronizeTreeCellRenderer()}; } @@ -67,75 +66,61 @@ } #copyLeft { - actionIcon:copyToLeft; - toolTipText:"observe.actions.synchro.referential.copyToLeft.tip"; - enabled:false; + action: {new RegisterCopyTaskAction(this, true)}; + visible:{stepModel.getSynchronizeMode().isRightWrite()}; } #copyRight { - actionIcon:copyToRight; - toolTipText:"observe.actions.synchro.referential.copyToRight.tip"; - enabled:false; + action: {new RegisterCopyTaskAction(this, false)}; + visible:{stepModel.getSynchronizeMode().isLeftWrite()}; } #revertLeft { - actionIcon:revertToLeft; - toolTipText:"observe.actions.synchro.referential.revertToLeft.tip"; - enabled:false; + action: {new RegisterRevertTaskAction(this, true)}; + visible:{stepModel.getSynchronizeMode().isLeftWrite()}; } #revertRight { - actionIcon:revertToRight; - toolTipText:"observe.actions.synchro.referential.revertToRight.tip"; - enabled:false; + action: {new RegisterRevertTaskAction(this, false)}; + visible:{stepModel.getSynchronizeMode().isRightWrite()}; } #skipLeft { - actionIcon:skipToLeft; - toolTipText:"observe.actions.synchro.referential.skipToLeft.tip"; - enabled:false; + action: {new RegisterSkipTaskAction(this, true)}; } #skipRight { - actionIcon:skipToRight; - toolTipText:"observe.actions.synchro.referential.skipToRight.tip"; - enabled:false; + action: {new RegisterSkipTaskAction(this, false)}; } #deleteLeft { - actionIcon:deleteFromLeft; - toolTipText:"observe.actions.synchro.referential.deleteFromLeft.tip"; - enabled:false; + action: {new RegisterDeleteTaskAction(this, true)}; + visible:{stepModel.getSynchronizeMode().isLeftWrite()}; } #deleteRight { - actionIcon:deleteFromRight; - toolTipText:"observe.actions.synchro.referential.deleteFromRight.tip"; - enabled:false; + action: {new RegisterDeleteTaskAction(this, false)}; + visible:{stepModel.getSynchronizeMode().isRightWrite()}; } #desactivateLeft { - actionIcon:desactivateFromLeft; - toolTipText:"observe.actions.synchro.referential.desactivateFromLeft.tip"; - enabled:false; + action: {new RegisterDesactivateTaskAction(this, true, false)}; + visible:{stepModel.getSynchronizeMode().isLeftWrite()}; } #desactivateRight { - actionIcon:desactivateFromRight; - toolTipText:"observe.actions.synchro.referential.desactivateFromRight.tip"; - enabled:false; + action: {new RegisterDesactivateTaskAction(this, false, false)}; + visible:{stepModel.getSynchronizeMode().isRightWrite()}; } -#desactivateLeftWithReplace { - actionIcon:desactivateFromLeftWithReplace; - toolTipText:"observe.actions.synchro.referential.desactivateFromLeftWithReplace.tip"; - enabled:false; +#desactivateWithReplaceLeft { + action: {new RegisterDesactivateTaskAction(this, true, true)}; + visible:{stepModel.getSynchronizeMode().isLeftWrite()}; } -#desactivateRightWithReplace { - actionIcon:desactivateFromRightWithReplace; - toolTipText:"observe.actions.synchro.referential.desactivateFromRightWithReplace.tip"; - enabled:false; +#desactivateWithReplaceRight { + action: {new RegisterDesactivateTaskAction(this, false, true)}; + visible:{stepModel.getSynchronizeMode().isRightWrite()}; } #actionsToConsumePane { @@ -146,5 +131,5 @@ #actionsToConsume { selectionMode:{ListSelectionModel.SINGLE_SELECTION}; cellRenderer:{new ReferentialSynchronizeTaskListCellRenderer()}; - model:{getStepModel().getTasks()}; + model:{stepModel.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 index b5d652e..2d2ffd2 100644 --- 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 @@ -1,41 +1,22 @@ 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.services.service.actions.synchro.referential.ReferentialSynchronizeMode; 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 fr.ird.observe.ui.admin.synchronize.referential.ng.tree.ReferentialSynchronizeTreeModel; 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.JScrollPane; +import javax.swing.JTree; import javax.swing.border.TitledBorder; -import javax.swing.tree.TreeModel; +import javax.swing.event.TreeSelectionListener; +import java.awt.Color; +import java.beans.PropertyChangeListener; import static org.nuiton.i18n.I18n.t; @@ -50,8 +31,23 @@ public class ReferentialSynchroUIHandler extends AdminTabUIHandler { /** Logger */ private static final Log log = LogFactory.getLog(ReferentialSynchroUIHandler.class); + private final TreeSelectionListener treeSelectionListener; + private final PropertyChangeListener leftTreeModelChanged; + private final PropertyChangeListener rightTreeModelChanged; + public ReferentialSynchroUIHandler(ReferentialSynchroUI ui) { super(ui); + this.treeSelectionListener = evt -> updateEnabledActions(); + this.leftTreeModelChanged = evt -> initTree(ui.getLeftTree(), + ui.getLeftTreePane(), + (ReferentialSynchronizeTreeModel) evt.getNewValue(), + getModel().getLocalSourceModel().getLabel(), + t("observe.actions.synchro.referential.message.referential.leftData.loaded")); + this.rightTreeModelChanged = evt -> initTree(ui.getRightTree(), + ui.getRightTreePane(), + (ReferentialSynchronizeTreeModel) evt.getNewValue(), + getModel().getCentralSourceModel().getLabel(), + t("observe.actions.synchro.referential.message.referential.rightData.loaded")); } public ReferentialSynchroModel getStepModel() { @@ -63,11 +59,6 @@ public class ReferentialSynchroUIHandler extends AdminTabUIHandler { 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); @@ -76,31 +67,11 @@ public class ReferentialSynchroUIHandler extends AdminTabUIHandler { 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")); - - }); + getStepModel().removePropertyChangeListener(ReferentialSynchroModel.LEFT_TREE_MODEL_PROPERTY_NAME, leftTreeModelChanged); + getStepModel().addPropertyChangeListener(ReferentialSynchroModel.LEFT_TREE_MODEL_PROPERTY_NAME, leftTreeModelChanged); + getStepModel().removePropertyChangeListener(ReferentialSynchroModel.RIGHT_TREE_MODEL_PROPERTY_NAME, rightTreeModelChanged); + getStepModel().addPropertyChangeListener(ReferentialSynchroModel.RIGHT_TREE_MODEL_PROPERTY_NAME, rightTreeModelChanged); ConfigUI configUI = (ConfigUI) ui.getStepUI(AdminStep.CONFIG); JAXXInitialContext tx = new JAXXInitialContext().add(configUI).add(this); @@ -109,203 +80,78 @@ public class ReferentialSynchroUIHandler extends AdminTabUIHandler { } - 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() { - - } + private void updateEnabledActions() { - public void addDeleteLeftTasks() { + ReferentialSynchroModel stepModel = getStepModel(); -// DataSelectionModel selectionDataModel = getStepModel().getLeftSelectionDataModel(); -// ObserveTreeHelper treeHelper = getUi().getLeftTreeHelper(); -// Map<ReferentialReference<ProgramDto>, List<DataReference>> selectedDataByProgram = selectionDataModel.getSelectedDataByProgram(); -// selectionDataModel.removeAllSelectedData(); + updateLeftTreeEnableActions(stepModel.getLeftTreeModel()); + updateRightTreeEnableActions(stepModel.getRightTreeModel()); } - public void addDeleteRightTasks() { + private void updateLeftTreeEnableActions(ReferentialSynchronizeTreeModel treeModel) { -// DataSelectionModel selectionDataModel = getStepModel().getRightSelectionDataModel(); -// ObserveTreeHelper treeHelper = getUi().getRightTreeHelper(); -// Map<ReferentialReference<ProgramDto>, List<DataReference>> selectedDataByProgram = selectionDataModel.getSelectedDataByProgram(); -// selectionDataModel.removeAllSelectedData(); + ReferentialSynchroModel stepModel = getStepModel(); + treeModel.updateSelectedActions(); + stepModel.setCopyLeft(treeModel.isCanAdd() || treeModel.isCanUpdate()); + stepModel.setDeleteLeft(treeModel.isCanDelete()); + stepModel.setDesactivateLeft(treeModel.isCanDelete()); + stepModel.setDesactivateWithReplaceLeft(treeModel.isCanDelete()); + stepModel.setRevertLeft(treeModel.isCanRevert()); + stepModel.setSkipLeft(treeModel.isCanSkip()); } - public void addDesactivateLeftTasks() { - -// DataSelectionModel selectionDataModel = getStepModel().getLeftSelectionDataModel(); -// ObserveTreeHelper treeHelper = getUi().getLeftTreeHelper(); -// Map<ReferentialReference<ProgramDto>, List<DataReference>> selectedDataByProgram = selectionDataModel.getSelectedDataByProgram(); -// selectionDataModel.removeAllSelectedData(); + private void updateRightTreeEnableActions(ReferentialSynchronizeTreeModel treeModel) { - } - - public void addDesactivateLeftWithReplaceTasks() { + ReferentialSynchroModel stepModel = getStepModel(); -// DataSelectionModel selectionDataModel = getStepModel().getLeftSelectionDataModel(); -// ObserveTreeHelper treeHelper = getUi().getLeftTreeHelper(); -// Map<ReferentialReference<ProgramDto>, List<DataReference>> selectedDataByProgram = selectionDataModel.getSelectedDataByProgram(); -// selectionDataModel.removeAllSelectedData(); + treeModel.updateSelectedActions(); + stepModel.setCopyRight(treeModel.isCanAdd() || treeModel.isCanUpdate()); + stepModel.setDeleteRight(treeModel.isCanDelete()); + stepModel.setDesactivateRight(treeModel.isCanDelete()); + stepModel.setDesactivateWithReplaceRight(treeModel.isCanDelete()); + stepModel.setRevertRight(treeModel.isCanRevert()); + stepModel.setSkipRight(treeModel.isCanSkip()); } - 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; + private void initTree(JTree tree, JScrollPane treePane, ReferentialSynchronizeTreeModel treeModel, String title, String message) { - ObserveSwingDataSource rightSource = getStepModel().getRightSource(); - boolean rightSourceIsH2 = rightSource.getConfiguration() instanceof ObserveDataSourceConfigurationTopiaH2; + ReferentialSynchronizeMode newValue = getStepModel().getSynchronizeMode(); - DefaultListModel<ReferentialSynchronizeTaskSupport> tasks = getStepModel().getTasks(); - int size = tasks.size(); + Color color = + (treeModel.isLeft() && newValue.isLeftWrite() || !treeModel.isLeft() && newValue.isRightWrite()) ? + Color.BLACK : Color.RED; - DecoratorService decoratorService = getDecoratorService(); - ReferentialReferenceDecorator<ProgramDto> programDecorator = decoratorService.getReferentialReferenceDecorator(ProgramDto.class); + TitledBorder border = new TitledBorder(title); + border.setTitleColor(color); - ReferentialSynchronizeRequest.Builder leftReferentialSynchronizeRequestBuilder = ReferentialSynchronizeRequest.builder(leftSourceIsH2, rightSourceIsH2); - ReferentialSynchronizeRequest.Builder rightReferentialSynchronizeRequestBuilder = ReferentialSynchronizeRequest.builder(rightSourceIsH2, leftSourceIsH2); - for (int i = 0; i < size; i++) { + treePane.setBorder(border); + tree.setModel(treeModel); + tree.setSelectionModel(treeModel); - ReferentialSynchronizeTaskSupport<?> task = tasks.getElementAt(i); + treeModel.removeTreeSelectionListener(treeSelectionListener); + treeModel.addTreeSelectionListener(treeSelectionListener); - String typeStr = task.decorateType(); - String dataStr = task.decorateData(); + UIHelper.initUI(treePane, tree); + //UIHelper.expandTree(tree); - if (task instanceof DeleteFromLeftReferentialSynchronizeTask) { + sendMessage(message); - sendMessage(t("observe.actions.synchro.referential.prepare.deleteFromLeftTask", typeStr, dataStr)); - leftReferentialSynchronizeRequestBuilder.addDeleteTask(new ReferentialSynchronizeDeleteTask<>(task.getData())); - continue; - } + if (treeModel.isLeft()) { - 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)); - } + updateLeftTreeEnableActions(treeModel); + } else { + updateRightTreeEnableActions(treeModel); } - 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); + ConfigUI configUI = (ConfigUI) parentUI.getStepUI(AdminStep.CONFIG); + configUI.getLocalSourceConfig().setBorder(new TitledBorder(getModel().getLocalSourceLabel())); + configUI.getCentralSourceConfig().setBorder(new TitledBorder(getModel().getCentralSourceLabel())); } + } \ No newline at end of file diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchronizeResources.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchronizeResources.java new file mode 100644 index 0000000..a1c908f --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchronizeResources.java @@ -0,0 +1,147 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng; + +import fr.ird.observe.ui.UIHelper; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferenceReferentialSynchroNodeSupport; + +import javax.swing.Icon; +import java.util.function.Predicate; + +import static org.nuiton.i18n.I18n.n; + +/** + * Created on 12/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public enum ReferentialSynchronizeResources { + + ADD( + "copyToRight", + "copyToLeft", + n("observe.actions.synchro.referential.task.addToRight"), + n("observe.actions.synchro.referential.task.addToLeft"), + null, + null, + null, + null, + ReferenceReferentialSynchroNodeSupport::isCanAdd), + UPDATE( + "copyToRight", + "copyToLeft", + n("observe.actions.synchro.referential.task.updateToRight"), + n("observe.actions.synchro.referential.task.updateToLeft"), + null, + null, + null, + null, + ReferenceReferentialSynchroNodeSupport::isCanUpdate), + COPY( + "copyToRight", + "copyToLeft", + null, + null, + n("observe.actions.synchro.referential.action.copyToRight.tip"), + n("observe.actions.synchro.referential.action.copyToLeft.tip"), + ReferentialSynchroModel.COPY_LEFT_PROPERTY_NAME, + ReferentialSynchroModel.COPY_RIGHT_PROPERTY_NAME, + node -> false), + DELETE( + "deleteFromLeft", + "deleteFromRight", + n("observe.actions.synchro.referential.task.deleteFromLeft"), + n("observe.actions.synchro.referential.task.deleteFromRight"), + n("observe.actions.synchro.referential.action.deleteFromLeft.tip"), + n("observe.actions.synchro.referential.action.deleteFromRight.tip"), + ReferentialSynchroModel.DELETE_LEFT_PROPERTY_NAME, + ReferentialSynchroModel.DELETE_RIGHT_PROPERTY_NAME, + ReferenceReferentialSynchroNodeSupport::isCanDelete), + REVERT( + "revertFromLeft", + "revertFromRight", + n("observe.actions.synchro.referential.task.revertFromLeft"), + n("observe.actions.synchro.referential.task.revertFromRight"), + n("observe.actions.synchro.referential.action.revertFromLeft.tip"), + n("observe.actions.synchro.referential.action.revertFromRight.tip"), + ReferentialSynchroModel.REVERT_LEFT_PROPERTY_NAME, + ReferentialSynchroModel.REVERT_RIGHT_PROPERTY_NAME, + ReferenceReferentialSynchroNodeSupport::isCanRevert), + SKIP( + "skipFromLeft", + "skipFromRight", + n("observe.actions.synchro.referential.task.skipFromLeft"), + n("observe.actions.synchro.referential.task.skipFromRight"), + n("observe.actions.synchro.referential.action.skipFromLeft.tip"), + n("observe.actions.synchro.referential.action.skipFromRight.tip"), + ReferentialSynchroModel.SKIP_LEFT_PROPERTY_NAME, + ReferentialSynchroModel.SKIP_RIGHT_PROPERTY_NAME, + node -> true), + DESACTIVATE( + "desactivateFromLeft", + "desactivateFromRight", + n("observe.actions.synchro.referential.task.desactivateWithReplaceFromLeft"), + n("observe.actions.synchro.referential.task.desactivateWithReplaceFromRight"), + n("observe.actions.synchro.referential.action.desactivateFromLeft.tip"), + n("observe.actions.synchro.referential.action.desactivateFromRight.tip"), + ReferentialSynchroModel.DESACTIVATE_LEFT_PROPERTY_NAME, + ReferentialSynchroModel.DESACTIVATE_RIGHT_PROPERTY_NAME, + ReferenceReferentialSynchroNodeSupport::isCanDelete); + + private final String leftActionName; + private final String leftTaskI18nKey; + private final String rightActionName; + private final String leftActionTipI18nKey; + private final String rightTaskI18nKey; + private final String rightActionTipI18nKey; + private final String leftPropertyName; + private final String rightPropertyName; + private final Predicate<ReferenceReferentialSynchroNodeSupport> predicate; + private transient Icon actionIcon; + + ReferentialSynchronizeResources(String leftActionName, + String rightActionName, + String leftTaskI18nKey, + String rightTaskI18nKey, + String leftActionTipI18nKey, + String rightActionTipI18nKey, + String leftPropertyName, + String rightPropertyName, + Predicate<ReferenceReferentialSynchroNodeSupport> predicate) { + this.leftActionName = leftActionName; + this.rightActionName = rightActionName; + this.leftTaskI18nKey = leftTaskI18nKey; + this.rightTaskI18nKey = rightTaskI18nKey; + this.leftActionTipI18nKey = leftActionTipI18nKey; + this.rightActionTipI18nKey = rightActionTipI18nKey; + this.leftPropertyName = leftPropertyName; + this.rightPropertyName = rightPropertyName; + this.predicate = predicate; + } + + public Predicate<ReferenceReferentialSynchroNodeSupport> getPredicate() { + return predicate; + } + + public Icon getIcon(boolean left) { + if (actionIcon == null) { + actionIcon = UIHelper.getUIManagerActionIcon(left ? leftActionName : rightActionName); + } + return actionIcon; + } + + public String getTaskLabel(boolean left) { + return left ? leftTaskI18nKey : rightTaskI18nKey; + } + + public String getActionTip(boolean left) { + return left ? leftActionTipI18nKey : rightActionTipI18nKey; + } + + public String getActionName(boolean left) { + return left ? leftActionName : rightActionName; + } + + public String getPropertyName(boolean left) { + return left ? leftPropertyName : rightPropertyName; + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchronizeTaskListModel.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchronizeTaskListModel.java new file mode 100644 index 0000000..fa846d2 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSynchronizeTaskListModel.java @@ -0,0 +1,47 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng; + +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.ReferentialSynchronizeTaskSupport; + +import javax.swing.DefaultListModel; +import java.util.Collection; + +/** + * Created on 13/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class ReferentialSynchronizeTaskListModel extends DefaultListModel<ReferentialSynchronizeTaskSupport> { + + private static final long serialVersionUID = 1L; + + private boolean tasksIsAdjusting; + + + public void addTasks(Collection<ReferentialSynchronizeTaskSupport> addedTasks) { + + tasksIsAdjusting = true; + try { + int minIndex = size(); + int maxIndex = minIndex + addedTasks.size() - 1; + ensureCapacity(maxIndex); + + for (ReferentialSynchronizeTaskSupport addedTask : addedTasks) { + addElement(addedTask); + } + + super.fireIntervalAdded(this, minIndex, maxIndex); + } finally { + tasksIsAdjusting = false; + } + } + + @Override + protected void fireIntervalAdded(Object source, int index0, int index1) { + if (tasksIsAdjusting) { + return; + } + super.fireIntervalAdded(source, index0, index1); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/ApplyAction.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/ApplyAction.java new file mode 100644 index 0000000..ad2ae6f --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/ApplyAction.java @@ -0,0 +1,114 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.action; + +import fr.ird.observe.db.ObserveSwingDataSource; +import fr.ird.observe.services.configuration.ObserveDataSourceConfigurationTopiaH2; +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.ui.UIHelper; +import fr.ird.observe.ui.actions.AbstractObserveAction; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchroModel; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchroUI; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchroUIHandler; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.AddToReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.DeleteReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.DesactivateReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.ReferentialSynchronizeTaskSupport; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.RevertReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.UpdateToReferentialSynchronizeTask; +import jaxx.runtime.swing.wizard.ext.WizardState; + +import javax.swing.DefaultListModel; +import java.awt.event.ActionEvent; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 12/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ApplyAction extends AbstractObserveAction { + + private static final long serialVersionUID = 1L; + + private final ReferentialSynchroUI ui; + + public ApplyAction(ReferentialSynchroUI ui) { + super(t("observe.action.apply"), UIHelper.getUIManagerActionIcon("apply")); + this.ui = ui; + } + + @Override + public void actionPerformed(ActionEvent e) { + ReferentialSynchroUIHandler handler = ui.getHandler(); + + ReferentialSynchroModel stepModel = ui.getStepModel(); + + ObserveSwingDataSource leftSource = stepModel.getLeftSource(); + boolean leftSourceIsH2 = leftSource.getConfiguration() instanceof ObserveDataSourceConfigurationTopiaH2; + + ObserveSwingDataSource rightSource = stepModel.getRightSource(); + boolean rightSourceIsH2 = rightSource.getConfiguration() instanceof ObserveDataSourceConfigurationTopiaH2; + + DefaultListModel<ReferentialSynchronizeTaskSupport> tasks = stepModel.getTasks(); + int size = tasks.size(); + + 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 taskLabel = t("observe.actions.synchro.referential.task.prepare", task.getLabel()); + if (task instanceof AddToReferentialSynchronizeTask) { + handler.sendMessage(taskLabel); + leftReferentialSynchronizeRequestBuilder.addAddTask(task.getData()); + continue; + } + + if (task instanceof DeleteReferentialSynchronizeTask) { + handler.sendMessage(taskLabel); + leftReferentialSynchronizeRequestBuilder.addDeleteTask((task.getData())); + continue; + } + + if (task instanceof DesactivateReferentialSynchronizeTask) { + handler.sendMessage(taskLabel); + leftReferentialSynchronizeRequestBuilder.addDesactivateWithReplaceTask((task.getData())); + continue; + } + + if (task instanceof RevertReferentialSynchronizeTask) { + handler.sendMessage(taskLabel); + leftReferentialSynchronizeRequestBuilder.addRevertTask((task.getData())); + continue; + } + + if (task instanceof UpdateToReferentialSynchronizeTask) { + handler.sendMessage(taskLabel); + leftReferentialSynchronizeRequestBuilder.addUpdateTask((task.getData())); + } + + } + + 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); + } + + ui.getModel().setStepState(WizardState.SUCCESSED); + + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterAddTaskAction.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterAddTaskAction.java new file mode 100644 index 0000000..3311aa1 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterAddTaskAction.java @@ -0,0 +1,40 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.action; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchroUI; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.AddToReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferenceReferentialSynchroNodeSupport; + +import java.util.function.Predicate; + +/** + * Created on 12/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class RegisterAddTaskAction extends RegisterTasksActionSupport { + + private static final long serialVersionUID = 1L; + private transient Iterable<ReferenceReferentialSynchroNodeSupport> nodes; + + public RegisterAddTaskAction(ReferentialSynchroUI ui, boolean left) { + super(ui, ReferentialSynchronizeResources.ADD, left, false); + } + + @Override + protected <R extends ReferentialDto> AddToReferentialSynchronizeTask<R> createTask(boolean left, ReferentialReference<R> reference, ReferentialReference<R> replaceReference) { + return new AddToReferentialSynchronizeTask<>(left, reference); + } + + @Override + protected Iterable<ReferenceReferentialSynchroNodeSupport> getReferenceReferentialSynchroNodes(Predicate<ReferenceReferentialSynchroNodeSupport> predicate) { + return nodes; + } + + public void updateNodes() { + + this.nodes = super.getReferenceReferentialSynchroNodes(predicate); + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterCopyTaskAction.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterCopyTaskAction.java new file mode 100644 index 0000000..e9f6588 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterCopyTaskAction.java @@ -0,0 +1,40 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.action; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchroUI; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.AddToReferentialSynchronizeTask; + +/** + * Created on 12/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class RegisterCopyTaskAction extends RegisterTasksActionSupport { + + private static final long serialVersionUID = 1L; + + private final RegisterAddTaskAction addAction; + private final RegisterUpdateTaskAction updateAction; + + public RegisterCopyTaskAction(ReferentialSynchroUI ui, boolean left) { + super(ui, ReferentialSynchronizeResources.COPY, left, false); + addAction = new RegisterAddTaskAction(ui, left); + updateAction = new RegisterUpdateTaskAction(ui, left); + + } + + @Override + protected void createTasks() { + addAction.updateNodes(); + updateAction.updateNodes(); + addAction.createTasks(); + updateAction.createTasks(); + } + + @Override + protected <R extends ReferentialDto> AddToReferentialSynchronizeTask<R> createTask(boolean left, ReferentialReference<R> reference, ReferentialReference<R> replaceReference) { + return new AddToReferentialSynchronizeTask<>(left, reference); + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterDeleteTaskAction.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterDeleteTaskAction.java new file mode 100644 index 0000000..5fb4bb5 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterDeleteTaskAction.java @@ -0,0 +1,33 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.action; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchroUI; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.DeleteReferentialSynchronizeTask; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 12/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class RegisterDeleteTaskAction extends RegisterTasksActionSupport { + + private static final long serialVersionUID = 1L; + + public RegisterDeleteTaskAction(ReferentialSynchroUI ui, boolean left) { + super(ui, ReferentialSynchronizeResources.DELETE, left, true); + } + + @Override + protected String getReplaceTitle(ReferentialReference reference) { + return t("observe.actions.synchro.referential.replaceBeforeDelete.title", typeStr, referenceStr); + } + + @Override + protected <R extends ReferentialDto> DeleteReferentialSynchronizeTask<R> createTask(boolean left, ReferentialReference<R> reference, ReferentialReference<R> replaceReference) { + return new DeleteReferentialSynchronizeTask<>(left, reference, replaceReference); + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterDesactivateTaskAction.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterDesactivateTaskAction.java new file mode 100644 index 0000000..19b709f --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterDesactivateTaskAction.java @@ -0,0 +1,33 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.action; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchroUI; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.DesactivateReferentialSynchronizeTask; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 12/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class RegisterDesactivateTaskAction extends RegisterTasksActionSupport { + + private static final long serialVersionUID = 1L; + + public RegisterDesactivateTaskAction(ReferentialSynchroUI ui, boolean left, boolean replace) { + super(ui, ReferentialSynchronizeResources.DESACTIVATE, left, replace); + } + + @Override + protected String getReplaceTitle(ReferentialReference reference) { + return t("observe.actions.synchro.referential.replaceBeforeDesactivate.title", typeStr, referenceStr); + } + + @Override + protected <R extends ReferentialDto> DesactivateReferentialSynchronizeTask<R> createTask(boolean left, ReferentialReference<R> reference, ReferentialReference<R> replaceReference) { + return new DesactivateReferentialSynchronizeTask<>(left, reference, replaceReference); + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterRevertTaskAction.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterRevertTaskAction.java new file mode 100644 index 0000000..98d7dc2 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterRevertTaskAction.java @@ -0,0 +1,26 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.action; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchroUI; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.RevertReferentialSynchronizeTask; + +/** + * Created on 12/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class RegisterRevertTaskAction extends RegisterTasksActionSupport { + + private static final long serialVersionUID = 1L; + + public RegisterRevertTaskAction(ReferentialSynchroUI ui, boolean left) { + super(ui, ReferentialSynchronizeResources.REVERT, left, false); + } + + @Override + protected <R extends ReferentialDto> RevertReferentialSynchronizeTask<R> createTask(boolean left, ReferentialReference<R> reference, ReferentialReference<R> replaceReference) { + return new RevertReferentialSynchronizeTask<>(left, reference); + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterSkipTaskAction.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterSkipTaskAction.java new file mode 100644 index 0000000..3c33905 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterSkipTaskAction.java @@ -0,0 +1,26 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.action; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchroUI; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.SkipReferentialSynchronizeTask; + +/** + * Created on 12/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class RegisterSkipTaskAction extends RegisterTasksActionSupport { + + private static final long serialVersionUID = 1L; + + public RegisterSkipTaskAction(ReferentialSynchroUI ui, boolean left) { + super(ui, ReferentialSynchronizeResources.SKIP, left, false); + } + + @Override + protected <R extends ReferentialDto> SkipReferentialSynchronizeTask<R> createTask(boolean left, ReferentialReference<R> reference, ReferentialReference<R> replaceReference) { + return new SkipReferentialSynchronizeTask<>(left, reference); + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterTasksActionSupport.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterTasksActionSupport.java new file mode 100644 index 0000000..39e8e57 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterTasksActionSupport.java @@ -0,0 +1,189 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.action; + +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 fr.ird.observe.services.dto.referential.ReferentialReferenceSet; +import fr.ird.observe.ui.UIHelper; +import fr.ird.observe.ui.actions.AbstractObserveAction; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialReplaceUI; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchroUI; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.ReferentialSynchronizeTaskSupport; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.ReferentialSynchronizeTreeModel; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferenceReferentialSynchroNodeSupport; +import fr.ird.observe.ui.tree.ObserveTreeHelper; +import jaxx.runtime.context.JAXXInitialContext; +import org.apache.commons.lang3.NotImplementedException; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.i18n.I18n; + +import javax.swing.Action; +import javax.swing.JOptionPane; +import java.awt.event.ActionEvent; +import java.util.Collection; +import java.util.LinkedList; +import java.util.function.Predicate; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 12/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public abstract class RegisterTasksActionSupport extends AbstractObserveAction { + + /** Logger. */ + private static final Log log = LogFactory.getLog(RegisterTasksActionSupport.class); + + private static final long serialVersionUID = 1L; + + private final ReferentialSynchroUI ui; + private final boolean left; + private final boolean needReplace; + + protected final Predicate<ReferenceReferentialSynchroNodeSupport> predicate; + protected String typeStr; + protected String referenceStr; + + public RegisterTasksActionSupport(ReferentialSynchroUI ui, + ReferentialSynchronizeResources resource, + boolean left, + boolean needReplace) { + super(null, null); + String tip = resource.getActionTip(left); + if (tip != null) { + putValue(SHORT_DESCRIPTION, t(tip)); + } + String actionName = resource.getActionName(left); + if (actionName != null) { + putValue(Action.SMALL_ICON, UIHelper.getUIManagerActionIcon(actionName)); + } + this.ui = ui; + this.left = left; + this.needReplace = needReplace; + this.predicate = resource.getPredicate(); + String propertyName = resource.getPropertyName(left); + if (propertyName != null) { + ui.getModel().getReferentialSynchroModel().addPropertyChangeListener(propertyName, evt -> setEnabled((Boolean) evt.getNewValue())); + } + } + + protected abstract <R extends ReferentialDto> ReferentialSynchronizeTaskSupport<R> createTask(boolean left, ReferentialReference<R> reference, ReferentialReference<R> replaceReference); + + public boolean isLeft() { + return left; + } + + protected String getReplaceTitle(ReferentialReference reference) { + throw new NotImplementedException(""); + } + + @Override + public void actionPerformed(ActionEvent e) { + + ReferentialSynchronizeTreeModel treeModel = getTreeModel(); + + createTasks(); + + treeModel.clearSelection(); + + } + + protected void createTasks() { + createTasks(getTreeModel(), predicate); + } + + protected <R extends ReferentialDto> void createTasks(ReferentialSynchronizeTreeModel treeModel, Predicate<ReferenceReferentialSynchroNodeSupport> predicate) { + + Collection<ReferenceReferentialSynchroNodeSupport> removedNodes = new LinkedList<>(); + Collection<ReferentialSynchronizeTaskSupport> addedTasks = new LinkedList<>(); + + for (ReferenceReferentialSynchroNodeSupport node : getReferenceReferentialSynchroNodes(predicate)) { + + ReferentialReference<R> reference = node.getUserObject(); + ReferentialReference<R> replaceReference = null; + + if (needReplace) { + + ReferentialReferenceSet<R> references; + Class<R> type = reference.getType(); + if (left) { + references = ui.getStepModel().getEngine().getLeftEnabledReferentialReferenceSet(type); + } else { + references = ui.getStepModel().getEngine().getRightEnabledReferentialReferenceSet(type); + } + + ReferentialReplaceUI<R> replaceUI = new ReferentialReplaceUI<>(new JAXXInitialContext() + .add(reference) + .add(references) + .add(this)); + + typeStr = t(DecoratorService.getEntityLabel(ObserveTreeHelper.TREE_NODE_PREFIX, type)); + referenceStr = ui.getHandler().getDecoratorService().getReferentialReferenceDecorator(type).toString(reference); + replaceUI.getMessage().setText(t("observe.actions.synchro.referential.replaceBefore.message", typeStr, referenceStr)); + + int response = UIHelper.askUser( + null, + t(getReplaceTitle(reference), typeStr, referenceStr), + replaceUI, + JOptionPane.WARNING_MESSAGE, + new Object[]{I18n.t("observe.choice.replace"), I18n.t("observe.choice.cancel")}, + 1); + + switch (response) { + case JOptionPane.CLOSED_OPTION: + case 1: + + break; + case 0: + replaceReference = replaceUI.getReplaceReference(); + break; + } + + if (log.isInfoEnabled()) { + log.info("replaceReference: " + replaceReference); + } + + if (replaceReference == null) { + if (log.isWarnEnabled()) { + log.warn("Skip this task, no replace referential reference selected"); + } + + continue; + } + + if (log.isInfoEnabled()) { + log.info("Selected replace referential reference: " + replaceReference); + } + + } + + ReferentialSynchronizeTaskSupport task = createTask(left, reference, replaceReference); + + if (log.isInfoEnabled()) { + log.info("Add " + task.getLabel()); + } + + ui.getHandler().sendMessage(task.getLabel()); + + removedNodes.add(node); + addedTasks.add(task); + + } + + treeModel.removeReferenceNodes(removedNodes); + ui.getStepModel().getTasks().addTasks(addedTasks); + } + + protected Iterable<ReferenceReferentialSynchroNodeSupport> getReferenceReferentialSynchroNodes(Predicate<ReferenceReferentialSynchroNodeSupport> predicate) { + return getTreeModel().filterSelectedReferenceNodes(predicate); + } + + protected ReferentialSynchronizeTreeModel getTreeModel() { + return left ? ui.getStepModel().getLeftTreeModel() : ui.getStepModel().getRightTreeModel(); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterUpdateTaskAction.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterUpdateTaskAction.java new file mode 100644 index 0000000..f7bd19e --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/action/RegisterUpdateTaskAction.java @@ -0,0 +1,41 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.action; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchroUI; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; +import fr.ird.observe.ui.admin.synchronize.referential.ng.task.UpdateToReferentialSynchronizeTask; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferenceReferentialSynchroNodeSupport; + +import java.util.function.Predicate; + +/** + * Created on 12/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class RegisterUpdateTaskAction extends RegisterTasksActionSupport { + + private static final long serialVersionUID = 1L; + + private Iterable<ReferenceReferentialSynchroNodeSupport> nodes; + + public RegisterUpdateTaskAction(ReferentialSynchroUI ui, boolean left) { + super(ui, ReferentialSynchronizeResources.UPDATE, left, false); + } + + @Override + protected <R extends ReferentialDto> UpdateToReferentialSynchronizeTask<R> createTask(boolean left, ReferentialReference<R> reference, ReferentialReference<R> replaceReference) { + return new UpdateToReferentialSynchronizeTask<>(left, reference); + } + + @Override + protected Iterable<ReferenceReferentialSynchroNodeSupport> getReferenceReferentialSynchroNodes(Predicate<ReferenceReferentialSynchroNodeSupport> predicate) { + return nodes; + } + + public void updateNodes() { + this.nodes = super.getReferenceReferentialSynchroNodes(predicate); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/AddToReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/AddToReferentialSynchronizeTask.java new file mode 100644 index 0000000..d86244e --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/AddToReferentialSynchronizeTask.java @@ -0,0 +1,19 @@ +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 fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class AddToReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public AddToReferentialSynchronizeTask(boolean left, ReferentialReference<R> data) { + super(ReferentialSynchronizeResources.ADD, left, data); + } + +} 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 deleted file mode 100644 index 1b0c340..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/CopyToLeftReferentialSynchronizeTask.java +++ /dev/null @@ -1,25 +0,0 @@ -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 deleted file mode 100644 index 9e6f33b..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/CopyToRightReferentialSynchronizeTask.java +++ /dev/null @@ -1,25 +0,0 @@ -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 deleted file mode 100644 index 15779b5..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DeleteFromLeftReferentialSynchronizeTask.java +++ /dev/null @@ -1,25 +0,0 @@ -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 deleted file mode 100644 index bc8806b..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DeleteFromRightReferentialSynchronizeTask.java +++ /dev/null @@ -1,25 +0,0 @@ -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/DeleteReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DeleteReferentialSynchronizeTask.java new file mode 100644 index 0000000..71dd314 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DeleteReferentialSynchronizeTask.java @@ -0,0 +1,19 @@ +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 fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class DeleteReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskWithReplaceSupport<R> { + + public DeleteReferentialSynchronizeTask(boolean left, ReferentialReference<R> data, ReferentialReference<R> replaceData) { + super(ReferentialSynchronizeResources.DELETE, left, data, replaceData); + } + +} 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 deleted file mode 100644 index eb4325e..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromLeftReferentialSynchronizeTask.java +++ /dev/null @@ -1,25 +0,0 @@ -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/DesactivateFromRightReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromRightReferentialSynchronizeTask.java deleted file mode 100644 index ef8a85a..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateFromRightReferentialSynchronizeTask.java +++ /dev/null @@ -1,25 +0,0 @@ -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/DesactivateReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateReferentialSynchronizeTask.java new file mode 100644 index 0000000..3ce1210 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateReferentialSynchronizeTask.java @@ -0,0 +1,40 @@ +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 fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; + +import static org.nuiton.i18n.I18n.n; +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class DesactivateReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskWithReplaceSupport<R> { + + private final String withoutReplaceI18nKey; + + public DesactivateReferentialSynchronizeTask(boolean left, ReferentialReference<R> data, ReferentialReference<R> replaceData) { + super(ReferentialSynchronizeResources.DESACTIVATE, left, data, replaceData); + + withoutReplaceI18nKey = left + ? n("observe.actions.synchro.referential.task.desactivateFromLeft") + : n("observe.actions.synchro.referential.task.desactivateFromRight"); + } + + @Override + public String getLabel() { + if (replaceDataStr == null) { + + // sans remplacement + return t(withoutReplaceI18nKey, typeStr, dataStr); + + } else { + + return super.getLabel(); + } + } +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateWithReplaceFromLeftReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateWithReplaceFromLeftReferentialSynchronizeTask.java deleted file mode 100644 index a304f94..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateWithReplaceFromLeftReferentialSynchronizeTask.java +++ /dev/null @@ -1,25 +0,0 @@ -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 DesactivateWithReplaceFromLeftReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { - - public DesactivateWithReplaceFromLeftReferentialSynchronizeTask(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/DesactivateWithReplaceFromRightReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateWithReplaceFromRightReferentialSynchronizeTask.java deleted file mode 100644 index 09bfe98..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/DesactivateWithReplaceFromRightReferentialSynchronizeTask.java +++ /dev/null @@ -1,25 +0,0 @@ -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 DesactivateWithReplaceFromRightReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { - - public DesactivateWithReplaceFromRightReferentialSynchronizeTask(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 index 7ca9c2f..b6d46b6 100644 --- 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 @@ -4,7 +4,7 @@ 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 fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; import javax.swing.Icon; @@ -18,15 +18,31 @@ import static org.nuiton.i18n.I18n.t; */ public abstract class ReferentialSynchronizeTaskSupport<R extends ReferentialDto> { + protected final String dataStr; + protected final String typeStr; + protected final String i18nKey; private final ReferentialReference<R> data; private final Icon icon; + private final boolean left; - protected ReferentialSynchronizeTaskSupport(ReferentialReference<R> data, String iconName) { + protected ReferentialSynchronizeTaskSupport(ReferentialSynchronizeResources resource, + boolean left, + ReferentialReference<R> data) { + this.left = left; this.data = data; - this.icon = SwingUtil.createActionIcon(iconName); + this.icon = resource.getIcon(left); + this.i18nKey = resource.getTaskLabel(left); + this.dataStr = ObserveSwingApplicationContext.get().getDecoratorService().getReferentialReferenceDecorator(data.getType()).toString(data); + this.typeStr = t(DecoratorService.getEntityLabel(data.getType())); } - public abstract String getLabel(); + public boolean isLeft() { + return left; + } + + public String getLabel() { + return t(i18nKey, typeStr, dataStr); + } public ReferentialReference<R> getData() { return data; @@ -36,13 +52,4 @@ public abstract class ReferentialSynchronizeTaskSupport<R extends ReferentialDto 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/ReferentialSynchronizeTaskWithReplaceSupport.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/ReferentialSynchronizeTaskWithReplaceSupport.java new file mode 100644 index 0000000..08419f9 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/ReferentialSynchronizeTaskWithReplaceSupport.java @@ -0,0 +1,34 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.task; + +import fr.ird.observe.ObserveSwingApplicationContext; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; + +import static org.nuiton.i18n.I18n.t; + +/** + * Created on 11/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public abstract class ReferentialSynchronizeTaskWithReplaceSupport<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + protected final String replaceDataStr; + private final ReferentialReference<R> replaceData; + + protected ReferentialSynchronizeTaskWithReplaceSupport(ReferentialSynchronizeResources resource, boolean left, ReferentialReference<R> data, ReferentialReference<R> replaceData) { + super(resource, left, data); + this.replaceData = replaceData; + this.replaceDataStr = replaceData == null ? null : ObserveSwingApplicationContext.get().getDecoratorService().getReferentialReferenceDecorator(replaceData.getType()).toString(replaceData); + } + + public ReferentialReference<R> getReplaceData() { + return replaceData; + } + + @Override + public String getLabel() { + return t(i18nKey, typeStr, dataStr, replaceDataStr); + } +} 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 deleted file mode 100644 index 86290f0..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/RevertFromLeftReferentialSynchronizeTask.java +++ /dev/null @@ -1,25 +0,0 @@ -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 deleted file mode 100644 index be1568a..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/RevertFromRightReferentialSynchronizeTask.java +++ /dev/null @@ -1,25 +0,0 @@ -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/RevertReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/RevertReferentialSynchronizeTask.java new file mode 100644 index 0000000..0398e29 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/RevertReferentialSynchronizeTask.java @@ -0,0 +1,19 @@ +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 fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class RevertReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public RevertReferentialSynchronizeTask(boolean left, ReferentialReference<R> data) { + super(ReferentialSynchronizeResources.REVERT, left, data); + } + +} 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 deleted file mode 100644 index 8cfb74d..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/SkipFromLeftReferentialSynchronizeTask.java +++ /dev/null @@ -1,25 +0,0 @@ -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 deleted file mode 100644 index 24f5772..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/SkipFromRightReferentialSynchronizeTask.java +++ /dev/null @@ -1,25 +0,0 @@ -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/task/SkipReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/SkipReferentialSynchronizeTask.java new file mode 100644 index 0000000..1c2e157 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/SkipReferentialSynchronizeTask.java @@ -0,0 +1,19 @@ +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 fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class SkipReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public SkipReferentialSynchronizeTask(boolean left, ReferentialReference<R> data) { + super(ReferentialSynchronizeResources.SKIP, left, data); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/UpdateToReferentialSynchronizeTask.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/UpdateToReferentialSynchronizeTask.java new file mode 100644 index 0000000..13b4c5c --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/task/UpdateToReferentialSynchronizeTask.java @@ -0,0 +1,19 @@ +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 fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchronizeResources; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public class UpdateToReferentialSynchronizeTask<R extends ReferentialDto> extends ReferentialSynchronizeTaskSupport<R> { + + public UpdateToReferentialSynchronizeTask(boolean left, ReferentialReference<R> data) { + super(ReferentialSynchronizeResources.UPDATE, left, data); + } + +} 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 index 5e1b845..7d97370 100644 --- 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 @@ -53,6 +53,8 @@ public class ReferentialSynchronizeTreeCellRenderer extends DefaultTreeCellRende private static final long serialVersionUID = 1L; + protected transient DecoratorService decoratorService; + public ReferentialSynchronizeTreeCellRenderer() { setBackgroundNonSelectionColor(null); @@ -63,13 +65,8 @@ public class ReferentialSynchronizeTreeCellRenderer extends DefaultTreeCellRende 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; 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 index 8943af9..68107f9 100644 --- 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 @@ -1,9 +1,12 @@ package fr.ird.observe.ui.admin.synchronize.referential.ng.tree; +import com.google.common.collect.ImmutableSet; import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferenceReferentialSynchroNodeSupport; 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.logging.Log; +import org.apache.commons.logging.LogFactory; import javax.swing.event.TreeModelListener; import javax.swing.event.TreeSelectionListener; @@ -14,24 +17,41 @@ import javax.swing.tree.TreeModel; import javax.swing.tree.TreePath; import javax.swing.tree.TreeSelectionModel; import java.beans.PropertyChangeListener; +import java.io.Serializable; +import java.util.Collection; +import java.util.Enumeration; +import java.util.LinkedList; +import java.util.function.Predicate; /** * Created on 10/08/16. * * @author Tony Chemit - chemit@codelutin.com */ -public class ReferentialSynchronizeTreeModel implements TreeSelectionModel, TreeModel { +public class ReferentialSynchronizeTreeModel implements TreeSelectionModel, TreeModel, Serializable { - private final TreeSelectionModel treeSelectionModel; + private static final long serialVersionUID = 1L; + + /** Logger. */ + private static final Log log = LogFactory.getLog(ReferentialSynchronizeTreeModel.class); + + private final DefaultTreeSelectionModel treeSelectionModel; private final DefaultTreeModel treeModel; - private boolean canCopy; + private boolean canAdd; + private boolean canUpdate; private boolean canDelete; private boolean canRevert; + public ReferentialSynchronizeTreeModel(RootReferentialSynchroNode root) { + this.treeModel = new DefaultTreeModel(root); + this.treeSelectionModel = new DefaultTreeSelectionModel(); + setSelectionMode(DISCONTIGUOUS_TREE_SELECTION); + } + public synchronized void updateSelectedActions() { - canCopy = canDelete = canRevert = false; + canAdd = canUpdate = canDelete = canRevert = false; for (TreePath selectionPath : getSelectionPaths()) { ReferentialSynchroNodeSupport lastPathComponent = (ReferentialSynchroNodeSupport) selectionPath.getLastPathComponent(); @@ -39,7 +59,8 @@ public class ReferentialSynchronizeTreeModel implements TreeSelectionModel, Tree if (lastPathComponent instanceof ReferenceReferentialSynchroNodeSupport) { ReferenceReferentialSynchroNodeSupport node = (ReferenceReferentialSynchroNodeSupport) lastPathComponent; - canCopy |= node.isCanCopy(); + canAdd |= node.isCanAdd(); + canUpdate |= node.isCanUpdate(); canDelete |= node.isCanDelete(); canRevert |= node.isCanRevert(); @@ -49,8 +70,28 @@ public class ReferentialSynchronizeTreeModel implements TreeSelectionModel, Tree } - public boolean isCanCopy() { - return canCopy; + public Iterable<ReferenceReferentialSynchroNodeSupport> filterSelectedReferenceNodes(Predicate<ReferenceReferentialSynchroNodeSupport> predicate) { + + ImmutableSet.Builder<ReferenceReferentialSynchroNodeSupport> builder = ImmutableSet.builder(); + + for (TreePath selectionPath : getSelectionPaths()) { + ReferentialSynchroNodeSupport lastPathComponent = (ReferentialSynchroNodeSupport) selectionPath.getLastPathComponent(); + if (lastPathComponent instanceof ReferenceReferentialSynchroNodeSupport) { + ReferenceReferentialSynchroNodeSupport node = (ReferenceReferentialSynchroNodeSupport) lastPathComponent; + if (predicate.test(node)) { + builder.add(node); + } + } + } + return builder.build(); + } + + public boolean isCanAdd() { + return canAdd; + } + + public boolean isCanUpdate() { + return canUpdate; } public boolean isCanDelete() { @@ -65,16 +106,6 @@ public class ReferentialSynchronizeTreeModel implements TreeSelectionModel, Tree return getSelectionCount() > 0; } - public ReferentialSynchronizeTreeModel(RootReferentialSynchroNode root) { - this.treeModel = new DefaultTreeModel(root); - this.treeSelectionModel = new DefaultTreeSelectionModel(); - setSelectionMode(DISCONTIGUOUS_TREE_SELECTION); - } - - public boolean isCanWrite() { - return getRoot().isCanWrite(); - } - public boolean isLeft() { return getRoot().isLeft(); } @@ -131,43 +162,72 @@ public class ReferentialSynchronizeTreeModel implements TreeSelectionModel, Tree } @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); + public void setSelectionMode(int mode) { + treeSelectionModel.setSelectionMode(mode); } @Override public void addSelectionPath(TreePath path) { - treeSelectionModel.addSelectionPath(path); + addSelectionPaths(path); } @Override - public void addSelectionPaths(TreePath[] paths) { - treeSelectionModel.addSelectionPaths(paths); + public void removeSelectionPath(TreePath path) { + removeSelectionPaths(path); } @Override - public void removeSelectionPath(TreePath path) { - treeSelectionModel.removeSelectionPath(path); + public void addSelectionPaths(TreePath... paths) { + + valueIsAdjusting = true; + + try { + Collection<TreePath> collectedPaths = new LinkedList<>(); + + collectPaths(collectedPaths, paths); + + if (log.isInfoEnabled()) { + log.info("path(s) to add: " + collectedPaths.size()); + } + treeSelectionModel.addSelectionPaths(collectedPaths.toArray(new TreePath[collectedPaths.size()])); + } finally { + + valueIsAdjusting = false; + + } } + private boolean valueIsAdjusting; + @Override - public void removeSelectionPaths(TreePath[] paths) { - treeSelectionModel.removeSelectionPaths(paths); + public void removeSelectionPaths(TreePath... paths) { + + if (valueIsAdjusting) { + return; + } + + valueIsAdjusting = true; + + try { + Collection<TreePath> collectedPaths = new LinkedList<>(); + + collectPaths(collectedPaths, paths); + + if (log.isInfoEnabled()) { + log.info("path(s) to remove: " + collectedPaths.size()); + } + treeSelectionModel.removeSelectionPaths(collectedPaths.toArray(new TreePath[collectedPaths.size()])); + } finally { + + valueIsAdjusting = false; + + } + } @Override @@ -176,11 +236,27 @@ public class ReferentialSynchronizeTreeModel implements TreeSelectionModel, Tree } @Override + public void setSelectionPath(TreePath path) { + + if (isPathSelected(path)) { + removeSelectionPaths(path); + } else { + addSelectionPaths(path); + } + + } + + @Override public TreePath[] getSelectionPaths() { return treeSelectionModel.getSelectionPaths(); } @Override + public void setSelectionPaths(TreePath[] paths) { + treeSelectionModel.setSelectionPaths(paths); + } + + @Override public int getSelectionCount() { return treeSelectionModel.getSelectionCount(); } @@ -201,13 +277,13 @@ public class ReferentialSynchronizeTreeModel implements TreeSelectionModel, Tree } @Override - public void setRowMapper(RowMapper newMapper) { - treeSelectionModel.setRowMapper(newMapper); + public RowMapper getRowMapper() { + return treeSelectionModel.getRowMapper(); } @Override - public RowMapper getRowMapper() { - return treeSelectionModel.getRowMapper(); + public void setRowMapper(RowMapper newMapper) { + treeSelectionModel.setRowMapper(newMapper); } @Override @@ -264,4 +340,45 @@ public class ReferentialSynchronizeTreeModel implements TreeSelectionModel, Tree public void removeTreeSelectionListener(TreeSelectionListener x) { treeSelectionModel.removeTreeSelectionListener(x); } + + private void collectPaths(Collection<TreePath> collectedPaths, TreePath... paths) { + for (TreePath path : paths) { + + collectedPaths.add(path); + + Object node = path.getLastPathComponent(); + + if (node instanceof TypeReferentialSynchroNode) { + TypeReferentialSynchroNode node1 = (TypeReferentialSynchroNode) node; + + Enumeration children = node1.children(); + while (children.hasMoreElements()) { + ReferenceReferentialSynchroNodeSupport childNode = (ReferenceReferentialSynchroNodeSupport) children.nextElement(); + collectedPaths.add(path.pathByAddingChild(childNode)); + } + + } + + } + + } + + public void removeReferenceNodes(Collection<ReferenceReferentialSynchroNodeSupport> removedNodes) { + + valueIsAdjusting = true; + + try { + for (ReferenceReferentialSynchroNodeSupport removedNode : removedNodes) { + TypeReferentialSynchroNode typeNode = removedNode.getParent(); + if (typeNode.getChildCount() == 1) { + treeModel.removeNodeFromParent(typeNode); + } else { + treeModel.removeNodeFromParent(removedNode); + } + } + } finally { + valueIsAdjusting = false; + } + + } } diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/ReferentialSynchronizeTreeModelsBuilder.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/ReferentialSynchronizeTreeModelsBuilder.java index 75f4199..3af7e05 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/ReferentialSynchronizeTreeModelsBuilder.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/ReferentialSynchronizeTreeModelsBuilder.java @@ -30,25 +30,12 @@ public class ReferentialSynchronizeTreeModelsBuilder { private final RootReferentialSynchroNode leftRootNode; private final RootReferentialSynchroNode rightRootNode; - private final CreateNode leftAddNode; - private final CreateNode rightAddNode; - private final CreateNode leftUpdateNode; - private final CreateNode rightUpdateNode; - public ReferentialSynchronizeTreeModelsBuilder(ReferentialSynchronizeMode synchronizeMode, ReferentialSynchronizeDiffsEngine engine) { Objects.nonNull(synchronizeMode); Objects.nonNull(engine); this.engine = engine; - this.leftRootNode = new RootReferentialSynchroNode(true, synchronizeMode != ReferentialSynchronizeMode.FROM_LEFT_TO_RIGHT); - this.rightRootNode = new RootReferentialSynchroNode(false, synchronizeMode != ReferentialSynchronizeMode.FROM_RIGHT_TO_LEFT); - - boolean rightCanWrite = rightRootNode.isCanWrite(); - boolean leftCanWrite = leftRootNode.isCanWrite(); - - this.leftAddNode = new CreateAddNode(rightCanWrite, leftCanWrite, false); - this.rightAddNode = new CreateAddNode(leftCanWrite, rightCanWrite, false); - this.leftUpdateNode = new CreateUpdateNode(rightCanWrite, false, leftCanWrite); - this.rightUpdateNode = new CreateUpdateNode(leftCanWrite, false, rightCanWrite); + this.leftRootNode = new RootReferentialSynchroNode(true, synchronizeMode.isLeftWrite()); + this.rightRootNode = new RootReferentialSynchroNode(false, synchronizeMode.isRightWrite()); } public Pair<ReferentialSynchronizeTreeModel, ReferentialSynchronizeTreeModel> build() { @@ -60,6 +47,14 @@ public class ReferentialSynchronizeTreeModelsBuilder { ReferentialSynchronizeDiff leftDiff = synchronizeDiffs.getLeftDiff(); ReferentialSynchronizeDiff rightDiff = synchronizeDiffs.getRightDiff(); + boolean rightCanWrite = rightRootNode.isCanWrite(); + boolean leftCanWrite = leftRootNode.isCanWrite(); + + CreateNode leftAddNode = new CreateAddNode(rightCanWrite, leftCanWrite, false); + CreateNode rightAddNode = new CreateAddNode(leftCanWrite, rightCanWrite, false); + CreateNode leftUpdateNode = new CreateUpdateNode(rightCanWrite, false, leftCanWrite); + CreateNode rightUpdateNode = new CreateUpdateNode(leftCanWrite, false, rightCanWrite); + for (Class<? extends ReferentialDto> referentialName : referentialNames) { { @@ -90,6 +85,7 @@ public class ReferentialSynchronizeTreeModelsBuilder { addFromRight(rightRootNode, optionalDiffStates.get(), referentialName, rightUpdateNode); } } + } ReferentialSynchronizeTreeModel leftTreeModel = new ReferentialSynchronizeTreeModel(leftRootNode); @@ -98,7 +94,6 @@ public class ReferentialSynchronizeTreeModelsBuilder { } - private <R extends ReferentialDto> void addFromLeft(RootReferentialSynchroNode rootNode, ImmutableSet<ReferentialSynchronizeDiffState> diffStates, Class<R> referentialName, CreateNode createNode) { ReferentialReferenceSet<R> referenceSet = engine.getLeftReferentialReferenceSet(referentialName, diffStates); ImmutableSet<ReferentialReference<R>> references = referenceSet.getReferences(); @@ -122,7 +117,7 @@ public class ReferentialSynchronizeTreeModelsBuilder { } } - private static abstract class CreateNode <R extends ReferentialDto>{ + private static abstract class CreateNode { protected final boolean canCopy; protected final boolean canDelete; @@ -134,32 +129,32 @@ public class ReferentialSynchronizeTreeModelsBuilder { this.canRevert = canRevert; } - public abstract void createNode(TypeReferentialSynchroNode typeNode, ReferentialReference<R> reference); + public abstract void createNode(TypeReferentialSynchroNode typeNode, ReferentialReference<?> reference); } - private static class CreateAddNode<R extends ReferentialDto> extends CreateNode<R> { + private static class CreateAddNode extends CreateNode { protected CreateAddNode(boolean canCopy, boolean canDelete, boolean canRevert) { super(canCopy, canDelete, canRevert); } @Override - public void createNode(TypeReferentialSynchroNode typeNode, ReferentialReference<R> reference) { - ReferenceReferentialSynchroNodeSupport node = new AddedReferenceReferentialSynchroNode(reference, canCopy, canDelete, canRevert); + public void createNode(TypeReferentialSynchroNode typeNode, ReferentialReference<?> reference) { + ReferenceReferentialSynchroNodeSupport node = new AddedReferenceReferentialSynchroNode(reference, canCopy, false, canDelete, canRevert); typeNode.add(node); } } - private static class CreateUpdateNode<R extends ReferentialDto> extends CreateNode<R> { + private static class CreateUpdateNode extends CreateNode { protected CreateUpdateNode(boolean canCopy, boolean canDelete, boolean canRevert) { super(canCopy, canDelete, canRevert); } @Override - public void createNode(TypeReferentialSynchroNode typeNode, ReferentialReference<R> reference) { - ReferenceReferentialSynchroNodeSupport node = new UpdatedReferenceReferentialSynchroNode(reference, canCopy, canDelete, canRevert); + public void createNode(TypeReferentialSynchroNode typeNode, ReferentialReference<?> reference) { + ReferenceReferentialSynchroNodeSupport node = new UpdatedReferenceReferentialSynchroNode(reference, false, canCopy, canDelete, canRevert); typeNode.add(node); } } diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/AddedReferenceReferentialSynchroNode.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/AddedReferenceReferentialSynchroNode.java index dee67f2..dcb31f5 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/AddedReferenceReferentialSynchroNode.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/AddedReferenceReferentialSynchroNode.java @@ -12,8 +12,8 @@ public class AddedReferenceReferentialSynchroNode extends ReferenceReferentialSy private static final long serialVersionUID = 1L; - public AddedReferenceReferentialSynchroNode(ReferentialReference<? extends ReferentialDto> referentialReference,boolean canCopy, boolean canDelete, boolean canRevert) { - super(referentialReference, "synchroAdd", canCopy, canDelete, canRevert); + public AddedReferenceReferentialSynchroNode(ReferentialReference<? extends ReferentialDto> referentialReference, boolean canAdd, boolean canUpdate, boolean canDelete, boolean canRevert) { + super(referentialReference, "synchroAdd", canAdd, canUpdate, canDelete, canRevert); } diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNodeSupport.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNodeSupport.java index 055c00d..0ebb9d2 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNodeSupport.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNodeSupport.java @@ -14,22 +14,30 @@ public abstract class ReferenceReferentialSynchroNodeSupport extends Referential private static final long serialVersionUID = 1L; - private final boolean canCopy; + private final boolean canAdd; + private final boolean canUpdate; private final boolean canDelete; private final boolean canRevert; - protected ReferenceReferentialSynchroNodeSupport(ReferentialReference<? extends ReferentialDto> referentialReference, String iconName, - boolean canCopy, + protected ReferenceReferentialSynchroNodeSupport(ReferentialReference<? extends ReferentialDto> referentialReference, + String iconName, + boolean canAdd, + boolean canUpdate, boolean canDelete, boolean canRevert) { super(UIHelper.createActionIcon(iconName), referentialReference); - this.canCopy = canCopy; + this.canAdd = canAdd; + this.canUpdate = canUpdate; this.canDelete = canDelete; this.canRevert = canRevert; } - public boolean isCanCopy() { - return canCopy; + public boolean isCanAdd() { + return canAdd; + } + + public boolean isCanUpdate() { + return canUpdate; } public boolean isCanDelete() { diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/UpdatedReferenceReferentialSynchroNode.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/UpdatedReferenceReferentialSynchroNode.java index f53816b..5d4560e 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/UpdatedReferenceReferentialSynchroNode.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/UpdatedReferenceReferentialSynchroNode.java @@ -12,8 +12,8 @@ public class UpdatedReferenceReferentialSynchroNode extends ReferenceReferential private static final long serialVersionUID = 1L; - public UpdatedReferenceReferentialSynchroNode(ReferentialReference<? extends ReferentialDto> referentialReference, boolean canCopy, boolean canDelete, boolean canRevert) { - super(referentialReference, "synchroUpdate", canCopy, canDelete, canRevert); + public UpdatedReferenceReferentialSynchroNode(ReferentialReference<? extends ReferentialDto> referentialReference, boolean canAdd, boolean canUpdate, boolean canDelete, boolean canRevert) { + super(referentialReference, "synchroUpdate", canAdd, canUpdate, canDelete, canRevert); } } diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/storage/StorageUIModel.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/storage/StorageUIModel.java index 27b83ba..a28ee48 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/storage/StorageUIModel.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/storage/StorageUIModel.java @@ -1450,7 +1450,7 @@ public class StorageUIModel extends WizardModel<StorageStep> { firePgConfigChanged(REMOTE_LOGIN_ROPERTY_NAME, null, remoteLogin); } - public void setRemotePassword(char[] remotePassword) { + public void setRemotePassword(char... remotePassword) { // char[] oldValue = getRemotePassword(); if (isEditRemoteConfig()) { diff --git a/observe-application-swing/src/main/resources/i18n/observe-application-swing_en_GB.properties b/observe-application-swing/src/main/resources/i18n/observe-application-swing_en_GB.properties index 3e58b10..25ffa5b 100644 --- a/observe-application-swing/src/main/resources/i18n/observe-application-swing_en_GB.properties +++ b/observe-application-swing/src/main/resources/i18n/observe-application-swing_en_GB.properties @@ -223,8 +223,6 @@ observe.actions.synchro.data.prepare.copyToLeftTask= observe.actions.synchro.data.prepare.copyToRightTask= observe.actions.synchro.data.prepare.deleteFromLeftTask= observe.actions.synchro.data.prepare.deleteFromRightTask= -observe.actions.synchro.data.prepare.skipFromLeftTask= -observe.actions.synchro.data.prepare.skipFromRightTask= observe.actions.synchro.data.step= observe.actions.synchro.data.step.description= observe.actions.synchro.data.title= @@ -232,23 +230,17 @@ observe.actions.synchro.data.title.tip= observe.actions.synchro.launch.operation=Launch operation < %1$S > observe.actions.synchro.prepare.operation=Prepare operation < %1$s > observe.actions.synchro.referential= +observe.actions.synchro.referential.action.copyToLeft.tip= +observe.actions.synchro.referential.action.copyToRight.tip= +observe.actions.synchro.referential.action.deleteFromLeft.tip= +observe.actions.synchro.referential.action.deleteFromRight.tip= +observe.actions.synchro.referential.action.desactivateFromLeft.tip= +observe.actions.synchro.referential.action.desactivateFromRight.tip= +observe.actions.synchro.referential.action.revertFromLeft.tip= +observe.actions.synchro.referential.action.revertFromRight.tip= +observe.actions.synchro.referential.action.skipFromLeft.tip= +observe.actions.synchro.referential.action.skipFromRight.tip= observe.actions.synchro.referential.config.mode= -observe.actions.synchro.referential.copyToLeft.tip= -observe.actions.synchro.referential.copyToLeftTask= -observe.actions.synchro.referential.copyToRight.tip= -observe.actions.synchro.referential.copyToRightTask= -observe.actions.synchro.referential.deleteFromLeft.tip= -observe.actions.synchro.referential.deleteFromLeftTask= -observe.actions.synchro.referential.deleteFromRight.tip= -observe.actions.synchro.referential.deleteFromRightTask= -observe.actions.synchro.referential.desactivateFromLeft.tip= -observe.actions.synchro.referential.desactivateFromLeftTask= -observe.actions.synchro.referential.desactivateFromLeftWithReplace.tip= -observe.actions.synchro.referential.desactivateFromLeftWithReplaceTask= -observe.actions.synchro.referential.desactivateFromRight.tip= -observe.actions.synchro.referential.desactivateFromRightTask= -observe.actions.synchro.referential.desactivateFromRightWithReplace.tip= -observe.actions.synchro.referential.desactivateFromRightWithReplaceTask= observe.actions.synchro.referential.description= observe.actions.synchro.referential.launch.operation= observe.actions.synchro.referential.legacy=Synchronize @@ -274,27 +266,30 @@ observe.actions.synchro.referential.message.saveLocal.skip= observe.actions.synchro.referential.message.synchro.local.modification= observe.actions.synchro.referential.obsolete.entities.list= observe.actions.synchro.referential.obsolete.entity.fix= -observe.actions.synchro.referential.prepare.copyToLeftTask= -observe.actions.synchro.referential.prepare.copyToRightTask= -observe.actions.synchro.referential.prepare.deleteFromLeftTask= -observe.actions.synchro.referential.prepare.deleteFromRightTask= -observe.actions.synchro.referential.prepare.desactivateFromLeftTask= -observe.actions.synchro.referential.prepare.desactivateFromLeftWithReplaceTask= -observe.actions.synchro.referential.prepare.desactivateFromRightTask= -observe.actions.synchro.referential.prepare.desactivateFromRightWithReplaceTask= -observe.actions.synchro.referential.revertFromRightLeft= -observe.actions.synchro.referential.revertFromRightTask= -observe.actions.synchro.referential.revertToLeft.tip= -observe.actions.synchro.referential.revertToRight.tip= +observe.actions.synchro.referential.replaceBefore.message= +observe.actions.synchro.referential.replaceBeforeDelete.title= +observe.actions.synchro.referential.replaceBeforeDesactivate.title= observe.actions.synchro.referential.safe.entity.to.choose.label= -observe.actions.synchro.referential.skipFromLeftTask= -observe.actions.synchro.referential.skipFromRightTask= -observe.actions.synchro.referential.skipToLeft.tip= -observe.actions.synchro.referential.skipToRight.tip= observe.actions.synchro.referential.step= observe.actions.synchro.referential.step.description= +observe.actions.synchro.referential.task.addToLeft= +observe.actions.synchro.referential.task.addToRight= +observe.actions.synchro.referential.task.deleteFromLeft= +observe.actions.synchro.referential.task.deleteFromRight= +observe.actions.synchro.referential.task.desactivateFromLeft= +observe.actions.synchro.referential.task.desactivateFromRight= +observe.actions.synchro.referential.task.desactivateWithReplaceFromLeft= +observe.actions.synchro.referential.task.desactivateWithReplaceFromRight= +observe.actions.synchro.referential.task.prepare= +observe.actions.synchro.referential.task.revertFromLeft= +observe.actions.synchro.referential.task.revertFromRight= +observe.actions.synchro.referential.task.skipFromLeft= +observe.actions.synchro.referential.task.skipFromRight= +observe.actions.synchro.referential.task.updateToLeft= +observe.actions.synchro.referential.task.updateToRight= observe.actions.synchro.referential.title= observe.actions.synchro.referential.title.tip= +observe.actions.synchro.referential.withMode= observe.actions.synchro.report.reset.tip=Reset selected report. observe.actions.validate= observe.actions.validate.choose.report.directory=Choose reports directory @@ -357,6 +352,7 @@ observe.choice.doNotSave=Do not save observe.choice.doNothing=Do nothing observe.choice.not.create.fin.veille.activity.and.continue= observe.choice.quit=Quit +observe.choice.replace= observe.choice.save=Save observe.choice.useRemoteStorage=Use a remote storage observe.codeMesureEnum.ld1=LD1 @@ -1964,8 +1960,10 @@ observe.storage.config.data.mode= observe.storage.config.data.storage= observe.storage.config.export.required.read.data= observe.storage.config.export.required.read.referentiel= +observe.storage.config.left.storage= observe.storage.config.referentiel.mode= observe.storage.config.referentiel.storage= +observe.storage.config.right.storage= observe.storage.config.source.storage= observe.storage.connexionStatut.failed= observe.storage.connexionStatut.failed.description= @@ -2034,7 +2032,9 @@ observe.storage.label.remote= observe.storage.label.server= observe.storage.label.synchro= observe.storage.label.synchro.incoming= +observe.storage.label.synchro.leftSource= observe.storage.label.synchro.referentiel= +observe.storage.label.synchro.rightSource= observe.storage.locale.db= observe.storage.message.closed= observe.storage.message.closing= diff --git a/observe-application-swing/src/main/resources/i18n/observe-application-swing_es_ES.properties b/observe-application-swing/src/main/resources/i18n/observe-application-swing_es_ES.properties index e4cf149..5ef06cb 100644 --- a/observe-application-swing/src/main/resources/i18n/observe-application-swing_es_ES.properties +++ b/observe-application-swing/src/main/resources/i18n/observe-application-swing_es_ES.properties @@ -223,8 +223,6 @@ observe.actions.synchro.data.prepare.copyToLeftTask= observe.actions.synchro.data.prepare.copyToRightTask= observe.actions.synchro.data.prepare.deleteFromLeftTask= observe.actions.synchro.data.prepare.deleteFromRightTask= -observe.actions.synchro.data.prepare.skipFromLeftTask= -observe.actions.synchro.data.prepare.skipFromRightTask= observe.actions.synchro.data.step= observe.actions.synchro.data.step.description= observe.actions.synchro.data.title= @@ -232,23 +230,17 @@ observe.actions.synchro.data.title.tip= observe.actions.synchro.launch.operation=Comenzar la operación < %1$s > observe.actions.synchro.prepare.operation=Prepara la operación <%1$s> observe.actions.synchro.referential= +observe.actions.synchro.referential.action.copyToLeft.tip= +observe.actions.synchro.referential.action.copyToRight.tip= +observe.actions.synchro.referential.action.deleteFromLeft.tip= +observe.actions.synchro.referential.action.deleteFromRight.tip= +observe.actions.synchro.referential.action.desactivateFromLeft.tip= +observe.actions.synchro.referential.action.desactivateFromRight.tip= +observe.actions.synchro.referential.action.revertFromLeft.tip= +observe.actions.synchro.referential.action.revertFromRight.tip= +observe.actions.synchro.referential.action.skipFromLeft.tip= +observe.actions.synchro.referential.action.skipFromRight.tip= observe.actions.synchro.referential.config.mode= -observe.actions.synchro.referential.copyToLeft.tip= -observe.actions.synchro.referential.copyToLeftTask= -observe.actions.synchro.referential.copyToRight.tip= -observe.actions.synchro.referential.copyToRightTask= -observe.actions.synchro.referential.deleteFromLeft.tip= -observe.actions.synchro.referential.deleteFromLeftTask= -observe.actions.synchro.referential.deleteFromRight.tip= -observe.actions.synchro.referential.deleteFromRightTask= -observe.actions.synchro.referential.desactivateFromLeft.tip= -observe.actions.synchro.referential.desactivateFromLeftTask= -observe.actions.synchro.referential.desactivateFromLeftWithReplace.tip= -observe.actions.synchro.referential.desactivateFromLeftWithReplaceTask= -observe.actions.synchro.referential.desactivateFromRight.tip= -observe.actions.synchro.referential.desactivateFromRightTask= -observe.actions.synchro.referential.desactivateFromRightWithReplace.tip= -observe.actions.synchro.referential.desactivateFromRightWithReplaceTask= observe.actions.synchro.referential.description= observe.actions.synchro.referential.launch.operation= observe.actions.synchro.referential.legacy= @@ -274,27 +266,30 @@ observe.actions.synchro.referential.message.saveLocal.skip=No es necesario reali observe.actions.synchro.referential.message.synchro.local.modification= observe.actions.synchro.referential.obsolete.entities.list= observe.actions.synchro.referential.obsolete.entity.fix=Cambiar las referencias del objeto seleccionado -observe.actions.synchro.referential.prepare.copyToLeftTask= -observe.actions.synchro.referential.prepare.copyToRightTask= -observe.actions.synchro.referential.prepare.deleteFromLeftTask= -observe.actions.synchro.referential.prepare.deleteFromRightTask= -observe.actions.synchro.referential.prepare.desactivateFromLeftTask= -observe.actions.synchro.referential.prepare.desactivateFromLeftWithReplaceTask= -observe.actions.synchro.referential.prepare.desactivateFromRightTask= -observe.actions.synchro.referential.prepare.desactivateFromRightWithReplaceTask= -observe.actions.synchro.referential.revertFromRightLeft= -observe.actions.synchro.referential.revertFromRightTask= -observe.actions.synchro.referential.revertToLeft.tip= -observe.actions.synchro.referential.revertToRight.tip= +observe.actions.synchro.referential.replaceBefore.message= +observe.actions.synchro.referential.replaceBeforeDelete.title= +observe.actions.synchro.referential.replaceBeforeDesactivate.title= observe.actions.synchro.referential.safe.entity.to.choose.label= -observe.actions.synchro.referential.skipFromLeftTask= -observe.actions.synchro.referential.skipFromRightTask= -observe.actions.synchro.referential.skipToLeft.tip= -observe.actions.synchro.referential.skipToRight.tip= observe.actions.synchro.referential.step= observe.actions.synchro.referential.step.description= +observe.actions.synchro.referential.task.addToLeft= +observe.actions.synchro.referential.task.addToRight= +observe.actions.synchro.referential.task.deleteFromLeft= +observe.actions.synchro.referential.task.deleteFromRight= +observe.actions.synchro.referential.task.desactivateFromLeft= +observe.actions.synchro.referential.task.desactivateFromRight= +observe.actions.synchro.referential.task.desactivateWithReplaceFromLeft= +observe.actions.synchro.referential.task.desactivateWithReplaceFromRight= +observe.actions.synchro.referential.task.prepare= +observe.actions.synchro.referential.task.revertFromLeft= +observe.actions.synchro.referential.task.revertFromRight= +observe.actions.synchro.referential.task.skipFromLeft= +observe.actions.synchro.referential.task.skipFromRight= +observe.actions.synchro.referential.task.updateToLeft= +observe.actions.synchro.referential.task.updateToRight= observe.actions.synchro.referential.title= observe.actions.synchro.referential.title.tip= +observe.actions.synchro.referential.withMode= observe.actions.synchro.report.reset.tip=Deseleccionar el informe actual observe.actions.validate= observe.actions.validate.choose.report.directory=Elegir el directorio de los informes @@ -357,6 +352,7 @@ observe.choice.doNotSave=No grabar observe.choice.doNothing=No hacer nada observe.choice.not.create.fin.veille.activity.and.continue=No crear la actividad de fin de guardia y continuar observe.choice.quit=Cerrar +observe.choice.replace= observe.choice.save=Grabar observe.choice.useRemoteStorage=Usar la base de datos remota observe.codeMesureEnum.ld1=LD1 @@ -1964,8 +1960,10 @@ observe.storage.config.data.mode= observe.storage.config.data.storage= observe.storage.config.export.required.read.data= observe.storage.config.export.required.read.referentiel= +observe.storage.config.left.storage= observe.storage.config.referentiel.mode=Modo de importación del referencial observe.storage.config.referentiel.storage=Configuración de la base de referencia +observe.storage.config.right.storage= observe.storage.config.source.storage=Configuración de la base origen observe.storage.connexionStatut.failed= observe.storage.connexionStatut.failed.description= @@ -2034,7 +2032,9 @@ observe.storage.label.remote=Base remota observe.storage.label.server= observe.storage.label.synchro=Base de sincronización observe.storage.label.synchro.incoming=Base origen <%1$s> +observe.storage.label.synchro.leftSource= observe.storage.label.synchro.referentiel=Base central <%1$s> +observe.storage.label.synchro.rightSource= observe.storage.locale.db=(local) observe.storage.message.closed= observe.storage.message.closing= diff --git a/observe-application-swing/src/main/resources/i18n/observe-application-swing_fr_FR.properties b/observe-application-swing/src/main/resources/i18n/observe-application-swing_fr_FR.properties index 7ac0633..9b0aa31 100644 --- a/observe-application-swing/src/main/resources/i18n/observe-application-swing_fr_FR.properties +++ b/observe-application-swing/src/main/resources/i18n/observe-application-swing_fr_FR.properties @@ -223,33 +223,25 @@ observe.actions.synchro.data.prepare.copyToLeftTask=Préparation de la recopie v observe.actions.synchro.data.prepare.copyToRightTask=Préparation de la recopie vers la base de droite \: %s - %s observe.actions.synchro.data.prepare.deleteFromLeftTask=Préparation de la suppression de la base de gauche \: %s - %s observe.actions.synchro.data.prepare.deleteFromRightTask=Préparation de la suppression de la base de droite \: %s - %s -observe.actions.synchro.data.prepare.skipFromLeftTask=Préparation de la non prise en compte de la base de gauche \: %s - %s -observe.actions.synchro.data.prepare.skipFromRightTask=Préparation de la non prise en compte de la base de droite \: %s - %s observe.actions.synchro.data.step=Synchronisation bi-directionnelle de données observe.actions.synchro.data.step.description=Synchronisation bi-directionnelle des données utilisateurs observe.actions.synchro.data.title=Synchronisation bi-directionnelle de données observe.actions.synchro.data.title.tip=Synchronisation bi-directionnelle des données utilisateurs observe.actions.synchro.launch.operation=Démarrer l'opération < %1$s > observe.actions.synchro.prepare.operation=Préparer l'opération <%1$s> -observe.actions.synchro.referential=Synchronisation bi-directionnelle de référentiel -observe.actions.synchro.referential.config.mode=Mode synchronisation -observe.actions.synchro.referential.copyToLeft.tip=Copier le référentiel sélectionné vers la base de gauche -observe.actions.synchro.referential.copyToLeftTask=Copier vers la base de gauche \: %s - %s -observe.actions.synchro.referential.copyToRight.tip=Copier le référentiel sélectionné vers la base de droite -observe.actions.synchro.referential.copyToRightTask=Copier vers la base de droite \: %s - %s -observe.actions.synchro.referential.deleteFromLeft.tip=Supprimer le reférentiel sélectionnée de la base de gauche -observe.actions.synchro.referential.deleteFromLeftTask=Supprimer de la base de gauche \: %s - %s -observe.actions.synchro.referential.deleteFromRight.tip=Supprimer le référentiel sélectionnée de la base de droite -observe.actions.synchro.referential.deleteFromRightTask=Supprimer de la base de droite \: %s - %s -observe.actions.synchro.referential.desactivateFromLeft.tip=Désactiver (sans remplacement) le référentiel sélectionné de la base de gauche -observe.actions.synchro.referential.desactivateFromLeftTask=Désactiver de la base de gauche (sans remplacement) \: %s - %s -observe.actions.synchro.referential.desactivateFromLeftWithReplace.tip=Désactiver (avec remplacement) le référentiel sélectionné de la base de gauche -observe.actions.synchro.referential.desactivateFromLeftWithReplaceTask=Désactiver de la base de gauche (avec remplacement) \: %s - %s -observe.actions.synchro.referential.desactivateFromRight.tip=Désactiver (sans remplacement) le référentiel sélectionné de la base de droite -observe.actions.synchro.referential.desactivateFromRightTask=Désactiver de la base de droite (sans remplacement) \: %s - %s -observe.actions.synchro.referential.desactivateFromRightWithReplace.tip=Désactiver (avec remplacement) le référentiel sélectionné de la base de droite -observe.actions.synchro.referential.desactivateFromRightWithReplaceTask=Désactiver de la base de droite (avec remplacement) \: %s - %s -observe.actions.synchro.referential.description=Synchronisation bi-directionnelle de référentiel +observe.actions.synchro.referential=Synchronisation avancée du référentiel +observe.actions.synchro.referential.action.copyToLeft.tip=Copier le référentiel sélectionné vers la base de gauche +observe.actions.synchro.referential.action.copyToRight.tip=Copier le référentiel sélectionné vers la base de droite +observe.actions.synchro.referential.action.deleteFromLeft.tip=Supprimer le reférentiel sélectionnée de la base de gauche +observe.actions.synchro.referential.action.deleteFromRight.tip=Supprimer le référentiel sélectionnée de la base de droite +observe.actions.synchro.referential.action.desactivateFromLeft.tip=Désactiver (sans remplacement) le référentiel sélectionné dans la base de gauche +observe.actions.synchro.referential.action.desactivateFromRight.tip=Désactiver (sans remplacement) le référentiel sélectionné dans la base de droite +observe.actions.synchro.referential.action.revertFromLeft.tip=Revenir en arrière du référentiel sélectionné à gauche +observe.actions.synchro.referential.action.revertFromRight.tip=Revenir en arrière du référentiel sélectionné à droite +observe.actions.synchro.referential.action.skipFromLeft.tip=Ne rien faire sur le référentiel sélectionné à gauche +observe.actions.synchro.referential.action.skipFromRight.tip=Ne rien faire sur le référentiel sélectionné à droite +observe.actions.synchro.referential.config.mode=Mode de synchronisation +observe.actions.synchro.referential.description=Synchronisation avancée du référentiel observe.actions.synchro.referential.launch.operation=Démarrer l'opération < %1$s > observe.actions.synchro.referential.legacy=Synchronisation du référentiel observe.actions.synchro.referential.legacy.description=Synchroniser le référentiel depuis la base centrale @@ -274,27 +266,30 @@ observe.actions.synchro.referential.message.saveLocal.skip=L'opération de sauve observe.actions.synchro.referential.message.synchro.local.modification=Des données ont été modifiées et la base locale doit être sauvée. observe.actions.synchro.referential.obsolete.entities.list=Liste des entités du référentiel obsolètes observe.actions.synchro.referential.obsolete.entity.fix=Changer les références sur l'objet sélectionné -observe.actions.synchro.referential.prepare.copyToLeftTask=Préparation de la recopie vers la base de gauche \: %s - %s -observe.actions.synchro.referential.prepare.copyToRightTask=Préparation de la recopie vers la base de droite \: %s - %s -observe.actions.synchro.referential.prepare.deleteFromLeftTask=Préparation de la suppression de la base de gauche \: %s - %s -observe.actions.synchro.referential.prepare.deleteFromRightTask=Préparation de la suppression de la base de droite \: %s - %s -observe.actions.synchro.referential.prepare.desactivateFromLeftTask=Préparation de la désactivation de la base de gauche (sans remplacement) \: %s - %s -observe.actions.synchro.referential.prepare.desactivateFromLeftWithReplaceTask=Préparation de la désactivation de la base de gauche (avec remplacement) \: %s - %s -observe.actions.synchro.referential.prepare.desactivateFromRightTask=Préparation de la désactivation de la base de droite (sans remplacement) \: %s - %s -observe.actions.synchro.referential.prepare.desactivateFromRightWithReplaceTask=Préparation de la désactivation de la base de droite (avec remplacement) \: %s - %s -observe.actions.synchro.referential.revertFromRightLeft=Préparation du retour en arrière de la base de gauche \: %s - %s -observe.actions.synchro.referential.revertFromRightTask=Préparation du retour en arrière de la base de droite \: %s - %s -observe.actions.synchro.referential.revertToLeft.tip=Revenir en arrière du référentiel sélectionné à gauche -observe.actions.synchro.referential.revertToRight.tip=Revenir en arrière du référentiel sélectionné à gauche +observe.actions.synchro.referential.replaceBefore.message=<html><body>Choisir un référentiel de remplacement de <i>%s</i> \: <b>%s</b>.<br/><br/> +observe.actions.synchro.referential.replaceBeforeDelete.title=Remplacement avant suppression - %s - %s +observe.actions.synchro.referential.replaceBeforeDesactivate.title=Remplacement avant désactivation - %s - %s observe.actions.synchro.referential.safe.entity.to.choose.label=Objets disponibles -observe.actions.synchro.referential.skipFromLeftTask=Ne pas tenir compte depuis la base de gauche \: %s - %s -observe.actions.synchro.referential.skipFromRightTask=Ne pas tenir compte depuis la base de droite \: %s - %s -observe.actions.synchro.referential.skipToLeft.tip=Ne rien faire sur le référentiel sélectionné à gauche -observe.actions.synchro.referential.skipToRight.tip=Ne rien faire sur le référentiel sélectionné à droite -observe.actions.synchro.referential.step=Synchronisation bi-directionnelle de référentiel +observe.actions.synchro.referential.step=Synchronisation avancée du référentiel observe.actions.synchro.referential.step.description=Synchronisation bi-directionnelle de référentiel -observe.actions.synchro.referential.title=Synchronisation bi-directionnelle de référentiel -observe.actions.synchro.referential.title.tip=Synchronisation bi-directionnelle de référentiel +observe.actions.synchro.referential.task.addToLeft=<html><body>Ajouter dans la base de gauche \: <i>%s</i> - «<b>%s</b>» +observe.actions.synchro.referential.task.addToRight=<html><body>Ajouter dans la base de droite \: <i>%s</i> - «<b>%s</b>» +observe.actions.synchro.referential.task.deleteFromLeft=<html><body>Supprimer dans la base de gauche \: <i>%s</i> - «<b>%s</b>» +observe.actions.synchro.referential.task.deleteFromRight=<html><body>Supprimer dans la base de droite \: <i>%s</i> - «<b>%s</b>» à remplacer par «<b>%s</b>» +observe.actions.synchro.referential.task.desactivateFromLeft=<html><body>Désactiver (sans remplacement) dans la base de gauche \: <i>%s</i> - «<b>%s</b>» +observe.actions.synchro.referential.task.desactivateFromRight=<html><body>Désactiver (sans remplacement) dans la base dans droite \: <i>%s</i> - «<b>%s</b>» +observe.actions.synchro.referential.task.desactivateWithReplaceFromLeft=<html><body>Désactiver dans la base de gauche \: <i>%s</i> - «<b>%s</b>» à remplacer par «<b>%s</b>» +observe.actions.synchro.referential.task.desactivateWithReplaceFromRight=<html><body>Désactiver dans la base de droite \: <i>%s</i> - «<b>%s</b>» à remplacer par «<b>%s</b>» +observe.actions.synchro.referential.task.prepare=Enregistement de l'action %s +observe.actions.synchro.referential.task.revertFromLeft=<html><body>Revenir en arrière dans la base de gauche \: <i>%s</i> - «<b>%s</b>» +observe.actions.synchro.referential.task.revertFromRight=<html><body>Revenir en arrière dans la base de droite \: <i>%s</i> - «<b>%s</b>» +observe.actions.synchro.referential.task.skipFromLeft=<html><body>Ne rien faire dans la base de gauche \: <i>%s</i> - «<b>%s</b>» +observe.actions.synchro.referential.task.skipFromRight=<html><body>Ne rien faire dans la base de droite \: <i>%s</i> - «<b>%s</b>» +observe.actions.synchro.referential.task.updateToLeft=<html><body>Mettre à jour dans la base de gauche \: <i>%s</i> - «<b>%s</b>» +observe.actions.synchro.referential.task.updateToRight=<html><body>Mettre à jour dans la base de droite \: <i>%s</i> - «<b>%s</b>» +observe.actions.synchro.referential.title=Synchronisation avancée du référentiel +observe.actions.synchro.referential.title.tip=Synchronisation avancée du référentiel +observe.actions.synchro.referential.withMode=Synchronisation du référentiel (%s) observe.actions.synchro.report.reset.tip=Déselectionner le report courant. observe.actions.validate=Valider les données observe.actions.validate.choose.report.directory=Choisir le répertoire des rapports @@ -357,6 +352,7 @@ observe.choice.doNotSave=Ne pas enregistrer observe.choice.doNothing=Ne rien faire observe.choice.not.create.fin.veille.activity.and.continue=Ne pas créer l'activité de fin de veille et continuer observe.choice.quit=Fermer +observe.choice.replace=Remplacer observe.choice.save=Enregistrer observe.choice.useRemoteStorage=Utiliser une base distante observe.codeMesureEnum.ld1=LD1 @@ -1964,8 +1960,10 @@ observe.storage.config.data.mode=Mode d'import des données observe.storage.config.data.storage=Configuration de la base de données observe.storage.config.export.required.read.data=Vous devez posséder les droits de lecture sur les données de la base distante observe.storage.config.export.required.read.referentiel=Vous devez posséder les droits de lecture sur le référentiel de la base distante +observe.storage.config.left.storage=Configuration de la base de gauche observe.storage.config.referentiel.mode=Mode d'import du référentiel observe.storage.config.referentiel.storage=Configuration de la base de référence +observe.storage.config.right.storage=Configuration de la base de droite observe.storage.config.source.storage=Configuration de la base source observe.storage.connexionStatut.failed=Connexion échouée observe.storage.connexionStatut.failed.description=La connexion a échouée pour la raison suivante \:\n %1$s @@ -2034,7 +2032,12 @@ observe.storage.label.remote=Base distante observe.storage.label.server=Serveur Distant observe.storage.label.synchro=Base de synchronisation observe.storage.label.synchro.incoming=Base source <%1$s> +observe.storage.label.synchro.incoming.name=base source +observe.storage.label.synchro.leftSource=Base de gauche <%1$s> +observe.storage.label.synchro.leftSource.name=base de gauche observe.storage.label.synchro.referentiel=Base centrale <%1$s> +observe.storage.label.synchro.rightSource=Base de droite <%1$s> +observe.storage.label.synchro.rightSource.name=base de droite observe.storage.locale.db=(locale) observe.storage.message.closed=La connexion [%1$s] est fermé observe.storage.message.closing=Fermeture de la connexion [%1$s] diff --git a/observe-application-swing/src/main/resources/icons/action-desactivateFromRightWithReplace.png b/observe-application-swing/src/main/resources/icons/action-desactivateWithReplaceFromLeft.png similarity index 100% rename from observe-application-swing/src/main/resources/icons/action-desactivateFromRightWithReplace.png rename to observe-application-swing/src/main/resources/icons/action-desactivateWithReplaceFromLeft.png diff --git a/observe-application-swing/src/main/resources/icons/action-desactivateFromLeftWithReplace.png b/observe-application-swing/src/main/resources/icons/action-desactivateWithReplaceFromRight.png similarity index 100% rename from observe-application-swing/src/main/resources/icons/action-desactivateFromLeftWithReplace.png rename to observe-application-swing/src/main/resources/icons/action-desactivateWithReplaceFromRight.png diff --git a/observe-application-swing/src/main/resources/icons/action-synchroUpdate.png b/observe-application-swing/src/main/resources/icons/action-synchroUpdate.png index 61a8556..e501b66 100644 Binary files a/observe-application-swing/src/main/resources/icons/action-synchroUpdate.png and b/observe-application-swing/src/main/resources/icons/action-synchroUpdate.png differ -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.