GitLab

at 2023-12-01T08:48:22+01:00

Move to persistence model 9.3

add persistence migration code

Do not disable TransmittingBuoy.country

Rename I18n label TransmittingBuoy.country to flagCountry

keep protected unknown TransmittingBuoyOwnership id

add listener on TransmittingBuoyOwnership to enable/disable vessel or country

remove commented code (from v7)

Merge branch 'feature/issue-2044' into develop
Peaufinage du form Balise : disponibilité des champs Appartenance, Pays et Navire
- Closes #2044

             }

         });

         states.getBean().addPropertyChangeListener(FloatingObjectDto.PROPERTY_OBJECT_OPERATION, e -> states.updateMaterials(getTable().getTreeTableModel(), (ObjectOperationReference) e.getNewValue()));

+        states.setFirstBuoyOwnershipListener(new DcpUIModelStates.TransmittingBuoyOwnershipListener<>(getTransmittingBuoy1(), getVessel1(), getCountry1()));

+        states.setSecondBuoyOwnershipListener(new DcpUIModelStates.TransmittingBuoyOwnershipListener<>(getTransmittingBuoy2(), getVessel2(), getCountry2()));

     }

 

     default void installExtraActions() {

         changeTypeTransmittingBuoyOperation(states, typeOperation, false);

     }

 

-    default void stopEditUI() {

+    default void stopEditUI(DcpUIModelStates<?, ?> states) {

         if (getMainTabbedPane().getSelectedIndex() == 1) {

             getTable().editingCanceled(null);

         }

         getValidatorBuoy1().setBean(null);

         getValidatorBuoy2().setBean(null);

+        states.removeFirstBuoyOwnershipListener(getTransmittingBuoy1());

+        states.removeSecondBuoyOwnershipListener(getTransmittingBuoy2());

     }

 

     default void changeTypeTransmittingBuoyOperation(ItemEvent event, DcpUIModelStates<?, ?> states) {

         FloatingObjectAware bean = states.getBean();

         if (bean.getFirstBuoy() != null) {

             getValidatorBuoy1().setBean(getTransmittingBuoy1());

+            states.addFirstBuoyOwnershipListener(getTransmittingBuoy1());

             if (bean.getSecondBuoy() != null) {

                 getValidatorBuoy2().setBean(getTransmittingBuoy2());

+                states.addSecondBuoyOwnershipListener(getTransmittingBuoy2());

             }

         }

         states.setModified(states.isCreatingMode());

         if (states.isEditing()) {

             getValidatorBuoy1().setBean(null);

             getValidatorBuoy2().setBean(null);

+            states.removeFirstBuoyOwnershipListener(getTransmittingBuoy1());

+            states.removeSecondBuoyOwnershipListener(getTransmittingBuoy2());

         }

 

         String[] transmittingBuoyOperationCodes = typeOperation.getTransmittingBuoyOperationCodes();

                 editorPanel.add(getTransmittingBuoy1EditorPanel());

                 if (states.isEditing()) {

                     getValidatorBuoy1().setBean(getTransmittingBuoy1());

+                    states.addFirstBuoyOwnershipListener(getTransmittingBuoy1());

                 }

                 focusOwner = getTransmittingBuoyType1();

                 break;

                 if (states.isEditing()) {

                     getValidatorBuoy1().setBean(getTransmittingBuoy1());

                     getValidatorBuoy2().setBean(getTransmittingBuoy2());

+                    states.addFirstBuoyOwnershipListener(getTransmittingBuoy1());

+                    states.addSecondBuoyOwnershipListener(getTransmittingBuoy2());

                 }

                 focusOwner = getTransmittingBuoyType1();

                 break;

         });

     }

 

+

     private void addTransmittingBuoyCoordinate() {

         Table transmittingBuoy1Editor = getTransmittingBuoy1Editor();

         if (transmittingBuoy1Editor.getComponentCount() != 13) {

             transmittingBuoy1Editor.add(getComment1(), new GridBagConstraints(0, 5, 2, 1, 0.0, 1.0, 10, 1, new Insets(3, 3, 3, 3), 0, 0));

         }

     }

+

 }
 import fr.ird.observe.dto.data.ps.dcp.FloatingObjectPresetsManager;

 import fr.ird.observe.dto.data.ps.logbook.TransmittingBuoyDto;

 import fr.ird.observe.dto.referential.ReferentialLocale;

+import fr.ird.observe.dto.referential.common.CountryReference;

