+import fr.ird.t3.entities.data.Route;

+import fr.ird.t3.entities.data.RouteTopiaDao;

+    @InjectDAO(entityType = Route.class)

+    protected RouteTopiaDao routeDAO;

+

+ *

+ *

+import fr.ird.t3.entities.data.Route;

+import java.util.Collection;

+import java.util.Date;

+import java.util.List;

+import java.util.Objects;

+    private static final ImmutableSet<Integer> VESSEL_ACTIVITY_CODES_TO_SKIP = ImmutableSet.of(

+    /** Logger. */

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

+    private boolean executeForTrip(Trip trip) throws TopiaException {

+        Route firstRoute = Objects.requireNonNull(trip.getRoute().get(0));

+        Route lastRoute = Objects.requireNonNull(Iterables.getLast(trip.getRoute()));

+        for (Route route : trip.getRoute()) {

+//            float timeAtSea = computeTimeAtSea(route);

+//            totalTimeAtSeaN0 += timeAtSea;

+            totalTimeAtSeaN0 += 24;

+//            route.setComputedTimeAtSeaN0(timeAtSea);

+//            incrementsProgression();

+            // compute fishing time

+            Float fishingTime = computeFishingTime(firstRoute, lastRoute, route);

+            route.setComputedFishingTimeN0(fishingTime);

+            incrementsProgression();

+            if (fishingTime == null) {

+                route.setComputedSearchTimeN0(null);

+                incrementsProgression();

+                continue;

+            }

+            totalFishingTimeN0 += fishingTime;

+            // compute search time

+            float searchTime = computeTripSearchTime(route, fishingTime);

+            totalSearchTimeN0 += searchTime;

+            route.setComputedSearchTimeN0(searchTime);

+            incrementsProgression();

+            String message = l(locale, "t3.level0.computeTripEffort",

+                    decorate(route),

+                    route.getComputedFishingTimeN0(),

+                    route.getComputedSearchTimeN0()

+            );

+            addInfoMessage(message);

+            if (log.isInfoEnabled()) {

+                log.info(message);

+            }

+        }

+        markTripAsTreated(trip);

+        return true;

+    }

+    private Float computeFishingTime(Route firstRoute, Route lastRoute, Route route) throws TopiaException {

+        Collection<Activity> activities = route.getActivity();

+        if (Objects.equals(firstRoute, route) || Objects.equals(lastRoute, route)) {

+            return computeSetFishingTimeForFirstOrLayDay(activities);

+        }

+        Date date = route.getDate();

+        if (!canComputeSetFishingTime(activities)) {

+            String message = l(locale, "t3.level0.computeTripEffortSkipForDay", decorate(route));

+            addInfoMessage(message);

+            if (log.isInfoEnabled()) {

+                log.info(message);

+            }

+            return null;

+        }

+        T3Point point;

+        if (activities.size() == 1) {

+            // only one activity for this day,

+            Activity activity = activities.iterator().next();

+            point = activity.toPoint();

+            if (log.isDebugEnabled()) {

+                log.debug("Day [" + date + "] , single activity,  point : " + point);

+            }

+        } else {

+            // compute barycenter for all activities of the day

+            point = routeDAO.getBarycenterForActivitiesOfADay(route, date);

+            if (log.isDebugEnabled()) {

+                log.debug("Day [" + date + "] Computed barycenter point " + point);

+        // compute day duration for this point and day (in minutes)

+        double duration = SunTimes.getDayDurationInMonths(date, point.getX(), point.getY());

+        if (log.isInfoEnabled()) {

+            log.info("Day [" + date + "] duration = " + duration);

+        }

+        return (float) duration;

+    private float computeTripSearchTime(Route route, float fishingTime) {

+        float catchesTime = route.getTotalSetsDuration();

+            log.debug(decorate(route) + " - trip search time = " + result);

+    private float computeSetFishingTimeForFirstOrLayDay(Collection<Activity> activities) {

+    private boolean canComputeSetFishingTime(Collection<Activity> activities) {

+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.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 »)

+package fr.ird.t3.entities.data;

+

+import fr.ird.t3.entities.type.T3Point;

+import fr.ird.t3.entities.type.T3PointImpl;

+import org.nuiton.topia.persistence.TopiaException;

+import org.nuiton.topia.persistence.support.TopiaSqlQuery;

+

+import java.sql.Connection;

+import java.sql.PreparedStatement;

+import java.sql.ResultSet;

+import java.sql.SQLException;

+import java.util.Date;

+

+public class AbstractRouteTopiaDao<E extends Route> extends GeneratedRouteTopiaDao<E> {

+

+    public T3Point getBarycenterForActivitiesOfADay(E route, Date day) throws TopiaException {

+

+        TopiaSqlQuery<T3Point> query = new GetT3PointQuery<E>(route, day);

+        return topiaSqlSupport.findSingleResult(query);

+    }

+

+    private static class GetT3PointQuery<E extends Route> extends TopiaSqlQuery<T3Point> {

+        private final E route;

+

+        private final Date day;

+

+        public GetT3PointQuery(E route, Date day) {

+            this.route = route;

+            this.day = day;

+        }

+

+        @Override

+        public PreparedStatement prepareQuery(Connection connection) throws SQLException {

+            PreparedStatement ps = connection.prepareStatement(

+                    "SELECT ST_X(record.point), ST_Y(record.point) FROM " +

+                            "(" +

+                            "   SELECT ST_Centroid(ST_Collect(a.the_geom)) AS point" +

+                            "   FROM activity a " +

+                            "   WHERE a.route = ? AND a.date::DATE = ?" +

+                            ") AS record;");

+            ps.setString(1, route.getTopiaId());

+            ps.setDate(2, new java.sql.Date(day.getTime()));

+            return ps;

+        }

+

+        @Override

+        public T3Point prepareResult(ResultSet set) throws SQLException {

+            float x = set.getFloat(1);

+            float y = set.getFloat(2);

+            return new T3PointImpl(x, y);

+        }

+    }

+

+}

+

+            hql = "SELECT t.id FROM TripImpl as t WHERE size(t.route) = 0";

+            hql = "SELECT DISTINCT(a.route.trip.id) FROM ActivityImpl a WHERE a.ocean = :ocean";

+import org.apache.commons.logging.Log;

+import org.apache.commons.logging.LogFactory;

+

+    public Trip getTrip() {

+        return getRoute().getTrip();

+    }

+

+    @Override

+package fr.ird.t3.entities.data;

+

+public class RouteImpl extends RouteAbstract {

+

+    private static final long serialVersionUID = 1L;

+

+    /** @return the sum of all activities set duration in hours. */

+    @Override

+    public float getTotalSetsDuration() {

+        float result = 0;

+        if (!isActivityEmpty()) {

+            for (Activity activity : getActivity()) {

+

+                // get the setDuration

+                Float setTime = activity.getSetDuration();

+

+                result += setTime == null ? 0f : setTime;

+            }

+        }

+        return result / 60;

+    }

+

+    @Override

+    public void deleteComputedDataLevel0() {

+        setComputedFishingTimeN0(null);

+        setComputedSearchTimeN0(null);

+        ComputedDataHelper.deleteComputedDataLevel0(getActivity());

+    }

+

+    @Override

+    public void deleteComputedData() {

+        ComputedDataHelper.deleteComputedDatas(this);

+    }

+

+    @Override

+    public void deleteComputedDataLevel1() {

+        ComputedDataHelper.deleteComputedDataLevel1(getActivity());

+    }

+

+    @Override

+    public void deleteComputedDataLevel2() {

+        ComputedDataHelper.deleteComputedDataLevel2(getActivity());

+    }

+

+    @Override

+    public void deleteComputedDataLevel3() {

+        ComputedDataHelper.deleteComputedDataLevel3(getActivity());

+    }

+}

+import org.nuiton.util.DateUtil;

+import java.util.Date;

+import java.util.LinkedList;

+import java.util.List;

+import java.util.Objects;

+import java.util.Optional;

+import java.util.stream.Collectors;

+import java.util.stream.Stream;

+//    /** @return the sum of all activities set duration in hours. */

+//    @Override

+//    public float getTotalSetsDuration() {

+//        float result = 0;

+//        if (!isActivityEmpty()) {

+//            for (Activity activity : getActivity()) {

+//

+//                // get the setDuration

+//                Float setTime = activity.getSetDuration();

+//

+//                result += setTime == null ? 0f : setTime;

+//            }

+//        }

+//        return result / 60;

+//    }

+//        setComputedFishingTimeN0(null);

+//        setComputedSearchTimeN0(null);

+//        setComputedTimeAtSeaN0(null);

+        ComputedDataHelper.deleteComputedDataLevel0(getRoute());

+        ComputedDataHelper.deleteComputedDataLevel1(getRoute());

+        ComputedDataHelper.deleteComputedDataLevel2(getRoute());

+        ComputedDataHelper.deleteComputedDataLevel3(getRoute());

+    @Override

+    public int getComputedTimeAtSeaN0() {

+        return 24 * sizeRoute();

+    }

+

+    @Override

+    public int sizeActivity() {

+        return (int) activityStream().count();

+    }

+

+    @Override

+    public boolean isActivityEmpty() {

+        return isRouteEmpty() || activityStream().count() == 0;

+    }

+

+    @Override

+    public boolean isActivityNotEmpty() {

+        return isRouteNotEmpty() && activityStream().count() > 0;

+    }

+

+    @Override

+    public List<Activity> getActivity() {

+        return activityStream().collect(Collectors.toList());

+    }

+

+    @Override

+    public void setActivity(List<Activity> activities) {

+        clearRoute();

+        for (Activity activity : activities) {

+            addActivity(activity);

+        }

+    }

+

+    @Override

+    public Activity getActivityByTopiaId(String topiaId) {

+        return activityStream().filter(a -> topiaId.equals(a.getTopiaId())).findFirst().orElse(null);

+    }

+

+    @Override

+    public Collection<String> getActivityTopiaIds() {

+        return activityStream().map(Activity::getTopiaId).collect(Collectors.toList());

+    }

+

+    @Override

+    public void addActivity(Activity activity) {

+        Date date = DateUtil.getDay(activity.getDate());

+        Optional<Route> optionalRoute = routeStream().filter(r -> Objects.equals(r.getDate(), date)).findFirst();

+        Route route;

+        if (optionalRoute.isPresent()) {

+            route = optionalRoute.get();

+        } else {

+            route = new RouteImpl();

+            route.setDate(date);

+            addRoute(route);

+        }

+        route.addActivity(activity);

+    }

+

+    @Override

+    public List<Route> getRoute() {

+        List<Route> route = super.getRoute();

+        if (route == null) {

+            setRoute(route = new LinkedList<>());

+        }

+        return route;

+    }

+

+    private Stream<Route> routeStream() {

+        return getRoute().stream();

+    }

+

+    private Stream<Activity> activityStream() {

+        return routeStream().flatMap(r -> r.getActivity().stream());

+    }

+                "FROM CountryImpl c, TripImpl t LEFT JOIN t.route as r LEFT JOIN r.activity as a " +

+                "FROM CountryImpl c, TripImpl t LEFT JOIN t.route as r LEFT JOIN r.activity as a " +

+     * @param samplesOnly if null no filter else filter on value

+    public Set<E> findAllUsedInTrip(Boolean samplesOnly) throws TopiaException {

+        String samplesOnlyFilter = samplesOnly == null ? "" : (" AND t.samplesOnly = " + samplesOnly);

+        String hql = "SELECT DISTINCT(vst) FROM VesselSimpleTypeImpl vst, TripImpl t WHERE t.vessel.vesselType.vesselSimpleType = vst.id" + samplesOnlyFilter;

+import fr.ird.t3.entities.data.Route;

+            // route decorator

+            registerJXPathDecorator(locale, Route.class, "${trip.vesselLabel}$s - ${trip.landingDate}$td/%2$tm/%2$tY - ${date}$td/%3$tm/%3$tY");

+

+package fr.ird.t3.services.migration;

+

+/*

+ * #%L

+ * T3 :: Domain

+ * %%

+ * Copyright (C) 2010 - 2017 IRD, Code Lutin, Ultreia.io

+ * %%

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

+ * 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%

+ */

+

+import com.google.auto.service.AutoService;

+import org.apache.commons.logging.Log;

+import org.apache.commons.logging.LogFactory;

+import org.nuiton.topia.migration.TopiaMigrationCallbackByClassNG;

+import org.nuiton.topia.persistence.TopiaException;

+import org.nuiton.topia.persistence.support.TopiaSqlQuery;

+import org.nuiton.topia.persistence.support.TopiaSqlSupport;

+import org.nuiton.util.DateUtil;

+import org.nuiton.version.Versions;

+

+import java.sql.Connection;

+import java.sql.PreparedStatement;