GitLab

at 2017-08-19T12:25:40+02:00

Améliorer le tri des types (See #853)

amélioration du chargement de la base

 key = ui.treeOpenNodes

 type = string

 

+[option treeSelectedNodes]

+description = observe.config.ui.treeSelectedNodes.description

+key = ui.treeSelectedNodes

+type = string

+

 [option validationSpeedEnable]

 description = observe.config.validation.speedEnable

 key = validation.speedEnable

 

     public void saveTreeOpenNodeIds(String... ids) {

         setTreeOpenNodes(StringUtils.join(ids, ","));

-        saveForUser();

+    }

+

+    public String[] getTreeSelectedNodeIds() {

+        String ids = getTreeSelectedNodes();

+        String[] result = null;

+        if (ids != null) {

+            result = ids.split(",");

+        }

+        return result;

+    }

+

+    public void saveTreeSelectedNodeIds(String... ids) {

+        setTreeSelectedNodes(StringUtils.join(ids, ","));

     }

 

     public File newBackupDataFile() {

 observe.config.ui.showTimeEditorSlider=Show timer slider

 observe.config.ui.storeRemoteStorage=Flag sets to true to store in config a remote connexion (except passwords)

 observe.config.ui.treeOpenNodes=Opened data from last session

+observe.config.ui.treeSelectedNodes.description=Selected nodes on last data source

 observe.config.validation.lengthWeightEnable=Force validation of species length max

 observe.config.validation.speedEnable=Force validation of activities speed

 observe.config.validation.speedMaxValue=Max speed value used in activities speed validation

 observe.config.ui.showTimeEditorSlider=Para mostrar la regla de edición de las horas

 observe.config.ui.storeRemoteStorage=Para activar la copia de seguridad de la configuración de la fuente de datos remota

 observe.config.ui.treeOpenNodes=Nudos abiertos del arbol abiertos cuando se cerró la base por última vez

+observe.config.ui.treeSelectedNodes.description=Selected nodes on last data source \#TODO

 observe.config.validation.lengthWeightEnable=Forcer la validation des bormes min/max de taille d'espèce \#TODO

 observe.config.validation.speedEnable=Force validation of activities speedTODO

 observe.config.validation.speedMaxValue=Max speed value used in activities speed validationTODO

 observe.config.ui.showTimeEditorSlider=Pour afficher la réglette d'édition des heures

 observe.config.ui.storeRemoteStorage=Pour activer la sauvegarde de la configuration de la source distante

 observe.config.ui.treeOpenNodes=Nœuds de l'arbre ouverts lors de la dernière fermeture de la base

+observe.config.ui.treeSelectedNodes.description=Nœuds sélectionnés sur la dernière base ouverte

 observe.config.validation.lengthWeightEnable=Forcer la validation des bormes min/max de taille d'espèce

 observe.config.validation.speedEnable=Forcer la validation des vitesses d'activités

 observe.config.validation.speedMaxValue=Vitesse maximale autorisée dans le contrôle des vitesses d'activités

     public void sanitize(ProgressModel progressModel, ObserveSwingDataSource dataSource) {

 

         ImmutableSet<String> existingIds = getIds();

-        ImmutableSet<String> ids = dataSource.getFloatingObjectService().retainExistingIds(existingIds);

+        ImmutableSet<String> ids = dataSource.getNavigationService().retainExistingIds(existingIds);

         int beforeSize = references.size();

 

         Iterator<FloatingObjectReference> iterator = references.iterator();

  */

 

 import com.google.common.base.Preconditions;

+import com.google.common.collect.ImmutableSet;

 import fr.ird.observe.client.db.ClientDataContext;

 import fr.ird.observe.client.db.ObserveSwingDataSource;

 import fr.ird.observe.client.ui.util.ProgressModel;

-import fr.ird.observe.services.ObserveServicesProvider;

-import fr.ird.observe.services.dto.IdHelper;

-import fr.ird.observe.services.dto.referential.ProgramDto;

 import java.io.Closeable;

 import java.util.Objects;

 

         this.dataContext = dataContext;

     }

 

-    public boolean canOpenProgram() {

+    private boolean canOpenProgram() {

         return !dataContext.isOpenProgram();

     }

 

         dataContext.resetOpen();

     }

 

-    public void sanitizeOpenIds(ProgressModel progressModel, String[] ids) {

+    public void sanitizeIds(ProgressModel progressModel, String[] ids) {

         if (ids != null) {

 

-            boolean exists = true;

+            ImmutableSet<String> safeIds = ObserveSwingDataSource.MAIN.getNavigationService().retainExistingIds(ImmutableSet.copyOf(ids));

+

+            progressModel.incrementsCurrentStep();

 

             for (int i = 0, l = ids.length; i < l; i++) {

                 String id = ids[i];

-

-                // si l'id précédent existe, on vérifie l'actuel

-                // sinon, on met à null

-                if (exists) {

-                    ObserveServicesProvider servicesProvider = ObserveSwingDataSource.MAIN;

-                    if (IdHelper.isProgramId(id)) {

-

-                        exists = servicesProvider.getReferentialService().exists(ProgramDto.class, id);

-

-                    } else if (IdHelper.isTripSeineId(id)) {

-

-                        exists = servicesProvider.getTripSeineService().exists(id);

-

-                    } else if (IdHelper.isRouteId(id)) {

-

-                        exists = servicesProvider.getRouteService().exists(id);

-

-                    } else if (IdHelper.isActivitySeineId(id)) {

-

-                        exists = servicesProvider.getActivitySeineService().exists(id);

-

-                    } else if (IdHelper.isSetSeineId(id)) {

-

-                        exists = servicesProvider.getSetSeineService().exists(id);

-

-                    } else if (IdHelper.isFloatingObjectId(id)) {

-

-                        exists = servicesProvider.getFloatingObjectService().exists(id);

-

-                    } else if (IdHelper.isTripLonglineId(id)) {

-

-                        exists = servicesProvider.getTripLonglineService().exists(id);

-

-                    } else if (IdHelper.isActivityLonglineId(id)) {

-

-                        exists = servicesProvider.getActivityLonglineService().exists(id);

-

-                    } else {

-                        exists = IdHelper.isSetLonglineId(id) && servicesProvider.getSetLonglineService().exists(id);

-                    }

-                }

-

-                if (!exists) {

+                if (!safeIds.contains(id)) {

                     ids[i] = null;

                 }

+

                 progressModel.incrementsCurrentStep();

             }

         }

     }

+

 }
  */

 

 import fr.ird.observe.client.db.constants.DataContextType;

-import fr.ird.observe.services.dto.IdHelper;

-import fr.ird.observe.services.dto.referential.ProgramDto;

-import fr.ird.observe.services.dto.seine.RouteDto;

 import fr.ird.observe.services.validation.ValidationDataContext;

 import java.util.ArrayList;

 import java.util.Arrays;

         firePropertyChange(PROPERTY_ENABLED, oldValue, enabled);

     }

 

-    public boolean isSelectionChanged() {

+    private boolean isSelectionChanged() {

         return selectionChanged;

     }

 

-    private boolean getSelectionChanged() {

-        return selectionChanged;

-    }

-

-    private void setSelectionChanged(boolean selectionChanged) {

-        boolean oldValue = getSelectionChanged();

-        this.selectionChanged = selectionChanged;

-        firePropertyChange(PROPERTY_SELECTION_CHANGED, oldValue, selectionChanged);

+    private void setSelectionChanged() {

+        boolean oldValue = isSelectionChanged();

+        this.selectionChanged = true;

+        firePropertyChange(PROPERTY_SELECTION_CHANGED, oldValue, true);

     }

 

     private static DataContextType[] types;

         return null;

     }

 

-    private String[] getSelectedIds() {

+    String[] getSelectedIds() {

 

         List<String> ids = new ArrayList<>();

 

         return ids.toArray(new String[ids.size()]);

     }

 

-    public String[] getOpenIds(Class<?> type) {

-

-        String[] result = null;

-

-        if (isOpenProgram()) {

-

-            List<String> ids = new ArrayList<>();

-            ids.add(getOpenProgramId());

-

-            if (!ProgramDto.class.equals(type) && isOpenTrip()) {

-

-                String tripId = getOpenTripId();

-                ids.add(tripId);

-

-                if (IdHelper.isTripSeineId(tripId)) {

-

-                    // on a seine trip

-                    if (!IdHelper.isTripClass(type) && isOpenRoute()) {

-

-                        ids.add(getOpenRouteId());

-

-                        if (!RouteDto.class.equals(type) && isOpenActivitySeine()) {

-

-                            ids.add(getOpenActivitySeineId());

-

-                            if (!IdHelper.isActivityClass(type) && isOpenSetSeine()) {

-                                ids.add(getOpenSetSeineId());

-                            }

-                        }

-                    }

-

-                } else {

-

-                    // on a longline trip

-                    if (!IdHelper.isTripClass(type) && isOpenActivityLongline()) {

-

-                        ids.add(getOpenActivityLonglineId());

-

-                        if (!IdHelper.isActivityClass(type) && isOpenSetLongline()) {

-                            ids.add(getOpenSetLonglineId());

-                        }

-

-                    }

-

-                }

-

-            }

-

-            result = ids.toArray(new String[ids.size()]);

-

-        }

-

-        return result;

-    }

-

     public boolean isOpenProgram() {

         return openProgramId != null;

     }

         for (DataContextType entityType : DataContextType.values()) {

             if (entityType.acceptType(type)) {

 

-                // bon type trouve

-

                 String openId = entityType.getOpenId(this);

                 String selectedId = entityType.getSelectedId(this);

-                if (selectedId == null || openId == null) {

+                return selectedId != null && openId != null && selectedId.equals(openId);

 

-                    // pas selectionne ou rien d'ouvert

-                    return false;

-                }

-

-                return selectedId.equals(openId);

             }

         }

 

-        // type non trouve

         return false;

     }

 

     public void populateSelectedIds(String... selectedId) {

-

+        if (!getEnabled()) {

+            throw new IllegalStateException(this + " is not enabled");

+        }

         List<String> oldSelection = Arrays.asList(getSelectedIds());

 

         if (log.isDebugEnabled()) {

             log.debug("old selection = " + oldSelection);

         }

 

-        // on nettoye toujours toutes les anciennes sélections

-        // avant de positionner les nouvelles

         resetSelect();

 

         List<String> realSelection = null;

             log.info("new selection = " + realSelection);

         }

 

-        // on change toujours l'état de selection

-

-        setSelectionChanged(true);

+        setSelectionChanged();

     }

 

     void populateOpens(String... openIds) {

         if (!getEnabled()) {

-

-            if (log.isWarnEnabled()) {

-                log.warn(this + " is not enabled");

-            }

-            // service non initialisé

-            resetOpen();

-            return;

+            throw new IllegalStateException(this + " is not enabled");

         }

 

         List<String> oldSelection = Arrays.asList(getOpenIds());

         }

     }

 

+    @Override

     protected void reset() {

         resetOpen();

         resetSelect();

         setOpenActivityLonglineId(null);

     }

 

-    protected void firePropertyChange(String propertyName, Object newValue) {

-        firePropertyChange(propertyName, null, newValue);

+    public boolean isSelectedRoute() {

+        return getSelectedRouteId() != null;

     }

 

-} //ClientDataContext
+    public boolean isSelectedSetSeine() {

+        return getSelectedSetSeineId() != null;

+    }

+

+    public boolean isSelectedSetLongline() {

+        return getSelectedSetLonglineId() != null;

+    }

+

+    public boolean isSelectedFloatingObject() {

+        return getSelectedFloatingObjectId()!=null;

+    }

+}
                     // la base n'a pas pu être chargée proprement

                     // ceci peut être due a une base dans une version pas

                     // assez recente, on doit donc refermer cette base