+import fr.ird.observe.dto.referential.common.VesselReference;

 import fr.ird.observe.dto.referential.ps.common.ObjectMaterialDto;

 import fr.ird.observe.dto.referential.ps.common.ObjectMaterialReference;

 import fr.ird.observe.dto.referential.ps.common.ObjectOperationReference;

 import fr.ird.observe.dto.referential.ps.common.TransmittingBuoyOwnershipReference;

 import io.ultreia.java4all.bean.JavaBean;

 import io.ultreia.java4all.jaxx.widgets.combobox.BeanEnumEditor;

+import io.ultreia.java4all.jaxx.widgets.combobox.FilterableComboBox;

 import org.apache.logging.log4j.LogManager;

 import org.apache.logging.log4j.Logger;

 

+import java.beans.PropertyChangeEvent;

+import java.beans.PropertyChangeListener;

 import java.util.Collection;

 import java.util.Date;

 import java.util.LinkedHashMap;

 

     Optional<ToolkitIdModifications> consolidate();

 

+    TransmittingBuoyOwnershipListener<?> getFirstBuoyOwnershipListener();

+

+    void setFirstBuoyOwnershipListener(TransmittingBuoyOwnershipListener<?> firstBuoyOwnershipListener);

+

+    TransmittingBuoyOwnershipListener<?> getSecondBuoyOwnershipListener();

+

+    void setSecondBuoyOwnershipListener(TransmittingBuoyOwnershipListener<?> secondBuoyOwnershipListener);

