GitLab

at 2017-08-04T10:58:20+02:00

Use a ClassMapping

clean entities

Le mode d'acquisition sur les espèces sensibles est Par individu par défaut (See #825)
Ecran faune sensible rejetée, gestion de la date du rejet (See #818)
Amélioration de l'ap des ContentHandler

 

     <field-validator type="fieldexpression" short-circuit="true">

       <param name="expression">

-        <![CDATA[ currentSetSeine.endPursingTime.time < detectionTime.time ]]>

+        <![CDATA[ currentSetSeine.endPursingTimeStamp.time < detectionTime.time ]]>

       </param>

       <message>observe.validation.nonTargetCatchRelease.detectionTime.after.endPursingTimeStamp</message>

     </field-validator>

 import java.awt.FocusTraversalPolicy;

 import java.awt.event.FocusEvent;

 import java.awt.event.FocusListener;

-import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.LinkedList;

             data = Collections.emptyList();

         } else {

 

-            Set<DataReference<R>> referenceSetDto = getModel().getDataReferences(list.getModel().getProperty());

-            data = new ArrayList<>(referenceSetDto);

+            data = getModel().getDataReferences(list.getModel().getProperty());

 

         }

 

             data = Collections.emptyList();

         } else {

 

-            Set<ReferentialReference<R>> referenceSetDto = getModel().getReferentialReferences(list.getModel().getProperty());

-            data = new ArrayList<>(referenceSetDto);

+            data = getModel().getReferentialReferences(list.getModel().getProperty());

 

         }

 

 

         } else {

 

-            Set<ReferentialReference<R>> referenceSetDto = getModel().getReferentialReferences(propertyName);

-            data = new ArrayList<>(referenceSetDto);

+            data = getModel().getReferentialReferences(propertyName);

 

         }

 

 

         } else {

 

-            Set<DataReference<R>> referenceSetDto = getModel().getDataReferences(propertyName);

-            data = new ArrayList<>(referenceSetDto);

+            data = getModel().getDataReferences(propertyName);

 

         }

 

     protected void openedUI() {

 

     }

+

     protected ObserveServicesProvider getServicesProvider() {

         return ObserveSwingDataSource.MAIN;

     }

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

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

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

+import java.util.LinkedList;

