Tony CHEMIT pushed to branch develop at ultreiaio / ird-observe Commits: 5875aca4 by Tony Chemit at 2023-03-09T17:30:25+01:00 update java-lang (Problème sur les arrondis de nombres décimaux - Closes #2636) update pom - - - - - c2db563c by Tony Chemit at 2023-03-09T17:30:28+01:00 Validation - Amélioration du message sur une détection d'entrée non unique dans une collection (on ajoute désormais le rendu de l'objet validé) - Closes #2637 - - - - - 770640e3 by Tony Chemit at 2023-03-09T17:30:33+01:00 Consolidation - Revue finale pour bien ajouter dans les logs toutes les modifications et amélioration des messages pour mieux voir les actions. - - - - - 17 changed files: - core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/AtomicConsolidateAction.java - core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/ComputeBiodegradableAction.java → core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/ComputeBiodegradableConsolidateAction.java - core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/ComputeNonEntanglingAction.java → core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/ComputeNonEntanglingConsolidateAction.java - core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/ComputeSimplifiedObjectTypeAction.java → core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/ComputeSimplifiedObjectTypeConsolidateAction.java - + core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/FloatingObjectConsolidateAction.java - core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/FloatingObjectConsolidateEngineSupport.java - core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/localmarket/BatchConsolidateActions.java - core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/localmarket/BatchConsolidateContext.java - core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/localmarket/BatchConsolidateEngine.java - + core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/logbook/FloatingObjectActions.java - core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/logbook/FloatingObjectConsolidateEngine.java - + core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/observation/FloatingObjectActions.java - core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/observation/FloatingObjectConsolidateEngine.java - core/persistence/consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/observation/CatchConsolidateActions.java - core/persistence/consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/observation/SampleConsolidateActions.java - pom.xml - toolkit/api-validation/src/main/java/fr/ird/observe/validation/validators/collection/AbstractCollectionUniqueKeyValidator.java Changes: ===================================== core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/AtomicConsolidateAction.java ===================================== @@ -41,8 +41,18 @@ public interface AtomicConsolidateAction<C extends ConsolidateContext<E>, E exte Logger log = LogManager.getLogger(AtomicConsolidateAction.class); + /** + * @return the field name on which action may compute the value. + */ String fieldName(); + /** + * @return extra field name on which action may have change also the value (for {@code computedSource} fields). + */ + default String extraFieldName() { + return null; + } + /** * Test if this action can be executed, and if so, then execute it. * @@ -59,13 +69,16 @@ public interface AtomicConsolidateAction<C extends ConsolidateContext<E>, E exte return false; } - - default void logModification(C context, E data) { + private void logModification(C context, E data) { String fieldName = fieldName(); logModification(context, data, fieldName); + String extraFieldName = extraFieldName(); + if (extraFieldName != null) { + logModification(context, data, extraFieldName); + } } - default void logModification(C context, E data, String fieldName) { + private void logModification(C context, E data, String fieldName) { context.getModification(fieldName).ifPresent(modification -> log.info(String.format("[%s] property '%s.%s' has changed [old value: %s - new value: %s] (by action %s)", data.getTopiaId(), context.dataType().getSimpleName(), ===================================== core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/ComputeBiodegradableAction.java → core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/ComputeBiodegradableConsolidateAction.java ===================================== @@ -22,7 +22,6 @@ package fr.ird.observe.consolidation.data.ps.dcp; * #L% */ -import fr.ird.observe.consolidation.AtomicConsolidateAction; import fr.ird.observe.dto.data.DataDto; import fr.ird.observe.dto.data.ps.DcpComputedValue; import fr.ird.observe.dto.data.ps.FloatingObjectAware; @@ -37,24 +36,13 @@ import java.util.Set; * @author Tony Chemit - dev@tchemit.fr * @since 9.0.26 */ -public interface ComputeBiodegradableAction<F extends DataDto & FloatingObjectAware, +public interface ComputeBiodegradableConsolidateAction<F extends DataDto & FloatingObjectAware, P extends DataDto & FloatingObjectPartAware, R extends FloatingObjectConsolidateRequestSupport<F, P>, - C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends AtomicConsolidateAction<C, F> { - - Set<P> getParts(R adapter); - - void setValue(F floatingObject, DcpComputedValue computedValue); + C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends FloatingObjectConsolidateAction<DcpComputedValue, F, P, R, C> { @Override - default void accept(C context, F floatingObject) { - R adapter = context.getRequest(); - Set<P> parts = getParts(adapter); - DcpComputedValue computedValue = computeValue(adapter, parts); - setValue(floatingObject, computedValue); - } - - private DcpComputedValue computeValue(R adapter, Set<P> parts) { + default DcpComputedValue computeValue(C context, R adapter, Set<P> parts) { if (parts.isEmpty()) { return null; } @@ -73,26 +61,16 @@ public interface ComputeBiodegradableAction<F extends DataDto & FloatingObjectAw return result; } - final class WhenArriving<F extends DataDto & FloatingObjectAware, + final class WhenArriving<F extends DataDto & FloatingObjectAware, P extends DataDto & FloatingObjectPartAware, R extends FloatingObjectConsolidateRequestSupport<F, P>, - C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeBiodegradableAction<F, P, R, C> { - - @Override - public boolean test(C context, F floatingObject) { - return floatingObject.getObjectOperation().isWhenArriving(); - } + C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeBiodegradableConsolidateAction<F, P, R, C>, WhenArrivingConsolidateAction<DcpComputedValue, F, P, R, C> { @Override public String fieldName() { return FloatingObjectDto.PROPERTY_COMPUTED_WHEN_ARRIVING_BIODEGRADABLE; } - @Override - public Set<P> getParts(R adapter) { - return adapter.getWhenArriving(); - } - @Override public void setValue(F floatingObject, DcpComputedValue computedValue) { floatingObject.setComputedWhenArrivingBiodegradable(computedValue); @@ -102,12 +80,7 @@ public interface ComputeBiodegradableAction<F extends DataDto & FloatingObjectAw final class WhenLeaving<F extends DataDto & FloatingObjectAware, P extends DataDto & FloatingObjectPartAware, R extends FloatingObjectConsolidateRequestSupport<F, P>, - C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeBiodegradableAction<F, P, R, C> { - - @Override - public boolean test(C context, F floatingObject) { - return floatingObject.getObjectOperation().isWhenLeaving(); - } + C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeBiodegradableConsolidateAction<F, P, R, C>, WhenLeavingConsolidateAction<DcpComputedValue, F, P, R, C> { @Override public String fieldName() { @@ -118,10 +91,5 @@ public interface ComputeBiodegradableAction<F extends DataDto & FloatingObjectAw public void setValue(F floatingObject, DcpComputedValue computedValue) { floatingObject.setComputedWhenLeavingBiodegradable(computedValue); } - - @Override - public Set<P> getParts(R adapter) { - return adapter.getWhenLeaving(); - } } } ===================================== core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/ComputeNonEntanglingAction.java → core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/ComputeNonEntanglingConsolidateAction.java ===================================== @@ -22,7 +22,6 @@ package fr.ird.observe.consolidation.data.ps.dcp; * #L% */ -import fr.ird.observe.consolidation.AtomicConsolidateAction; import fr.ird.observe.dto.data.DataDto; import fr.ird.observe.dto.data.ps.DcpComputedValue; import fr.ird.observe.dto.data.ps.FloatingObjectAware; @@ -37,24 +36,13 @@ import java.util.Set; * @author Tony Chemit - dev@tchemit.fr * @since 9.0.26 */ -public interface ComputeNonEntanglingAction<F extends DataDto & FloatingObjectAware, +public interface ComputeNonEntanglingConsolidateAction<F extends DataDto & FloatingObjectAware, P extends DataDto & FloatingObjectPartAware, R extends FloatingObjectConsolidateRequestSupport<F, P>, - C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends AtomicConsolidateAction<C, F> { - - Set<P> getParts(R adapter); - - void setValue(F floatingObject, DcpComputedValue computedValue); + C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends FloatingObjectConsolidateAction<DcpComputedValue, F, P, R, C> { @Override - default void accept(C context, F floatingObject) { - R adapter = context.getRequest(); - Set<P> parts = getParts(adapter); - DcpComputedValue computedValue = computeValue(adapter, parts); - setValue(floatingObject, computedValue); - } - - private DcpComputedValue computeValue(R adapter, Set<P> parts) { + default DcpComputedValue computeValue(C context, R adapter, Set<P> parts) { if (parts.isEmpty()) { return null; } @@ -76,22 +64,13 @@ public interface ComputeNonEntanglingAction<F extends DataDto & FloatingObjectAw final class WhenArriving<F extends DataDto & FloatingObjectAware, P extends DataDto & FloatingObjectPartAware, R extends FloatingObjectConsolidateRequestSupport<F, P>, - C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeNonEntanglingAction<F, P, R, C> { - @Override - public boolean test(C context, F floatingObject) { - return floatingObject.getObjectOperation().isWhenArriving(); - } + C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeNonEntanglingConsolidateAction<F, P, R, C>, WhenArrivingConsolidateAction<DcpComputedValue, F, P, R, C> { @Override public String fieldName() { return FloatingObjectDto.PROPERTY_COMPUTED_WHEN_ARRIVING_NON_ENTANGLING; } - @Override - public Set<P> getParts(R adapter) { - return adapter.getWhenArriving(); - } - @Override public void setValue(F floatingObject, DcpComputedValue computedValue) { floatingObject.setComputedWhenArrivingNonEntangling(computedValue); @@ -101,22 +80,13 @@ public interface ComputeNonEntanglingAction<F extends DataDto & FloatingObjectAw final class WhenLeaving<F extends DataDto & FloatingObjectAware, P extends DataDto & FloatingObjectPartAware, R extends FloatingObjectConsolidateRequestSupport<F, P>, - C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeNonEntanglingAction<F, P, R, C> { - @Override - public boolean test(C context, F floatingObject) { - return floatingObject.getObjectOperation().isWhenLeaving(); - } + C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeNonEntanglingConsolidateAction<F, P, R, C>, WhenLeavingConsolidateAction<DcpComputedValue, F, P, R, C> { @Override public String fieldName() { return FloatingObjectDto.PROPERTY_COMPUTED_WHEN_LEAVING_NON_ENTANGLING; } - @Override - public Set<P> getParts(R adapter) { - return adapter.getWhenLeaving(); - } - @Override public void setValue(F floatingObject, DcpComputedValue computedValue) { floatingObject.setComputedWhenLeavingNonEntangling(computedValue); ===================================== core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/ComputeSimplifiedObjectTypeAction.java → core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/ComputeSimplifiedObjectTypeConsolidateAction.java ===================================== @@ -22,7 +22,6 @@ package fr.ird.observe.consolidation.data.ps.dcp; * #L% */ -import fr.ird.observe.consolidation.AtomicConsolidateAction; import fr.ird.observe.dto.data.DataDto; import fr.ird.observe.dto.data.ps.FloatingObjectAware; import fr.ird.observe.dto.data.ps.FloatingObjectPartAware; @@ -37,49 +36,30 @@ import java.util.stream.Collectors; * @author Tony Chemit - dev@tchemit.fr * @since 9.0.26 */ -public interface ComputeSimplifiedObjectTypeAction<F extends DataDto & FloatingObjectAware, +public interface ComputeSimplifiedObjectTypeConsolidateAction<F extends DataDto & FloatingObjectAware, P extends DataDto & FloatingObjectPartAware, R extends FloatingObjectConsolidateRequestSupport<F, P>, - C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends AtomicConsolidateAction<C, F> { - Set<P> getParts(R adapter); - - void setValue(F floatingObject, String computedValue); + C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends FloatingObjectConsolidateAction<String, F, P, R, C> { @Override - default void accept(C context, F floatingObject) { - R adapter = context.getRequest(); - Set<P> parts = getParts(adapter); - String computedValue = computeValue(context.getSimplifiedObjectTypeManager(), adapter, parts); - setValue(floatingObject, computedValue); - } - - private String computeValue(SimplifiedObjectTypeManager simplifiedObjectTypeManager, R adapter, Set<P> parts) { + default String computeValue(C context, R adapter, Set<P> parts) { if (parts.isEmpty()) { return null; } Set<String> objectMaterialIds = parts.stream().map(adapter::getObjectMaterialId).collect(Collectors.toSet()); - return simplifiedObjectTypeManager.getStandardCode(objectMaterialIds); + return context.getSimplifiedObjectTypeManager().getStandardCode(objectMaterialIds); } final class WhenArriving<F extends DataDto & FloatingObjectAware, P extends DataDto & FloatingObjectPartAware, R extends FloatingObjectConsolidateRequestSupport<F, P>, - C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeSimplifiedObjectTypeAction<F, P, R, C> { - @Override - public boolean test(C context, F floatingObject) { - return floatingObject.getObjectOperation().isWhenArriving(); - } + C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeSimplifiedObjectTypeConsolidateAction<F, P, R, C>, WhenArrivingConsolidateAction<String, F, P, R, C> { @Override public String fieldName() { return FloatingObjectDto.PROPERTY_COMPUTED_WHEN_ARRIVING_SIMPLIFIED_OBJECT_TYPE; } - @Override - public Set<P> getParts(R adapter) { - return adapter.getWhenArriving(); - } - @Override public void setValue(F floatingObject, String computedValue) { floatingObject.setComputedWhenArrivingSimplifiedObjectType(computedValue); @@ -89,22 +69,13 @@ public interface ComputeSimplifiedObjectTypeAction<F extends DataDto & FloatingO final class WhenLeaving<F extends DataDto & FloatingObjectAware, P extends DataDto & FloatingObjectPartAware, R extends FloatingObjectConsolidateRequestSupport<F, P>, - C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeSimplifiedObjectTypeAction<F, P, R, C> { - @Override - public boolean test(C context, F floatingObject) { - return floatingObject.getObjectOperation().isWhenLeaving(); - } + C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeSimplifiedObjectTypeConsolidateAction<F, P, R, C>, WhenLeavingConsolidateAction<String, F, P, R, C> { @Override public String fieldName() { return FloatingObjectDto.PROPERTY_COMPUTED_WHEN_LEAVING_SIMPLIFIED_OBJECT_TYPE; } - @Override - public Set<P> getParts(R adapter) { - return adapter.getWhenLeaving(); - } - @Override public void setValue(F floatingObject, String computedValue) { floatingObject.setComputedWhenLeavingSimplifiedObjectType(computedValue); ===================================== core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/FloatingObjectConsolidateAction.java ===================================== @@ -0,0 +1,97 @@ +package fr.ird.observe.consolidation.data.ps.dcp; + +/*- + * #%L + * ObServe Core :: API :: Dto Consolidation + * %% + * 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% + */ + +import fr.ird.observe.consolidation.AtomicConsolidateAction; +import fr.ird.observe.dto.data.DataDto; +import fr.ird.observe.dto.data.ps.FloatingObjectAware; +import fr.ird.observe.dto.data.ps.FloatingObjectPartAware; + +import java.util.Set; + +/** + * Created on 09/03/2023. + * + * @author Tony Chemit - dev@tchemit.fr + * @since 9.0.27 + */ +public interface FloatingObjectConsolidateAction< + V, + F extends DataDto & FloatingObjectAware, + P extends DataDto & FloatingObjectPartAware, + R extends FloatingObjectConsolidateRequestSupport<F, P>, + C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends AtomicConsolidateAction<C, F> { + + Set<P> getParts(R adapter); + + void setValue(F floatingObject, V computedValue); + + V computeValue(C context, R adapter, Set<P> parts); + + @Override + default void accept(C context, F floatingObject) { + R adapter = context.getRequest(); + Set<P> parts = getParts(adapter); + if (parts.isEmpty()) { + return; + } + V computedValue = computeValue(context, adapter, parts); + setValue(floatingObject, computedValue); + } + + interface WhenArrivingConsolidateAction< + V, + F extends DataDto & FloatingObjectAware, + P extends DataDto & FloatingObjectPartAware, + R extends FloatingObjectConsolidateRequestSupport<F, P>, + C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends FloatingObjectConsolidateAction<V, F, P, R, C> { + + @Override + default boolean test(C context, F floatingObject) { + return floatingObject.getObjectOperation().isWhenArriving(); + } + + @Override + default Set<P> getParts(R adapter) { + return adapter.getWhenArriving(); + } + } + + interface WhenLeavingConsolidateAction< + V, + F extends DataDto & FloatingObjectAware, + P extends DataDto & FloatingObjectPartAware, + R extends FloatingObjectConsolidateRequestSupport<F, P>, + C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends FloatingObjectConsolidateAction<V, F, P, R, C> { + + @Override + default boolean test(C context, F floatingObject) { + return floatingObject.getObjectOperation().isWhenLeaving(); + } + + @Override + default Set<P> getParts(R adapter) { + return adapter.getWhenLeaving(); + } + } +} ===================================== core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/FloatingObjectConsolidateEngineSupport.java ===================================== @@ -22,6 +22,7 @@ package fr.ird.observe.consolidation.data.ps.dcp; * #L% */ +import fr.ird.observe.consolidation.AtomicConsolidateAction; import fr.ird.observe.decoration.DecoratorService; import fr.ird.observe.dto.ToolkitIdModifications; import fr.ird.observe.dto.data.DataDto; @@ -89,17 +90,17 @@ public abstract class FloatingObjectConsolidateEngineSupport< } } - protected abstract ComputeSimplifiedObjectTypeAction.WhenArriving<F, P, R, C> computeSimplifiedObjectTypeWhenArrivingAction(); + protected abstract AtomicConsolidateAction<C, F> computeSimplifiedObjectTypeWhenArrivingAction(); - protected abstract ComputeSimplifiedObjectTypeAction.WhenLeaving<F, P, R, C> computeSimplifiedObjectTypeWhenLeavingAction(); + protected abstract AtomicConsolidateAction<C, F> computeSimplifiedObjectTypeWhenLeavingAction(); - protected abstract ComputeBiodegradableAction.WhenArriving<F, P, R, C> computeBiodegradableWhenArrivingAction(); + protected abstract AtomicConsolidateAction<C, F> computeBiodegradableWhenArrivingAction(); - protected abstract ComputeBiodegradableAction.WhenLeaving<F, P, R, C> computeBiodegradableWhenLeavingAction(); + protected abstract AtomicConsolidateAction<C, F> computeBiodegradableWhenLeavingAction(); - protected abstract ComputeNonEntanglingAction.WhenArriving<F, P, R, C> computeNonEntanglingWhenArrivingAction(); + protected abstract AtomicConsolidateAction<C, F> computeNonEntanglingWhenArrivingAction(); - protected abstract ComputeNonEntanglingAction.WhenLeaving<F, P, R, C> computeNonEntanglingWhenLeavingAction(); + protected abstract AtomicConsolidateAction<C, F> computeNonEntanglingWhenLeavingAction(); public SimplifiedObjectTypeManager getSimplifiedObjectTypeManager() { return simplifiedObjectTypeManager; ===================================== core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/localmarket/BatchConsolidateActions.java ===================================== @@ -131,10 +131,13 @@ public enum BatchConsolidateActions implements AtomicConsolidateAction<BatchCons return BatchDto.PROPERTY_WEIGHT; } + @Override + public String extraFieldName() { + return BatchDto.PROPERTY_WEIGHT_COMPUTED_SOURCE; + } @Override - public void logModification(BatchConsolidateContext context, BatchDto data) { - AtomicConsolidateAction.super.logModification(context, data); - AtomicConsolidateAction.super.logModification(context, data, BatchDto.PROPERTY_WEIGHT_COMPUTED_SOURCE); + public String toString() { + return BatchConsolidateActions.class.getSimpleName() + "." + name(); } } ===================================== core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/localmarket/BatchConsolidateContext.java ===================================== @@ -60,6 +60,8 @@ public class BatchConsolidateContext implements ConsolidateContext<BatchDto> { this.request = Objects.requireNonNull(request); this.batch = Objects.requireNonNull(request.getBatch()); monitor.setBean(batch); + batch.setWeight(null); + batch.setWeightComputedSource(null); } public Optional<ToolkitIdModifications> build() { ===================================== core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/localmarket/BatchConsolidateEngine.java ===================================== @@ -51,29 +51,35 @@ public class BatchConsolidateEngine { public Optional<ToolkitIdModifications> consolidate(BatchConsolidateRequest request) { BatchDto dto = request.getBatch(); - // the only thing we can consolidate is the batch.weight + // the only thing we can consolidate is batch.weight if (dto.getWeight() != null && dto.getWeightComputedSource() == null) { // the value was set by user, do not change any thing return Optional.empty(); } - context.watch(request); + Optional<ToolkitIdModifications> result = consolidate(context, request, dto); + result.ifPresent(r -> { + if (r.withModifications()) { + log.info(String.format("Found some modifications on batch: %s", request.getBatch().getId())); + } + if (r.withWarnings()) { + log.warn(String.format("Found some warnings on batch: %s", request.getBatch().getId())); + } + }); + return result; + } + + private Optional<ToolkitIdModifications> consolidate(BatchConsolidateContext context, BatchConsolidateRequest request, BatchDto dto) { + context.watch(request); try { - if (!BatchConsolidateActions.ComputeWeightFromSpeciesMeanWeight.execute(context, dto)) { - if (!BatchConsolidateActions.ComputeWeightFromPackagingMeanWeight.execute(context, dto)) { - BatchConsolidateActions.ResetWeightValues.execute(context, dto); - } + if (BatchConsolidateActions.ComputeWeightFromSpeciesMeanWeight.execute(context, dto)) { + return context.build(); + } + if (BatchConsolidateActions.ComputeWeightFromPackagingMeanWeight.execute(context, dto)) { + return context.build(); } - Optional<ToolkitIdModifications> result = context.build(); - result.ifPresent(r -> { - if (r.withModifications()) { - log.info(String.format("Found some modifications on batch: %s", request.getBatch().getId())); - } - if (r.withWarnings()) { - log.warn(String.format("Found some warnings on batch: %s", request.getBatch().getId())); - } - }); - return result; + BatchConsolidateActions.ResetWeightValues.execute(context, dto); + return context.build(); } finally { context.clear(); } ===================================== core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/logbook/FloatingObjectActions.java ===================================== @@ -0,0 +1,80 @@ +package fr.ird.observe.consolidation.data.ps.logbook; + +/*- + * #%L + * ObServe Core :: API :: Dto Consolidation + * %% + * 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% + */ + +import fr.ird.observe.consolidation.AtomicConsolidateAction; +import fr.ird.observe.consolidation.data.ps.dcp.ComputeBiodegradableConsolidateAction; +import fr.ird.observe.consolidation.data.ps.dcp.ComputeNonEntanglingConsolidateAction; +import fr.ird.observe.consolidation.data.ps.dcp.ComputeSimplifiedObjectTypeConsolidateAction; +import fr.ird.observe.consolidation.data.ps.dcp.FloatingObjectConsolidateAction; +import fr.ird.observe.dto.data.ps.logbook.FloatingObjectDto; +import fr.ird.observe.dto.data.ps.logbook.FloatingObjectPartDto; + +/** + * Created on 09/03/2023. + * + * @author Tony Chemit - dev@tchemit.fr + * @since 9.0.27 + */ +public enum FloatingObjectActions implements AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> { + + ComputeBiodegradableWhenArriving(new ComputeBiodegradableConsolidateAction.WhenArriving<>()), + ComputeBiodegradableWhenLeaving(new ComputeBiodegradableConsolidateAction.WhenLeaving<>()), + + ComputeNonEntanglingWhenArriving(new ComputeNonEntanglingConsolidateAction.WhenArriving<>()), + ComputeNonEntanglingWhenLeaving(new ComputeNonEntanglingConsolidateAction.WhenLeaving<>()), + + ComputeSimplifiedObjectTypeWhenArriving(new ComputeSimplifiedObjectTypeConsolidateAction.WhenArriving<>()), + ComputeSimplifiedObjectTypeWhenLeaving(new ComputeSimplifiedObjectTypeConsolidateAction.WhenLeaving<>()); + + private final FloatingObjectConsolidateAction<?, FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> action; + + FloatingObjectActions(FloatingObjectConsolidateAction<?, FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> action) { + this.action = action; + } + + @Override + public String fieldName() { + return action.fieldName(); + } + + @Override + public String extraFieldName() { + return action.extraFieldName(); + } + + @Override + public void accept(FloatingObjectConsolidateContext floatingObjectConsolidateContext, FloatingObjectDto floatingObjectDto) { + action.accept(floatingObjectConsolidateContext, floatingObjectDto); + } + + @Override + public boolean test(FloatingObjectConsolidateContext floatingObjectConsolidateContext, FloatingObjectDto floatingObjectDto) { + return action.test(floatingObjectConsolidateContext, floatingObjectDto); + } + + @Override + public String toString() { + return FloatingObjectActions.class.getSimpleName() + "." + name(); + } +} ===================================== core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/logbook/FloatingObjectConsolidateEngine.java ===================================== @@ -22,9 +22,7 @@ package fr.ird.observe.consolidation.data.ps.logbook; * #L% */ -import fr.ird.observe.consolidation.data.ps.dcp.ComputeBiodegradableAction; -import fr.ird.observe.consolidation.data.ps.dcp.ComputeNonEntanglingAction; -import fr.ird.observe.consolidation.data.ps.dcp.ComputeSimplifiedObjectTypeAction; +import fr.ird.observe.consolidation.AtomicConsolidateAction; import fr.ird.observe.consolidation.data.ps.dcp.FloatingObjectConsolidateEngineSupport; import fr.ird.observe.consolidation.data.ps.dcp.SimplifiedObjectTypeManager; import fr.ird.observe.decoration.DecoratorService; @@ -39,13 +37,6 @@ import fr.ird.observe.dto.data.ps.logbook.FloatingObjectPartDto; */ public class FloatingObjectConsolidateEngine extends FloatingObjectConsolidateEngineSupport<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> { - public static final ComputeBiodegradableAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_BIODEGRADABLE_WHEN_ARRIVING_ACTION = new ComputeBiodegradableAction.WhenArriving<>(); - public static final ComputeBiodegradableAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_BIODEGRADABLE_WHEN_LEAVING_ACTION = new ComputeBiodegradableAction.WhenLeaving<>(); - public static final ComputeNonEntanglingAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_NON_ENTANGLING_WHEN_ARRIVING_ACTION = new ComputeNonEntanglingAction.WhenArriving<>(); - public static final ComputeNonEntanglingAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_NON_ENTANGLING_WHEN_LEAVING_ACTION = new ComputeNonEntanglingAction.WhenLeaving<>(); - public static final ComputeSimplifiedObjectTypeAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_ARRIVING_ACTION = new ComputeSimplifiedObjectTypeAction.WhenArriving<>(); - public static final ComputeSimplifiedObjectTypeAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_LEAVING_ACTION = new ComputeSimplifiedObjectTypeAction.WhenLeaving<>(); - public FloatingObjectConsolidateEngine(SimplifiedObjectTypeManager simplifiedObjectTypeManager, DecoratorService decoratorService) { super(simplifiedObjectTypeManager, FloatingObjectDto.class, decoratorService); } @@ -56,32 +47,32 @@ public class FloatingObjectConsolidateEngine extends FloatingObjectConsolidateEn } @Override - protected ComputeSimplifiedObjectTypeAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeSimplifiedObjectTypeWhenArrivingAction() { - return COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_ARRIVING_ACTION; + protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeSimplifiedObjectTypeWhenArrivingAction() { + return FloatingObjectActions.ComputeSimplifiedObjectTypeWhenArriving; } @Override - protected ComputeSimplifiedObjectTypeAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeSimplifiedObjectTypeWhenLeavingAction() { - return COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_LEAVING_ACTION; + protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeSimplifiedObjectTypeWhenLeavingAction() { + return FloatingObjectActions.ComputeSimplifiedObjectTypeWhenLeaving; } @Override - protected ComputeBiodegradableAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeBiodegradableWhenArrivingAction() { - return COMPUTE_BIODEGRADABLE_WHEN_ARRIVING_ACTION; + protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeBiodegradableWhenArrivingAction() { + return FloatingObjectActions.ComputeBiodegradableWhenArriving; } @Override - protected ComputeBiodegradableAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeBiodegradableWhenLeavingAction() { - return COMPUTE_BIODEGRADABLE_WHEN_LEAVING_ACTION; + protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeBiodegradableWhenLeavingAction() { + return FloatingObjectActions.ComputeBiodegradableWhenLeaving; } @Override - protected ComputeNonEntanglingAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeNonEntanglingWhenArrivingAction() { - return COMPUTE_NON_ENTANGLING_WHEN_ARRIVING_ACTION; + protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeNonEntanglingWhenArrivingAction() { + return FloatingObjectActions.ComputeNonEntanglingWhenArriving; } @Override - protected ComputeNonEntanglingAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeNonEntanglingWhenLeavingAction() { - return COMPUTE_NON_ENTANGLING_WHEN_LEAVING_ACTION; + protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeNonEntanglingWhenLeavingAction() { + return FloatingObjectActions.ComputeNonEntanglingWhenLeaving; } } ===================================== core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/observation/FloatingObjectActions.java ===================================== @@ -0,0 +1,80 @@ +package fr.ird.observe.consolidation.data.ps.observation; + +/*- + * #%L + * ObServe Core :: API :: Dto Consolidation + * %% + * 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% + */ + +import fr.ird.observe.consolidation.AtomicConsolidateAction; +import fr.ird.observe.consolidation.data.ps.dcp.ComputeBiodegradableConsolidateAction; +import fr.ird.observe.consolidation.data.ps.dcp.ComputeNonEntanglingConsolidateAction; +import fr.ird.observe.consolidation.data.ps.dcp.ComputeSimplifiedObjectTypeConsolidateAction; +import fr.ird.observe.consolidation.data.ps.dcp.FloatingObjectConsolidateAction; +import fr.ird.observe.dto.data.ps.observation.FloatingObjectDto; +import fr.ird.observe.dto.data.ps.observation.FloatingObjectPartDto; + +/** + * Created on 09/03/2023. + * + * @author Tony Chemit - dev@tchemit.fr + * @since 9.0.27 + */ +public enum FloatingObjectActions implements AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> { + + ComputeBiodegradableWhenArriving(new ComputeBiodegradableConsolidateAction.WhenArriving<>()), + ComputeBiodegradableWhenLeaving(new ComputeBiodegradableConsolidateAction.WhenLeaving<>()), + + ComputeNonEntanglingWhenArriving(new ComputeNonEntanglingConsolidateAction.WhenArriving<>()), + ComputeNonEntanglingWhenLeaving(new ComputeNonEntanglingConsolidateAction.WhenLeaving<>()), + + ComputeSimplifiedObjectTypeWhenArriving(new ComputeSimplifiedObjectTypeConsolidateAction.WhenArriving<>()), + ComputeSimplifiedObjectTypeWhenLeaving(new ComputeSimplifiedObjectTypeConsolidateAction.WhenLeaving<>()); + + private final FloatingObjectConsolidateAction<?, FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> action; + + FloatingObjectActions(FloatingObjectConsolidateAction<?, FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> action) { + this.action = action; + } + + @Override + public String fieldName() { + return action.fieldName(); + } + + @Override + public String extraFieldName() { + return action.extraFieldName(); + } + + @Override + public void accept(FloatingObjectConsolidateContext floatingObjectConsolidateContext, FloatingObjectDto floatingObjectDto) { + action.accept(floatingObjectConsolidateContext, floatingObjectDto); + } + + @Override + public boolean test(FloatingObjectConsolidateContext floatingObjectConsolidateContext, FloatingObjectDto floatingObjectDto) { + return action.test(floatingObjectConsolidateContext, floatingObjectDto); + } + + @Override + public String toString() { + return FloatingObjectActions.class.getSimpleName() + "." + name(); + } +} ===================================== core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/observation/FloatingObjectConsolidateEngine.java ===================================== @@ -22,9 +22,7 @@ package fr.ird.observe.consolidation.data.ps.observation; * #L% */ -import fr.ird.observe.consolidation.data.ps.dcp.ComputeBiodegradableAction; -import fr.ird.observe.consolidation.data.ps.dcp.ComputeNonEntanglingAction; -import fr.ird.observe.consolidation.data.ps.dcp.ComputeSimplifiedObjectTypeAction; +import fr.ird.observe.consolidation.AtomicConsolidateAction; import fr.ird.observe.consolidation.data.ps.dcp.FloatingObjectConsolidateEngineSupport; import fr.ird.observe.consolidation.data.ps.dcp.SimplifiedObjectTypeManager; import fr.ird.observe.decoration.DecoratorService; @@ -39,13 +37,6 @@ import fr.ird.observe.dto.data.ps.observation.FloatingObjectPartDto; */ public class FloatingObjectConsolidateEngine extends FloatingObjectConsolidateEngineSupport<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> { - public static final ComputeBiodegradableAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_BIODEGRADABLE_WHEN_ARRIVING_ACTION = new ComputeBiodegradableAction.WhenArriving<>(); - public static final ComputeBiodegradableAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_BIODEGRADABLE_WHEN_LEAVING_ACTION = new ComputeBiodegradableAction.WhenLeaving<>(); - public static final ComputeNonEntanglingAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_NON_ENTANGLING_WHEN_ARRIVING_ACTION = new ComputeNonEntanglingAction.WhenArriving<>(); - public static final ComputeNonEntanglingAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_NON_ENTANGLING_WHEN_LEAVING_ACTION = new ComputeNonEntanglingAction.WhenLeaving<>(); - public static final ComputeSimplifiedObjectTypeAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_ARRIVING_ACTION = new ComputeSimplifiedObjectTypeAction.WhenArriving<>(); - public static final ComputeSimplifiedObjectTypeAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_LEAVING_ACTION = new ComputeSimplifiedObjectTypeAction.WhenLeaving<>(); - public FloatingObjectConsolidateEngine(SimplifiedObjectTypeManager simplifiedObjectTypeManager, DecoratorService decoratorService) { super(simplifiedObjectTypeManager, FloatingObjectDto.class, decoratorService); } @@ -56,32 +47,32 @@ public class FloatingObjectConsolidateEngine extends FloatingObjectConsolidateEn } @Override - protected ComputeSimplifiedObjectTypeAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeSimplifiedObjectTypeWhenArrivingAction() { - return COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_ARRIVING_ACTION; + protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeSimplifiedObjectTypeWhenArrivingAction() { + return FloatingObjectActions.ComputeSimplifiedObjectTypeWhenArriving; } @Override - protected ComputeSimplifiedObjectTypeAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeSimplifiedObjectTypeWhenLeavingAction() { - return COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_LEAVING_ACTION; + protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeSimplifiedObjectTypeWhenLeavingAction() { + return FloatingObjectActions.ComputeSimplifiedObjectTypeWhenLeaving; } @Override - protected ComputeBiodegradableAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeBiodegradableWhenArrivingAction() { - return COMPUTE_BIODEGRADABLE_WHEN_ARRIVING_ACTION; + protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeBiodegradableWhenArrivingAction() { + return FloatingObjectActions.ComputeBiodegradableWhenArriving; } @Override - protected ComputeBiodegradableAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeBiodegradableWhenLeavingAction() { - return COMPUTE_BIODEGRADABLE_WHEN_LEAVING_ACTION; + protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeBiodegradableWhenLeavingAction() { + return FloatingObjectActions.ComputeBiodegradableWhenLeaving; } @Override - protected ComputeNonEntanglingAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeNonEntanglingWhenArrivingAction() { - return COMPUTE_NON_ENTANGLING_WHEN_ARRIVING_ACTION; + protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeNonEntanglingWhenArrivingAction() { + return FloatingObjectActions.ComputeNonEntanglingWhenArriving; } @Override - protected ComputeNonEntanglingAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeNonEntanglingWhenLeavingAction() { - return COMPUTE_NON_ENTANGLING_WHEN_LEAVING_ACTION; + protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeNonEntanglingWhenLeavingAction() { + return FloatingObjectActions.ComputeNonEntanglingWhenLeaving; } } ===================================== core/persistence/consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/observation/CatchConsolidateActions.java ===================================== @@ -47,6 +47,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons return Catch.PROPERTY_MEAN_LENGTH; } + @Override + public String extraFieldName() { + return Catch.PROPERTY_MEAN_LENGTH_COMPUTED_SOURCE; + } + @Override public boolean test(CatchConsolidateContext context, Catch aCatch) { return context.withLengthWeightParameter() @@ -74,6 +79,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons return Catch.PROPERTY_MEAN_WEIGHT; } + @Override + public String extraFieldName() { + return Catch.PROPERTY_MEAN_WEIGHT_COMPUTED_SOURCE; + } + @Override public boolean test(CatchConsolidateContext context, Catch aCatch) { return context.withLengthWeightParameter() @@ -103,6 +113,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons return Catch.PROPERTY_CATCH_WEIGHT; } + @Override + public String extraFieldName() { + return Catch.PROPERTY_CATCH_WEIGHT_COMPUTED_SOURCE; + } + @Override public boolean test(CatchConsolidateContext context, Catch aCatch) { return aCatch.withoutCatchWeight() @@ -130,6 +145,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons return Catch.PROPERTY_TOTAL_COUNT; } + @Override + public String extraFieldName() { + return Catch.PROPERTY_TOTAL_COUNT_COMPUTED_SOURCE; + } + @Override public boolean test(CatchConsolidateContext context, Catch aCatch) { return aCatch.withoutTotalCount() @@ -160,6 +180,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons return Catch.PROPERTY_MEAN_WEIGHT; } + @Override + public String extraFieldName() { + return Catch.PROPERTY_MEAN_WEIGHT_COMPUTED_SOURCE; + } + @Override public boolean test(CatchConsolidateContext context, Catch aCatch) { return aCatch.withoutMeanWeight() @@ -187,6 +212,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons return Catch.PROPERTY_MEAN_LENGTH; } + @Override + public String extraFieldName() { + return Catch.PROPERTY_MEAN_LENGTH_COMPUTED_SOURCE; + } + @Override public boolean test(CatchConsolidateContext context, Catch aCatch) { return aCatch.withoutMeanLength() @@ -210,6 +240,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons return Catch.PROPERTY_MEAN_WEIGHT; } + @Override + public String extraFieldName() { + return Catch.PROPERTY_MEAN_WEIGHT_COMPUTED_SOURCE; + } + @Override public boolean test(CatchConsolidateContext context, Catch aCatch) { return aCatch.withoutMeanWeight() @@ -233,6 +268,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons return Catch.PROPERTY_MEAN_LENGTH; } + @Override + public String extraFieldName() { + return Catch.PROPERTY_MEAN_LENGTH_COMPUTED_SOURCE; + } + @Override public boolean test(CatchConsolidateContext context, Catch aCatch) { return context.withSampleMeasures() && aCatch.withoutMeanLength(); @@ -269,6 +309,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons return Catch.PROPERTY_TOTAL_COUNT; } + @Override + public String extraFieldName() { + return Catch.PROPERTY_TOTAL_COUNT_COMPUTED_SOURCE; + } + @Override public boolean test(CatchConsolidateContext context, Catch aCatch) { return context.withSampleMeasures() && aCatch.withoutTotalCount(); @@ -312,4 +357,9 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons } }; + + @Override + public String toString() { + return CatchConsolidateActions.class.getSimpleName() + "." + name(); + } } ===================================== core/persistence/consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/observation/SampleConsolidateActions.java ===================================== @@ -47,6 +47,11 @@ public enum SampleConsolidateActions implements AtomicConsolidateAction<SampleCo return SampleMeasure.PROPERTY_LENGTH; } + @Override + public String extraFieldName() { + return SampleMeasure.PROPERTY_IS_LENGTH_COMPUTED; + } + @Override public boolean test(SampleConsolidateContext context, SampleMeasure sampleMeasure) { return sampleMeasure.getLength() == null @@ -58,7 +63,6 @@ public enum SampleConsolidateActions implements AtomicConsolidateAction<SampleCo public void accept(SampleConsolidateContext context, SampleMeasure sampleMeasure) { LengthWeightParameter lengthWeightParameter = context.getLengthWeightParameter(); Float weight = sampleMeasure.getWeight(); - Float length = lengthWeightParameter.computeFromFormulaTwo(weight); if (length != null) { sampleMeasure.setLength(length); @@ -77,6 +81,11 @@ public enum SampleConsolidateActions implements AtomicConsolidateAction<SampleCo return SampleMeasure.PROPERTY_WEIGHT; } + @Override + public String extraFieldName() { + return SampleMeasure.PROPERTY_IS_WEIGHT_COMPUTED; + } + @Override public boolean test(SampleConsolidateContext context, SampleMeasure sampleMeasure) { boolean canExecute = sampleMeasure.getWeight() == null @@ -98,12 +107,14 @@ public enum SampleConsolidateActions implements AtomicConsolidateAction<SampleCo Float length = sampleMeasure.getLength(); SizeMeasureType inputSizeMeasureType = sampleMeasure.getSizeMeasureType(); LengthWeightParameter lengthWeightParameter = context.getLengthWeightParameter(); - SizeMeasureType outputSizeMeasureType = lengthWeightParameter.getSizeMeasureType(); if (!Objects.equals(inputSizeMeasureType, outputSizeMeasureType)) { // execute length conversion before applying the RTP LengthLengthParameter lengthLengthParameter = context.getLengthLengthParameter(); length = lengthLengthParameter.computeFromFormulaOne(length); + if (length == null) { + return; + } } Float weight = lengthWeightParameter.computeFromFormulaOne(length); if (weight != null) { @@ -112,5 +123,10 @@ public enum SampleConsolidateActions implements AtomicConsolidateAction<SampleCo } } }; + + @Override + public String toString() { + return SampleConsolidateActions.class.getSimpleName() + "." + name(); + } } ===================================== pom.xml ===================================== @@ -23,7 +23,7 @@ <parent> <groupId>io.ultreia.maven</groupId> <artifactId>pom</artifactId> - <version>2023.10</version> + <version>2023.11</version> </parent> <groupId>fr.ird.observe</groupId> <artifactId>ird-observe</artifactId> @@ -128,6 +128,7 @@ <!-- FIXME <lib.version.jts>1.18.2</lib.version.jts>--> <lib.version.hsqldb>2.7.0</lib.version.hsqldb> <!-- FIXME <lib.version.hsqldb>2.7.1</lib.version.hsqldb>--> + <lib.version.java4all.java-lang>2.0.5</lib.version.java4all.java-lang> <!-- license header configuration --> <license.licenseName>gpl_v3</license.licenseName> <license.organizationName>IRD, Ultreia.io</license.organizationName> @@ -1277,6 +1278,7 @@ <reports> <report>dependency-updates-report</report> <report>plugin-updates-report</report> + <report>property-updates-report</report> </reports> </reportSet> </reportSets> ===================================== toolkit/api-validation/src/main/java/fr/ird/observe/validation/validators/collection/AbstractCollectionUniqueKeyValidator.java ===================================== @@ -23,7 +23,9 @@ package fr.ird.observe.validation.validators.collection; */ import com.opensymphony.xwork2.validator.ValidationException; +import fr.ird.observe.decoration.DecoratorService; import fr.ird.observe.dto.IdDto; +import io.ultreia.java4all.decoration.Decorated; import org.nuiton.validator.xwork2.field.NuitonFieldValidatorSupport; import java.util.Collection; @@ -49,6 +51,7 @@ public abstract class AbstractCollectionUniqueKeyValidator<O> extends NuitonFiel * To keep the first index in collection that breaks unique rule (used in error message). */ protected int firstBadIndex; + protected String firstBadRow; protected abstract String computeUniqueKey(O collectionValue); @@ -56,7 +59,7 @@ public abstract class AbstractCollectionUniqueKeyValidator<O> extends NuitonFiel public abstract String getValidatorType(); protected AbstractCollectionUniqueKeyValidator(String validationMessageKey) { - setDefaultMessage(validationMessageKey + "##${firstBadIndex}"); + setDefaultMessage(validationMessageKey + "##${firstBadIndex} (${firstBadRow})"); } @Override @@ -75,10 +78,17 @@ public abstract class AbstractCollectionUniqueKeyValidator<O> extends NuitonFiel if (!uniqueKeys.add(uniqueKey)) { // found a duplicated entry firstBadIndex = uniqueKeys.size() + 1; + Decorated decorated = (Decorated) collectionValue; + if (decorated.decorator().isEmpty()) { + DecoratorService decoratorService = (DecoratorService) stack.findValue("decoratorService"); + decoratorService.installDecorator(decorated); + } + firstBadRow = collectionValue.toString(); addFieldError(fieldName, object); return; } } + } finally { uniqueKeys.clear(); } @@ -93,10 +103,16 @@ public abstract class AbstractCollectionUniqueKeyValidator<O> extends NuitonFiel return (Collection<O>) fieldValue; } + @SuppressWarnings("unused") public int getFirstBadIndex() { return firstBadIndex; } + @SuppressWarnings("unused") + public String getFirstBadRow() { + return firstBadRow; + } + protected void addComponentValue(StringBuilder builder, IdDto value) { builder.append("|").append(Optional.ofNullable(value).map(IdDto::getId).orElse("null")); } View it on GitLab: https://gitlab.com/ultreiaio/ird-observe/-/compare/18d65252ceaff46122987b93b... -- View it on GitLab: https://gitlab.com/ultreiaio/ird-observe/-/compare/18d65252ceaff46122987b93b... You're receiving this email because of your account on gitlab.com.