GitLab

at 2024-06-24T17:08:45+02:00

Permettre la sauvegarde de la source de données, si le droit en lecture de données est présent

Amélioration des droits sur l'onglet de configuration de la synchronisation avancée de données

Correction d'un traduction sur les droits nécessaires pour un appel service

Gestion plus fine des droits sur les actions copier/supprimer

Extraction du code pour gérer le mode de synchronisation et utilisation sur la synchronisation de référentiel

Mise en place du mode de synchronisation sur la synchronisation de données

Revue de la disposition des actions propre à chaque arbre de navigation pour les positionner au centre de l'écran (comme en synchronisation avancée de référentiels)

Merge branch 'feature/issue_2888' into develop
En synchro avancée de données, amélioration de la gestion des droits des bases utilisées - Closes #2888

 observe.constant.AdminStep.SYNCHRONIZE.description

 observe.constant.AdminStep.VALIDATE

 observe.constant.AdminStep.VALIDATE.description

-observe.constant.ReferentialSynchronizeMode.BOTH

-observe.constant.ReferentialSynchronizeMode.FROM_LEFT_TO_RIGHT

-observe.constant.ReferentialSynchronizeMode.FROM_RIGHT_TO_LEFT

+observe.constant.SynchronizeMode.BOTH

+observe.constant.SynchronizeMode.FROM_LEFT_TO_RIGHT

+observe.constant.SynchronizeMode.FROM_RIGHT_TO_LEFT

 observe.constant.ValidationModelMode.DATA

 observe.constant.ValidationModelMode.DATA.description

 observe.constant.ValidationModelMode.REFERENTIEL

 observe.ui.action.choose.reportFile

 observe.ui.action.close

 observe.ui.action.close.synchro.tip

+observe.ui.action.config.export.required.read.data

 observe.ui.action.config.export.required.write.data

 observe.ui.action.config.left.datasource.required.write.data

 observe.ui.action.configuration.tip

 observe.ui.datasource.editor.actions.synchro.data.message.data.loaded

 observe.ui.datasource.editor.actions.synchro.data.title

 observe.ui.datasource.editor.actions.synchro.data.title.tip

+observe.ui.datasource.editor.actions.synchro.data.withMode

 observe.ui.datasource.editor.actions.synchro.launch.operation

 observe.ui.datasource.editor.actions.synchro.prepare.operation

 observe.ui.datasource.editor.actions.synchro.referential

 observe.ui.datasource.editor.actions.report.select.file

 observe.ui.datasource.editor.actions.report.select.file.tip

 observe.ui.datasource.editor.actions.report.variables

+observe.ui.datasource.editor.actions.synchro.config.mode

 observe.ui.datasource.editor.actions.synchro.data.actionsToPerform

-observe.ui.datasource.editor.actions.synchro.referential.config.mode

 observe.ui.datasource.editor.actions.synchro.referential.obsolete.entities.list

 observe.ui.datasource.editor.actions.synchro.referential.obsolete.entity.fix

 observe.ui.datasource.editor.actions.synchro.referential.safe.entity.to.choose.label

+package fr.ird.observe.client.datasource.actions.synchronize;

+

+/*-

+ * #%L

+ * ObServe Client :: DataSource :: Actions

+ * %%

+ * Copyright (C) 2008 - 2024 IRD, Ultreia.io

+ * %%

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as

+ * published by the Free Software Foundation, either version 3 of the

+ * License, or (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public

+ * License along with this program.  If not, see

+ * <http://www.gnu.org/licenses/gpl-3.0.html>.

+ * #L%

+ */

+

+import org.nuiton.jaxx.runtime.swing.action.JAXXObjectActionSupport;

+

+import javax.swing.ActionMap;

+import javax.swing.InputMap;

+import javax.swing.JComponent;

+import java.awt.event.ActionEvent;

+

+/**

+ * To select synchronize mode on admin config ui.

+ * <p>

+ * Created at 25/06/2024.

+ *

+ * @author Tony Chemit - dev@tchemit.fr

+ * @since 9.3.6

+ */

+public class SelectSynchronizeMode extends JAXXObjectActionSupport<SynchronizeConfigUI> {

+

+    private final SynchronizeMode mode;

+

+    public SelectSynchronizeMode(SynchronizeMode mode) {

+        super(SelectSynchronizeMode.class.getName() + "#" + mode, mode.getLabel(), mode.getLabel(), mode.getIconName(), mode.getKeyStroke());

+        this.mode = mode;

+    }

+

+    @Override

+    protected InputMap getInputMap(SynchronizeConfigUI ui, int inputMapCondition) {

+        return ui.getInputMap(inputMapCondition);

+    }

+

+    @Override

+    protected int getInputMapCondition() {

+        return JComponent.WHEN_IN_FOCUSED_WINDOW;

+    }

+

+    @Override

+    protected ActionMap getActionMap(SynchronizeConfigUI ui) {

+        return ui.getActionMap();

+    }

+

+    @Override

+    protected void doActionPerformed(ActionEvent e, SynchronizeConfigUI ui) {

+        ui.getStepModel().setSynchronizeMode(mode);

+    }

+}
+package fr.ird.observe.client.datasource.actions.synchronize;

+

+/*-

+ * #%L

+ * ObServe Client :: DataSource :: Actions

+ * %%

+ * Copyright (C) 2008 - 2024 IRD, Ultreia.io

+ * %%

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as

+ * published by the Free Software Foundation, either version 3 of the

+ * License, or (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public

+ * License along with this program.  If not, see

+ * <http://www.gnu.org/licenses/gpl-3.0.html>.

+ * #L%

+ */

+

+import fr.ird.observe.client.datasource.actions.AdminUIModel;

+import fr.ird.observe.client.datasource.editor.api.wizard.connexion.DataSourceSelectorModel;

+import org.apache.logging.log4j.LogManager;

+import org.apache.logging.log4j.Logger;

+import org.nuiton.jaxx.runtime.JAXXObject;

+import org.nuiton.jaxx.runtime.swing.JAXXButtonGroup;

+

+import javax.swing.ActionMap;

+import javax.swing.InputMap;

+import javax.swing.JToggleButton;

+import java.util.EnumSet;

+

+/**

+ * Contract of admin config ui when using synchronize mode.

+ * <p>

+ * Created at 25/06/2024.

+ *

+ * @author Tony Chemit - dev@tchemit.fr

+ * @since 9.3.6

+ */

+public interface SynchronizeConfigUI extends JAXXObject {

+    Logger log = LogManager.getLogger(SynchronizeConfigUI.class);

+

+    JToggleButton getBOTH();

+

+    JToggleButton getFROM_LEFT_TO_RIGHT();

+

+    JToggleButton getFROM_RIGHT_TO_LEFT();

+

+    AdminUIModel getModel();

+

+    SynchronizeModel getStepModel();

+

+    JAXXButtonGroup getSynchronizeMode();

+

+    ActionMap getActionMap();

+

+    InputMap getInputMap(int condition);

+

+    default void updateSynchroModes() {

+        AdminUIModel model = getModel();

+        SynchronizeModel stepModel = getStepModel();

+        SynchronizeMode synchronizeMode = stepModel.getSynchronizeMode();

+        log.info(String.format("Will update synchro modes (previous value: %s)", synchronizeMode));

+        DataSourceSelectorModel leftSourceModel = model.getConfigModel().getLeftSourceModel();

+        if (!leftSourceModel.isInit()) {

+            return;

+        }

+        DataSourceSelectorModel rightSourceModel = model.getConfigModel().getRightSourceModel();

+        if (!rightSourceModel.isInit()) {

+            return;

+        }

+        boolean dataSourcesValid = leftSourceModel.validateExt() && rightSourceModel.validateExt();

+        boolean leftToRightEnabled = dataSourcesValid && stepModel.isCanWrite(rightSourceModel);

+        log.debug(String.format("Update synchro modes: leftToRight: %s", leftToRightEnabled));

+        boolean rightToLeftEnabled = dataSourcesValid && stepModel.isCanWrite(leftSourceModel);

+        log.debug(String.format("Update synchro modes: rightToLeft: %s", rightToLeftEnabled));

+        boolean bothEnabled = leftToRightEnabled && rightToLeftEnabled;

+        log.debug(String.format("Update synchro modes: both: %s", bothEnabled));

+        getFROM_LEFT_TO_RIGHT().setEnabled(leftToRightEnabled);

+        getFROM_RIGHT_TO_LEFT().setEnabled(rightToLeftEnabled);

+        getBOTH().setEnabled(bothEnabled);

+        EnumSet<SynchronizeMode> candidates = EnumSet.allOf(SynchronizeMode.class);

+        if (!leftToRightEnabled) {

+            candidates.remove(SynchronizeMode.FROM_LEFT_TO_RIGHT);

+        }

+        if (!rightToLeftEnabled) {

+            candidates.remove(SynchronizeMode.FROM_RIGHT_TO_LEFT);

+        }

+        if (!bothEnabled) {

+            candidates.remove(SynchronizeMode.BOTH);

+        }

+        if (!candidates.contains(synchronizeMode)) {

+            if (candidates.isEmpty()) {

+                synchronizeMode = null;

+            } else {

+                synchronizeMode = candidates.iterator().next();

+            }

+        }

+        log.info(String.format("Will update synchro modes (new value: %s)", synchronizeMode));

+        stepModel.setSynchronizeMode(null);

+        stepModel.setSynchronizeMode(synchronizeMode);

+    }

+}
-package fr.ird.observe.client.datasource.actions.synchronize.referential.ng.actions;