+import java.util.List;

 import java.util.Objects;

 import java.util.Optional;

 import java.util.Set;

  */

 public abstract class ContentUIModel<E extends IdDto> extends AbstractSerializableBean {

 

-    public static final String PROPERTY_EDIT_BEAN = "editBean";

-

     public static final String PROPERTY_MODE = "mode";

-

-    public static final String PROPERTY_READING_MODE = "readingMode";

-

-    public static final String PROPERTY_CREATING_MODE = "creatingMode";

-

-    public static final String PROPERTY_UPDATING_MODE = "updatingMode";

-

-    public static final String PROPERTY_ENABLED = "enabled";

-

     public static final String PROPERTY_MODIFIED = "modified";

-

     public static final String PROPERTY_EDITING = "editing";

-

     public static final String PROPERTY_EDITABLE = "editable";

-

-    public static final String PROPERTY_VALID = "valid";

-

-    public static final String PROPERTY_CAN_WRITE = "canWrite";

-

     public static final String PROPERTY_FORM = "form";

 

+    private static final String PROPERTY_EDIT_BEAN = "editBean";

+    private static final String PROPERTY_READING_MODE = "readingMode";

+    private static final String PROPERTY_CREATING_MODE = "creatingMode";

+    private static final String PROPERTY_UPDATING_MODE = "updatingMode";

+    private static final String PROPERTY_ENABLED = "enabled";

+    private static final String PROPERTY_VALID = "valid";

+    private static final String PROPERTY_CAN_WRITE = "canWrite";

+

     /** Logger */

-    static private final Log log = LogFactory.getLog(ContentUIModel.class);

+    private static final Log log = LogFactory.getLog(ContentUIModel.class);

 

     private static final long serialVersionUID = 1L;

 

-    protected final Class<E> beanType;

+    private final Class<E> beanType;

 

     protected Form<E> form;

 

 

     protected boolean editable;

 

-    protected boolean canWrite;

+    private boolean canWrite;

 

     /**

      * Les référentiels qu'on peut utiliser, ils sont chargés depuis le cache des référentiels et peuvent être filtrés.

      */

     protected ImmutableMap<String, DataReferenceSet<?>> dataReferenceSetsByPropertyName = ImmutableMap.of();

 

-    public static <E extends IdDto, U extends ContentUI<E, U>> ContentUIModel<E> newModel(U ui) {

-

-        String uiName = ui.getClass().getName();

-        String modelName = uiName + "Model";

+    static <E extends IdDto, U extends ContentUI<E, U>> ContentUIModel<E> newModel(U ui) {

 

         try {

 

-            Class<ContentUIModel<E>> modelClass = (Class) Class.forName(modelName);

+            Class<ContentUIModel<E>> modelClass = (Class) UiToModelClassMapping.get().getClass(ui.getClass());

             return modelClass.newInstance();

 

         } catch (Exception e) {

         firePropertyChange(PROPERTY_MODIFIED, oldValue, modified);

     }

 

-    public boolean isCanWrite() {

+    boolean isCanWrite() {

         return canWrite;

     }

 

         firePropertyChange(PROPERTY_CAN_WRITE, oldValue, canWrite);

     }

 

-    public <D extends ReferentialDto> Set<ReferentialReference<D>> getReferentialReferences(String name) {

+    public <D extends ReferentialDto> List<ReferentialReference<D>> getReferentialReferences(String name) {

 

         ReferentialReferenceSet<D> referentialReferenceSet = getReferentialReferenceSet(name);

-        return referentialReferenceSet.getReferences();

+        return new LinkedList<>(referentialReferenceSet.getReferences());

 

     }

 

-    public <D extends DataDto> Set<DataReference<D>> getDataReferences(String name) {

+    <D extends DataDto> List<DataReference<D>> getDataReferences(String name) {

 

         DataReferenceSet<D> referentialReferenceSet = getDataReferenceSet(name);

-        return referentialReferenceSet.getReferences();

+        return new LinkedList<>(referentialReferenceSet.getReferences());

 

     }

 

         this.referentialReferenceSetsByPropertyName = referentialReferenceSetsByPropertyName;

     }

 

-    public void setDataReferenceSetsByPropertyName(ImmutableMap<String, DataReferenceSet<?>> dataReferenceSetsByPropertyName) {

-        this.dataReferenceSetsByPropertyName = dataReferenceSetsByPropertyName;

-    }

-

     public ImmutableMap<String, ReferentialReferenceSet<?>> getReferentialReferenceSets() {

         return referentialReferenceSetsByPropertyName;

     }

 

-    public ImmutableMap<String, DataReferenceSet<?>> getDataReferenceSets() {

-        return dataReferenceSetsByPropertyName;

-    }

-

-    protected <R extends DataDto> Optional<Set<DataReference<R>>> tryToGetDataReferenceSet(String propertyName) {

+    <R extends DataDto> Optional<Set<DataReference<R>>> tryToGetDataReferenceSet(String propertyName) {

         DataReferenceSet<R> referenceSet = getDataReferenceSet(propertyName);

         Set<DataReference<R>> references = null;

         if (referenceSet != null) {

     }

 

     private <R extends ReferentialDto> ReferentialReferenceSet<R> getReferentialReferenceSet(String propertyName) {

-        ReferentialReferenceSet<?> referenceSet = this.referentialReferenceSetsByPropertyName.get(propertyName);

-        Objects.requireNonNull(referenceSet, "Could not find referantialRefenceSet named " + propertyName);

+        ReferentialReferenceSet<?> referenceSet = referentialReferenceSetsByPropertyName.get(propertyName);

+        Objects.requireNonNull(referenceSet, "Could not find referentialRefenceSet named " + propertyName);

         return (ReferentialReferenceSet<R>) referenceSet;

     }

 

-    public <R extends DataDto> DataReferenceSet<R> getDataReferenceSet(String propertyName) {

+    private <R extends DataDto> DataReferenceSet<R> getDataReferenceSet(String propertyName) {

         DataReferenceSet<?> referenceSet = dataReferenceSetsByPropertyName.get(propertyName);

         Objects.requireNonNull(referenceSet, "Could not find dataReferenceSet named " + propertyName);

         return (DataReferenceSet<R>) referenceSet;

-package fr.ird.observe.entities.seine;

+package fr.ird.observe.client.ui.content;

 

 /*-

  * #%L

- * ObServe :: Persistence

+ * ObServe :: Client

  * %%

  * Copyright (C) 2008 - 2017 IRD, Code Lutin, Ultreia.io

  * %%

  * #L%

  */

 

-import java.util.Date;

-import org.nuiton.util.DateUtil;

-

-public class NonTargetCatchReleaseImpl extends NonTargetCatchReleaseAbstract {

+import io.ultreia.java4all.http.ClassMapping;

 

+/**

+ * Created by tchemit on 04/08/17.

+ *

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

+ * @since 7.0

+ */

+public class UiToModelClassMapping extends ClassMapping<ContentUI, ContentUIModel> {

 

-    private static final long serialVersionUID = 1L;

+    private static UiToModelClassMapping INSTANCE = new UiToModelClassMapping();

 

-    @Override

-    public void setDetectionTime(Date detectionTime) {

-        super.setDetectionTime(detectionTime == null ? null : DateUtil.getTime(detectionTime, false, false));

+    public static UiToModelClassMapping get() {

+        return INSTANCE;

     }

 

-    @Override

-    public void setReleaseTime(Date releaseTime) {

-        super.setReleaseTime(releaseTime == null ? null : DateUtil.getTime(releaseTime, false, false));

+    private UiToModelClassMapping() {

+        super(ContentUI.class.getPackage(), ContentUIModel.class.getPackage(), "Model");

     }

+

 }
 public abstract class ContentTableModel<P extends IdDto, B extends IdDto> extends AbstractTableModel {

 

     /** Le nom de la propriété de la ligne en cours d'édition */

-    public static final String SELECTED_ROW_PROPERTY = "selectedRow";

+    static final String SELECTED_ROW_PROPERTY = "selectedRow";

 

     /** Le nom de la propriété modifié du modèle */

-    public static final String MODIFIED_PROPERTY = "modified";

+    private static final String MODIFIED_PROPERTY = "modified";

 

     /** Le nom de la propriété pour editer le modele */

-    public static final String EDITABLE_PROPERTY = "editable";

+    private static final String EDITABLE_PROPERTY = "editable";

 

     /**

      * Le nom de la propriété pour indiquer que l'entrée en cours d'édition est

     public static final String CREATE_PROPERTY = "create";

 

     /** Le nom de la propriété pour savoir si le modèle est vide */

-    public static final String EMPTY_PROPERTY = "empty";

+    private static final String EMPTY_PROPERTY = "empty";

 

     private static final long serialVersionUID = 1L;

 

     protected final List<ContentTableMeta<B>> metas;

 

     /** pour la propagation des modifications d'états */

-    protected final PropertyChangeSupport pcs = new PropertyChangeSupport(this);

+    private final PropertyChangeSupport pcs = new PropertyChangeSupport(this);

 

     /** la liste des données du modèle */

     protected List<B> data = new ArrayList<>();

      * un drapeau pour modifier la selection de la ligne en cours sans aucune

      * verification.

      */

-    protected boolean valueAdjusting;

+    private boolean valueAdjusting;

 

     /** l'entrée sélectionnée (-1 quand pas de sélection) */

     protected int selectedRow = -1;

             String property,

             boolean unmodiableWhenExisting) {

 

-        return new ContentTableMeta<>(childType,

-                                      property, unmodiableWhenExisting);

+        return new ContentTableMeta<>(childType, property, unmodiableWhenExisting);

     }

 

     /**

      * <p>

      * Cela va initialiser la liste à utiliser.

      */

-    public void attachModel() {

+    void attachModel() {

         // pas de ligne selectionne

         setSelectedRow(-1);

 

         fireTableDataChanged();

     }

 

-    public void dettachModel() {

+    void dettachModel() {

         setModified(false);

         int size = getRowCount();

         // on indique que le modele n'est plus lie au bean

         }

     }

 

-    public boolean isCanQuitEditingRow() {

+    boolean isCanQuitEditingRow() {

         if (selectedRow == -1) {

             // aucune ligne selectionne

             // on peut changer la ligne sans verification

      *

      * @param row l'index de la nouvelle ligne a editer

      */

-    public void changeSelectedRow(int row) {

+    void changeSelectedRow(int row) {

 

         if (log.isDebugEnabled()) {

             log.debug("row      : " + row);

         firePropertyChange(EDITABLE_PROPERTY, oldModified, editable);

     }

 

-    public boolean isValueAdjusting() {

+    boolean isValueAdjusting() {

         return valueAdjusting;

     }

 

         return metas.get(columnIndex).getType();

     }

 

-    public ContentTableMeta<B> getColumnMeta(int columnIndex) {

+    private ContentTableMeta<B> getColumnMeta(int columnIndex) {

         ensureColumnIndex(columnIndex);

         return metas.get(columnIndex);

     }

         return list == null ? null : list.get(row);

     }

 

-    public void updateEmpty() {

+    private void updateEmpty() {

         firePropertyChange(EMPTY_PROPERTY, null, isEmpty());

     }

 

     }

 

     @SuppressWarnings("unchecked")

-    protected SwingValidator<P> getParentValidator() {

+    private SwingValidator<P> getParentValidator() {

         return context == null ? null : context.getValidator();

     }

 

         return meta.setValue(this, bean, aValue, row);

     }

 

-    protected void ensureColumnIndex(int columnIndex) throws ArrayIndexOutOfBoundsException {

+    private void ensureColumnIndex(int columnIndex) throws ArrayIndexOutOfBoundsException {

         if (columnIndex < 0 || columnIndex >= metas.size()) {

             throw new ArrayIndexOutOfBoundsException("column index should be in [0," + metas.size() + "], but was " + columnIndex);

         }

     }

 

-    protected void ensureRowIndex(int rowIndex) throws ArrayIndexOutOfBoundsException {

+    private void ensureRowIndex(int rowIndex) throws ArrayIndexOutOfBoundsException {

         int size = getRowCount();

         if (rowIndex < 0 || rowIndex >= size) {

             throw new ArrayIndexOutOfBoundsException("row index should be in [0," + (getRowCount() - 1) + "], but was " + rowIndex);

         }

     }

 

-    protected void ensureEditable() throws IllegalStateException {

+    private void ensureEditable() throws IllegalStateException {

         if (!editable) {

             throw new IllegalStateException("can not edit this model since it is marked as none editable " + this);

         }

         clearCache();

     }

 

-    protected void clearCache() {

+    private void clearCache() {

         data = null;

     }

 

-    protected void updateBeanList(boolean shouldChanged) {

+    private void updateBeanList(boolean shouldChanged) {

         SwingValidator<P> parentValidator = getParentValidator();

         boolean wasChanged = parentValidator.isChanged();

 

 

     protected abstract void setChilds(P parent, List<B> childs);

 

-    protected boolean isModelModified() {

+    private boolean isModelModified() {

         return getValidator().isChanged();

     }

 

-    protected boolean isModelValid() {

+    private boolean isModelValid() {

         return getValidator().isValid();

     }

 }
         return tableEditBean;

     }

 

-    public final D newTableEditBean() {

+    public D newTableEditBean() {

         try {

 

             return getChildType().getConstructor().newInstance();

 import fr.ird.observe.services.dto.seine.SetSeineNonTargetCatchReleaseDto;

 import java.util.Collection;

 import java.util.List;

-import org.apache.commons.logging.Log;

-import org.apache.commons.logging.LogFactory;

 

 /**

  * Created on 12/4/14.

  *

  * @author Tony Chemit - dev@tchemit.fr

- * @since 3.8

+ * @since 7.0

  */

 public class NonTargetCatchReleaseTableModel extends ContentTableModel<SetSeineNonTargetCatchReleaseDto, NonTargetCatchReleaseDto> {

 

-    /** Logger. */

-    private static final Log log = LogFactory.getLog(NonTargetCatchReleaseTableModel.class);

-

     private static final long serialVersionUID = 1L;

     private boolean adjusting;

 

-    public NonTargetCatchReleaseTableModel(ObserveContentTableUI<SetSeineNonTargetCatchReleaseDto, NonTargetCatchReleaseDto, ?> context,

-                                           List<ContentTableMeta<NonTargetCatchReleaseDto>> contentTableMetas) {

+    NonTargetCatchReleaseTableModel(ObserveContentTableUI<SetSeineNonTargetCatchReleaseDto, NonTargetCatchReleaseDto, ?> context,

+                                    List<ContentTableMeta<NonTargetCatchReleaseDto>> contentTableMetas) {

         super(context, contentTableMetas);

     }

 

         return bean.getNonTargetCatchRelease();

     }

 

-    public void moveUp(int selectedRow) {

+    void moveUp(int selectedRow) {

         NonTargetCatchReleaseDto remove = data.remove(selectedRow);

         data.add(selectedRow - 1, remove);

         fireTableRowsUpdated(selectedRow - 1, selectedRow);

         getModel().setModified(true);

     }

 

-    public void moveDown(int selectedRow) {

+    void moveDown(int selectedRow) {

         NonTargetCatchReleaseDto remove = data.remove(selectedRow);

         data.add(selectedRow + 1, remove);

         fireTableRowsUpdated(selectedRow, selectedRow + 1);

         getModel().setModified(true);

     }

 

-    public boolean isAdjusting() {

+    boolean isAdjusting() {

         return adjusting;

     }

 }
     fr.ird.observe.client.validation.ObserveSwingValidator

     fr.ird.observe.client.ui.content.table.impl.seine.ModeSaisieEchantillonEnum

 

-    org.nuiton.jaxx.widgets.datetime.TimeEditor

+    org.nuiton.jaxx.widgets.datetime.DateTimeEditor

     org.nuiton.jaxx.widgets.number.NumberEditor

     org.nuiton.jaxx.widgets.select.BeanComboBox

 

       </cell>

     </row>

 

-    <!-- detection time / release time -->

+    <!-- detection time -->

     <row>

       <cell columns="2" weightx="1">

-        <JPanel layout='{new GridLayout(1,0)}'>

-          <TimeEditor id='detectionTime' constructorParams='this'/>

-          <TimeEditor id='releaseTime' constructorParams='this'/>

-        </JPanel>

+        <DateTimeEditor id='detectionTime' constructorParams='this'/>

+      </cell>

+    </row>

+    <!-- release time -->

+    <row>

+      <cell columns="2" weightx="1">

+        <DateTimeEditor id='releaseTime' constructorParams='this'/>

       </cell>

     </row>

 

 }

 

 #detectionTime {

-  propertyTime:{NonTargetCatchReleaseDto.PROPERTY_DETECTION_TIME};

+  propertyDate:{NonTargetCatchReleaseDto.PROPERTY_DETECTION_TIME};

   bean:{tableEditBean};

   label:{t("observe.common.detectionTime")};

-  time:{tableEditBean.getDetectionTime()};

+  date:{tableEditBean.getDetectionTime()};

+  dateEditable:false;

   _validatorLabel:{t("observe.common.detectionTime")};

   showTimeEditorSlider: false;

 }

 

 #releaseTime {

-  propertyTime:{NonTargetCatchReleaseDto.PROPERTY_RELEASE_TIME};

+  propertyDate:{NonTargetCatchReleaseDto.PROPERTY_RELEASE_TIME};

   bean:{tableEditBean};

   label:{t("observe.common.releaseTime")};

-  time:{tableEditBean.getReleaseTime()};

-  _validatorLabel:{t("observe.common.releaseTime")};

+  date:{tableEditBean.getReleaseTime()};

   showTimeEditorSlider: false;

 }
  */

 package fr.ird.observe.client.ui.content.table.impl.seine;

 

-import com.google.common.collect.Lists;

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

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

 import fr.ird.observe.client.ui.content.table.ContentTableUIHandler;

 import java.util.List;

 import java.util.Map;

 import java.util.Objects;

-import java.util.Set;

 import java.util.TreeMap;

 import javax.swing.JComponent;

 import javax.swing.JPopupMenu;

         NonTargetCatchReleaseTableModel model = getTableModel();

 

         if (!model.isEditable()) {

-

-            // rien a faire

             return;

         }

 

         JComponent requestFocus;

 

         if (create) {

-            Set<ReferentialReference<SpeciesDto>> speciesSet = getModel().getReferentialReferences(NonTargetCatchReleaseDto.PROPERTY_SPECIES);

-            availableEspeces = Lists.newArrayList(speciesSet);

+

+            availableEspeces = getModel().getReferentialReferences(NonTargetCatchReleaseDto.PROPERTY_SPECIES);

 

             requestFocus = ui.getSpecies();

 

             if (model.isCreate()) {

 

-                // on passe le mode de saisie en count

-                ui.getAcquisitionModeGroup().setSelectedValue(null);

-                ui.getAcquisitionModeGroup().setSelectedValue(ModeSaisieEchantillonEnum.byEffectif);

-

                 ui.getStatus().init(null);

             }

 

         } else {

+

             ReferentialReference<SpeciesDto> species = bean.getSpecies();

             availableEspeces = new ArrayList<>();

             availableEspeces.add(species);

             requestFocus = ui.getSex();

 

-            int acquisitionMode = bean.getAcquisitionMode();

-            ModeSaisieEchantillonEnum enumValue = ModeSaisieEchantillonEnum.valueOf(acquisitionMode);

-            ui.getAcquisitionModeGroup().setSelectedValue(null);

-            ui.getAcquisitionModeGroup().setSelectedValue(enumValue);

         }

 

+        int acquisitionMode = bean.getAcquisitionMode();

+        ModeSaisieEchantillonEnum enumValue = ModeSaisieEchantillonEnum.valueOf(acquisitionMode);

+        ui.getAcquisitionModeGroup().setSelectedValue(null);

+        ui.getAcquisitionModeGroup().setSelectedValue(enumValue);

+

         ui.getSpecies().setData(availableEspeces);

 

-        Date releaseTime;

-        Date detectionTime;

-        NonTargetCatchReleaseStatus status;

-        if (create) {

+        Date releaseTime = bean.getReleaseTime();

+        Date detectionTime = bean.getDetectionTime();

+        NonTargetCatchReleaseStatus status = bean.getStatus();

 

-            releaseTime = getModel().getForm().getObject().getEndPursingTimeStamp();

-            detectionTime = getModel().getForm().getObject().getEndPursingTimeStamp();

-            status = null;

-        } else {

-            releaseTime = bean.getReleaseTime();

-            detectionTime = bean.getDetectionTime();

-            status = bean.getStatus();

-        }

         updateSpecies(bean.getSpecies());

 

         getModel().setDetectionTime(detectionTime);

         initModel(ui, metas);

     }

 

+

+    @Override

+    public NonTargetCatchReleaseDto newTableEditBean() {

+        NonTargetCatchReleaseDto result = super.newTableEditBean();

+        Date endPursingTimeStamp = getBean().getEndPursingTimeStamp();

+        result.setDetectionTime(endPursingTimeStamp);

+        result.setReleaseTime(endPursingTimeStamp);

+        result.setAcquisitionMode(ModeSaisieEchantillonEnum.byIndividu.ordinal());

+        return result;

+    }

+

     @Override

     protected NonTargetCatchReleaseTableModel createTableModel(

             ObserveContentTableUI<SetSeineNonTargetCatchReleaseDto, NonTargetCatchReleaseDto, ?> ui,

 package fr.ird.observe.client.ui.content.table.impl.seine;

 

 import com.google.common.collect.Iterables;

-import com.google.common.collect.Lists;

 import com.google.common.collect.Sets;

 import fr.ird.observe.client.ObserveSwingApplicationContext;

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

         JComponent requestFocus;

 

         if (create) {

-            Set<ReferentialReference<SpeciesDto>> speciesSet = getModel().getReferentialReferences(NonTargetCatchDto.PROPERTY_SPECIES);

-            availableEspeces = Lists.newArrayList(speciesSet);

+            availableEspeces = getModel().getReferentialReferences(NonTargetCatchDto.PROPERTY_SPECIES);

 

             requestFocus = ui.getSpecies();

         } else {

 import java.util.LinkedList;

 import java.util.List;

 import java.util.Optional;

-import java.util.Set;

 import javax.swing.JComponent;

 import javax.swing.JTable;

 import javax.swing.table.DefaultTableCellRenderer;

                 ui.getAcquisitionModeGroup().setSelectedValue(ModeSaisieEchantillonEnum.byEffectif);

             }

 

-            Set<ReferentialReference<SpeciesDto>> speciesReferences = getModel().getReferentialReferences(NonTargetLengthDto.PROPERTY_SPECIES);

-            availableEspeces = Lists.newArrayList(speciesReferences);

+            availableEspeces = getModel().getReferentialReferences(NonTargetLengthDto.PROPERTY_SPECIES);

 

             // on utilise le code par defaut de l'espèce

             sizeMeasureType = getSpeciesDefaultSizeMeasureType(species);

         JComponent requestFocus;

 

         if (create) {

-            Set<ReferentialReference<SpeciesDto>> references = getModel().getReferentialReferences(SchoolEstimateDto.PROPERTY_SPECIES);

+            List<ReferentialReference<SpeciesDto>> references = getModel().getReferentialReferences(SchoolEstimateDto.PROPERTY_SPECIES);

 

             List<ReferentialReference<SpeciesDto>> listSpeciesUsed = model.getColumnValues(0);

 

 

             // un espèce est selectionnee, on calcule les categories pour cette espèce

             // on ne conserve que les categories de l'espèce

-            Set<ReferentialReference<WeightCategoryDto>> allCategories = getModel().getReferentialReferences(TargetCatchDto.PROPERTY_WEIGHT_CATEGORY);

+            List<ReferentialReference<WeightCategoryDto>> allCategories = getModel().getReferentialReferences(TargetCatchDto.PROPERTY_WEIGHT_CATEGORY);

             availableCategories = WeightCategoryHelper.filterSpeciesWeightCategories(allCategories, species.getId());

 

         }

 

     private List<ReferentialReference<WeightCategoryDto>> buildWeightCategoryList(ReferentialReference<SpeciesDto> species) {

 

-        Set<ReferentialReference<WeightCategoryDto>> allCategories = getModel().getReferentialReferences(TargetCatchDto.PROPERTY_WEIGHT_CATEGORY);

+        List<ReferentialReference<WeightCategoryDto>> allCategories = getModel().getReferentialReferences(TargetCatchDto.PROPERTY_WEIGHT_CATEGORY);

         return WeightCategoryHelper.filterSpeciesWeightCategories(allCategories, species.getId());

 

     }

 

     @SuppressWarnings("unchecked")

     private List<ReferentialReference<ReasonForDiscardDto>> buildReasonFordiscardList() {

-

-        Set<ReferentialReference<ReasonForDiscardDto>> reasonForDiscardSet = getModel().getReferentialReferences(TargetCatchDto.PROPERTY_REASON_FOR_DISCARD);

-        return new ArrayList<>(reasonForDiscardSet);

-

+        return getModel().getReferentialReferences(TargetCatchDto.PROPERTY_REASON_FOR_DISCARD);

     }

 

     private List<ReferentialReference<WeightCategoryDto>> getAllWeightCategories() {

-

-        Set<ReferentialReference<WeightCategoryDto>> weightCategorySet = getModel().getReferentialReferences(TargetCatchDto.PROPERTY_WEIGHT_CATEGORY);

-        return new ArrayList<>(weightCategorySet);

-

+        return getModel().getReferentialReferences(TargetCatchDto.PROPERTY_WEIGHT_CATEGORY);

     }

 

     @Override

 import javax.swing.JPanel;

 import javax.swing.JRadioButton;

 import javax.swing.KeyStroke;

+import javax.swing.SwingUtilities;

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

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

 

                     Boolean changeStep = (Boolean) abstractButton.getClientProperty("changeStep");

                     if (changeStep != null && changeStep) {

                         StorageUI parentContainer = ui.getParentContainer(StorageUI.class);

-                        parentContainer.getNextAction().doClick();

+                        SwingUtilities.invokeLater(parentContainer.getNextAction()::doClick);

+                        return;

                     }

                     Boolean apply = (Boolean) abstractButton.getClientProperty("apply");

                     if (apply != null && apply) {

                         StorageUI parentContainer = ui.getParentContainer(StorageUI.class);

-                        parentContainer.getApplyAction().doClick();

+                        SwingUtilities.invokeLater(parentContainer.getNextAction()::doClick);

+                        SwingUtilities.invokeLater(parentContainer.getApplyAction()::doClick);

                     }

                 }

             });

 import java.util.Collections;

 import java.util.List;

 import java.util.Objects;

-import org.apache.commons.logging.Log;

-import org.apache.commons.logging.LogFactory;

 import org.nuiton.util.NumberUtil;

 

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

 public class ActivitySeineImpl extends ActivitySeineAbstract {

 

-    /** Logger. */

-    private static final Log log = LogFactory.getLog(ActivitySeineImpl.class);

-

     private static final long serialVersionUID = 2L;

 

     public static final String ACTIVITY_FIN_DE_VEILLE = "16";

 

-    public static final String ACTIVITY_DEBUT_DE_PECHE = "7";

+    private static final String ACTIVITY_DEBUT_DE_PECHE = "7";

 

-    public static final String ACTIVITY_FIN_DE_PECHE = "6";

+    private static final String ACTIVITY_FIN_DE_PECHE = "6";

 

-    public static final String ACTIVITY_CHANGED_ZONE = "21";

+    private static final String ACTIVITY_CHANGED_ZONE = "21";

 

     private static final List<String> CALEE_OPERATIONS = Collections.singletonList(ACTIVITY_FIN_DE_PECHE);

 

 

     private static final List<String> SYSTEM_OPERATIONS = Arrays.asList("0", "11", "11", ACTIVITY_FIN_DE_VEILLE);

 

-    public static final String PROPERTY_CHANGED_ZONE_OPERATION = "changedZoneOperation";

-

-    public static final String PROPERTY_SET_OPERATION = "setOperation";

-

-//    @Override

-//    public OpenableEntity getOpenChild() {

-//        // sur une activity, pas d'enfant OpenableEntity

-//        return null;

-//    }

-//

-//    @Override

-//    public List<?> getOpenableChilds() {

-//        // sur une activity, pas d'enfant OpenableEntity

-//        return null;

-//    }

+    private static final String PROPERTY_CHANGED_ZONE_OPERATION = "changedZoneOperation";

 

-    /** @return {@code true} si l'activite concerne un DCP */

     @Override

     public boolean isDCPOperation() {

         return vesselActivitySeine != null && DCP_OPERATIONS.contains(vesselActivitySeine.getCode());

     }

 

-    /** @return {@code true} si l'activite concerne une calée */

     @Override

     public boolean isSetOperation() {

         return vesselActivitySeine != null && CALEE_OPERATIONS.contains(vesselActivitySeine.getCode());

     }

 

-    /** @return {@code true} si l'activite concerne un système observé */

     @Override

     public boolean isObservedSystemOperation() {

         return vesselActivitySeine != null && SYSTEM_OPERATIONS.contains(vesselActivitySeine.getCode());

     }

 

-    /** @return {@code true} si l'activite concerne un changement de zone */

     @Override

     public boolean isChangedZoneOperation() {

         return vesselActivitySeine != null && ACTIVITY_CHANGED_ZONE.equals(vesselActivitySeine.getCode());

         return CoordinateHelper.getQuadrant(longitude, latitude);

     }

 

-//    @Override

-//    public void setQuadrant(Integer quadrant) {

-//        if (!Objects.equals(this.quadrant, quadrant)) {

-//            Entities.printDebugInformations(PROPERTY_QUADRANT, this, quadrant);

-//        }

-//        Integer old = this.quadrant;

-////        fireOnPreWrite(PROPERTY_QUADRANT, old, quadrant);

-//        this.quadrant = quadrant;

-//        fireOnPostWrite(PROPERTY_QUADRANT, old, quadrant);

-//    }

-

     @Override

     public SchoolType getSchoolType() {

         return ActivitySeines.getSchoolType(this);

     public void setObservedSystemDistance(Float observedSystemDistance) {

         if (observedSystemDistance != null) {

 

-            // on arrondit à 2 décimales

-            observedSystemDistance =

-                    NumberUtil.roundTwoDigits(observedSystemDistance);

+            observedSystemDistance = NumberUtil.roundTwoDigits(observedSystemDistance);

         }

         super.setObservedSystemDistance(observedSystemDistance);

     }

 import fr.ird.observe.common.constants.seine.TypeTransmittingBuoyOperation;

 import fr.ird.observe.entities.referentiel.seine.TransmittingBuoyOperation;

 

-/** Implantation des objectOperations pour l'entité FloatingObject. */

 public class FloatingObjectImpl extends FloatingObjectAbstract {

 

     private static final long serialVersionUID = 1L;

  */

 

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

+import java.util.Collection;

 import java.util.List;

 import java.util.Set;

 import java.util.function.Predicate;

      * @param speciesId l'identifiant de l'espèce

      * @return la liste de toutes les catégories de poids de l'espèce

      */

-    public static List<ReferentialReference<WeightCategoryDto>> filterSpeciesWeightCategories(Set<ReferentialReference<WeightCategoryDto>> weightCategoryReferences, String speciesId) {

+    public static List<ReferentialReference<WeightCategoryDto>> filterSpeciesWeightCategories(Collection<ReferentialReference<WeightCategoryDto>> weightCategoryReferences, String speciesId) {

 

         List<ReferentialReference<WeightCategoryDto>> references = weightCategoryReferences.stream().filter(new WeightCategorySpeciesPredicate(speciesId)).collect(Collectors.toList());

 

-package fr.ird.observe.services.dto.seine;

-

-/*-

- * #%L

- * ObServe :: Services

- * %%

- * Copyright (C) 2008 - 2017 IRD, Code Lutin, 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 java.util.Date;

-import org.nuiton.util.DateUtil;

-

-public class NonTargetCatchReleaseDto extends GeneratedNonTargetCatchReleaseDto {

-

-    private static final long serialVersionUID = 1L;

-

-    @Override

-    public void setDetectionTime(Date detectionTime) {

-        super.setDetectionTime(detectionTime == null ? null : DateUtil.getTime(detectionTime, false, false));

-    }

-

-    @Override

-    public void setReleaseTime(Date releaseTime) {

-        super.setReleaseTime(releaseTime == null ? null : DateUtil.getTime(releaseTime, false, false));

-    }

-}

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

Commits:

21 changed files:

Changes: