environment:

     name: test

   script:

 .publish-site: &publish-site

   environment:

   <<: *triggers

   <<: *build-for-release

 trigger-deploy-demo:

   <<: *stage_test

   <<: *triggers

   before_script:

     - export CREATE_DOCKER=true

 make-release:

   <<: *stage_release

   <<: *manual

  */

 public class ComputeRF1Action extends AbstractLevel0Action<ComputeRF1Configuration> {

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

     /** total catch weight for trips with rf1 != null. */

     /** total landing weight for trips with rf1 != null. */

     /** Number of trips rejected (with no logbook). */

     /** Number of accepted trips (says with a rf1 computation). */

     /** Number of accepted complete trips (says with a rf1 computation). */

     /** Number of complete accepted trips (says with a rf1 computation, but not in defined bound). */

     @InjectDAO(entityType = RF1SpeciesForFleet.class)

     private RF1SpeciesForFleetTopiaDao rF1SpecieForFleetDAO;

     /** usable trips group by vessel */

             treatCompleteTrip(completeTrip, species, minimumRate, maximumRate);

             // complete trip was consumed

             completeTrip.removeTrips(tripList);

         }

         if (CollectionUtils.isNotEmpty(tripList)) {

             // still some trips not complete

         for (Trip trip : trips) {

             String tripStr = decorate(trip);

             Float rf1ToUse = rf1;

                 // means can not apply any rf1 : rf1 must stay at null...

                 rf1ToUse = null;

                 addWarningMessage(l(locale, "t3.level0.computeRF1.warning.no.logbook", tripStr));

                 decorate(completeTrip.getLandingTrip()), tripTotalCatchWeightRf1, tripTotalLandingWeight));

         log.debug(String.format("After trip %s totalCatchWeightRF1 = %s totalLandingWeight = %s",

                 decorate(completeTrip.getLandingTrip()), totalCatchWeightRF1, totalLandingWeight));

     }

     private float computeRF1ForCompleteTrip(Iterable<Trip> completeTrip, Collection<Species> speciesList) {

     private T3Input inputPilot;

     private boolean safe;

     @SuppressWarnings("unused")

     public Trip getTripToReplace(Trip trip) {

         Map<Trip, Trip> resultAsMap = getResultAsMap(RESULT_TRIPS_TO_REPLACE);

             }

             String[] analyzeWarnings = inputPilot.getAnalyzeWarnings();

             if (analyzeWarnings != null && analyzeWarnings.length > 0) {

                 for (String analyzeWarning : analyzeWarnings) {

                     sb.append('\n').append(analyzeWarning);

                 }

             }

             putResult(RESULT_SAFE_TRIPS, safeTrips);

             putResult(RESULT_UNSAFE_TRIPS, unsafeTrips);

             // while analyzing db, nothing to commit in db

             return false;

         } finally {

         if (!withWell) {

             // no well for this trip can remove all missing fk for wells

             addWarningMessage(l(locale, "t3.import.warning.no.wellPlan", decorate(trip)));

             // remove missing keys Sample->Well since there is no well

             removeWellMissingForeignKeys(missingForeignKeys, false, SAMPLE_TO_WELL, missingFkToMessage);

             removeWellMissingForeignKeys(missingForeignKeys, true, WELL_PLAN_TO_ACTIVITY, missingFkToMessage);

         } else {

             // there is some wells for this trip

                 addInfoMessage(l(locale, "t3.import.message.use.new.vessel.for.trip", decorate(vessel), decorate(trip)));

             }

         }

         //TODO Use this when Will have exact list of entities to exclude...

         // check we are not using bad references

 //        tripSafe &= checkReferences(trip, entitiesUsed);

 Treatment to apply to catches with samples:

 <#if configuration.useAllSamplesOfStratum>

 <#else>

 Keep their own samples (do nothing)

 </#if>

 t3.admin.deleteTripDatas=Delete data of trip %s

 t3.common.rf1.maximumRate.acceptable=Maximum acceptable rf1 rate

 t3.common.rf1.minimumRate.acceptable=Minimum acceptable rf1 rate

 t3.import.error.badReferenceCode=Trip %s uses a reference of type %s with forbidden code %s

 t3.import.error.missingForeignKey=It miss on trip %s foreign keys from %s %s to %s %s

 t3.import.error.missingForeignKeyInT3=On trip %s, it miss in T3+ referentials, entity %s (natural key\: %s)

 t3.admin.deleteTripDatas=Suppresion des données de la marée %s

 t3.common.rf1.maximumRate.acceptable=Seuil maximum acceptable du rf1

 t3.common.rf1.minimumRate.acceptable=Seuil minimum acceptable du rf1

 t3.import.error.badReferenceCode=La marée %s utilise un référentiel de type %s avec le code %s

 t3.import.error.missingForeignKey=Il manque sur la marée %s des clefs étrangères type %s %s vers %s %s

 t3.import.error.missingForeignKeyInT3=Pour la marée %s, il manque dans le référentiel T3+ l'entité %s (clef métier\: %s)

     @Override

     protected Map<String, Object> createTemplateParameters() {

         Map<String, Object> parameters = super.createTemplateParameters();

         Map<String, String> vesselSimpleTypes = new TreeMap<>();

         parameters.put("vesselSimpleTypes", vesselSimpleTypes);

         Map<String, String> fleets = new TreeMap<>();

         putInMap(fleets, fixtures.frenchCountry());

         parameters.put("fleets", fleets);

         return parameters;

     }

  * it under the terms of the GNU Affero 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 Affero General Public License

  * along with this program.  If not, see <http://www.gnu.org/licenses/>.

  * #L%

  */

 public class T3Predicates {

     /**

      * Predicates that trip ends a complete trip.

      *

      */

     public static final Predicate<Trip> TRIP_ENDS_A_COMPLETE_TRIP = input -> input.getFishHoldEmpty() == 1;

     public static final Predicate<Activity> ACTIVITY_WITH_SET_SAMPLE = input -> !input.isSetSpeciesCatWeightEmpty();

     public static final Predicate<LengthWeightConversion> LENGTH_WEIGHT_CONVERSION_BY_COEFFICIENT = input -> {

         boolean result = true;

     public static Predicate<Trip> tripUsingOcean(Collection<Ocean> oceans) {

         return input -> {

             boolean result = false;

                 Set<Ocean> allOceans = input.getAllOceans();

                 for (Ocean ocean : allOceans) {

                     if (oceans.contains(ocean)) {

 //    public static <E extends TopiaEntity> Predicate<E> equalsTopiaEntity(String id) {

 //        return input -> id.equals(input.getTopiaId());

 //    }

 }

 import java.sql.ResultSet;

 import java.sql.SQLException;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.Comparator;

 public class AbstractTripTopiaDao<E extends Trip> extends GeneratedTripTopiaDao<E> {

     public static final Ocean EMPTY_OCEAN = new OceanImpl();

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

     static {

         EMPTY_OCEAN.setTopiaId("fr.ird.t3.entities.reference.Ocean#EMPTY#EMPTY");

     }

     public static String getSamplesOnlyFilter(String prefix, Boolean samplesOnly) {

         if (samplesOnly == null) {

             return "";

     }

     public static boolean isTripsAllWithLogBook(Iterable<Trip> trips) {

     }

     /**

  * it under the terms of the GNU Affero 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 Affero General Public License

  * along with this program.  If not, see <http://www.gnu.org/licenses/>.

  * #L%

     }

     private transient Boolean level2Computed;

     private transient Boolean level3Computed;

     @Override

     public boolean isSomeDataComputed() {

         return TripType.LOGBOOKMISSING == getTripType();

     }

     public boolean isLevel2Computed() {

         if (level2Computed == null) {

             level2Computed = false;

         return level2Computed;

     }

     public boolean isLevel3Computed() {

         if (level3Computed == null) {

             level3Computed = false;

         return result;

     }

 //    @Override

 //    public float getTotalSetsDuration() {

 //        float result = 0;

      */

     List<MissingForeignKey> getMissingForeignKeys(Trip trip);

     /**

      * Method to clean input internal states.

      * <p/>

 import fr.ird.t3.entities.T3EntityEnum;

 import fr.ird.t3.entities.T3EntityMap;

 import fr.ird.t3.entities.data.Trip;

 import fr.ird.t3.entities.data.TripType;

 import fr.ird.t3.entities.reference.Vessel;

 import fr.ird.t3.io.input.MissingForeignKey;

 import java.beans.PropertyChangeEvent;

 import java.beans.PropertyChangeListener;

 import java.io.File;

 import java.util.Arrays;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 public abstract class AbstractT3InputMSAccess implements T3Input {

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

     private ReferenceEntityMap safeReferences;

     private Map<Trip, List<MissingForeignKey>> missingFK;

     public abstract T3AccessDataSource newDataSource(File inputFile);

         T3AccessHitModel hitModel = new T3AccessHitModel();

         hitModel.addPropertyChangeListener(new LoadDbPropertyChangeListener(t3DataTypes));

         // analyse data source

         if (dataSource.hasError()) {

         }

         if (dataSource.hasWarning()) {

         }

     }

     @Override

     public String[] getAnalyzeErrors() {

     }

     @Override

     public String[] getAnalyzeWarnings() {

     }

     @Override

         T3EntityEnum constant = T3EntityEnum.valueOf(Trip.class);

         T3AccessEntityMeta meta = dataSource.getMeta(constant);

         List<Trip> entities = dataSource.loadEntities(meta);

         missingFK = new HashMap<>();

         T3DataEntityVisitor dataVisitor = newDataVisitor(dataSource, safeReferences);

         try {

         return missingFK.get(trip);

     }

     private Trip loadTrip(int vesselCode, Trip trip, T3DataEntityVisitor dataVisitor, TripType tripType, boolean canCreateVessel) {

         RemoveProxyEntityVisitor visitor = new RemoveProxyEntityVisitor();

         try {

             dataVisitor.doVisit(trip, true);

             // remove proxy on data

             Trip loadedTrip = visitor.doVisit(trip);

             if (trip.getVessel() == null && canCreateVessel) {

                 // use new created vessel

                 Vessel vessel = getNewVessels().get(vesselCode);

 import fr.ird.msaccess.importer.AbstractAccessDataSource;

 import fr.ird.t3.entities.T3EntityEnum;

 import fr.ird.t3.entities.reference.T3ReferenceEntity;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

     }

     public void analyzeDb(T3AccessHitModel hits) throws Exception {

         // always init the data source

         init();

         Set<String> tables = getTableNames();

                     activity.setSchoolType(Objects.requireNonNull(sampleSet.getActivitySchoolType()));

                     sampleSet.setActivity(endActivity(activity));

                     parent.addActivity(activity);

                 }

             };

         } else {

 ---

 ALTER TABLE Trip ADD COLUMN tripType VARCHAR(255) DEFAULT 'STANDARD' NOT NULL;

 UPDATE Trip set tripType = 'SAMPLEONLY' WHERE samplesonly = TRUE;

 CREATE INDEX idx_trip_tripType ON Trip(tripType);

 ALTER TABLE Trip DROP COLUMN  samplesonly;

  */

 package fr.ird.t3.entities.reference;

 import fr.ird.t3.entities.AbstractDatabaseTest;

 import fr.ird.t3.entities.T3TopiaPersistenceContext;

 import org.junit.Assert;

 import java.util.ArrayList;

 import java.util.Comparator;

 import java.util.List;

 import java.util.Map;

         catUnbound.setMax(null);

         Map<WeightCategoryTreatment, Integer> weightCategories =

         weightCategories.put(catBound, 20);

         weightCategories.put(catUnbound, Integer.MAX_VALUE);

         catUnbound.setMax(null);

         Map<WeightCategoryTreatment, Integer> weightCategories =

         weightCategories.put(catBound, 20);

         weightCategories.put(catBound2, 40);

     @Override

     public T3DataEntityVisitor newDataVisitor(T3AccessDataSource dataSource, ReferenceEntityMap safeReferences) {

     }

     @Override

     @Override

     public T3DataEntityVisitor newDataVisitor(T3AccessDataSource dataSource, ReferenceEntityMap safeReferences) {

     }

     @Override

  * it under the terms of the GNU Affero 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 Affero General Public License

  * along with this program.  If not, see <http://www.gnu.org/licenses/>.

  * #L%

  */

 public class BalbayaOperationExecutionTripImpl extends AbstractBalbayaOperationExecution {

         super(connection, T3OutputOperationBalbayaImpl.TRIP_AND_LANDING);

     }

     @Override

     protected boolean checkDatas(T3OutputBalbayaImpl output, List<Trip> trips) throws SQLException {

         // check pKeys before all

         for (Trip trip : trips) {

             int tripVesselCode = trip.getVessel().getCode();

             Date tripLandingDate = trip.getLandingDate();

             if (exists) {

                 // this trip already exists, can not import it, stop operation

                 Locale locale = output.getLocale();

                 output.getMessager().addErrorMessage(

                 return false;

             }

         }

         return true;

     }

     @Override