-                    handlingError("Could not obtain open datas from " + source.getLabel(), e);

+                    handlingError("Could not obtain open data from " + source.getLabel(), e);

 

                     // fermeture de la source

                     source.close();

                 ClientDataContext dataContext = applicationContext.getDataContext();

                 dataContext.setEnabled(false);

 

-                // suppresion des opens dans le context de données

                 applicationContext.getConfig().saveTreeOpenNodeIds(dataContext.getOpenIds());

-                dataContext.populateOpens();

-

+                applicationContext.getConfig().saveTreeSelectedNodeIds(dataContext.getSelectedIds());

+                applicationContext.getConfig().saveForUser();

+                dataContext.reset();

                 mainUI.getInitializer().cleanNavigationUI(new ProgressModel());

 

                 // on met a jour l'état dans la config

                     mainUI.getInitializer().cleanNavigationUI(progressModel);

 

                     String[] openIds = config.getTreeOpenNodeIds();

+                    String[] selectedIds = config.getTreeSelectedNodeIds();

 

+                    if (source.canReadData()) {

+                        applicationContext.getOpenDataManager().sanitizeIds(progressModel, selectedIds);

+                    }

                     if (source.canWriteData()) {

-                        applicationContext.getOpenDataManager().sanitizeOpenIds(progressModel, openIds);

+                        applicationContext.getOpenDataManager().sanitizeIds(progressModel, openIds);

                     }

 

                     if (source.canWriteData()) {

                     }

 

                     dataContext.populateOpens(openIds);