+

     default void recomputeComputedValues() {

         Optional<ToolkitIdModifications> result = consolidate();

         result.ifPresent(r -> {

 

     Map<String, ObjectMaterialDto> getReferentialMap();

 

+    void setReferentialMap(Map<String, ObjectMaterialDto> referentialMap);

+

     Map<String, TransmittingBuoyOperationReference> getBuoyOperationMap();

 

+    void setBuoyOperationMap(Map<String, TransmittingBuoyOperationReference> buoyOperationMap);

+

     default TransmittingBuoyOperationReference getBuoyOperation(String code) {

         return getBuoyOperationMap().get(code);

     }

 

-    void setBuoyOperationMap(Map<String, TransmittingBuoyOperationReference> buoyOperationMap);

-

     Map<ObjectMaterialDto, String> getWhenArriving();

 

     Map<ObjectMaterialDto, String> getWhenLeaving();

         return all.stream().filter(ObjectMaterialDto::withData).collect(Collectors.toSet());

     }

 

-    void setReferentialMap(Map<String, ObjectMaterialDto> referentialMap);

-

     void setWhenArriving(String id, String value);

 

     void setWhenLeaving(String id, String value);

 

         FloatingObjectPreset floatingObjectReference = getReference();

 

-        // FIXME See why we have to do this

-//        bean.getTransmittingBuoy().clear();

-//        bean.getFloatingObjectPart().clear();

-//        Form<FloatingObjectDto> form = model.openForm(getModel().getStates().getSelectedId());

         List<TransmittingBuoyOperationReference> referentialReferences = referencesCache.getReferentialReferences(TransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY_OPERATION);

         setBuoyOperationMap(Maps.uniqueIndex(referentialReferences, TransmittingBuoyOperationReference::getCode));

 

 

         openTable.accept(bean.isPersisted() || floatingObjectReference != null);

 

-        Optional.ofNullable(bean.getFirstBuoy()).ifPresent(b -> b.copy(ui1));

-        Optional.ofNullable(bean.getSecondBuoy()).ifPresent(b -> b.copy(ui2));

+        Optional.ofNullable(bean.getFirstBuoy()).ifPresent(b -> {

+            b.copy(ui1);

+            getFirstBuoyOwnershipListener().apply();

+        });

+        Optional.ofNullable(bean.getSecondBuoy()).ifPresent(b -> {

+            b.copy(ui2);

+            getSecondBuoyOwnershipListener().apply();

+        });

         getBean().setCanValidateMaterials(true);

     }

 

     ReferencesCache getReferenceCache();

 

     boolean isCreatingMode();

+

+    default void addFirstBuoyOwnershipListener(TransmittingBuoyAware buoy) {

+        TransmittingBuoyOwnershipListener<?> listener = getFirstBuoyOwnershipListener();

+        buoy.removePropertyChangeListener(TransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY_OWNERSHIP, listener);

+        buoy.addPropertyChangeListener(TransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY_OWNERSHIP, listener);

+        listener.apply();

+    }

+

+    default void removeFirstBuoyOwnershipListener(TransmittingBuoyAware buoy) {

+        PropertyChangeListener listener = getFirstBuoyOwnershipListener();

+        buoy.removePropertyChangeListener(TransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY_OWNERSHIP, listener);

+    }

+

+    default void addSecondBuoyOwnershipListener(TransmittingBuoyAware buoy) {

+        TransmittingBuoyOwnershipListener<?> listener = getSecondBuoyOwnershipListener();

+        buoy.removePropertyChangeListener(TransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY_OWNERSHIP, listener);

+        buoy.addPropertyChangeListener(TransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY_OWNERSHIP, listener);

+        listener.apply();

+    }

+

+    default void removeSecondBuoyOwnershipListener(TransmittingBuoyAware buoy) {

+        PropertyChangeListener listener = getSecondBuoyOwnershipListener();

+        buoy.removePropertyChangeListener(TransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY_OWNERSHIP, listener);

+    }

+

+    class TransmittingBuoyOwnershipListener<T extends TransmittingBuoyAware> implements PropertyChangeListener {

+

+        private final T buoy;

+        private final FilterableComboBox<VesselReference> vessel;

+        private final FilterableComboBox<CountryReference> country;

+

+        public TransmittingBuoyOwnershipListener(T buoy, FilterableComboBox<VesselReference> vessel, FilterableComboBox<CountryReference> country) {

+            this.buoy = buoy;

+            this.vessel = vessel;

+            this.country = country;

+        }

+

+        @Override

+        public void propertyChange(PropertyChangeEvent evt) {

+            TransmittingBuoyOwnershipReference buoyOwnership = (TransmittingBuoyOwnershipReference) evt.getNewValue();

+            apply(buoyOwnership);

+        }

+

+        public void apply() {

+            apply(buoy.getTransmittingBuoyOwnership());

+        }

+

+        private void apply(TransmittingBuoyOwnershipReference buoyOwnership) {

+            boolean enableVessel = true;

+            boolean enableCountry = true;

+            if (buoyOwnership != null) {

+                switch (buoyOwnership.getId()) {

+                    case ProtectedIdsPs.PS_COMMON_TRANSMITTING_BUOY_OWNERSHIP_THIS_SHIP_ID:

+                        enableVessel = false;

+                        enableCountry = false;

+                        break;

+                    case ProtectedIdsPs.PS_COMMON_TRANSMITTING_BUOY_OWNERSHIP_UNKNOWN_ID:

+                        enableVessel = false;

+                        break;

+                }

+            }

+            if (enableVessel) {

+                vessel.setEnabled(true);

+            } else {

+                buoy.setVessel(null);

+                vessel.setEnabled(false);

+            }

+            if (enableCountry) {

+                country.setEnabled(true);

+            } else {

+                buoy.setCountry(null);

+                country.setEnabled(false);

+            }

+        }

+    }

 }
 

 #transmittingBuoyOwnership1 {

   property:{TransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY_OWNERSHIP};

-  enabled: {!DcpUIModelStates.isBuoyDeployement(transmittingBuoy1.getTransmittingBuoyOperation())}

 }

 

 #country1Label {

 

 #transmittingBuoyOwnership2 {

   property:{TransmittingBuoyDto.PROPERTY_TRANSMITTING_BUOY_OWNERSHIP};

-  enabled: {!DcpUIModelStates.isBuoyDeployement(transmittingBuoy2.getTransmittingBuoyOperation())}

 }

 

 #country2Label {

 

     @Override

     public void stopEditUI() {

-        ui.stopEditUI();

+        ui.stopEditUI(ui.getModel().getStates());

         super.stopEditUI();

     }

 

     private boolean arriving;

     private boolean leaving;

     private FloatingObjectConsolidateEngine consolidateEngine;

+    private TransmittingBuoyOwnershipListener<?> firstBuoyOwnershipListener;

+    private TransmittingBuoyOwnershipListener<?> secondBuoyOwnershipListener;

 

     public FloatingObjectUIModelStates(GeneratedFloatingObjectUIModel model) {

         super(model);

         this.simplifiedObjectTypeSpecializedRulesSupplier = SingletonSupplier.of(model.getClientConfig()::getSimplifiedObjectTypeSpecializedRules);

     }

 

