type = Boolean

 defaultValue = false

 [option sizeMeasureTypeSeineObservationTargetSampleId]

 description = observe.config.sizeMeasureType.seine.observation.targetSample

 key = referential.sizeMeasureType.seine.observation.targetSample

 observe.config.client.temporaryFiles.timeout.description

 observe.config.consolidation.failIfLengthLengthParameterNotFound

 observe.config.consolidation.failIfLengthWeightParameterNotFound

 observe.config.coordinate.format

 observe.config.db.locale

 observe.config.dcpPresetsDirectory.description

 //            helper.setCloseAction(((DataSourceEditor)currentBody.get()).getContentUIManager()::restartEdit);

 //        }

         addUiOptions(helper);

         addNavigationOptions(helper);

         addMapOptions(helper);

         return helper;

     }

         helper.addCategory(n("observe.config.category.application"),

                            n("observe.config.category.application.description"),

         helper.addOption(ClientConfigOption.VALIDATION_USE_DISABLED_REFERENTIAL);

         helper.addOption(ClientConfigOption.CONSOLIDATION_FAIL_IF_LENGTH_WEIGHT_PARAMETER_NOT_FOUND);

         helper.addOption(ClientConfigOption.CONSOLIDATION_FAIL_IF_LENGTH_LENGTH_PARAMETER_NOT_FOUND);

     }

           <JCheckBox id='consolidationFailIfLengthLengthParameterNotFound' styleClass="skipI18n"/>

         </cell>

       </row>

     </Table>

     <!--Table id='consolidationReportConfig' fill='both' constraints='BorderLayout.CENTER'>

       <row>

 import org.apache.logging.log4j.Logger;

 import org.nuiton.jaxx.runtime.swing.wizard.ext.WizardState;

 import java.util.Set;

 import java.util.TreeSet;

 public class ConsolidateModel extends AdminActionModel {

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

     /**

      * To track trip that has already been consolidated (they won't be again processed).

      */

     private final Set<String> alreadyDoneTripIds;

     private boolean consolidationFailIfLengthWeightParameterNotFound;

     private boolean consolidationFailIfLengthLengthParameterNotFound;

     private boolean skipForReport;

     public ConsolidateModel() {

         super(AdminStep.CONSOLIDATE);

         this.alreadyDoneTripIds = new TreeSet<>();

         setConsolidationFailIfLengthWeightParameterNotFound(getClientConfig().isConsolidationFailIfLengthWeightParameterNotFound());

         setConsolidationFailIfLengthLengthParameterNotFound(getClientConfig().isConsolidationFailIfLengthLengthParameterNotFound());

     }

     @Override

         firePropertyChange("consolidationFailIfLengthLengthParameterNotFound", oldValue, consolidationFailIfLengthLengthParameterNotFound);

     }

     public boolean isSkipForReport() {

         return skipForReport;

     }

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

         SelectConsolidationConfigFlag.init(extraConfig, extraConfig.getConsolidationFailIfLengthWeightParameterNotFound(), new SelectConsolidationConfigFlag("consolidationFailIfLengthWeightParameterNotFound", ConsolidateModel::isConsolidationFailIfLengthWeightParameterNotFound, ConsolidateModel::setConsolidationFailIfLengthWeightParameterNotFound, 5));

         SelectConsolidationConfigFlag.init(extraConfig, extraConfig.getConsolidationFailIfLengthLengthParameterNotFound(), new SelectConsolidationConfigFlag("consolidationFailIfLengthLengthParameterNotFound", ConsolidateModel::isConsolidationFailIfLengthLengthParameterNotFound, ConsolidateModel::setConsolidationFailIfLengthLengthParameterNotFound, 6));

         configUI.getExtraConfig().add(extraConfig);

     }

 }

         request.setTripId(tripId);

         request.setFailIfLengthWeightParameterNotFound(stepModel.isConsolidationFailIfLengthWeightParameterNotFound());

         request.setFailIfLengthLengthParameterNotFound(stepModel.isConsolidationFailIfLengthLengthParameterNotFound());

         TripConsolidateResult result = consolidateDataService.consolidateTrip(simplifiedObjectTypeSpecializedRules, request);

         if (result != null) {

 observe.config.client.temporaryFiles.timeout.description=Temporary files delete (in hours)

 observe.config.consolidation.failIfLengthLengthParameterNotFound=In consolidate action, raise an error if a lengthLengthParameter is not found, otherwise add an warning in action

 observe.config.consolidation.failIfLengthWeightParameterNotFound=In consolidate action, raise an error if a lengthWeightParameter is not found, otherwise add an warning in action

 observe.config.coordinate.format=Position format (DMD, DD, DMS)

 observe.config.db.locale=Language of data source (fr_FR, en_GB or es_ES)

 observe.config.dcpPresetsDirectory.description=Dcp presets directory

 observe.config.client.temporaryFiles.timeout.description=Temporary files delete (in hours) \#TODO

 observe.config.consolidation.failIfLengthLengthParameterNotFound=In consolidate action, raise an error if a lengthLengthParameter is not found, otherwise add an warning in action \#TODO

 observe.config.consolidation.failIfLengthWeightParameterNotFound=In consolidate action, raise an error if a lengthWeightParameter is not found, otherwise add an warning in action \#TODO

 observe.config.coordinate.format=Formato de posición (DMD, DD, DMS)

 observe.config.db.locale=Idioma del referencial (fr_FR, en_GB o es_ES)

 observe.config.dcpPresetsDirectory.description=Dcp presets directory \#TODO

 observe.config.client.temporaryFiles.timeout.description=Nettoyage des fichiers temporaires (en heures)

 observe.config.consolidation.failIfLengthLengthParameterNotFound=Dans l'action de consolidation, déclencher une erreur si une relation taille-taille n'est pas trouvée, sinon consigner cela en avertissement de l'action

 observe.config.consolidation.failIfLengthWeightParameterNotFound=Dans l'action de consolidation, déclencher une erreur si une relation taille-poids n'est pas trouvée, sinon consigner cela en avertissement de l'action

 observe.config.coordinate.format=Format des positions (DMD, DD, DMS)

 observe.config.db.locale=La langue du référentiel (fr_FR, en_GB ou es_ES)

 observe.config.dcpPresetsDirectory.description=Répertoire des pré-configurations de DCP

 import io.ultreia.java4all.util.json.JsonAware;

 /**

  * Request to consolidate a trip.

  * <p>

      */

     private boolean failIfLengthLengthParameterNotFound;

     public boolean isFailIfLengthWeightParameterNotFound() {

         return failIfLengthWeightParameterNotFound;

     }

     public void setFailIfLengthLengthParameterNotFound(boolean failIfLengthLengthParameterNotFound) {

         this.failIfLengthLengthParameterNotFound = failIfLengthLengthParameterNotFound;

     }

 }

         Trip trip = Trip.loadEntity(context, tripId);

         Set<ToolkitIdModifications> localmarketBatchResults = consolidateLocalmarketBatches(trip, failIfLengthWeightParameterNotFound);

         Set<fr.ird.observe.consolidation.data.ps.observation.ActivityConsolidateResult> observationActivityConsolidateResults = consolidateObservationActivities(trip, failIfLengthWeightParameterNotFound, failIfLengthLengthParameterNotFound);

         }

     }

         Set<ToolkitIdModifications> result = new LinkedHashSet<>();

         if (trip.isWellEmpty() || trip.isSampleEmpty()) {

             return result;

         }

         return result;

     }

      */

     ComputeWeightedWeight() {

         @Override

         public List<String> fieldNames() {

             return List.of(SampleActivity.PROPERTY_WEIGHTED_WEIGHT, SampleActivity.PROPERTY_WEIGHTED_WEIGHT_COMPUTED);

         @Override

         public void accept(SampleActivityConsolidateContext context, SampleActivity datum) {

             String wellId = context.getSampleWell();

             Activity activity = datum.getActivity();

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

             // Get total weight of the set which is this well

             if (w1 == 0) {

                 // limit case if the well was not found in trip well plan

                 log.warn("Well {} not found for activity {} in trip well plan.", wellId, activity.getTopiaId());

                 return;

             }

             // Get total weight of the set which are in well that has been sampled

             // Get total weight of the set in any well

             // the weighted weight is the formula: weightedWeight = (w1/w2)*wT

             float weightedWeight = (float) ((w1 / w2) * wT);

             Float oldWeightedWeight = datum.getWeightedWeight();

     private final JavaBeanMonitor monitor;

     private final Decorator decorator;

     private final Set<Well> tripWell;

     private final Set<ToolkitIdModifications> resultBuilder;

     private final java.util.Set<String> warnings = new LinkedHashSet<>();

     private final Set<String> sampledWellIds;

     private Sample sample;

     private SampleActivity datum;

         this.monitor = monitor;

         this.decorator = decorator;

         this.tripWell = trip.getWell();

         this.sampledWellIds = trip.getSample().stream().map(Sample::getWell).collect(Collectors.toSet());

         this.resultBuilder = resultBuilder;

     }

         return sampledWellIds;

     }

     public void watch(Sample sample, SampleActivity datum) {

         this.sample = Objects.requireNonNull(sample);

         this.datum = Objects.requireNonNull(datum);

         this.decorator = decoratorService.getDecoratorByType(SampleActivity.class);

     }

         for (Sample sample : trip.getSample()) {

             if (sample.isSampleActivityEmpty()) {

                 continue;

 import org.junit.Assert;

 import java.net.URL;

 import java.util.List;

 import java.util.Optional;

 import java.util.Set;

         TripConsolidateRequest request = new TripConsolidateRequest();

         request.setTripId(getProperty("consolidateTrip.id"));

         request.setFailIfLengthWeightParameterNotFound(false);

         TripConsolidateResult actual = service.consolidateTrip(simplifiedObjectTypeSpecializedRules, request);

         Assert.assertNotNull(actual);

 # #%L

 # ObServe Core :: Services :: Test

 # %%

 # %%

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

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

 #

 # 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

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

 # #L%

 ###

 consolidateTrip.observationsActivityResult.count=4

 consolidateTrip.observationsActivityResult.withModifications.count=4

 consolidateTrip.observationsActivityResult.withWarnings.count=4