+                    dataContext.populateSelectedIds(selectedIds);

 

                     mainUI.getInitializer().loadNavigationUI(progressModel);

 

 

         try {

 

-            doOpencontent(ui, path, uiClass);

+            doOpenContent(ui, path, uiClass);

 

         } catch (Exception e) {

             UIHelper.handlingError(e);

         }

     }

 

-    private void doOpencontent(ObserveMainUI ui, TreePath path, Class<? extends ContentUI<?, ?>> uiClass) {

+    private void doOpenContent(ObserveMainUI ui, TreePath path, Class<? extends ContentUI<?, ?>> uiClass) {

 

         ContentUIManager manager = ui.getContentUIManager();

 

         UIActionSupport action = null;

         if (contentUI instanceof ContentListUI<?, ?, ?>) {

             ContentListUI<?, ?, ?> listUI = (ContentListUI<?, ?, ?>) contentUI;

-            action = (UIActionSupport) listUI.getGotoOpen().getAction();

+            action = (UIActionSupport) listUI.getReopen().getAction();

         } else if (contentUI instanceof ContentOpenableUI<?, ?> && !contentUI.getModel().isCreatingMode()) {

             ContentOpenableUI<?, ?> openableUI = (ContentOpenableUI<?, ?>) contentUI;

             action = (UIActionSupport) openableUI.getReopen().getAction();

         super(mainUI,

               ACTION_NAME,

               null,

-              (int) 'e',

+              (int) 'E',

               t("observe.type.reference.common"),

               t("observe.action.goto.referentiel.common.tip"),

               "navigation.referentiel");

         typeModel.clear();

 

         Set<Class> messageTypes = tabUI.getStepModel().getMessageTypes();

-        List<Class> classes = ObserveI18nDecoratorHelper.sortTypes(messageTypes);

+        List<Class> classes = ObserveI18nDecoratorHelper.sortTypes(messageTypes, ObserveSwingApplicationContext.get().getConfig().getLocale());

 

         for (Class e : classes) {

             typeModel.addElement(e);

  */

 

 import com.google.common.collect.ImmutableList;

+import fr.ird.observe.client.ObserveSwingApplicationContext;

 import fr.ird.observe.client.ui.content.ContentUIModel;

 import fr.ird.observe.services.decoration.ObserveI18nDecoratorHelper;

 import fr.ird.observe.services.dto.referential.ProgramDto;

 

     protected ReferenceHomeUIModel(List<Class<? extends ReferentialDto>> types, String nodeName) {

         super(ProgramDto.class);

-        this.types = ImmutableList.copyOf(ObserveI18nDecoratorHelper.sortPluralTypes(types));

+        this.types = ImmutableList.copyOf(ObserveI18nDecoratorHelper.sortPluralTypes(types, ObserveSwingApplicationContext.get().getConfig().getLocale()));

         this.nodeName = nodeName;

     }

 

 import fr.ird.observe.client.db.ObserveSwingDataSource;

 import fr.ird.observe.client.ui.ObserveKeyStrokes;

 import fr.ird.observe.client.ui.ObserveMainUI;

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

 import fr.ird.observe.client.ui.actions.SelectRadioButtonAction;

 import fr.ird.observe.client.ui.storage.tabs.ChooseDbModeUI;

 import fr.ird.observe.client.ui.storage.tabs.ConfigUI;

 import fr.ird.observe.client.ui.storage.tabs.StorageTabUI;

 import fr.ird.observe.client.ui.tree.selection.SelectionTreeModel;

 import fr.ird.observe.client.ui.util.ProgressModel;

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

 import fr.ird.observe.services.configuration.ObserveDataSourceConfiguration;

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

 import fr.ird.observe.services.configuration.rest.ObserveDataSourceConfigurationRest;

             stepsCount += 2;

         }

         String[] openIds = config.getTreeOpenNodeIds();

-        stepsCount += openIds.length;

+        if (openIds != null) {

+            stepsCount += 1 + openIds.length;

+        }

+        String[] selectedIds = config.getTreeSelectedNodeIds();

+        if (selectedIds != null) {

+            stepsCount += 1 + selectedIds.length;

+        }

         stepsCount += observeContext.getFloatingObjectReferencesManager().getNames().size();

 

         progressModel.installUI(ui.getCONFIRM().getProgressBar());

 

         } else {

 

-            // on trouve le meilleur noeud a selectionner.

-

-            String id = context.getHigherOpenId();

+            String id = context.getHigherSelectedId();

 

             NavigationTreeNodeSupport selectedNode = null;

             if (id != null) {

 

-                // on se positionne sur la donnée la plus haute ouverte

-                if (context.isOpenTrip()) {

+                if (context.isSelectedTrip()) {

 

-                    NavigationTreeNodeSupport tripNode = getTripNode(context.getOpenProgramId(), context.getOpenTripId());

-                    selectedNode = tripNode;

+                    selectedNode = getTripNode(context.getSelectedProgramId(), context.getSelectedTripId());

 

-                    if (context.isOpenRoute()) {

+                    if (context.isSelectedRoute()) {

 

-                        NavigationTreeNodeSupport routeNode = getRouteNode(tripNode, context.getOpenRouteId());

-                        selectedNode = routeNode;

-                        if (context.isOpenActivity()) {

+                        selectedNode = getRouteNode(selectedNode, context.getSelectedRouteId());

+                        if (context.isSelectedActivitySeine()) {

 

-                            NavigationTreeNodeSupport activitySeineNode = getActivitySeineNode(routeNode, context.getOpenActivityId());

-                            selectedNode = activitySeineNode;

-                            if (context.isOpenSet()) {

-                                selectedNode = getSetSeineNode(activitySeineNode);

+                            selectedNode = getActivitySeineNode(selectedNode, context.getSelectedActivityId());

+                            if (context.isSelectedSetSeine()) {

+                                selectedNode = getSetSeineNode(selectedNode);

 

+                            } else if (context.isSelectedFloatingObject()) {

+                                selectedNode = getFloatingObjectNode(selectedNode, context.getSelectedFloatingObjectId());

                             }

                         }

                     }

 

-                    if (context.isOpenActivityLongline()) {

+                    if (context.isSelectedActivityLongline()) {

 

-                        NavigationTreeNodeSupport activityLonglineNode = getActivityLonglineNode(tripNode, context.getOpenActivityId());

-                        selectedNode = activityLonglineNode;

-                        if (context.isOpenSet()) {

-                            selectedNode = getSetLonglineNode(activityLonglineNode);

+                        selectedNode = getActivityLonglineNode(selectedNode, context.getSelectedActivityId());

+                        if (context.isSelectedSetLongline()) {

+                            selectedNode = getSetLonglineNode(selectedNode);

 

                         }

                     }

                 }

 

             } else {

-                selectedNode = getTreeModel().getRoot();

-                if (!selectedNode.isLeaf()) {

-                    selectedNode = (NavigationTreeNodeSupport) selectedNode.getFirstChild();

-                }

 

+                id = context.getHigherOpenId();

+

+                if (id != null) {

+

+                    if (context.isOpenTrip()) {

+

+                        selectedNode = getTripNode(context.getOpenProgramId(), context.getOpenTripId());

+

+                        if (context.isOpenRoute()) {

+

+                            selectedNode = getRouteNode(selectedNode, context.getOpenRouteId());

+                            if (context.isOpenActivity()) {

+

+                                selectedNode = getActivitySeineNode(selectedNode, context.getOpenActivityId());

+                                if (context.isOpenSet()) {

+                                    selectedNode = getSetSeineNode(selectedNode);

+

+                                }

+                            }

+                        }

+

+                        if (context.isOpenActivityLongline()) {

+

+                            selectedNode = getActivityLonglineNode(selectedNode, context.getOpenActivityId());

+

+                            if (context.isOpenSet()) {

+                                selectedNode = getSetLonglineNode(selectedNode);

+

+                            }

+                        }

+                    }

+

+                } else {

+

+                    selectedNode = getTreeModel().getRoot();

+                    if (!selectedNode.isLeaf()) {

+                        selectedNode = (NavigationTreeNodeSupport) selectedNode.getFirstChild();

+                    }

+

+                }

             }

 

 

         return getTreeModel().findNodeByType(activitySeineNode, SetSeineNavigationTreeNode.class);

     }

 

+    public NavigationTreeNodeSupport getFloatingObjectNode(NavigationTreeNodeSupport setSeineNode, String floatingObjectId) {

+        return getTreeModel().findNode(setSeineNode, floatingObjectId);

+    }

+

     public NavigationTreeNodeSupport getSetLonglineNode(NavigationTreeNodeSupport activityLonglineNode) {

         return getTreeModel().findNodeByType(activityLonglineNode, SetLonglineNavigationTreeNode.class);

     }

  */

 

 import com.google.common.collect.ImmutableSet;

+import fr.ird.observe.client.ObserveSwingApplicationContext;

 import fr.ird.observe.client.ui.tree.navigation.nodes.StringNavigationTreeNodeSupport;

 import fr.ird.observe.services.decoration.ObserveI18nDecoratorHelper;

 import fr.ird.observe.services.dto.referential.ReferentialDto;

  */

 public abstract class ReferentialsNavigationTreeNodeSupport extends StringNavigationTreeNodeSupport {

 

-    public ReferentialsNavigationTreeNodeSupport(String name, ImmutableSet<Class<? extends ReferentialDto>> types) {

+    ReferentialsNavigationTreeNodeSupport(String name, ImmutableSet<Class<? extends ReferentialDto>> types) {

         super(name, true);

-        for (Class<? extends ReferentialDto> aClass : ObserveI18nDecoratorHelper.sortPluralTypes(types)) {

+        for (Class<? extends ReferentialDto> aClass : ObserveI18nDecoratorHelper.sortPluralTypes(types, ObserveSwingApplicationContext.get().getConfig().getLocale())) {

             ReferentialNavigationTreeNode child = new ReferentialNavigationTreeNode<>(aClass);

             add(child);

         }

  * #L%

  */

 

+import java.text.Collator;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Comparator;

 import java.util.HashMap;

 import java.util.List;

+import java.util.Locale;

 import java.util.Map;

 import java.util.Properties;

 import java.util.function.Function;

         return targetProperties;

     }

 

-    public static <C extends Class<?>> List<C> sortTypes(Collection<C> types, Function<Class, String> function) {

+    public static <C extends Class<?>> List<C> sortTypes(Collection<C> types, Function<Class, String> function, Locale locale) {

 

         List<C> list = new ArrayList<>(types);

-        new ClassComparator<C>(function).sort(list);

+        new ClassComparator<C>(function, locale).sort(list);

         return list;

 

     }

         private final Map<Class, String> cache;

         private final Function<Class, String> function;

 

-        private ClassComparator(Function<Class, String> function) {

+        private final Collator collator;

+

+        private ClassComparator(Function<Class, String> function, Locale locale) {

             this.cache = new HashMap<>();

             this.function = function;

+            this.collator = Collator.getInstance(locale);

+            this.collator.setStrength(Collator.PRIMARY);

         }

 

         @Override

         public int compare(Class o1, Class o2) {

             String s1 = getValue(o1);

             String s2 = getValue(o2);

-            return s1.compareTo(s2);

+            return this.collator.compare(s1, s2);

         }

 

         String getValue(Class klass) {

             cache.clear();

         }

     }

+

 }
 POST   /api/v1/actions/validate/ValidateService/validateData                                                                         v1.actions.validate.ValidateServiceRestApi.validateData

 POST   /api/v1/actions/validate/ValidateService/validateReferential                                                                  v1.actions.validate.ValidateServiceRestApi.validateReferential

 GET    /api/v1/data/NavigationService/getNavigation                                                                                  v1.data.NavigationServiceRestApi.getNavigation

+GET    /api/v1/data/NavigationService/retainExistingIds                                                                              v1.data.NavigationServiceRestApi.retainExistingIds

 POST   /api/v1/data/TripManagementService/deleteTrip                                                                                 v1.data.TripManagementServiceRestApi.deleteTrip

 POST   /api/v1/data/TripManagementService/exportTrip                                                                                 v1.data.TripManagementServiceRestApi.exportTrip

 POST   /api/v1/data/TripManagementService/importTrip                                                                                 v1.data.TripManagementServiceRestApi.importTrip

 GET    /api/v1/data/seine/FloatingObjectService/loadForm                                                                             v1.data.seine.FloatingObjectServiceRestApi.loadForm

 GET    /api/v1/data/seine/FloatingObjectService/loadReferenceToRead                                                                  v1.data.seine.FloatingObjectServiceRestApi.loadReferenceToRead

 GET    /api/v1/data/seine/FloatingObjectService/preCreate                                                                            v1.data.seine.FloatingObjectServiceRestApi.preCreate

-GET    /api/v1/data/seine/FloatingObjectService/retainExistingIds                                                                    v1.data.seine.FloatingObjectServiceRestApi.retainExistingIds

 POST   /api/v1/data/seine/FloatingObjectService/save                                                                                 v1.data.seine.FloatingObjectServiceRestApi.save

 POST   /api/v1/data/seine/FloatingObjectService/saveParts                                                                            v1.data.seine.FloatingObjectServiceRestApi.saveParts

 GET    /api/v1/data/seine/NonTargetCatchReleaseService/getSampleSpecies                                                              v1.data.seine.NonTargetCatchReleaseServiceRestApi.getSampleSpecies

 import com.google.common.collect.ImmutableMap;

 import com.google.common.collect.ImmutableSet;

 import com.google.common.collect.Maps;

+import fr.ird.observe.persistence.ObserveTopiaPersistenceContext;

+import fr.ird.observe.services.dto.IdHelper;

 import fr.ird.observe.services.dto.longline.TripLonglineDto;

 import fr.ird.observe.services.dto.longline.TripLonglineHelper;

 import fr.ird.observe.services.dto.reference.DataReference;

 

         return new NavigationResult(programsBuilder.build(), tripsSeineByProgram, tripsLonglineByProgram);

     }

+

+    @Override

+    public ImmutableSet<String> retainExistingIds(ImmutableSet<String> ids) {

+        ImmutableSet.Builder<String> result = ImmutableSet.builder();

+

+        ObserveTopiaPersistenceContext topiaPersistenceContext = serviceContext.getTopiaPersistenceContext();

+        for (String id : ids) {

+            boolean exists;

+            if (IdHelper.isProgramId(id)) {

+

+                exists = topiaPersistenceContext.getProgramDao().forTopiaIdEquals(id).exists();

+

+            } else if (IdHelper.isTripSeineId(id)) {

+

+                exists = topiaPersistenceContext.getTripSeineDao().forTopiaIdEquals(id).exists();

+

+            } else if (IdHelper.isRouteId(id)) {

+

+                exists = topiaPersistenceContext.getRouteDao().forTopiaIdEquals(id).exists();

+

+            } else if (IdHelper.isActivitySeineId(id)) {

+

+                exists = topiaPersistenceContext.getActivitySeineDao().forTopiaIdEquals(id).exists();

+

+            } else if (IdHelper.isSetSeineId(id)) {

+

+                exists = topiaPersistenceContext.getSetSeineDao().forTopiaIdEquals(id).exists();

+

+            } else if (IdHelper.isFloatingObjectId(id)) {

+

+                exists = topiaPersistenceContext.getFloatingObjectDao().forTopiaIdEquals(id).exists();

+

+            } else if (IdHelper.isTripLonglineId(id)) {

+

+                exists = topiaPersistenceContext.getTripLonglineDao().forTopiaIdEquals(id).exists();

+

+            } else if (IdHelper.isActivityLonglineId(id)) {

+

+                exists = topiaPersistenceContext.getActivityLonglineDao().forTopiaIdEquals(id).exists();

+

+            } else {

+                exists = IdHelper.isSetLonglineId(id) && topiaPersistenceContext.getSetLonglineDao().forTopiaIdEquals(id).exists();

+            }

+            if (exists) {

+                result.add(id);

+            }

+            if (!exists) {

+                break;

+            }

+        }

+        return result.build();

+    }

 }
     }

 

     @Override

-    public ImmutableSet<String> retainExistingIds(ImmutableSet<String> existingIds) {

-        LinkedHashSet<String> result = new LinkedHashSet<>(getTopiaPersistenceContext().getFloatingObjectDao().findAllIds());

-        result.retainAll(existingIds);

-        return ImmutableSet.copyOf(result);

-    }

-

-    @Override

     public DataReference<FloatingObjectDto> loadReferenceToRead(String floatingObjectId) {

         if (log.isTraceEnabled()) {

             log.trace("loadReferenceToRead(" + floatingObjectId + ")");

 import java.beans.Introspector;

 import java.util.Collection;

 import java.util.List;

+import java.util.Locale;

 import java.util.function.Function;

 import org.apache.commons.lang3.StringUtils;

 import org.atteo.evo.inflector.English;

     private static final String OBSERVE_COMMON_PREFIX = "observe.common.";

     private static final String OBSERVE_TYPE_PREFIX = "observe.type.";

 

-    public static <C extends Class<?>> List<C> sortTypes(Collection<C> types) {

-        return ObserveUtil.sortTypes(types, klass -> t(ObserveI18nDecoratorHelper.getTypeI18nKey(klass)));

+    public static <C extends Class<?>> List<C> sortTypes(Collection<C> types, Locale locale) {

+        return ObserveUtil.sortTypes(types, klass -> t(ObserveI18nDecoratorHelper.getTypeI18nKey(klass)), locale);

     }

 

-    public static <C extends Class<?>> List<C> sortPluralTypes(Collection<C> types) {

-        return ObserveUtil.sortTypes(types, klass -> t(ObserveI18nDecoratorHelper.getTypePluralI18nKey(klass)));

+    public static <C extends Class<?>> List<C> sortPluralTypes(Collection<C> types, Locale locale) {

+        return ObserveUtil.sortTypes(types, klass -> t(ObserveI18nDecoratorHelper.getTypePluralI18nKey(klass)), locale);

     }

 

     public static String getPropertyName(Class key) {

  * #L%

  */

 

+import com.google.common.collect.ImmutableSet;

 import fr.ird.observe.services.service.ObserveService;

+import fr.ird.observe.services.spi.ReadDataPermission;

 import io.ultreia.java4all.http.spi.Get;

 

 /**

     @Get

     NavigationResult getNavigation(NavigationRequest request);

 

+    @Get

+    @ReadDataPermission

+    ImmutableSet<String> retainExistingIds(ImmutableSet<String> ids);

 }
 

     @Get

     @ReadDataPermission

-    ImmutableSet<String> retainExistingIds(ImmutableSet<String> existingIds);

-

-    @Get

-    @ReadDataPermission

     Form<FloatingObjectDto> loadForm(String floatingObjectId);

 

     @Get

         return selectedTripId != null && IdHelper.isSeineId(selectedTripId);

     }

 

+    public boolean isSelectedTrip() {

+        return isSelectedTripLongline() || isSelectedTripSeine();

+    }

+

     public String getSelectedRouteId() {

         return selectedRouteId;

     }

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

Commits:

25 changed files:

Changes: