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 c1d88ba6fd0084d64cf6a294bd990d8e796ffd1c Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Aug 11 15:50:29 2016 +0200 Simplify noe api --- .../referential/ng/ReferentialSelectionModel.java | 358 --------------------- .../ReferentialSynchronizeTreeCellRenderer.java | 11 +- .../ng/tree/ReferentialSynchronizeTreeModel.java | 230 +++---------- .../ReferentialSynchronizeTreeModelsBuilder.java | 166 ++++++++++ .../node/AddedReferenceReferentialSynchroNode.java | 20 ++ .../tree/node/ReferenceReferentialSynchroNode.java | 96 ------ .../ReferenceReferentialSynchroNodeSupport.java | 53 +++ .../node/ReferenceReferentialSynchroNodeType.java | 70 ---- .../tree/node/ReferentialSynchroNodeSupport.java | 71 +--- .../ng/tree/node/ReferentialSynchroNodeType.java | 13 - .../ng/tree/node/RootReferentialSynchroNode.java | 23 +- .../ng/tree/node/TypeReferentialSynchroNode.java | 34 +- .../UpdatedReferenceReferentialSynchroNode.java | 19 ++ 13 files changed, 344 insertions(+), 820 deletions(-) diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSelectionModel.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSelectionModel.java deleted file mode 100644 index 86f5698..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/ReferentialSelectionModel.java +++ /dev/null @@ -1,358 +0,0 @@ -/* - * #%L - * ObServe :: Business - * %% - * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/gpl-3.0.html>. - * #L% - */ -package fr.ird.observe.ui.admin.synchronize.referential.ng; - -import com.google.common.base.Preconditions; -import com.google.common.collect.Lists; -import fr.ird.observe.db.ObserveSwingDataSource; -import fr.ird.observe.services.dto.DataReference; -import fr.ird.observe.services.dto.referential.ProgramDto; -import fr.ird.observe.services.dto.referential.ReferentialDto; -import fr.ird.observe.services.dto.referential.ReferentialReference; -import fr.ird.observe.services.service.actions.synchro.referential.ReferentialSynchronizeMode; -import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffService; -import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffs; -import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffsEngine; -import org.apache.commons.collections4.CollectionUtils; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.jdesktop.beans.AbstractSerializableBean; - -import java.beans.PropertyChangeListener; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.stream.Collectors; - -import static com.google.common.collect.Maps.newHashMap; -import static com.google.common.collect.Sets.newHashSet; - -/** - * Un modèle pour représenter la sélection de données. - * - * @author Tony Chemit - chemit@codelutin.com - * @since 1.4 - */ -public class ReferentialSelectionModel extends AbstractSerializableBean { - - private ReferentialSynchronizeMode synchronizeMode; - - public static void populate(ReferentialSelectionModel model, ObserveSwingDataSource leftSource, ObserveSwingDataSource rightSource) { - - Preconditions.checkState(leftSource.isOpen()); - Preconditions.checkState(rightSource.isOpen()); - - ReferentialSynchronizeDiffService leftDiffSynchronizeService = leftSource.newReferentialSynchronizeDiffService(); - ReferentialSynchronizeDiffService rightDiffSynchronizeService = rightSource.newReferentialSynchronizeDiffService(); - - ReferentialSynchronizeDiffsEngine engine = new ReferentialSynchronizeDiffsEngine(leftDiffSynchronizeService, rightDiffSynchronizeService); - - ReferentialSynchronizeDiffs synchronizeDiffs = engine.build(model.getSynchronizeMode()); - - - model.setDatas(null); - - } - - protected static void populate(ReferentialReference<ProgramDto> program, - List<DataReference> trips, - Map<ReferentialReference<ProgramDto>, List<DataReference>> datas) { - - if (!trips.isEmpty()) { - - datas.put(program, trips); - if (log.isDebugEnabled()) { - log.debug("Add program " + program.getPropertyValue(ProgramDto.PROPERTY_LABEL1) + " with " + trips.size() + " trip(s)."); - } - - - } - - } - - public static final String PROPERTY_SELECTED_DATA = "selectedData"; - public static final String PROPERTY_DATAS = "datas"; - public static final String PROPERTY_SYNCHRONIZE_MODE = "syncrhronizeMode"; - - /** Logger */ - private static final Log log = LogFactory.getLog(ReferentialSelectionModel.class); - - private static final long serialVersionUID = 2L; - - protected transient Map<Class<? extends ReferentialDto>, List<ReferentialReference<? extends ReferentialDto>>> datas; - - protected transient Set<ReferentialReference> selectedData; - - /** nb marees */ - protected int nbTrips; - - public void populate() { - throw new UnsupportedOperationException(); - } - - public ReferentialSelectionModel() { - - } - - public boolean isEmpty() { - return selectedData == null || selectedData.isEmpty(); - } - - public boolean isFull() { - return selectedData != null && selectedData.size() == nbTrips; - } - - public int selectDataSize() { - return selectedData == null ? 0 : selectedData.size(); - } - - public ReferentialSynchronizeMode getSynchronizeMode() { - return synchronizeMode; - } - - public void setSynchronizeMode(ReferentialSynchronizeMode synchronizeMode) { - ReferentialSynchronizeMode oldValue = getSynchronizeMode(); - this.synchronizeMode = synchronizeMode; - firePropertyChange(PROPERTY_DATAS, oldValue, synchronizeMode); - } - - public Map<Class<? extends ReferentialDto>, List<ReferentialReference<? extends ReferentialDto>>> getDatas() { - if (datas == null) { - datas = newHashMap(); - } - return datas; - } - - public <Type extends ReferentialDto> boolean containsData(Class<Type> program, ReferentialReference<Type> trip) { - List<ReferentialReference<Type>> datas = getDatas(program); - return datas != null && datas.contains(trip); - } - - public Set<ReferentialReference> getSelectedData() { - if (selectedData == null) { - selectedData = newHashSet(); - } - return selectedData; - } - - public Map<Class<? extends ReferentialDto>, List<ReferentialReference<? extends ReferentialDto>>> getSelectedDataByProgram() { - if (datas == null || selectedData == null || selectedData.isEmpty()) { - return Collections.emptyMap(); - } - Map<Class<? extends ReferentialDto>, List<ReferentialReference<? extends ReferentialDto>>> result = new HashMap<>(); - - for (ReferentialReference referenceDto : selectedData) { - - // on recherche son program - for (Class<? extends ReferentialDto> p : datas.keySet()) { - if (datas.get(p).contains(referenceDto)) { - List<ReferentialReference<?>> referenceDtos = result.get(p); - if (referenceDtos == null) { - referenceDtos = Lists.newArrayList(); - result.put(p, referenceDtos); - } - referenceDtos.add(referenceDto); - break; - } - } - } - return result; - } - - public List<Class<? extends ReferentialDto>> getSelectedProgram() { - if (datas == null || selectedData == null || selectedData.isEmpty()) { - return Collections.emptyList(); - } - - Set<Class<? extends ReferentialDto>> result = new HashSet<>(); - - for (ReferentialReference referenceDto : selectedData) { - - // on recherche son program - for (Class<? extends ReferentialDto> p : datas.keySet()) { - if (datas.get(p).contains(referenceDto)) { - result.add(p); - break; - } - } - } - - return result.stream().collect(Collectors.toList()); - } - - - public <Type extends ReferentialDto> List<ReferentialReference<Type>> getSelectedTripsByProgram(Class<Type> program) { - if (datas == null || selectedData == null || selectedData.isEmpty()) { - return Collections.emptyList(); - } - - List<ReferentialReference<Type>> result = getDatas(program).stream() - .filter(trip -> selectedData.contains(trip)) - .collect(Collectors.toList()); - - return result; - } - - public <Type extends ReferentialDto> boolean isSelectedData(ReferentialReference<Type> referenceDto) { - - boolean result; - - List<ReferentialReference<Type>> trips = getDatas(referenceDto.getType()); - result = CollectionUtils.isNotEmpty(trips); - - if (result) { - for (ReferentialReference trip : trips) { - if (!getSelectedData().contains(trip)) { - result = false; - } - } - } - - return result; - - } - - - public void removeAll() { - getSelectedData().clear(); - firePropertyChange(PROPERTY_SELECTED_DATA, selectedData); - } - - public void setDatas(Map<Class<? extends ReferentialDto>, List<ReferentialReference<? extends ReferentialDto>>> datas) { - this.datas = datas; - - // on compte le count de marées totale - int nbTrips = 0; - if (datas != null) { - for (List<ReferentialReference<? extends ReferentialDto>> marees : datas.values()) { - nbTrips += marees.size(); - } - } - this.nbTrips = nbTrips; - - if (log.isDebugEnabled()) { - log.debug("Nb program registred : " + (datas == null ? 0 : datas.size())); - log.debug("Nb trip registred : " + this.nbTrips); - } - firePropertyChange(PROPERTY_DATAS, datas); - } - - public <Type extends ReferentialDto> void addSelectedData(ReferentialReference<Type> referenceDto) { - - if (log.isDebugEnabled()) { - log.debug("Add referential " + referenceDto.getId()); - } - getSelectedData().add((ReferentialReference) referenceDto); - - firePropertyChange(PROPERTY_SELECTED_DATA, selectedData); - } - - public void addAllSelectedData() { - if (log.isDebugEnabled()) { - log.debug("All all data."); - } - for (List<ReferentialReference<? extends ReferentialDto>> p : datas.values()) { - getSelectedData().addAll(p); - } - firePropertyChange(PROPERTY_SELECTED_DATA, selectedData); - } - - public <Type extends ReferentialDto> void removeSelectedData(ReferentialReference<Type> referenceDto) { - - - // ajout d'une marée - if (log.isDebugEnabled()) { - log.debug("Remove maree " + referenceDto); - } - getSelectedData().remove(referenceDto); - - firePropertyChange(PROPERTY_SELECTED_DATA, selectedData); - } - - public void removeAllSelectedData() { - if (selectedData != null) { - selectedData.clear(); - } - firePropertyChange(PROPERTY_SELECTED_DATA, selectedData); - } - - public void destroy() { - removeAll(); - // suppression de tous les listeners - PropertyChangeListener[] listeners = getPropertyChangeListeners(); - for (PropertyChangeListener l : listeners) { - removePropertyChangeListener(l); - } - } - - @Override - protected void finalize() throws Throwable { - super.finalize(); - destroy(); - } - - public <R extends ReferentialDto> List<ReferentialReference<R>> getDatas(Class<R> programId) { - java.util.Optional<Class<? extends ReferentialDto>> programRefOptional = getDatas().keySet().stream().filter(key -> key.equals(programId)).findFirst(); - - List<ReferentialReference<R>> result; - - if (programRefOptional.isPresent()) { - - result = (List) getDatas().get(programRefOptional.get()); - - } else { - - result = Collections.emptyList(); - - } - - return result; - } - - public <R extends ReferentialDto> void addData(Class<R> program, ReferentialReference<R> trip) { - if (!getDatas().containsKey(program)) { - getDatas().put(program, new ArrayList<>()); - } - getDatas(program).add(trip); - firePropertyChange(PROPERTY_DATAS, getDatas()); - } - - public Set<Class<? extends ReferentialDto>> getPrograms() { - return getDatas().keySet(); - } - - public <R extends ReferentialDto> void removeTrip(Class<R> program, ReferentialReference<R> trip) { - List<ReferentialReference<R>> data = getDatas(program); - data.remove(trip); - if (data.isEmpty()) { - getDatas().remove(program); - } - } - - protected void firePropertyChange(String propertyName, Object newValue) { - super.firePropertyChange(propertyName, null, newValue); - } -} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/ReferentialSynchronizeTreeCellRenderer.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/ReferentialSynchronizeTreeCellRenderer.java index 5955104..5e1b845 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 @@ -24,7 +24,7 @@ package fr.ird.observe.ui.admin.synchronize.referential.ng.tree; import fr.ird.observe.ObserveSwingApplicationContext; import fr.ird.observe.application.swing.decoration.DecoratorService; import fr.ird.observe.services.dto.referential.ReferentialReference; -import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferenceReferentialSynchroNode; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferenceReferentialSynchroNodeSupport; import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferentialSynchroNodeSupport; import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.TypeReferentialSynchroNode; import fr.ird.observe.ui.tree.ObserveTreeHelper; @@ -34,7 +34,6 @@ import org.nuiton.decorator.Decorator; import javax.swing.Icon; import javax.swing.JTree; -import javax.swing.UIManager; import javax.swing.tree.DefaultTreeCellRenderer; import java.awt.Color; import java.awt.Component; @@ -97,14 +96,14 @@ public class ReferentialSynchronizeTreeCellRenderer extends DefaultTreeCellRende Icon icon = null; if (node instanceof TypeReferentialSynchroNode) { TypeReferentialSynchroNode node1 = (TypeReferentialSynchroNode) node; - icon = UIManager.getIcon("navigation.sub.referentiel-16"); + icon = node1.getIcon(); text = "<html><body>" + t(DecoratorService.getEntityLabel(ObserveTreeHelper.TREE_NODE_PREFIX, node1.getUserObject())); int childCount = node1.getChildCount(); text += " <i>(" + childCount + ")</i>"; - } else if (node instanceof ReferenceReferentialSynchroNode) { - ReferenceReferentialSynchroNode node1 = (ReferenceReferentialSynchroNode) node; + } else if (node instanceof ReferenceReferentialSynchroNodeSupport) { + ReferenceReferentialSynchroNodeSupport node1 = (ReferenceReferentialSynchroNodeSupport) node; - icon = node1.getType().icon(); + icon = node1.getIcon(); ReferentialReference reference = node1.getUserObject(); Decorator<?> decorator = getDecoratorService().getReferentialReferenceDecorator(reference.getType()); text = "<html><body>" + decorator.toString(reference); 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 9a2050f..8943af9 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,22 +1,9 @@ package fr.ird.observe.ui.admin.synchronize.referential.ng.tree; -import com.google.common.base.Preconditions; -import com.google.common.collect.ImmutableSet; -import fr.ird.observe.db.ObserveSwingDataSource; -import fr.ird.observe.services.dto.referential.ReferentialDto; -import fr.ird.observe.services.dto.referential.ReferentialReference; -import fr.ird.observe.services.dto.referential.ReferentialReferenceSet; -import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiff; -import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffService; -import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffState; -import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffs; -import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffsEngine; -import fr.ird.observe.ui.admin.synchronize.referential.ng.ReferentialSynchroModel; -import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferenceReferentialSynchroNode; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.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.lang3.tuple.Pair; import javax.swing.event.TreeModelListener; import javax.swing.event.TreeSelectionListener; @@ -27,7 +14,6 @@ import javax.swing.tree.TreeModel; import javax.swing.tree.TreePath; import javax.swing.tree.TreeSelectionModel; import java.beans.PropertyChangeListener; -import java.util.Optional; /** * Created on 10/08/16. @@ -37,206 +23,76 @@ import java.util.Optional; public class ReferentialSynchronizeTreeModel implements TreeSelectionModel, TreeModel { private final TreeSelectionModel treeSelectionModel; - private final TreeModel treeModel; - - public static Pair<ReferentialSynchronizeTreeModel, ReferentialSynchronizeTreeModel> buildTreeModels(ReferentialSynchroModel model) { - - ObserveSwingDataSource leftSource = model.getLeftSource(); - Preconditions.checkState(leftSource.isOpen()); - ObserveSwingDataSource rightSource = model.getRightSource(); - Preconditions.checkState(rightSource.isOpen()); - - ReferentialSynchronizeDiffService leftDiffSynchronizeService = leftSource.newReferentialSynchronizeDiffService(); - ReferentialSynchronizeDiffService rightDiffSynchronizeService = rightSource.newReferentialSynchronizeDiffService(); - - ReferentialSynchronizeDiffsEngine engine = new ReferentialSynchronizeDiffsEngine(leftDiffSynchronizeService, rightDiffSynchronizeService); - - ReferentialSynchronizeDiffs synchronizeDiffs = engine.build(model.getSynchronizeMode()); - - ImmutableSet<Class<? extends ReferentialDto>> referentialNames = synchronizeDiffs.getReferentialNames(); - RootReferentialSynchroNode leftRootNode = new RootReferentialSynchroNode(true); - RootReferentialSynchroNode rightRootNode = new RootReferentialSynchroNode(false); - - switch (model.getSynchronizeMode()) { - - case FROM_LEFT_TO_RIGHT: - for (Class<? extends ReferentialDto> referentialName : referentialNames) { - buildFromLeftToRight(engine, referentialName, synchronizeDiffs, leftRootNode, rightRootNode); - } - break; - case FROM_RIGHT_TO_LEFT: - for (Class<? extends ReferentialDto> referentialName : referentialNames) { - buildFromRightToLeft(engine, referentialName, synchronizeDiffs, leftRootNode, rightRootNode); - } - break; - case BOTH: - for (Class<? extends ReferentialDto> referentialName : referentialNames) { - buildFromBoth(engine, referentialName, synchronizeDiffs, leftRootNode, rightRootNode); - } - break; - } - - return Pair.of(new ReferentialSynchronizeTreeModel(leftRootNode), new ReferentialSynchronizeTreeModel(rightRootNode)); - } - - private static <R extends ReferentialDto> void read(ReferentialSynchronizeDiffsEngine engine, - ReferentialSynchronizeDiff synchronizeDiff, - Class<R> referentialName, - RootReferentialSynchroNode rootNode) { - - Optional<ImmutableSet<ReferentialSynchronizeDiffState>> optionalAddedReferentials = synchronizeDiff.getAddedReferentials(referentialName); - Optional<ImmutableSet<ReferentialSynchronizeDiffState>> optionalUpdatedReferentials = synchronizeDiff.getUpdatedReferentials(referentialName); - - boolean withAdd = optionalAddedReferentials.isPresent(); - boolean withUpdate = optionalUpdatedReferentials.isPresent(); - - TypeReferentialSynchroNode typeNode = rootNode.addTypeNode(referentialName); - - if (withAdd) { + private final DefaultTreeModel treeModel; - // des référentiels à supprimer - ImmutableSet<ReferentialSynchronizeDiffState> diffStates = optionalAddedReferentials.get(); - ReferentialReferenceSet<R> referenceSet = engine.getRightReferentialReferenceSet(referentialName, diffStates); + private boolean canCopy; + private boolean canDelete; + private boolean canRevert; - for (ReferentialReference<R> referentialReference : referenceSet.getReferences()) { + public synchronized void updateSelectedActions() { - ReferenceReferentialSynchroNode node = typeNode.addDeleteNode(referentialReference); + canCopy = canDelete = canRevert = false; - } - } - if (withUpdate) { + for (TreePath selectionPath : getSelectionPaths()) { + ReferentialSynchroNodeSupport lastPathComponent = (ReferentialSynchroNodeSupport) selectionPath.getLastPathComponent(); - // des mises à jour ç annuler - ImmutableSet<ReferentialSynchronizeDiffState> diffStates = optionalUpdatedReferentials.get(); - ReferentialReferenceSet<R> referenceSet = engine.getRightReferentialReferenceSet(referentialName, diffStates); + if (lastPathComponent instanceof ReferenceReferentialSynchroNodeSupport) { - for (ReferentialReference<R> referentialReference : referenceSet.getReferences()) { - - ReferenceReferentialSynchroNode node = typeNode.addRevertNode(referentialReference); + ReferenceReferentialSynchroNodeSupport node = (ReferenceReferentialSynchroNodeSupport) lastPathComponent; + canCopy |= node.isCanCopy(); + canDelete |= node.isCanDelete(); + canRevert |= node.isCanRevert(); } } - } - private static <R extends ReferentialDto> void write(ReferentialSynchronizeDiffsEngine engine, - ReferentialSynchronizeDiff synchronizeDiff, - Class<R> referentialName, - RootReferentialSynchroNode rootNode) { - - Optional<ImmutableSet<ReferentialSynchronizeDiffState>> optionalAddedReferentials = synchronizeDiff.getAddedReferentials(referentialName); - Optional<ImmutableSet<ReferentialSynchronizeDiffState>> optionalUpdatedReferentials = synchronizeDiff.getUpdatedReferentials(referentialName); - - boolean withAdd = optionalAddedReferentials.isPresent(); - boolean withUpdate = optionalUpdatedReferentials.isPresent(); - - TypeReferentialSynchroNode typeNode = rootNode.addTypeNode(referentialName); - - if (withAdd) { - - // des référentiels à ajouter - ImmutableSet<ReferentialSynchronizeDiffState> diffStates = optionalAddedReferentials.get(); - ReferentialReferenceSet<R> referenceSet = engine.getRightReferentialReferenceSet(referentialName, diffStates); - - for (ReferentialReference<R> referentialReference : referenceSet.getReferences()) { - - ReferenceReferentialSynchroNode node = typeNode.addAddNode(referentialReference); - - } - } - if (withUpdate) { - - // des mises à jour - ImmutableSet<ReferentialSynchronizeDiffState> diffStates = optionalUpdatedReferentials.get(); - ReferentialReferenceSet<R> referenceSet = engine.getRightReferentialReferenceSet(referentialName, diffStates); - - for (ReferentialReference<R> referentialReference : referenceSet.getReferences()) { - - ReferenceReferentialSynchroNode node = typeNode.addUpdateNode(referentialReference); - - } - - } + public boolean isCanCopy() { + return canCopy; } - - private static <R extends ReferentialDto> void buildFromLeftToRight(ReferentialSynchronizeDiffsEngine engine, - Class<R> referentialName, - ReferentialSynchronizeDiffs synchronizeDiffs, - RootReferentialSynchroNode leftRootNode, - RootReferentialSynchroNode rightRootNode) { - - boolean inLeft = synchronizeDiffs.isLeftReferentialUsed(referentialName); - boolean inRight = synchronizeDiffs.isRightReferentialUsed(referentialName); - - if (inLeft) { - - read(engine, synchronizeDiffs.getLeftDiff(), referentialName, leftRootNode); - - } - - if (inRight) { - - write(engine, synchronizeDiffs.getRightDiff(), referentialName, rightRootNode); - - } + public boolean isCanDelete() { + return canDelete; } - private static void buildFromRightToLeft(ReferentialSynchronizeDiffsEngine engine, - Class<? extends ReferentialDto> referentialName, - ReferentialSynchronizeDiffs synchronizeDiffs, - RootReferentialSynchroNode leftRootNode, - RootReferentialSynchroNode rightRootNode) { - - boolean inLeft = synchronizeDiffs.isLeftReferentialUsed(referentialName); - boolean inRight = synchronizeDiffs.isRightReferentialUsed(referentialName); - - if (inLeft) { - - write(engine, synchronizeDiffs.getLeftDiff(), referentialName, leftRootNode); - - } - if (inRight) { - - read(engine, synchronizeDiffs.getRightDiff(), referentialName, rightRootNode); - - } + public boolean isCanRevert() { + return canRevert; } - private static void buildFromBoth(ReferentialSynchronizeDiffsEngine engine, - Class<? extends ReferentialDto> referentialName, - ReferentialSynchronizeDiffs synchronizeDiffs, - RootReferentialSynchroNode leftRootNode, - RootReferentialSynchroNode rightRootNode) { - - boolean inLeft = synchronizeDiffs.isLeftReferentialUsed(referentialName); - boolean inRight = synchronizeDiffs.isRightReferentialUsed(referentialName); + public boolean isCanSkip() { + return getSelectionCount() > 0; + } - if (inLeft) { + public ReferentialSynchronizeTreeModel(RootReferentialSynchroNode root) { + this.treeModel = new DefaultTreeModel(root); + this.treeSelectionModel = new DefaultTreeSelectionModel(); + setSelectionMode(DISCONTIGUOUS_TREE_SELECTION); + } - write(engine, synchronizeDiffs.getLeftDiff(), referentialName, leftRootNode); - read(engine, synchronizeDiffs.getLeftDiff(), referentialName, leftRootNode); + public boolean isCanWrite() { + return getRoot().isCanWrite(); + } - } - if (inRight) { + public boolean isLeft() { + return getRoot().isLeft(); + } - read(engine, synchronizeDiffs.getRightDiff(), referentialName, rightRootNode); - write(engine, synchronizeDiffs.getRightDiff(), referentialName, rightRootNode); + public void removeReferenceNode(ReferenceReferentialSynchroNodeSupport node) { + TypeReferentialSynchroNode parent = node.getParent(); + treeModel.removeNodeFromParent(node); + if (parent.isLeaf()) { + treeModel.removeNodeFromParent(parent); + } else { + treeModel.reload(parent); } } - public ReferentialSynchronizeTreeModel(ReferentialSynchroNodeSupport root) { - this.treeModel = new DefaultTreeModel(root); - this.treeSelectionModel = new DefaultTreeSelectionModel(); - setSelectionMode(DISCONTIGUOUS_TREE_SELECTION); - } - @Override - public ReferentialSynchroNodeSupport getRoot() { - return (ReferentialSynchroNodeSupport) treeModel.getRoot(); + public RootReferentialSynchroNode getRoot() { + return (RootReferentialSynchroNode) treeModel.getRoot(); } @Override 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 new file mode 100644 index 0000000..75f4199 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/ReferentialSynchronizeTreeModelsBuilder.java @@ -0,0 +1,166 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.tree; + +import com.google.common.collect.ImmutableSet; +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.services.dto.referential.ReferentialReferenceSet; +import fr.ird.observe.services.service.actions.synchro.referential.ReferentialSynchronizeMode; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiff; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffState; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffs; +import fr.ird.observe.services.service.actions.synchro.referential.diff.ReferentialSynchronizeDiffsEngine; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.AddedReferenceReferentialSynchroNode; +import fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.ReferenceReferentialSynchroNodeSupport; +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 fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node.UpdatedReferenceReferentialSynchroNode; +import org.apache.commons.lang3.tuple.Pair; + +import java.util.Objects; +import java.util.Optional; + +/** + * Created on 11/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class ReferentialSynchronizeTreeModelsBuilder { + + private final ReferentialSynchronizeDiffsEngine engine; + 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); + } + + public Pair<ReferentialSynchronizeTreeModel, ReferentialSynchronizeTreeModel> build() { + + ReferentialSynchronizeDiffs synchronizeDiffs = engine.build(); + + ImmutableSet<Class<? extends ReferentialDto>> referentialNames = synchronizeDiffs.getReferentialNames(); + + ReferentialSynchronizeDiff leftDiff = synchronizeDiffs.getLeftDiff(); + ReferentialSynchronizeDiff rightDiff = synchronizeDiffs.getRightDiff(); + + for (Class<? extends ReferentialDto> referentialName : referentialNames) { + + { + // Tous les référentiels ajoutés à gauche peuvent être copié à droite + Optional<ImmutableSet<ReferentialSynchronizeDiffState>> optionalDiffStates = leftDiff.getAddedReferentials(referentialName); + if (optionalDiffStates.isPresent()) { + addFromLeft(leftRootNode, optionalDiffStates.get(), referentialName, leftAddNode); + } + } + { + // Tous les référentiels mises à jour à gauche peuvent être copié à droite + Optional<ImmutableSet<ReferentialSynchronizeDiffState>> optionalDiffStates = leftDiff.getUpdatedReferentials(referentialName); + if (optionalDiffStates.isPresent()) { + addFromLeft(leftRootNode, optionalDiffStates.get(), referentialName, leftUpdateNode); + } + } + { + // Tous les référentiels ajoutés à droite peuvent être supprimé ou désactivés + Optional<ImmutableSet<ReferentialSynchronizeDiffState>> optionalDiffStates = rightDiff.getAddedReferentials(referentialName); + if (optionalDiffStates.isPresent()) { + addFromRight(rightRootNode, optionalDiffStates.get(), referentialName, rightAddNode); + } + } + { + // Tous les référentiels mises à jour à droite peuvent être remis en arrière + Optional<ImmutableSet<ReferentialSynchronizeDiffState>> optionalDiffStates = rightDiff.getUpdatedReferentials(referentialName); + if (optionalDiffStates.isPresent()) { + addFromRight(rightRootNode, optionalDiffStates.get(), referentialName, rightUpdateNode); + } + } + } + + ReferentialSynchronizeTreeModel leftTreeModel = new ReferentialSynchronizeTreeModel(leftRootNode); + ReferentialSynchronizeTreeModel rightTreeModel = new ReferentialSynchronizeTreeModel(rightRootNode); + return Pair.of(leftTreeModel, rightTreeModel); + + } + + + 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(); + if (!references.isEmpty()) { + TypeReferentialSynchroNode typeNode = rootNode.getOrAddTypeNode(referentialName); + for (ReferentialReference<R> reference : references) { + createNode.createNode(typeNode, reference); + } + + } + } + + private <R extends ReferentialDto> void addFromRight(RootReferentialSynchroNode rootNode, ImmutableSet<ReferentialSynchronizeDiffState> diffStates, Class<R> referentialName, CreateNode createNode) { + ReferentialReferenceSet<R> referenceSet = engine.getRightReferentialReferenceSet(referentialName, diffStates); + ImmutableSet<ReferentialReference<R>> references = referenceSet.getReferences(); + if (!references.isEmpty()) { + TypeReferentialSynchroNode typeNode = rootNode.getOrAddTypeNode(referentialName); + for (ReferentialReference<R> reference : references) { + createNode.createNode(typeNode, reference); + } + } + } + + private static abstract class CreateNode <R extends ReferentialDto>{ + + protected final boolean canCopy; + protected final boolean canDelete; + protected final boolean canRevert; + + protected CreateNode(boolean canCopy, boolean canDelete, boolean canRevert) { + this.canCopy = canCopy; + this.canDelete = canDelete; + this.canRevert = canRevert; + } + + public abstract void createNode(TypeReferentialSynchroNode typeNode, ReferentialReference<R> reference); + + } + + private static class CreateAddNode<R extends ReferentialDto> extends CreateNode<R> { + + 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); + typeNode.add(node); + } + } + + private static class CreateUpdateNode<R extends ReferentialDto> extends CreateNode<R> { + + 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); + 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 new file mode 100644 index 0000000..dee67f2 --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/AddedReferenceReferentialSynchroNode.java @@ -0,0 +1,20 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +/** + * Created on 11/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class AddedReferenceReferentialSynchroNode extends ReferenceReferentialSynchroNodeSupport { + + private static final long serialVersionUID = 1L; + + public AddedReferenceReferentialSynchroNode(ReferentialReference<? extends ReferentialDto> referentialReference,boolean canCopy, boolean canDelete, boolean canRevert) { + super(referentialReference, "synchroAdd", canCopy, canDelete, canRevert); + } + + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNode.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNode.java deleted file mode 100644 index ba1e41a..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNode.java +++ /dev/null @@ -1,96 +0,0 @@ -package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; - -import fr.ird.observe.services.dto.referential.ReferentialDto; -import fr.ird.observe.services.dto.referential.ReferentialReference; - -/** - * Created on 09/08/16. - * - * @author Tony Chemit - chemit@codelutin.com - * @since 5.0 - */ -public class ReferenceReferentialSynchroNode extends ReferentialSynchroNodeSupport { - - private static final long serialVersionUID = 1L; - - private final ReferenceReferentialSynchroNodeType type; - - public ReferenceReferentialSynchroNode(boolean left, ReferenceReferentialSynchroNodeType type, ReferentialReference<? extends ReferentialDto> referentialReference) { - super(left, ReferentialSynchroNodeType.REFERENCE, referentialReference); - this.type = type; - } - - public ReferenceReferentialSynchroNodeType getType() { - return type; - } - - @Override - public TypeReferentialSynchroNode getParent() { - return (TypeReferentialSynchroNode) super.getParent(); - } - - @Override - public ReferentialReference getUserObject() { - return (ReferentialReference) super.getUserObject(); - } - - @Override - public boolean canRevertToLeft() { - return isLeft() && type.canRevert(); - } - - @Override - public boolean canRevertToRight() { - return isRight() && type.canRevert(); - } - - @Override - public boolean canAddToLeft() { - return isLeft() && type.canAdd(); - } - - @Override - public boolean canAddToRight() { - return isRight() && type.canAdd(); - } - - @Override - public boolean canUpdateToLeft() { - return isLeft() && type.canUpdate(); - } - - @Override - public boolean canUpdateToRight() { - return isRight() && type.canUpdate(); - } - - @Override - public boolean canDeleteFromLeft() { - return isLeft() && type.canDelete(); - } - - @Override - public boolean canDeleteFromRight() { - return isRight() && type.canDelete(); - } - - @Override - public boolean canDesactivateFromLeft() { - return isLeft() && type.canDesactivate(); - } - - @Override - public boolean canDesactivateFromRight() { - return isRight() && type.canDesactivate(); - } - - @Override - public boolean canDesactivateFromLeftWithReplace() { - return isLeft() && type.canDesactivateWithReplace(); - } - - @Override - public boolean canDesactivateFromRightWithReplace() { - return isRight() && type.canDesactivateWithReplace(); - } -} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNodeSupport.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNodeSupport.java new file mode 100644 index 0000000..055c00d --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNodeSupport.java @@ -0,0 +1,53 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; +import fr.ird.observe.ui.UIHelper; + +/** + * Created on 09/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 + */ +public abstract class ReferenceReferentialSynchroNodeSupport extends ReferentialSynchroNodeSupport { + + private static final long serialVersionUID = 1L; + + private final boolean canCopy; + private final boolean canDelete; + private final boolean canRevert; + + protected ReferenceReferentialSynchroNodeSupport(ReferentialReference<? extends ReferentialDto> referentialReference, String iconName, + boolean canCopy, + boolean canDelete, + boolean canRevert) { + super(UIHelper.createActionIcon(iconName), referentialReference); + this.canCopy = canCopy; + this.canDelete = canDelete; + this.canRevert = canRevert; + } + + public boolean isCanCopy() { + return canCopy; + } + + public boolean isCanDelete() { + return canDelete; + } + + public boolean isCanRevert() { + return canRevert; + } + + @Override + public TypeReferentialSynchroNode getParent() { + return (TypeReferentialSynchroNode) super.getParent(); + } + + @Override + public ReferentialReference getUserObject() { + return (ReferentialReference) super.getUserObject(); + } + +} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNodeType.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNodeType.java deleted file mode 100644 index 0605f0f..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferenceReferentialSynchroNodeType.java +++ /dev/null @@ -1,70 +0,0 @@ -package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; - -import fr.ird.observe.ui.UIHelper; - -import javax.swing.Icon; - -/** - * Created on 10/08/16. - * - * @author Tony Chemit - chemit@codelutin.com - */ -public enum ReferenceReferentialSynchroNodeType { - - ADD(true, false, false, false, false, false, "synchroAdd"), - UPDATE(false, true, false, false, false, false, "synchroUpdate"), - REVERT(false, false, true, false, false, false, "synchroRevert"), - DELETE(false, false, false, true, true, true, "synchroDelete"); - - private final boolean canAdd; - private final boolean canUpdate; - private final boolean canRevert; - private final boolean canDelete; - private final boolean canDesactivate; - private final boolean canDesactivateWithReplace; - private final transient Icon icon; - - ReferenceReferentialSynchroNodeType(boolean canAdd, - boolean canUpdate, - boolean canRevert, - boolean canDelete, - boolean canDesactivate, - boolean canDesactivateWithReplace, - String actionIconName) { - this.canAdd = canAdd; - this.canUpdate = canUpdate; - this.canRevert = canRevert; - this.canDelete = canDelete; - this.canDesactivate = canDesactivate; - this.canDesactivateWithReplace = canDesactivateWithReplace; - this.icon = UIHelper.createActionIcon(actionIconName); - } - - public boolean canAdd() { - return canAdd; - } - - public boolean canUpdate() { - return canUpdate; - } - - public boolean canRevert() { - return canRevert; - } - - public boolean canDelete() { - return canDelete; - } - - public boolean canDesactivate() { - return canDesactivate; - } - - public boolean canDesactivateWithReplace() { - return canDesactivateWithReplace; - } - - public Icon icon() { - return icon; - } -} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferentialSynchroNodeSupport.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferentialSynchroNodeSupport.java index 487b54f..a206fe9 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferentialSynchroNodeSupport.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferentialSynchroNodeSupport.java @@ -1,5 +1,6 @@ package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; +import javax.swing.Icon; import javax.swing.tree.DefaultMutableTreeNode; /** @@ -11,73 +12,27 @@ public abstract class ReferentialSynchroNodeSupport extends DefaultMutableTreeNo private static final long serialVersionUID = 1L; - private final boolean left; - private final ReferentialSynchroNodeType nodeType; + private transient Icon icon; - protected ReferentialSynchroNodeSupport(boolean left, ReferentialSynchroNodeType nodeType, Object userObject) { - this.left = left; - this.nodeType = nodeType; + protected ReferentialSynchroNodeSupport(Icon icon, Object userObject) { setUserObject(userObject); + this.icon = icon; } - public boolean isLeft() { - return left; - } - - public boolean isRight() { - return !left; - } - - public ReferentialSynchroNodeType getNodeType() { - return nodeType; - } - - public boolean canRevertToLeft() { - return false; - } - - public boolean canRevertToRight() { - return false; - } - - public boolean canAddToLeft() { - return false; - } - - public boolean canAddToRight() { - return false; + public Icon getIcon() { + return icon; } - public boolean canUpdateToLeft() { - return false; - } - - public boolean canUpdateToRight() { - return false; - } - - public boolean canDeleteFromLeft() { - return false; - } - - public boolean canDeleteFromRight() { - return false; - } - - public boolean canDesactivateFromLeft() { - return false; - } - - public boolean canDesactivateFromRight() { - return false; + public boolean isLeft() { + return getRoot().isLeaf(); } - public boolean canDesactivateFromLeftWithReplace() { - return false; + public boolean isRight() { + return !isLeft(); } - public boolean canDesactivateFromRightWithReplace() { - return false; + @Override + public ReferentialSynchroNodeSupport getParent() { + return (ReferentialSynchroNodeSupport) super.getParent(); } - } diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferentialSynchroNodeType.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferentialSynchroNodeType.java deleted file mode 100644 index 29be162..0000000 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/ReferentialSynchroNodeType.java +++ /dev/null @@ -1,13 +0,0 @@ -package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; - -/** - * Created on 10/08/16. - * - * @author Tony Chemit - chemit@codelutin.com - * @since 5.0 - */ -public enum ReferentialSynchroNodeType { - ROOT, - TYPE, - REFERENCE -} diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/RootReferentialSynchroNode.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/RootReferentialSynchroNode.java index 6df1105..3ba65dd 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/RootReferentialSynchroNode.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/RootReferentialSynchroNode.java @@ -8,18 +8,34 @@ import java.util.Enumeration; * Created on 10/08/16. * * @author Tony Chemit - chemit@codelutin.com + * @since 5.0 */ public class RootReferentialSynchroNode extends ReferentialSynchroNodeSupport { + private static final long serialVersionUID = 1L; - public RootReferentialSynchroNode(boolean left) { - super(left, ReferentialSynchroNodeType.ROOT, null); + private final boolean left; + private final boolean canWrite; + + public RootReferentialSynchroNode(boolean left, boolean canWrite) { + super(null, null); + this.left = left; + this.canWrite = canWrite; + } + + @Override + public boolean isLeft() { + return left; + } + + public boolean isCanWrite() { + return canWrite; } public <R extends ReferentialDto> TypeReferentialSynchroNode getOrAddTypeNode(Class<R> referentialName) { TypeReferentialSynchroNode node = getChild(referentialName); if (node == null) { - node = new TypeReferentialSynchroNode(isLeft(), referentialName); + node = new TypeReferentialSynchroNode(referentialName); add(node); } return node; @@ -35,4 +51,5 @@ public class RootReferentialSynchroNode extends ReferentialSynchroNodeSupport { } return null; } + } diff --git a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/TypeReferentialSynchroNode.java b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/TypeReferentialSynchroNode.java index 8378773..1d3ec2d 100644 --- a/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/TypeReferentialSynchroNode.java +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/TypeReferentialSynchroNode.java @@ -1,8 +1,8 @@ package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; import fr.ird.observe.services.dto.referential.ReferentialDto; -import fr.ird.observe.services.dto.referential.ReferentialReference; +import javax.swing.UIManager; import java.util.Enumeration; /** @@ -14,8 +14,8 @@ public class TypeReferentialSynchroNode extends ReferentialSynchroNodeSupport { private static final long serialVersionUID = 1L; - public TypeReferentialSynchroNode(boolean left, Class<? extends ReferentialDto> type) { - super(left, ReferentialSynchroNodeType.TYPE, type); + public TypeReferentialSynchroNode(Class<? extends ReferentialDto> type) { + super(UIManager.getIcon("navigation.sub.referentiel-16"), type); } @Override @@ -23,10 +23,10 @@ public class TypeReferentialSynchroNode extends ReferentialSynchroNodeSupport { return (RootReferentialSynchroNode) super.getParent(); } - public <R extends ReferentialDto> ReferenceReferentialSynchroNode getChild(String id) { + public <R extends ReferentialDto> ReferenceReferentialSynchroNodeSupport getChild(String id) { Enumeration children = children(); while (children.hasMoreElements()) { - ReferenceReferentialSynchroNode o = (ReferenceReferentialSynchroNode) children.nextElement(); + ReferenceReferentialSynchroNodeSupport o = (ReferenceReferentialSynchroNodeSupport) children.nextElement(); if (id.equals(o.getUserObject().getId())) { return o; } @@ -39,28 +39,4 @@ public class TypeReferentialSynchroNode extends ReferentialSynchroNodeSupport { return (Class) super.getUserObject(); } - public <R extends ReferentialDto> ReferenceReferentialSynchroNode addDeleteNode(ReferentialReference<R> referentialReference) { - ReferenceReferentialSynchroNode node = new ReferenceReferentialSynchroNode(isLeft(), ReferenceReferentialSynchroNodeType.DELETE, referentialReference); - add(node); - return node; - } - - public <R extends ReferentialDto> ReferenceReferentialSynchroNode addAddNode(ReferentialReference<R> referentialReference) { - ReferenceReferentialSynchroNode node = new ReferenceReferentialSynchroNode(isLeft(), ReferenceReferentialSynchroNodeType.ADD, referentialReference); - add(node); - return node; - } - - public <R extends ReferentialDto> ReferenceReferentialSynchroNode addUpdateNode(ReferentialReference<R> referentialReference) { - ReferenceReferentialSynchroNode node = new ReferenceReferentialSynchroNode(isLeft(), ReferenceReferentialSynchroNodeType.UPDATE, referentialReference); - add(node); - return node; - } - - public <R extends ReferentialDto> ReferenceReferentialSynchroNode addRevertNode(ReferentialReference<R> referentialReference) { - ReferenceReferentialSynchroNode node = new ReferenceReferentialSynchroNode(isLeft(), ReferenceReferentialSynchroNodeType.REVERT, referentialReference); - add(node); - return node; - } - } diff --git a/observe-application-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 new file mode 100644 index 0000000..f53816b --- /dev/null +++ b/observe-application-swing/src/main/java/fr/ird/observe/ui/admin/synchronize/referential/ng/tree/node/UpdatedReferenceReferentialSynchroNode.java @@ -0,0 +1,19 @@ +package fr.ird.observe.ui.admin.synchronize.referential.ng.tree.node; + +import fr.ird.observe.services.dto.referential.ReferentialDto; +import fr.ird.observe.services.dto.referential.ReferentialReference; + +/** + * Created on 11/08/16. + * + * @author Tony Chemit - chemit@codelutin.com + */ +public class UpdatedReferenceReferentialSynchroNode extends ReferenceReferentialSynchroNodeSupport { + + private static final long serialVersionUID = 1L; + + public UpdatedReferenceReferentialSynchroNode(ReferentialReference<? extends ReferentialDto> referentialReference, boolean canCopy, boolean canDelete, boolean canRevert) { + super(referentialReference, "synchroUpdate", canCopy, canDelete, canRevert); + } + +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.