-

-/*-

+/*

  * #%L

  * ObServe Client :: DataSource :: Actions

  * %%

  * #L%

  */

-import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.ReferentialSynchroConfigUI;

-import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.ReferentialSynchronizeMode;

-import org.nuiton.jaxx.runtime.swing.action.JComponentActionSupport;

-

-import java.awt.event.ActionEvent;

-

-public class SelectReferentialSynchronizeMode extends JComponentActionSupport<ReferentialSynchroConfigUI> {

-

-    private final ReferentialSynchronizeMode mode;

+#synchronizeConfigPanel {

+  border:{new TitledBorder(t("observe.ui.datasource.editor.actions.synchro.config.mode") +  "")};

+}

-    public SelectReferentialSynchronizeMode(ReferentialSynchronizeMode mode) {

-        super(SelectReferentialSynchronizeMode.class.getName() + "#" + mode, mode.getLabel(), mode.getLabel(), mode.getIconName(), mode.getKeyStroke());

-        this.mode = mode;

-    }

+#synchronizeMode {

+  selectedValue:{stepModel.getSynchronizeMode()};

+}

-    @Override

-    protected void doActionPerformed(ActionEvent e, ReferentialSynchroConfigUI ui) {

-        ui.getStepModel().setSynchronizeMode(mode);

-    }

+.synchronizeMode {

+  buttonGroup:"synchronizeMode";

+  enabled:false;

+  selected:{java.util.Objects.equals(fr.ird.observe.client.datasource.actions.synchronize.SynchronizeMode.%%, stepModel.getSynchronizeMode())};

+  value:{fr.ird.observe.client.datasource.actions.synchronize.SynchronizeMode.%%};

+  action:{new fr.ird.observe.client.datasource.actions.synchronize.SelectSynchronizeMode(fr.ird.observe.client.datasource.actions.synchronize.SynchronizeMode.%%)};

 }

+
-package fr.ird.observe.client.datasource.actions.synchronize.referential.ng;

+package fr.ird.observe.client.datasource.actions.synchronize;

 /*-

  * #%L

 import javax.swing.KeyStroke;

 /**

- * Type de synchronisation de référentiel. Définit quelles bases sont en écriture.

+ * Synchronize mode, defines on which side we can write.

  * <p>

  * Created on 10/08/16.

  *

  * @since 5.0

  */

 @TranslateEnumeration(name = I18nDecoratorHelper.I18N_CONSTANT_LABEL, pattern = I18nDecoratorHelper.I18N_CONSTANT_LABEL_PATTERN)

