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

Commits:

17 changed files:

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
    41 41
    42 42 
         Logger log = LogManager.getLogger(AtomicConsolidateAction.class);
    43 43
    44 
    +    /**
    45 
    +     * @return the field name on which action may compute the value.
    46 
    +     */
    44 47 
         String fieldName();
    45 48
    49 
    +    /**
    50 
    +     * @return extra field name on which action may have change also the value (for {@code computedSource} fields).
    51 
    +     */
    52 
    +    default String extraFieldName() {
    53 
    +        return null;
    54 
    +    }
    55 
    +
    46 56 
         /**
    47 57 
          * Test if this action can be executed, and if so, then execute it.
    48 58 
          *
    ... ... @@ -59,13 +69,16 @@ public interface AtomicConsolidateAction<C extends ConsolidateContext<E>, E exte
    59 69 
             return false;
    60 70 
         }
    61 71
    62 
    -
    63 
    -    default void logModification(C context, E data) {
    72 
    +    private void logModification(C context, E data) {
    64 73 
             String fieldName = fieldName();
    65 74 
             logModification(context, data, fieldName);
    75 
    +        String extraFieldName = extraFieldName();
    76 
    +        if (extraFieldName != null) {
    77 
    +            logModification(context, data, extraFieldName);
    78 
    +        }
    66 79 
         }
    67 80
    68 
    -    default void logModification(C context, E data, String fieldName) {
    81 
    +    private void logModification(C context, E data, String fieldName) {
    69 82 
             context.getModification(fieldName).ifPresent(modification -> log.info(String.format("[%s] property '%s.%s' has changed [old value: %s - new value: %s] (by action %s)",
    70 83 
                                                                                                 data.getTopiaId(),
    71 84 
                                                                                                 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;
    22 22 
      * #L%
    23 23 
      */
    24 24
    25 
    -import fr.ird.observe.consolidation.AtomicConsolidateAction;
    26 25 
     import fr.ird.observe.dto.data.DataDto;
    27 26 
     import fr.ird.observe.dto.data.ps.DcpComputedValue;
    28 27 
     import fr.ird.observe.dto.data.ps.FloatingObjectAware;
    ... ... @@ -37,24 +36,13 @@ import java.util.Set;
    37 36 
      * @author Tony Chemit - dev@tchemit.fr
    38 37 
      * @since 9.0.26
    39 38 
      */
    40 
    -public interface ComputeBiodegradableAction<F extends DataDto & FloatingObjectAware,
    39 
    +public interface ComputeBiodegradableConsolidateAction<F extends DataDto & FloatingObjectAware,
    41 40 
             P extends DataDto & FloatingObjectPartAware,
    42 41 
             R extends FloatingObjectConsolidateRequestSupport<F, P>,
    43 
    -        C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends AtomicConsolidateAction<C, F> {
    44 
    -
    45 
    -     Set<P> getParts(R adapter);
    46 
    -
    47 
    -     void setValue(F floatingObject, DcpComputedValue computedValue);
    42 
    +        C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends FloatingObjectConsolidateAction<DcpComputedValue, F, P, R, C> {
    48 43
    49 44 
         @Override
    50 
    -    default void accept(C context, F floatingObject) {
    51 
    -        R adapter = context.getRequest();
    52 
    -        Set<P> parts = getParts(adapter);
    53 
    -        DcpComputedValue computedValue = computeValue(adapter, parts);
    54 
    -        setValue(floatingObject, computedValue);
    55 
    -    }
    56 
    -
    57 
    -    private DcpComputedValue computeValue(R adapter, Set<P> parts) {
    45 
    +    default DcpComputedValue computeValue(C context, R adapter, Set<P> parts) {
    58 46 
             if (parts.isEmpty()) {
    59 47 
                 return null;
    60 48 
             }
    ... ... @@ -73,26 +61,16 @@ public interface ComputeBiodegradableAction<F extends DataDto & FloatingObjectAw
    73 61 
             return result;
    74 62 
         }
    75 63
    76 
    -   final  class WhenArriving<F extends DataDto & FloatingObjectAware,
    64 
    +    final class WhenArriving<F extends DataDto & FloatingObjectAware,
    77 65 
                 P extends DataDto & FloatingObjectPartAware,
    78 66 
                 R extends FloatingObjectConsolidateRequestSupport<F, P>,
    79 
    -            C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeBiodegradableAction<F, P, R, C> {
    80 
    -
    81 
    -        @Override
    82 
    -        public boolean test(C context, F floatingObject) {
    83 
    -            return floatingObject.getObjectOperation().isWhenArriving();
    84 
    -        }
    67 
    +            C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeBiodegradableConsolidateAction<F, P, R, C>, WhenArrivingConsolidateAction<DcpComputedValue, F, P, R, C> {
    85 68
    86 69 
             @Override
    87 70 
             public String fieldName() {
    88 71 
                 return FloatingObjectDto.PROPERTY_COMPUTED_WHEN_ARRIVING_BIODEGRADABLE;
    89 72 
             }
    90 73
    91 
    -        @Override
    92 
    -        public Set<P> getParts(R adapter) {
    93 
    -            return adapter.getWhenArriving();
    94 
    -        }
    95 
    -
    96 74 
             @Override
    97 75 
             public void setValue(F floatingObject, DcpComputedValue computedValue) {
    98 76 
                 floatingObject.setComputedWhenArrivingBiodegradable(computedValue);
    ... ... @@ -102,12 +80,7 @@ public interface ComputeBiodegradableAction<F extends DataDto & FloatingObjectAw
    102 80 
         final class WhenLeaving<F extends DataDto & FloatingObjectAware,
    103 81 
                 P extends DataDto & FloatingObjectPartAware,
    104 82 
                 R extends FloatingObjectConsolidateRequestSupport<F, P>,
    105 
    -            C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeBiodegradableAction<F, P, R, C> {
    106 
    -
    107 
    -        @Override
    108 
    -        public boolean test(C context, F floatingObject) {
    109 
    -            return floatingObject.getObjectOperation().isWhenLeaving();
    110 
    -        }
    83 
    +            C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeBiodegradableConsolidateAction<F, P, R, C>, WhenLeavingConsolidateAction<DcpComputedValue, F, P, R, C> {
    111 84
    112 85 
             @Override
    113 86 
             public String fieldName() {
    ... ... @@ -118,10 +91,5 @@ public interface ComputeBiodegradableAction<F extends DataDto & FloatingObjectAw
    118 91 
             public void setValue(F floatingObject, DcpComputedValue computedValue) {
    119 92 
                 floatingObject.setComputedWhenLeavingBiodegradable(computedValue);
    120 93 
             }
    121 
    -
    122 
    -        @Override
    123 
    -        public Set<P> getParts(R adapter) {
    124 
    -            return adapter.getWhenLeaving();
    125 
    -        }
    126 94 
         }
    127 95 
     }

  • 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;
    22 22 
      * #L%
    23 23 
      */
    24 24
    25 
    -import fr.ird.observe.consolidation.AtomicConsolidateAction;
    26 25 
     import fr.ird.observe.dto.data.DataDto;
    27 26 
     import fr.ird.observe.dto.data.ps.DcpComputedValue;
    28 27 
     import fr.ird.observe.dto.data.ps.FloatingObjectAware;
    ... ... @@ -37,24 +36,13 @@ import java.util.Set;
    37 36 
      * @author Tony Chemit - dev@tchemit.fr
    38 37 
      * @since 9.0.26
    39 38 
      */
    40 
    -public interface ComputeNonEntanglingAction<F extends DataDto & FloatingObjectAware,
    39 
    +public interface ComputeNonEntanglingConsolidateAction<F extends DataDto & FloatingObjectAware,
    41 40 
             P extends DataDto & FloatingObjectPartAware,
    42 41 
             R extends FloatingObjectConsolidateRequestSupport<F, P>,
    43 
    -        C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends AtomicConsolidateAction<C, F> {
    44 
    -
    45 
    -    Set<P> getParts(R adapter);
    46 
    -
    47 
    -    void setValue(F floatingObject, DcpComputedValue computedValue);
    42 
    +        C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends FloatingObjectConsolidateAction<DcpComputedValue, F, P, R, C> {
    48 43
    49 44 
         @Override
    50 
    -    default void accept(C context, F floatingObject) {
    51 
    -        R adapter = context.getRequest();
    52 
    -        Set<P> parts = getParts(adapter);
    53 
    -        DcpComputedValue computedValue = computeValue(adapter, parts);
    54 
    -        setValue(floatingObject, computedValue);
    55 
    -    }
    56 
    -
    57 
    -    private DcpComputedValue computeValue(R adapter, Set<P> parts) {
    45 
    +    default DcpComputedValue computeValue(C context, R adapter, Set<P> parts) {
    58 46 
             if (parts.isEmpty()) {
    59 47 
                 return null;
    60 48 
             }
    ... ... @@ -76,22 +64,13 @@ public interface ComputeNonEntanglingAction<F extends DataDto & FloatingObjectAw
    76 64 
         final class WhenArriving<F extends DataDto & FloatingObjectAware,
    77 65 
                 P extends DataDto & FloatingObjectPartAware,
    78 66 
                 R extends FloatingObjectConsolidateRequestSupport<F, P>,
    79 
    -            C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeNonEntanglingAction<F, P, R, C> {
    80 
    -        @Override
    81 
    -        public boolean test(C context, F floatingObject) {
    82 
    -            return floatingObject.getObjectOperation().isWhenArriving();
    83 
    -        }
    67 
    +            C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeNonEntanglingConsolidateAction<F, P, R, C>, WhenArrivingConsolidateAction<DcpComputedValue, F, P, R, C> {
    84 68
    85 69 
             @Override
    86 70 
             public String fieldName() {
    87 71 
                 return FloatingObjectDto.PROPERTY_COMPUTED_WHEN_ARRIVING_NON_ENTANGLING;
    88 72 
             }
    89 73
    90 
    -        @Override
    91 
    -        public Set<P> getParts(R adapter) {
    92 
    -            return adapter.getWhenArriving();
    93 
    -        }
    94 
    -
    95 74 
             @Override
    96 75 
             public void setValue(F floatingObject, DcpComputedValue computedValue) {
    97 76 
                 floatingObject.setComputedWhenArrivingNonEntangling(computedValue);
    ... ... @@ -101,22 +80,13 @@ public interface ComputeNonEntanglingAction<F extends DataDto & FloatingObjectAw
    101 80 
         final class WhenLeaving<F extends DataDto & FloatingObjectAware,
    102 81 
                 P extends DataDto & FloatingObjectPartAware,
    103 82 
                 R extends FloatingObjectConsolidateRequestSupport<F, P>,
    104 
    -            C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeNonEntanglingAction<F, P, R, C> {
    105 
    -        @Override
    106 
    -        public boolean test(C context, F floatingObject) {
    107 
    -            return floatingObject.getObjectOperation().isWhenLeaving();
    108 
    -        }
    83 
    +            C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeNonEntanglingConsolidateAction<F, P, R, C>, WhenLeavingConsolidateAction<DcpComputedValue, F, P, R, C> {
    109 84
    110 85 
             @Override
    111 86 
             public String fieldName() {
    112 87 
                 return FloatingObjectDto.PROPERTY_COMPUTED_WHEN_LEAVING_NON_ENTANGLING;
    113 88 
             }
    114 89
    115 
    -        @Override
    116 
    -        public Set<P> getParts(R adapter) {
    117 
    -            return adapter.getWhenLeaving();
    118 
    -        }
    119 
    -
    120 90 
             @Override
    121 91 
             public void setValue(F floatingObject, DcpComputedValue computedValue) {
    122 92 
                 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;
    22 22 
      * #L%
    23 23 
      */
    24 24
    25 
    -import fr.ird.observe.consolidation.AtomicConsolidateAction;
    26 25 
     import fr.ird.observe.dto.data.DataDto;
    27 26 
     import fr.ird.observe.dto.data.ps.FloatingObjectAware;
    28 27 
     import fr.ird.observe.dto.data.ps.FloatingObjectPartAware;
    ... ... @@ -37,49 +36,30 @@ import java.util.stream.Collectors;
    37 36 
      * @author Tony Chemit - dev@tchemit.fr
    38 37 
      * @since 9.0.26
    39 38 
      */
    40 
    -public interface ComputeSimplifiedObjectTypeAction<F extends DataDto & FloatingObjectAware,
    39 
    +public interface ComputeSimplifiedObjectTypeConsolidateAction<F extends DataDto & FloatingObjectAware,
    41 40 
             P extends DataDto & FloatingObjectPartAware,
    42 41 
             R extends FloatingObjectConsolidateRequestSupport<F, P>,
    43 
    -        C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends AtomicConsolidateAction<C, F> {
    44 
    -    Set<P> getParts(R adapter);
    45 
    -
    46 
    -    void setValue(F floatingObject, String computedValue);
    42 
    +        C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends FloatingObjectConsolidateAction<String, F, P, R, C> {
    47 43
    48 44 
         @Override
    49 
    -    default void accept(C context, F floatingObject) {
    50 
    -        R adapter = context.getRequest();
    51 
    -        Set<P> parts = getParts(adapter);
    52 
    -        String computedValue = computeValue(context.getSimplifiedObjectTypeManager(), adapter, parts);
    53 
    -        setValue(floatingObject, computedValue);
    54 
    -    }
    55 
    -
    56 
    -    private String computeValue(SimplifiedObjectTypeManager simplifiedObjectTypeManager, R adapter, Set<P> parts) {
    45 
    +    default String computeValue(C context, R adapter, Set<P> parts) {
    57 46 
             if (parts.isEmpty()) {
    58 47 
                 return null;
    59 48 
             }
    60 49 
             Set<String> objectMaterialIds = parts.stream().map(adapter::getObjectMaterialId).collect(Collectors.toSet());
    61 
    -        return simplifiedObjectTypeManager.getStandardCode(objectMaterialIds);
    50 
    +        return context.getSimplifiedObjectTypeManager().getStandardCode(objectMaterialIds);
    62 51 
         }
    63 52
    64 53 
         final class WhenArriving<F extends DataDto & FloatingObjectAware,
    65 54 
                 P extends DataDto & FloatingObjectPartAware,
    66 55 
                 R extends FloatingObjectConsolidateRequestSupport<F, P>,
    67 
    -            C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeSimplifiedObjectTypeAction<F, P, R, C> {
    68 
    -        @Override
    69 
    -        public boolean test(C context, F floatingObject) {
    70 
    -            return floatingObject.getObjectOperation().isWhenArriving();
    71 
    -        }
    56 
    +            C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeSimplifiedObjectTypeConsolidateAction<F, P, R, C>, WhenArrivingConsolidateAction<String, F, P, R, C> {
    72 57
    73 58 
             @Override
    74 59 
             public String fieldName() {
    75 60 
                 return FloatingObjectDto.PROPERTY_COMPUTED_WHEN_ARRIVING_SIMPLIFIED_OBJECT_TYPE;
    76 61 
             }
    77 62
    78 
    -        @Override
    79 
    -        public Set<P> getParts(R adapter) {
    80 
    -            return adapter.getWhenArriving();
    81 
    -        }
    82 
    -
    83 63 
             @Override
    84 64 
             public void setValue(F floatingObject, String computedValue) {
    85 65 
                 floatingObject.setComputedWhenArrivingSimplifiedObjectType(computedValue);
    ... ... @@ -89,22 +69,13 @@ public interface ComputeSimplifiedObjectTypeAction<F extends DataDto & FloatingO
    89 69 
         final class WhenLeaving<F extends DataDto & FloatingObjectAware,
    90 70 
                 P extends DataDto & FloatingObjectPartAware,
    91 71 
                 R extends FloatingObjectConsolidateRequestSupport<F, P>,
    92 
    -            C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeSimplifiedObjectTypeAction<F, P, R, C> {
    93 
    -        @Override
    94 
    -        public boolean test(C context, F floatingObject) {
    95 
    -            return floatingObject.getObjectOperation().isWhenLeaving();
    96 
    -        }
    72 
    +            C extends FloatingObjectConsolidateContextSupport<F, P, R>> implements ComputeSimplifiedObjectTypeConsolidateAction<F, P, R, C>, WhenLeavingConsolidateAction<String, F, P, R, C> {
    97 73
    98 74 
             @Override
    99 75 
             public String fieldName() {
    100 76 
                 return FloatingObjectDto.PROPERTY_COMPUTED_WHEN_LEAVING_SIMPLIFIED_OBJECT_TYPE;
    101 77 
             }
    102 78
    103 
    -        @Override
    104 
    -        public Set<P> getParts(R adapter) {
    105 
    -            return adapter.getWhenLeaving();
    106 
    -        }
    107 
    -
    108 79 
             @Override
    109 80 
             public void setValue(F floatingObject, String computedValue) {
    110 81 
                 floatingObject.setComputedWhenLeavingSimplifiedObjectType(computedValue);

  • core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/dcp/FloatingObjectConsolidateAction.java
    1 
    +package fr.ird.observe.consolidation.data.ps.dcp;
    2 
    +
    3 
    +/*-
    4 
    + * #%L
    5 
    + * ObServe Core :: API :: Dto Consolidation
    6 
    + * %%
    7 
    + * Copyright (C) 2008 - 2023 IRD, Ultreia.io
    8 
    + * %%
    9 
    + * This program is free software: you can redistribute it and/or modify
    10 
    + * it under the terms of the GNU General Public License as
    11 
    + * published by the Free Software Foundation, either version 3 of the
    12 
    + * License, or (at your option) any later version.
    13 
    + *
    14 
    + * This program is distributed in the hope that it will be useful,
    15 
    + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    16 
    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17 
    + * GNU General Public License for more details.
    18 
    + *
    19 
    + * You should have received a copy of the GNU General Public
    20 
    + * License along with this program.  If not, see
    21 
    + * <http://www.gnu.org/licenses/gpl-3.0.html>.
    22 
    + * #L%
    23 
    + */
    24 
    +
    25 
    +import fr.ird.observe.consolidation.AtomicConsolidateAction;
    26 
    +import fr.ird.observe.dto.data.DataDto;
    27 
    +import fr.ird.observe.dto.data.ps.FloatingObjectAware;
    28 
    +import fr.ird.observe.dto.data.ps.FloatingObjectPartAware;
    29 
    +
    30 
    +import java.util.Set;
    31 
    +
    32 
    +/**
    33 
    + * Created on 09/03/2023.
    34 
    + *
    35 
    + * @author Tony Chemit - dev@tchemit.fr
    36 
    + * @since 9.0.27
    37 
    + */
    38 
    +public interface FloatingObjectConsolidateAction<
    39 
    +        V,
    40 
    +        F extends DataDto & FloatingObjectAware,
    41 
    +        P extends DataDto & FloatingObjectPartAware,
    42 
    +        R extends FloatingObjectConsolidateRequestSupport<F, P>,
    43 
    +        C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends AtomicConsolidateAction<C, F> {
    44 
    +
    45 
    +    Set<P> getParts(R adapter);
    46 
    +
    47 
    +    void setValue(F floatingObject, V computedValue);
    48 
    +
    49 
    +    V computeValue(C context, R adapter, Set<P> parts);
    50 
    +
    51 
    +    @Override
    52 
    +    default void accept(C context, F floatingObject) {
    53 
    +        R adapter = context.getRequest();
    54 
    +        Set<P> parts = getParts(adapter);
    55 
    +        if (parts.isEmpty()) {
    56 
    +            return;
    57 
    +        }
    58 
    +        V computedValue = computeValue(context, adapter, parts);
    59 
    +        setValue(floatingObject, computedValue);
    60 
    +    }
    61 
    +
    62 
    +    interface WhenArrivingConsolidateAction<
    63 
    +            V,
    64 
    +            F extends DataDto & FloatingObjectAware,
    65 
    +            P extends DataDto & FloatingObjectPartAware,
    66 
    +            R extends FloatingObjectConsolidateRequestSupport<F, P>,
    67 
    +            C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends FloatingObjectConsolidateAction<V, F, P, R, C> {
    68 
    +
    69 
    +        @Override
    70 
    +        default boolean test(C context, F floatingObject) {
    71 
    +            return floatingObject.getObjectOperation().isWhenArriving();
    72 
    +        }
    73 
    +
    74 
    +        @Override
    75 
    +        default Set<P> getParts(R adapter) {
    76 
    +            return adapter.getWhenArriving();
    77 
    +        }
    78 
    +    }
    79 
    +
    80 
    +    interface WhenLeavingConsolidateAction<
    81 
    +            V,
    82 
    +            F extends DataDto & FloatingObjectAware,
    83 
    +            P extends DataDto & FloatingObjectPartAware,
    84 
    +            R extends FloatingObjectConsolidateRequestSupport<F, P>,
    85 
    +            C extends FloatingObjectConsolidateContextSupport<F, P, R>> extends FloatingObjectConsolidateAction<V, F, P, R, C> {
    86 
    +
    87 
    +        @Override
    88 
    +        default boolean test(C context, F floatingObject) {
    89 
    +            return floatingObject.getObjectOperation().isWhenLeaving();
    90 
    +        }
    91 
    +
    92 
    +        @Override
    93 
    +        default Set<P> getParts(R adapter) {
    94 
    +            return adapter.getWhenLeaving();
    95 
    +        }
    96 
    +    }
    97 
    +}

  • 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;
    22 22 
      * #L%
    23 23 
      */
    24 24
    25 
    +import fr.ird.observe.consolidation.AtomicConsolidateAction;
    25 26 
     import fr.ird.observe.decoration.DecoratorService;
    26 27 
     import fr.ird.observe.dto.ToolkitIdModifications;
    27 28 
     import fr.ird.observe.dto.data.DataDto;
    ... ... @@ -89,17 +90,17 @@ public abstract class FloatingObjectConsolidateEngineSupport<
    89 90 
             }
    90 91 
         }
    91 92
    92 
    -    protected abstract ComputeSimplifiedObjectTypeAction.WhenArriving<F, P, R, C> computeSimplifiedObjectTypeWhenArrivingAction();
    93 
    +    protected abstract AtomicConsolidateAction<C, F> computeSimplifiedObjectTypeWhenArrivingAction();
    93 94
    94 
    -    protected abstract ComputeSimplifiedObjectTypeAction.WhenLeaving<F, P, R, C> computeSimplifiedObjectTypeWhenLeavingAction();
    95 
    +    protected abstract AtomicConsolidateAction<C, F> computeSimplifiedObjectTypeWhenLeavingAction();
    95 96
    96 
    -    protected abstract ComputeBiodegradableAction.WhenArriving<F, P, R, C> computeBiodegradableWhenArrivingAction();
    97 
    +    protected abstract AtomicConsolidateAction<C, F> computeBiodegradableWhenArrivingAction();
    97 98
    98 
    -    protected abstract ComputeBiodegradableAction.WhenLeaving<F, P, R, C> computeBiodegradableWhenLeavingAction();
    99 
    +    protected abstract AtomicConsolidateAction<C, F> computeBiodegradableWhenLeavingAction();
    99 100
    100 
    -    protected abstract ComputeNonEntanglingAction.WhenArriving<F, P, R, C> computeNonEntanglingWhenArrivingAction();
    101 
    +    protected abstract AtomicConsolidateAction<C, F> computeNonEntanglingWhenArrivingAction();
    101 102
    102 
    -    protected abstract ComputeNonEntanglingAction.WhenLeaving<F, P, R, C> computeNonEntanglingWhenLeavingAction();
    103 
    +    protected abstract AtomicConsolidateAction<C, F> computeNonEntanglingWhenLeavingAction();
    103 104
    104 105 
         public SimplifiedObjectTypeManager getSimplifiedObjectTypeManager() {
    105 106 
             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
    131 131 
             return BatchDto.PROPERTY_WEIGHT;
    132 132 
         }
    133 133
    134 
    +    @Override
    135 
    +    public String extraFieldName() {
    136 
    +        return BatchDto.PROPERTY_WEIGHT_COMPUTED_SOURCE;
    137 
    +    }
    134 138
    135 139 
         @Override
    136 
    -    public void logModification(BatchConsolidateContext context, BatchDto data) {
    137 
    -        AtomicConsolidateAction.super.logModification(context, data);
    138 
    -        AtomicConsolidateAction.super.logModification(context, data, BatchDto.PROPERTY_WEIGHT_COMPUTED_SOURCE);
    140 
    +    public String toString() {
    141 
    +        return BatchConsolidateActions.class.getSimpleName() + "." + name();
    139 142 
         }
    140 143 
     }

  • 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> {
    60 60 
             this.request = Objects.requireNonNull(request);
    61 61 
             this.batch = Objects.requireNonNull(request.getBatch());
    62 62 
             monitor.setBean(batch);
    63 
    +        batch.setWeight(null);
    64 
    +        batch.setWeightComputedSource(null);
    63 65 
         }
    64 66
    65 67 
         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 {
    51 51 
         public Optional<ToolkitIdModifications> consolidate(BatchConsolidateRequest request) {
    52 52 
             BatchDto dto = request.getBatch();
    53 53
    54 
    -        // the only thing we can consolidate is the batch.weight
    54 
    +        // the only thing we can consolidate is batch.weight
    55 55 
             if (dto.getWeight() != null && dto.getWeightComputedSource() == null) {
    56 56 
                 // the value was set by user, do not change any thing
    57 57 
                 return Optional.empty();
    58 58 
             }
    59 
    -        context.watch(request);
    60 59
    60 
    +        Optional<ToolkitIdModifications> result = consolidate(context, request, dto);
    61 
    +        result.ifPresent(r -> {
    62 
    +            if (r.withModifications()) {
    63 
    +                log.info(String.format("Found some modifications on batch: %s", request.getBatch().getId()));
    64 
    +            }
    65 
    +            if (r.withWarnings()) {
    66 
    +                log.warn(String.format("Found some warnings on batch: %s", request.getBatch().getId()));
    67 
    +            }
    68 
    +        });
    69 
    +        return result;
    70 
    +    }
    71 
    +
    72 
    +    private Optional<ToolkitIdModifications> consolidate(BatchConsolidateContext context, BatchConsolidateRequest request, BatchDto dto) {
    73 
    +        context.watch(request);
    61 74 
             try {
    62 
    -            if (!BatchConsolidateActions.ComputeWeightFromSpeciesMeanWeight.execute(context, dto)) {
    63 
    -                if (!BatchConsolidateActions.ComputeWeightFromPackagingMeanWeight.execute(context, dto)) {
    64 
    -                    BatchConsolidateActions.ResetWeightValues.execute(context, dto);
    65 
    -                }
    75 
    +            if (BatchConsolidateActions.ComputeWeightFromSpeciesMeanWeight.execute(context, dto)) {
    76 
    +                return context.build();
    77 
    +            }
    78 
    +            if (BatchConsolidateActions.ComputeWeightFromPackagingMeanWeight.execute(context, dto)) {
    79 
    +                return context.build();
    66 80 
                 }
    67 
    -            Optional<ToolkitIdModifications> result = context.build();
    68 
    -            result.ifPresent(r -> {
    69 
    -                if (r.withModifications()) {
    70 
    -                    log.info(String.format("Found some modifications on batch: %s", request.getBatch().getId()));
    71 
    -                }
    72 
    -                if (r.withWarnings()) {
    73 
    -                    log.warn(String.format("Found some warnings on batch: %s", request.getBatch().getId()));
    74 
    -                }
    75 
    -            });
    76 
    -            return result;
    81 
    +            BatchConsolidateActions.ResetWeightValues.execute(context, dto);
    82 
    +            return context.build();
    77 83 
             } finally {
    78 84 
                 context.clear();
    79 85 
             }

  • core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/logbook/FloatingObjectActions.java
    1 
    +package fr.ird.observe.consolidation.data.ps.logbook;
    2 
    +
    3 
    +/*-
    4 
    + * #%L
    5 
    + * ObServe Core :: API :: Dto Consolidation
    6 
    + * %%
    7 
    + * Copyright (C) 2008 - 2023 IRD, Ultreia.io
    8 
    + * %%
    9 
    + * This program is free software: you can redistribute it and/or modify
    10 
    + * it under the terms of the GNU General Public License as
    11 
    + * published by the Free Software Foundation, either version 3 of the
    12 
    + * License, or (at your option) any later version.
    13 
    + *
    14 
    + * This program is distributed in the hope that it will be useful,
    15 
    + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    16 
    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17 
    + * GNU General Public License for more details.
    18 
    + *
    19 
    + * You should have received a copy of the GNU General Public
    20 
    + * License along with this program.  If not, see
    21 
    + * <http://www.gnu.org/licenses/gpl-3.0.html>.
    22 
    + * #L%
    23 
    + */
    24 
    +
    25 
    +import fr.ird.observe.consolidation.AtomicConsolidateAction;
    26 
    +import fr.ird.observe.consolidation.data.ps.dcp.ComputeBiodegradableConsolidateAction;
    27 
    +import fr.ird.observe.consolidation.data.ps.dcp.ComputeNonEntanglingConsolidateAction;
    28 
    +import fr.ird.observe.consolidation.data.ps.dcp.ComputeSimplifiedObjectTypeConsolidateAction;
    29 
    +import fr.ird.observe.consolidation.data.ps.dcp.FloatingObjectConsolidateAction;
    30 
    +import fr.ird.observe.dto.data.ps.logbook.FloatingObjectDto;
    31 
    +import fr.ird.observe.dto.data.ps.logbook.FloatingObjectPartDto;
    32 
    +
    33 
    +/**
    34 
    + * Created on 09/03/2023.
    35 
    + *
    36 
    + * @author Tony Chemit - dev@tchemit.fr
    37 
    + * @since 9.0.27
    38 
    + */
    39 
    +public enum FloatingObjectActions implements AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> {
    40 
    +
    41 
    +    ComputeBiodegradableWhenArriving(new ComputeBiodegradableConsolidateAction.WhenArriving<>()),
    42 
    +    ComputeBiodegradableWhenLeaving(new ComputeBiodegradableConsolidateAction.WhenLeaving<>()),
    43 
    +
    44 
    +    ComputeNonEntanglingWhenArriving(new ComputeNonEntanglingConsolidateAction.WhenArriving<>()),
    45 
    +    ComputeNonEntanglingWhenLeaving(new ComputeNonEntanglingConsolidateAction.WhenLeaving<>()),
    46 
    +
    47 
    +    ComputeSimplifiedObjectTypeWhenArriving(new ComputeSimplifiedObjectTypeConsolidateAction.WhenArriving<>()),
    48 
    +    ComputeSimplifiedObjectTypeWhenLeaving(new ComputeSimplifiedObjectTypeConsolidateAction.WhenLeaving<>());
    49 
    +
    50 
    +    private final FloatingObjectConsolidateAction<?, FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> action;
    51 
    +
    52 
    +    FloatingObjectActions(FloatingObjectConsolidateAction<?, FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> action) {
    53 
    +        this.action = action;
    54 
    +    }
    55 
    +
    56 
    +    @Override
    57 
    +    public String fieldName() {
    58 
    +        return action.fieldName();
    59 
    +    }
    60 
    +
    61 
    +    @Override
    62 
    +    public String extraFieldName() {
    63 
    +        return action.extraFieldName();
    64 
    +    }
    65 
    +
    66 
    +    @Override
    67 
    +    public void accept(FloatingObjectConsolidateContext floatingObjectConsolidateContext, FloatingObjectDto floatingObjectDto) {
    68 
    +        action.accept(floatingObjectConsolidateContext, floatingObjectDto);
    69 
    +    }
    70 
    +
    71 
    +    @Override
    72 
    +    public boolean test(FloatingObjectConsolidateContext floatingObjectConsolidateContext, FloatingObjectDto floatingObjectDto) {
    73 
    +        return action.test(floatingObjectConsolidateContext, floatingObjectDto);
    74 
    +    }
    75 
    +
    76 
    +    @Override
    77 
    +    public String toString() {
    78 
    +        return FloatingObjectActions.class.getSimpleName() + "." + name();
    79 
    +    }
    80 
    +}

  • 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;
    22 22 
      * #L%
    23 23 
      */
    24 24
    25 
    -import fr.ird.observe.consolidation.data.ps.dcp.ComputeBiodegradableAction;
    26 
    -import fr.ird.observe.consolidation.data.ps.dcp.ComputeNonEntanglingAction;
    27 
    -import fr.ird.observe.consolidation.data.ps.dcp.ComputeSimplifiedObjectTypeAction;
    25 
    +import fr.ird.observe.consolidation.AtomicConsolidateAction;
    28 26 
     import fr.ird.observe.consolidation.data.ps.dcp.FloatingObjectConsolidateEngineSupport;
    29 27 
     import fr.ird.observe.consolidation.data.ps.dcp.SimplifiedObjectTypeManager;
    30 28 
     import fr.ird.observe.decoration.DecoratorService;
    ... ... @@ -39,13 +37,6 @@ import fr.ird.observe.dto.data.ps.logbook.FloatingObjectPartDto;
    39 37 
      */
    40 38 
     public class FloatingObjectConsolidateEngine extends FloatingObjectConsolidateEngineSupport<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> {
    41 39
    42 
    -    public static final ComputeBiodegradableAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_BIODEGRADABLE_WHEN_ARRIVING_ACTION = new ComputeBiodegradableAction.WhenArriving<>();
    43 
    -    public static final ComputeBiodegradableAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_BIODEGRADABLE_WHEN_LEAVING_ACTION = new ComputeBiodegradableAction.WhenLeaving<>();
    44 
    -    public static final ComputeNonEntanglingAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_NON_ENTANGLING_WHEN_ARRIVING_ACTION = new ComputeNonEntanglingAction.WhenArriving<>();
    45 
    -    public static final ComputeNonEntanglingAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_NON_ENTANGLING_WHEN_LEAVING_ACTION = new ComputeNonEntanglingAction.WhenLeaving<>();
    46 
    -    public static final ComputeSimplifiedObjectTypeAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_ARRIVING_ACTION = new ComputeSimplifiedObjectTypeAction.WhenArriving<>();
    47 
    -    public static final ComputeSimplifiedObjectTypeAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_LEAVING_ACTION = new ComputeSimplifiedObjectTypeAction.WhenLeaving<>();
    48 
    -
    49 40 
         public FloatingObjectConsolidateEngine(SimplifiedObjectTypeManager simplifiedObjectTypeManager, DecoratorService decoratorService) {
    50 41 
             super(simplifiedObjectTypeManager, FloatingObjectDto.class, decoratorService);
    51 42 
         }
    ... ... @@ -56,32 +47,32 @@ public class FloatingObjectConsolidateEngine extends FloatingObjectConsolidateEn
    56 47 
         }
    57 48
    58 49 
         @Override
    59 
    -    protected ComputeSimplifiedObjectTypeAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeSimplifiedObjectTypeWhenArrivingAction() {
    60 
    -        return COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_ARRIVING_ACTION;
    50 
    +    protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeSimplifiedObjectTypeWhenArrivingAction() {
    51 
    +        return FloatingObjectActions.ComputeSimplifiedObjectTypeWhenArriving;
    61 52 
         }
    62 53
    63 54 
         @Override
    64 
    -    protected ComputeSimplifiedObjectTypeAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeSimplifiedObjectTypeWhenLeavingAction() {
    65 
    -        return COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_LEAVING_ACTION;
    55 
    +    protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeSimplifiedObjectTypeWhenLeavingAction() {
    56 
    +        return FloatingObjectActions.ComputeSimplifiedObjectTypeWhenLeaving;
    66 57 
         }
    67 58
    68 59 
         @Override
    69 
    -    protected ComputeBiodegradableAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeBiodegradableWhenArrivingAction() {
    70 
    -        return COMPUTE_BIODEGRADABLE_WHEN_ARRIVING_ACTION;
    60 
    +    protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeBiodegradableWhenArrivingAction() {
    61 
    +        return FloatingObjectActions.ComputeBiodegradableWhenArriving;
    71 62 
         }
    72 63
    73 64 
         @Override
    74 
    -    protected ComputeBiodegradableAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeBiodegradableWhenLeavingAction() {
    75 
    -        return COMPUTE_BIODEGRADABLE_WHEN_LEAVING_ACTION;
    65 
    +    protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeBiodegradableWhenLeavingAction() {
    66 
    +        return FloatingObjectActions.ComputeBiodegradableWhenLeaving;
    76 67 
         }
    77 68
    78 69 
         @Override
    79 
    -    protected ComputeNonEntanglingAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeNonEntanglingWhenArrivingAction() {
    80 
    -        return COMPUTE_NON_ENTANGLING_WHEN_ARRIVING_ACTION;
    70 
    +    protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeNonEntanglingWhenArrivingAction() {
    71 
    +        return FloatingObjectActions.ComputeNonEntanglingWhenArriving;
    81 72 
         }
    82 73
    83 74 
         @Override
    84 
    -    protected ComputeNonEntanglingAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeNonEntanglingWhenLeavingAction() {
    85 
    -        return COMPUTE_NON_ENTANGLING_WHEN_LEAVING_ACTION;
    75 
    +    protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeNonEntanglingWhenLeavingAction() {
    76 
    +        return FloatingObjectActions.ComputeNonEntanglingWhenLeaving;
    86 77 
         }
    87 78 
     }

  • core/api/dto-consolidation/src/main/java/fr/ird/observe/consolidation/data/ps/observation/FloatingObjectActions.java
    1 
    +package fr.ird.observe.consolidation.data.ps.observation;
    2 
    +
    3 
    +/*-
    4 
    + * #%L
    5 
    + * ObServe Core :: API :: Dto Consolidation
    6 
    + * %%
    7 
    + * Copyright (C) 2008 - 2023 IRD, Ultreia.io
    8 
    + * %%
    9 
    + * This program is free software: you can redistribute it and/or modify
    10 
    + * it under the terms of the GNU General Public License as
    11 
    + * published by the Free Software Foundation, either version 3 of the
    12 
    + * License, or (at your option) any later version.
    13 
    + *
    14 
    + * This program is distributed in the hope that it will be useful,
    15 
    + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    16 
    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17 
    + * GNU General Public License for more details.
    18 
    + *
    19 
    + * You should have received a copy of the GNU General Public
    20 
    + * License along with this program.  If not, see
    21 
    + * <http://www.gnu.org/licenses/gpl-3.0.html>.
    22 
    + * #L%
    23 
    + */
    24 
    +
    25 
    +import fr.ird.observe.consolidation.AtomicConsolidateAction;
    26 
    +import fr.ird.observe.consolidation.data.ps.dcp.ComputeBiodegradableConsolidateAction;
    27 
    +import fr.ird.observe.consolidation.data.ps.dcp.ComputeNonEntanglingConsolidateAction;
    28 
    +import fr.ird.observe.consolidation.data.ps.dcp.ComputeSimplifiedObjectTypeConsolidateAction;
    29 
    +import fr.ird.observe.consolidation.data.ps.dcp.FloatingObjectConsolidateAction;
    30 
    +import fr.ird.observe.dto.data.ps.observation.FloatingObjectDto;
    31 
    +import fr.ird.observe.dto.data.ps.observation.FloatingObjectPartDto;
    32 
    +
    33 
    +/**
    34 
    + * Created on 09/03/2023.
    35 
    + *
    36 
    + * @author Tony Chemit - dev@tchemit.fr
    37 
    + * @since 9.0.27
    38 
    + */
    39 
    +public enum FloatingObjectActions implements AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> {
    40 
    +
    41 
    +    ComputeBiodegradableWhenArriving(new ComputeBiodegradableConsolidateAction.WhenArriving<>()),
    42 
    +    ComputeBiodegradableWhenLeaving(new ComputeBiodegradableConsolidateAction.WhenLeaving<>()),
    43 
    +
    44 
    +    ComputeNonEntanglingWhenArriving(new ComputeNonEntanglingConsolidateAction.WhenArriving<>()),
    45 
    +    ComputeNonEntanglingWhenLeaving(new ComputeNonEntanglingConsolidateAction.WhenLeaving<>()),
    46 
    +
    47 
    +    ComputeSimplifiedObjectTypeWhenArriving(new ComputeSimplifiedObjectTypeConsolidateAction.WhenArriving<>()),
    48 
    +    ComputeSimplifiedObjectTypeWhenLeaving(new ComputeSimplifiedObjectTypeConsolidateAction.WhenLeaving<>());
    49 
    +
    50 
    +    private final FloatingObjectConsolidateAction<?, FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> action;
    51 
    +
    52 
    +    FloatingObjectActions(FloatingObjectConsolidateAction<?, FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> action) {
    53 
    +        this.action = action;
    54 
    +    }
    55 
    +
    56 
    +    @Override
    57 
    +    public String fieldName() {
    58 
    +        return action.fieldName();
    59 
    +    }
    60 
    +
    61 
    +    @Override
    62 
    +    public String extraFieldName() {
    63 
    +        return action.extraFieldName();
    64 
    +    }
    65 
    +
    66 
    +    @Override
    67 
    +    public void accept(FloatingObjectConsolidateContext floatingObjectConsolidateContext, FloatingObjectDto floatingObjectDto) {
    68 
    +        action.accept(floatingObjectConsolidateContext, floatingObjectDto);
    69 
    +    }
    70 
    +
    71 
    +    @Override
    72 
    +    public boolean test(FloatingObjectConsolidateContext floatingObjectConsolidateContext, FloatingObjectDto floatingObjectDto) {
    73 
    +        return action.test(floatingObjectConsolidateContext, floatingObjectDto);
    74 
    +    }
    75 
    +
    76 
    +    @Override
    77 
    +    public String toString() {
    78 
    +        return FloatingObjectActions.class.getSimpleName() + "." + name();
    79 
    +    }
    80 
    +}

  • 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;
    22 22 
      * #L%
    23 23 
      */
    24 24
    25 
    -import fr.ird.observe.consolidation.data.ps.dcp.ComputeBiodegradableAction;
    26 
    -import fr.ird.observe.consolidation.data.ps.dcp.ComputeNonEntanglingAction;
    27 
    -import fr.ird.observe.consolidation.data.ps.dcp.ComputeSimplifiedObjectTypeAction;
    25 
    +import fr.ird.observe.consolidation.AtomicConsolidateAction;
    28 26 
     import fr.ird.observe.consolidation.data.ps.dcp.FloatingObjectConsolidateEngineSupport;
    29 27 
     import fr.ird.observe.consolidation.data.ps.dcp.SimplifiedObjectTypeManager;
    30 28 
     import fr.ird.observe.decoration.DecoratorService;
    ... ... @@ -39,13 +37,6 @@ import fr.ird.observe.dto.data.ps.observation.FloatingObjectPartDto;
    39 37 
      */
    40 38 
     public class FloatingObjectConsolidateEngine extends FloatingObjectConsolidateEngineSupport<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> {
    41 39
    42 
    -    public static final ComputeBiodegradableAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_BIODEGRADABLE_WHEN_ARRIVING_ACTION = new ComputeBiodegradableAction.WhenArriving<>();
    43 
    -    public static final ComputeBiodegradableAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_BIODEGRADABLE_WHEN_LEAVING_ACTION = new ComputeBiodegradableAction.WhenLeaving<>();
    44 
    -    public static final ComputeNonEntanglingAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_NON_ENTANGLING_WHEN_ARRIVING_ACTION = new ComputeNonEntanglingAction.WhenArriving<>();
    45 
    -    public static final ComputeNonEntanglingAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_NON_ENTANGLING_WHEN_LEAVING_ACTION = new ComputeNonEntanglingAction.WhenLeaving<>();
    46 
    -    public static final ComputeSimplifiedObjectTypeAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_ARRIVING_ACTION = new ComputeSimplifiedObjectTypeAction.WhenArriving<>();
    47 
    -    public static final ComputeSimplifiedObjectTypeAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_LEAVING_ACTION = new ComputeSimplifiedObjectTypeAction.WhenLeaving<>();
    48 
    -
    49 40 
         public FloatingObjectConsolidateEngine(SimplifiedObjectTypeManager simplifiedObjectTypeManager, DecoratorService decoratorService) {
    50 41 
             super(simplifiedObjectTypeManager, FloatingObjectDto.class, decoratorService);
    51 42 
         }
    ... ... @@ -56,32 +47,32 @@ public class FloatingObjectConsolidateEngine extends FloatingObjectConsolidateEn
    56 47 
         }
    57 48
    58 49 
         @Override
    59 
    -    protected ComputeSimplifiedObjectTypeAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeSimplifiedObjectTypeWhenArrivingAction() {
    60 
    -        return COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_ARRIVING_ACTION;
    50 
    +    protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeSimplifiedObjectTypeWhenArrivingAction() {
    51 
    +        return FloatingObjectActions.ComputeSimplifiedObjectTypeWhenArriving;
    61 52 
         }
    62 53
    63 54 
         @Override
    64 
    -    protected ComputeSimplifiedObjectTypeAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeSimplifiedObjectTypeWhenLeavingAction() {
    65 
    -        return COMPUTE_SIMPLIFIED_OBJECT_TYPE_WHEN_LEAVING_ACTION;
    55 
    +    protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeSimplifiedObjectTypeWhenLeavingAction() {
    56 
    +        return FloatingObjectActions.ComputeSimplifiedObjectTypeWhenLeaving;
    66 57 
         }
    67 58
    68 59 
         @Override
    69 
    -    protected ComputeBiodegradableAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeBiodegradableWhenArrivingAction() {
    70 
    -        return COMPUTE_BIODEGRADABLE_WHEN_ARRIVING_ACTION;
    60 
    +    protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeBiodegradableWhenArrivingAction() {
    61 
    +        return FloatingObjectActions.ComputeBiodegradableWhenArriving;
    71 62 
         }
    72 63
    73 64 
         @Override
    74 
    -    protected ComputeBiodegradableAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeBiodegradableWhenLeavingAction() {
    75 
    -        return COMPUTE_BIODEGRADABLE_WHEN_LEAVING_ACTION;
    65 
    +    protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeBiodegradableWhenLeavingAction() {
    66 
    +        return FloatingObjectActions.ComputeBiodegradableWhenLeaving;
    76 67 
         }
    77 68
    78 69 
         @Override
    79 
    -    protected ComputeNonEntanglingAction.WhenArriving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeNonEntanglingWhenArrivingAction() {
    80 
    -        return COMPUTE_NON_ENTANGLING_WHEN_ARRIVING_ACTION;
    70 
    +    protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeNonEntanglingWhenArrivingAction() {
    71 
    +        return FloatingObjectActions.ComputeNonEntanglingWhenArriving;
    81 72 
         }
    82 73
    83 74 
         @Override
    84 
    -    protected ComputeNonEntanglingAction.WhenLeaving<FloatingObjectDto, FloatingObjectPartDto, FloatingObjectConsolidateRequest, FloatingObjectConsolidateContext> computeNonEntanglingWhenLeavingAction() {
    85 
    -        return COMPUTE_NON_ENTANGLING_WHEN_LEAVING_ACTION;
    75 
    +    protected AtomicConsolidateAction<FloatingObjectConsolidateContext, FloatingObjectDto> computeNonEntanglingWhenLeavingAction() {
    76 
    +        return FloatingObjectActions.ComputeNonEntanglingWhenLeaving;
    86 77 
         }
    87 78 
     }

  • 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
    47 47 
                 return Catch.PROPERTY_MEAN_LENGTH;
    48 48 
             }
    49 49
    50 
    +        @Override
    51 
    +        public String extraFieldName() {
    52 
    +            return Catch.PROPERTY_MEAN_LENGTH_COMPUTED_SOURCE;
    53 
    +        }
    54 
    +
    50 55 
             @Override
    51 56 
             public boolean test(CatchConsolidateContext context, Catch aCatch) {
    52 57 
                 return context.withLengthWeightParameter()
    ... ... @@ -74,6 +79,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons
    74 79 
                 return Catch.PROPERTY_MEAN_WEIGHT;
    75 80 
             }
    76 81
    82 
    +        @Override
    83 
    +        public String extraFieldName() {
    84 
    +            return Catch.PROPERTY_MEAN_WEIGHT_COMPUTED_SOURCE;
    85 
    +        }
    86 
    +
    77 87 
             @Override
    78 88 
             public boolean test(CatchConsolidateContext context, Catch aCatch) {
    79 89 
                 return context.withLengthWeightParameter()
    ... ... @@ -103,6 +113,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons
    103 113 
                 return Catch.PROPERTY_CATCH_WEIGHT;
    104 114 
             }
    105 115
    116 
    +        @Override
    117 
    +        public String extraFieldName() {
    118 
    +            return Catch.PROPERTY_CATCH_WEIGHT_COMPUTED_SOURCE;
    119 
    +        }
    120 
    +
    106 121 
             @Override
    107 122 
             public boolean test(CatchConsolidateContext context, Catch aCatch) {
    108 123 
                 return aCatch.withoutCatchWeight()
    ... ... @@ -130,6 +145,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons
    130 145 
                 return Catch.PROPERTY_TOTAL_COUNT;
    131 146 
             }
    132 147
    148 
    +        @Override
    149 
    +        public String extraFieldName() {
    150 
    +            return Catch.PROPERTY_TOTAL_COUNT_COMPUTED_SOURCE;
    151 
    +        }
    152 
    +
    133 153 
             @Override
    134 154 
             public boolean test(CatchConsolidateContext context, Catch aCatch) {
    135 155 
                 return aCatch.withoutTotalCount()
    ... ... @@ -160,6 +180,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons
    160 180 
                 return Catch.PROPERTY_MEAN_WEIGHT;
    161 181 
             }
    162 182
    183 
    +        @Override
    184 
    +        public String extraFieldName() {
    185 
    +            return Catch.PROPERTY_MEAN_WEIGHT_COMPUTED_SOURCE;
    186 
    +        }
    187 
    +
    163 188 
             @Override
    164 189 
             public boolean test(CatchConsolidateContext context, Catch aCatch) {
    165 190 
                 return aCatch.withoutMeanWeight()
    ... ... @@ -187,6 +212,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons
    187 212 
                 return Catch.PROPERTY_MEAN_LENGTH;
    188 213 
             }
    189 214
    215 
    +        @Override
    216 
    +        public String extraFieldName() {
    217 
    +            return Catch.PROPERTY_MEAN_LENGTH_COMPUTED_SOURCE;
    218 
    +        }
    219 
    +
    190 220 
             @Override
    191 221 
             public boolean test(CatchConsolidateContext context, Catch aCatch) {
    192 222 
                 return aCatch.withoutMeanLength()
    ... ... @@ -210,6 +240,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons
    210 240 
                 return Catch.PROPERTY_MEAN_WEIGHT;
    211 241 
             }
    212 242
    243 
    +        @Override
    244 
    +        public String extraFieldName() {
    245 
    +            return Catch.PROPERTY_MEAN_WEIGHT_COMPUTED_SOURCE;
    246 
    +        }
    247 
    +
    213 248 
             @Override
    214 249 
             public boolean test(CatchConsolidateContext context, Catch aCatch) {
    215 250 
                 return aCatch.withoutMeanWeight()
    ... ... @@ -233,6 +268,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons
    233 268 
                 return Catch.PROPERTY_MEAN_LENGTH;
    234 269 
             }
    235 270
    271 
    +        @Override
    272 
    +        public String extraFieldName() {
    273 
    +            return Catch.PROPERTY_MEAN_LENGTH_COMPUTED_SOURCE;
    274 
    +        }
    275 
    +
    236 276 
             @Override
    237 277 
             public boolean test(CatchConsolidateContext context, Catch aCatch) {
    238 278 
                 return context.withSampleMeasures() && aCatch.withoutMeanLength();
    ... ... @@ -269,6 +309,11 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons
    269 309 
                 return Catch.PROPERTY_TOTAL_COUNT;
    270 310 
             }
    271 311
    312 
    +        @Override
    313 
    +        public String extraFieldName() {
    314 
    +            return Catch.PROPERTY_TOTAL_COUNT_COMPUTED_SOURCE;
    315 
    +        }
    316 
    +
    272 317 
             @Override
    273 318 
             public boolean test(CatchConsolidateContext context, Catch aCatch) {
    274 319 
                 return context.withSampleMeasures() && aCatch.withoutTotalCount();
    ... ... @@ -312,4 +357,9 @@ public enum CatchConsolidateActions implements AtomicConsolidateAction<CatchCons
    312 357 
             }
    313 358 
         };
    314 359
    360 
    +
    361 
    +    @Override
    362 
    +    public String toString() {
    363 
    +        return CatchConsolidateActions.class.getSimpleName() + "." + name();
    364 
    +    }
    315 365 
     }

  • 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
    47 47 
                 return SampleMeasure.PROPERTY_LENGTH;
    48 48 
             }
    49 49
    50 
    +        @Override
    51 
    +        public String extraFieldName() {
    52 
    +            return SampleMeasure.PROPERTY_IS_LENGTH_COMPUTED;
    53 
    +        }
    54 
    +
    50 55 
             @Override
    51 56 
             public boolean test(SampleConsolidateContext context, SampleMeasure sampleMeasure) {
    52 57 
                 return sampleMeasure.getLength() == null
    ... ... @@ -58,7 +63,6 @@ public enum SampleConsolidateActions implements AtomicConsolidateAction<SampleCo
    58 63 
             public void accept(SampleConsolidateContext context, SampleMeasure sampleMeasure) {
    59 64 
                 LengthWeightParameter lengthWeightParameter = context.getLengthWeightParameter();
    60 65 
                 Float weight = sampleMeasure.getWeight();
    61 
    -
    62 66 
                 Float length = lengthWeightParameter.computeFromFormulaTwo(weight);
    63 67 
                 if (length != null) {
    64 68 
                     sampleMeasure.setLength(length);
    ... ... @@ -77,6 +81,11 @@ public enum SampleConsolidateActions implements AtomicConsolidateAction<SampleCo
    77 81 
                 return SampleMeasure.PROPERTY_WEIGHT;
    78 82 
             }
    79 83
    84 
    +        @Override
    85 
    +        public String extraFieldName() {
    86 
    +            return SampleMeasure.PROPERTY_IS_WEIGHT_COMPUTED;
    87 
    +        }
    88 
    +
    80 89 
             @Override
    81 90 
             public boolean test(SampleConsolidateContext context, SampleMeasure sampleMeasure) {
    82 91 
                 boolean canExecute = sampleMeasure.getWeight() == null
    ... ... @@ -98,12 +107,14 @@ public enum SampleConsolidateActions implements AtomicConsolidateAction<SampleCo
    98 107 
                 Float length = sampleMeasure.getLength();
    99 108 
                 SizeMeasureType inputSizeMeasureType = sampleMeasure.getSizeMeasureType();
    100 109 
                 LengthWeightParameter lengthWeightParameter = context.getLengthWeightParameter();
    101 
    -
    102 110 
                 SizeMeasureType outputSizeMeasureType = lengthWeightParameter.getSizeMeasureType();
    103 111 
                 if (!Objects.equals(inputSizeMeasureType, outputSizeMeasureType)) {
    104 112 
                     // execute length conversion before applying the RTP
    105 113 
                     LengthLengthParameter lengthLengthParameter = context.getLengthLengthParameter();
    106 114 
                     length = lengthLengthParameter.computeFromFormulaOne(length);
    115 
    +                if (length == null) {
    116 
    +                    return;
    117 
    +                }
    107 118 
                 }
    108 119 
                 Float weight = lengthWeightParameter.computeFromFormulaOne(length);
    109 120 
                 if (weight != null) {
    ... ... @@ -112,5 +123,10 @@ public enum SampleConsolidateActions implements AtomicConsolidateAction<SampleCo
    112 123 
                 }
    113 124 
             }
    114 125 
         };
    126 
    +
    127 
    +    @Override
    128 
    +    public String toString() {
    129 
    +        return SampleConsolidateActions.class.getSimpleName() + "." + name();
    130 
    +    }
    115 131 
     }
    116 132

  • pom.xml
    ... ... @@ -23,7 +23,7 @@
    23 23 
       <parent>
    24 24 
         <groupId>io.ultreia.maven</groupId>
    25 25 
         <artifactId>pom</artifactId>
    26 
    -    <version>2023.10</version>
    26 
    +    <version>2023.11</version>
    27 27 
       </parent>
    28 28 
       <groupId>fr.ird.observe</groupId>
    29 29 
       <artifactId>ird-observe</artifactId>
    ... ... @@ -128,6 +128,7 @@
    128 128 
         <!-- FIXME   <lib.version.jts>1.18.2</lib.version.jts>-->
    129 129 
         <lib.version.hsqldb>2.7.0</lib.version.hsqldb>
    130 130 
         <!-- FIXME   <lib.version.hsqldb>2.7.1</lib.version.hsqldb>-->
    131 
    +    <lib.version.java4all.java-lang>2.0.5</lib.version.java4all.java-lang>
    131 132 
         <!-- license header configuration -->
    132 133 
         <license.licenseName>gpl_v3</license.licenseName>
    133 134 
         <license.organizationName>IRD, Ultreia.io</license.organizationName>
    ... ... @@ -1277,6 +1278,7 @@
    1277 1278 
                     <reports>
    1278 1279 
                       <report>dependency-updates-report</report>
    1279 1280 
                       <report>plugin-updates-report</report>
    1281 
    +                  <report>property-updates-report</report>
    1280 1282 
                     </reports>
    1281 1283 
                   </reportSet>
    1282 1284 
                 </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;
    23 23 
      */
    24 24
    25 25 
     import com.opensymphony.xwork2.validator.ValidationException;
    26 
    +import fr.ird.observe.decoration.DecoratorService;
    26 27 
     import fr.ird.observe.dto.IdDto;
    28 
    +import io.ultreia.java4all.decoration.Decorated;
    27 29 
     import org.nuiton.validator.xwork2.field.NuitonFieldValidatorSupport;
    28 30
    29 31 
     import java.util.Collection;
    ... ... @@ -49,6 +51,7 @@ public abstract class AbstractCollectionUniqueKeyValidator<O> extends NuitonFiel
    49 51 
          * To keep the first index in collection that breaks unique rule (used in error message).
    50 52 
          */
    51 53 
         protected int firstBadIndex;
    54 
    +    protected String firstBadRow;
    52 55
    53 56 
         protected abstract String computeUniqueKey(O collectionValue);
    54 57
    ... ... @@ -56,7 +59,7 @@ public abstract class AbstractCollectionUniqueKeyValidator<O> extends NuitonFiel
    56 59 
         public abstract String getValidatorType();
    57 60
    58 61 
         protected AbstractCollectionUniqueKeyValidator(String validationMessageKey) {
    59 
    -        setDefaultMessage(validationMessageKey + "##${firstBadIndex}");
    62 
    +        setDefaultMessage(validationMessageKey + "##${firstBadIndex} (${firstBadRow})");
    60 63 
         }
    61 64
    62 65 
         @Override
    ... ... @@ -75,10 +78,17 @@ public abstract class AbstractCollectionUniqueKeyValidator<O> extends NuitonFiel
    75 78 
                     if (!uniqueKeys.add(uniqueKey)) {
    76 79 
                         // found a duplicated entry
    77 80 
                         firstBadIndex = uniqueKeys.size() + 1;
    81 
    +                    Decorated decorated = (Decorated) collectionValue;
    82 
    +                    if (decorated.decorator().isEmpty()) {
    83 
    +                        DecoratorService decoratorService = (DecoratorService) stack.findValue("decoratorService");
    84 
    +                        decoratorService.installDecorator(decorated);
    85 
    +                    }
    86 
    +                    firstBadRow = collectionValue.toString();
    78 87 
                         addFieldError(fieldName, object);
    79 88 
                         return;
    80 89 
                     }
    81 90 
                 }
    91 
    +
    82 92 
             } finally {
    83 93 
                 uniqueKeys.clear();
    84 94 
             }
    ... ... @@ -93,10 +103,16 @@ public abstract class AbstractCollectionUniqueKeyValidator<O> extends NuitonFiel
    93 103 
             return (Collection<O>) fieldValue;
    94 104 
         }
    95 105
    106 
    +    @SuppressWarnings("unused")
    96 107 
         public int getFirstBadIndex() {
    97 108 
             return firstBadIndex;
    98 109 
         }
    99 110
    111 
    +    @SuppressWarnings("unused")
    112 
    +    public String getFirstBadRow() {
    113 
    +        return firstBadRow;
    114 
    +    }
    115 
    +
    100 116 
         protected void addComponentValue(StringBuilder builder, IdDto value) {
    101 117 
             builder.append("|").append(Optional.ofNullable(value).map(IdDto::getId).orElse("null"));
    102 118 
         }

    • —
    View it on GitLab.
    You're receiving this email because of your account on gitlab.com. Manage all notifications · Help