+    @Override

+    public TransmittingBuoyOwnershipListener<?> getFirstBuoyOwnershipListener() {

+        return firstBuoyOwnershipListener;

+    }

+

+    @Override

+    public void setFirstBuoyOwnershipListener(TransmittingBuoyOwnershipListener<?> firstBuoyOwnershipListener) {

+        this.firstBuoyOwnershipListener = firstBuoyOwnershipListener;

+    }

+

+    @Override

+    public TransmittingBuoyOwnershipListener<?> getSecondBuoyOwnershipListener() {

+        return secondBuoyOwnershipListener;

+    }

+

+    @Override

+    public void setSecondBuoyOwnershipListener(TransmittingBuoyOwnershipListener<?> secondBuoyOwnershipListener) {

+        this.secondBuoyOwnershipListener = secondBuoyOwnershipListener;

+    }

+

     @Override

     public Map<String, TransmittingBuoyOperationReference> getBuoyOperationMap() {

         return buoyOperationMap;

         return whenLeaving;

     }

 

-    @Override

-    public void setReferentialMap(Map<String, ObjectMaterialDto> referentialMap) {

-        this.referentialMap = referentialMap;

-    }

-

     @Override

     public void setWhenArriving(String id, String value) {

         setWhen0(id, value, whenArriving);

         return referentialMap;

     }

 

+    @Override

+    public void setReferentialMap(Map<String, ObjectMaterialDto> referentialMap) {

+        this.referentialMap = referentialMap;

+    }