-public enum ReferentialSynchronizeMode {

-

+public enum SynchronizeMode {

     /**

      * La base de gauche est en lecture, la base de droite est en écriture.

      */

      * La base de gauche est en écriture, la base de droite est en écriture.

      */

     BOTH(true, true, "copyToBoth");

-

     /**

      * Est ce que la source de gauche est en écriture ?

      */

     private final String iconName;

-    ReferentialSynchronizeMode(boolean leftWrite, boolean rightWrite, String iconName) {

+    SynchronizeMode(boolean leftWrite, boolean rightWrite, String iconName) {

         this.leftWrite = leftWrite;

         this.rightWrite = rightWrite;

         this.keyStroke = ObserveKeyStrokesSupport.getFunctionKeyStroke(ordinal() + 1);

     }

     public String getLabel() {

-        return ReferentialSynchronizeModeI18n.getLabel(this);

+        return SynchronizeModeI18n.getLabel(this);

     }

 }
+package fr.ird.observe.client.datasource.actions.synchronize;

+

+/*-

+ * #%L

+ * ObServe Client :: DataSource :: Actions

+ * %%

+ * Copyright (C) 2008 - 2024 IRD, Ultreia.io

+ * %%

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as

+ * published by the Free Software Foundation, either version 3 of the

+ * License, or (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public

+ * License along with this program.  If not, see

+ * <http://www.gnu.org/licenses/gpl-3.0.html>.

+ * #L%

+ */

+

+import fr.ird.observe.client.datasource.actions.AdminActionModel;

+import fr.ird.observe.client.datasource.actions.AdminUI;

+import fr.ird.observe.client.datasource.actions.AdminUIModel;

+import fr.ird.observe.client.datasource.actions.synchronize.data.DataSynchroModel;

+import fr.ird.observe.client.datasource.editor.api.wizard.connexion.DataSourceSelectorModel;

+import io.ultreia.java4all.bean.JavaBean;

+

+/**

+ * Contract of {@link AdminActionModel} model when using synchronize mode.

+ * <p>

+ * Created at 25/06/2024.

+ *

+ * @author Tony Chemit - dev@tchemit.fr

+ * @since 9.3.6

+ */

+public interface SynchronizeModel extends JavaBean {

+

+    String SYNCHRONIZE_MODE_PROPERTY_NAME = "synchronizeMode";

+

+    SynchronizeMode getSynchronizeMode();

+

+    void setSynchronizeMode(SynchronizeMode synchronizeMode);

+

+    default void start(AdminUIModel uiModel) {

+

+        addPropertyChangeListener(SYNCHRONIZE_MODE_PROPERTY_NAME, evt -> {

+            if (uiModel.isWasStarted()) {

+                // on ne propage plus rien (il n'y a plus de configuration possible...)

+                return;

+            }

+            uiModel.validate();

+        });

+

+        setSynchronizeMode(SynchronizeMode.FROM_LEFT_TO_RIGHT);

+    }

+

+    default void afterInit(AdminUI parentUI) {

+        addPropertyChangeListener(DataSynchroModel.SYNCHRONIZE_MODE_PROPERTY_NAME, evt -> {

+            SynchronizeMode newValue = (SynchronizeMode) evt.getNewValue();

+            if (parentUI.getTabs().getComponentCount() > 1 && newValue != null) {

+                parentUI.getTabs().setTitleAt(1, getTitleWithMode(newValue));

+            }

+        });

+    }

+

+    boolean isCanWrite(DataSourceSelectorModel dataSourceSelectorModel);

+

+    String getTitleWithMode(SynchronizeMode mode);

+}
+<!--

+  #%L

+  ObServe Client :: DataSource :: Actions

+  %%

+  Copyright (C) 2008 - 2023 IRD, Ultreia.io

+  %%

+  This program is free software: you can redistribute it and/or modify

+  it under the terms of the GNU General Public License as

+  published by the Free Software Foundation, either version 3 of the

+  License, or (at your option) any later version.

+  This program is distributed in the hope that it will be useful,

+  but WITHOUT ANY WARRANTY; without even the implied warranty of

+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+  GNU General Public License for more details.

+  You should have received a copy of the GNU General Public

+  License along with this program.  If not, see

+  <http://www.gnu.org/licenses/gpl-3.0.html>.

+  #L%

+  -->

+<JPanel id="dataSynchronizeConfig" layout="{new BorderLayout()}" implements="fr.ird.observe.client.datasource.actions.synchronize.SynchronizeConfigUI">

+

+  <style source="../SynchronizeConfigUI.jcss"/>

+  <import>

+    fr.ird.observe.client.datasource.actions.AdminUIModel

+

+    io.ultreia.java4all.i18n.I18n

+

+    static io.ultreia.java4all.i18n.I18n.t

+    static fr.ird.observe.client.util.UIHelper.getStringValue

+  </import>

+

+  <DataSynchroUIHandler id='handler' initializer='getContextValue(DataSynchroUIHandler.class)'/>

+  <AdminUIModel id='model' initializer='getContextValue(AdminUIModel.class)'/>

+  <DataSynchroModel id='stepModel' initializer='model.getDataSynchroModel()'/>

+  <ButtonGroup id='synchronizeMode'/>

+

+  <script><![CDATA[

+public void destroy() {

+    model = null;

+    stepModel = null;

+}

+]]>

+  </script>

+

+  <JPanel id="synchronizeConfigPanel" constraints='BorderLayout.CENTER' layout='{new GridLayout(0, 1)}'>

+    <JToggleButton id="FROM_LEFT_TO_RIGHT" styleClass="synchronizeMode"/>

+    <JToggleButton id="FROM_RIGHT_TO_LEFT" styleClass="synchronizeMode"/>

+    <JToggleButton id="BOTH" styleClass="synchronizeMode"/>

+  </JPanel>

+</JPanel>
 import fr.ird.observe.client.datasource.actions.AdminActionModel;

 import fr.ird.observe.client.datasource.actions.AdminStep;

 import fr.ird.observe.client.datasource.actions.AdminUIModel;

+import fr.ird.observe.client.datasource.actions.synchronize.SynchronizeMode;

+import fr.ird.observe.client.datasource.actions.synchronize.SynchronizeModel;

 import fr.ird.observe.client.datasource.actions.synchronize.data.tree.DataSelectionTreePaneModel;

 import fr.ird.observe.client.datasource.api.data.DataTaskSupport;

 import fr.ird.observe.client.datasource.api.data.TaskSide;

 import fr.ird.observe.client.datasource.editor.api.wizard.connexion.DataSourceSelectorModel;

 import fr.ird.observe.datasource.configuration.ObserveDataSourceInformation;

+import io.ultreia.java4all.i18n.I18n;

 import io.ultreia.java4all.util.TwoSideContext;

 import org.apache.logging.log4j.LogManager;

 import org.apache.logging.log4j.Logger;

  * @author Tony Chemit - dev@tchemit.fr

  * @since 5.0

  */

-public class DataSynchroModel extends AdminActionModel implements TwoSideContext<TaskSide, DataSelectionTreePaneModel> {

-

+public class DataSynchroModel extends AdminActionModel implements SynchronizeModel, TwoSideContext<TaskSide, DataSelectionTreePaneModel> {

     public static final String LEFT_MODEL = "leftModel";

     public static final String RIGHT_MODEL = "rightModel";

     private static final String TASKS_EMPTY_PROPERTY_NAME = "tasksEmpty";

      * Right model.

      */

     private final DataSelectionTreePaneModel rightModel = new DataSelectionTreePaneModel();

-

     /**

      * Registered tasks to apply.

      */

     private final DefaultListModel<DataTaskSupport> tasks = new DefaultListModel<>();

+    /**

+     * Synchronize mode.

+     */

+    private SynchronizeMode synchronizeMode;

     public DataSynchroModel() {

         super(AdminStep.DATA_SYNCHRONIZE);

         rightSourceModel.setRequiredReadOnReferential(true);

         rightSourceModel.setRequiredReadOnData(true);

         fireTasksEmptyChanged();

+        SynchronizeModel.super.start(uiModel);

+    }

+

+    @Override

+    public boolean isCanWrite(DataSourceSelectorModel dataSourceSelectorModel) {

+        return dataSourceSelectorModel.isCanWriteData();

+    }

+

+    @Override

+    public String getTitleWithMode(SynchronizeMode mode) {

+        return I18n.t("observe.ui.datasource.editor.actions.synchro.data.withMode", mode.getLabel());

+    }

+

+    @Override

+    public SynchronizeMode getSynchronizeMode() {

+        return synchronizeMode;

+    }

+

+    @Override

+    public void setSynchronizeMode(SynchronizeMode synchronizeMode) {

+        Object oldValue = getSynchronizeMode();

+        this.synchronizeMode = synchronizeMode;

+        firePropertyChange(SYNCHRONIZE_MODE_PROPERTY_NAME, oldValue, synchronizeMode);

     }

     @Override

 import fr.ird.observe.client.datasource.api.data.TaskSide;

 import fr.ird.observe.client.datasource.editor.api.selection.actions.SelectUnselectWithOpposite;

 import fr.ird.observe.client.datasource.editor.api.wizard.StorageUIModel;

+import fr.ird.observe.client.util.UIHelper;

 import fr.ird.observe.client.util.init.UIInitHelper;

 import org.nuiton.jaxx.runtime.spi.UIHandler;

         SelectUnselectWithOpposite.init(ui.getLeftTreePane().getTree(), null, new SelectUnselectWithOpposite(ui.getRightTreePane().getTree()));

         JScrollPane descriptionPane = ui.getDescriptionPane();

         descriptionPane.getParent().remove(descriptionPane);

-

         hideFixedPanelLabel(ui);

+        ui.getStepModel().afterInit(parentUI);

     }

     @Override

     protected void initConfig(ConfigUI configUI) {

+        configUI.getLeftSourceConfig().getSourceInfoLabel().setVisible(true);

         configUI.getLeftSourceModel().setSourceLabel(t("observe.ui.datasource.storage.config.left.storage"));

+        configUI.getLeftSourceConfig().getSourceInfoLabel().setText(t("observe.ui.action.config.export.required.read.data"));

+        configUI.getRightSourceConfig().getSourceInfoLabel().setText(t("observe.ui.action.config.export.required.read.data"));

         configUI.getRightSourceModel().setSourceLabel(t("observe.ui.datasource.storage.config.right.storage"));

+        DataSynchroConfigUI extraConfig = new DataSynchroConfigUI(UIHelper.initialContext(configUI, this));

+        configUI.getExtraConfig().add(extraConfig);

         ConfigModel configModel = configUI.getStepModel();

+        configModel.addPropertyChangeListener(StorageUIModel.VALID_STEP_PROPERTY_NAME, evt -> extraConfig.updateSynchroModes());

         configModel.addPropertyChangeListener(StorageUIModel.VALID_PROPERTY_NAME, evt -> getModel().validate());

     }

                 rightModel.setSource(rightSource);

                 DataSelectionTreePane leftTreePane = tabUI.getLeftTreePane();

-                DataSelectionTreePaneHandler.initDatasource(configModel.getLeftSourceModel(), rightSource.getDataSourceInformation().canWriteData(), leftTreePane, leftModel.getIdStates());

+                boolean rightCanWrite = rightSource.getDataSourceInformation().canWriteData()

+                        && configModel.getRightSourceModel().isCanWriteReferential()

+                        && stepModel.getSynchronizeMode().isRightWrite();

+                DataSelectionTreePaneHandler.initDatasource(configModel.getLeftSourceModel(), rightCanWrite, stepModel.getSynchronizeMode().isLeftWrite(),leftTreePane, leftModel.getIdStates());

                 progressModel.increments();

                 sendMessage(t("observe.ui.datasource.editor.actions.synchro.data.message.data.loaded", leftSourceLabel));

                 DataSelectionTreePane rightTreePane = tabUI.getRightTreePane();

-                DataSelectionTreePaneHandler.initDatasource(configModel.getRightSourceModel(), leftSource.getDataSourceInformation().canWriteData(), rightTreePane, rightModel.getIdStates());

+                boolean leftCanWrite = leftSource.getDataSourceInformation().canWriteData()

+                        && configModel.getLeftSourceModel().isCanWriteReferential()

+                        && stepModel.getSynchronizeMode().isLeftWrite();

+                DataSelectionTreePaneHandler.initDatasource(configModel.getRightSourceModel(), leftCanWrite, stepModel.getSynchronizeMode().isRightWrite(),rightTreePane, rightModel.getIdStates());

                 progressModel.increments();

                 sendMessage(t("observe.ui.datasource.editor.actions.synchro.data.message.data.loaded", rightSourceLabel));

     <JToggleButton id="toggleNewer"/>

     <JToggleButton id="toggleOlder"/>

     <JToggleButton id="toggleEquals"/>

-    <JSeparator orientation='{JSeparator.VERTICAL}'/>

-    <JButton id="copy" enabled="false"/>

-    <JButton id="delete" enabled="false"/>

   </JToolBar>

   <SelectionTreePane id='tree' constructorParams="!side.onLeft()" constraints='BorderLayout.CENTER'/>

+  <JToolBar id="middleActions" layout="{new GridLayout(0, 1)}" constraints='BorderLayout.EAST'>

+    <JButton id="copy" enabled="false" visible="{model.isCanCopy()}"/>

+    <JButton id="delete" enabled="false" visible="{model.isCanDelete()}"/>

+  </JToolBar>

 </JPanel>
 import javax.swing.SwingUtilities;

 import javax.swing.ToolTipManager;

 import javax.swing.tree.TreePath;

+import java.awt.BorderLayout;

 import java.awt.Color;

 import java.awt.Component;

 import java.awt.event.MouseAdapter;

  */

 public class DataSelectionTreePaneHandler implements UIHandler<DataSelectionTreePane> {

-    private static final Logger log = LogManager.getLogger(DataSelectionTreePaneHandler.class);

-

     public static final TwoSideContext<TaskSide, String> MODEL_NAMES = TwoSideContext.of(DataSynchroModel.LEFT_MODEL, DataSynchroModel.RIGHT_MODEL);

+    private static final Logger log = LogManager.getLogger(DataSelectionTreePaneHandler.class);

     static DataSelectionTreePaneModel getModel(DataSelectionTreePane ui) {

         return ui.getContextValue(DataSelectionTreePaneModel.class, MODEL_NAMES.onSameSide(ui.getSide()));

         for (Component component : ui.getToolbar().getComponents()) {

             treePane.getToolbar().add(component);

         }

+        boolean isLeft = taskSide.onLeft();

+        if (!isLeft) {

+            ui.remove(ui.getMiddleActions());

+            ui.add(ui.getMiddleActions(), BorderLayout.WEST);

+        }

         Consumer<TreeConfigUI> consumer = TreeConfigUIHandler::hideOptions;

         Consumer<TreeConfigUI> apply = u -> rebuildTree(parent.getModel().getDataSynchroModel(), ui, true);

         DataSelectionTreePaneModel model = ui.getModel();

         model.setSelectionDataModel(treeModel);

         // When model idStates has changed, rebuild the tree (but not the flat model)

-        model.addPropertyChangeListener(DataSelectionTreePaneModel.ID_STATES_PROPERTY_NAME,

-                                        evt -> DataSelectionTreePaneHandler.rebuildTree(parent.getStepModel(), ui, false));

+        model.addPropertyChangeListener(DataSelectionTreePaneModel.ID_STATES_PROPERTY_NAME, evt -> rebuildTree(parent.getStepModel(), ui, false));

         // When tree model has changed, rebuild accessibility to copy and delete action

         treeModel.addPropertyChangeListener(evt -> {

             boolean withDataSelected = !treeModel.isSelectionEmpty();

-            ui.getCopy().setEnabled(withDataSelected);

-            ui.getDelete().setEnabled(withDataSelected);

+            ui.getCopy().setEnabled(ui.getModel().isCanCopy() && withDataSelected);

+            ui.getDelete().setEnabled(ui.getModel().isCanDelete() && withDataSelected);

         });

         // When use double clicks in tree, update selection state of the selected node

         tree.addMouseListener(new MouseAdapter() {

         });

     }

-    public static void initDatasource(DataSourceSelectorModel sourceModel, boolean oppositeCanWriteData, DataSelectionTreePane ui, EnumSet<IdState> idStates) {

+    public static void initDatasource(DataSourceSelectorModel sourceModel, boolean oppositeCanWrite, boolean canWrite, DataSelectionTreePane ui, EnumSet<IdState> idStates) {

         ui.setContextValue(sourceModel);

-        boolean canWriteData = sourceModel.getDataSourceInformation().canWriteData();

+        boolean canWriteData = canWrite && sourceModel.isCanWriteData();

         Color color = canWriteData ? Color.BLACK : Color.RED;

-

-        ui.getDelete().setEnabled(canWriteData);

-        ui.getCopy().setEnabled(oppositeCanWriteData);

+        ui.getModel().setCanCopy(oppositeCanWrite);

+        ui.getModel().setCanDelete(canWriteData);

         ui.getToggleEquals().setSelected(idStates.contains(IdState.EQUALS));

         ui.getToggleOlder().setSelected(idStates.contains(IdState.OBSOLETE));

         ui.getToggleNewer().setSelected(idStates.contains(IdState.UPDATED));

     public void beforeInit(DataSelectionTreePane ui) {

         ui.setComponentPopupMenu(new JPopupMenu());

     }

-

 }
     public static final String ID_STATES_PROPERTY_NAME = "idStates";

     private static final Logger log = LogManager.getLogger(DataSelectionTreePaneModel.class);

     private static final String SOURCE_PROPERTY_NAME = "source";

+    private static final String CAN_COPY_PROPERTY_NAME = "canCopy";

+    private static final String CAN_DELETE_PROPERTY_NAME = "canDelete";

     /**

      * Which id states we use in tree model.

      */

      */

     private List<IdAndLastUpdateDate> dataIds = List.of();

+    /**

+     * Can we copy from this side?

+     */

+    private boolean canCopy;

+    /**

+     * Can we delete from this side?

+     */

+    private boolean canDelete;

     public void dispose() {

         source = null;

         treeFlatModel = null;

         firePropertyChange(SOURCE_PROPERTY_NAME, source);

     }

+    public boolean isCanCopy() {

+        return canCopy;

+    }

+

+    public void setCanCopy(boolean canCopy) {

+        boolean oldValue = this.canCopy;

+        this.canCopy = canCopy;

+        firePropertyChange(CAN_COPY_PROPERTY_NAME, oldValue, canCopy);

+    }

+

+    public boolean isCanDelete() {

+        return canDelete;

+    }

+

+    public void setCanDelete(boolean canDelete) {

+        boolean oldValue = this.canDelete;

+        this.canDelete = canDelete;

+        firePropertyChange(CAN_DELETE_PROPERTY_NAME, oldValue, canDelete);

+    }

+

     public SelectionTreeModel getSelectionDataModel() {

         return selectionDataModel;

     }

   <http://www.gnu.org/licenses/gpl-3.0.html>.

   #L%

   -->

-<JPanel id="referentialSynchronizeConfig" layout="{new BorderLayout()}">

+<JPanel id="referentialSynchronizeConfig" layout="{new BorderLayout()}" implements="fr.ird.observe.client.datasource.actions.synchronize.SynchronizeConfigUI">

+  <style source="../../SynchronizeConfigUI.jcss"/>

   <import>

-    fr.ird.observe.client.configuration.ClientConfig

-    fr.ird.observe.client.datasource.actions.synchronize.referential.ng.ReferentialSynchronizeMode

-    fr.ird.observe.client.datasource.actions.synchronize.referential.ng.actions.SelectReferentialSynchronizeMode

     fr.ird.observe.client.datasource.actions.AdminUIModel

-    org.nuiton.validator.NuitonValidatorScope

     io.ultreia.java4all.i18n.I18n

-    java.io.File

-    java.util.Objects

-    javax.swing.JComboBox

-

     static io.ultreia.java4all.i18n.I18n.t

     static fr.ird.observe.client.util.UIHelper.getStringValue

   </import>

 ]]>

   </script>

-  <JPanel id="referentialSynchronizeConfigPanel" constraints='BorderLayout.CENTER' layout='{new GridLayout(0, 1)}'>

+  <JPanel id="synchronizeConfigPanel" constraints='BorderLayout.CENTER' layout='{new GridLayout(0, 1)}'>

     <JToggleButton id="FROM_LEFT_TO_RIGHT" styleClass="synchronizeMode"/>

     <JToggleButton id="FROM_RIGHT_TO_LEFT" styleClass="synchronizeMode"/>

     <JToggleButton id="BOTH" styleClass="synchronizeMode"/>

   <Table constraints='BorderLayout.SOUTH' weightx='1'>

     <row>

       <cell>

-        <JCheckBox id='showProperties'

-                   onStateChanged='getStepModel().setShowProperties(((JCheckBox)event.getSource()).isSelected())'/>

+        <JCheckBox id='showProperties' onStateChanged='getStepModel().setShowProperties(((JCheckBox)event.getSource()).isSelected())'/>

       </cell>

     </row>

     <row>

  * #L%

  */

-#referentialSynchronizeConfigPanel {

-  border:{new TitledBorder(t("observe.ui.datasource.editor.actions.synchro.referential.config.mode") +  "")};

-}

-

-#synchronizeMode {

-  selectedValue:{stepModel.getSynchronizeMode()};

-}

-

-.synchronizeMode {

-  buttonGroup:"synchronizeMode";

-  enabled:false;

-  selected:{Objects.equals(ReferentialSynchronizeMode.%%, stepModel.getSynchronizeMode())};

-  value:{ReferentialSynchronizeMode.%%};

-  action:{new SelectReferentialSynchronizeMode(ReferentialSynchronizeMode.%%)};

-}

-

 #showProperties {

   text:"observe.ui.action.show.properties";

   toolTipText:"observe.ui.action.show.properties.tip";

 import fr.ird.observe.client.datasource.actions.AdminStep;

 import fr.ird.observe.client.datasource.actions.AdminUIModel;

 import fr.ird.observe.client.datasource.actions.config.ConfigModel;

+import fr.ird.observe.client.datasource.actions.synchronize.SynchronizeMode;

+import fr.ird.observe.client.datasource.actions.synchronize.SynchronizeModel;

 import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.task.ReferentialSynchronizeTaskListModel;

 import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.task.SwingReferentialSynchronizeTask;

 import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.ReferentialSynchronizeTreeModel;

 import fr.ird.observe.services.service.referential.differential.DifferentialModelBuilder;

 import fr.ird.observe.services.service.referential.differential.DifferentialType;

 import fr.ird.observe.services.service.referential.synchro.SynchronizeTaskType;

+import io.ultreia.java4all.i18n.I18n;

 import io.ultreia.java4all.util.LeftOrRight;

 import io.ultreia.java4all.util.LeftOrRightContext;

 import org.apache.logging.log4j.LogManager;

  * @since 5.0

  */

 @SuppressWarnings("unused")

-public class ReferentialSynchroModel extends AdminActionModel {

+public class ReferentialSynchroModel extends AdminActionModel implements SynchronizeModel {

-    public static final String SYNCHRONIZE_MODE_PROPERTY_NAME = "synchronizeMode";

     public static final String SHOW_PROPERTIES_PROPERTY_NAME = "showProperties";

     public static final String LEFT_SOURCE_PROPERTY_NAME = "leftSource";

     public static final String RIGHT_SOURCE_PROPERTY_NAME = "rightSource";

     private final LeftOrRightContext<ReferentialSynchronizeTreeModel> treeModels;

     private ObserveSwingDataSource leftSource;

     private ObserveSwingDataSource rightSource;

-    private ReferentialSynchronizeMode synchronizeMode;

+    private SynchronizeMode synchronizeMode;

     private boolean showProperties;

     private ReferentialSynchronizeTreeModel leftTreeModel;

     private ReferentialSynchronizeTreeModel rightTreeModel;

         };

     }

+    @Override

+    public boolean isCanWrite(DataSourceSelectorModel dataSourceSelectorModel) {

+        return dataSourceSelectorModel.isCanWriteReferential();

+    }

+

+    @Override

+    public String getTitleWithMode(SynchronizeMode mode) {

+        return I18n.t("observe.ui.datasource.editor.actions.synchro.referential.withMode", mode.getLabel());

+    }

+

+

     @Override

     public void start(AdminUIModel uiModel) {

         configModel.getLeftSourceModel().setRequiredReadOnReferential(true);

         configModel.getRightSourceModel().setRequiredReadOnReferential(true);

-        addPropertyChangeListener(SYNCHRONIZE_MODE_PROPERTY_NAME, evt -> {

-            if (uiModel.isWasStarted()) {

-                // on ne propage plus rien (il n'y a plus de configuration possible...)

-                log.debug("Stop propagation, was started... " + evt.getPropertyName());

-                return;

-            }

-            uiModel.validate();

-        });

-        setSynchronizeMode(ReferentialSynchronizeMode.FROM_LEFT_TO_RIGHT);

+        SynchronizeModel.super.start(uiModel);

         setShowProperties(true);

     }

     @Override

     public boolean validateConfig(AdminUIModel uiModel) {

-        ReferentialSynchronizeMode synchronizeMode = uiModel.getReferentialSynchroModel().getSynchronizeMode();

+        SynchronizeMode synchronizeMode = uiModel.getReferentialSynchroModel().getSynchronizeMode();

         if (synchronizeMode == null) {

             log.info("No synchronize mode selected");

             return false;

         rightTreeModel = null;

     }

-    public ReferentialSynchronizeMode getSynchronizeMode() {

+    @Override

+    public SynchronizeMode getSynchronizeMode() {

         return synchronizeMode;

     }

-    public void setSynchronizeMode(ReferentialSynchronizeMode synchronizeMode) {

+    @Override

+    public void setSynchronizeMode(SynchronizeMode synchronizeMode) {

         Object oldValue = getSynchronizeMode();

         this.synchronizeMode = synchronizeMode;

         firePropertyChange(SYNCHRONIZE_MODE_PROPERTY_NAME, oldValue, synchronizeMode);

  */

 import fr.ird.observe.client.datasource.actions.AdminTabUIHandler;

-import fr.ird.observe.client.datasource.actions.AdminUIModel;

 import fr.ird.observe.client.datasource.actions.config.ConfigUI;

 import fr.ird.observe.client.datasource.editor.api.wizard.StorageUIModel;

-import fr.ird.observe.client.datasource.editor.api.wizard.connexion.DataSourceSelectorModel;

 import fr.ird.observe.client.util.UIHelper;

-import org.apache.logging.log4j.LogManager;

-import org.apache.logging.log4j.Logger;

 import org.nuiton.jaxx.runtime.spi.UIHandler;

 import javax.swing.ToolTipManager;

-import java.util.EnumSet;

 import static io.ultreia.java4all.i18n.I18n.t;

  */

 public class ReferentialSynchroUIHandler extends AdminTabUIHandler<ReferentialSynchroUI> implements UIHandler<ReferentialSynchroUI> {

-    private static final Logger log = LogManager.getLogger(ReferentialSynchroUIHandler.class);

-

     @Override

     public void afterInit(ReferentialSynchroUI ui) {

         super.afterInit(ui);

         setAutoStart(ui.getStart());

         ui.getLeftTreePane().init();

         ui.getRightTreePane().init();

-        ui.getStepModel().addPropertyChangeListener(ReferentialSynchroModel.SYNCHRONIZE_MODE_PROPERTY_NAME, evt -> {

-

-            ReferentialSynchronizeMode newValue = (ReferentialSynchronizeMode) evt.getNewValue();

-            if (parentUI.getTabs().getComponentCount() > 1 && newValue != null) {

-                parentUI.getTabs().setTitleAt(1, t("observe.ui.datasource.editor.actions.synchro.referential.withMode", newValue.getLabel()));

-            }

-        });

+        ui.getStepModel().afterInit(parentUI);

         hideFixedPanelLabel(ui);

         ToolTipManager.sharedInstance().registerComponent(ui.getLeftTreePane().getTree());

         ToolTipManager.sharedInstance().registerComponent(ui.getRightTreePane().getTree());

         configUI.getExtraConfig().add(extraConfig);

         configUI.getLeftSourceModel().setSourceLabel(t("observe.ui.datasource.storage.config.left.storage"));

         configUI.getRightSourceModel().setSourceLabel(t("observe.ui.datasource.storage.config.right.storage"));

-        configUI.getStepModel().addPropertyChangeListener(StorageUIModel.VALID_STEP_PROPERTY_NAME, evt -> updateSynchroModes(extraConfig));

-    }

-

-    private void updateSynchroModes(ReferentialSynchroConfigUI extraConfig) {

-        AdminUIModel model = getUi().getModel();

-        ReferentialSynchronizeMode synchronizeMode = model.getReferentialSynchroModel().getSynchronizeMode();

-        log.info(String.format("Will update synchro modes (previous value: %s)", synchronizeMode));

-        DataSourceSelectorModel leftSourceModel = model.getConfigModel().getLeftSourceModel();

-        if (!leftSourceModel.isInit()) {

-            return;

-        }

-        DataSourceSelectorModel rightSourceModel = model.getConfigModel().getRightSourceModel();

-        if (!rightSourceModel.isInit()) {

-            return;

-        }

-        boolean dataSourcesValid = leftSourceModel.validateExt() && rightSourceModel.validateExt();

-        boolean leftToRightEnabled = dataSourcesValid && rightSourceModel.isCanWriteReferential();

-        log.debug(String.format("Update synchro modes: leftToRight: %s", leftToRightEnabled));

-        boolean rightToLeftEnabled = dataSourcesValid && leftSourceModel.isCanWriteReferential();

-        log.debug(String.format("Update synchro modes: rightToLeft: %s", rightToLeftEnabled));

-        boolean bothEnabled = leftToRightEnabled && rightToLeftEnabled;

-        log.debug(String.format("Update synchro modes: both: %s", bothEnabled));

-        extraConfig.getFROM_LEFT_TO_RIGHT().setEnabled(leftToRightEnabled);

-        extraConfig.getFROM_RIGHT_TO_LEFT().setEnabled(rightToLeftEnabled);

-        extraConfig.getBOTH().setEnabled(bothEnabled);

-        EnumSet<ReferentialSynchronizeMode> candidates = EnumSet.allOf(ReferentialSynchronizeMode.class);

-        if (!leftToRightEnabled) {

-            candidates.remove(ReferentialSynchronizeMode.FROM_LEFT_TO_RIGHT);

-        }

-        if (!rightToLeftEnabled) {

-            candidates.remove(ReferentialSynchronizeMode.FROM_RIGHT_TO_LEFT);

-        }

-        if (!bothEnabled) {

-            candidates.remove(ReferentialSynchronizeMode.BOTH);

-        }

-        if (!candidates.contains(synchronizeMode)) {

-            if (candidates.isEmpty()) {

-                synchronizeMode = null;

-            } else {

-                synchronizeMode = candidates.iterator().next();

-            }

-        }

-        log.info(String.format("Will update synchro modes (new value: %s)", synchronizeMode));

-        model.getReferentialSynchroModel().setSynchronizeMode(null);

-        model.getReferentialSynchroModel().setSynchronizeMode(synchronizeMode);

+        configUI.getStepModel().addPropertyChangeListener(StorageUIModel.VALID_STEP_PROPERTY_NAME, evt -> extraConfig.updateSynchroModes());

     }

 }
  */

 import fr.ird.observe.client.datasource.actions.AdminUIModel;

+import fr.ird.observe.client.datasource.actions.synchronize.SynchronizeMode;

 import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.ReferentialSynchroModel;

 import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.ReferentialSynchroUI;

-import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.ReferentialSynchronizeMode;

 import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.ReferentialSelectionTree;

 import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.ReferentialSelectionTreePane;

 import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.ReferentialSynchronizeTreeModel;

             try (ObserveSwingDataSource rightSource = ui.getModel().getConfigModel().getRightSourceModel().getSafeSource(true)) {

                 stepModel.setRightSource(rightSource);

                 DifferentialModelBuilder engine = stepModel.newDifferentialModelBuilder();

-                ReferentialSynchronizeMode synchronizeMode = stepModel.getSynchronizeMode();

+                SynchronizeMode synchronizeMode = stepModel.getSynchronizeMode();

                 ProgressionModel progressionModel = stepModel.getProgressModel();

                 ReferentialSynchronizeTreeModelsBuilder treeModelsBuilder = new ReferentialSynchronizeTreeModelsBuilder(synchronizeMode, stepModel.isShowProperties(), engine, progressionModel);

                 LeftOrRightContext<ReferentialSynchronizeTreeModel> treePair = treeModelsBuilder.build();

     private void initTree(ReferentialSelectionTreePane pane, ReferentialSynchronizeTreeModel treeModel, DataSourceSelectorModel dataSourceSelectorModel, String message, PropertyChangeListener listener) {

         ReferentialSelectionTree tree = pane.getTree();

-        ReferentialSynchronizeMode newValue = ui.getStepModel().getSynchronizeMode();

+        SynchronizeMode synchronizeMode = ui.getStepModel().getSynchronizeMode();

         pane.setContextValue(dataSourceSelectorModel);

         Color color =

-                (treeModel.isLeft() && newValue.isLeftWrite() || !treeModel.isLeft() && newValue.isRightWrite()) ?

+                (treeModel.isLeft() && synchronizeMode.isLeftWrite() || !treeModel.isLeft() && synchronizeMode.isRightWrite()) ?

                         Color.BLACK : Color.RED;

         pane.setBorder(new TitledBorder(""));

         String label = dataSourceSelectorModel.getLabel();

         pane.getDataSourceLabel().setText(dataSourceSelectorModel.getSource().getLabel() + " " + labelWithUrl);

         pane.getDataSourceLabel().setForeground(color);

+        boolean isRight = pane.isRight();

+        boolean canCopy = isRight ? synchronizeMode.isLeftWrite() : synchronizeMode.isRightWrite();

+        boolean canRevert = isRight ? synchronizeMode.isRightWrite() : synchronizeMode.isLeftWrite();

+        pane.getCopy().setVisible(canCopy);

+        pane.getRevert().setVisible(canRevert);

+        pane.getDeactivate().setVisible(canRevert);

+        pane.getDeactivateWithReplace().setVisible(canRevert);

+        pane.getDelete().setVisible(canRevert);

+

         tree.setModel(treeModel);

         treeModel.addPropertyChangeListener(ReferentialSynchronizeTreeModel.SELECTED_COUNT, listener);

-

         listener.propertyChange(null);

         sendMessage(message);

     }

  * #L%

  */

-import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.ReferentialSynchroModel;

-import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.ReferentialSynchroUI;

-import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.ReferentialSynchroUIHandler;

-import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.ReferentialSynchronizeMode;

-import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.actions.*;

+import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.actions.RegisterCopy;

+import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.actions.RegisterDeactivate;

+import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.actions.RegisterDeactivateWithReplacement;

+import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.actions.RegisterDelete;

+import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.actions.RegisterRevert;

+import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.actions.SelectUnselect;

 import fr.ird.observe.client.util.init.DefaultUIInitializer;

 import io.ultreia.java4all.util.LeftOrRight;

 import org.nuiton.jaxx.runtime.spi.UIHandler;

-import java.awt.*;

+import java.awt.BorderLayout;

 /**

  * @author Tony Chemit - dev@tchemit.fr

     }

     void init(ReferentialSelectionTreePane ui) {

-        ReferentialSynchroUI parent = ui.getContextValue(ReferentialSynchroUI.class, ReferentialSynchroUIHandler.ADMIN_TAB_UI);

-        ReferentialSynchroModel stepModel = parent.getStepModel();

-        stepModel.addPropertyChangeListener(ReferentialSynchroModel.SYNCHRONIZE_MODE_PROPERTY_NAME, evt -> onUpdateMode(ui, (ReferentialSynchronizeMode) evt.getNewValue()));

         boolean isLeft = ui.isLeft();

-        LeftOrRight side = isLeft?LeftOrRight.LEFT : LeftOrRight.RIGHT;

-        RegisterCopy.init(ui, ui.copy, new RegisterCopy(ui, side));

-        RegisterRevert.init(ui, ui.revert, new RegisterRevert(ui, side));

-        RegisterDeactivate.init(ui, ui.deactivate, new RegisterDeactivate(ui, side));

-        RegisterDeactivateWithReplacement.init(ui, ui.deactivateWithReplace, new RegisterDeactivateWithReplacement(ui, side));

-        RegisterDelete.init(ui, ui.delete, new RegisterDelete(ui, side));

+        LeftOrRight side = isLeft ? LeftOrRight.LEFT : LeftOrRight.RIGHT;

+        RegisterCopy.init(ui, ui.getCopy(), new RegisterCopy(ui, side));

+        RegisterRevert.init(ui, ui.getRevert(), new RegisterRevert(ui, side));

+        RegisterDeactivate.init(ui, ui.getDeactivate(), new RegisterDeactivate(ui, side));

+        RegisterDeactivateWithReplacement.init(ui, ui.getDeactivateWithReplace(), new RegisterDeactivateWithReplacement(ui, side));

+        RegisterDelete.init(ui, ui.getDelete(), new RegisterDelete(ui, side));

         SelectUnselect.init(ui, null, new SelectUnselect(ui));

         if (!isLeft) {

             ui.remove(ui.getMiddleActions());

         // an update is asked using the deleted data...)

         ui.getMiddleActions().remove(ui.delete);

     }

-

-    private void onUpdateMode(ReferentialSelectionTreePane ui, ReferentialSynchronizeMode synchronizeMode) {

-        if (synchronizeMode == null) {

-            return;

-        }

-        boolean isRight = ui.isRight();

-        boolean canCopy = isRight ? synchronizeMode.isLeftWrite() : synchronizeMode.isRightWrite();

-        boolean canRevert = isRight ? synchronizeMode.isRightWrite() : synchronizeMode.isLeftWrite();

-        ui.copy.setVisible(canCopy);

-        ui.revert.setVisible(canRevert);

-        ui.deactivate.setVisible(canRevert);

-        ui.deactivateWithReplace.setVisible(canRevert);

-        ui.delete.setVisible(canRevert);

-    }

-

 }

  */

 import fr.ird.observe.client.WithClientUIContextApi;

-import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.ReferentialSynchronizeMode;

+import fr.ird.observe.client.datasource.actions.synchronize.SynchronizeMode;

 import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.node.ReferentialAddedSynchroNode;

 import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.node.ReferentialPropertyUpdatedNode;

 import fr.ird.observe.client.datasource.actions.synchronize.referential.ng.tree.node.ReferentialSynchroNodeSupport;

     }

-    public ReferentialSynchronizeTreeModelsBuilder(ReferentialSynchronizeMode synchronizeMode, boolean showProperties, DifferentialModelBuilder engine, ProgressionModel progressionModel) {

+    public ReferentialSynchronizeTreeModelsBuilder(SynchronizeMode synchronizeMode, boolean showProperties, DifferentialModelBuilder engine, ProgressionModel progressionModel) {

         this.engine = Objects.requireNonNull(engine);

         this.leftRootNode = new RootSynchroNode(true, Objects.requireNonNull(synchronizeMode).isLeftWrite(), showProperties);

         this.rightRootNode = new RootSynchroNode(false, synchronizeMode.isRightWrite(), showProperties);

 observe.ui.datasource.storage.no.referentiel.import

 observe.ui.datasource.storage.report.can.migrate

 observe.ui.datasource.storage.report.can.not.migrate

-observe.ui.datasource.storage.required.rw.on.data

+observe.ui.datasource.storage.required.read.on.data

 observe.ui.datasource.storage.server.dataBase.name

 observe.ui.datasource.storage.server.default.dataBase

 observe.ui.datasource.storage.server.sessionExpire

             if (!service.isLocal() && !(service.canReadData() && service.canWriteData())) {

                 askToUser(

                         t("observe.ui.title.can.not.export.obstuna"),

-                        t("observe.ui.datasource.storage.required.rw.on.data", service),

+                        t("observe.ui.datasource.storage.required.read.on.data", service),

                         JOptionPane.ERROR_MESSAGE,

                         new Object[]{t("observe.ui.choice.cancel")},

                         0

         return isLocal() || Optional.ofNullable(getDataSourceInformation()).map(ObserveDataSourceInformation::canWriteReferential).orElse(false);

     }

+    public boolean isCanWriteData() {

+        return isLocal() || Optional.ofNullable(getDataSourceInformation()).map(ObserveDataSourceInformation::canWriteData).orElse(false);

+    }

+

     public boolean validateExt() {

         setValidationMessage(null);

         if (!isValid()) {

 observe.constant.ObstunaAdminAction.SECURITY.description=Update security

 observe.constant.ObstunaAdminAction.UPDATE=Update

 observe.constant.ObstunaAdminAction.UPDATE.description=Update a  database

-observe.constant.ReferentialSynchronizeMode.BOTH=Bi directional

-observe.constant.ReferentialSynchronizeMode.FROM_LEFT_TO_RIGHT=From left to right

-observe.constant.ReferentialSynchronizeMode.FROM_RIGHT_TO_LEFT=From right to left

 observe.constant.StorageStep.BACKUP=Save

 observe.constant.StorageStep.BACKUP.description=Save local database before changing data source

 observe.constant.StorageStep.CHOOSE_DB_MODE=Mode

 observe.constant.StorageStep.ROLES.description=Apply security on database roles

 observe.constant.StorageStep.SELECT_DATA=Data selection

 observe.constant.StorageStep.SELECT_DATA.description=Select data to export in backup

+observe.constant.SynchronizeMode.BOTH=Bi directional

+observe.constant.SynchronizeMode.FROM_LEFT_TO_RIGHT=From left to right

+observe.constant.SynchronizeMode.FROM_RIGHT_TO_LEFT=From right to left

 observe.constant.ValidationModelMode.DATA=Only data

 observe.constant.ValidationModelMode.DATA.description=Only data

 observe.constant.ValidationModelMode.REFERENTIEL=Only referential

 observe.ui.action.commandline.launch.remote.admin.ui=Launch an administration task on remote

 observe.ui.action.commandline.launch.server.admin.ui=Launch an administration task on server

 observe.ui.action.commandline.use.jmx=Add JMX support

+observe.ui.action.config.export.required.read.data=Read permission is required on data for this operation

 observe.ui.action.config.export.required.read.referentiel=Read permission is required on referential for this operation

 observe.ui.action.config.export.required.write.data=Write permission is required on data for this operation

 observe.ui.action.config.left.datasource.required.write.data=Write permission is required on data for this operation

 observe.ui.datasource.editor.actions.saveLocal=Save local database

 observe.ui.datasource.editor.actions.saveLocal.description=Save modifications on local database

 observe.ui.datasource.editor.actions.synchro.cancel.tip=Cancel

+observe.ui.datasource.editor.actions.synchro.config.mode=Synchronisation mode

 observe.ui.datasource.editor.actions.synchro.copy.tip=Copy result of report in clipboard

 observe.ui.datasource.editor.actions.synchro.data=Advanced data management

 observe.ui.datasource.editor.actions.synchro.data.actionsToPerform=Operations to perform

 observe.ui.datasource.editor.actions.synchro.data.message.data.loaded=Database «%s» - Data loaded

 observe.ui.datasource.editor.actions.synchro.data.title=Advanced data management

 observe.ui.datasource.editor.actions.synchro.data.title.tip=Advanced data management

+observe.ui.datasource.editor.actions.synchro.data.withMode=Advanced data management (%s)

 observe.ui.datasource.editor.actions.synchro.launch.operation=Launch operation < %1$S >

 observe.ui.datasource.editor.actions.synchro.prepare.operation=Prepare operation < %1$s >

 observe.ui.datasource.editor.actions.synchro.referential=Advanced referential management

 observe.ui.datasource.editor.actions.synchro.referential.action.deleteFromRight.tip=Delete selected referential(s) from right database

 observe.ui.datasource.editor.actions.synchro.referential.action.revertFromLeft.tip=Revert selected referential(s) into left database

 observe.ui.datasource.editor.actions.synchro.referential.action.revertFromRight.tip=Revert selected referential(s) into right database

-observe.ui.datasource.editor.actions.synchro.referential.config.mode=Synchronisation mode

 observe.ui.datasource.editor.actions.synchro.referential.description=Advanced referential management

 observe.ui.datasource.editor.actions.synchro.referential.launch.operation=Compute differentials of referential

 observe.ui.datasource.editor.actions.synchro.referential.legacy=Update referential

 observe.ui.datasource.storage.report.action.migrate=Update policy

 observe.ui.datasource.storage.report.can.migrate=Update if necessary (current version\: %1$s)

 observe.ui.datasource.storage.report.can.not.migrate=No update possible

-observe.ui.datasource.storage.required.rw.on.data=You don't have sufficient credentials to perform this operation.\n\nTo perform this operation, you need Read/Write permissions on data.

+observe.ui.datasource.storage.required.read.on.data=You don't have sufficient credentials to perform this operation.\n\nTo perform this operation, you need Read permission on data.

 observe.ui.datasource.storage.server.dataBase=Databases

 observe.ui.datasource.storage.server.dataBase.name=Database

 observe.ui.datasource.storage.server.default.dataBase=default

 observe.constant.ObstunaAdminAction.SECURITY.description=Actualización de securidad de una base remota

 observe.constant.ObstunaAdminAction.UPDATE=Actualización de une base remota

 observe.constant.ObstunaAdminAction.UPDATE.description=Actualización de una base remota

-observe.constant.ReferentialSynchronizeMode.BOTH=Bidireccional

-observe.constant.ReferentialSynchronizeMode.FROM_LEFT_TO_RIGHT=De izquierda a derecha

-observe.constant.ReferentialSynchronizeMode.FROM_RIGHT_TO_LEFT=De derecha a izquierda

 observe.constant.StorageStep.BACKUP=Copia de seguridad

 observe.constant.StorageStep.BACKUP.description=Guardadar la base local antes de cambiar la fuente de datos

 observe.constant.StorageStep.CHOOSE_DB_MODE=Modo

 observe.constant.StorageStep.ROLES.description=Configuración de la seguridad

 observe.constant.StorageStep.SELECT_DATA=Selección de datos

 observe.constant.StorageStep.SELECT_DATA.description=Seleccionar los datos a exportar en la copia de seguridad

+observe.constant.SynchronizeMode.BOTH=Bidireccional

+observe.constant.SynchronizeMode.FROM_LEFT_TO_RIGHT=De izquierda a derecha

+observe.constant.SynchronizeMode.FROM_RIGHT_TO_LEFT=De derecha a izquierda

 observe.constant.ValidationModelMode.DATA=Datos

 observe.constant.ValidationModelMode.DATA.description=Datos

 observe.constant.ValidationModelMode.REFERENTIEL=Referencial

 observe.ui.action.commandline.launch.remote.admin.ui=Ejecutar una operación de administración sobre remota

 observe.ui.action.commandline.launch.server.admin.ui=Lancer une opération d'administration sur un serveur \#TODO

 observe.ui.action.commandline.use.jmx=Mostrar el soporte JMX

+observe.ui.action.config.export.required.read.data=Debe tener derechos de lectura sobre los datos para esta operación

 observe.ui.action.config.export.required.read.referentiel=Debe tener derechos de lectura sobre el referencial de datos para esta operación

 observe.ui.action.config.export.required.write.data=Debe tener derechos de escritura sobre los datos para esta operación

 observe.ui.action.config.left.datasource.required.write.data=Write permission is required on data for this operation \#TODO

 observe.ui.datasource.editor.actions.saveLocal=Copia de seguridad de la base local

 observe.ui.datasource.editor.actions.saveLocal.description=Guardar las modificationes realizadas en la base locale

 observe.ui.datasource.editor.actions.synchro.cancel.tip=Cancelar

+observe.ui.datasource.editor.actions.synchro.config.mode=Modo de synchronización

 observe.ui.datasource.editor.actions.synchro.copy.tip=Copiar el informe en el portapapeles

 observe.ui.datasource.editor.actions.synchro.data=Gestión avanzada de los datos

 observe.ui.datasource.editor.actions.synchro.data.actionsToPerform=Operaciones a realisar

 observe.ui.datasource.editor.actions.synchro.data.message.data.loaded=Base «%s» - Datos recuperadas.

 observe.ui.datasource.editor.actions.synchro.data.title=Gestión avanzada de los datos

 observe.ui.datasource.editor.actions.synchro.data.title.tip=Sincronización bi-directionnal de los datos de los usaurios

+observe.ui.datasource.editor.actions.synchro.data.withMode=Gestión avanzada de los datos (%s)

 observe.ui.datasource.editor.actions.synchro.launch.operation=Comenzar la operación < %1$s >

 observe.ui.datasource.editor.actions.synchro.prepare.operation=Preparar la operación <%1$s>

 observe.ui.datasource.editor.actions.synchro.referential=Gestión avanzada del referencial

 observe.ui.datasource.editor.actions.synchro.referential.action.deleteFromRight.tip=Eliminar el referencial seleccionado en la base de la derecha

 observe.ui.datasource.editor.actions.synchro.referential.action.revertFromLeft.tip=Volver atrás el referencial seleccionado en la izquierda

 observe.ui.datasource.editor.actions.synchro.referential.action.revertFromRight.tip=Volver atrás el referencial seleccionado en la derecha

-observe.ui.datasource.editor.actions.synchro.referential.config.mode=Modo de synchronización

 observe.ui.datasource.editor.actions.synchro.referential.description=Gestión avanzada del referencial

 observe.ui.datasource.editor.actions.synchro.referential.launch.operation=Calcular el diferencial de los referenciales de los fuentes de datos

 observe.ui.datasource.editor.actions.synchro.referential.legacy=Actualización del referencial

 observe.ui.datasource.storage.report.action.migrate=Politica de actualización

 observe.ui.datasource.storage.report.can.migrate=Actualizar si es necesario (version actual \: %1$s)

 observe.ui.datasource.storage.report.can.not.migrate=No es posible actualizar

-observe.ui.datasource.storage.required.rw.on.data=No tiene los permisos necesarios para realizar esta operación.\n\nDebe tener permios de lectura y escritura de los datos del obaservador.

+observe.ui.datasource.storage.required.read.on.data=No tiene los permisos necesarios para realizar esta operación.\n\nDebe tener permios de lectura de los datos del obaservador.

 observe.ui.datasource.storage.server.dataBase=Base de datos

 observe.ui.datasource.storage.server.dataBase.name=Database \#TODO

 observe.ui.datasource.storage.server.default.dataBase=default \#TODO

 observe.constant.ObstunaAdminAction.SECURITY.description=Mise à jour de la sécurité d'une base distante

 observe.constant.ObstunaAdminAction.UPDATE=Mise à jour d'une base distante

 observe.constant.ObstunaAdminAction.UPDATE.description=Mise à jour d'une base distante

-observe.constant.ReferentialSynchronizeMode.BOTH=Bidirectionnel

-observe.constant.ReferentialSynchronizeMode.FROM_LEFT_TO_RIGHT=De la gauche vers la droite

-observe.constant.ReferentialSynchronizeMode.FROM_RIGHT_TO_LEFT=De la droite vers la gauche

 observe.constant.StorageStep.BACKUP=Sauvegarde

 observe.constant.StorageStep.BACKUP.description=Sauvegarder la base locale avant de changer de source de données

 observe.constant.StorageStep.CHOOSE_DB_MODE=Mode

 observe.constant.StorageStep.ROLES.description=Mise en place de la sécurité

 observe.constant.StorageStep.SELECT_DATA=Sélection données

 observe.constant.StorageStep.SELECT_DATA.description=Sélectionner les données à exporter dans la sauvegarde

+observe.constant.SynchronizeMode.BOTH=Bidirectionnel

+observe.constant.SynchronizeMode.FROM_LEFT_TO_RIGHT=De la gauche vers la droite

+observe.constant.SynchronizeMode.FROM_RIGHT_TO_LEFT=De la droite vers la gauche

 observe.constant.ValidationModelMode.DATA=Données

 observe.constant.ValidationModelMode.DATA.description=Données

 observe.constant.ValidationModelMode.REFERENTIEL=Référentiel

 observe.ui.action.commandline.launch.remote.admin.ui=Lancer une opération d'administration sur une base distante

 observe.ui.action.commandline.launch.server.admin.ui=Lancer une opération d'administration sur un serveur

 observe.ui.action.commandline.use.jmx=Ajouter le support JMX

+observe.ui.action.config.export.required.read.data=Lecture sur les données requis pour cette opération

 observe.ui.action.config.export.required.read.referentiel=Lecture sur le référentiel requis pour cette opération

 observe.ui.action.config.export.required.write.data=Écriture sur les données requis pour cette opération

 observe.ui.action.config.left.datasource.required.write.data=Écriture sur les données requis pour cette opération

 observe.ui.datasource.editor.actions.saveLocal=Sauvegarde de la base locale

 observe.ui.datasource.editor.actions.saveLocal.description=Sauvegarder les modifications effectuées vers la base locale

 observe.ui.datasource.editor.actions.synchro.cancel.tip=Annuler

+observe.ui.datasource.editor.actions.synchro.config.mode=Mode de synchronisation

 observe.ui.datasource.editor.actions.synchro.copy.tip=Copier le rapport dans le presse-papier

 observe.ui.datasource.editor.actions.synchro.data=Gestion avancée de données

 observe.ui.datasource.editor.actions.synchro.data.actionsToPerform=Opérations à réaliser

 observe.ui.datasource.editor.actions.synchro.data.message.data.loaded=Source «%s» - Données récupérées.

 observe.ui.datasource.editor.actions.synchro.data.title=Gestion avancée de données

 observe.ui.datasource.editor.actions.synchro.data.title.tip=Synchronisation bidirectionnelle des données utilisateurs

+observe.ui.datasource.editor.actions.synchro.data.withMode=Gestion avancée de données (%s)

 observe.ui.datasource.editor.actions.synchro.launch.operation=Démarrer l'opération < %1$s >

 observe.ui.datasource.editor.actions.synchro.prepare.operation=Préparer l'opération <%1$s>

 observe.ui.datasource.editor.actions.synchro.referential=Gestion avancée du référentiel

 observe.ui.datasource.editor.actions.synchro.referential.action.deleteFromRight.tip=Supprimer le référentiel sélectionnée de la base de droite

 observe.ui.datasource.editor.actions.synchro.referential.action.revertFromLeft.tip=Revenir en arrière du référentiel sélectionné à gauche

 observe.ui.datasource.editor.actions.synchro.referential.action.revertFromRight.tip=Revenir en arrière du référentiel sélectionné à droite

-observe.ui.datasource.editor.actions.synchro.referential.config.mode=Mode de synchronisation

 observe.ui.datasource.editor.actions.synchro.referential.description=Gestion avancée du référentiel

 observe.ui.datasource.editor.actions.synchro.referential.launch.operation=Calculer le différentiel des référentiels des sources de données

 observe.ui.datasource.editor.actions.synchro.referential.legacy=Mise à jour du référentiel

 observe.ui.datasource.storage.report.action.migrate=Politique de mise à jour

 observe.ui.datasource.storage.report.can.migrate=Mise à jour si nécessaire (version actuelle \: %1$s)

 observe.ui.datasource.storage.report.can.not.migrate=Pas de mise à jour possible

-observe.ui.datasource.storage.required.rw.on.data=Vous n'avez pas les droits suffisants pour effectuer cette opération.\n\nPour effectuer cette opération vous devez avoir les droits de lecture et d'écriture sur les données observateur.

+observe.ui.datasource.storage.required.read.on.data=Vous n'avez pas les droits suffisants pour effectuer cette opération.\n\nPour effectuer cette opération vous devez avoir les droits de lecture sur les données observateur.

 observe.ui.datasource.storage.server.dataBase=Base de données

 observe.ui.datasource.storage.server.dataBase.name=Base

 observe.ui.datasource.storage.server.default.dataBase=par défaut

 observe.referential.common.Wind.swellHeight=Houle (m)

 observe.referential.diff.loading.type=Chargement du référentiel %-2d/%d «%s»

 observe.referential.package.title=%sRéférentiel %s

-observe.service.error.method.unauthorized=Vous n'avez pas les autorisations nécessaire pour appeler le service '%s → %s'

+observe.service.error.method.unauthorized=Vous n'avez pas les droits suffisants pour appeler le service '%s → %s'

 observe.services.topia.error.concurrentModification=La donnée %s est plus récente en base (%s) que votre version (%s)

 observe.services.topia.error.data.not.found=Donnée [%s] (de type\: %s) non trouvée.

 observe.services.topia.error.data.source.with.no.referential=Impossible de créer la base (aucun import référentiel)

Tony CHEMIT pushed to branch develop at ultreiaio / ird-observe

Commits:

29 changed files:

Changes: