# T3 changelog

  * Author [Tony Chemit](mailto:dev@tchemit.fr)

 ## Version [2.5](https://gitlab.com/ultreiaio/ird-t3/milestones/35)

   <groupId>fr.ird.t3</groupId>

   <artifactId>ird-t3</artifactId>

   <packaging>pom</packaging>

   <name>T3 :: Pom</name>

     <projectId>ird-t3</projectId>

     <stageId>frirdt3</stageId>

     <applicationName>t3</applicationName>

     <lib.version.java4all.i18n>4.0-alpha-11</lib.version.java4all.i18n>

     <env>dev</env>

   <parent>

     <groupId>fr.ird.t3</groupId>

     <artifactId>ird-t3</artifactId>

   </parent>

   <artifactId>t3-actions</artifactId>

 import com.google.common.collect.ArrayListMultimap;

 import com.google.common.collect.ListMultimap;

 import com.google.common.collect.Multimap;

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

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

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

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

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

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

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

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

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

 import fr.ird.t3.services.DecoratorService;

 import fr.ird.t3.services.ioc.InjectDAO;

 import fr.ird.t3.services.ioc.InjectEntitiesById;

 import org.apache.commons.collections.CollectionUtils;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Set;

 import static org.nuiton.i18n.I18n.l;

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

     @InjectEntitiesById(entityType = Harbour.class)

     private List<Harbour> landingHarbours;

     private int nbStratum;

     private int nbTripsWithRF2;

     @InjectDAO(entityType = RaisingFactor2.class)

     private CountryTopiaDao countryDAO;

     @InjectDAO(entityType = VesselSimpleType.class)

     private VesselSimpleTypeTopiaDao vesselSimpleTypeDAO;

     /** usable complete trips group by vessel */

     private ListMultimap<Vessel, CompleteTrip> completeTripsByVessel;

     public ComputeRF2Action() {

         super(Level0Step.COMPUTE_RF2);

             // use all fleets

             fleets = countryDAO.findAll();

         }

         List<Trip> tripList = getUsableTrips(landingHarbours, true);

         setTrips(tripList);

         completeTripsByVessel = ArrayListMultimap.create();

         // get all trips group by the vessel

         ListMultimap<Vessel, Trip> tripsByVessel = TripTopiaDao.groupByVessel(tripList);

         // compute for each vessel list of complete trip

             TripTopiaDao.sortTrips(tripsForVessel);

             // get all complete trips

             List<CompleteTrip> completeTrips = tripDAO.toCompleteTrip(tripsForVessel);

             completeTripsByVessel.putAll(vessel, completeTrips);

         }

         boolean result = false;

         if (CollectionUtils.isNotEmpty(trips)) {

             setNbSteps(landingHarbours.size() * fleets.size() * vesselSimpleTypes.size());

             for (Harbour harbour : landingHarbours) {

                 String harbourStr = harbour.getLabel1();

                 for (Country fleet : fleets) {

                     String countryStr = fleet.getLabel1();

                     for (VesselSimpleType vesselSimpleType : vesselSimpleTypes) {

                         incrementsProgression();

                         // get all trip usable for this stratum

                         String vesselSimpleTypeStr = vesselSimpleType.getLabel1();

                         // obtain all trips for harbour / fleet / vesselSimpleType

                         List<CompleteTrip> completeTrips = getStratumCompleteTrips(stratumVessels, harbour);

                         if (completeTrips.isEmpty()) {

                             // no trip for this stratum

                             continue;

                         }

                         Multimap<T3Date, CompleteTrip> tripsByMonth = TripTopiaDao.splitTripsByMonth(completeTrips);

                             nbStratum++;

                             String message = l(locale, "t3.level0.computeRF2.nbTrips.for.stratum",

                                     harbourStr,

                                     countryStr,

                                     vesselSimpleTypeStr,

                             log.info(message);

                             addInfoMessage(message);

                         }

                     }

                 }

                                    Country fleet,

                                    VesselSimpleType vesselSimpleType,

                                    T3Date month,

                                    Collection<CompleteTrip> trips,

                                    boolean computeRf2) throws TopiaException {

         }

         // do the rf2 stratum computation

         float rf2 = computeRf2 ? computeRF2ForStratum(trips, species) : 1f;

         // assign rf2 value to the entity

         raisingFactor.setRaisingFactorValue(rf2);

         if (!rFCreated) {

         // set rf2 to all trips

         for (CompleteTrip trip : trips) {

             String tripStr = decorate(trip);

             }

             trip.applyRf2(rf2);

             markTripAsTreated(trip);

         }

     }

         float totalLandingWeight = 0f;

         float totalCatchWeight = 0f;

         for (CompleteTrip trip : trips) {

                     tripCatchWeight = trip.getElementaryCatchTotalWeightRf1(species);

                 }

                 totalCatchWeight += tripCatchWeight;

             } else {

                 // this trip does not have any landing catches for given species

             }

         }

         addInfoMessage(l(locale, "t3.level0.computeRF2.resume.total.rf1", totalCatchWeight, totalLandingWeight));

         }

     }

 }

 t3.level0.computeRF1.warning.no.species.usable.for.country=Could not find usable species fro Raising Factor 1 computation from country %s

 t3.level0.computeRF1.warning.too.high.rf1=For complete trip %s from %s to %s computed rf1 %s is too high (higher than %s)

 t3.level0.computeRF1.warning.too.low.rf1=For complete trip %s from %s to %s computed rf1 is too small (less than %s)

 t3.level0.computeRF2.computed.rf2.for.stratum=Computed rf2 for stratum \: %s

 t3.level0.computeRF2.resume.rf1.for.trip=Trip %s total rf1 catches weight %s / total landing weight %s

 t3.level0.computeRF2.resume.skip.for.trip=Trip %s has not elementary landing (trip not used to compute rf2)

 t3.level0.computeRF2.resume.total.rf1=Sum total rf1 catches weight %s  / Sum total landing weight %s

 t3.level0.computeSetDurationAndPositiveSetCount.error.noSetDurationFound=SetDuration data not found (ocean %s, fleet %s, school type %s, year %s)

 t3.level0.computeTripEffort=Trip efforts %s (fishing %s, search %s)

 t3.level0.computeTripEffortSkipForDay=Trip %s, day without fishing time (only activities of type « at harbour » or « under way without prospection »)

 t3.level0.computeRF1.warning.too.low.rf1=Pour la marée complète %s de %s à %s le rf1 calculé %s est trop petit (inférieur à %s)

 t3.level0.computeRF1.warning.trip.is.not.complete=La marée %s n'est pas complète, calcul du rf1 impossible

 t3.level0.computeRF2.computed.rf2.for.stratum=Valeur du rf2 calculé pour la strate \: %s

 t3.level0.computeRF2.resume.rf1.for.trip=Marée %s Poids total des captures rf1isées %s / Poids total des ventes %s

 t3.level0.computeRF2.resume.skip.for.trip=La marée %s ne possède pas de lots commerciaux (non prise en compte dans le calcul du rf2)

 t3.level0.computeRF2.resume.total.rf1=Poids cumulé des captures rf1isées %s  / Poids cumulé des ventes %s

 t3.level0.computeSetDurationAndPositiveSetCount.error.noSetDurationFound=Donnée SetDuration non trouvée (ocean %s, flotte %s, type de banc %s, année %s)

 t3.level0.computeTripEffort=Efforts de la marée %s (pêche %s, recherche %s)

 t3.level0.computeTripEffortSkipForDay=Marée %s, jour sans temps de pêche (uniquement des activités « au port » ou « route sans veille »)

   <parent>

     <groupId>fr.ird.t3</groupId>

     <artifactId>ird-t3</artifactId>

   </parent>

   <artifactId>t3-domain</artifactId>

      * @param pKey primary key of this trip

      */

     public static void checkAndSetStandardTripType(Trip trip, Object[] pKey) {

         switch (logBookAvailability) {

             case TRIP_WITHOUT_LOGBOOK:

                 if (trip.isActivityNotEmpty()) {

      * @param pKey primary key of this trip

      */

     public static void checkAndSetLogbookMissingTripType(Trip trip, Object[] pKey) {

         if (trip.getTripType() == TripType.LOGBOOKMISSING) {

             if (TRIP_WITH_LOGBOOK == logBookAvailability) {

                 throw new IllegalStateException(String.format("Trip %s has no logBook but logBookAvailability says the opposite, please fix this trip.", Arrays.toString(pKey)));

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

 import org.nuiton.util.DateUtil;

 import java.util.Collection;

 import java.util.Comparator;

 import java.util.Date;

     private transient Boolean level2Computed;

     private transient Boolean level3Computed;

     @Override

     public boolean isSomeDataComputed() {

     public boolean isLevel2Computed() {

         if (level2Computed == null) {

             level2Computed = false;

                 for (Activity a : getActivity()) {

                     Boolean b = a.getUseMeanStratumCompositionN2();

                     if (b != null) {

     public boolean isLevel3Computed() {

         if (level3Computed == null) {

             level3Computed = false;

                 for (Activity a : getActivity()) {

                     Boolean b = a.getUseMeanStratumCompositionN3();

                     if (b != null) {

         return result;

     }

     @Override

     public float getElementaryCatchTotalWeight(Collection<Species> species) {

         float result = 0;

             for (Activity activity : getActivity()) {

                 result += activity.getElementaryCatchTotalWeight(species);

             }

     @Override

     public float getElementaryCatchTotalWeightRf1(Collection<Species> species) {

         float result = 0;

             for (Activity activity : getActivity()) {

                 if (activity.isElementaryCatchEmpty()) {

     @Override

     public float getElementaryCatchTotalWeightRf2(Collection<Species> species) {

         float result = 0;

             for (Activity activity : getActivity()) {

                 if (activity.isElementaryCatchEmpty()) {

     @Override

     public float getElementaryLandingTotalWeight(Collection<Species> species) {

         float result = 0;

             for (ElementaryLanding elementaryLanding : getElementaryLanding()) {

                 if (species.contains(elementaryLanding.getWeightCategoryLanding().getSpecies())) {

                     result += elementaryLanding.getWeight();

     @Override

     public Set<Species> getElementaryCatchSpecies() {

         Set<Species> result = new HashSet<>();

             for (Activity activity : getActivity()) {

                 if (!activity.isElementaryCatchEmpty()) {

                     for (ElementaryCatch aCatch : activity.getElementaryCatch()) {

     @Override

     public Set<Species> getElementaryLandingSpecies() {

         Set<Species> result = new HashSet<>();

             for (ElementaryLanding landing : getElementaryLanding()) {

                 result.add(landing.getWeightCategoryLanding().getSpecies());

             }

     @Override

     public Set<Ocean> getAllOceans() {

         Set<Ocean> result = new HashSet<>();

             for (Activity activity : getActivity()) {

                 result.add(activity.getOcean());

             }

             registerJXPathDecorator(locale, Trip.class, WITH_ID, "${vesselLabel}$s - ${landingDate}$td/%2$tm/%2$tY [${topiaId}$s]");

             // trip (with topiaid) decorator

             // trip (with topiaid) decorator

             // well (with topiaid) decorator

             registerJXPathDecorator(locale, Well.class, "Number ${wellNumber}$s - Position ${wellPosition}$s [${topiaId}$s]");

 model.tagValue.notGenerateToString=true

 model.tagValue.generateOperatorForDAOHelper=true

 model.tagValue.constantPrefix=PROPERTY_

 model.tagValue.indexForeignKeys=true

 fr.ird.t3.entities.reference.WeightCategoryLogBookConversion.attribute.distributions.stereotype=ordered

   <parent>

     <groupId>fr.ird.t3</groupId>

     <artifactId>ird-t3</artifactId>

   </parent>

   <artifactId>t3-input-avdthv33</artifactId>

                 Trip.PROPERTY_FALSE_FISHES_WEIGHT, Float.class, "V_POIDS_FP",

                 Trip.PROPERTY_LANDING_TOTAL_WEIGHT, Float.class, "V_POIDS_DBQ",

                 Trip.PROPERTY_FISH_HOLD_EMPTY, Integer.class, "F_CAL_VID",

         );

         // OPERA : [C_OPERA, L_OP8L, L_OPERA]

   <parent>

     <groupId>fr.ird.t3</groupId>

     <artifactId>ird-t3</artifactId>

   </parent>

   <artifactId>t3-input-avdthv35</artifactId>

                 Trip.PROPERTY_FALSE_FISHES_WEIGHT, Float.class, "V_POIDS_FP",

                 Trip.PROPERTY_LANDING_TOTAL_WEIGHT, Float.class, "V_POIDS_DBQ",

                 Trip.PROPERTY_FISH_HOLD_EMPTY, Integer.class, "F_CAL_VID",

         );

         // FP_LOT : [C_BAT, D_DBQ, N_LOT, C_ESP, C_COND, , V_POIDS_PESE, L_ORIGINE, L_COM]

   <parent>

     <groupId>fr.ird.t3</groupId>

     <artifactId>ird-t3</artifactId>

   </parent>

   <artifactId>t3-input-avdthv36</artifactId>

                 Trip.PROPERTY_FALSE_FISHES_WEIGHT, Float.class, "V_POIDS_FP",

                 Trip.PROPERTY_LANDING_TOTAL_WEIGHT, Float.class, "V_POIDS_DBQ",

                 Trip.PROPERTY_FISH_HOLD_EMPTY, Integer.class, "F_CAL_VID",

         );

         // FP_LOT : [C_BAT, D_DBQ, N_LOT, C_ESP, C_COND, , V_POIDS_PESE, L_ORIGINE, L_COM]

   <parent>

     <groupId>fr.ird.t3</groupId>

     <artifactId>ird-t3</artifactId>

   </parent>

   <artifactId>t3-installer</artifactId>

   <parent>

     <groupId>fr.ird.t3</groupId>

     <artifactId>ird-t3</artifactId>

   </parent>

   <artifactId>t3-msaccess-importer</artifactId>

   <parent>

     <groupId>fr.ird.t3</groupId>

     <artifactId>ird-t3</artifactId>

   </parent>

   <artifactId>t3-output-balbayav32</artifactId>

   <parent>

     <groupId>fr.ird.t3</groupId>

     <artifactId>ird-t3</artifactId>

   </parent>

   <artifactId>t3-web</artifactId>

 import java.io.File;

 import java.io.IOException;

 import java.io.InputStream;

 import java.util.Arrays;

 import java.util.Collections;

 import java.util.Enumeration;

         File targetDirectory = getTreatmentDirectory();

         String filename = getSourceToLoadFileName();

         if (ZipUtil.isZipFile(upload)) {

             Enumeration<? extends ZipEntry> entries = zipfile.entries();

             if (!entries.hasMoreElements()) {

                 String message = t("t3.error.required.one.entry.in.zip.to.upload");

             // get first entry

             ZipEntry zipEntry = entries.nextElement();

             // keep the filename of the zip entry

             File target = new File(targetDirectory, filename);

             log.info(String.format("Will copy loaded zipped entry file %s to treatment configuration directory %s", filename, target));

             try (InputStream in = zipfile.getInputStream(zipEntry)) {

   <parent>

     <groupId>fr.ird.t3</groupId>

     <artifactId>ird-t3</artifactId>

   </parent>

   <artifactId>t3</artifactId>