+

     @Override

     public String getComputedWhenArrivingBiodegradableValue() {

         return DcpUIModelStates.super.getComputedWhenArrivingBiodegradableValue();

 

     @Override

     public void stopEditUI() {

-        ui.stopEditUI();

+        ui.stopEditUI(ui.getModel().getStates());

         super.stopEditUI();

     }

 

     private boolean arriving;

     private boolean leaving;

     private FloatingObjectConsolidateEngine consolidateEngine;

+    private TransmittingBuoyOwnershipListener<?> firstBuoyOwnershipListener;

+    private TransmittingBuoyOwnershipListener<?> secondBuoyOwnershipListener;

 

     public FloatingObjectUIModelStates(GeneratedFloatingObjectUIModel model) {

         super(model);

         this.simplifiedObjectTypeSpecializedRulesSupplier = SingletonSupplier.of(model.getClientConfig()::getSimplifiedObjectTypeSpecializedRules);

     }

 

+    @Override

+    public TransmittingBuoyOwnershipListener<?> getFirstBuoyOwnershipListener() {

+        return firstBuoyOwnershipListener;

+    }

+

+    @Override

+    public void setFirstBuoyOwnershipListener(TransmittingBuoyOwnershipListener<?> firstBuoyOwnershipListener) {

+        this.firstBuoyOwnershipListener = firstBuoyOwnershipListener;

+    }

+

+    @Override

+    public TransmittingBuoyOwnershipListener<?> getSecondBuoyOwnershipListener() {

+        return secondBuoyOwnershipListener;

+    }

+

+    @Override

+    public void setSecondBuoyOwnershipListener(TransmittingBuoyOwnershipListener<?> secondBuoyOwnershipListener) {

+        this.secondBuoyOwnershipListener = secondBuoyOwnershipListener;

+    }

+

     @Override

     public Map<String, TransmittingBuoyOperationReference> getBuoyOperationMap() {

         return buoyOperationMap;

         return whenLeaving;

     }

 

-    @Override

-    public void setReferentialMap(Map<String, ObjectMaterialDto> referentialMap) {

-        this.referentialMap = referentialMap;

-    }

-

     @Override

     public void setWhenArriving(String id, String value) {

         setWhen0(id, value, whenArriving);

         return referentialMap;

     }

 

+    @Override

+    public void setReferentialMap(Map<String, ObjectMaterialDto> referentialMap) {

+        this.referentialMap = referentialMap;

+    }

+

     @Override

     public String getComputedWhenArrivingBiodegradableValue() {

         return DcpUIModelStates.super.getComputedWhenArrivingBiodegradableValue();

 observe.data.ps.logbook.SampleSpeciesMeasure.count.short

 observe.data.ps.logbook.SampleSpeciesMeasure.type

 observe.data.ps.logbook.TransmittingBuoy.code

+observe.data.ps.logbook.TransmittingBuoy.country

 observe.data.ps.logbook.TransmittingBuoy.type

 observe.data.ps.logbook.Well.action.create

 observe.data.ps.logbook.Well.action.move

 observe.data.ps.observation.SpeciesFateDiscardMode.trueValue

 observe.data.ps.observation.SpeciesFateDiscardMode.type

 observe.data.ps.observation.TransmittingBuoy.code

+observe.data.ps.observation.TransmittingBuoy.country

 observe.data.ps.observation.TransmittingBuoy.type

 observe.referential.MinMaxWeight.maxWeight

 observe.referential.MinMaxWeight.minMaxWeight

 //FIXME-PROTECTED-ID

 public interface ProtectedIdsPs {

     String PS_COMMON_TRANSMITTING_BUOY_OWNERSHIP_THIS_SHIP_ID = "fr.ird.referential.ps.common.TransmittingBuoyOwnership#0#3";

+    String PS_COMMON_TRANSMITTING_BUOY_OWNERSHIP_UNKNOWN_ID = "fr.ird.referential.ps.common.TransmittingBuoyOwnership#0#0";

     String PS_COMMON_SCHOOL_TYPE_UNDEFINED_ID = "fr.ird.referential.ps.common.SchoolType#0#0";

     String PS_COMMON_SCHOOL_TYPE_FREE_ID = "fr.ird.referential.ps.common.SchoolType#0#2";

     String PS_COMMON_SCHOOL_TYPE_OBJECT_ID = "fr.ird.referential.ps.common.SchoolType#0#1";

  * @author Tony Chemit - dev@tchemit.fr

  * @since 9.3.0

  */

-//@AutoService(MigrationVersionResource.class)

+@AutoService(MigrationVersionResource.class)

 public class DataSourceMigrationForVersion_9_3 extends ByMajorMigrationVersionResource {

 

     public DataSourceMigrationForVersion_9_3() {

         super(Version.valueOf("9.3"), false);

-        createResourceScriptVariables(this, "2023-11-15", "2023-09-01 00:00:00.000000");

+        createResourceScriptVariables(this, "2023-12-01", "2023-12-01 00:00:00.000000");

     }

 

-

     @Override

     public void generateSqlScript(MigrationVersionResourceExecutor executor) {

         boolean withIds = executor.findSingleResult(SqlQuery.wrap("SELECT COUNT (*) FROM common.person", r -> r.getInt(1) > 0));

-

+        if (withIds) {

+            // See https://gitlab.com/ultreiaio/ird-observe/-/issues/2044

+            executor.addScript("01", "issue-2044");

+        }

     }

 

 }

+---

+-- #%L

+-- ObServe Core :: Persistence :: Migration

+-- %%

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

+-- %%

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

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

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

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

+--

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

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

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

+-- GNU General Public License for more details.

+--

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

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

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

+-- #L%

+---

+-- Unknown vessel → no vessel

+UPDATE ps_observation.TransmittingBuoy SET vessel = NULL WHERE transmittingBuoyOwnership = 'fr.ird.referential.ps.common.TransmittingBuoyOwnership#0#0';

+UPDATE ps_logbook.TransmittingBuoy SET vessel = NULL WHERE transmittingBuoyOwnership = 'fr.ird.referential.ps.common.TransmittingBuoyOwnership#0#0';

+-- This vessel → no country, nor vessel

+UPDATE ps_observation.TransmittingBuoy SET country = NULL, vessel = NULL WHERE transmittingBuoyOwnership = 'fr.ird.referential.ps.common.TransmittingBuoyOwnership#0#3';

+UPDATE ps_logbook.TransmittingBuoy SET country = NULL, vessel = NULL WHERE transmittingBuoyOwnership = 'fr.ird.referential.ps.common.TransmittingBuoyOwnership#0#3';
 observe.data.ps.logbook.SampleSpeciesMeasure.count.short=Count

 observe.data.ps.logbook.SampleSpeciesMeasure.type=Sample species measure

 observe.data.ps.logbook.TransmittingBuoy.code=Code

+observe.data.ps.logbook.TransmittingBuoy.country=Flag country

 observe.data.ps.logbook.TransmittingBuoy.type=Transmitting buoy

 observe.data.ps.logbook.Well.action.create=Next well

 observe.data.ps.logbook.Well.action.move=Change trip

 observe.data.ps.observation.SpeciesFateDiscardMode.trueValue=Discarded

 observe.data.ps.observation.SpeciesFateDiscardMode.type=Species fate discard mode

 observe.data.ps.observation.TransmittingBuoy.code=Code

+observe.data.ps.observation.TransmittingBuoy.country=Flag country

 observe.data.ps.observation.TransmittingBuoy.type=Transmitting buoy

 observe.data.ps.pairing.ActivityPairingResultItem.computedDistance=Distance (km)

 observe.data.ps.pairing.ActivityPairingResultItem.computedTime=Time shift (days\:hours\:minutes)

 observe.data.ps.logbook.SampleSpeciesMeasure.count.short=Count

 observe.data.ps.logbook.SampleSpeciesMeasure.type=Sample species measure

 observe.data.ps.logbook.TransmittingBuoy.code=Identificación

+observe.data.ps.logbook.TransmittingBuoy.country=Bandera

 observe.data.ps.logbook.TransmittingBuoy.type=TransmittingBuoy

 observe.data.ps.logbook.Well.action.create=Next well

 observe.data.ps.logbook.Well.action.move=Change trip

 observe.data.ps.observation.SpeciesFateDiscardMode.trueValue=Discarded

 observe.data.ps.observation.SpeciesFateDiscardMode.type=Species fate discard mode

 observe.data.ps.observation.TransmittingBuoy.code=Identificación

+observe.data.ps.observation.TransmittingBuoy.country=Bandera

 observe.data.ps.observation.TransmittingBuoy.type=TransmittingBuoy

 observe.data.ps.pairing.ActivityPairingResultItem.computedDistance=Distance (km) \#TODO

 observe.data.ps.pairing.ActivityPairingResultItem.computedTime=Time shift (days\:hours\:minutes) \#TODO

 observe.data.ps.logbook.SampleSpeciesMeasure.count.short=Effectif

 observe.data.ps.logbook.SampleSpeciesMeasure.type=Mesure d'un échantillon espèce

 observe.data.ps.logbook.TransmittingBuoy.code=Identifiant

+observe.data.ps.logbook.TransmittingBuoy.country=Pavillon

 observe.data.ps.logbook.TransmittingBuoy.type=Balise émettrice

 observe.data.ps.logbook.Well.action.create=Cuve suivante

 observe.data.ps.logbook.Well.action.move=Changer de marée

 observe.data.ps.observation.SpeciesFateDiscardMode.trueValue=Rejeté

 observe.data.ps.observation.SpeciesFateDiscardMode.type=Mode de rejet (du devenir)

 observe.data.ps.observation.TransmittingBuoy.code=Identifiant

+observe.data.ps.observation.TransmittingBuoy.country=Pavillon

 observe.data.ps.observation.TransmittingBuoy.type=Balise émettrice

 observe.data.ps.pairing.ActivityPairingResultItem.computedDistance=Distance (km)

 observe.data.ps.pairing.ActivityPairingResultItem.computedTime=Écart de temps (jours\:heures\:minutes)

 data.ll.landing.Landing=vessel

 data.ps.localmarket.Sample=well

 data.ps.logbook.Catch=weightMeasureMethod.validation.required

+data.ps.logbook.TransmittingBuoy=country

 data.ps.observation.Catch=minWeight,maxWeight,minMaxWeight,weightMeasureMethod

 data.ps.observation.SchoolEstimate=species

 data.ps.observation.Set=startTime,haulingStartTimeStamp,haulingEndTimeStamp,endTimeStamp

+data.ps.observation.TransmittingBuoy=country

 referential.common.Species=codeAndHomeId

 referential.ps.common.AcquisitionStatus=observation,logbook,landing,localMarket
     <model.persistence.defaultPackage>fr.ird.observe.entities</model.persistence.defaultPackage>

     <model.persistence.fullPackagePath>fr.ird.observe</model.persistence.fullPackagePath>

     <!--persistence model version-->

-    <persistence.model.version>9.2</persistence.model.version>

+    <persistence.model.version>9.3</persistence.model.version>

     <!--persistence previous model version used for tck migration-->

-    <persistence.previous.model.version>9.1</persistence.previous.model.version>

+    <persistence.previous.model.version>9.2</persistence.previous.model.version>

     <tck.filename>tck-v${persistence.model.version}.zip</tck.filename>

     <tck.updated.filename>updated-${tck.filename}</tck.updated.filename>

     <tck.remote.path>/var/www/html/private/ird-observe/tck</tck.remote.path>

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

Commits:

16 changed files:

Changes: