branch develop updated (70d655b -> dd58708)
This is an automated email from the git hooks/post-receive script. New change to branch develop in repository observe. See http://git.codelutin.com/observe.git from 70d655b Tout sur develop (mais il reste encore à gerer les traductions des messages) See #7493 Merge branch 'feature/7493' into develop new 4a0089a implantation du service de generation des rapport + test (refs #7498) new a43149f implantation du service de generation des rapport + test (refs #7498) new 9f49fbf implantation du service de generation des rapport + test (refs #7498) new dd58708 Merge sur develop (termine #7498) The 4 revisions listed above as "new" are entirely new to this repository and will be described in separate emails. The revisions listed as "adds" were already present in the repository and have only been added to this reference. Detailed log of new commits: commit dd58708693aa0e18c8fb86466417a53c7543fceb Merge: 70d655b 9f49fbf Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Sep 3 16:19:32 2015 +0200 Merge sur develop (termine #7498) commit 9f49fbf654ccbba2f3f57256cee2332414b1be24 Author: Sylvain Bavencoff <bavencoff@codelutin.com> Date: Thu Sep 3 10:12:20 2015 +0200 implantation du service de generation des rapport + test (refs #7498) commit a43149fa3931cd617db1157a6f9454b72308c11a Author: Sylvain Bavencoff <bavencoff@codelutin.com> Date: Thu Sep 3 10:11:26 2015 +0200 implantation du service de generation des rapport + test (refs #7498) commit 4a0089a1c8b27b0884ef95df4b9eb73aa7154af0 Author: Sylvain Bavencoff <bavencoff@codelutin.com> Date: Thu Sep 3 10:09:52 2015 +0200 implantation du service de generation des rapport + test (refs #7498) Summary of changes: .../fr/ird/observe/AbstractObserveTopiaDao.java | 18 + observe-services-api/pom.xml | 24 +- .../src/main/filters/observe-reports.properties | 8 +- .../service/actions}/report/ReportBuilder.java | 17 +- .../service/actions/report/ReportService.java | 20 + .../service/actions}/report/model/DataMatrix.java | 2 +- .../service/actions}/report/model/Report.java | 15 +- .../actions}/report/model/ReportOperation.java | 20 +- .../actions}/report/model/ReportRequest.java | 63 +- .../actions}/report/model/ReportVariable.java | 27 +- .../report/model/operations/ExecuteRequests.java | 45 +- .../report/model/operations/GroupByLength.java | 20 +- .../report/model/operations/SumColumn.java | 25 +- .../report/model/operations/SumIntColumn.java | 25 +- .../report/model/operations/SumIntRow.java | 25 +- .../actions}/report/model/operations/SumRow.java | 25 +- ...es.service.actions.report.model.ReportOperation | 6 + .../service/actions/report/ReportBuilderTest.java | 130 +++ .../actions/report/observe-reports-test.properties | 27 + .../service/actions/report/ReportServiceTopia.java | 207 +++++ .../report/AbstractReportServiceTopiaTest.java | 150 ++-- .../actions/report/ReportAccessoryCatch2Test.java | 199 +++++ .../report/ReportAccessoryCatchByGroup2Test.java | 68 ++ .../report/ReportAccessoryCatchByGroupTest.java | 100 +++ .../actions/report/ReportAccessoryCatchTest.java | 156 ++++ .../report/ReportActivityWithCommentTest.java | 348 ++++++++ .../actions/report/ReportAllActivitysTest.java | 943 +++++++++++++++++++++ .../actions/report/ReportDailySetAndCatchTest.java | 61 +- .../service/actions/report/ReportDcpUsageTest.java | 67 +- .../report/ReportSetByAssociation2Test.java | 14 +- .../actions/report/ReportSetByAssociationTest.java | 26 +- .../report/ReportTargetCatchByAssociationTest.java | 66 +- .../ReportTargetDiscardedByAssociationTest.java | 66 +- 33 files changed, 2655 insertions(+), 358 deletions(-) create mode 100644 observe-entities/src/main/java/fr/ird/observe/AbstractObserveTopiaDao.java copy {observe-business => observe-services-api}/src/main/filters/observe-reports.properties (99%) copy {observe-business/src/main/java/fr/ird/observe => observe-services-api/src/main/java/fr/ird/observe/services/service/actions}/report/ReportBuilder.java (97%) create mode 100644 observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/ReportService.java copy {observe-business/src/main/java/fr/ird/observe => observe-services-api/src/main/java/fr/ird/observe/services/service/actions}/report/model/DataMatrix.java (99%) copy {observe-business/src/main/java/fr/ird/observe => observe-services-api/src/main/java/fr/ird/observe/services/service/actions}/report/model/Report.java (88%) copy {observe-business/src/main/java/fr/ird/observe => observe-services-api/src/main/java/fr/ird/observe/services/service/actions}/report/model/ReportOperation.java (82%) copy {observe-business/src/main/java/fr/ird/observe => observe-services-api/src/main/java/fr/ird/observe/services/service/actions}/report/model/ReportRequest.java (86%) copy {observe-business/src/main/java/fr/ird/observe => observe-services-api/src/main/java/fr/ird/observe/services/service/actions}/report/model/ReportVariable.java (71%) copy {observe-business/src/main/java/fr/ird/observe => observe-services-api/src/main/java/fr/ird/observe/services/service/actions}/report/model/operations/ExecuteRequests.java (70%) copy {observe-business/src/main/java/fr/ird/observe => observe-services-api/src/main/java/fr/ird/observe/services/service/actions}/report/model/operations/GroupByLength.java (83%) copy {observe-business/src/main/java/fr/ird/observe => observe-services-api/src/main/java/fr/ird/observe/services/service/actions}/report/model/operations/SumColumn.java (84%) copy {observe-business/src/main/java/fr/ird/observe => observe-services-api/src/main/java/fr/ird/observe/services/service/actions}/report/model/operations/SumIntColumn.java (84%) copy {observe-business/src/main/java/fr/ird/observe => observe-services-api/src/main/java/fr/ird/observe/services/service/actions}/report/model/operations/SumIntRow.java (84%) copy {observe-business/src/main/java/fr/ird/observe => observe-services-api/src/main/java/fr/ird/observe/services/service/actions}/report/model/operations/SumRow.java (84%) create mode 100644 observe-services-api/src/main/resources/META-INF/services/fr.ird.observe.services.service.actions.report.model.ReportOperation create mode 100644 observe-services-api/src/test/java/fr/ird/observe/services/service/actions/report/ReportBuilderTest.java create mode 100644 observe-services-api/src/test/resources/fr/ird/observe/services/service/actions/report/observe-reports-test.properties create mode 100644 observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/report/ReportServiceTopia.java copy observe-business/src/test/java/fr/ird/observe/its/report/AbstractReportIT.java => observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/AbstractReportServiceTopiaTest.java (60%) create mode 100644 observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatch2Test.java create mode 100644 observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroup2Test.java create mode 100644 observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroupTest.java create mode 100644 observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchTest.java create mode 100644 observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportActivityWithCommentTest.java create mode 100644 observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAllActivitysTest.java copy observe-business/src/test/java/fr/ird/observe/its/report/dailySetAndCatch/ReportIT.java => observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDailySetAndCatchTest.java (53%) copy observe-business/src/test/java/fr/ird/observe/its/report/dcpUsage/ReportIT.java => observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDcpUsageTest.java (55%) copy observe-business/src/test/java/fr/ird/observe/its/report/setByAssociation/Report2IT.java => observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociation2Test.java (85%) copy observe-business/src/test/java/fr/ird/observe/its/report/setByAssociation/ReportIT.java => observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociationTest.java (83%) copy observe-business/src/test/java/fr/ird/observe/its/report/targetCatchByAssociation/ReportIT.java => observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetCatchByAssociationTest.java (56%) copy observe-business/src/test/java/fr/ird/observe/its/report/targetDiscardedByAssociation/ReportIT.java => observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetDiscardedByAssociationTest.java (55%) -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.
This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository observe. See http://git.codelutin.com/observe.git commit 4a0089a1c8b27b0884ef95df4b9eb73aa7154af0 Author: Sylvain Bavencoff <bavencoff@codelutin.com> Date: Thu Sep 3 10:09:52 2015 +0200 implantation du service de generation des rapport + test (refs #7498) --- .../fr/ird/observe/AbstractObserveTopiaDao.java | 18 + observe-services-api/pom.xml | 24 +- .../service/actions/report/ReportBuilder.java | 489 +++++++++++++++++++++ .../service/actions/report/ReportService.java | 20 + .../service/actions/report/model/DataMatrix.java | 259 +++++++++++ .../service/actions/report/model/Report.java | 157 +++++++ .../actions/report/model/ReportOperation.java | 106 +++++ .../actions/report/model/ReportRequest.java | 406 +++++++++++++++++ .../actions/report/model/ReportVariable.java | 80 ++++ .../report/model/operations/ExecuteRequests.java | 120 +++++ .../report/model/operations/GroupByLength.java | 111 +++++ .../actions/report/model/operations/SumColumn.java | 129 ++++++ .../report/model/operations/SumIntColumn.java | 129 ++++++ .../actions/report/model/operations/SumIntRow.java | 129 ++++++ .../actions/report/model/operations/SumRow.java | 129 ++++++ ...es.service.actions.report.model.ReportOperation | 6 + .../service/actions/report/ReportBuilderTest.java | 130 ++++++ .../actions/report/observe-reports-test.properties | 27 ++ .../service/actions/report/ReportServiceTopia.java | 207 +++++++++ 19 files changed, 2675 insertions(+), 1 deletion(-) diff --git a/observe-entities/src/main/java/fr/ird/observe/AbstractObserveTopiaDao.java b/observe-entities/src/main/java/fr/ird/observe/AbstractObserveTopiaDao.java new file mode 100644 index 0000000..d8e110f --- /dev/null +++ b/observe-entities/src/main/java/fr/ird/observe/AbstractObserveTopiaDao.java @@ -0,0 +1,18 @@ +package fr.ird.observe; + +import org.nuiton.topia.persistence.TopiaEntity; +import org.nuiton.topia.persistence.internal.AbstractTopiaDao; + +import java.util.List; +import java.util.Map; + +public abstract class AbstractObserveTopiaDao<E extends TopiaEntity> extends AbstractTopiaDao<E> { + + public <O> List<O> findAllFromHql(String hql, Map<String, Object> hqlParameters) { + + return findAll(hql, hqlParameters); + + } + + +} \ No newline at end of file diff --git a/observe-services-api/pom.xml b/observe-services-api/pom.xml index af0a253..d46fc6e 100644 --- a/observe-services-api/pom.xml +++ b/observe-services-api/pom.xml @@ -69,7 +69,29 @@ </dependencies> <build> - + <resources> + <resource> + <directory>src/main/resources</directory> + <includes> + <include>**/*</include> + </includes> + </resource> + <resource> + <directory>src/main/filters</directory> + <filtering>true</filtering> + <includes> + <include>*.properties</include> + </includes> + </resource> + </resources> + <testResources> + <testResource> + <directory>src/test/resources</directory> + <includes> + <include>**/*</include> + </includes> + </testResource> + </testResources> <plugins> <plugin> <groupId>com.thoughtworks.paranamer</groupId> diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/ReportBuilder.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/ReportBuilder.java new file mode 100644 index 0000000..55b40b3 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/ReportBuilder.java @@ -0,0 +1,489 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report; + + +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportOperation; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import fr.ird.observe.services.service.actions.report.model.ReportVariable; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.util.SortedProperties; + +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Enumeration; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.ServiceLoader; +import java.util.TreeMap; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * Classe responsable de la construction d'un report à partir de sa définition + * lue dans un fichier de propriétés. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.4 + */ +public class ReportBuilder { + + public static final Pattern REPORT_DEFINITION_PATTERN = Pattern.compile("report.(\\w+).name"); + + public static final String REQUEST_PREFIX = "request."; + + public static final String OPERATION_PREFIX = "operations."; + + public static final String VARIABLE_PREFIX = "variable."; + + public static final String REPEAT_VARIABLE_PREFIX = "repeatVariable."; + + /** Logger */ + private static final Log log = LogFactory.getLog(ReportBuilder.class); + + /** les propriétés chargées par le builder pour construire les reports */ + protected Properties properties; + + /** la liste des lastName sde reports connus par le système */ + protected List<String> reportNames; + + /** les operations connues par le système */ + protected static Map<String, Class<?>> operations; + + public static Map<String, Class<?>> getOperations() { + if (operations == null) { + operations = new TreeMap<String, Class<?>>(); + ServiceLoader<ReportOperation> loader = + ServiceLoader.load(ReportOperation.class); + for (ReportOperation op : loader) { + if (log.isInfoEnabled()) { + log.info("Detected operations : " + op.getOperationName()); + } + operations.put(op.getOperationName(), op.getClass()); + } + } + return operations; + } + + public static ReportOperation newOperation(String operationsName) { + Class<?> operationsType = getOperations().get(operationsName); + if (operationsType == null) { + throw new IllegalArgumentException("No such operations [" + operationsName + "], available operationss : " + getOperations().keySet()); + } + try { + Object result = operationsType.newInstance(); + return (ReportOperation) result; + } catch (Exception e) { + throw new IllegalStateException("Could not instanciate operations [" + operationsType + "]", e); + } + } + + public List<String> getReportNames() { + return reportNames; + } + + public List<Report> load(URL definition) throws IOException { + properties = new SortedProperties(); + InputStream in = definition.openStream(); + try { + properties.load(in); + } finally { + in.close(); + } + + reportNames = detectReportNames(); + if (log.isInfoEnabled()) { + log.info("Detected report names : " + reportNames); + } + + List<Report> reports = new ArrayList<Report>(); + for (String reportName : reportNames) { + Report report = build(reportName); + reports.add(report); + } + + return reports; + } + + + protected List<String> detectReportNames() { + List<String> reportNames = new ArrayList<String>(); + Enumeration<Object> keys = properties.keys(); + while (keys.hasMoreElements()) { + String key = (String) keys.nextElement(); + Matcher matcher = REPORT_DEFINITION_PATTERN.matcher(key); + if (!matcher.matches()) { + + // pas de match + continue; + } + String reportName = matcher.group(1); + if (log.isInfoEnabled()) { + log.info("Discover a new report : " + reportName); + } + reportNames.add(reportName); + } + return reportNames; + } + + protected Report build(String reportName) { + + Map<String, String> dico = detectReportProperties(reportName); + + if (log.isDebugEnabled()) { + log.debug("Will build report [" + reportName + "] with " + dico.size() + " properties (" + dico + ")."); + } + + String name = getValue(dico, "name").trim(); + String description = getValue(dico, "description").trim(); + String rows = getValue(dico, "rows"); + String columns = getValue(dico, "columns"); + String[] rowHeaders = rows == null ? null : rows.split(","); + if (rowHeaders != null) { + for (int i = 0; i < rowHeaders.length; i++) { + String rowHeader = rowHeaders[i]; + rowHeaders[i] = rowHeader.trim(); + } + } + String[] columnHeaders = columns == null ? null : columns.split(","); + if (columnHeaders != null) { + for (int i = 0; i < columnHeaders.length; i++) { + String columnHeader = columnHeaders[i]; + columnHeaders[i] = columnHeader.trim(); + } + } + ReportRequest[] requests = getRequests(reportName, dico); + ReportOperation[] operationss = getOperations(reportName, dico); + ReportVariable[] variables = getVariables(reportName, dico); + ReportVariable[] repeatVariables = getRepeatVariables(reportName, dico); + + // a la fin il ne devrait plus y avoir de propriétés pour le report + if (!dico.isEmpty()) { + if (log.isWarnEnabled()) { + log.warn("Il reste des propriétés non utilisées pour le report [" + reportName + "] : " + dico); + } + } + + Report report = new Report(reportName, + name, + description, + rowHeaders, + columnHeaders, + operationss, + variables, + repeatVariables, + requests + ); + + return report; + } + + protected Map<String, String> detectReportProperties(String reportName) { + + Map<String, String> dico = new TreeMap<String, String>(); + + // pour chaque report, on récupère ses informations + String reportKeyPrefix = "report." + reportName + "."; + int reportKeyPrefixLength = reportKeyPrefix.length(); + + Enumeration<Object> keys = properties.keys(); + while (keys.hasMoreElements()) { + String key = (String) keys.nextElement(); + if (!key.startsWith(reportKeyPrefix)) { + // pas de match + continue; + } + String realKey = key.substring(reportKeyPrefixLength); + dico.put(realKey, (String) properties.get(key)); + } + + return dico; + } + + protected ReportRequest[] getRequests(String reportName, Map<String, String> dico) { + + Map<Integer, String> requestDico = new TreeMap<Integer, String>(); + Map<Integer, String> requestRepeatDico = new TreeMap<Integer, String>(); + Iterator<Map.Entry<String, String>> itr = dico.entrySet().iterator(); + while (itr.hasNext()) { + Map.Entry<String, String> entry = itr.next(); + String key = entry.getKey(); + if (!key.startsWith(REQUEST_PREFIX)) { + + continue; + } + String REQUEST_REPEAT_SUFFIX = ".repeat"; + if (key.endsWith(REQUEST_REPEAT_SUFFIX)) { + + // definition d'un repeat + String request = entry.getValue(); + String requestId = key.substring(REQUEST_PREFIX.length()); + requestId = requestId.substring(0, requestId.length() - REQUEST_REPEAT_SUFFIX.length()); + Integer id = Integer.valueOf(requestId); + if (log.isInfoEnabled()) { + log.info("Detects a request repeat [" + reportName + ":" + id + "] = " + request); + } + requestRepeatDico.put(id, request); + itr.remove(); + continue; + } + String request = entry.getValue(); + String requestId = key.substring(REQUEST_PREFIX.length()); + Integer id = Integer.valueOf(requestId); + if (log.isDebugEnabled()) { + log.debug("Detects a request [" + reportName + ":" + id + "] = " + request); + } + requestDico.put(id, request); + itr.remove(); + + } + + // On trie les request + List<Integer> ids = new ArrayList<Integer>(requestDico.keySet()); + Collections.sort(ids); + + // on construit (dans le bon ordre la liste des requetes) + List<ReportRequest> result = new ArrayList<ReportRequest>(); + for (Integer id : ids) { + + String requestDef = requestDico.get(id); + String requestRepeatDef = requestRepeatDico.get(id); + + ReportRequest def = getRequest(requestDef, requestRepeatDef); + if (log.isInfoEnabled()) { + log.info("Detects a request : " + def); + } + result.add(def); + + } + return result.toArray(new ReportRequest[result.size()]); + } + + protected ReportRequest getRequest(String requestDef, + String requestRepeatDef) { + + String[] parts = requestDef.split("\\|"); + if (parts.length != 3) { + throw new IllegalArgumentException("La définition de la requete doit etre de type 'X,Y|layout|hql' mais est : " + requestDef); + } + String[] coords = parts[0].split(","); + String layout = parts[1]; + String hql = parts[2]; + + if (coords.length != 2) { + throw new IllegalArgumentException("La définition des coordonées doit etre de type 'X,Y' mais est : " + parts[0]); + } + + int x = Integer.valueOf(coords[0]); + int y = Integer.valueOf(coords[1]); + ReportRequest.RequestLayout realLayout = ReportRequest.RequestLayout.valueOf(layout); + + ReportRequest.RequestRepeat repeat = null; + if (requestRepeatDef != null) { + + // il y a un repeat + String[] repeatParts = requestRepeatDef.split("\\|"); + if (repeatParts.length != 2) { + throw new IllegalArgumentException("La définition d'un repéteur de requete doit etre de type 'repeatName|layout' mais est : " + requestRepeatDef); + } + String repeatName = repeatParts[0].trim(); + String repeatLayout = repeatParts[1].trim(); + ReportRequest.RequestLayout realRepeatLayout = + ReportRequest.RequestLayout.valueOf(repeatLayout); + repeat = new ReportRequest.RequestRepeat(repeatName, realRepeatLayout); + + } + ReportRequest def = new ReportRequest(realLayout, x, y, hql, repeat); + return def; + } + + protected ReportOperation[] getOperations(String reportName, Map<String, String> dico) { + + Map<Integer, String> requestDico = new TreeMap<Integer, String>(); + Iterator<Map.Entry<String, String>> itr = dico.entrySet().iterator(); + while (itr.hasNext()) { + Map.Entry<String, String> entry = itr.next(); + String key = entry.getKey(); + if (!key.startsWith(OPERATION_PREFIX)) { + + continue; + } + String operations = entry.getValue(); + String requestId = key.substring(OPERATION_PREFIX.length()); + Integer id = Integer.valueOf(requestId); + if (log.isDebugEnabled()) { + log.debug("Detects a operations [" + reportName + ":" + id + "] = " + operations); + } + requestDico.put(id, operations); + itr.remove(); + } + + // On trie les request + List<Integer> ids = new ArrayList<Integer>(requestDico.keySet()); + Collections.sort(ids); + + // on construit (dans le bon ordre la liste des requetes) + List<ReportOperation> result = new ArrayList<ReportOperation>(); + for (Integer id : ids) { + + String operationsDef = requestDico.get(id); + + ReportOperation def = getOperation(operationsDef); + if (log.isInfoEnabled()) { + log.info("Detects a operations : " + def); + } + result.add(def); + } + return result.toArray(new ReportOperation[result.size()]); + } + + protected ReportVariable[] getVariables(String reportName, Map<String, String> dico) { + List<ReportVariable> result = new ArrayList<ReportVariable>(); + Iterator<Map.Entry<String, String>> itr = dico.entrySet().iterator(); + List<String> ids = new ArrayList<String>(); + while (itr.hasNext()) { + Map.Entry<String, String> entry = itr.next(); + String key = entry.getKey(); + if (!key.startsWith(VARIABLE_PREFIX)) { + + continue; + } + String operations = entry.getValue(); + String id = key.substring(VARIABLE_PREFIX.length()); + + // on interdit la surcharge d'une variable déjà trouvée pour le report + if (ids.contains(id)) { + throw new IllegalArgumentException("La variable " + id + " est déjà définie pour le report " + reportName); + } + + // on interdit l'utilisation de la variable tripId + if (ReportRequest.TRIP_ID_VARIABLE.equals(id)) { + throw new IllegalArgumentException("La variable tripId n'est pas utilisable (c'est uen variable réservée) pour le report " + reportName); + } + ids.add(id); + String[] parts = operations.split("\\|"); + + if (parts.length != 2) { + throw new IllegalArgumentException("La définition d'une variable doit etre de la forme 'type|hql' mais est : " + operations); + } + String typeStr = parts[0].trim(); + String request = parts[1].trim(); + Class<?> type = null; + try { + type = Class.forName(typeStr); + } catch (ClassNotFoundException eee) { + throw new IllegalArgumentException("Le type " + typeStr + " n'est pas connu", eee); + } + ReportVariable variable = new ReportVariable(id, type, request); + if (log.isInfoEnabled()) { + log.info("Detects a variable : [" + reportName + ":" + variable.getName() + "] = " + variable.getRequest() + " (type = " + variable.getType().getName() + ")"); + } + result.add(variable); + itr.remove(); + } + return result.toArray(new ReportVariable[result.size()]); + } + + protected ReportVariable[] getRepeatVariables(String reportName, Map<String, String> dico) { + List<ReportVariable> result = new ArrayList<ReportVariable>(); + Iterator<Map.Entry<String, String>> itr = dico.entrySet().iterator(); + List<String> ids = new ArrayList<String>(); + while (itr.hasNext()) { + Map.Entry<String, String> entry = itr.next(); + String key = entry.getKey(); + if (!key.startsWith(REPEAT_VARIABLE_PREFIX)) { + + continue; + } + String operations = entry.getValue(); + String id = key.substring(REPEAT_VARIABLE_PREFIX.length()); + + // on interdit la surcharge d'une variable déjà trouvée pour le report + if (ids.contains(id)) { + throw new IllegalArgumentException("La variable de répétition " + id + " est déjà définie pour le report " + reportName); + } + + // on interdit l'utilisation de la variable tripId + if (ReportRequest.TRIP_ID_VARIABLE.equals(id)) { + throw new IllegalArgumentException("La variable de répétition tripId n'est pas utilisable (c'est uen variable réservée) pour le report " + reportName); + } + ids.add(id); + String[] parts = operations.split("\\|"); + + if (parts.length != 2) { + throw new IllegalArgumentException("La définition d'une variable de répétition doit etre de la forme 'type|hql' mais est : " + operations); + } + String typeStr = parts[0].trim(); + String request = parts[1].trim(); + Class<?> type = null; + try { + type = Class.forName(typeStr); + } catch (ClassNotFoundException eee) { + throw new IllegalArgumentException("Le type " + type + " n'est pas connu", eee); + } + ReportVariable variable = new ReportVariable(id, type, request); + if (log.isInfoEnabled()) { + log.info("Detects a variable : [" + reportName + ":" + variable.getName() + "] = " + variable.getRequest() + " (type = " + variable.getType().getName() + ")"); + } + result.add(variable); + itr.remove(); + } + return result.toArray(new ReportVariable[result.size()]); + } + + protected ReportOperation getOperation(String operationsDef) { + + // pour le moment, une operations n'a qu'une seule valeur : celle + // du lastName de l'opération + String operationsName = operationsDef; + + ReportOperation def = newOperation(operationsName); + return def; + } + + protected String getValue(Map<String, String> dico, String key) { + + String value = dico.get(key); + if (value != null) { + dico.remove(key); + } + return value; + } + + public void clear() { + if (reportNames != null) { + reportNames.clear(); + reportNames = null; + } + if (properties != null) { + properties.clear(); + properties = null; + } + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/ReportService.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/ReportService.java new file mode 100644 index 0000000..e184862 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/ReportService.java @@ -0,0 +1,20 @@ +package fr.ird.observe.services.service.actions.report; + +import fr.ird.observe.services.ObserveService; +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; + +import java.util.List; +import java.util.Map; + +/** + * @author Sylvain Bavencoff - bavencoff@codelutin.com + */ +public interface ReportService extends ObserveService { + + Report populateVariables(Report report, String tripId); + + DataMatrix executeReport(Report report, String tripId); + + <R> List<R> executeRequest(String request, Map<String, Object> params); +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/DataMatrix.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/DataMatrix.java new file mode 100644 index 0000000..c7c8bc6 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/DataMatrix.java @@ -0,0 +1,259 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report.model; + +import org.apache.commons.lang3.builder.ToStringBuilder; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.awt.Dimension; +import java.awt.Point; +import java.io.Serializable; + +/** + * Une matrice de données + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.4 + */ +public class DataMatrix { + + /** Logger */ + private static final Log log = LogFactory.getLog(DataMatrix.class); + + protected Object[][] data; + + protected int width; + + protected int height; + + protected int x; + + protected int y; + + public int getWidth() { + return width; + } + + public int getHeight() { + return height; + } + + public int getX() { + return x; + } + + public int getY() { + return y; + } + + public Object[][] getData() { + return data; + } + + public void setWidth(int width) { + this.width = width; + } + + public void setHeight(int height) { + this.height = height; + } + + public void setX(int x) { + this.x = x; + } + + public void setY(int y) { + this.y = y; + } + + public void createData() { + data = new Object[height][width]; + } + + public void setData(Object[][] data) { + this.data = data; + } + + public void copyData(DataMatrix incoming) { + + int x = incoming.getX(); + int y = incoming.getY(); + + Integer height = incoming.getHeight(); + Integer width = incoming.getWidth(); + + if (log.isDebugEnabled()) { + log.debug("copying incoming matrix (dim: " + + incoming.getDimension() + ", location: " + + incoming.getLocation() + ")"); + } + + for (int i = 0; i < width; i++) { + + for (int j = 0; j < height; j++) { + + Serializable value = incoming.getValue(i, j); + setValue(x + i, y + j, value); + } + } + } + + public Dimension getDimension() { + return new Dimension(width, height); + } + + public void setDimension(Dimension dim) { + height = (int) dim.getHeight(); + width = (int) dim.getWidth(); + } + + public Point getLocation() { + return new Point(x, y); + } + + public void setLocation(Point location) { + x = (int) location.getX(); + y = (int) location.getY(); + } + + public Serializable getValue(int x, int y) { + return data == null ? null : (Serializable) data[y][x]; + } + + public void setValue(int x, int y, Object data) { + + String cellData = data == null ? null : String.valueOf(data); + if (log.isDebugEnabled()) { + log.debug("Put data [" + x + "," + y + "] = " + cellData); + } + this.data[y][x] = cellData; + } + + public static Dimension getDimension(DataMatrix... datas) { + int width = 0; + int height = 0; + + for (DataMatrix request : datas) { + + int nWidth = request.getX() + request.getWidth(); + int nHeight = request.getY() + request.getHeight(); + if (nWidth > width) { + width = nWidth; + } + if (nHeight > height) { + height = nHeight; + } + } + return new Dimension(width, height); + } + + public static DataMatrix merge(DataMatrix... incomings) { + DataMatrix result = merge(-1, -1, incomings); + return result; + } + + public static DataMatrix merge(int rows, + int columns, + DataMatrix... incomings) { + Dimension dimension = getDimension(incomings); + + if (log.isDebugEnabled()) { + log.debug("Merge dimension : " + dimension); + } + + if (rows != -1) { + int height = (int) dimension.getHeight(); + // on verifie que récupère bien le bon count de lignes + if (rows != height) { + if (log.isWarnEnabled()) { + log.warn("No matching rows number : should have " + rows + + ", but was " + height); + } + } + } + + if (columns != -1) { + int width = (int) dimension.getWidth(); + // on verifie que récupère bien le bon count de colonnes + if (columns != width) { + if (log.isWarnEnabled()) { + log.warn("No matching columns number : should have " + + columns + ", but was " + width); + } + } + } + + DataMatrix result = new DataMatrix(); + result.setDimension(dimension); + result.createData(); + for (DataMatrix incoming : incomings) { + result.copyData(incoming); + } + return result; + } + + @Override + public String toString() { + ToStringBuilder builder = new ToStringBuilder(this); + builder.append("dimension", getDimension()); + builder.append("location", getLocation()); + return builder.toString(); + } + + public String getClipbordContent(boolean copyRowHeaders, + boolean copyColumnHeaders) { + + if (getWidth() <= 0 || getHeight() <= 0) { + return ""; + } + + StringBuilder buffer = new StringBuilder(); + + char sep = '\t'; + char eol = '\n'; + + for (int y = copyColumnHeaders ? 0 : 1, rows = getHeight(); y < rows; y++) { + + Serializable value; + + // nouvell ligne + + int x = copyRowHeaders ? 0 : 1; + + for (int columns = getWidth() - 1; x < columns; x++) { + + // sur chaque cellule (sauf la dernière) + value = getValue(x, y); + buffer.append(value).append(sep); + } + + // dernière cellule + value = getValue(x, y); + buffer.append(value); + + // fin de ligne + buffer.append(eol); + } + return buffer.toString(); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/Report.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/Report.java new file mode 100644 index 0000000..ea12c0e --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/Report.java @@ -0,0 +1,157 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report.model; + +import com.google.common.base.Predicate; +import com.google.common.collect.Iterables; +import com.google.common.collect.Lists; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.io.Serializable; + +import static org.nuiton.i18n.I18n.t; + +public class Report implements Serializable { + + /** Logger. */ + private static final Log log = LogFactory.getLog(Report.class); + + /** l'id du report. */ + protected final String id; + + /** le libellé court du report. */ + protected final String name; + + /** la description du report. */ + protected final String description; + + /** les libellés des colonnes du report. */ + protected final String[] columnHeaders; + + /** les libellés des lignes du report. */ + protected final String[] rowHeaders; + + /** la liste des requêtes à jouer. */ + protected final ReportRequest[] requests; + + /** la liste des opérations à jouer. */ + protected final ReportOperation[] operations; + + /** la liste des variables du report. */ + protected final ReportVariable[] variables; + + /** la liste des variables de type repeat du report */ + protected final ReportVariable[] repeatVariables; + + private static final long serialVersionUID = 1L; + + public Report(String id, + String name, + String description, + String[] rowHeaders, + String[] columnHeaders, + ReportOperation[] operations, + ReportVariable[] variables, + ReportVariable[] repeatVariables, + ReportRequest... requests) { + this.id = id; + this.name = name; + this.description = description; + this.rowHeaders = rowHeaders; + this.columnHeaders = columnHeaders; + this.requests = requests; + this.operations = operations; + this.variables = variables; + this.repeatVariables = repeatVariables; + if (log.isDebugEnabled()) { + log.debug("New report [" + id + ":" + name + "], nb requests : " + + requests.length + ", nb objectOperations : " + + operations.length + ", nb variables : " + + variables.length + ", nb repeat variables : " + + repeatVariables.length); + } + } + + public String getId() { + return id; + } + + public String getName() { + return name; + } + + public String getDescription() { + return description; + } + + public int getRows() { + return rowHeaders == null ? -1 : rowHeaders.length; + } + + public int getColumns() { + return columnHeaders == null ? -1 : columnHeaders.length; + } + + public String[] getColumnHeaders() { + return columnHeaders; + } + + public String[] getRowHeaders() { + return rowHeaders; + } + + public ReportRequest[] getRequests() { + return requests; + } + + public ReportOperation[] getOperations() { + return operations; + } + + public ReportVariable[] getVariables() { + return variables; + } + + public ReportVariable[] getRepeatVariables() { + return repeatVariables; + } + + public boolean isVariableRequired() { + return variables.length > 0; + } + + @Override + public String toString() { + return t(name); + } + + public ReportVariable getRepeatVariable(final String name) { + return Iterables.find(Lists.newArrayList(repeatVariables), new Predicate<ReportVariable>() { + @Override + public boolean apply(ReportVariable reportVariable) { + return name.equals(reportVariable.getName()); + } + }); + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/ReportOperation.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/ReportOperation.java new file mode 100644 index 0000000..c7da96e --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/ReportOperation.java @@ -0,0 +1,106 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report.model; + +import fr.ird.observe.services.service.actions.report.ReportService; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.awt.Dimension; +import java.awt.Point; +import java.io.Serializable; + +/** + * Pour caractériser une opération à lancer dans un report. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.4 + */ +public abstract class ReportOperation implements Serializable { + + private static final long serialVersionUID = 1L; + + /** Logger */ + private static final Log log = LogFactory.getLog(ReportOperation.class); + + public abstract String getOperationName(); + + /** + * Calcule la position où positionner le rsultat dans la matrice sortante. + * + * @param model le report + * @param incoming la matrice entrante + * @return la position de la première cellule + */ + protected abstract Point computeLocation(Report model, + DataMatrix incoming); + + /** + * Calcule la dimension du résultat de l'opération. + * + * @param model le report + * @param incoming la matrice entrante + * @return la dimension des données de l'opération + */ + protected abstract Dimension computeDimension(Report model, + DataMatrix incoming); + + /** + * Pour executer l'opération. + * + * @param reportService le service de raport + * @param model le modèle + * @param tripId l'identifiant du la maré + * @param incoming la matrice entrante + * @return la matrice sortante + * @pour toute erreur de manipulation de base + */ + public abstract DataMatrix execute(ReportService reportService, + Report model, + String tripId, + DataMatrix incoming); + + protected ReportOperation() { + } + + protected DataMatrix createTmpMatrix(Report model, DataMatrix incoming) { + + DataMatrix result = new DataMatrix(); + + // calcul de la position des résultats de l'opération + Point location = computeLocation(model, incoming); + result.setLocation(location); + + // calcul de la taille des résultats de l'opération + Dimension dim = computeDimension(model, incoming); + result.setDimension(dim); + + // creation de la matrice + result.createData(); + + if (log.isDebugEnabled()) { + log.debug("Operation [" + getOperationName() + "] tmp matrix : " + result); + } + return result; + } + +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/ReportRequest.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/ReportRequest.java new file mode 100644 index 0000000..bdc6acc --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/ReportRequest.java @@ -0,0 +1,406 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report.model; + +import com.google.common.collect.Maps; +import fr.ird.observe.services.service.actions.report.ReportService; +import org.apache.commons.lang3.builder.ToStringBuilder; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.awt.Dimension; +import java.awt.Point; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +/** + * Pour caractériser une requète à lancer dans un report. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.4 + */ +public class ReportRequest implements Serializable { + + private static final long serialVersionUID = 1L; + + /** Logger. */ + private static final Log log = LogFactory.getLog(ReportRequest.class); + + public static final String TRIP_ID_VARIABLE = "tripId"; + + /** le layout de la requete. */ + public enum RequestLayout { + /** lorsque les résultats de la requète sont les lignes du résultat. */ + row, + /** lorsque les résultats de la requète sont les colonnes du résultat. */ + column + } + + /** Un repeater optionnel sur la requête. */ + public static class RequestRepeat implements Serializable { + + protected final String variableName; + + protected final RequestLayout layout; + + private static final long serialVersionUID = 1L; + + public RequestRepeat(String variableName, RequestLayout layout) { + this.variableName = variableName; + this.layout = layout; + } + + public String getVariableName() { + return variableName; + } + + public RequestLayout getLayout() { + return layout; + } + + @Override + public String toString() { + ToStringBuilder builder = new ToStringBuilder(this); + builder.append("variableName", getVariableName()); + builder.append("layout", getLayout()); + return builder.toString(); + } + } + + /** layout de la requète. */ + protected final RequestLayout layout; + + /** la requète à exécuter. */ + protected final String request; + + /** la position de la requète. */ + protected final Point location; + + /** le repeater optionel. */ + protected final RequestRepeat repeat; + + public ReportRequest(RequestLayout layout, + int x, + int y, + String request, + RequestRepeat repeat) { + this.layout = layout; + this.request = request; + this.repeat = repeat; + location = new Point(x, y); + } + + public RequestLayout getLayout() { + return layout; + } + + public int getX() { + return (int) location.getX(); + } + + public int getY() { + return (int) location.getY(); + } + + public Point getLocation() { + return location; + } + + public String getRequest() { + return request; + } + + public RequestRepeat getRepeat() { + return repeat; + } + + public DataMatrix execute(ReportService reportService, + Report report, + String tripId, + ReportVariable repeatValues) { + + DataMatrix result = new DataMatrix(); + + Map<String, Object> params = extractParams(report, tripId); + + for (Object repeatValue : repeatValues.getValues()) { + params.put(repeat.getVariableName(), repeatValue); + DataMatrix tmp = execute(reportService, params); + if (result == null) { + + // premiere requete executee + result = tmp; + result.setX(0); + result.setY(0); + } else { + switch (repeat.getLayout()) { + + case row: + + // on ajoute le resultat a droite de celui deja present + tmp.setX(result.getX() + result.getWidth()); + tmp.setY(result.getY()); + break; + + case column: + + // on ajoute le resultat en dessous de celui deja present + tmp.setX(result.getX()); + tmp.setY(result.getY() + result.getHeight()); + break; + } + result = DataMatrix.merge(result, tmp); + } + } + result.setX(getX()); + result.setY(getY()); + if (log.isDebugEnabled()) { + log.debug("Result location : " + result.getLocation()); + log.debug("Result data :\n" + result.getClipbordContent(true, true)); + } + return result; + } + + public DataMatrix execute(ReportService reportService, + Report report, + String tripId) { + Map<String, Object> params = extractParams(report, tripId); + + DataMatrix dataMatrix = execute(reportService, params); + + return dataMatrix; + + + } + + public static Map<String, Object> extractParams(Report report, String tripId) { + + Map<String, Object> params = Maps.newHashMap(); + + params.put(TRIP_ID_VARIABLE, tripId); + + for (ReportVariable variable : report.getVariables()) { + + String name = variable.getName(); + + Object value = variable.getSelectedValue(); + + params.put(name, value); + + } + return params; + + } + + + protected DataMatrix execute(ReportService reportService, Map<String, Object> params) { + + // création des paramètres : couples (key, value) + if (log.isDebugEnabled()) { + log.debug("Request : " + request); + log.debug("Available params : " + params.keySet()); + log.debug("Params to use : " + params); + } + + // lancement de la requête + List<?> list = reportService.executeRequest(request, params); + if (log.isDebugEnabled()) { + log.debug("Result size : " + list.size()); + } + + // determination des dimensions du résultat + Dimension dimension = computeDimension(list); + if (log.isDebugEnabled()) { + log.debug("Result dimension : " + dimension); + } + + // construction du resultat + DataMatrix result = computeResult(dimension, list); + if (log.isDebugEnabled()) { + log.debug("Result location : " + result.getLocation()); + log.debug("Result data :\n" + result.getClipbordContent(true, true)); + } + return result; + } + + protected DataMatrix computeResult(Dimension dimension, List<?> list) { + + DataMatrix result = new DataMatrix(); + result.setDimension(dimension); + result.createData(); + + // le seul cas différent est le n-* (une ligne correspond à une colonne) + + int y = 0; + int x = 0; + + switch (layout) { + + case row: + + boolean uniqueColumn = result.getWidth() == 1; + + // les lignes du résultat sont les lignes du tableau + + for (Object row : list) { + + if (uniqueColumn) { + + // une seule colonne + result.setValue(0, y, row); + } else { + + x = 0; + Object[] cells = (Object[]) row; + for (Object cell : cells) { + result.setValue(x++, y, cell); + } + } + + // on passage a la ligne suivante + y++; + } + break; + case column: + + // les lignes du résultat sont les colonnes du tableau + + boolean uniqueRow = result.getHeight() == 1; + + for (Object col : list) { + + if (uniqueRow) { + + // une seule ligne + result.setValue(x, 0, col); + } else { + + y = 0; + Object[] cells = (Object[]) col; + for (Object cell : cells) { + result.setValue(x, y++, cell); + } + } + + // on passage a la colonne suivante + x++; + } + break; + } + + // on pousse la position du résultat + result.setX(getX()); + result.setY(getY()); + return result; + } + + protected Dimension computeDimension(List<?> list) { + + int height = 0; + int width = 0; + + switch (layout) { + + case row: + + // le count de result est le lastNamebre de lignes + height = list.size(); + + if (list.isEmpty()) { + + // vu qu'il n'y a pas de résultat, on ne peut rien dire + width = 0; + } else { + + Object o = list.get(0); + + if (o == null || !o.getClass().isArray()) { + + // une seule colonne + width = 1; + } else { + width = ((Object[]) o).length; + } + } + + break; + case column: + + // le count de result est le lastNamebre de colonnes + width = list.size(); + + if (list.isEmpty()) { + + // vu qu'il n'y a pas de résultat, on ne peut rien dire + height = 0; + } else { + + Object o = list.get(0); + + if (o == null || !o.getClass().isArray()) { + + // une seule ligne + height = 1; + } else { + height = ((Object[]) o).length; + } + } + + break; + } + return new Dimension(width, height); + } + + public static Object[] getParams(String request, Map<String, Object> params) { + + // on parcourt la liste de tous les paramètres pour savoir si on doit + // les inclure pour la requête donnée : + List<String> namesToUsed = new ArrayList<String>(); + for (String paramName : params.keySet()) { + if (request.contains(":" + paramName)) { + namesToUsed.add(paramName); + } + } + Object[] datas = new Object[namesToUsed.size() * 2]; + int index = 0; + for (String name : namesToUsed) { + Object value = params.get(name); + datas[index * 2] = name; + datas[index * 2 + 1] = value; + index++; + } + namesToUsed.clear(); + return datas; + } + + @Override + public String toString() { + ToStringBuilder builder = new ToStringBuilder(this); + builder.append("request", getRequest()); + builder.append("layout", getLayout()); + builder.append("location", getLocation()); + builder.append("repeatVariable", getRepeat()); + return builder.toString(); + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/ReportVariable.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/ReportVariable.java new file mode 100644 index 0000000..a06f6a0 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/ReportVariable.java @@ -0,0 +1,80 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report.model; + +import java.io.Serializable; +import java.util.Set; + +/** + * La définition d'une variable utilisable dans un report. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.7 + */ +public class ReportVariable implements Serializable { + + private static final long serialVersionUID = 1L; + + protected String name; + + protected Class type; + + protected String request; + + protected Set values; + + protected Object selectedValue; + + public ReportVariable(String name, Class type, String request) { + this.name = name; + this.type = type; + this.request = request; + } + + public String getName() { + return name; + } + + public Class<?> getType() { + return type; + } + + public String getRequest() { + return request; + } + + public Set getValues() { + return values; + } + + public void setValues(Set values) { + this.values = values; + } + + public Object getSelectedValue() { + return selectedValue; + } + + public void setSelectedValue(Object selectedValue) { + this.selectedValue = selectedValue; + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/ExecuteRequests.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/ExecuteRequests.java new file mode 100644 index 0000000..075a7c3 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/ExecuteRequests.java @@ -0,0 +1,120 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report.model.operations; + +import fr.ird.observe.services.service.actions.report.ReportService; +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportOperation; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import fr.ird.observe.services.service.actions.report.model.ReportVariable; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.awt.Dimension; +import java.awt.Point; + +/** + * Opération pour lancer les requètes d'un report. + * <p/> + * Cette opération est toujours exécuter en premier lors de la construction + * du résultat d'un report. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.4 + */ +public class ExecuteRequests extends ReportOperation { + + /** Logger */ + private static final Log log = LogFactory.getLog(ExecuteRequests.class); + + private static final long serialVersionUID = 1L; + + public static final String OPERATION_NAME = "ExecuteRequests"; + + public ExecuteRequests() { + } + + public String getOperationName() { + return OPERATION_NAME; + } + + @Override + public DataMatrix execute(ReportService reportService, + Report report, + String tripId, + DataMatrix incoming) { + + if (log.isDebugEnabled()) { + log.debug("Launch " + this); + } + + ReportRequest[] requests = report.getRequests(); + + DataMatrix[] requestResults = new DataMatrix[requests.length]; + + int i = 0; + for (ReportRequest request : requests) { + + ReportRequest.RequestRepeat repeatVariable = request.getRepeat(); + + DataMatrix result; + + if (repeatVariable == null) { + + // requete simple sans repetition + result = request.execute(reportService, report, tripId); + } else { + + // on a une requete avec repetition + String repeatVariableName = repeatVariable.getVariableName(); + ReportVariable repeat = report.getRepeatVariable(repeatVariableName); + + + result = request.execute(reportService, report, tripId, repeat); + + + } + + requestResults[i++] = result; + } + + int rows = report.getRows(); + int columns = report.getColumns(); + + DataMatrix result = DataMatrix.merge(rows, columns, requestResults); + return result; + } + + @Override + protected Point computeLocation(Report model, DataMatrix incoming) { + Point result = new Point(0, 0); + return result; + } + + @Override + protected Dimension computeDimension(Report model, DataMatrix incoming) { + + Dimension result = new Dimension(0, 0); + return result; + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/GroupByLength.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/GroupByLength.java new file mode 100644 index 0000000..effca69 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/GroupByLength.java @@ -0,0 +1,111 @@ +package fr.ird.observe.services.service.actions.report.model.operations; + +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2015 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ + + +import fr.ird.observe.services.service.actions.report.ReportService; +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportOperation; +import org.apache.commons.lang3.mutable.MutableInt; + +import java.awt.Dimension; +import java.awt.Point; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Set; + +/** + * To group by legnth (first column, second row is count). + * + * I don't know how to make this with hibernate the group by + sum does not work :(. + * + * Created on 5/23/15. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 4.0 + */ +public class GroupByLength extends ReportOperation { + + private static final long serialVersionUID = 1L; + + private static final String OPERATION_NAME = "GroupByLength"; + + @Override + public String getOperationName() { + return OPERATION_NAME; + } + + @Override + protected Point computeLocation(Report model, DataMatrix incoming) { + Point result = new Point(0, incoming.getHeight()); + return result; + } + + @Override + protected Dimension computeDimension(Report model, DataMatrix incoming) { + Set<String> lengths = new HashSet<String>(); + for (int i = 0; i < incoming.getHeight(); i++) { + lengths.add((String) incoming.getValue(0, i)); + } + Dimension result = new Dimension(incoming.getWidth(), lengths.size()); + return result; + } + + @Override + public DataMatrix execute(ReportService reportService, + Report report, + String tripId, + DataMatrix incoming) { + + // Première passe pour grouper par classe de taille + Map<String, MutableInt> data = new LinkedHashMap<String, MutableInt>(); + for (int i = 0, nbRows = incoming.getHeight(); i < nbRows; i++) { + + String length = (String) incoming.getValue(0, i); + Integer count = Integer.valueOf(incoming.getValue(1, i).toString()); + + MutableInt mutableInt = data.get(length); + if (mutableInt == null) { + mutableInt = new MutableInt(); + data.put(length, mutableInt); + } + mutableInt.add(count); + + } + + // Deuxième passe pour remplir la matrice + DataMatrix result = createTmpMatrix(report, incoming); + int row = 0; + for (Map.Entry<String, MutableInt> entry : data.entrySet()) { + String length = entry.getKey(); + MutableInt mutableInt = entry.getValue(); + result.setValue(0, row, length); + result.setValue(1, row, mutableInt.intValue()); + row++; + } + + return result; + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/SumColumn.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/SumColumn.java new file mode 100644 index 0000000..eb88fd2 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/SumColumn.java @@ -0,0 +1,129 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report.model.operations; + + +import fr.ird.observe.services.service.actions.report.ReportService; +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportOperation; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.awt.Dimension; +import java.awt.Point; +import java.io.Serializable; + +/** + * Opération pour calculer la somme de toutes les cellules d'une colonne. + * <p/> + * Le résultat de l'opération vient se placer dans une nouvelle ligne en bas + * du tableau. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.4 + */ +public class SumColumn extends ReportOperation { + + /** Logger */ + private static final Log log = + LogFactory.getLog(SumColumn.class); + + private static final long serialVersionUID = 1L; + + private static final String OPERATION_NAME = "SumColumn"; + + + public SumColumn() { + } + + public String getOperationName() { + return OPERATION_NAME; + } + + @Override + public DataMatrix execute(ReportService reportService, + Report report, + String tripId, + DataMatrix incoming) { + + if (log.isDebugEnabled()) { + log.debug("Launch " + this); + } + + // construction du resultat + + DataMatrix tmpMatrix = createTmpMatrix(report, incoming); + + for (int i = 0, nbColumns = incoming.getWidth(); i < nbColumns; i++) { + + Object result = getColumnData(i, incoming); + tmpMatrix.setValue(i, 0, result); + if (log.isDebugEnabled()) { + log.debug("objectOperation [" + i + ",0] = " + result); + } + } + + DataMatrix result = DataMatrix.merge(incoming, tmpMatrix); + return result; + } + + protected Object getColumnData(int column, DataMatrix incoming) { + Double result = 0d; + + int nbRows = incoming.getHeight(); + + for (int row = 0; row < nbRows; row++) { + Serializable o = incoming.getValue(column, row); + + if (o == null || "null".equals(o)) { + o = 0; + } + Double d; + try { + d = Double.valueOf(o.toString()); + } catch (NumberFormatException e) { + // une des données de la colonne n'est pas un count + // on sort directement + if (log.isDebugEnabled()) { + log.debug("Could not convert " + o + " to number", e); + } + return "-"; + } + result += d; + } + + return result; + } + + @Override + protected Point computeLocation(Report model, DataMatrix incoming) { + Point result = new Point(0, incoming.getHeight()); + return result; + } + + @Override + protected Dimension computeDimension(Report model, DataMatrix incoming) { + Dimension result = new Dimension(incoming.getWidth(), 1); + return result; + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/SumIntColumn.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/SumIntColumn.java new file mode 100644 index 0000000..364a07a --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/SumIntColumn.java @@ -0,0 +1,129 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report.model.operations; + + +import fr.ird.observe.services.service.actions.report.ReportService; +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportOperation; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.awt.Dimension; +import java.awt.Point; +import java.io.Serializable; + +/** + * Opération pour calculer la somme entière de toutes les cellules d'une colonne. + * <p/> + * Le résultat de l'opération vient se placer dans une nouvelle ligne en bas + * du tableau. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.4 + */ +public class SumIntColumn extends ReportOperation { + + /** Logger */ + private static final Log log = + LogFactory.getLog(SumIntColumn.class); + + private static final long serialVersionUID = 1L; + + private static final String OPERATION_NAME = "SumIntColumn"; + + + public SumIntColumn() { + } + + public String getOperationName() { + return OPERATION_NAME; + } + + @Override + public DataMatrix execute(ReportService reportService, + Report report, + String tripId, + DataMatrix incoming) { + + if (log.isDebugEnabled()) { + log.debug("Launch " + this); + } + + // construction du resultat + + DataMatrix tmpMatrix = createTmpMatrix(report, incoming); + + for (int i = 0, nbColumns = incoming.getWidth(); i < nbColumns; i++) { + + Object result = getColumnData(i, incoming); + tmpMatrix.setValue(i, 0, result); + if (log.isDebugEnabled()) { + log.debug("objectOperation [" + i + ",0] = " + result); + } + } + + DataMatrix result = DataMatrix.merge(incoming, tmpMatrix); + return result; + } + + protected Object getColumnData(int column, DataMatrix incoming) { + Double result = 0d; + + int nbRows = incoming.getHeight(); + + for (int row = 0; row < nbRows; row++) { + Serializable o = incoming.getValue(column, row); + + if (o == null || "null".equals(o)) { + o = 0; + } + Double d; + try { + d = Double.valueOf(o.toString()); + } catch (NumberFormatException e) { + // une des données de la colonne n'est pas un count + // on sort directement + if (log.isDebugEnabled()) { + log.debug("Could not convert " + o + " to number", e); + } + return "-"; + } + result += d; + } + + return result.intValue(); + } + + @Override + protected Point computeLocation(Report model, DataMatrix incoming) { + Point result = new Point(0, incoming.getHeight()); + return result; + } + + @Override + protected Dimension computeDimension(Report model, DataMatrix incoming) { + Dimension result = new Dimension(incoming.getWidth(), 1); + return result; + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/SumIntRow.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/SumIntRow.java new file mode 100644 index 0000000..66d2038 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/SumIntRow.java @@ -0,0 +1,129 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report.model.operations; + + +import fr.ird.observe.services.service.actions.report.ReportService; +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportOperation; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.awt.Dimension; +import java.awt.Point; +import java.io.Serializable; + +/** + * Opération pour calculer la somme entière de toutes les cellules d'une ligne. + * <p/> + * Le résultat de l'opération vient se placer dans une nouvelle colonne à + * droite du tableau. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.4 + */ +public class SumIntRow extends ReportOperation { + + /** Logger */ + private static final Log log = LogFactory.getLog(SumIntRow.class); + + public static final String OPERATION_NAME = "SumIntRow"; + + private static final long serialVersionUID = 1L; + + public SumIntRow() { + } + + public String getOperationName() { + return OPERATION_NAME; + } + + @Override + public DataMatrix execute(ReportService reportService, + Report report, + String tripId, + DataMatrix incoming) { + if (log.isDebugEnabled()) { + log.debug("Launch " + this); + } + + // construction du result + + DataMatrix tmpMatrix = createTmpMatrix(report, incoming); + + for (int i = 0, nbRows = incoming.getHeight(); i < nbRows; i++) { + + Object result = getRowData(i, incoming); + tmpMatrix.setValue(0, i, result); + if (log.isDebugEnabled()) { + log.debug("objectOperation [0, " + i + "] = " + result); + } + } + + DataMatrix result = DataMatrix.merge(incoming, tmpMatrix); + return result; + } + + + protected Object getRowData(int row, DataMatrix incoming) { + + Double result = 0d; + + int nbColumns = incoming.getWidth(); + + for (int col = 0; col < nbColumns; col++) { + Serializable o = incoming.getValue(col, row); + + if (o == null || "null".equals(o)) { + o = 0; + } + Double d; + try { + d = Double.valueOf(o.toString()); + } catch (NumberFormatException e) { + // une des données de la colonne n'est pas un count + // on sort directement + if (log.isDebugEnabled()) { + log.debug("Could not convert " + o + " to number", e); + } + return "-"; + } + result += d; + } + + return result.intValue(); + } + + @Override + protected Point computeLocation(Report model, DataMatrix incoming) { + Point result = new Point(incoming.getWidth(), 0); + return result; + } + + @Override + protected Dimension computeDimension(Report model, DataMatrix incoming) { + + Dimension result = new Dimension(1, incoming.getHeight()); + return result; + } +} diff --git a/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/SumRow.java b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/SumRow.java new file mode 100644 index 0000000..438da89 --- /dev/null +++ b/observe-services-api/src/main/java/fr/ird/observe/services/service/actions/report/model/operations/SumRow.java @@ -0,0 +1,129 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report.model.operations; + + +import fr.ird.observe.services.service.actions.report.ReportService; +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportOperation; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import java.awt.Dimension; +import java.awt.Point; +import java.io.Serializable; + +/** + * Opération pour calculer la somme de toutes les cellules d'une ligne. + * <p/> + * Le résultat de l'opération vient se placer dans une nouvelle colonne à + * droite du tableau. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.4 + */ +public class SumRow extends ReportOperation { + + /** Logger */ + private static final Log log = LogFactory.getLog(SumRow.class); + + public static final String OPERATION_NAME = "SumRow"; + + private static final long serialVersionUID = 1L; + + public SumRow() { + } + + public String getOperationName() { + return OPERATION_NAME; + } + + @Override + public DataMatrix execute(ReportService reportService, + Report report, + String tripId, + DataMatrix incoming) { + if (log.isDebugEnabled()) { + log.debug("Launch " + this); + } + + // construction du result + + DataMatrix tmpMatrix = createTmpMatrix(report, incoming); + + for (int i = 0, nbRows = incoming.getHeight(); i < nbRows; i++) { + + Object result = getRowData(i, incoming); + tmpMatrix.setValue(0, i, result); + if (log.isDebugEnabled()) { + log.debug("objectOperation [0, " + i + "] = " + result); + } + } + + DataMatrix result = DataMatrix.merge(incoming, tmpMatrix); + return result; + } + + + protected Object getRowData(int row, DataMatrix incoming) { + + Double result = 0d; + + int nbColumns = incoming.getWidth(); + + for (int col = 0; col < nbColumns; col++) { + Serializable o = incoming.getValue(col, row); + + if (o == null || "null".equals(o)) { + o = 0; + } + Double d; + try { + d = Double.valueOf(o.toString()); + } catch (NumberFormatException e) { + // une des données de la colonne n'est pas un count + // on sort directement + if (log.isDebugEnabled()) { + log.debug("Could not convert " + o + " to number", e); + } + return "-"; + } + result += d; + } + + return result; + } + + @Override + protected Point computeLocation(Report model, DataMatrix incoming) { + Point result = new Point(incoming.getWidth(), 0); + return result; + } + + @Override + protected Dimension computeDimension(Report model, DataMatrix incoming) { + + Dimension result = new Dimension(1, incoming.getHeight()); + return result; + } +} diff --git a/observe-services-api/src/main/resources/META-INF/services/fr.ird.observe.services.service.actions.report.model.ReportOperation b/observe-services-api/src/main/resources/META-INF/services/fr.ird.observe.services.service.actions.report.model.ReportOperation new file mode 100644 index 0000000..10334f3 --- /dev/null +++ b/observe-services-api/src/main/resources/META-INF/services/fr.ird.observe.services.service.actions.report.model.ReportOperation @@ -0,0 +1,6 @@ +fr.ird.observe.services.service.actions.report.model.operations.SumIntColumn +fr.ird.observe.services.service.actions.report.model.operations.SumColumn +fr.ird.observe.services.service.actions.report.model.operations.SumIntRow +fr.ird.observe.services.service.actions.report.model.operations.SumRow +fr.ird.observe.services.service.actions.report.model.operations.ExecuteRequests +fr.ird.observe.services.service.actions.report.model.operations.GroupByLength \ No newline at end of file diff --git a/observe-services-api/src/test/java/fr/ird/observe/services/service/actions/report/ReportBuilderTest.java b/observe-services-api/src/test/java/fr/ird/observe/services/service/actions/report/ReportBuilderTest.java new file mode 100644 index 0000000..d63920f --- /dev/null +++ b/observe-services-api/src/test/java/fr/ird/observe/services/service/actions/report/ReportBuilderTest.java @@ -0,0 +1,130 @@ +package fr.ird.observe.services.service.actions.report; + +import fr.ird.observe.services.dto.referential.SpeciesGroupDto; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportOperation; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import fr.ird.observe.services.service.actions.report.model.ReportVariable; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.net.URL; +import java.util.List; + +/** + * @author Sylvain Bavencoff - bavencoff@codelutin.com + */ +public class ReportBuilderTest { + + ReportBuilder reportBuilder; + + @Before + public void beforeTest() { + reportBuilder = new ReportBuilder(); + } + + + @Test + public void loadTest() throws Exception { + URL reportFileUrl = getClass().getResource("observe-reports-test.properties"); + + List<Report> reports = reportBuilder.load(reportFileUrl); + + Assert.assertNotNull(reports); + Assert.assertEquals(2, reports.size()); + + /* + Report 1 + */ + + Report report1 = reports.get(0); + + Assert.assertNotNull(report1); + Assert.assertEquals("reportOne", report1.getId()); + Assert.assertEquals("Rapport numéro 1", report1.getName()); + Assert.assertEquals("Description du rapport numéro 1", report1.getDescription()); + Assert.assertEquals(4, report1.getColumns()); + Assert.assertEquals("Colonne 1", report1.getColumnHeaders()[0]); + Assert.assertEquals("Colonne 2", report1.getColumnHeaders()[1]); + Assert.assertEquals("Colonne 3", report1.getColumnHeaders()[2]); + Assert.assertEquals("Dernière colonne", report1.getColumnHeaders()[3]); + + Assert.assertEquals(0, report1.getVariables().length); + Assert.assertEquals(0, report1.getRepeatVariables().length); + Assert.assertEquals(0, report1.getOperations().length); + Assert.assertEquals(1, report1.getRequests().length); + + ReportRequest request1_1 = report1.getRequests()[0]; + Assert.assertNotNull(request1_1); + Assert.assertEquals(0, request1_1.getX()); + Assert.assertEquals(0, request1_1.getY()); + Assert.assertEquals("Select * from uneTable;", request1_1.getRequest()); + + /* + Report 2 + */ + + Report report2 = reports.get(1); + + Assert.assertNotNull(report2); + Assert.assertEquals("reportTwo", report2.getId()); + Assert.assertEquals("Rapport numéro 2", report2.getName()); + Assert.assertEquals("Description du rapport numéro 2", report2.getDescription()); + Assert.assertEquals(5, report2.getColumns()); + Assert.assertEquals("Colonne 1", report2.getColumnHeaders()[0]); + Assert.assertEquals("Colonne 2", report2.getColumnHeaders()[1]); + Assert.assertEquals("Colonne 3", report2.getColumnHeaders()[2]); + Assert.assertEquals("Avant dernière colonne", report2.getColumnHeaders()[3]); + Assert.assertEquals("Total", report2.getColumnHeaders()[4]); + + Assert.assertEquals(1, report2.getVariables().length); + ReportVariable variable = report2.getVariables()[0]; + Assert.assertNotNull(variable); + Assert.assertEquals("groupId", variable.getName()); + Assert.assertEquals(SpeciesGroupDto.class, variable.getType()); + Assert.assertEquals("From SpeciesGroupImpl ge Order By ge.code", variable.getRequest()); + Assert.assertNull(variable.getValues()); + Assert.assertNull(variable.getSelectedValue()); + + Assert.assertEquals(1, report2.getRepeatVariables().length); + ReportVariable repeatVariable = report2.getRepeatVariables()[0]; + Assert.assertNotNull(repeatVariable); + Assert.assertEquals("typeObjetId", repeatVariable.getName()); + Assert.assertEquals(String.class, repeatVariable.getType()); + Assert.assertEquals("Select id from uneTable where group = :groupId order By code;", repeatVariable.getRequest()); + Assert.assertNull(repeatVariable.getValues()); + Assert.assertNull(repeatVariable.getSelectedValue()); + + + Assert.assertEquals(1, report2.getOperations().length); + ReportOperation operation = report2.getOperations()[0]; + Assert.assertNotNull(operation); + Assert.assertEquals("SumRow", operation.getOperationName()); + + + Assert.assertEquals(2, report2.getRequests().length); + + ReportRequest request2_1 = report2.getRequests()[0]; + Assert.assertNotNull(request2_1); + Assert.assertEquals(0, request2_1.getX()); + Assert.assertEquals(0, request2_1.getY()); + Assert.assertEquals("Select * from uneTable where id = :typeObjectId;", request2_1.getRequest()); + ReportRequest.RequestRepeat repeat1 = request2_1.getRepeat(); + Assert.assertNotNull(repeat1); + Assert.assertEquals("typeObjetId", repeat1.getVariableName()); + Assert.assertEquals(ReportRequest.RequestLayout.column, repeat1.getLayout()); + + ReportRequest request2_2 = report2.getRequests()[0]; + Assert.assertNotNull(request2_2); + Assert.assertEquals(0, request2_2.getX()); + Assert.assertEquals(0, request2_2.getY()); + Assert.assertEquals("Select * from uneTable where id = :typeObjectId;", request2_2.getRequest()); + ReportRequest.RequestRepeat repeat2 = request2_2.getRepeat(); + Assert.assertNotNull(repeat2); + Assert.assertEquals("typeObjetId", repeat2.getVariableName()); + Assert.assertEquals(ReportRequest.RequestLayout.column, repeat2.getLayout()); + + } + +} diff --git a/observe-services-api/src/test/resources/fr/ird/observe/services/service/actions/report/observe-reports-test.properties b/observe-services-api/src/test/resources/fr/ird/observe/services/service/actions/report/observe-reports-test.properties new file mode 100644 index 0000000..fe3a896 --- /dev/null +++ b/observe-services-api/src/test/resources/fr/ird/observe/services/service/actions/report/observe-reports-test.properties @@ -0,0 +1,27 @@ +################################################################################ +## Rapport 1 : +################################################################################ + +report.reportOne.name=Rapport num\u00e9ro 1 +report.reportOne.description=Description du rapport num\u00e9ro 1 +report.reportOne.columns=Colonne 1, Colonne 2, Colonne 3, Derni\u00e8re colonne +report.reportOne.request.1=0,0|row|\ + Select * from uneTable; + +################################################################################ +## Rapport 2 : +################################################################################ + +report.reportTwo.name=Rapport num\u00e9ro 2 +report.reportTwo.description=Description du rapport num\u00e9ro 2 +report.reportTwo.columns=Colonne 1, Colonne 2, Colonne 3, Avant derni\u00e8re colonne, Total +report.reportTwo.operations.1=SumRow +report.reportTwo.variable.groupId=fr.ird.observe.services.dto.referential.SpeciesGroupDto|From SpeciesGroupImpl ge Order By ge.code +report.reportTwo.repeatVariable.typeObjetId=java.lang.String|\ + Select id from uneTable where group = :groupId order By code; +report.reportTwo.request.1=0,0|row|\ + Select * from uneTable where id = :typeObjectId; +report.reportTwo.request.1.repeat=typeObjetId|column +report.reportTwo.request.2=1,0|row|\ + Select * from uneAutreTable where id = :typeObjectId; +report.reportTwo.request.2.repeat=typeObjetId|column \ No newline at end of file diff --git a/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/report/ReportServiceTopia.java b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/report/ReportServiceTopia.java new file mode 100644 index 0000000..00a26de --- /dev/null +++ b/observe-services-topia/src/main/java/fr/ird/observe/services/service/actions/report/ReportServiceTopia.java @@ -0,0 +1,207 @@ +package fr.ird.observe.services.service.actions.report; + +import com.google.common.collect.Maps; +import fr.ird.observe.AbstractObserveTopiaDao; +import fr.ird.observe.entities.seine.TripSeine; +import fr.ird.observe.services.ObserveServiceTopia; +import fr.ird.observe.services.dto.IdDto; +import fr.ird.observe.services.dto.ReferenceDto; +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportOperation; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import fr.ird.observe.services.service.actions.report.model.ReportVariable; +import fr.ird.observe.services.service.actions.report.model.operations.ExecuteRequests; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.nuiton.topia.persistence.TopiaEntity; + +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.TreeMap; + +/** + * @author Sylvain Bavencoff - bavencoff@codelutin.com + */ +public class ReportServiceTopia extends ObserveServiceTopia implements ReportService { + + private static final Log log = LogFactory.getLog(ReportServiceTopia.class); + + @Override + public Report populateVariables(Report report, String tripId) { + + Map<String, Object> vars = new TreeMap<String, Object>(); + + vars.put(ReportRequest.TRIP_ID_VARIABLE, tripId); + + for (ReportVariable variable : report.getVariables()) { + + LinkedHashSet<Object> values = new LinkedHashSet<>(); + + String hql = variable.getRequest(); + + Class<?> type = variable.getType(); + + if (IdDto.class.isAssignableFrom(type)) { + + Class<? extends IdDto> dtoType = (Class<? extends IdDto>) type; + + List<TopiaEntity> universe = executeRequest(hql, vars); + + for (TopiaEntity entity : universe) { + + ReferenceDto<?> dto = entityToReferenceDto(dtoType, entity); + + values.add(dto); + + } + + } else { + + List<Object> universe = executeRequest(hql, vars); + + values.addAll(universe); + + } + + variable.setValues(values); + } + + return report; + + } + + @Override + public DataMatrix executeReport(Report report, String tripId) { + + if (report == null) { + + // pas de report selectionne, donc pas de résultat + return null; + } + + if (!canExecute(report)) { + + // la requete n'est pas exécutable + return null; + } + + // remplissage des variables de répétition si nécessaire + doPopulateRepeatVariables(report, tripId); + + if (log.isDebugEnabled()) { + log.debug("Build result for report [" + report.getName() + + "] on " + tripId); + } + + int rows = report.getRows(); + int columns = report.getColumns(); + + if (log.isDebugEnabled()) { + log.debug("Dimension : [" + rows + "," + columns + "]"); + } + + + + // creation de la première opération qui exécute les requètes + ReportOperation firstRequest = ReportBuilder.newOperation(ExecuteRequests.OPERATION_NAME); + + // lancement de la première opération et la matrice de resultat + DataMatrix result = firstRequest.execute( + this, + report, + tripId, + new DataMatrix()); + + // lancement des opérations supplémentaires + for (ReportOperation objectOperation : report.getOperations()) { + + DataMatrix tmp = result; + if (log.isDebugEnabled()) { + log.debug("Apply objectOperation " + objectOperation + " to " + tmp); + } + result = objectOperation.execute( + this, + report, + tripId, + tmp); + } + if (log.isDebugEnabled()) { + log.debug("Final result : " + result); + } + return result; + } + + @Override + public <R> List<R> executeRequest(String request, Map<String, Object> params) { + + // si il y a des references de DTO dans les valeur des paramètres on les remplace par leur id + // on copie pour ne pas modifier le paramètre de la méthode + Map<String, Object> paramsFixes = Maps.newHashMap(); + + for (Map.Entry<String, Object> entry : params.entrySet()) { + + String name = entry.getKey(); + + if (request.contains(":" + name)) { + + Object value = entry.getValue(); + + if (value instanceof ReferenceDto) { + ReferenceDto referenceDto = (ReferenceDto) value; + + value = referenceDto.getId(); + + } + + paramsFixes.put(name, value); + } + + } + + AbstractObserveTopiaDao dao = (AbstractObserveTopiaDao) getTopiaPersistenceContext().getDao(TripSeine.class); + + List<R> result = dao.findAllFromHql(request, paramsFixes); + + return result; + } + + public boolean canExecute(Report report) { + + for (ReportVariable variable : report.getVariables()) { + + // on verifie qu'on a bien cette variable + String name = variable.getName(); + if (variable.getSelectedValue() == null) { + + if (log.isInfoEnabled()) { + log.info("variable " + name + " is missing"); + } + return false; + } + } + + // le report peut-être executé + return true; + } + + protected void doPopulateRepeatVariables(Report report, String tripId) { + + Map<String, Object> vars = ReportRequest.extractParams(report, tripId); + + for (ReportVariable variable : report.getRepeatVariables()) { + + String hql = variable.getRequest(); + + List<Object> universe = executeRequest(hql, vars); + + LinkedHashSet<Object> values = new LinkedHashSet<>(universe); + + variable.setValues(values); + } + + + } + +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.
This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository observe. See http://git.codelutin.com/observe.git commit a43149fa3931cd617db1157a6f9454b72308c11a Author: Sylvain Bavencoff <bavencoff@codelutin.com> Date: Thu Sep 3 10:11:26 2015 +0200 implantation du service de generation des rapport + test (refs #7498) --- .../report/AbstractReportServiceTopiaTest.java | 242 ++++++ .../actions/report/ReportAccessoryCatch2Test.java | 199 +++++ .../report/ReportAccessoryCatchByGroup2Test.java | 68 ++ .../report/ReportAccessoryCatchByGroupTest.java | 100 +++ .../actions/report/ReportAccessoryCatchTest.java | 156 ++++ .../report/ReportActivityWithCommentTest.java | 348 ++++++++ .../actions/report/ReportAllActivitysTest.java | 943 +++++++++++++++++++++ .../actions/report/ReportDailySetAndCatchTest.java | 103 +++ .../service/actions/report/ReportDcpUsageTest.java | 142 ++++ .../report/ReportSetByAssociation2Test.java | 50 ++ .../actions/report/ReportSetByAssociationTest.java | 128 +++ .../report/ReportTargetCatchByAssociationTest.java | 116 +++ .../ReportTargetDiscardedByAssociationTest.java | 116 +++ 13 files changed, 2711 insertions(+) diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/AbstractReportServiceTopiaTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/AbstractReportServiceTopiaTest.java new file mode 100644 index 0000000..302845c --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/AbstractReportServiceTopiaTest.java @@ -0,0 +1,242 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report; + + +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Iterables; +import fr.ird.observe.services.dto.ReferenceDtos; +import fr.ird.observe.services.service.AbstractServiceTopiaTest; +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import fr.ird.observe.services.service.actions.report.model.ReportVariable; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.io.IOException; +import java.net.URL; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * Classe abstraite de test d'un report. + * <p/> + * On définit ici le mécanisme pour tester unitairement un report et son + * résultat. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.9 + */ +public abstract class AbstractReportServiceTopiaTest extends AbstractServiceTopiaTest { + + /** Logger */ + private static final Log log = LogFactory.getLog(AbstractReportServiceTopiaTest.class); + + protected ReportService service; + + /** La liste de tous les reports connus. */ + protected static List<Report> reports; + + /** Le report à tester. */ + private Report report; + + protected abstract String getReportId(); + + @Override + public String getScriptName() { + return "dataForTestSeine"; + } + + @Override + public Set<String> getTestNamesChangeDataBase() { + return ImmutableSet.of(); + } + + @Before + public final void setUp() throws Exception { + + super.setUp(); + + service = newService(ReportService.class); + + // recuperation du report à tester + report = getReport(log, getReportId()); + + if (log.isInfoEnabled()) { + log.info("Will use report '" + report + "'"); + } + + } + + + /** + * L'unique test à lancer. + * <p/> + * On vérifie : + * <ul> + * <li>la syntaxe du report via {@link #testReportSyntax(Report)}</li> + * <li>le résultat du report via {@link #testReportResult(DataMatrix)}</li> + * </ul> + * + * @throws Exception pour toute erreur lors de l'execution du report + */ + @Test + public final void testReport() throws Exception { + + // test de la syntaxe du report + testReportSyntax(report); + + // creation de l'executeur de report + report = service.populateVariables(report, TRIP_SEINE_ID_1); + + // les variables a utiliser (par defaut, pas de variable) + Map<String, Object> variables = new HashMap<String, Object>(); + + // preparation des variables + prepareVariables(); + + + // on execute le report + DataMatrix result = service.executeReport(report, TRIP_SEINE_ID_1); + + if (log.isInfoEnabled()) { + log.info("Result :\n" + result.getClipbordContent(true, true)); + } + + // on verifie le resultat + testReportResult(result); + } + + protected void prepareVariables() { + + } + + protected void setVariableValue(String variableName, String id) { + + for (ReportVariable variable : report.getVariables()) { + + if (variableName.equals(variable.getName())) { + + Object value = Iterables.find(variable.getValues(), ReferenceDtos.newIdPredicate(id)); + + variable.setSelectedValue(value); + + } + + } + + } + + protected abstract void testReportSyntax(Report report); + + protected abstract void testReportResult(DataMatrix result); + + protected static Report getReport(Log log, String reportId) throws IOException { + if (reports == null) { + + URL reportLocation = + AbstractReportServiceTopiaTest.class.getResource("/observe-reports.properties"); + + if (log.isInfoEnabled()) { + log.info("Loading reports from " + reportLocation); + } + + ReportBuilder builder = new ReportBuilder(); + + reports = builder.load(reportLocation); + + builder.clear(); + + Assert.assertNotNull(reports); + Assert.assertFalse(reports.isEmpty()); + } + + Report result = null; + // recuperation du report à tester + for (Report report : reports) { + if (reportId.equals(report.getId())) { + result = report; + break; + } + } + + Assert.assertNotNull("Could not find report with id " + reportId, reports); + return result; + } + + protected void assertReportName(Report report, + String name, + String description) { + Assert.assertEquals(getReportId(), report.getId()); + Assert.assertEquals(name, report.getName()); + Assert.assertEquals(description, report.getDescription()); + } + + protected void assertReportDimension(Report report, + int rows, + int columns, + String[] columnsHeader, + String[] rowsHeader) { + Assert.assertEquals(rows, report.getRows()); + Assert.assertEquals(columns, report.getColumns()); + Assert.assertArrayEquals(columnsHeader, report.getColumnHeaders()); + Assert.assertArrayEquals(rowsHeader, report.getRowHeaders()); + } + + protected void assertReportNbRequests(Report report, int nbRequests) { + ReportRequest[] requests = report.getRequests(); + Assert.assertNotNull(requests); + Assert.assertEquals(nbRequests, requests.length); + } + + protected void assertReportRequestDimension(ReportRequest request, + ReportRequest.RequestLayout layout, + int x, + int y) { + Assert.assertEquals(layout, request.getLayout()); +// Assert.assertEquals(new Point(width, height), request.getLocation()); + Assert.assertEquals(x, request.getX()); + Assert.assertEquals(y, request.getY()); + } + + protected void assertResultDimension(DataMatrix result, + int width, + int height, + int x, + int y) { + Assert.assertEquals(width, result.getWidth()); + Assert.assertEquals(height, result.getHeight()); + Assert.assertEquals(x, result.getX()); + Assert.assertEquals(y, result.getY()); + } + + protected void assertResultRow(DataMatrix result, int rowId, Object... row) { + Object[] actualRow = result.getData()[rowId]; + Assert.assertArrayEquals(row, actualRow); + } +} diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatch2Test.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatch2Test.java new file mode 100644 index 0000000..0d821da --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatch2Test.java @@ -0,0 +1,199 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report; + + +import fr.ird.observe.services.service.actions.report.model.DataMatrix; + +/** + * Test du report {@code discardedAccessoire}. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.9 + */ +public class ReportAccessoryCatch2Test extends ReportAccessoryCatchTest { + + @Override + protected void prepareVariables() { + setVariableValue("speciesGroup", "fr.ird.observe.entities.referentiel.SpeciesGroup#1239832683689#0.12092280503502995"); + } + + + @Override + protected void testReportResult(DataMatrix result) { + assertResultDimension(result, 3, 151, 0, 0); + + int row = 0; + assertResultRow(result, row++, "[FAO]LUK [sc]Selene dorsalis [fr]Selene dorsalis", "-", "-"); + assertResultRow(result, row++, "[FAO]ABU [sc]Abudefduf saxatilis [fr]Sergent-major ", "-", "-"); + assertResultRow(result, row++, "[FAO]ALI [sc]Alepisaurus spp [fr]Lanciers nca", "-", "-"); + assertResultRow(result, row++, "[FAO]ALS [sc]Carcharhinus albimarginatus [fr]Requin pointe blanche", "-", "-"); + assertResultRow(result, row++, "[FAO]ALX [sc]Alepisaurus ferox [fr]Lancier longnez", "-", "-"); + assertResultRow(result, row++, "[FAO]AMB [sc]Seriola dumerili [fr]Purlish amberjack", "-", "-"); + assertResultRow(result, row++, "[FAO]AML [sc]Carcharhinus amblyrhynchos [fr]Grey reef shark", "-", "-"); + assertResultRow(result, row++, "[FAO]DDD [sc]Abudefduf vaigiensis [fr]Sergent-major", "-", "-"); + assertResultRow(result, row++, "[FAO]AVR [sc]Aprion virescens [fr]Job gris", "-", "-"); + assertResultRow(result, row++, "[FAO]- [sc]Balistes capriscus [fr]Baliste (Atlantique)", "-", "-"); + assertResultRow(result, row++, "[FAO]AJS [sc]Abalistes stellatus [fr]Baliste étoilé", "-", "+ Effectif : 20 Poids total (t) : 0.01"); + assertResultRow(result, row++, "[FAO]TRG [sc]Balistes carolinensis [fr]Baliste cabri ", "-", "-"); + assertResultRow(result, row++, "[FAO]BVP [sc]Balistes punctatus [fr]Baliste à taches bleues", "-", "-"); + assertResultRow(result, row++, "[FAO]BAR [sc]Sphyraena spp [fr]Barracudas nca", "-", "-"); + assertResultRow(result, row++, "[FAO]ALN [sc]Aluterus scriptus [fr]Bourse écriture", "+ Effectif : 1 Poids total (t) : 0.00050", "-"); + assertResultRow(result, row++, "[FAO]ALM [sc]Aluterus monoceros [fr]Bourse loulou", "-", "+ Effectif : 16 Poids total (t) : 0.01060"); + assertResultRow(result, row++, "[FAO]CNT [sc]Canthidermis maculata [fr]Baliste rude", "+ Effectif : 2 Poids total (t) : 0.00134", "+ Effectif : 2230 Poids total (t) : 1.49359"); + assertResultRow(result, row++, "[FAO]BAF [sc]Ablennes hians [fr]Orphie plate ", "-", "-"); + assertResultRow(result, row++, "[FAO]BLR [sc]Carcharhinus melanopterus [fr]Requin pointes noires", "-", "-"); + assertResultRow(result, row++, "[FAO]BON [sc]Sarda sarda [fr]Bonite à dos rayé", "-", "+ Effectif : 11"); + assertResultRow(result, row++, "[FAO]BPQ [sc]Brama japonica [fr]Castagnole du Pacific", "-", "-"); + assertResultRow(result, row++, "[FAO]BRA [sc]Brama spp. [fr]", "-", "-"); + assertResultRow(result, row++, "[FAO]BRZ [sc]Bramidae [fr]Famille Bramidae", "-", "-"); + assertResultRow(result, row++, "[FAO]BRO [sc]Carcharhinus brachyurus [fr]Requin cuivre", "-", "-"); + assertResultRow(result, row++, "[FAO]CAQ [sc]Catharacta lonnbergi [fr]Labbe brun", "-", "-"); + assertResultRow(result, row++, "[FAO]CBG [sc]Cubiceps gracilis [fr]Libine", "-", "-"); + assertResultRow(result, row++, "[FAO]DVH [sc]Cyclichthys orbicularis [fr]Cyclichthys orbicularis", "-", "-"); + assertResultRow(result, row++, "[FAO]CCL [sc]Carcharhinus limbatus [fr]Requin bordé", "-", "-"); + assertResultRow(result, row++, "[FAO]CCP [sc]Carcharhinus plumbeus [fr]Requin gris", "-", "-"); + assertResultRow(result, row++, "[FAO]MSD [sc]Decapterus macarellus [fr]Comète maquereau ", "+ Effectif : 47 Poids total (t) : 0.0024", "+ Effectif : 6 Poids total (t) : 0.0027"); + assertResultRow(result, row++, "[FAO]CLP [sc]Clupeidae [fr]Famille Clupeidae", "-", "-"); + assertResultRow(result, row++, "[FAO]NXU [sc]Caranx lugubris [fr]Carangue noire", "-", "-"); + assertResultRow(result, row++, "[FAO]CFW [sc]Coryphaena equiselis [fr]Coryphène dauphin", "+ Effectif : 2 Poids total (t) : 0.008", "-"); + assertResultRow(result, row++, "[FAO]DOL [sc]Coryphaena hippurus [fr]Coryphène commun", "+ Effectif : 5 Poids total (t) : 0.03824", "+ Effectif : 107 Poids total (t) : 0.57632"); + assertResultRow(result, row++, "[FAO]NGT [sc]Carangoides orthogrammus [fr]Carangue des îles ", "-", "-"); + assertResultRow(result, row++, "[FAO]CXS [sc]Caranx sexfasciatus [fr]Carangue vorace ", "-", "+ Effectif : 22 Poids total (t) : 0.01100"); + assertResultRow(result, row++, "[FAO]CRU [sc]Crustacea [fr]Crustacés nca", "-", "-"); + assertResultRow(result, row++, "[FAO]RUB [sc]Caranx crysos [fr]Carangue coubali", "-", "-"); + assertResultRow(result, row++, "[FAO]3CUH [sc]Uraspis helvola [fr]Carangue coton helvola", "-", "-"); + assertResultRow(result, row++, "[FAO]CUP [sc]Cubiceps spp [fr]Cubiceps nca", "-", "-"); + assertResultRow(result, row++, "[FAO]USE [sc]Uraspis secunda [fr]Carangue coton", "-", "-"); + assertResultRow(result, row++, "[FAO]3CUX [sc]Uraspis spp [fr]Carangue coton", "-", "-"); + assertResultRow(result, row++, "[FAO]CWZ [sc]Carcharhinus spp [fr]Requins Carcharhinus nca", "-", "-"); + assertResultRow(result, row++, "[FAO]CWZ [sc]Carcharhinus spp [fr]Requins Carcharhinus nca", "-", "-"); + assertResultRow(result, row++, "[FAO]DIY [sc]Diodon hystrix [fr]Porc-épic boubou ", "-", "-"); + assertResultRow(result, row++, "[FAO]DIO [sc]Diodontidae [fr]Famille Diodontidae", "+ Effectif : 1 Poids total (t) : 0.00050", "-"); + assertResultRow(result, row++, "[FAO]3DEY [sc]Diodon eydouxii [fr]Porc-épic", "-", "-"); + assertResultRow(result, row++, "[FAO]EAG [sc]Myliobatidae [fr]Aigles de mer nca", "-", "-"); + assertResultRow(result, row++, "[FAO]EHN [sc]Echeneis naucrates [fr]Rémora commun ", "+ Effectif : 7 Poids total (t) : 0.00350", "-"); + assertResultRow(result, row++, "[FAO]RRU [sc]Elagatis bipinnulata [fr]Commère saumon", "-", "+ Effectif : 211 Poids total (t) : 0.45108"); + assertResultRow(result, row++, "[FAO]HTL [sc]Phtheirichthys lineatus [fr]Rémora ", "-", "-"); + assertResultRow(result, row++, "[FAO]TRI [sc]Balistidae [fr]Famille Balistidae", "-", "-"); + assertResultRow(result, row++, "[FAO]BEN [sc]Belonidae [fr]Famille Belonidae", "-", "-"); + assertResultRow(result, row++, "[FAO]FBT [sc]Natator depressus [fr]Tortue plate", "-", "-"); + assertResultRow(result, row++, "[FAO]DOX [sc]Coryphaenidae [fr]Famille Coryphaenidae", "-", "-"); + assertResultRow(result, row++, "[FAO]CGX [sc]Carangidae [fr]Famille Carangidae", "+ Effectif : 1 Poids total (t) : 0.00050", "+ Effectif : 49 Poids total (t) : 0.02450"); + assertResultRow(result, row++, "[FAO]ECN [sc]Echeneidae [fr]Famille Echeneidae", "+ Effectif : 2 Poids total (t) : 0.00100", "-"); + assertResultRow(result, row++, "[FAO]SPA [sc]Ephippidae [fr]Famille Ephippidae", "-", "-"); + assertResultRow(result, row++, "[FAO]EXQ [sc]Euleptorhamphus velox [fr]Demi-bec volant ", "-", "-"); + assertResultRow(result, row++, "[FAO]FLY [sc]Exocoetidae [fr]Famille Exocoetidae", "-", "-"); + assertResultRow(result, row++, "[FAO]FIT [sc]Fistularia spp [fr]Cornettes", "-", "-"); + assertResultRow(result, row++, "[FAO]FFX [sc]Monacanthidae [fr]Poisson-lime", "-", "-"); + assertResultRow(result, row++, "[FAO]KYP [sc]Kyphosus spp [fr]Kyphosus calicagères nca ", "-", "-"); + assertResultRow(result, row++, "[FAO]3MOP [sc]Molidae [fr]Famille Molidae", "-", "-"); + assertResultRow(result, row++, "[FAO]DSF [sc]Pomacentridae [fr]Famille Pomacentridae", "-", "-"); + assertResultRow(result, row++, "[FAO]MAX [sc]Scombridae [fr]Famille Scombridae", "-", "-"); + assertResultRow(result, row++, "[FAO]BSX [sc]Serranidae [fr]Famille Serranidae", "-", "-"); + assertResultRow(result, row++, "[FAO]PUX [sc]Tetraodontidae [fr]Famille Tetraodontidae", "-", "-"); + assertResultRow(result, row++, "[FAO]GEP [sc]Gempylidae [fr]Escoliers, rouvets nca", "-", "-"); + assertResultRow(result, row++, "[FAO]GES [sc]Gempylus serpens [fr]Escolier serpent", "-", "-"); + assertResultRow(result, row++, "[FAO]JDP [sc]Dasyatis pastinaca [fr]Pastenague commune", "-", "-"); + assertResultRow(result, row++, "[FAO]KYC [sc]Kyphosus cinerascens [fr]Calicagère bleue ", "-", "-"); + assertResultRow(result, row++, "[FAO]KYS [sc]Kyphosus sectatrix [fr]Calicagère blanche ", "-", "-"); + assertResultRow(result, row++, "[FAO]KYV [sc]Kyphosus vaigiensis [fr]Caligagère", "-", "+ Effectif : 5 Poids total (t) : 0.0025"); + assertResultRow(result, row++, "[FAO]LAG [sc]Lampris guttatus [fr]Opah", "-", "-"); + assertResultRow(result, row++, "[FAO]LAM [sc]Lampris spp [fr]Saumon des dieux", "-", "-"); + assertResultRow(result, row++, "[FAO]LAP [sc]Lampris spp [fr]Opah", "-", "-"); + assertResultRow(result, row++, "[FAO]3LDI [sc]Lactoria diaphana [fr]Lactoria diaphana", "-", "-"); + assertResultRow(result, row++, "[FAO]LEC [sc]Lepidocybium flavobrunneum [fr]Escolier noir", "-", "-"); + assertResultRow(result, row++, "[FAO]LGH [sc]Lagocephalus lagocephalus [fr]Compère océanique ", "-", "-"); + assertResultRow(result, row++, "[FAO]LMA [sc]Isurus paucus [fr]Petite taupe, Mako", "-", "-"); + assertResultRow(result, row++, "[FAO]LOB [sc]Lobotes surinamensis [fr]Croupia roche ", "-", "+ Effectif : 28 Poids total (t) : 0.06754"); + assertResultRow(result, row++, "[FAO]LOP [sc]Lophotus capellei [fr]Roi des harengs", "-", "-"); + assertResultRow(result, row++, "[FAO]LVM [sc]Luvarus imperialis [fr]Luvar ", "-", "-"); + assertResultRow(result, row++, "[FAO]MRW [sc]Masturus lanceolatus [fr]Poisson-lune à queue pointue", "-", "-"); + assertResultRow(result, row++, "[FAO]MAW [sc]Scomberomorus tritor [fr]Thazard blanc", "-", "-"); + assertResultRow(result, row++, "[FAO]MAZ [sc]Scomber spp [fr]Maquereaux scomber nca", "-", "-"); + assertResultRow(result, row++, "[FAO]MOX [sc]Mola mola [fr]Poisson lune", "-", "-"); + assertResultRow(result, row++, "[FAO]MOP [sc]Mola spp [fr]Poissons lunes nca", "-", "-"); + assertResultRow(result, row++, "[FAO]MZZ [sc]Osteichthyes [fr]Poissons marins nca ", "-", "-"); + assertResultRow(result, row++, "[FAO]NAU [sc]Naucrates ductor [fr]Poisson pilote", "+ Effectif : 1 Poids total (t) : 0.00050", "-"); + assertResultRow(result, row++, "[FAO]NEN [sc]Nesiarchus nasutus [fr]Escolier long nez", "-", "-"); + assertResultRow(result, row++, "[FAO]NXI [sc]Caranx ignobilis [fr]Carangue têtue", "-", "-"); + assertResultRow(result, row++, "[FAO]OMZ [sc]Ommastrephidae [fr]Encornets Ommastrephidae nca", "-", "-"); + assertResultRow(result, row++, "[FAO]OOT [sc]Oreosoma atlanticum [fr]Oreosoma atlanticum ", "-", "-"); + assertResultRow(result, row++, "[FAO]OSF [sc]Stegostoma fasciatum [fr]Requin zèbre", "-", "-"); + assertResultRow(result, row++, "[FAO]PFM [sc]Pristipomoides filamentosus [fr]Colas fil", "-", "-"); + assertResultRow(result, row++, "[FAO]BAT [sc]Platax spp [fr]Poules d'eau ", "-", "-"); + assertResultRow(result, row++, "[FAO]BAO [sc]Platax teira [fr]Poule d'eau", "-", "-"); + assertResultRow(result, row++, "[FAO]POA [sc]Brama brama [fr]Grande castagnole", "-", "-"); + assertResultRow(result, row++, "[FAO]PRP [sc]Promethichthys prometheus [fr]Escolier clair", "-", "-"); + assertResultRow(result, row++, "[FAO]PSC [sc]Psenes cyanophrys [fr]Psenes cyanophrys", "-", "-"); + assertResultRow(result, row++, "[FAO]PSK [sc]Pseudocarcharias kamoharai [fr]Requin crocodile", "-", "-"); + assertResultRow(result, row++, "[FAO]RAJ [sc]Rajidae [fr]Rajidés nca", "-", "-"); + assertResultRow(result, row++, "[FAO]RZV [sc]Ranzania laevis [fr]Ranzania", "-", "-"); + assertResultRow(result, row++, "[FAO]3RAU [sc]Remora australis [fr]Rémora", "-", "-"); + assertResultRow(result, row++, "[FAO]RDB [sc]Dasyatis benneti [fr]Bennett s stingray", "-", "-"); + assertResultRow(result, row++, "[FAO]RDX [sc]Dasyatis ushiei [fr]Cow stingray", "-", "-"); + assertResultRow(result, row++, "[FAO]RDZ [sc]Dasyatis zugei [fr]Pale-edged stingray", "-", "-"); + assertResultRow(result, row++, "[FAO]RRL [sc]Remorina albescens [fr]Rémora blanche", "-", "-"); + assertResultRow(result, row++, "[FAO]REO [sc]Remora remora [fr]Rémora", "+ Effectif : 2 Poids total (t) : 0.001", "-"); + assertResultRow(result, row++, "[FAO]REZ [sc]Remora osteochir [fr]Rémora des marlins ", "-", "-"); + assertResultRow(result, row++, "[FAO]REY [sc]Remora brachyptera [fr]Rémora des espadons ", "-", "-"); + assertResultRow(result, row++, "[FAO]RMH [sc]Mobula hypostoma [fr]Mante diable", "-", "-"); + assertResultRow(result, row++, "[FAO]OIL [sc]Ruvettus pretiosus [fr]Rouvet", "-", "-"); + assertResultRow(result, row++, "[FAO]RXX [sc]Rexea spp. [fr]Rexea spp.", "-", "-"); + assertResultRow(result, row++, "[FAO]SBF [sc]Thunnus maccoyii [fr]Thon rouge du Sud", "-", "-"); + assertResultRow(result, row++, "[FAO]SDX [sc]Decapterus spp [fr]Comètes nca ", "-", "-"); + assertResultRow(result, row++, "[FAO]YTL [sc]Seriola rivoliana [fr]Sériole limon ", "-", "-"); + assertResultRow(result, row++, "[FAO]MAS [sc]Scomber japonicus [fr]Maquereau espagnol", "-", "-"); + assertResultRow(result, row++, "[FAO]SKH [sc]Selachimorpha [fr]Requins divers nca", "-", "-"); + assertResultRow(result, row++, "[FAO]SKX [sc]Elasmobranchii [fr]Requins, raies, etc. nca", "-", "-"); + assertResultRow(result, row++, "[FAO]SLP [sc]Hydrurga leptonyx [fr]Léopard de mer", "-", "-"); + assertResultRow(result, row++, "[FAO]SNK [sc]Thyrsites atun [fr]Escolier", "-", "-"); + assertResultRow(result, row++, "[FAO]GBA [sc]Sphyraena barracuda [fr]Barracuda", "-", "+ Effectif : 26 Poids total (t) : 0.11222"); + assertResultRow(result, row++, "[FAO]BAZ [sc]Sphyraenidae [fr]Famille Sphyraenidae", "-", "-"); + assertResultRow(result, row++, "[FAO]SPN [sc]Sphyrna spp [fr]Requins marteau nca", "-", "-"); + assertResultRow(result, row++, "[FAO]SQC [sc]Loligo spp [fr]Calmars Loligo nca", "-", "-"); + assertResultRow(result, row++, "[FAO]MAC [sc]Scomber scombrus [fr]Maquereau commun", "-", "-"); + assertResultRow(result, row++, "[FAO]SXH [sc]Scombrolabrax heterolepis [fr]Escolier aile longue", "-", "-"); + assertResultRow(result, row++, "[FAO]TAL [sc]Taractichthys longipinnis [fr]Big-scale pomfret", "-", "-"); + assertResultRow(result, row++, "[FAO]BTS [sc]Tylosurus crocodilus [fr]Aiguille crocodile ", "-", "+ Effectif : 1 Poids total (t) : 0.00050"); + assertResultRow(result, row++, "[FAO]TCR [sc]Taractes rubescens [fr]Keeltail pomfret", "-", "-"); + assertResultRow(result, row++, "[FAO]THM [sc]Thyrsitoides merleyi [fr]Escolier gracile", "-", "-"); + assertResultRow(result, row++, "[FAO]TJZ [sc]Trachipterus jacksonensis [fr]", "-", "-"); + assertResultRow(result, row++, "[FAO]TRE [sc]Caranx spp [fr]Chinchards, carangues nca", "-", "-"); + assertResultRow(result, row++, "[FAO]TRQ [sc]Trachipterus trachipterus [fr]Mediterranean dealfish", "-", "-"); + assertResultRow(result, row++, "[FAO]TRW [sc]Trachipterus ishikawae [fr]", "-", "-"); + assertResultRow(result, row++, "[FAO]TST [sc]Taractichtys steindachneri [fr]Castagnole fauchoire", "-", "-"); + assertResultRow(result, row++, "[FAO]TUS [sc]Thunnus spp [fr]Thons Thunnus nca", "-", "-"); + assertResultRow(result, row++, "[FAO]UBP [sc]Cubiceps capensis [fr]Dérivant", "-", "-"); + assertResultRow(result, row++, "[FAO]URU [sc]Uraspis uraspis [fr]Carangue paia ", "-", "-"); + assertResultRow(result, row++, "[FAO]VLF* [sc]Very long fish nei [fr]Très longs poissons nca", "-", "-"); + assertResultRow(result, row++, "[FAO]VVL* [sc]Very very long fish nei [fr]Très très longs poissons nca", "-", "-"); + assertResultRow(result, row++, "[FAO]WAH [sc]Acanthocybium solandri [fr]Thazard bâtard", "-", "+ Effectif : 90 Poids total (t) : 0.6800"); + assertResultRow(result, row++, "[FAO]WHH [sc]Tetrapturus spp [fr]Makaires Tetrapturus nca", "-", "-"); + assertResultRow(result, row++, "[FAO]9XXX [sc]Indéterminé [fr]Indéterminé", "-", "-"); + assertResultRow(result, row++, "[FAO]XXX* [sc] [fr]", "-", "-"); + assertResultRow(result, row++, "[FAO]YMO [sc]Sthenoteuthis oualaniensis [fr]Encornet bande violette", "-", "-"); + assertResultRow(result, row++, "[FAO]YTC [sc]Seriola lalandi [fr]Sériole chicard", "-", "-"); + assertResultRow(result, row++, "[FAO]ZAO [sc]Zanclus cornutus [fr]Zanclus cornutus", "-", "-"); + } + +} diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroup2Test.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroup2Test.java new file mode 100644 index 0000000..09c5776 --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroup2Test.java @@ -0,0 +1,68 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report; + + +import fr.ird.observe.services.service.actions.report.model.DataMatrix; + +/** + * Pour tester le report {@code discardedAccessoireByGroup} + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.9 + */ +public class ReportAccessoryCatchByGroup2Test extends ReportAccessoryCatchByGroupTest { + + @Override + protected void prepareVariables() { + setVariableValue("speciesGroup", "fr.ird.observe.entities.referentiel.SpeciesGroup#1239832683689#0.12092280503502995"); + } + + @Override + protected void testReportResult(DataMatrix result) { + assertResultDimension(result, 11, 21, 0, 0); + + int row = 0; + assertResultRow(result, row++, "[FAO]AJS [sc]Abalistes stellatus [fr]Baliste étoilé", "0", "20", "0", "0", "0", "20", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]ALN [sc]Aluterus scriptus [fr]Bourse écriture", "1", "0", "0", "0", "0", "1", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]ALM [sc]Aluterus monoceros [fr]Bourse loulou", "0", "16", "0", "0", "2", "14", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]CNT [sc]Canthidermis maculata [fr]Baliste rude", "2", "2230", "0", "0", "185", "1981", "0", "0", "66", "0.0"); + assertResultRow(result, row++, "[FAO]BON [sc]Sarda sarda [fr]Bonite à dos rayé", "0", "11", "0", "0", "0", "11", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]MSD [sc]Decapterus macarellus [fr]Comète maquereau ", "47", "6", "0", "0", "0", "6", "0", "0", "47", "0.0"); + assertResultRow(result, row++, "[FAO]CFW [sc]Coryphaena equiselis [fr]Coryphène dauphin", "2", "0", "0", "0", "0", "2", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]DOL [sc]Coryphaena hippurus [fr]Coryphène commun", "5", "107", "0", "0", "1", "59", "0", "37", "15", "0.0"); + assertResultRow(result, row++, "[FAO]CXS [sc]Caranx sexfasciatus [fr]Carangue vorace ", "0", "22", "0", "0", "1", "18", "0", "0", "3", "0.0"); + assertResultRow(result, row++, "[FAO]DIO [sc]Diodontidae [fr]Famille Diodontidae", "1", "0", "0", "0", "1", "0", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]EHN [sc]Echeneis naucrates [fr]Rémora commun ", "7", "0", "0", "0", "6", "1", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]RRU [sc]Elagatis bipinnulata [fr]Commère saumon", "0", "211", "0", "0", "25", "177", "0", "0", "9", "0.0"); + assertResultRow(result, row++, "[FAO]CGX [sc]Carangidae [fr]Famille Carangidae", "1", "49", "0", "0", "7", "43", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]ECN [sc]Echeneidae [fr]Famille Echeneidae", "2", "0", "0", "0", "2", "0", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]KYV [sc]Kyphosus vaigiensis [fr]Caligagère", "0", "5", "0", "0", "0", "5", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]LOB [sc]Lobotes surinamensis [fr]Croupia roche ", "0", "28", "0", "0", "1", "26", "0", "0", "1", "0.0"); + assertResultRow(result, row++, "[FAO]NAU [sc]Naucrates ductor [fr]Poisson pilote", "1", "0", "0", "0", "1", "0", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]REO [sc]Remora remora [fr]Rémora", "2", "0", "0", "0", "2", "0", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]GBA [sc]Sphyraena barracuda [fr]Barracuda", "0", "26", "0", "0", "3", "23", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]BTS [sc]Tylosurus crocodilus [fr]Aiguille crocodile ", "0", "1", "0", "0", "1", "0", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]WAH [sc]Acanthocybium solandri [fr]Thazard bâtard", "0", "90", "0", "0", "3", "85", "0", "0", "2", "0.0"); + + } +} diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroupTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroupTest.java new file mode 100644 index 0000000..21fa2c1 --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroupTest.java @@ -0,0 +1,100 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report; + +import fr.ird.observe.services.service.actions.report.AbstractReportServiceTopiaTest; +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import org.junit.Assert; + +/** + * Pour tester le report {@code discardedAccessoireByGroup} + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.9 + */ +public class ReportAccessoryCatchByGroupTest extends AbstractReportServiceTopiaTest { + + @Override + protected void testReportSyntax(Report report) { + Assert.assertNotNull(report); + assertReportName( + report, + "Dénombrement des captures accessoires et devenir, filtrés par groupe", + "Afficher les nombres de captures accessoires par groupe d'espèce selon le type de banc et le devenir" + ); + + assertReportDimension( + report, + -1, + 11, + new String[]{"Espèce", + "Total BL", + "Total BO", + "Sorti vivant/échappé", + "Sorti mort", + "Rejeté vivant", + "Rejeté mort", + "Partiellement conservé", + "Cuve", + "Cuisine", + "Autre" + }, + null + ); + + assertReportNbRequests(report, 1); + + ReportRequest[] requests = report.getRequests(); + + assertReportRequestDimension( + requests[0], + ReportRequest.RequestLayout.row, + 0, + 0 + ); + } + + @Override + protected String getReportId() { + return "accessoryCatchByGroup"; + } + + @Override + protected void prepareVariables() { + setVariableValue("speciesGroup", "fr.ird.observe.entities.referentiel.SpeciesGroup#1239832683689#0.7120116158620075"); + } + + @Override + protected void testReportResult(DataMatrix result) { + assertResultDimension(result, 11, 6, 0, 0); + + int row = 0; + assertResultRow(result, row++, "[FAO]FAL [sc]Carcharhinus falciformis [fr]Requin soyeux", "0", "17", "0", "0", "10", "7", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]OCS [sc]Carcharhinus longimanus [fr]Requin océanique", "1", "0", "0", "0", "1", "0", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]RSK [sc]Carcharhinidae spp [fr]Famille Carcharhinidae", "0", "11", "0", "0", "5", "6", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]STT [sc]Dasyatidae [fr]Famille Dasyatidae", "7", "0", "0", "0", "6", "0", "0", "0", "0", "1.0"); + assertResultRow(result, row++, "[FAO]SPY [sc]Sphyrnidae [fr]Famille Sphyrnidae", "0", "1", "0", "0", "1", "0", "0", "0", "0", "0.0"); + assertResultRow(result, row++, "[FAO]RMB [sc]Manta birostris [fr]Mante atlantique", "9", "0", "0", "0", "9", "0", "0", "0", "0", "0.0"); + } +} diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchTest.java new file mode 100644 index 0000000..dbfe11c --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchTest.java @@ -0,0 +1,156 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report; + + +import fr.ird.observe.services.service.actions.report.AbstractReportServiceTopiaTest; +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import org.junit.Assert; + +/** + * Test du report {@code accessoryCatch}. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.9 + */ +public class ReportAccessoryCatchTest extends AbstractReportServiceTopiaTest { + + @Override + protected void testReportSyntax(Report report) { + Assert.assertNotNull(report); + assertReportName( + report, + "Liste des captures accessoires selon le type de banc, filtrées par groupe", + "Afficher les captures accessoires par groupe d'espèce\n" + + "Les poids sont exprimés en tonnes." + ); + + assertReportDimension( + report, + -1, + 3, + new String[]{"Espèce", + "Banc libre", + "Banc objet", + }, + null + ); + + assertReportNbRequests(report, 3); + + ReportRequest[] requests = report.getRequests(); + + assertReportRequestDimension( + requests[0], + ReportRequest.RequestLayout.row, + 0, + 0 + ); + assertReportRequestDimension( + requests[1], + ReportRequest.RequestLayout.row, + 1, + 0 + ); + assertReportRequestDimension( + requests[2], + ReportRequest.RequestLayout.row, + 2, + 0 + ); + } + + @Override + protected String getReportId() { + return "accessoryCatch"; + } + + @Override + protected void prepareVariables() { + setVariableValue("speciesGroup", "fr.ird.observe.entities.referentiel.SpeciesGroup#1239832683689#0.7120116158620075"); + } + + @Override + protected void testReportResult(DataMatrix result) { + assertResultDimension(result, 3, 54, 0, 0); + + int row = 0; + assertResultRow(result, row++, "[FAO]MAE [sc]Aetobatus narinari [fr]Aigle de mer léopard", "-", "-"); + assertResultRow(result, row++, "[FAO]PTH [sc]Alopias pelagicus [fr]Renard pélagique", "-", "-"); + assertResultRow(result, row++, "[FAO]BTH [sc]Alopias superciliosus [fr]Renard à gros yeux", "-", "-"); + assertResultRow(result, row++, "[FAO]ALV [sc]Alopias vulpinus [fr]Renard", "-", "-"); + assertResultRow(result, row++, "[FAO]WSH [sc]Carcharodon carcharias [fr]Grand requin blanc", "-", "-"); + assertResultRow(result, row++, "[FAO]CCE [sc]Carcharhinus leucas [fr]Requin-bouledogue", "-", "-"); + assertResultRow(result, row++, "[FAO]FAL [sc]Carcharhinus falciformis [fr]Requin soyeux", "-", "+ Effectif : 17 Poids total (t) : 0.1753"); + assertResultRow(result, row++, "[FAO]OCS [sc]Carcharhinus longimanus [fr]Requin océanique", "+ Effectif : 1 Poids total (t) : 0.0447", "-"); + assertResultRow(result, row++, "[FAO]DUS [sc]Carcharhinus obscurus [fr]Requin sombre", "-", "-"); + assertResultRow(result, row++, "[FAO]PLS [sc]Dasyatys (Pteroplatytrygon) violacea [fr]Pastenague violette", "-", "-"); + assertResultRow(result, row++, "[FAO]SHL [sc]Etmopterus spp [fr]Genre Etmopterus", "-", "-"); + assertResultRow(result, row++, "[FAO]THR [sc]Alopias spp [fr]Renards de mer nca ", "-", "-"); + assertResultRow(result, row++, "[FAO]RSK [sc]Carcharhinidae spp [fr]Famille Carcharhinidae", "-", "+ Effectif : 11 Poids total (t) : 0.55"); + assertResultRow(result, row++, "[FAO]STT [sc]Dasyatidae [fr]Famille Dasyatidae", "+ Effectif : 7 Poids total (t) : 0.015", "-"); + assertResultRow(result, row++, "[FAO]MSK [sc]Lamnidae [fr]Famille Lamnidae", "-", "-"); + assertResultRow(result, row++, "[FAO]2FOD [sc]Odontaspididae [fr]Odontaspididae", "-", "-"); + assertResultRow(result, row++, "[FAO]- [sc]Rhincodontidae [fr]Famille Rhincodontidae", "-", "-"); + assertResultRow(result, row++, "[FAO]SPY [sc]Sphyrnidae [fr]Famille Sphyrnidae", "-", "+ Effectif : 1"); + assertResultRow(result, row++, "[FAO]TIG [sc]Galeocerdo cuvier [fr]Requin tigre commun", "-", "-"); + assertResultRow(result, row++, "[FAO]ISB [sc]Isistius brasiliensis [fr]Squalelet féroce", "-", "-"); + assertResultRow(result, row++, "[FAO]SMA [sc]Isurus oxyrinchus [fr]Taupe bleu", "-", "-"); + assertResultRow(result, row++, "[FAO]MAK [sc]Isurus spp [fr]Taupes", "-", "-"); + assertResultRow(result, row++, "[FAO]MAN [sc]Mobulidae [fr]Mantes, diables de mer nca ", "-", "-"); + assertResultRow(result, row++, "[FAO]MYL [sc]Myliobatis aquila [fr]Aigle commun", "-", "-"); + assertResultRow(result, row++, "[FAO]RMB [sc]Manta birostris [fr]Mante atlantique", "+ Effectif : 9 Poids total (t) : 1.1824", "-"); + assertResultRow(result, row++, "[FAO]RMT [sc]Mobula tarapacana [fr]Diable géant de Guinée", "-", "-"); + assertResultRow(result, row++, "[FAO]MNT [sc]Manta spp [fr]Raies manta", "-", "-"); + assertResultRow(result, row++, "[FAO]RMM [sc]Mobula mobular [fr]Mante mobula", "-", "-"); + assertResultRow(result, row++, "[FAO]LMP [sc]Megachasma pelagios [fr]Requin grande gueule", "-", "-"); + assertResultRow(result, row++, "[FAO]RMJ [sc]Mobula japanica [fr]Mante aiguillat", "-", "-"); + assertResultRow(result, row++, "[FAO]CVX [sc]Carcharhiniformes [fr]Ordre Carcharhiniformes", "-", "-"); + assertResultRow(result, row++, "[FAO]HDQ [sc]Heterodontiformes [fr]Ordre Heterodontiformes", "-", "-"); + assertResultRow(result, row++, "[FAO]HXW [sc]Hexanchiformes [fr]Ordre Hexanchiformes", "-", "-"); + assertResultRow(result, row++, "[FAO]LMZ [sc]Lamniformes [fr]Ordre Lamniformes", "-", "-"); + assertResultRow(result, row++, "[FAO]OCX [sc]Orectolobiformes [fr]Ordre Orectolobiformes", "-", "-"); + assertResultRow(result, row++, "[FAO]PWS [sc]Pristiophorus spp [fr]Requins-scies nca ", "-", "-"); + assertResultRow(result, row++, "[FAO]SHX [sc]Squaliformes [fr]Ordre Squaliformes", "-", "-"); + assertResultRow(result, row++, "[FAO]ASK [sc]Squatinidae [fr]Anges de mer nca ", "-", "-"); + assertResultRow(result, row++, "[FAO]BSH [sc]Prionace glauca [fr]Peau bleue", "-", "-"); + assertResultRow(result, row++, "[FAO]POR [sc]Lamna nasus [fr]Requin taupe commun", "-", "-"); + assertResultRow(result, row++, "[FAO]SRX [sc]Raie non identifiée [fr]Raie non identifiée", "-", "-"); + assertResultRow(result, row++, "[FAO]2REX [sc]Requin non identifié [fr]Requin non identifié", "-", "-"); + assertResultRow(result, row++, "[FAO]- [sc]Rhinopteridae [fr]Famille Rhinopteridae", "-", "-"); + assertResultRow(result, row++, "[FAO]NZX [sc]Rhinoptera spp [fr]Mourines", "-", "-"); + assertResultRow(result, row++, "[FAO]RMA [sc]Manta alfredi [fr]Manta Alfredi", "-", "-"); + assertResultRow(result, row++, "[FAO]RMC [sc]Mobula coilloti [fr]Mobula coilloti ", "-", "-"); + assertResultRow(result, row++, "[FAO]RMO [sc]Mobula thurstoni [fr]Mobula", "-", "-"); + assertResultRow(result, row++, "[FAO]RMV [sc]Mobula spp [fr]Mobula nca", "-", "-"); + assertResultRow(result, row++, "[FAO]BSK [sc]Cetorhinus maximus [fr]Requin pèlerin", "-", "-"); + assertResultRow(result, row++, "[FAO]RHN [sc]Rhincodon typus [fr]Requin baleine", "-", "-"); + assertResultRow(result, row++, "[FAO]SPL [sc]Sphyrna lewini [fr]Requin marteau halicorne", "-", "-"); + assertResultRow(result, row++, "[FAO]SPK [sc]Sphyrna mokarran [fr]Grand requin marteau", "-", "-"); + assertResultRow(result, row++, "[FAO]SPZ [sc]Sphyrna zygaena [fr]Requin marteau commun", "-", "-"); + assertResultRow(result, row++, "[FAO]TOD [sc]Torpedinidae [fr]Torpilles, raies électriq. nca ", "-", "-"); + + + } +} diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportActivityWithCommentTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportActivityWithCommentTest.java new file mode 100644 index 0000000..39e6e80 --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportActivityWithCommentTest.java @@ -0,0 +1,348 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report; + +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import org.junit.Assert; + + +/** + * Pour tester le report {@code dailySetAndCapture}. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.9 + */ +public class ReportActivityWithCommentTest extends AbstractReportServiceTopiaTest { + + @Override + protected String getReportId() { + return "activityWithComment"; + } + + @Override + protected void testReportSyntax(Report report) { + Assert.assertNotNull(report); + assertReportName( + report, + "Activités avec comment et leurs positions", + "Afficher les activités avec comment et leurs positions géographiques" + ); + + assertReportDimension( + report, + -1, + 5, + new String[]{"Jour - Heure observation", + "Latitude", + "Longitude", + "Activité", + "Commentaire" + }, + null + ); + + assertReportNbRequests(report, 1); + + ReportRequest[] requests = report.getRequests(); + + assertReportRequestDimension( + requests[0], + ReportRequest.RequestLayout.row, + 0, + 0 + ); + } + + @Override + protected void testReportResult(DataMatrix result) { + assertResultDimension(result, 5, 265, 0, 0); + + int row = 0; + assertResultRow(result, row++, "25/1/2013 19:0", "-19.833473", "57.466805", "Fin de veille", "Pas de fin de veille, toujours en transit 01."); + assertResultRow(result, row++, "26/1/2013 10:25", "-16.35014", "57.616802", "Transit (route sans recherche)", ""); + assertResultRow(result, row++, "26/1/2013 11:24", "-16.083473", "57.800137", "Transit (route sans recherche)", ""); + assertResultRow(result, row++, "26/1/2013 19:0", "-14.233473", "58.066803", "Autres (à préciser dans les notes)", "Fin de journée toujours en transit."); + assertResultRow(result, row++, "27/1/2013 7:20", "-11.0", "58.716805", "Route vers des systèmes observés", "Listao trop rapide."); + assertResultRow(result, row++, "27/1/2013 9:24", "-10.616806", "58.766804", "Route vers des systèmes observés", "Listao trop rapide et petit banc"); + assertResultRow(result, row++, "27/1/2013 15:12", "-9.60014", "58.700138", "Recherche (général)", "albacore de 3 à 4 kg poissons dispersés et trop petits"); + assertResultRow(result, row++, "28/1/2013 6:0", "-9.250139", "56.800137", "Recherche (général)", "Transit la nuit, arrété prés d'une épave mais au petit matin pas de poisson donc nous sommes reparti directement sans toucher à l'épave."); + assertResultRow(result, row++, "28/1/2013 11:51", "-8.450139", "56.716805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "28/1/2013 16:52", "-7.8501387", "57.53347", "Recherche (général)", "Rencontre d'un thonier espagnol visible à l'oeil nu."); + assertResultRow(result, row++, "29/1/2013 7:0", "-7.883472", "58.166805", "Recherche (général)", "au moins 5 thoniers visibles au radar (français et espagnols)"); + assertResultRow(result, row++, "29/1/2013 10:5", "-7.7334723", "58.566803", "Route vers des systèmes observés", "marsouins et oiseaux."); + assertResultRow(result, row++, "29/1/2013 11:5", "-7.650139", "58.633472", "Route vers des systèmes observés", "Pas de calée car plus de marsouins que de thons.\nSuivi d'un nouveaux système: oiseaux à 3.0 milles"); + assertResultRow(result, row++, "29/1/2013 12:5", "-7.650139", "58.800137", "Recherche (général)", "oiseaux mais pas de thons"); + assertResultRow(result, row++, "29/1/2013 17:36", "-7.800139", "58.516804", "Thonier arrivant sur le système détecté", "retour au radeau posé le matin meme"); + assertResultRow(result, row++, "30/1/2013 5:58", "-6.8334723", "57.966805", "Recherche (général)", "Présence de 7 autres navires thoniers français (CFTO) et espagnols"); + assertResultRow(result, row++, "30/1/2013 6:27", "-6.766805", "57.90014", "Thonier arrivant sur le système détecté", "Présence de marsouin, impossible de tourner la senne"); + assertResultRow(result, row++, "30/1/2013 7:16", "-6.783472", "57.716805", "Recherche (général)", ""); + assertResultRow(result, row++, "30/1/2013 9:58", "-6.766805", "57.73347", "Route vers des systèmes observés", "Présence de marsouins, impossible de tourner la senne."); + assertResultRow(result, row++, "30/1/2013 10:8", "-6.800139", "57.716805", "Recherche (général)", ""); + assertResultRow(result, row++, "30/1/2013 12:33", "-6.483472", "58.200138", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "30/1/2013 12:50", "-6.4668055", "58.200138", "Début de pêche (larguage du skiff)", "Aucunes espèces accessoires, aucuns rejets de thon lors du shiftage le 31.01.2013 sauf erreur de ma part deux listao de 67 et 71 cm!"); + assertResultRow(result, row++, "31/1/2013 6:6", "-7.766805", "58.450138", "Recherche (général)", ""); + assertResultRow(result, row++, "31/1/2013 7:57", "-7.533472", "58.65014", "Recherche (général)", ""); + assertResultRow(result, row++, "31/1/2013 9:28", "-7.4168053", "58.866802", "Route vers des systèmes observés", "présence de marsouins"); + assertResultRow(result, row++, "31/1/2013 9:59", "-7.3668056", "58.966805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "31/1/2013 10:53", "-7.3168054", "59.100136", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "31/1/2013 12:23", "-7.2501388", "58.90014", "Route vers des systèmes observés", "couple de frégattes"); + assertResultRow(result, row++, "31/1/2013 13:0", "-7.2668056", "58.816803", "Recherche (général)", ""); + assertResultRow(result, row++, "31/1/2013 15:15", "-7.2668056", "58.316803", "Recherche (général)", "Shiftage du 30.01.2013 réalisé à 14h. Observation de marsouins dont non calée lors du shiftage."); + assertResultRow(result, row++, "31/1/2013 17:59", "-7.3668056", "57.766804", "Route vers des systèmes observés", "frégattes\nNon coup de senne : changement de câble de la senne."); + assertResultRow(result, row++, "31/1/2013 18:25", "-7.283472", "57.73347", "Recherche (général)", ""); + assertResultRow(result, row++, "1/2/2013 14:54", "-6.5668054", "57.53347", "Recherche (général)", ""); + assertResultRow(result, row++, "1/2/2013 15:52", "-6.4501386", "57.53347", "Recherche (général)", ""); + assertResultRow(result, row++, "2/2/2013 5:54", "-6.433472", "57.68347", "Recherche (général)", "7 thoniers autour de nous visibles au radar et à l'oeil nu"); + assertResultRow(result, row++, "2/2/2013 6:47", "-6.4501386", "57.53347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 8:5", "-6.400139", "57.550137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 8:26", "-6.433472", "57.53347", "Recherche (général)", "Rencontre avec le DOLOMIEUX, flotte SAPMER, pour récupérer les balises du BERNICA récupérées à MAHE aux Seychelles."); + assertResultRow(result, row++, "2/2/2013 11:50", "-6.516805", "57.550137", "Fin de pêche (remontée du skiff)", "Coup nul, filet déchiré et emmélé."); + assertResultRow(result, row++, "2/2/2013 12:48", "-6.433472", "57.58347", "Recherche (général)", ""); + assertResultRow(result, row++, "2/2/2013 13:36", "-6.4168053", "57.750137", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "2/2/2013 13:41", "-6.433472", "57.766804", "Thonier arrivant sur le système détecté", "Présence marsouin"); + assertResultRow(result, row++, "2/2/2013 14:50", "-6.483472", "57.98347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 15:20", "-6.533472", "58.08347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 15:48", "-6.550139", "58.116802", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 16:53", "-6.433472", "58.28347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 18:10", "-6.5001388", "58.166805", "Thonier arrivant sur le système détecté", "perte du système"); + assertResultRow(result, row++, "2/2/2013 18:20", "-6.483472", "58.15014", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 18:50", "-6.5668054", "58.08347", "Fin de veille", "3 bateaux dans la zone. On reste sur zone jusqu'à demain car présence de \"nourriture\" aux sonars"); + assertResultRow(result, row++, "3/2/2013 6:1", "-6.533472", "58.100136", "Recherche (général)", "un autre thonier dans la zone visible au radar."); + assertResultRow(result, row++, "3/2/2013 6:59", "-6.633472", "58.100136", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 8:18", "-6.4501386", "58.15014", "Thonier arrivant sur le système détecté", "Haut fond à 292 m, risque de perdre le filet si coup de senne"); + assertResultRow(result, row++, "3/2/2013 11:22", "-6.516805", "58.15014", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 11:33", "-6.550139", "58.166805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 11:43", "-6.550139", "58.166805", "Recherche (général)", ""); + assertResultRow(result, row++, "3/2/2013 12:44", "-6.6168056", "58.300137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 13:22", "-6.6001387", "58.383472", "Route vers des systèmes observés", "Tâche au sonar, ne savent pas ce que c'est!"); + assertResultRow(result, row++, "3/2/2013 13:24", "-6.6001387", "58.383472", "Route vers des systèmes observés", "Balbaya visible à l'oeil nu. Autre système que celui observé à 13h22."); + assertResultRow(result, row++, "3/2/2013 13:37", "-6.6168056", "58.383472", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 13:40", "-6.6168056", "58.40014", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 16:32", "-6.7501388", "58.28347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 17:20", "-6.800139", "58.28347", "Route vers des systèmes observés", "Présence de marsouins donc non calée."); + assertResultRow(result, row++, "3/2/2013 17:53", "-6.8668056", "58.216805", "Thonier arrivant sur le système détecté", "Balise appartenant au Glénan, bateau de la SAPMER"); + assertResultRow(result, row++, "3/2/2013 18:1", "-6.883472", "58.18347", "Route vers des systèmes observés", "Banc de listao. Présence d'un palangrier et de thoniers au radar et à l'oeil nu."); + assertResultRow(result, row++, "3/2/2013 18:15", "-6.883472", "58.18347", "Thonier arrivant sur le système détecté", "Banc de listao, Albacore recherché!"); + assertResultRow(result, row++, "4/2/2013 5:49", "-6.7334723", "58.166805", "Recherche (général)", "2 thoniers visibles au radar."); + assertResultRow(result, row++, "4/2/2013 7:48", "-6.5834723", "58.016804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 8:0", "-6.5834723", "58.0", "Récupération d'une épave n'appartenant pas au bateau", ""); + assertResultRow(result, row++, "4/2/2013 8:31", "-6.533472", "58.066803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 9:52", "-6.433472", "58.23347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 10:17", "-6.4501386", "58.28347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 12:32", "-6.550139", "57.966805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 12:50", "-6.5668054", "57.90014", "Thonier arrivant sur le système détecté", "Il ya des thons albacores partout tout autour du navire. Ils sautent, vont dans tous les sens le banc est énorme mais dispersé et il ne garde pas le même cap!"); + assertResultRow(result, row++, "4/2/2013 13:50", "-6.5834723", "57.816803", "Thonier arrivant sur le système détecté", "Même banc que précédemment! dispersé et trop rapide."); + assertResultRow(result, row++, "4/2/2013 14:17", "-6.650139", "57.816803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 14:20", "-6.650139", "57.816803", "Route vers des systèmes observés", "Même banc qu'à 12h50 ENORME!"); + assertResultRow(result, row++, "4/2/2013 15:36", "-6.533472", "57.766804", "Thonier arrivant sur le système détecté", "Poissons dispersés et trop rapide. Ne gardent pas le même cap, sautent dans tous les sens!"); + assertResultRow(result, row++, "4/2/2013 16:24", "-6.483472", "57.750137", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "4/2/2013 16:31", "-6.5001388", "57.766804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 16:39", "-6.483472", "57.766804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 16:59", "-6.4501386", "57.750137", "Thonier arrivant sur le système détecté", "Présence de globicéphales."); + assertResultRow(result, row++, "4/2/2013 17:12", "-6.4668055", "57.800137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 17:36", "-6.433472", "57.850136", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "4/2/2013 19:43", "-6.433472", "57.916805", "Fin de pêche (remontée du skiff)", "Coup Nul."); + assertResultRow(result, row++, "5/2/2013 5:43", "-6.4501386", "58.18347", "Thonier arrivant sur le système détecté", "Route de nuit vers le DCP mis la veille."); + assertResultRow(result, row++, "5/2/2013 9:29", "-6.6001387", "58.016804", "Thonier arrivant sur le système détecté", "Présence de marsouins"); + assertResultRow(result, row++, "5/2/2013 10:30", "-6.683472", "57.83347", "Thonier arrivant sur le système détecté", "Présence de Marsouins!"); + assertResultRow(result, row++, "5/2/2013 11:13", "-6.800139", "57.750137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "5/2/2013 16:17", "-7.9501386", "57.516804", "Route vers des systèmes observés", "Listao"); + assertResultRow(result, row++, "5/2/2013 16:28", "-8.0", "57.516804", "Thonier arrivant sur le système détecté", "Listao"); + assertResultRow(result, row++, "5/2/2013 17:42", "-8.316806", "57.43347", "Recherche (général)", "Marsouins observé mais nous les avons laissé au loin sur tribord sans prendre leur direction"); + assertResultRow(result, row++, "6/2/2013 6:31", "-11.766806", "56.53347", "Route vers des systèmes observés", "Banc de listao"); + assertResultRow(result, row++, "6/2/2013 6:37", "-11.800139", "56.53347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "6/2/2013 7:34", "-12.016806", "56.550137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "6/2/2013 7:47", "-12.016806", "56.550137", "Recherche (général)", "Shiftage de la calée du 05.02.13 réalisée à 8H"); + assertResultRow(result, row++, "6/2/2013 8:51", "-12.233473", "56.200138", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "6/2/2013 9:41", "-12.366806", "56.200138", "Route vers des systèmes observés", "Zone avec pleins de petits balbaya. 3 thoniers français sur zone."); + assertResultRow(result, row++, "6/2/2013 9:43", "-12.366806", "56.18347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "6/2/2013 12:49", "-12.416806", "56.050137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "6/2/2013 13:26", "-12.416806", "56.133472", "Route vers des systèmes observés", "Pleins de petits banc d'YFT et de SKJ"); + assertResultRow(result, row++, "6/2/2013 14:20", "-12.450139", "56.0", "Thonier arrivant sur le système détecté", "listao + baleine"); + assertResultRow(result, row++, "6/2/2013 14:30", "-12.450139", "56.050137", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "6/2/2013 15:51", "-12.366806", "56.03347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "6/2/2013 16:22", "-12.400139", "56.03347", "Route vers des systèmes observés", "une dizaine de poisson (petit banc)."); + assertResultRow(result, row++, "6/2/2013 16:25", "-12.400139", "56.016804", "Thonier arrivant sur le système détecté", "Plusieurs bancs, dont un plus interessant."); + assertResultRow(result, row++, "7/2/2013 6:6", "-12.183473", "56.116802", "Route vers des systèmes observés", "Présence de marsouins, nous continuons notre route."); + assertResultRow(result, row++, "7/2/2013 6:34", "-12.200139", "56.133472", "Thonier arrivant sur le système détecté", "Banc de listao"); + assertResultRow(result, row++, "7/2/2013 7:9", "-12.266806", "56.133472", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "7/2/2013 7:13", "-12.266806", "56.18347", "Route vers des systèmes observés", "Listao + baleines"); + assertResultRow(result, row++, "7/2/2013 7:25", "-12.300139", "56.216805", "Thonier arrivant sur le système détecté", "Listao + 3 baleines"); + assertResultRow(result, row++, "7/2/2013 7:32", "-12.333472", "56.200138", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "7/2/2013 8:11", "-12.383472", "56.050137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "7/2/2013 11:46", "-12.383472", "55.98347", "Route vers des systèmes observés", "Nombre impressionnant de thons! gros balbaya!"); + assertResultRow(result, row++, "7/2/2013 12:47", "-12.416806", "56.016804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "7/2/2013 13:8", "-12.35014", "56.03347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "7/2/2013 16:43", "-12.266806", "55.966805", "Route vers des systèmes observés", "Banc de Listao"); + assertResultRow(result, row++, "7/2/2013 16:45", "-12.283473", "55.950138", "Thonier arrivant sur le système détecté", "Banc de listao trop rapide, banc de gros albacore visé!"); + assertResultRow(result, row++, "7/2/2013 16:52", "-12.283473", "55.98347", "Route vers des systèmes observés", "Banc de listao vu directement aux jumelles nous continuons donc notre route!"); + assertResultRow(result, row++, "7/2/2013 17:39", "-12.250139", "55.98347", "Route vers des systèmes observés", "Listao + baleine"); + assertResultRow(result, row++, "7/2/2013 18:1", "-12.283473", "55.916805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 6:58", "-12.333472", "55.93347", "Route vers des systèmes observés", "Pleins de \"petits bouillons\" partout tout autour de nous, petits bancs rapides!"); + assertResultRow(result, row++, "8/2/2013 7:17", "-12.316806", "55.950138", "Thonier arrivant sur le système détecté", "Banc de listao + marsouins+ oiseaux"); + assertResultRow(result, row++, "8/2/2013 7:29", "-12.283473", "56.0", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 7:50", "-12.216805", "56.016804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 8:2", "-12.250139", "56.03347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 8:4", "-12.250139", "56.03347", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "8/2/2013 8:21", "-12.200139", "56.100136", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 8:27", "-12.200139", "56.116802", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 9:15", "-12.250139", "56.016804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 12:30", "-12.183473", "56.066803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 12:59", "-12.183473", "56.116802", "Thonier arrivant sur le système détecté", "listao + albacore trop petits"); + assertResultRow(result, row++, "9/2/2013 6:35", "-12.166806", "56.100136", "Route vers des systèmes observés", "Banc de listao, pas interessant, nous continuons notre route sans s'arrêter!"); + assertResultRow(result, row++, "9/2/2013 6:53", "-12.133472", "56.15014", "Thonier arrivant sur le système détecté", "Présence de \"marsouins\" et banc trop petit"); + assertResultRow(result, row++, "9/2/2013 7:12", "-12.150139", "56.116802", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "9/2/2013 7:59", "-12.266806", "56.03347", "Thonier arrivant sur le système détecté", "Banc de listao"); + assertResultRow(result, row++, "9/2/2013 8:24", "-12.366806", "56.050137", "Thonier arrivant sur le système détecté", "Pleins de petits bancs partout"); + assertResultRow(result, row++, "9/2/2013 11:12", "-12.35014", "56.03347", "Thonier arrivant sur le système détecté", "Listao trop rapide et pas interessant pour le capitaine."); + assertResultRow(result, row++, "9/2/2013 11:31", "-12.316806", "56.03347", "Thonier arrivant sur le système détecté", "Listao + baleine"); + assertResultRow(result, row++, "9/2/2013 11:32", "-12.316806", "56.050137", "Route vers des systèmes observés", "pleins de petits \"bouts\" partout"); + assertResultRow(result, row++, "9/2/2013 15:15", "-12.283473", "55.966805", "Thonier arrivant sur le système détecté", "Shiftage de 14h à 15h."); + assertResultRow(result, row++, "9/2/2013 15:48", "-12.316806", "56.050137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "10/2/2013 5:55", "-12.316806", "55.916805", "Thonier arrivant sur le système détecté", "épave balisée la veille."); + assertResultRow(result, row++, "10/2/2013 7:58", "-12.316806", "55.916805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "10/2/2013 11:21", "-12.450139", "55.850136", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "10/2/2013 12:6", "-12.400139", "55.816803", "Route vers des systèmes observés", "Banc de Listao."); + assertResultRow(result, row++, "10/2/2013 12:16", "-12.383472", "55.850136", "Thonier arrivant sur le système détecté", "Banc de Listao"); + assertResultRow(result, row++, "10/2/2013 14:17", "-12.033473", "55.600136", "Recherche (général)", "Shiftage de 14h à 16h06!"); + assertResultRow(result, row++, "10/2/2013 19:4", "-12.216805", "55.48347", "Fin de veille", ""); + assertResultRow(result, row++, "11/2/2013 6:56", "-12.433473", "55.48347", "Route vers des systèmes observés", "Poissons \"étalés\""); + assertResultRow(result, row++, "11/2/2013 7:17", "-12.466805", "55.53347", "Thonier arrivant sur le système détecté", "Nous sommes 5 sur la zone avec notamment le Glénan (CFTO), le Dolomieu (SAPMER) et Franche-Terre (SAPMER)"); + assertResultRow(result, row++, "11/2/2013 11:23", "-12.433473", "55.516804", "Début de pêche (larguage du skiff)", "Shiftage du 10.02.2013 de 11h10 à 11h30"); + assertResultRow(result, row++, "11/2/2013 14:8", "-12.416806", "55.53347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "11/2/2013 14:33", "-12.366806", "55.53347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "12/2/2013 5:50", "-12.516806", "55.450138", "Recherche (général)", "Nous sommes à côté d'un épave."); + assertResultRow(result, row++, "12/2/2013 6:47", "-12.366806", "55.53347", "Thonier arrivant sur le système détecté", "Poissons étalés, Mélange Listao et Albacore"); + assertResultRow(result, row++, "12/2/2013 6:59", "-12.35014", "55.550137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "12/2/2013 7:20", "-12.333472", "55.566803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "12/2/2013 9:36", "-12.300139", "55.53347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "12/2/2013 15:0", "-11.300139", "55.600136", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "13/2/2013 5:52", "-9.016806", "55.250137", "Thonier arrivant sur le système détecté", "Route de nuit vers ce radeau."); + assertResultRow(result, row++, "13/2/2013 7:0", "-8.983473", "55.450138", "Recherche (général)", "Présence du Glénan (CFTO)"); + assertResultRow(result, row++, "13/2/2013 7:32", "-8.950139", "55.516804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "13/2/2013 8:35", "-8.950139", "55.68347", "Route vers des systèmes observés", "Nous n'avons pas trouvé le radeau à cause de la pluie, nous ne l'avons pas retrouvé!"); + assertResultRow(result, row++, "13/2/2013 10:20", "-9.016806", "56.016804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "13/2/2013 11:29", "-9.0", "56.23347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "13/2/2013 13:55", "-8.983473", "56.73347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", ""); + assertResultRow(result, row++, "13/2/2013 14:20", "-9.0", "56.766804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "13/2/2013 16:24", "-9.250139", "57.133472", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "13/2/2013 18:57", "-8.783473", "57.350136", "Fin de veille", "Route jusqu'à 23h."); + assertResultRow(result, row++, "14/2/2013 6:5", "-7.9501386", "57.68347", "Recherche (général)", "Pluie."); + assertResultRow(result, row++, "14/2/2013 7:2", "-7.7501388", "57.73347", "Route vers des systèmes observés", "Présence de marsouins, nous n'allons pas vers le système observé, nous reprnons notre cap sans se rendre sur zone. Pluie"); + assertResultRow(result, row++, "14/2/2013 7:5", "-7.7334723", "57.73347", "Recherche (général)", "Pluie"); + assertResultRow(result, row++, "14/2/2013 10:19", "-7.150139", "58.0", "Thonier arrivant sur le système détecté", "\"Balbaya de Marsouins\" pas d'YFT."); + assertResultRow(result, row++, "14/2/2013 18:23", "-6.633472", "57.48347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "14/2/2013 18:52", "-6.633472", "57.383472", "Fin de veille", "Route toute la nuit."); + assertResultRow(result, row++, "15/2/2013 16:54", "-5.7334723", "54.33347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "15/2/2013 17:46", "-5.5834723", "54.33347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "15/2/2013 19:1", "-5.433472", "54.166805", "Route de nuit vers objet", "Route vers un radeau balisé du bateau au nord apperçu sur un logiciel du bateau."); + assertResultRow(result, row++, "16/2/2013 6:0", "-4.2168055", "53.850136", "Recherche (général)", "Nous n'avons pas retrouvé le radeau balisé appartenant au navire, nous reprenons notre route vers l'ouest"); + assertResultRow(result, row++, "16/2/2013 8:5", "-4.383472", "53.716805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "16/2/2013 8:39", "-4.4668055", "53.666805", "Route vers des systèmes observés", "\"Chicanneurs"); + assertResultRow(result, row++, "16/2/2013 8:48", "-4.5001388", "53.666805", "Thonier arrivant sur le système détecté", "\"Chicaneurs\" vus \"sur l'eau\" en surface puis ils ont plongés."); + assertResultRow(result, row++, "16/2/2013 9:43", "-4.633472", "53.766804", "Thonier arrivant sur le système détecté", "\"chicaneurs\""); + assertResultRow(result, row++, "16/2/2013 11:3", "-4.633472", "53.550137", "Route vers des systèmes observés", "Frégates observées."); + assertResultRow(result, row++, "16/2/2013 11:21", "-4.5834723", "53.53347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "16/2/2013 16:40", "-4.6168056", "53.08347", "Recherche (général)", "Erreur de ma part sur l'horraire, j'ai cru que le nid de pie avait vu quelque chose hors il n'y avait rien."); + assertResultRow(result, row++, "16/2/2013 19:8", "-4.783472", "52.68347", "Fin de veille", "Route jusqu'à 20h"); + assertResultRow(result, row++, "17/2/2013 6:12", "-4.8168054", "52.550137", "Recherche (général)", ""); + assertResultRow(result, row++, "17/2/2013 7:22", "-4.7168055", "52.350136", "Route vers des systèmes observés", "Listao, la distance est trop importante, nous allons voir \"point de volaille\" moins loin."); + assertResultRow(result, row++, "17/2/2013 7:41", "-4.7168055", "52.28347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "17/2/2013 7:43", "-4.7168055", "52.28347", "Route vers des systèmes observés", "\"Chicaneurs\", même système observé que celui de 07h22"); + assertResultRow(result, row++, "17/2/2013 7:50", "-4.7334723", "52.266804", "Thonier arrivant sur le système détecté", "Pas de thons mais des \"Marsouins\""); + assertResultRow(result, row++, "17/2/2013 9:9", "-4.5834723", "52.03347", "Route vers des systèmes observés", "Tâche au sonar, nous prenons le cap puis confirmation des jumelles comme quoi c'est un balbaya de \"marsouins\" et non de \"gros\" nous reprenons notre cap directement sans aller jusqu'au système observé."); + assertResultRow(result, row++, "17/2/2013 13:45", "-4.4668055", "51.73347", "Recherche (général)", "Shiftage de la calée duy 16.02.2013 de 14h à 14h57"); + assertResultRow(result, row++, "17/2/2013 14:22", "-4.483472", "51.700138", "Début de pêche (larguage du skiff)", "Environ 10 globicéphales autour du bateau"); + assertResultRow(result, row++, "17/2/2013 19:15", "-4.7001386", "51.466805", "Fin de veille", "Pas de route cette nuit. Nous sommes stoppés."); + assertResultRow(result, row++, "18/2/2013 7:59", "-4.7001386", "51.066803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "18/2/2013 8:0", "-4.7001386", "51.066803", "Recherche (général)", "Shiftage de 8h30 à 10h36J'ai loupé la rencontre avec un objet flottant, voilà le détail: Aux positions 4'42 et 50'53 il y a eut récupération d'une balise 98 et pose d'une balise 04 sur un radeau (bambou filet) appartenant à un autre armement"); + assertResultRow(result, row++, "18/2/2013 17:50", "-4.2168055", "49.40014", "Recherche (général)", "Changement d'heure (-1 heure!)"); + assertResultRow(result, row++, "18/2/2013 18:23", "-4.183472", "49.300137", "Fin de veille", "Nous faisons route toute la nuit seuf si rencontre avec d'autres navires, nous stoppons."); + assertResultRow(result, row++, "19/2/2013 6:35", "-3.6168058", "48.116802", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "19/2/2013 7:47", "-3.550139", "47.93347", "Route vers des systèmes observés", "Présence de \"Marsousins\" et de Listao vu aux jumelle avant d'être arrivé sur le système observé, nous reprenons directement notre cap!"); + assertResultRow(result, row++, "19/2/2013 9:28", "-3.4668057", "47.766804", "Début de pêche (larguage du skiff)", "Présence du bteau TREVIGNON"); + assertResultRow(result, row++, "19/2/2013 16:40", "-3.4668057", "47.78347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "19/2/2013 16:53", "-3.4834723", "47.83347", "Route vers des systèmes observés", "Vu mattes aux jumelles, direction du système observé puis avant d'y arriver sur le système observé nous avons repris notre cap car c'était des listao!"); + assertResultRow(result, row++, "19/2/2013 17:18", "-3.550139", "47.766804", "Route vers des systèmes observés", "Gleurre"); + assertResultRow(result, row++, "19/2/2013 17:36", "-3.6168058", "47.716805", "Thonier arrivant sur le système détecté", "Gleurre en plus"); + assertResultRow(result, row++, "19/2/2013 17:40", "-3.6168058", "47.700138", "Début de pêche (larguage du skiff)", "Gleurre en plus"); + assertResultRow(result, row++, "20/2/2013 7:3", "-3.450139", "47.716805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "20/2/2013 8:45", "-3.2168057", "47.700138", "Recherche (général)", "Shiftage de la première calée du 19.02.2013 de 8h à 10h05"); + assertResultRow(result, row++, "20/2/2013 11:30", "-2.900139", "47.416805", "Route vers des systèmes observés", "Matte observée, route vers système observé, puis changement de cap avant d'arriver sur le système observé car listao aperçu. Reprenons notre cap sans se rendre sur le système observé."); + assertResultRow(result, row++, "20/2/2013 14:37", "-2.6334722", "47.93347", "Recherche (général)", "Shiftage de la deuxième calée du 19.02.2013 de 14h à 15h30"); + assertResultRow(result, row++, "20/2/2013 18:20", "-2.2168057", "48.300137", "Fin de veille", "Stopper pour la nuit à partir de 20h."); + assertResultRow(result, row++, "21/2/2013 8:0", "-2.150139", "48.700138", "Recherche (général)", "shiftage de la 3 ème calée du 19.02.2013"); + assertResultRow(result, row++, "21/2/2013 12:41", "-1.6168056", "49.316803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "21/2/2013 14:2", "-1.5501388", "49.53347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", ""); + assertResultRow(result, row++, "21/2/2013 16:0", "-1.5334722", "49.800137", "Route vers des systèmes observés", "L'épave n'était pas à 1 milles mais plus près, nous l'avons dépassé sans la voir donc nous ne sommes pas aller sur le système observé, de plus aucun oiseaux n'avaient été vu a proximité de l'épave. Nous avons repris directement notre cap."); + assertResultRow(result, row++, "21/2/2013 18:11", "-1.3001388", "50.066803", "Fin de veille", "Route toute la nuit."); + assertResultRow(result, row++, "22/2/2013 7:21", "-0.25013888", "52.23347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", "YFT de 70 kg environ mélangé avec beaucoup de \"marsouins\" impossible de pêcher."); + assertResultRow(result, row++, "22/2/2013 7:59", "-0.18347223", "52.316803", "Thonier arrivant sur le système détecté", "Albacore de 70 kg environ mélangés avec \"marsouins\" impossible de pêcher!"); + assertResultRow(result, row++, "22/2/2013 8:19", "-0.1501389", "52.366802", "Route vers des systèmes observés", "Vu matte au loin, prenons direction du système observé mais en cours de route les matelots aux jumelles s'apperçoivent qu'il y a des \"marsouins\" avec les YFT, nous ^reprnons notre cap sans nous être rendu sur le système observé"); + assertResultRow(result, row++, "22/2/2013 8:35", "-0.10013889", "52.350136", "Route vers des systèmes observés", "YFT + \"marsouins\", reprise du cap sans nous rendre sur le système observé."); + assertResultRow(result, row++, "22/2/2013 10:22", "-0.16680557", "52.616802", "Thonier arrivant sur le système détecté", "YFT mélangés avec\"Marsouins\""); + assertResultRow(result, row++, "22/2/2013 15:4", "-0.26680556", "53.23347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", "Changement d'heur: +1h (heure de l'île maurice, de la réunion et des seychelles!)"); + assertResultRow(result, row++, "22/2/2013 15:13", "-0.26680556", "53.250137", "Route vers des systèmes observés", "YFT + \"Marsouins\" mais vu lors du transit en allant sur le système observé, reprise du cap!"); + assertResultRow(result, row++, "22/2/2013 17:41", "-0.5501389", "53.566803", "Recherche (général)", "Marsouins observé à 2 mioles mais nous n'allons pas sur le système observé"); + assertResultRow(result, row++, "22/2/2013 18:58", "-0.7501389", "53.40014", "Fin de veille", "Route de nuit."); + assertResultRow(result, row++, "23/2/2013 7:4", "-2.350139", "51.03347", "Thonier arrivant sur le système détecté", "Listao + présence d'un cordage pose d'un radeau activité suivante."); + assertResultRow(result, row++, "23/2/2013 7:35", "-2.3334723", "50.98347", "Route vers des systèmes observés", "volaille apperçu aux jumelles, nous prenons la direction pour en cours de route on observe que ce sont des listao, on reprend notre cap initial sans se rendre sur le système observé."); + assertResultRow(result, row++, "23/2/2013 8:41", "-2.2834723", "50.750137", "Route vers des systèmes observés", "vu au sonar!"); + assertResultRow(result, row++, "23/2/2013 12:40", "-2.250139", "50.65014", "Thonier arrivant sur le système détecté", "Plusieurs bancs plus ou moins gros!"); + assertResultRow(result, row++, "23/2/2013 13:1", "-2.250139", "50.633472", "Route vers des systèmes observés", "Poissons allant trop vite re tour sur système observé précédément"); + assertResultRow(result, row++, "23/2/2013 13:28", "-2.2334723", "50.65014", "Thonier arrivant sur le système détecté", "Petit banc et dispérsé"); + assertResultRow(result, row++, "23/2/2013 13:30", "-2.2334723", "50.65014", "Recherche (général)", ""); + assertResultRow(result, row++, "23/2/2013 13:47", "-2.2334723", "50.68347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "23/2/2013 16:6", "-2.2668056", "50.616802", "Recherche (général)", ""); + assertResultRow(result, row++, "23/2/2013 16:34", "-2.2668056", "50.716805", "Route vers des systèmes observés", "En train de mesurer lorsque le système a été apperçu aux jumelles!"); + assertResultRow(result, row++, "23/2/2013 19:1", "-2.300139", "50.68347", "Fin de pêche (remontée du skiff)", "Changement d'heure - 1h"); + assertResultRow(result, row++, "24/2/2013 5:27", "-2.350139", "50.616802", "Recherche (général)", "shiftage du 23.02.2013 de 5h35 à 12h33 puis après calée!"); + assertResultRow(result, row++, "24/2/2013 8:26", "-2.3168056", "50.716805", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "24/2/2013 8:42", "-2.2668056", "50.73347", "Thonier arrivant sur le système détecté", "Mélangé avec \"Marsouins\" (je pense des dauphins longirostre)."); + assertResultRow(result, row++, "24/2/2013 8:48", "-2.2668056", "50.716805", "Route vers des systèmes observés", "Le poisson se déplace trop vite, nous n'allons pas sur le système observé"); + assertResultRow(result, row++, "24/2/2013 9:59", "-2.2834723", "50.68347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "24/2/2013 11:27", "-2.5834723", "50.716805", "Route vers des systèmes observés", "Dauphins longirostre. On fait se séparer les thons et les dauphins en suivant ces derniers.\n"); + assertResultRow(result, row++, "24/2/2013 11:30", "-2.5834723", "50.716805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "24/2/2013 11:57", "-2.600139", "50.716805", "Route vers des systèmes observés", "Arrivés sur le système à 12h03 (oublies de le noter sur le formulaire route!)"); + assertResultRow(result, row++, "24/2/2013 15:19", "-2.6168058", "50.766804", "Route vers des systèmes observés", "2 mattes"); + assertResultRow(result, row++, "24/2/2013 15:32", "-2.5834723", "50.800137", "Thonier arrivant sur le système détecté", "Mélange SKJ + YFT."); + assertResultRow(result, row++, "24/2/2013 15:58", "-2.5168056", "50.816803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "24/2/2013 16:58", "-2.3334723", "50.73347", "Route vers des systèmes observés", "\"Marsouins\" apperçu après avoir pris la direction du système observé, reprise du cap sans se rendre sur le système."); + assertResultRow(result, row++, "24/2/2013 18:12", "-2.5168056", "50.616802", "Fin de veille", "Stopper pour la nuit."); + assertResultRow(result, row++, "25/2/2013 5:52", "-2.7168057", "50.53347", "Route vers des systèmes observés", "Balbya de \"Marsouins\", reprise du cap sans s'être rendu sur le système observé."); + assertResultRow(result, row++, "25/2/2013 6:12", "-2.7668056", "50.58347", "Recherche (général)", "Shiftage du 23 et 24.02.2013 jusqu'à 14h20"); + assertResultRow(result, row++, "25/2/2013 6:24", "-2.8168056", "50.58347", "Route vers des systèmes observés", "Banc trop petit et inintéressant, recherche général sans se rendre sur le système observé."); + assertResultRow(result, row++, "25/2/2013 12:35", "-3.4168057", "50.600136", "Route vers des systèmes observés", "\"Marsouins\" vu en coursz de route, reprise directement du cap, sans se rendre sur le système observé"); + assertResultRow(result, row++, "25/2/2013 14:31", "-3.5834723", "50.90014", "Route vers des systèmes observés", "Fin du shiftage du 23 et 24.02.2013 à 14h 20"); + assertResultRow(result, row++, "25/2/2013 16:22", "-3.5668056", "51.050137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "26/2/2013 6:3", "-4.300139", "52.98347", "Début de pêche (larguage du skiff)", "Sachant que nous débarquons le lendemain aux Seychelles, il n'y aura pas de shiftage, les poissons restent en saumure!"); + assertResultRow(result, row++, "26/2/2013 9:53", "-4.3501387", "53.166805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "26/2/2013 10:35", "-4.433472", "53.23347", "Thonier arrivant sur le système détecté", "Trombe d'eau apparçu à 5 milles"); + assertResultRow(result, row++, "26/2/2013 12:4", "-4.6001387", "53.366802", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "26/2/2013 13:7", "-4.6668053", "53.58347", "Recherche (général)", "Shiftage du 25.02.2013 de 13h à 16h35"); + assertResultRow(result, row++, "26/2/2013 18:22", "-5.3168054", "54.566803", "Fin de veille", "Stopper pour la nuit."); + assertResultRow(result, row++, "27/2/2013 15:36", "-4.5834723", "55.48347", "Autres (à préciser dans les notes)", "En attente pour rentrer au port avec le pilote"); + assertResultRow(result, row++, "27/2/2013 16:22", "-4.6168056", "55.450138", "Au port", "Fin de la première partie de calée.Loch totale marée: 5953.03"); + } +} diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAllActivitysTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAllActivitysTest.java new file mode 100644 index 0000000..969788f --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAllActivitysTest.java @@ -0,0 +1,943 @@ +package fr.ird.observe.services.service.actions.report; + +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2014 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ + +import fr.ird.observe.services.service.actions.report.AbstractReportServiceTopiaTest; +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import org.junit.Assert; + +/** + * Created on 7/4/14. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 3.5 + */ +public class ReportAllActivitysTest extends AbstractReportServiceTopiaTest { + + @Override + protected String getReportId() { + return "allActivitys"; + } + + @Override + protected void testReportSyntax(Report report) { + Assert.assertNotNull(report); + assertReportName( + report, + "Toutes les activités et leurs positions", + "Afficher toutes les activités et leurs positions géographiques" + ); + + assertReportDimension( + report, + -1, + 5, + new String[]{"Jour - Heure observation", "Latitude", "Longitude", "Activité", "Commentaire", + }, + null + ); + + assertReportNbRequests(report, 1); + + ReportRequest[] requests = report.getRequests(); + + assertReportRequestDimension( + requests[0], + ReportRequest.RequestLayout.row, + 0, + 0 + ); + } + + @Override + protected void testReportResult(DataMatrix result) { + assertResultDimension(result, 5, 862, 0, 0); + + int row = 0; + assertResultRow(result, row++, "25/1/2013 16:50", "-20.166805", "57.466805", "Au port", null); + assertResultRow(result, row++, "25/1/2013 17:50", "-20.083473", "57.466805", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "25/1/2013 19:0", "-19.833473", "57.466805", "Fin de veille", "Pas de fin de veille, toujours en transit 01."); + assertResultRow(result, row++, "26/1/2013 6:18", "-17.416805", "57.466805", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "26/1/2013 7:15", "-17.20014", "57.466805", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "26/1/2013 8:23", "-16.900139", "57.516804", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "26/1/2013 9:21", "-16.650139", "57.566803", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "26/1/2013 10:25", "-16.35014", "57.616802", "Transit (route sans recherche)", ""); + assertResultRow(result, row++, "26/1/2013 11:24", "-16.083473", "57.800137", "Transit (route sans recherche)", ""); + assertResultRow(result, row++, "26/1/2013 12:26", "-15.800139", "57.73347", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "26/1/2013 13:35", "-15.500139", "57.800137", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "26/1/2013 14:26", "-15.283473", "57.83347", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "26/1/2013 15:26", "-15.016806", "57.883472", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "26/1/2013 16:22", "-14.883472", "57.916805", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "26/1/2013 17:28", "-14.633472", "58.0", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "26/1/2013 18:22", "-14.400139", "58.03347", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "26/1/2013 19:0", "-14.233473", "58.066803", "Autres (à préciser dans les notes)", "Fin de journée toujours en transit."); + assertResultRow(result, row++, "27/1/2013 6:0", "-11.283473", "58.666805", "Recherche (général)", null); + assertResultRow(result, row++, "27/1/2013 7:0", "-11.066806", "58.716805", "Recherche (général)", null); + assertResultRow(result, row++, "27/1/2013 7:20", "-11.0", "58.716805", "Route vers des systèmes observés", "Listao trop rapide."); + assertResultRow(result, row++, "27/1/2013 8:0", "-10.916806", "58.78347", "Recherche (général)", null); + assertResultRow(result, row++, "27/1/2013 9:0", "-10.700139", "58.78347", "Recherche (général)", null); + assertResultRow(result, row++, "27/1/2013 9:24", "-10.616806", "58.766804", "Route vers des systèmes observés", "Listao trop rapide et petit banc"); + assertResultRow(result, row++, "27/1/2013 10:0", "-10.516806", "58.766804", "Recherche (général)", null); + assertResultRow(result, row++, "27/1/2013 11:0", "-10.366806", "58.800137", "Recherche (général)", null); + assertResultRow(result, row++, "27/1/2013 11:25", "-10.266806", "58.800137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "27/1/2013 11:34", "-10.250139", "58.800137", "Recherche (général)", null); + assertResultRow(result, row++, "27/1/2013 12:29", "-10.050139", "58.78347", "Recherche (général)", null); + assertResultRow(result, row++, "27/1/2013 13:30", "-9.866806", "58.750137", "Recherche (général)", null); + assertResultRow(result, row++, "27/1/2013 14:30", "-9.666806", "58.68347", "Recherche (général)", null); + assertResultRow(result, row++, "27/1/2013 15:0", "-9.616806", "58.700138", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "27/1/2013 15:12", "-9.60014", "58.700138", "Recherche (général)", "albacore de 3 à 4 kg poissons dispersés et trop petits"); + assertResultRow(result, row++, "27/1/2013 16:9", "-9.433473", "58.600136", "Recherche (général)", null); + assertResultRow(result, row++, "27/1/2013 17:11", "-9.333472", "58.450138", "Recherche (général)", null); + assertResultRow(result, row++, "27/1/2013 18:11", "-9.316806", "58.250137", "Recherche (général)", null); + assertResultRow(result, row++, "27/1/2013 18:56", "-9.300139", "58.08347", "Fin de veille", null); + assertResultRow(result, row++, "28/1/2013 6:0", "-9.250139", "56.800137", "Recherche (général)", "Transit la nuit, arrété prés d'une épave mais au petit matin pas de poisson donc nous sommes reparti directement sans toucher à l'épave."); + assertResultRow(result, row++, "28/1/2013 7:0", "-9.10014", "56.666805", "Recherche (général)", null); + assertResultRow(result, row++, "28/1/2013 7:30", "-9.050139", "56.616802", "Récupération d'une épave n'appartenant pas au bateau", null); + assertResultRow(result, row++, "28/1/2013 7:39", "-9.050139", "56.616802", "Recherche (général)", null); + assertResultRow(result, row++, "28/1/2013 8:34", "-8.900139", "56.500137", "Recherche (général)", null); + assertResultRow(result, row++, "28/1/2013 9:35", "-8.733473", "56.366802", "Recherche (général)", null); + assertResultRow(result, row++, "28/1/2013 10:36", "-8.566806", "56.516804", "Recherche (général)", null); + assertResultRow(result, row++, "28/1/2013 11:27", "-8.450139", "56.68347", "Recherche (général)", null); + assertResultRow(result, row++, "28/1/2013 11:51", "-8.450139", "56.716805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "28/1/2013 12:52", "-8.283473", "56.90014", "Recherche (général)", null); + assertResultRow(result, row++, "28/1/2013 13:52", "-8.216805", "57.066803", "Recherche (général)", null); + assertResultRow(result, row++, "28/1/2013 14:54", "-8.083472", "57.200138", "Recherche (général)", null); + assertResultRow(result, row++, "28/1/2013 15:52", "-7.933472", "57.350136", "Recherche (général)", null); + assertResultRow(result, row++, "28/1/2013 16:52", "-7.8501387", "57.53347", "Recherche (général)", "Rencontre d'un thonier espagnol visible à l'oeil nu."); + assertResultRow(result, row++, "28/1/2013 17:52", "-7.7334723", "57.73347", "Recherche (général)", null); + assertResultRow(result, row++, "28/1/2013 18:52", "-7.7001386", "57.766804", "Fin de veille", null); + assertResultRow(result, row++, "29/1/2013 6:0", "-7.9834723", "58.116802", "Recherche (général)", null); + assertResultRow(result, row++, "29/1/2013 7:0", "-7.883472", "58.166805", "Recherche (général)", "au moins 5 thoniers visibles au radar (français et espagnols)"); + assertResultRow(result, row++, "29/1/2013 7:43", "-7.7334723", "58.216805", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "29/1/2013 7:52", "-7.7334723", "58.200138", "Recherche (général)", null); + assertResultRow(result, row++, "29/1/2013 8:52", "-7.8168054", "58.40014", "Recherche (général)", null); + assertResultRow(result, row++, "29/1/2013 9:5", "-7.800139", "58.416805", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "29/1/2013 10:5", "-7.7334723", "58.566803", "Route vers des systèmes observés", "marsouins et oiseaux."); + assertResultRow(result, row++, "29/1/2013 11:5", "-7.650139", "58.633472", "Route vers des systèmes observés", "Pas de calée car plus de marsouins que de thons.\nSuivi d'un nouveaux système: oiseaux à 3.0 milles"); + assertResultRow(result, row++, "29/1/2013 12:5", "-7.650139", "58.800137", "Recherche (général)", "oiseaux mais pas de thons"); + assertResultRow(result, row++, "29/1/2013 13:5", "-7.7501388", "58.90014", "Recherche (général)", null); + assertResultRow(result, row++, "29/1/2013 14:5", "-7.9168053", "59.0", "Recherche (général)", null); + assertResultRow(result, row++, "29/1/2013 15:5", "-8.050139", "58.866802", "Recherche (général)", null); + assertResultRow(result, row++, "29/1/2013 16:5", "-7.9834723", "58.716805", "Recherche (général)", null); + assertResultRow(result, row++, "29/1/2013 17:5", "-7.9668055", "58.566803", "Recherche (général)", null); + assertResultRow(result, row++, "29/1/2013 17:36", "-7.800139", "58.516804", "Thonier arrivant sur le système détecté", "retour au radeau posé le matin meme"); + assertResultRow(result, row++, "29/1/2013 18:46", "-7.6001387", "58.43347", "Fin de veille", null); + assertResultRow(result, row++, "30/1/2013 5:58", "-6.8334723", "57.966805", "Recherche (général)", "Présence de 7 autres navires thoniers français (CFTO) et espagnols"); + assertResultRow(result, row++, "30/1/2013 6:23", "-6.766805", "57.90014", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "30/1/2013 6:27", "-6.766805", "57.90014", "Thonier arrivant sur le système détecté", "Présence de marsouin, impossible de tourner la senne"); + assertResultRow(result, row++, "30/1/2013 7:16", "-6.783472", "57.716805", "Recherche (général)", ""); + assertResultRow(result, row++, "30/1/2013 8:16", "-6.8168054", "58.0", "Recherche (général)", null); + assertResultRow(result, row++, "30/1/2013 9:16", "-6.7501388", "58.016804", "Recherche (général)", null); + assertResultRow(result, row++, "30/1/2013 9:58", "-6.766805", "57.73347", "Route vers des systèmes observés", "Présence de marsouins, impossible de tourner la senne."); + assertResultRow(result, row++, "30/1/2013 10:8", "-6.800139", "57.716805", "Recherche (général)", ""); + assertResultRow(result, row++, "30/1/2013 11:8", "-6.7168055", "58.016804", "Recherche (général)", null); + assertResultRow(result, row++, "30/1/2013 12:8", "-6.550139", "58.133472", "Recherche (général)", null); + assertResultRow(result, row++, "30/1/2013 12:33", "-6.483472", "58.200138", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "30/1/2013 12:50", "-6.4668055", "58.200138", "Début de pêche (larguage du skiff)", "Aucunes espèces accessoires, aucuns rejets de thon lors du shiftage le 31.01.2013 sauf erreur de ma part deux listao de 67 et 71 cm!"); + assertResultRow(result, row++, "30/1/2013 15:14", "-6.483472", "58.200138", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "30/1/2013 15:31", "-6.4668055", "58.23347", "Recherche (général)", null); + assertResultRow(result, row++, "30/1/2013 16:33", "-6.483472", "58.200138", "Recherche (général)", null); + assertResultRow(result, row++, "30/1/2013 17:33", "-6.683472", "58.200138", "Recherche (général)", null); + assertResultRow(result, row++, "30/1/2013 18:53", "-6.9834723", "58.266804", "Fin de veille", null); + assertResultRow(result, row++, "31/1/2013 5:46", "-7.766805", "58.450138", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "31/1/2013 6:6", "-7.766805", "58.450138", "Recherche (général)", ""); + assertResultRow(result, row++, "31/1/2013 7:6", "-7.6168056", "58.566803", "Recherche (général)", null); + assertResultRow(result, row++, "31/1/2013 7:40", "-7.516805", "58.633472", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "31/1/2013 7:42", "-7.533472", "58.65014", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "31/1/2013 7:57", "-7.533472", "58.65014", "Recherche (général)", ""); + assertResultRow(result, row++, "31/1/2013 8:59", "-7.4668055", "58.78347", "Recherche (général)", null); + assertResultRow(result, row++, "31/1/2013 9:12", "-7.433472", "58.816803", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "31/1/2013 9:28", "-7.4168053", "58.866802", "Route vers des systèmes observés", "présence de marsouins"); + assertResultRow(result, row++, "31/1/2013 9:59", "-7.3668056", "58.966805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "31/1/2013 10:0", "-7.3668056", "58.966805", "Recherche (général)", null); + assertResultRow(result, row++, "31/1/2013 10:53", "-7.3168054", "59.100136", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "31/1/2013 11:23", "-7.283472", "59.100136", "Recherche (général)", null); + assertResultRow(result, row++, "31/1/2013 12:23", "-7.2501388", "58.90014", "Route vers des systèmes observés", "couple de frégattes"); + assertResultRow(result, row++, "31/1/2013 12:42", "-7.2501388", "58.850136", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "31/1/2013 12:55", "-7.2668056", "58.800137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "31/1/2013 13:0", "-7.2668056", "58.816803", "Recherche (général)", ""); + assertResultRow(result, row++, "31/1/2013 15:15", "-7.2668056", "58.316803", "Recherche (général)", "Shiftage du 30.01.2013 réalisé à 14h. Observation de marsouins dont non calée lors du shiftage."); + assertResultRow(result, row++, "31/1/2013 16:15", "-7.3501387", "58.116802", "Recherche (général)", null); + assertResultRow(result, row++, "31/1/2013 17:19", "-7.3668056", "57.883472", "Recherche (général)", null); + assertResultRow(result, row++, "31/1/2013 17:59", "-7.3668056", "57.766804", "Route vers des systèmes observés", "frégattes\nNon coup de senne : changement de câble de la senne."); + assertResultRow(result, row++, "31/1/2013 18:25", "-7.283472", "57.73347", "Recherche (général)", ""); + assertResultRow(result, row++, "31/1/2013 18:59", "-7.3501387", "57.666805", "Fin de veille", null); + assertResultRow(result, row++, "1/2/2013 5:42", "-6.3334723", "57.53347", "Recherche (général)", null); + assertResultRow(result, row++, "1/2/2013 6:15", "-6.3501387", "57.550137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "1/2/2013 6:22", "-6.3334723", "57.550137", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "1/2/2013 6:40", "-6.3501387", "57.550137", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "1/2/2013 8:25", "-6.3501387", "57.566803", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "1/2/2013 8:31", "-6.3501387", "57.566803", "Recherche (général)", null); + assertResultRow(result, row++, "1/2/2013 8:56", "-6.3668056", "57.58347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "1/2/2013 9:2", "-6.4168053", "57.58347", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "1/2/2013 9:30", "-6.400139", "57.566803", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "1/2/2013 11:20", "-6.383472", "57.566803", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "1/2/2013 11:25", "-6.400139", "57.550137", "Recherche (général)", null); + assertResultRow(result, row++, "1/2/2013 12:30", "-6.383472", "57.566803", "Recherche (général)", null); + assertResultRow(result, row++, "1/2/2013 13:30", "-6.5834723", "57.53347", "Recherche (général)", null); + assertResultRow(result, row++, "1/2/2013 14:30", "-6.6001387", "57.516804", "Recherche (général)", null); + assertResultRow(result, row++, "1/2/2013 14:37", "-6.6168056", "57.53347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "1/2/2013 14:44", "-6.5668054", "57.53347", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "1/2/2013 14:54", "-6.5668054", "57.53347", "Recherche (général)", ""); + assertResultRow(result, row++, "1/2/2013 15:42", "-6.4668055", "57.53347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "1/2/2013 15:52", "-6.4501386", "57.53347", "Recherche (général)", ""); + assertResultRow(result, row++, "1/2/2013 16:55", "-6.2668056", "57.43347", "Recherche (général)", null); + assertResultRow(result, row++, "1/2/2013 17:55", "-6.300139", "57.566803", "Recherche (général)", null); + assertResultRow(result, row++, "1/2/2013 18:56", "-6.4168053", "57.600136", "Fin de veille", null); + assertResultRow(result, row++, "2/2/2013 5:54", "-6.433472", "57.68347", "Recherche (général)", "7 thoniers autour de nous visibles au radar et à l'oeil nu"); + assertResultRow(result, row++, "2/2/2013 6:45", "-6.4501386", "57.550137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "2/2/2013 6:47", "-6.4501386", "57.53347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 6:48", "-6.4501386", "57.53347", "Recherche (général)", null); + assertResultRow(result, row++, "2/2/2013 7:48", "-6.383472", "57.516804", "Recherche (général)", null); + assertResultRow(result, row++, "2/2/2013 8:0", "-6.400139", "57.53347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "2/2/2013 8:5", "-6.400139", "57.550137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 8:13", "-6.400139", "57.550137", "Recherche (général)", null); + assertResultRow(result, row++, "2/2/2013 8:26", "-6.433472", "57.53347", "Recherche (général)", "Rencontre avec le DOLOMIEUX, flotte SAPMER, pour récupérer les balises du BERNICA récupérées à MAHE aux Seychelles."); + assertResultRow(result, row++, "2/2/2013 8:59", "-6.5001388", "57.550137", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "2/2/2013 9:4", "-6.5001388", "57.550137", "Recherche (général)", null); + assertResultRow(result, row++, "2/2/2013 9:8", "-6.516805", "57.550137", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "2/2/2013 9:12", "-6.533472", "57.550137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "2/2/2013 9:18", "-6.533472", "57.516804", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "2/2/2013 9:20", "-6.533472", "57.516804", "Recherche (général)", null); + assertResultRow(result, row++, "2/2/2013 9:22", "-6.516805", "57.516804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "2/2/2013 9:24", "-6.516805", "57.53347", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "2/2/2013 9:37", "-6.516805", "57.53347", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "2/2/2013 11:50", "-6.516805", "57.550137", "Fin de pêche (remontée du skiff)", "Coup nul, filet déchiré et emmélé."); + assertResultRow(result, row++, "2/2/2013 11:52", "-6.516805", "57.550137", "Recherche (général)", null); + assertResultRow(result, row++, "2/2/2013 12:31", "-6.4501386", "57.550137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "2/2/2013 12:37", "-6.433472", "57.566803", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "2/2/2013 12:48", "-6.433472", "57.58347", "Recherche (général)", ""); + assertResultRow(result, row++, "2/2/2013 13:36", "-6.4168053", "57.750137", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "2/2/2013 13:41", "-6.433472", "57.766804", "Thonier arrivant sur le système détecté", "Présence marsouin"); + assertResultRow(result, row++, "2/2/2013 14:41", "-6.4668055", "57.966805", "Recherche (général)", null); + assertResultRow(result, row++, "2/2/2013 14:45", "-6.4668055", "57.98347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "2/2/2013 14:50", "-6.483472", "57.98347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 14:51", "-6.483472", "58.0", "Recherche (général)", null); + assertResultRow(result, row++, "2/2/2013 15:13", "-6.5001388", "58.066803", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "2/2/2013 15:20", "-6.533472", "58.08347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 15:24", "-6.533472", "58.066803", "Recherche (général)", null); + assertResultRow(result, row++, "2/2/2013 15:42", "-6.5668054", "58.08347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "2/2/2013 15:48", "-6.550139", "58.116802", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 15:53", "-6.550139", "58.116802", "Recherche (général)", null); + assertResultRow(result, row++, "2/2/2013 16:49", "-6.4501386", "58.28347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "2/2/2013 16:53", "-6.433472", "58.28347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 16:56", "-6.433472", "58.300137", "Recherche (général)", null); + assertResultRow(result, row++, "2/2/2013 17:56", "-6.533472", "58.18347", "Recherche (général)", null); + assertResultRow(result, row++, "2/2/2013 18:10", "-6.5001388", "58.166805", "Thonier arrivant sur le système détecté", "perte du système"); + assertResultRow(result, row++, "2/2/2013 18:12", "-6.5001388", "58.166805", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "2/2/2013 18:20", "-6.483472", "58.15014", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "2/2/2013 18:50", "-6.5668054", "58.08347", "Fin de veille", "3 bateaux dans la zone. On reste sur zone jusqu'à demain car présence de \"nourriture\" aux sonars"); + assertResultRow(result, row++, "3/2/2013 6:1", "-6.533472", "58.100136", "Recherche (général)", "un autre thonier dans la zone visible au radar."); + assertResultRow(result, row++, "3/2/2013 6:56", "-6.6168056", "58.08347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "3/2/2013 6:59", "-6.633472", "58.100136", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 7:5", "-6.6168056", "58.08347", "Recherche (général)", null); + assertResultRow(result, row++, "3/2/2013 7:57", "-6.483472", "58.15014", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "3/2/2013 7:59", "-6.483472", "58.15014", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "3/2/2013 8:18", "-6.4501386", "58.15014", "Thonier arrivant sur le système détecté", "Haut fond à 292 m, risque de perdre le filet si coup de senne"); + assertResultRow(result, row++, "3/2/2013 8:22", "-6.4501386", "58.166805", "Recherche (général)", null); + assertResultRow(result, row++, "3/2/2013 8:50", "-6.483472", "58.166805", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "3/2/2013 9:0", "-6.483472", "58.133472", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "3/2/2013 9:3", "-6.483472", "58.133472", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "3/2/2013 10:41", "-6.4668055", "58.15014", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "3/2/2013 10:43", "-6.4668055", "58.15014", "Recherche (général)", null); + assertResultRow(result, row++, "3/2/2013 11:18", "-6.5001388", "58.133472", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "3/2/2013 11:22", "-6.516805", "58.15014", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 11:23", "-6.516805", "58.15014", "Recherche (général)", null); + assertResultRow(result, row++, "3/2/2013 11:29", "-6.516805", "58.15014", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "3/2/2013 11:33", "-6.550139", "58.166805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 11:43", "-6.550139", "58.166805", "Recherche (général)", ""); + assertResultRow(result, row++, "3/2/2013 12:17", "-6.6001387", "58.23347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "3/2/2013 12:44", "-6.6168056", "58.300137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 13:17", "-6.6001387", "58.383472", "Recherche (général)", null); + assertResultRow(result, row++, "3/2/2013 13:22", "-6.6001387", "58.383472", "Route vers des systèmes observés", "Tâche au sonar, ne savent pas ce que c'est!"); + assertResultRow(result, row++, "3/2/2013 13:24", "-6.6001387", "58.383472", "Route vers des systèmes observés", "Balbaya visible à l'oeil nu. Autre système que celui observé à 13h22."); + assertResultRow(result, row++, "3/2/2013 13:37", "-6.6168056", "58.383472", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 13:38", "-6.6168056", "58.40014", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "3/2/2013 13:40", "-6.6168056", "58.40014", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 13:44", "-6.633472", "58.383472", "Recherche (général)", null); + assertResultRow(result, row++, "3/2/2013 13:45", "-6.633472", "58.383472", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "3/2/2013 13:57", "-6.683472", "58.33347", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "3/2/2013 14:21", "-6.6668053", "58.366802", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "3/2/2013 16:8", "-6.683472", "58.350136", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "3/2/2013 16:14", "-6.7001386", "58.33347", "Recherche (général)", null); + assertResultRow(result, row++, "3/2/2013 16:19", "-6.7168055", "58.33347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "3/2/2013 16:32", "-6.7501388", "58.28347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "3/2/2013 16:39", "-6.7501388", "58.266804", "Recherche (général)", null); + assertResultRow(result, row++, "3/2/2013 17:20", "-6.800139", "58.28347", "Route vers des systèmes observés", "Présence de marsouins donc non calée."); + assertResultRow(result, row++, "3/2/2013 17:41", "-6.8501387", "58.250137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "3/2/2013 17:53", "-6.8668056", "58.216805", "Thonier arrivant sur le système détecté", "Balise appartenant au Glénan, bateau de la SAPMER"); + assertResultRow(result, row++, "3/2/2013 17:54", "-6.8668056", "58.216805", "Recherche (général)", null); + assertResultRow(result, row++, "3/2/2013 18:1", "-6.883472", "58.18347", "Route vers des systèmes observés", "Banc de listao. Présence d'un palangrier et de thoniers au radar et à l'oeil nu."); + assertResultRow(result, row++, "3/2/2013 18:15", "-6.883472", "58.18347", "Thonier arrivant sur le système détecté", "Banc de listao, Albacore recherché!"); + assertResultRow(result, row++, "3/2/2013 18:25", "-6.8668056", "58.166805", "Recherche (général)", null); + assertResultRow(result, row++, "3/2/2013 18:53", "-6.766805", "58.18347", "Fin de veille", null); + assertResultRow(result, row++, "4/2/2013 5:49", "-6.7334723", "58.166805", "Recherche (général)", "2 thoniers visibles au radar."); + assertResultRow(result, row++, "4/2/2013 6:49", "-6.6001387", "58.15014", "Recherche (général)", null); + assertResultRow(result, row++, "4/2/2013 7:43", "-6.6001387", "58.016804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "4/2/2013 7:48", "-6.5834723", "58.016804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 7:59", "-6.5834723", "58.0", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null); + assertResultRow(result, row++, "4/2/2013 8:0", "-6.5834723", "58.0", "Récupération d'une épave n'appartenant pas au bateau", ""); + assertResultRow(result, row++, "4/2/2013 8:13", "-6.5668054", "58.016804", "Recherche (général)", null); + assertResultRow(result, row++, "4/2/2013 8:14", "-6.5668054", "58.016804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "4/2/2013 8:31", "-6.533472", "58.066803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 8:49", "-6.533472", "58.08347", "Recherche (général)", null); + assertResultRow(result, row++, "4/2/2013 9:49", "-6.4168053", "58.23347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "4/2/2013 9:52", "-6.433472", "58.23347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 10:0", "-6.433472", "58.23347", "Recherche (général)", null); + assertResultRow(result, row++, "4/2/2013 10:6", "-6.4501386", "58.250137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "4/2/2013 10:17", "-6.4501386", "58.28347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 10:21", "-6.4501386", "58.28347", "Recherche (général)", null); + assertResultRow(result, row++, "4/2/2013 11:21", "-6.5834723", "58.116802", "Recherche (général)", null); + assertResultRow(result, row++, "4/2/2013 12:9", "-6.550139", "58.03347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "4/2/2013 12:32", "-6.550139", "57.966805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 12:36", "-6.550139", "57.950138", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "4/2/2013 12:50", "-6.5668054", "57.90014", "Thonier arrivant sur le système détecté", "Il ya des thons albacores partout tout autour du navire. Ils sautent, vont dans tous les sens le banc est énorme mais dispersé et il ne garde pas le même cap!"); + assertResultRow(result, row++, "4/2/2013 13:50", "-6.5834723", "57.816803", "Thonier arrivant sur le système détecté", "Même banc que précédemment! dispersé et trop rapide."); + assertResultRow(result, row++, "4/2/2013 14:8", "-6.6168056", "57.816803", "Recherche (général)", null); + assertResultRow(result, row++, "4/2/2013 14:9", "-6.6168056", "57.816803", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "4/2/2013 14:17", "-6.650139", "57.816803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 14:20", "-6.650139", "57.816803", "Route vers des systèmes observés", "Même banc qu'à 12h50 ENORME!"); + assertResultRow(result, row++, "4/2/2013 14:36", "-6.5834723", "57.78347", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "4/2/2013 15:36", "-6.533472", "57.766804", "Thonier arrivant sur le système détecté", "Poissons dispersés et trop rapide. Ne gardent pas le même cap, sautent dans tous les sens!"); + assertResultRow(result, row++, "4/2/2013 16:24", "-6.483472", "57.750137", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "4/2/2013 16:31", "-6.5001388", "57.766804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 16:32", "-6.5001388", "57.766804", "Recherche (général)", null); + assertResultRow(result, row++, "4/2/2013 16:33", "-6.5001388", "57.766804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "4/2/2013 16:39", "-6.483472", "57.766804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 16:46", "-6.483472", "57.78347", "Recherche (général)", null); + assertResultRow(result, row++, "4/2/2013 16:57", "-6.4501386", "57.766804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "4/2/2013 16:59", "-6.4501386", "57.750137", "Thonier arrivant sur le système détecté", "Présence de globicéphales."); + assertResultRow(result, row++, "4/2/2013 17:4", "-6.4501386", "57.766804", "Recherche (général)", null); + assertResultRow(result, row++, "4/2/2013 17:6", "-6.4501386", "57.78347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "4/2/2013 17:12", "-6.4668055", "57.800137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "4/2/2013 17:24", "-6.4501386", "57.816803", "Recherche (général)", null); + assertResultRow(result, row++, "4/2/2013 17:36", "-6.433472", "57.850136", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "4/2/2013 17:40", "-6.433472", "57.883472", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "4/2/2013 18:3", "-6.433472", "57.916805", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "4/2/2013 19:43", "-6.433472", "57.916805", "Fin de pêche (remontée du skiff)", "Coup Nul."); + assertResultRow(result, row++, "4/2/2013 19:44", "-6.433472", "57.916805", "Fin de veille", null); + assertResultRow(result, row++, "5/2/2013 5:43", "-6.4501386", "58.18347", "Thonier arrivant sur le système détecté", "Route de nuit vers le DCP mis la veille."); + assertResultRow(result, row++, "5/2/2013 5:48", "-6.4501386", "58.18347", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "5/2/2013 8:0", "-6.4668055", "58.200138", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "5/2/2013 8:16", "-6.4668055", "58.23347", "Recherche (général)", null); + assertResultRow(result, row++, "5/2/2013 9:22", "-6.5834723", "58.08347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "5/2/2013 9:29", "-6.6001387", "58.016804", "Thonier arrivant sur le système détecté", "Présence de marsouins"); + assertResultRow(result, row++, "5/2/2013 9:30", "-6.6001387", "58.016804", "Recherche (général)", null); + assertResultRow(result, row++, "5/2/2013 10:13", "-6.6668053", "57.883472", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "5/2/2013 10:26", "-6.6668053", "57.83347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "5/2/2013 10:30", "-6.683472", "57.83347", "Thonier arrivant sur le système détecté", "Présence de Marsouins!"); + assertResultRow(result, row++, "5/2/2013 10:33", "-6.683472", "57.816803", "Recherche (général)", null); + assertResultRow(result, row++, "5/2/2013 10:53", "-6.7501388", "57.78347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "5/2/2013 11:13", "-6.800139", "57.750137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "5/2/2013 11:25", "-6.800139", "57.750137", "Recherche (général)", null); + assertResultRow(result, row++, "5/2/2013 12:25", "-6.8168054", "57.666805", "Recherche (général)", null); + assertResultRow(result, row++, "5/2/2013 13:25", "-7.183472", "57.666805", "Recherche (général)", null); + assertResultRow(result, row++, "5/2/2013 14:25", "-7.4501386", "57.616802", "Recherche (général)", null); + assertResultRow(result, row++, "5/2/2013 14:35", "-7.5001388", "57.633472", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "5/2/2013 14:38", "-7.5001388", "57.633472", "Recherche (général)", null); + assertResultRow(result, row++, "5/2/2013 15:38", "-7.766805", "57.600136", "Recherche (général)", null); + assertResultRow(result, row++, "5/2/2013 16:17", "-7.9501386", "57.516804", "Route vers des systèmes observés", "Listao"); + assertResultRow(result, row++, "5/2/2013 16:28", "-8.0", "57.516804", "Thonier arrivant sur le système détecté", "Listao"); + assertResultRow(result, row++, "5/2/2013 16:35", "-8.016806", "57.516804", "Recherche (général)", null); + assertResultRow(result, row++, "5/2/2013 17:42", "-8.316806", "57.43347", "Recherche (général)", "Marsouins observé mais nous les avons laissé au loin sur tribord sans prendre leur direction"); + assertResultRow(result, row++, "5/2/2013 18:57", "-8.650139", "57.43347", "Fin de veille", null); + assertResultRow(result, row++, "6/2/2013 5:55", "-11.616806", "56.550137", "Recherche (général)", null); + assertResultRow(result, row++, "6/2/2013 6:31", "-11.766806", "56.53347", "Route vers des systèmes observés", "Banc de listao"); + assertResultRow(result, row++, "6/2/2013 6:37", "-11.800139", "56.53347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "6/2/2013 6:41", "-11.800139", "56.550137", "Recherche (général)", null); + assertResultRow(result, row++, "6/2/2013 7:28", "-12.0", "56.550137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "6/2/2013 7:34", "-12.016806", "56.550137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "6/2/2013 7:47", "-12.016806", "56.550137", "Recherche (général)", "Shiftage de la calée du 05.02.13 réalisée à 8H"); + assertResultRow(result, row++, "6/2/2013 8:43", "-12.200139", "56.40014", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "6/2/2013 8:51", "-12.233473", "56.200138", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "6/2/2013 9:41", "-12.366806", "56.200138", "Route vers des systèmes observés", "Zone avec pleins de petits balbaya. 3 thoniers français sur zone."); + assertResultRow(result, row++, "6/2/2013 9:43", "-12.366806", "56.18347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "6/2/2013 10:5", "-12.433473", "56.100136", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "6/2/2013 10:16", "-12.466805", "56.066803", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "6/2/2013 10:19", "-12.466805", "56.050137", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "6/2/2013 12:28", "-12.466805", "56.03347", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "6/2/2013 12:32", "-12.466805", "56.050137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "6/2/2013 12:49", "-12.416806", "56.050137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "6/2/2013 13:0", "-12.433473", "56.066803", "Recherche (général)", null); + assertResultRow(result, row++, "6/2/2013 13:10", "-12.450139", "56.100136", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "6/2/2013 13:26", "-12.416806", "56.133472", "Route vers des systèmes observés", "Pleins de petits banc d'YFT et de SKJ"); + assertResultRow(result, row++, "6/2/2013 14:20", "-12.450139", "56.0", "Thonier arrivant sur le système détecté", "listao + baleine"); + assertResultRow(result, row++, "6/2/2013 14:20", "-12.450139", "56.0", "Recherche (général)", null); + assertResultRow(result, row++, "6/2/2013 14:30", "-12.450139", "56.050137", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "6/2/2013 15:14", "-12.450139", "56.100136", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "6/2/2013 15:51", "-12.366806", "56.03347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "6/2/2013 15:54", "-12.366806", "56.03347", "Recherche (général)", null); + assertResultRow(result, row++, "6/2/2013 16:22", "-12.400139", "56.03347", "Route vers des systèmes observés", "une dizaine de poisson (petit banc)."); + assertResultRow(result, row++, "6/2/2013 16:25", "-12.400139", "56.016804", "Thonier arrivant sur le système détecté", "Plusieurs bancs, dont un plus interessant."); + assertResultRow(result, row++, "6/2/2013 16:53", "-12.400139", "56.016804", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "6/2/2013 19:1", "-12.383472", "56.0", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "6/2/2013 19:3", "-12.383472", "56.0", "Recherche (général)", null); + assertResultRow(result, row++, "6/2/2013 19:22", "-12.333472", "56.03347", "Fin de veille", null); + assertResultRow(result, row++, "7/2/2013 5:47", "-12.216805", "56.116802", "Recherche (général)", null); + assertResultRow(result, row++, "7/2/2013 6:6", "-12.183473", "56.116802", "Route vers des systèmes observés", "Présence de marsouins, nous continuons notre route."); + assertResultRow(result, row++, "7/2/2013 6:8", "-12.183473", "56.116802", "Recherche (général)", null); + assertResultRow(result, row++, "7/2/2013 6:32", "-12.200139", "56.116802", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "7/2/2013 6:34", "-12.200139", "56.133472", "Thonier arrivant sur le système détecté", "Banc de listao"); + assertResultRow(result, row++, "7/2/2013 6:36", "-12.216805", "56.133472", "Recherche (général)", null); + assertResultRow(result, row++, "7/2/2013 6:38", "-12.216805", "56.133472", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "7/2/2013 7:9", "-12.266806", "56.133472", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "7/2/2013 7:10", "-12.266806", "56.166805", "Recherche (général)", null); + assertResultRow(result, row++, "7/2/2013 7:13", "-12.266806", "56.18347", "Route vers des systèmes observés", "Listao + baleines"); + assertResultRow(result, row++, "7/2/2013 7:25", "-12.300139", "56.216805", "Thonier arrivant sur le système détecté", "Listao + 3 baleines"); + assertResultRow(result, row++, "7/2/2013 7:32", "-12.333472", "56.200138", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "7/2/2013 8:11", "-12.383472", "56.050137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "7/2/2013 8:15", "-12.383472", "56.03347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "7/2/2013 8:21", "-12.383472", "56.03347", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "7/2/2013 8:57", "-12.400139", "55.950138", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "7/2/2013 11:12", "-12.400139", "55.93347", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "7/2/2013 11:16", "-12.400139", "55.93347", "Recherche (général)", null); + assertResultRow(result, row++, "7/2/2013 11:46", "-12.383472", "55.98347", "Route vers des systèmes observés", "Nombre impressionnant de thons! gros balbaya!"); + assertResultRow(result, row++, "7/2/2013 11:47", "-12.383472", "55.98347", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "7/2/2013 12:47", "-12.416806", "56.016804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "7/2/2013 12:51", "-12.416806", "56.016804", "Recherche (général)", null); + assertResultRow(result, row++, "7/2/2013 13:3", "-12.383472", "56.03347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "7/2/2013 13:8", "-12.35014", "56.03347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "7/2/2013 13:42", "-12.35014", "56.016804", "Recherche (général)", null); + assertResultRow(result, row++, "7/2/2013 13:46", "-12.366806", "56.016804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "7/2/2013 13:52", "-12.400139", "56.016804", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "7/2/2013 13:56", "-12.400139", "56.016804", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "7/2/2013 15:54", "-12.416806", "56.016804", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "7/2/2013 16:10", "-12.366806", "55.98347", "Recherche (général)", null); + assertResultRow(result, row++, "7/2/2013 16:43", "-12.266806", "55.966805", "Route vers des systèmes observés", "Banc de Listao"); + assertResultRow(result, row++, "7/2/2013 16:45", "-12.283473", "55.950138", "Thonier arrivant sur le système détecté", "Banc de listao trop rapide, banc de gros albacore visé!"); + assertResultRow(result, row++, "7/2/2013 16:46", "-12.283473", "55.950138", "Recherche (général)", null); + assertResultRow(result, row++, "7/2/2013 16:52", "-12.283473", "55.98347", "Route vers des systèmes observés", "Banc de listao vu directement aux jumelles nous continuons donc notre route!"); + assertResultRow(result, row++, "7/2/2013 17:39", "-12.250139", "55.98347", "Route vers des systèmes observés", "Listao + baleine"); + assertResultRow(result, row++, "7/2/2013 18:1", "-12.283473", "55.916805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "7/2/2013 18:9", "-12.300139", "55.90014", "Recherche (général)", null); + assertResultRow(result, row++, "7/2/2013 19:0", "-12.433473", "55.883472", "Fin de veille", null); + assertResultRow(result, row++, "8/2/2013 5:54", "-12.433473", "55.816803", "Recherche (général)", null); + assertResultRow(result, row++, "8/2/2013 6:54", "-12.383472", "55.90014", "Recherche (général)", null); + assertResultRow(result, row++, "8/2/2013 6:58", "-12.333472", "55.93347", "Route vers des systèmes observés", "Pleins de \"petits bouillons\" partout tout autour de nous, petits bancs rapides!"); + assertResultRow(result, row++, "8/2/2013 7:17", "-12.316806", "55.950138", "Thonier arrivant sur le système détecté", "Banc de listao + marsouins+ oiseaux"); + assertResultRow(result, row++, "8/2/2013 7:23", "-12.300139", "55.98347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "8/2/2013 7:29", "-12.283473", "56.0", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 7:34", "-12.266806", "56.0", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "8/2/2013 7:50", "-12.216805", "56.016804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 7:52", "-12.233473", "56.016804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "8/2/2013 8:2", "-12.250139", "56.03347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 8:4", "-12.250139", "56.03347", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "8/2/2013 8:21", "-12.200139", "56.100136", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 8:25", "-12.200139", "56.116802", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "8/2/2013 8:27", "-12.200139", "56.116802", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 8:52", "-12.183473", "56.08347", "Recherche (général)", null); + assertResultRow(result, row++, "8/2/2013 9:1", "-12.216805", "56.066803", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "8/2/2013 9:15", "-12.250139", "56.016804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 9:29", "-12.250139", "56.016804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "8/2/2013 9:39", "-12.250139", "55.98347", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "8/2/2013 9:52", "-12.250139", "55.98347", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "8/2/2013 11:51", "-12.250139", "55.98347", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "8/2/2013 12:0", "-12.233473", "55.98347", "Recherche (général)", null); + assertResultRow(result, row++, "8/2/2013 12:26", "-12.200139", "56.066803", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "8/2/2013 12:30", "-12.183473", "56.066803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "8/2/2013 12:42", "-12.183473", "56.100136", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "8/2/2013 12:59", "-12.183473", "56.116802", "Thonier arrivant sur le système détecté", "listao + albacore trop petits"); + assertResultRow(result, row++, "8/2/2013 13:0", "-12.183473", "56.133472", "Recherche (général)", null); + assertResultRow(result, row++, "8/2/2013 13:6", "-12.183473", "56.116802", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "8/2/2013 13:11", "-12.200139", "56.116802", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "8/2/2013 13:27", "-12.200139", "56.133472", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "8/2/2013 15:34", "-12.216805", "56.116802", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "8/2/2013 15:47", "-12.250139", "56.116802", "Recherche (général)", null); + assertResultRow(result, row++, "8/2/2013 15:51", "-12.266806", "56.100136", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "8/2/2013 16:1", "-12.283473", "56.100136", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "8/2/2013 16:3", "-12.283473", "56.100136", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "8/2/2013 18:8", "-12.300139", "56.100136", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "8/2/2013 18:16", "-12.300139", "56.116802", "Recherche (général)", null); + assertResultRow(result, row++, "8/2/2013 18:56", "-12.233473", "56.116802", "Fin de veille", null); + assertResultRow(result, row++, "9/2/2013 5:50", "-12.233473", "56.050137", "Recherche (général)", null); + assertResultRow(result, row++, "9/2/2013 6:35", "-12.166806", "56.100136", "Route vers des systèmes observés", "Banc de listao, pas interessant, nous continuons notre route sans s'arrêter!"); + assertResultRow(result, row++, "9/2/2013 6:41", "-12.133472", "56.100136", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "9/2/2013 6:53", "-12.133472", "56.15014", "Thonier arrivant sur le système détecté", "Présence de \"marsouins\" et banc trop petit"); + assertResultRow(result, row++, "9/2/2013 6:57", "-12.133472", "56.15014", "Recherche (général)", null); + assertResultRow(result, row++, "9/2/2013 7:3", "-12.150139", "56.15014", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "9/2/2013 7:12", "-12.150139", "56.116802", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "9/2/2013 7:30", "-12.166806", "56.066803", "Recherche (général)", null); + assertResultRow(result, row++, "9/2/2013 7:42", "-12.216805", "56.066803", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "9/2/2013 7:59", "-12.266806", "56.03347", "Thonier arrivant sur le système détecté", "Banc de listao"); + assertResultRow(result, row++, "9/2/2013 8:0", "-12.266806", "56.03347", "Recherche (général)", null); + assertResultRow(result, row++, "9/2/2013 8:3", "-12.283473", "56.03347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "9/2/2013 8:24", "-12.366806", "56.050137", "Thonier arrivant sur le système détecté", "Pleins de petits bancs partout"); + assertResultRow(result, row++, "9/2/2013 8:50", "-12.333472", "56.066803", "Recherche (général)", null); + assertResultRow(result, row++, "9/2/2013 8:51", "-12.35014", "56.066803", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "9/2/2013 8:53", "-12.35014", "56.066803", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "9/2/2013 8:55", "-12.366806", "56.050137", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "9/2/2013 11:4", "-12.366806", "56.03347", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "9/2/2013 11:11", "-12.35014", "56.016804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "9/2/2013 11:12", "-12.35014", "56.03347", "Thonier arrivant sur le système détecté", "Listao trop rapide et pas interessant pour le capitaine."); + assertResultRow(result, row++, "9/2/2013 11:27", "-12.333472", "56.03347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "9/2/2013 11:31", "-12.316806", "56.03347", "Thonier arrivant sur le système détecté", "Listao + baleine"); + assertResultRow(result, row++, "9/2/2013 11:32", "-12.316806", "56.050137", "Route vers des systèmes observés", "pleins de petits \"bouts\" partout"); + assertResultRow(result, row++, "9/2/2013 11:35", "-12.316806", "56.050137", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "9/2/2013 11:40", "-12.316806", "56.066803", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "9/2/2013 14:1", "-12.300139", "56.03347", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "9/2/2013 14:3", "-12.300139", "56.03347", "Recherche (général)", null); + assertResultRow(result, row++, "9/2/2013 15:15", "-12.283473", "55.966805", "Thonier arrivant sur le système détecté", "Shiftage de 14h à 15h."); + assertResultRow(result, row++, "9/2/2013 15:18", "-12.283473", "55.966805", "Recherche (général)", null); + assertResultRow(result, row++, "9/2/2013 15:37", "-12.316806", "56.0", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "9/2/2013 15:48", "-12.316806", "56.050137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "9/2/2013 15:51", "-12.300139", "56.050137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "9/2/2013 15:56", "-12.300139", "56.066803", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "9/2/2013 16:17", "-12.316806", "56.03347", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "9/2/2013 18:39", "-12.333472", "56.016804", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "9/2/2013 18:40", "-12.333472", "56.016804", "Recherche (général)", null); + assertResultRow(result, row++, "9/2/2013 19:3", "-12.316806", "55.98347", "Fin de veille", null); + assertResultRow(result, row++, "10/2/2013 5:55", "-12.316806", "55.916805", "Thonier arrivant sur le système détecté", "épave balisée la veille."); + assertResultRow(result, row++, "10/2/2013 6:2", "-12.316806", "55.916805", "Recherche (général)", null); + assertResultRow(result, row++, "10/2/2013 7:2", "-12.366806", "56.03347", "Recherche (général)", null); + assertResultRow(result, row++, "10/2/2013 7:57", "-12.316806", "55.916805", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "10/2/2013 7:58", "-12.316806", "55.916805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "10/2/2013 8:5", "-12.316806", "55.916805", "Recherche (général)", null); + assertResultRow(result, row++, "10/2/2013 8:11", "-12.333472", "55.916805", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "10/2/2013 8:21", "-12.366806", "55.916805", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "10/2/2013 8:26", "-12.366806", "55.916805", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "10/2/2013 10:38", "-12.383472", "55.916805", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "10/2/2013 10:39", "-12.383472", "55.93347", "Recherche (général)", null); + assertResultRow(result, row++, "10/2/2013 11:6", "-12.433473", "55.90014", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "10/2/2013 11:21", "-12.450139", "55.850136", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "10/2/2013 11:33", "-12.450139", "55.850136", "Recherche (général)", null); + assertResultRow(result, row++, "10/2/2013 12:6", "-12.400139", "55.816803", "Route vers des systèmes observés", "Banc de Listao."); + assertResultRow(result, row++, "10/2/2013 12:16", "-12.383472", "55.850136", "Thonier arrivant sur le système détecté", "Banc de Listao"); + assertResultRow(result, row++, "10/2/2013 12:17", "-12.383472", "55.850136", "Recherche (général)", null); + assertResultRow(result, row++, "10/2/2013 13:17", "-12.200139", "55.73347", "Recherche (général)", null); + assertResultRow(result, row++, "10/2/2013 14:17", "-12.033473", "55.600136", "Recherche (général)", "Shiftage de 14h à 16h06!"); + assertResultRow(result, row++, "10/2/2013 15:17", "-11.866806", "55.466805", "Recherche (général)", null); + assertResultRow(result, row++, "10/2/2013 16:17", "-11.700139", "55.350136", "Recherche (général)", null); + assertResultRow(result, row++, "10/2/2013 17:46", "-11.983473", "55.366802", "Recherche (général)", null); + assertResultRow(result, row++, "10/2/2013 19:4", "-12.216805", "55.48347", "Fin de veille", ""); + assertResultRow(result, row++, "11/2/2013 5:54", "-12.283473", "55.48347", "Recherche (général)", null); + assertResultRow(result, row++, "11/2/2013 6:54", "-12.433473", "55.48347", "Recherche (général)", null); + assertResultRow(result, row++, "11/2/2013 6:56", "-12.433473", "55.48347", "Route vers des systèmes observés", "Poissons \"étalés\""); + assertResultRow(result, row++, "11/2/2013 7:17", "-12.466805", "55.53347", "Thonier arrivant sur le système détecté", "Nous sommes 5 sur la zone avec notamment le Glénan (CFTO), le Dolomieu (SAPMER) et Franche-Terre (SAPMER)"); + assertResultRow(result, row++, "11/2/2013 8:21", "-12.450139", "55.516804", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "11/2/2013 11:6", "-12.433473", "55.516804", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "11/2/2013 11:10", "-12.433473", "55.516804", "Recherche (général)", null); + assertResultRow(result, row++, "11/2/2013 11:23", "-12.433473", "55.516804", "Début de pêche (larguage du skiff)", "Shiftage du 10.02.2013 de 11h10 à 11h30"); + assertResultRow(result, row++, "11/2/2013 14:2", "-12.416806", "55.516804", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "11/2/2013 14:6", "-12.416806", "55.516804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "11/2/2013 14:8", "-12.416806", "55.53347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "11/2/2013 14:13", "-12.416806", "55.53347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "11/2/2013 14:33", "-12.366806", "55.53347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "11/2/2013 15:7", "-12.366806", "55.566803", "Recherche (général)", null); + assertResultRow(result, row++, "11/2/2013 15:15", "-12.366806", "55.550137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "11/2/2013 15:17", "-12.383472", "55.550137", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "11/2/2013 15:28", "-12.366806", "55.566803", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "11/2/2013 17:35", "-12.35014", "55.550137", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "11/2/2013 17:39", "-12.35014", "55.53347", "Recherche (général)", null); + assertResultRow(result, row++, "11/2/2013 18:57", "-12.500139", "55.600136", "Fin de veille", null); + assertResultRow(result, row++, "12/2/2013 5:50", "-12.516806", "55.450138", "Recherche (général)", "Nous sommes à côté d'un épave."); + assertResultRow(result, row++, "12/2/2013 6:28", "-12.416806", "55.500137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "12/2/2013 6:47", "-12.366806", "55.53347", "Thonier arrivant sur le système détecté", "Poissons étalés, Mélange Listao et Albacore"); + assertResultRow(result, row++, "12/2/2013 6:58", "-12.35014", "55.550137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "12/2/2013 6:59", "-12.35014", "55.550137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "12/2/2013 7:13", "-12.35014", "55.550137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "12/2/2013 7:20", "-12.333472", "55.566803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "12/2/2013 7:38", "-12.316806", "55.566803", "Recherche (général)", null); + assertResultRow(result, row++, "12/2/2013 8:38", "-12.316806", "55.366802", "Recherche (général)", null); + assertResultRow(result, row++, "12/2/2013 9:20", "-12.316806", "55.53347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "12/2/2013 9:36", "-12.300139", "55.53347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "12/2/2013 9:40", "-12.300139", "55.53347", "Recherche (général)", null); + assertResultRow(result, row++, "12/2/2013 10:40", "-12.116806", "55.600136", "Recherche (général)", null); + assertResultRow(result, row++, "12/2/2013 11:30", "-12.016806", "55.700138", "Recherche (général)", null); + assertResultRow(result, row++, "12/2/2013 12:30", "-11.800139", "55.700138", "Recherche (général)", null); + assertResultRow(result, row++, "12/2/2013 13:24", "-11.60014", "55.68347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null); + assertResultRow(result, row++, "12/2/2013 13:30", "-11.60014", "55.68347", "Recherche (général)", null); + assertResultRow(result, row++, "12/2/2013 14:30", "-11.35014", "55.666805", "Recherche (général)", null); + assertResultRow(result, row++, "12/2/2013 14:53", "-11.316806", "55.616802", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "12/2/2013 15:0", "-11.300139", "55.600136", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "12/2/2013 15:5", "-11.300139", "55.616802", "Recherche (général)", null); + assertResultRow(result, row++, "12/2/2013 16:5", "-11.083472", "55.616802", "Recherche (général)", null); + assertResultRow(result, row++, "12/2/2013 17:5", "-10.866806", "55.58347", "Recherche (général)", null); + assertResultRow(result, row++, "12/2/2013 18:0", "-10.683473", "55.53347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null); + assertResultRow(result, row++, "12/2/2013 18:5", "-10.666806", "55.53347", "Recherche (général)", null); + assertResultRow(result, row++, "12/2/2013 18:58", "-10.500139", "55.53347", "Fin de veille", null); + assertResultRow(result, row++, "13/2/2013 5:52", "-9.016806", "55.250137", "Thonier arrivant sur le système détecté", "Route de nuit vers ce radeau."); + assertResultRow(result, row++, "13/2/2013 6:0", "-9.0", "55.250137", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 7:0", "-8.983473", "55.450138", "Recherche (général)", "Présence du Glénan (CFTO)"); + assertResultRow(result, row++, "13/2/2013 7:24", "-8.983473", "55.516804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "13/2/2013 7:32", "-8.950139", "55.516804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "13/2/2013 7:41", "-8.966805", "55.516804", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 8:35", "-8.950139", "55.68347", "Route vers des systèmes observés", "Nous n'avons pas trouvé le radeau à cause de la pluie, nous ne l'avons pas retrouvé!"); + assertResultRow(result, row++, "13/2/2013 9:0", "-8.966805", "55.750137", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 10:0", "-9.0", "55.966805", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 10:16", "-9.0", "56.016804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "13/2/2013 10:20", "-9.016806", "56.016804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "13/2/2013 10:36", "-9.016806", "56.050137", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 11:17", "-9.016806", "56.166805", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "13/2/2013 11:29", "-9.0", "56.23347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "13/2/2013 11:33", "-9.0", "56.250137", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 12:38", "-9.0", "56.48347", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 13:38", "-8.966805", "56.68347", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 13:43", "-8.966805", "56.700138", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "13/2/2013 13:55", "-8.983473", "56.73347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", ""); + assertResultRow(result, row++, "13/2/2013 14:0", "-8.983473", "56.73347", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 14:12", "-8.983473", "56.766804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "13/2/2013 14:20", "-9.0", "56.766804", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "13/2/2013 14:27", "-9.016806", "56.816803", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 15:27", "-9.116806", "56.016804", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 16:20", "-9.250139", "57.133472", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "13/2/2013 16:24", "-9.250139", "57.133472", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "13/2/2013 16:26", "-9.250139", "57.133472", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 17:27", "-9.066806", "57.23347", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 18:27", "-8.883472", "57.33347", "Recherche (général)", null); + assertResultRow(result, row++, "13/2/2013 18:57", "-8.783473", "57.350136", "Fin de veille", "Route jusqu'à 23h."); + assertResultRow(result, row++, "14/2/2013 6:5", "-7.9501386", "57.68347", "Recherche (général)", "Pluie."); + assertResultRow(result, row++, "14/2/2013 7:2", "-7.7501388", "57.73347", "Route vers des systèmes observés", "Présence de marsouins, nous n'allons pas vers le système observé, nous reprnons notre cap sans se rendre sur zone. Pluie"); + assertResultRow(result, row++, "14/2/2013 7:5", "-7.7334723", "57.73347", "Recherche (général)", "Pluie"); + assertResultRow(result, row++, "14/2/2013 8:5", "-7.533472", "57.800137", "Recherche (général)", null); + assertResultRow(result, row++, "14/2/2013 9:5", "-7.383472", "57.916805", "Recherche (général)", null); + assertResultRow(result, row++, "14/2/2013 10:5", "-7.2001386", "58.0", "Recherche (général)", null); + assertResultRow(result, row++, "14/2/2013 10:10", "-7.183472", "58.0", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "14/2/2013 10:19", "-7.150139", "58.0", "Thonier arrivant sur le système détecté", "\"Balbaya de Marsouins\" pas d'YFT."); + assertResultRow(result, row++, "14/2/2013 10:20", "-7.150139", "58.016804", "Recherche (général)", null); + assertResultRow(result, row++, "14/2/2013 11:20", "-6.9501386", "58.050137", "Recherche (général)", null); + assertResultRow(result, row++, "14/2/2013 12:20", "-6.7334723", "58.050137", "Recherche (général)", null); + assertResultRow(result, row++, "14/2/2013 13:20", "-6.5668054", "58.166805", "Recherche (général)", null); + assertResultRow(result, row++, "14/2/2013 14:20", "-6.483472", "58.050137", "Recherche (général)", null); + assertResultRow(result, row++, "14/2/2013 15:20", "-6.4668055", "57.850136", "Recherche (général)", null); + assertResultRow(result, row++, "14/2/2013 16:20", "-6.483472", "57.516804", "Recherche (général)", null); + assertResultRow(result, row++, "14/2/2013 17:20", "-6.633472", "57.68347", "Recherche (général)", null); + assertResultRow(result, row++, "14/2/2013 18:20", "-6.633472", "57.48347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "14/2/2013 18:23", "-6.633472", "57.48347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "14/2/2013 18:25", "-6.633472", "57.466805", "Recherche (général)", null); + assertResultRow(result, row++, "14/2/2013 18:52", "-6.633472", "57.383472", "Fin de veille", "Route toute la nuit."); + assertResultRow(result, row++, "15/2/2013 6:5", "-6.383472", "55.300137", "Recherche (général)", null); + assertResultRow(result, row++, "15/2/2013 7:5", "-6.2668056", "55.15014", "Recherche (général)", null); + assertResultRow(result, row++, "15/2/2013 8:5", "-6.150139", "55.0", "Recherche (général)", null); + assertResultRow(result, row++, "15/2/2013 9:5", "-6.0668054", "55.0", "Recherche (général)", null); + assertResultRow(result, row++, "15/2/2013 10:5", "-5.9834723", "54.90014", "Recherche (général)", null); + assertResultRow(result, row++, "15/2/2013 11:5", "-5.9501386", "54.700138", "Recherche (général)", null); + assertResultRow(result, row++, "15/2/2013 11:6", "-5.9501386", "54.700138", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "15/2/2013 11:14", "-5.9501386", "54.666805", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "15/2/2013 12:8", "-6.0", "54.666805", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "15/2/2013 14:4", "-6.0", "54.700138", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "15/2/2013 14:15", "-6.0", "54.700138", "Recherche (général)", null); + assertResultRow(result, row++, "15/2/2013 15:15", "-5.9501386", "54.550137", "Recherche (général)", null); + assertResultRow(result, row++, "15/2/2013 16:15", "-5.8168054", "54.40014", "Recherche (général)", null); + assertResultRow(result, row++, "15/2/2013 16:51", "-5.7334723", "54.33347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "15/2/2013 16:54", "-5.7334723", "54.33347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "15/2/2013 16:56", "-5.7334723", "54.33347", "Recherche (général)", null); + assertResultRow(result, row++, "15/2/2013 17:37", "-5.6001387", "54.316803", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "15/2/2013 17:46", "-5.5834723", "54.33347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "15/2/2013 17:50", "-5.5668054", "54.33347", "Recherche (général)", null); + assertResultRow(result, row++, "15/2/2013 18:54", "-5.4501386", "54.166805", "Recherche (général)", null); + assertResultRow(result, row++, "15/2/2013 19:0", "-5.433472", "54.166805", "Fin de veille", null); + assertResultRow(result, row++, "15/2/2013 19:1", "-5.433472", "54.166805", "Route de nuit vers objet", "Route vers un radeau balisé du bateau au nord apperçu sur un logiciel du bateau."); + assertResultRow(result, row++, "16/2/2013 6:0", "-4.2168055", "53.850136", "Recherche (général)", "Nous n'avons pas retrouvé le radeau balisé appartenant au navire, nous reprenons notre route vers l'ouest"); + assertResultRow(result, row++, "16/2/2013 7:0", "-4.2168055", "53.766804", "Recherche (général)", null); + assertResultRow(result, row++, "16/2/2013 7:54", "-4.3668056", "53.716805", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "16/2/2013 8:5", "-4.383472", "53.716805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "16/2/2013 8:6", "-4.383472", "53.716805", "Recherche (général)", null); + assertResultRow(result, row++, "16/2/2013 8:39", "-4.4668055", "53.666805", "Route vers des systèmes observés", "\"Chicanneurs"); + assertResultRow(result, row++, "16/2/2013 8:48", "-4.5001388", "53.666805", "Thonier arrivant sur le système détecté", "\"Chicaneurs\" vus \"sur l'eau\" en surface puis ils ont plongés."); + assertResultRow(result, row++, "16/2/2013 9:0", "-4.5001388", "53.700138", "Recherche (général)", null); + assertResultRow(result, row++, "16/2/2013 9:28", "-4.5834723", "53.73347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "16/2/2013 9:43", "-4.633472", "53.766804", "Thonier arrivant sur le système détecté", "\"chicaneurs\""); + assertResultRow(result, row++, "16/2/2013 9:47", "-4.633472", "53.78347", "Recherche (général)", null); + assertResultRow(result, row++, "16/2/2013 10:47", "-4.633472", "53.616802", "Recherche (général)", null); + assertResultRow(result, row++, "16/2/2013 11:3", "-4.633472", "53.550137", "Route vers des systèmes observés", "Frégates observées."); + assertResultRow(result, row++, "16/2/2013 11:21", "-4.5834723", "53.53347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "16/2/2013 11:25", "-4.5668054", "53.516804", "Recherche (général)", null); + assertResultRow(result, row++, "16/2/2013 12:28", "-4.533472", "53.316803", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "16/2/2013 12:37", "-4.550139", "53.33347", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "16/2/2013 12:55", "-4.5668054", "53.316803", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "16/2/2013 15:15", "-4.5668054", "53.316803", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "16/2/2013 15:21", "-4.5668054", "53.316803", "Recherche (général)", null); + assertResultRow(result, row++, "16/2/2013 16:21", "-4.5668054", "53.116802", "Recherche (général)", null); + assertResultRow(result, row++, "16/2/2013 16:40", "-4.6168056", "53.08347", "Recherche (général)", "Erreur de ma part sur l'horraire, j'ai cru que le nid de pie avait vu quelque chose hors il n'y avait rien."); + assertResultRow(result, row++, "16/2/2013 17:40", "-4.7001386", "52.950138", "Recherche (général)", null); + assertResultRow(result, row++, "16/2/2013 18:20", "-4.783472", "52.83347", "Recherche (général)", null); + assertResultRow(result, row++, "16/2/2013 19:8", "-4.783472", "52.68347", "Fin de veille", "Route jusqu'à 20h"); + assertResultRow(result, row++, "17/2/2013 6:12", "-4.8168054", "52.550137", "Recherche (général)", ""); + assertResultRow(result, row++, "17/2/2013 7:12", "-4.7501388", "52.366802", "Recherche (général)", null); + assertResultRow(result, row++, "17/2/2013 7:22", "-4.7168055", "52.350136", "Route vers des systèmes observés", "Listao, la distance est trop importante, nous allons voir \"point de volaille\" moins loin."); + assertResultRow(result, row++, "17/2/2013 7:28", "-4.7168055", "52.316803", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "17/2/2013 7:41", "-4.7168055", "52.28347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "17/2/2013 7:43", "-4.7168055", "52.28347", "Route vers des systèmes observés", "\"Chicaneurs\", même système observé que celui de 07h22"); + assertResultRow(result, row++, "17/2/2013 7:50", "-4.7334723", "52.266804", "Thonier arrivant sur le système détecté", "Pas de thons mais des \"Marsouins\""); + assertResultRow(result, row++, "17/2/2013 7:51", "-4.7334723", "52.266804", "Recherche (général)", null); + assertResultRow(result, row++, "17/2/2013 8:0", "-4.7168055", "52.23347", "Recherche (général)", null); + assertResultRow(result, row++, "17/2/2013 8:32", "-4.650139", "52.133472", "Recherche (général)", null); + assertResultRow(result, row++, "17/2/2013 9:9", "-4.5834723", "52.03347", "Route vers des systèmes observés", "Tâche au sonar, nous prenons le cap puis confirmation des jumelles comme quoi c'est un balbaya de \"marsouins\" et non de \"gros\" nous reprenons notre cap directement sans aller jusqu'au système observé."); + assertResultRow(result, row++, "17/2/2013 9:12", "-4.5668054", "52.016804", "Recherche (général)", null); + assertResultRow(result, row++, "17/2/2013 9:54", "-4.5001388", "51.90014", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "17/2/2013 10:0", "-4.5001388", "51.883472", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "17/2/2013 10:35", "-4.5001388", "51.90014", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "17/2/2013 12:50", "-4.483472", "51.90014", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "17/2/2013 13:0", "-4.4668055", "51.883472", "Recherche (général)", null); + assertResultRow(result, row++, "17/2/2013 13:45", "-4.4668055", "51.73347", "Recherche (général)", "Shiftage de la calée duy 16.02.2013 de 14h à 14h57"); + assertResultRow(result, row++, "17/2/2013 14:22", "-4.483472", "51.700138", "Début de pêche (larguage du skiff)", "Environ 10 globicéphales autour du bateau"); + assertResultRow(result, row++, "17/2/2013 16:50", "-4.483472", "51.700138", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "17/2/2013 16:52", "-4.483472", "51.700138", "Recherche (général)", null); + assertResultRow(result, row++, "17/2/2013 17:52", "-4.5668054", "51.566803", "Recherche (général)", null); + assertResultRow(result, row++, "17/2/2013 18:55", "-4.7001386", "51.53347", "Recherche (général)", null); + assertResultRow(result, row++, "17/2/2013 19:15", "-4.7001386", "51.466805", "Fin de veille", "Pas de route cette nuit. Nous sommes stoppés."); + assertResultRow(result, row++, "18/2/2013 6:18", "-4.800139", "51.383472", "Recherche (général)", null); + assertResultRow(result, row++, "18/2/2013 7:18", "-4.766805", "51.200138", "Recherche (général)", null); + assertResultRow(result, row++, "18/2/2013 7:42", "-4.7168055", "51.133472", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "18/2/2013 7:59", "-4.7001386", "51.066803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "18/2/2013 8:0", "-4.7001386", "51.066803", "Recherche (général)", "Shiftage de 8h30 à 10h36J'ai loupé la rencontre avec un objet flottant, voilà le détail: Aux positions 4'42 et 50'53 il y a eut récupération d'une balise 98 et pose d'une balise 04 sur un radeau (bambou filet) appartenant à un autre armement"); + assertResultRow(result, row++, "18/2/2013 9:50", "-4.650139", "50.800137", "Recherche (général)", null); + assertResultRow(result, row++, "18/2/2013 10:50", "-4.6001387", "50.616802", "Recherche (général)", null); + assertResultRow(result, row++, "18/2/2013 11:50", "-4.183472", "50.466805", "Recherche (général)", null); + assertResultRow(result, row++, "18/2/2013 12:25", "-4.7168055", "50.383472", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "18/2/2013 12:35", "-4.7168055", "50.40014", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "18/2/2013 12:45", "-4.7168055", "50.40014", "Recherche (général)", null); + assertResultRow(result, row++, "18/2/2013 13:50", "-4.5668054", "50.250137", "Recherche (général)", null); + assertResultRow(result, row++, "18/2/2013 14:50", "-4.4668055", "50.08347", "Recherche (général)", null); + assertResultRow(result, row++, "18/2/2013 15:50", "-4.383472", "49.90014", "Recherche (général)", null); + assertResultRow(result, row++, "18/2/2013 16:50", "-4.4168053", "49.73347", "Recherche (général)", null); + assertResultRow(result, row++, "18/2/2013 17:50", "-4.300139", "49.58347", "Recherche (général)", null); + assertResultRow(result, row++, "18/2/2013 17:50", "-4.2168055", "49.40014", "Recherche (général)", "Changement d'heure (-1 heure!)"); + assertResultRow(result, row++, "18/2/2013 18:23", "-4.183472", "49.300137", "Fin de veille", "Nous faisons route toute la nuit seuf si rencontre avec d'autres navires, nous stoppons."); + assertResultRow(result, row++, "19/2/2013 5:45", "-3.700139", "48.116802", "Recherche (général)", null); + assertResultRow(result, row++, "19/2/2013 6:31", "-3.6334722", "48.116802", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "19/2/2013 6:35", "-3.6168058", "48.116802", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "19/2/2013 6:40", "-3.600139", "48.116802", "Recherche (général)", null); + assertResultRow(result, row++, "19/2/2013 7:40", "-3.5334723", "47.966805", "Recherche (général)", null); + assertResultRow(result, row++, "19/2/2013 7:47", "-3.550139", "47.93347", "Route vers des systèmes observés", "Présence de \"Marsousins\" et de Listao vu aux jumelle avant d'être arrivé sur le système observé, nous reprenons directement notre cap!"); + assertResultRow(result, row++, "19/2/2013 7:50", "-3.550139", "47.916805", "Recherche (général)", null); + assertResultRow(result, row++, "19/2/2013 8:50", "-3.550139", "47.766804", "Recherche (général)", null); + assertResultRow(result, row++, "19/2/2013 9:17", "-3.4668057", "47.766804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "19/2/2013 9:19", "-3.4668057", "47.766804", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "19/2/2013 9:28", "-3.4668057", "47.766804", "Début de pêche (larguage du skiff)", "Présence du bteau TREVIGNON"); + assertResultRow(result, row++, "19/2/2013 12:7", "-3.4834723", "47.78347", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "19/2/2013 12:16", "-3.500139", "47.83347", "Recherche (général)", null); + assertResultRow(result, row++, "19/2/2013 12:54", "-3.5668056", "47.73347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "19/2/2013 13:0", "-3.5668056", "47.73347", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "19/2/2013 13:20", "-3.5668056", "47.73347", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "19/2/2013 16:0", "-3.5834723", "47.78347", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "19/2/2013 16:1", "-3.5834723", "47.78347", "Recherche (général)", null); + assertResultRow(result, row++, "19/2/2013 16:27", "-3.500139", "47.766804", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "19/2/2013 16:40", "-3.4668057", "47.78347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "19/2/2013 16:41", "-3.4834723", "47.78347", "Recherche (général)", null); + assertResultRow(result, row++, "19/2/2013 16:53", "-3.4834723", "47.83347", "Route vers des systèmes observés", "Vu mattes aux jumelles, direction du système observé puis avant d'y arriver sur le système observé nous avons repris notre cap car c'était des listao!"); + assertResultRow(result, row++, "19/2/2013 16:54", "-3.4834723", "47.83347", "Recherche (général)", null); + assertResultRow(result, row++, "19/2/2013 17:18", "-3.550139", "47.766804", "Route vers des systèmes observés", "Gleurre"); + assertResultRow(result, row++, "19/2/2013 17:36", "-3.6168058", "47.716805", "Thonier arrivant sur le système détecté", "Gleurre en plus"); + assertResultRow(result, row++, "19/2/2013 17:40", "-3.6168058", "47.700138", "Début de pêche (larguage du skiff)", "Gleurre en plus"); + assertResultRow(result, row++, "19/2/2013 21:6", "-3.6168058", "47.766804", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "19/2/2013 21:7", "-3.6168058", "47.766804", "Fin de veille", null); + assertResultRow(result, row++, "20/2/2013 5:25", "-3.550139", "47.850136", "Recherche (général)", null); + assertResultRow(result, row++, "20/2/2013 6:25", "-3.5168056", "47.800137", "Recherche (général)", null); + assertResultRow(result, row++, "20/2/2013 6:40", "-3.4668057", "47.78347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "20/2/2013 7:3", "-3.450139", "47.716805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "20/2/2013 7:5", "-3.450139", "47.716805", "Recherche (général)", null); + assertResultRow(result, row++, "20/2/2013 7:45", "-3.3668058", "47.750137", "Recherche (général)", null); + assertResultRow(result, row++, "20/2/2013 8:45", "-3.2168057", "47.700138", "Recherche (général)", "Shiftage de la première calée du 19.02.2013 de 8h à 10h05"); + assertResultRow(result, row++, "20/2/2013 9:45", "-3.0168056", "47.68347", "Recherche (général)", null); + assertResultRow(result, row++, "20/2/2013 10:45", "-2.8834722", "47.566803", "Recherche (général)", null); + assertResultRow(result, row++, "20/2/2013 11:30", "-2.900139", "47.416805", "Route vers des systèmes observés", "Matte observée, route vers système observé, puis changement de cap avant d'arriver sur le système observé car listao aperçu. Reprenons notre cap sans se rendre sur le système observé."); + assertResultRow(result, row++, "20/2/2013 11:32", "-2.900139", "47.416805", "Recherche (général)", null); + assertResultRow(result, row++, "20/2/2013 12:30", "-2.7668056", "47.550137", "Recherche (général)", null); + assertResultRow(result, row++, "20/2/2013 13:30", "-2.750139", "47.750137", "Recherche (général)", null); + assertResultRow(result, row++, "20/2/2013 14:37", "-2.6334722", "47.93347", "Recherche (général)", "Shiftage de la deuxième calée du 19.02.2013 de 14h à 15h30"); + assertResultRow(result, row++, "20/2/2013 15:37", "-2.650139", "48.133472", "Recherche (général)", null); + assertResultRow(result, row++, "20/2/2013 16:37", "-2.4668057", "48.08347", "Recherche (général)", null); + assertResultRow(result, row++, "20/2/2013 17:37", "-2.3168056", "48.216805", "Recherche (général)", null); + assertResultRow(result, row++, "20/2/2013 18:20", "-2.2168057", "48.300137", "Fin de veille", "Stopper pour la nuit à partir de 20h."); + assertResultRow(result, row++, "21/2/2013 5:40", "-2.3168056", "48.33347", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 6:40", "-2.2334723", "48.48347", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 7:52", "-2.150139", "48.700138", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 7:58", "-2.150139", "48.700138", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null); + assertResultRow(result, row++, "21/2/2013 8:0", "-2.150139", "48.700138", "Recherche (général)", "shiftage de la 3 ème calée du 19.02.2013"); + assertResultRow(result, row++, "21/2/2013 9:0", "-2.0334723", "48.866802", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 10:0", "-1.9168056", "49.016804", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 11:0", "-1.7834722", "49.166805", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 12:0", "-1.6501389", "49.266804", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 12:13", "-1.6168056", "49.250137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "21/2/2013 12:41", "-1.6168056", "49.316803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "21/2/2013 12:45", "-1.6168056", "49.316803", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 13:45", "-1.5668055", "49.500137", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 13:58", "-1.5501388", "49.53347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "21/2/2013 14:2", "-1.5501388", "49.53347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", ""); + assertResultRow(result, row++, "21/2/2013 14:5", "-1.5334722", "49.53347", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 15:5", "-1.5834721", "49.65014", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 16:0", "-1.5334722", "49.800137", "Route vers des systèmes observés", "L'épave n'était pas à 1 milles mais plus près, nous l'avons dépassé sans la voir donc nous ne sommes pas aller sur le système observé, de plus aucun oiseaux n'avaient été vu a proximité de l'épave. Nous avons repris directement notre cap."); + assertResultRow(result, row++, "21/2/2013 16:2", "-1.5334722", "49.816803", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 17:2", "-1.4334723", "49.966805", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 17:45", "-1.3334723", "50.0", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null); + assertResultRow(result, row++, "21/2/2013 17:50", "-1.3334723", "50.0", "Recherche (général)", null); + assertResultRow(result, row++, "21/2/2013 18:11", "-1.3001388", "50.066803", "Fin de veille", "Route toute la nuit."); + assertResultRow(result, row++, "22/2/2013 5:22", "-0.3834722", "51.90014", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 5:43", "-0.35013887", "51.950138", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null); + assertResultRow(result, row++, "22/2/2013 5:45", "-0.35013887", "51.966805", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 6:45", "-0.31680554", "52.133472", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 6:47", "-0.31680554", "52.15014", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "22/2/2013 7:20", "-0.25013888", "52.23347", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "22/2/2013 7:21", "-0.25013888", "52.23347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", "YFT de 70 kg environ mélangé avec beaucoup de \"marsouins\" impossible de pêcher."); + assertResultRow(result, row++, "22/2/2013 7:32", "-0.23347223", "52.23347", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 7:51", "-0.2001389", "52.300137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "22/2/2013 7:59", "-0.18347223", "52.316803", "Thonier arrivant sur le système détecté", "Albacore de 70 kg environ mélangés avec \"marsouins\" impossible de pêcher!"); + assertResultRow(result, row++, "22/2/2013 8:0", "-0.18347223", "52.316803", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 8:19", "-0.1501389", "52.366802", "Route vers des systèmes observés", "Vu matte au loin, prenons direction du système observé mais en cours de route les matelots aux jumelles s'apperçoivent qu'il y a des \"marsouins\" avec les YFT, nous ^reprnons notre cap sans nous être rendu sur le système observé"); + assertResultRow(result, row++, "22/2/2013 8:23", "-0.1501389", "52.366802", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 8:35", "-0.10013889", "52.350136", "Route vers des systèmes observés", "YFT + \"marsouins\", reprise du cap sans nous rendre sur le système observé."); + assertResultRow(result, row++, "22/2/2013 8:38", "-0.10013889", "52.350136", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 9:38", "-0.16680557", "52.48347", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 9:50", "-0.18347223", "52.516804", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null); + assertResultRow(result, row++, "22/2/2013 9:53", "-0.18347223", "52.53347", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 10:13", "-0.16680557", "52.58347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "22/2/2013 10:22", "-0.16680557", "52.616802", "Thonier arrivant sur le système détecté", "YFT mélangés avec\"Marsouins\""); + assertResultRow(result, row++, "22/2/2013 10:36", "-0.18347223", "52.616802", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 11:21", "-0.1501389", "52.750137", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null); + assertResultRow(result, row++, "22/2/2013 11:25", "-0.1501389", "52.750137", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 12:25", "-0.1501389", "52.93347", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 13:25", "-0.21680556", "53.116802", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 15:4", "-0.26680556", "53.23347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", "Changement d'heur: +1h (heure de l'île maurice, de la réunion et des seychelles!)"); + assertResultRow(result, row++, "22/2/2013 15:10", "-0.26680556", "53.250137", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 15:13", "-0.26680556", "53.250137", "Route vers des systèmes observés", "YFT + \"Marsouins\" mais vu lors du transit en allant sur le système observé, reprise du cap!"); + assertResultRow(result, row++, "22/2/2013 15:45", "-0.3001389", "53.350136", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 16:45", "-0.3834722", "53.53347", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 16:57", "-0.3834722", "53.566803", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null); + assertResultRow(result, row++, "22/2/2013 17:0", "-0.40013888", "53.58347", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 17:41", "-0.5501389", "53.566803", "Recherche (général)", "Marsouins observé à 2 mioles mais nous n'allons pas sur le système observé"); + assertResultRow(result, row++, "22/2/2013 18:24", "-0.6834722", "53.500137", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null); + assertResultRow(result, row++, "22/2/2013 18:25", "-0.6834722", "53.500137", "Recherche (général)", null); + assertResultRow(result, row++, "22/2/2013 18:58", "-0.7501389", "53.40014", "Fin de veille", "Route de nuit."); + assertResultRow(result, row++, "23/2/2013 6:16", "-2.2668056", "51.18347", "Recherche (général)", null); + assertResultRow(result, row++, "23/2/2013 6:53", "-2.3334723", "51.066803", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "23/2/2013 7:4", "-2.350139", "51.03347", "Thonier arrivant sur le système détecté", "Listao + présence d'un cordage pose d'un radeau activité suivante."); + assertResultRow(result, row++, "23/2/2013 7:11", "-2.350139", "51.03347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null); + assertResultRow(result, row++, "23/2/2013 7:25", "-2.350139", "51.03347", "Recherche (général)", null); + assertResultRow(result, row++, "23/2/2013 7:35", "-2.3334723", "50.98347", "Route vers des systèmes observés", "volaille apperçu aux jumelles, nous prenons la direction pour en cours de route on observe que ce sont des listao, on reprend notre cap initial sans se rendre sur le système observé."); + assertResultRow(result, row++, "23/2/2013 7:43", "-2.3168056", "50.966805", "Recherche (général)", null); + assertResultRow(result, row++, "23/2/2013 8:41", "-2.2834723", "50.750137", "Route vers des systèmes observés", "vu au sonar!"); + assertResultRow(result, row++, "23/2/2013 8:50", "-2.2668056", "50.716805", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "23/2/2013 9:18", "-2.2834723", "50.750137", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "23/2/2013 12:10", "-2.2834723", "50.73347", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "23/2/2013 12:17", "-2.300139", "50.716805", "Recherche (général)", null); + assertResultRow(result, row++, "23/2/2013 12:36", "-2.2668056", "50.65014", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "23/2/2013 12:40", "-2.250139", "50.65014", "Thonier arrivant sur le système détecté", "Plusieurs bancs plus ou moins gros!"); + assertResultRow(result, row++, "23/2/2013 13:1", "-2.250139", "50.633472", "Route vers des systèmes observés", "Poissons allant trop vite re tour sur système observé précédément"); + assertResultRow(result, row++, "23/2/2013 13:8", "-2.250139", "50.616802", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "23/2/2013 13:28", "-2.2334723", "50.65014", "Thonier arrivant sur le système détecté", "Petit banc et dispérsé"); + assertResultRow(result, row++, "23/2/2013 13:30", "-2.2334723", "50.65014", "Recherche (général)", ""); + assertResultRow(result, row++, "23/2/2013 13:45", "-2.2334723", "50.68347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "23/2/2013 13:47", "-2.2334723", "50.68347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "23/2/2013 13:56", "-2.2334723", "50.68347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "23/2/2013 14:6", "-2.2334723", "50.633472", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "23/2/2013 14:9", "-2.250139", "50.633472", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "23/2/2013 16:5", "-2.2668056", "50.616802", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "23/2/2013 16:6", "-2.2668056", "50.616802", "Recherche (général)", ""); + assertResultRow(result, row++, "23/2/2013 16:34", "-2.2668056", "50.716805", "Route vers des systèmes observés", "En train de mesurer lorsque le système a été apperçu aux jumelles!"); + assertResultRow(result, row++, "23/2/2013 16:36", "-2.2668056", "50.716805", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "23/2/2013 16:44", "-2.2668056", "50.716805", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "23/2/2013 19:1", "-2.300139", "50.68347", "Fin de pêche (remontée du skiff)", "Changement d'heure - 1h"); + assertResultRow(result, row++, "23/2/2013 19:3", "-2.300139", "50.68347", "Fin de veille", null); + assertResultRow(result, row++, "24/2/2013 5:27", "-2.350139", "50.616802", "Recherche (général)", "shiftage du 23.02.2013 de 5h35 à 12h33 puis après calée!"); + assertResultRow(result, row++, "24/2/2013 6:27", "-2.4168057", "50.700138", "Recherche (général)", null); + assertResultRow(result, row++, "24/2/2013 7:27", "-2.5168056", "50.716805", "Recherche (général)", null); + assertResultRow(result, row++, "24/2/2013 8:26", "-2.3168056", "50.716805", "Route vers des systèmes observés", ""); + assertResultRow(result, row++, "24/2/2013 8:42", "-2.2668056", "50.73347", "Thonier arrivant sur le système détecté", "Mélangé avec \"Marsouins\" (je pense des dauphins longirostre)."); + assertResultRow(result, row++, "24/2/2013 8:48", "-2.2668056", "50.716805", "Route vers des systèmes observés", "Le poisson se déplace trop vite, nous n'allons pas sur le système observé"); + assertResultRow(result, row++, "24/2/2013 9:0", "-2.250139", "50.750137", "Recherche (général)", null); + assertResultRow(result, row++, "24/2/2013 9:45", "-2.250139", "50.716805", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "24/2/2013 9:59", "-2.2834723", "50.68347", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "24/2/2013 10:0", "-2.2834723", "50.68347", "Recherche (général)", null); + assertResultRow(result, row++, "24/2/2013 11:0", "-2.4834723", "50.68347", "Recherche (général)", null); + assertResultRow(result, row++, "24/2/2013 11:27", "-2.5834723", "50.716805", "Route vers des systèmes observés", "Dauphins longirostre. On fait se séparer les thons et les dauphins en suivant ces derniers.\n"); + assertResultRow(result, row++, "24/2/2013 11:30", "-2.5834723", "50.716805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "24/2/2013 11:57", "-2.600139", "50.716805", "Route vers des systèmes observés", "Arrivés sur le système à 12h03 (oublies de le noter sur le formulaire route!)"); + assertResultRow(result, row++, "24/2/2013 12:33", "-2.6334722", "50.766804", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "24/2/2013 15:5", "-2.6334722", "50.750137", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "24/2/2013 15:8", "-2.650139", "50.750137", "Recherche (général)", null); + assertResultRow(result, row++, "24/2/2013 15:19", "-2.6168058", "50.766804", "Route vers des systèmes observés", "2 mattes"); + assertResultRow(result, row++, "24/2/2013 15:32", "-2.5834723", "50.800137", "Thonier arrivant sur le système détecté", "Mélange SKJ + YFT."); + assertResultRow(result, row++, "24/2/2013 15:34", "-2.5834723", "50.800137", "Recherche (général)", null); + assertResultRow(result, row++, "24/2/2013 15:51", "-2.5334723", "50.83347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "24/2/2013 15:58", "-2.5168056", "50.816803", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "24/2/2013 16:2", "-2.5168056", "50.83347", "Recherche (général)", null); + assertResultRow(result, row++, "24/2/2013 16:58", "-2.3334723", "50.73347", "Route vers des systèmes observés", "\"Marsouins\" apperçu après avoir pris la direction du système observé, reprise du cap sans se rendre sur le système."); + assertResultRow(result, row++, "24/2/2013 17:0", "-2.3334723", "50.73347", "Recherche (général)", null); + assertResultRow(result, row++, "24/2/2013 18:0", "-2.4834723", "50.616802", "Recherche (général)", null); + assertResultRow(result, row++, "24/2/2013 18:12", "-2.5168056", "50.616802", "Fin de veille", "Stopper pour la nuit."); + assertResultRow(result, row++, "25/2/2013 5:26", "-2.7334723", "50.500137", "Recherche (général)", null); + assertResultRow(result, row++, "25/2/2013 5:52", "-2.7168057", "50.53347", "Route vers des systèmes observés", "Balbya de \"Marsouins\", reprise du cap sans s'être rendu sur le système observé."); + assertResultRow(result, row++, "25/2/2013 6:12", "-2.7668056", "50.58347", "Recherche (général)", "Shiftage du 23 et 24.02.2013 jusqu'à 14h20"); + assertResultRow(result, row++, "25/2/2013 6:24", "-2.8168056", "50.58347", "Route vers des systèmes observés", "Banc trop petit et inintéressant, recherche général sans se rendre sur le système observé."); + assertResultRow(result, row++, "25/2/2013 6:30", "-2.8168056", "50.600136", "Recherche (général)", null); + assertResultRow(result, row++, "25/2/2013 6:42", "-2.800139", "50.633472", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "25/2/2013 6:46", "-2.800139", "50.65014", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "25/2/2013 6:55", "-2.800139", "50.633472", "Début de pêche (larguage du skiff)", null); + assertResultRow(result, row++, "25/2/2013 9:35", "-2.8334723", "50.633472", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "25/2/2013 9:36", "-2.8334723", "50.633472", "Recherche (général)", null); + assertResultRow(result, row++, "25/2/2013 10:36", "-2.9668057", "50.700138", "Recherche (général)", null); + assertResultRow(result, row++, "25/2/2013 11:30", "-3.1668057", "50.65014", "Recherche (général)", null); + assertResultRow(result, row++, "25/2/2013 12:30", "-3.400139", "50.616802", "Recherche (général)", null); + assertResultRow(result, row++, "25/2/2013 12:35", "-3.4168057", "50.600136", "Route vers des systèmes observés", "\"Marsouins\" vu en coursz de route, reprise directement du cap, sans se rendre sur le système observé"); + assertResultRow(result, row++, "25/2/2013 12:43", "-3.4334724", "50.616802", "Recherche (général)", null); + assertResultRow(result, row++, "25/2/2013 13:43", "-3.5334723", "50.816803", "Recherche (général)", null); + assertResultRow(result, row++, "25/2/2013 14:31", "-3.5834723", "50.90014", "Route vers des systèmes observés", "Fin du shiftage du 23 et 24.02.2013 à 14h 20"); + assertResultRow(result, row++, "25/2/2013 14:40", "-3.5668056", "50.916805", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "25/2/2013 14:46", "-3.550139", "50.90014", "Recherche (général)", null); + assertResultRow(result, row++, "25/2/2013 15:50", "-3.6668057", "51.08347", "Recherche (général)", null); + assertResultRow(result, row++, "25/2/2013 16:17", "-3.5668056", "51.050137", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "25/2/2013 16:22", "-3.5668056", "51.050137", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "25/2/2013 16:23", "-3.550139", "51.050137", "Recherche (général)", null); + assertResultRow(result, row++, "25/2/2013 17:26", "-3.5334723", "51.266804", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null); + assertResultRow(result, row++, "25/2/2013 17:31", "-3.5334723", "51.28347", "Recherche (général)", null); + assertResultRow(result, row++, "25/2/2013 17:57", "-3.5668056", "51.33347", "Fin de veille", null); + assertResultRow(result, row++, "26/2/2013 5:50", "-4.3168054", "53.0", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "26/2/2013 6:3", "-4.300139", "52.98347", "Début de pêche (larguage du skiff)", "Sachant que nous débarquons le lendemain aux Seychelles, il n'y aura pas de shiftage, les poissons restent en saumure!"); + assertResultRow(result, row++, "26/2/2013 8:45", "-4.300139", "52.966805", "Fin de pêche (remontée du skiff)", null); + assertResultRow(result, row++, "26/2/2013 8:48", "-4.300139", "52.966805", "Recherche (général)", null); + assertResultRow(result, row++, "26/2/2013 9:42", "-4.383472", "53.15014", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "26/2/2013 9:53", "-4.3501387", "53.166805", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "26/2/2013 10:0", "-4.3501387", "53.18347", "Recherche (général)", null); + assertResultRow(result, row++, "26/2/2013 10:29", "-4.383472", "53.23347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "26/2/2013 10:35", "-4.433472", "53.23347", "Thonier arrivant sur le système détecté", "Trombe d'eau apparçu à 5 milles"); + assertResultRow(result, row++, "26/2/2013 10:37", "-4.4501386", "53.23347", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "26/2/2013 11:30", "-4.533472", "53.40014", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "26/2/2013 12:4", "-4.6001387", "53.366802", "Thonier arrivant sur le système détecté", ""); + assertResultRow(result, row++, "26/2/2013 12:7", "-4.6001387", "53.383472", "Recherche (général)", null); + assertResultRow(result, row++, "26/2/2013 13:7", "-4.6668053", "53.58347", "Recherche (général)", "Shiftage du 25.02.2013 de 13h à 16h35"); + assertResultRow(result, row++, "26/2/2013 14:7", "-4.783472", "53.766804", "Recherche (général)", null); + assertResultRow(result, row++, "26/2/2013 15:20", "-4.9668055", "53.966805", "Recherche (général)", null); + assertResultRow(result, row++, "26/2/2013 16:35", "-5.133472", "54.200138", "Recherche (général)", null); + assertResultRow(result, row++, "26/2/2013 17:35", "-5.2501388", "54.40014", "Recherche (général)", null); + assertResultRow(result, row++, "26/2/2013 18:22", "-5.3168054", "54.566803", "Fin de veille", "Stopper pour la nuit."); + assertResultRow(result, row++, "27/2/2013 6:36", "-5.400139", "54.90014", "Recherche (général)", null); + assertResultRow(result, row++, "27/2/2013 7:36", "-5.4168053", "55.133472", "Recherche (général)", null); + assertResultRow(result, row++, "27/2/2013 7:44", "-5.400139", "55.166805", "Route vers des systèmes observés", null); + assertResultRow(result, row++, "27/2/2013 7:49", "-5.400139", "55.18347", "Thonier arrivant sur le système détecté", null); + assertResultRow(result, row++, "27/2/2013 7:52", "-5.400139", "55.18347", "Recherche (général)", null); + assertResultRow(result, row++, "27/2/2013 8:40", "-5.283472", "55.133472", "Fin de veille", null); + assertResultRow(result, row++, "27/2/2013 8:42", "-5.283472", "55.133472", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "27/2/2013 9:42", "-5.150139", "55.18347", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "27/2/2013 10:42", "-5.150139", "55.316803", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "27/2/2013 11:25", "-4.9501386", "55.43347", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "27/2/2013 12:25", "-4.8501387", "55.566803", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "27/2/2013 13:25", "-4.7001386", "55.600136", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "27/2/2013 14:25", "-4.5834723", "55.58347", "Transit (route sans recherche)", null); + assertResultRow(result, row++, "27/2/2013 15:36", "-4.5834723", "55.48347", "Autres (à préciser dans les notes)", "En attente pour rentrer au port avec le pilote"); + assertResultRow(result, row++, "27/2/2013 16:22", "-4.6168056", "55.450138", "Au port", "Fin de la première partie de calée.Loch totale marée: 5953.03"); + + } +} \ No newline at end of file diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDailySetAndCatchTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDailySetAndCatchTest.java new file mode 100644 index 0000000..0b07b83 --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDailySetAndCatchTest.java @@ -0,0 +1,103 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report; + + +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import org.junit.Assert; + +/** + * Pour tester le report {@code dailySetAndCapture}. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.9 + */ +public class ReportDailySetAndCatchTest extends AbstractReportServiceTopiaTest { + + @Override + protected String getReportId() { + return "dailySetAndCatch"; + } + + @Override + protected void testReportSyntax(Report report) { + Assert.assertNotNull(report); + assertReportName( + report, + "Nombre de calées et captures journalières d'une marée", + "Afficher le nombre de calées et les captures journalières d’une calée" + ); + + assertReportDimension( + report, + -1, + 3, + new String[]{"Jour observation", + "Nombre de calées", + "Captures thon" + }, + null + ); + + assertReportNbRequests(report, 1); + + ReportRequest[] requests = report.getRequests(); + ReportRequest request = requests[0]; + + assertReportRequestDimension( + request, + ReportRequest.RequestLayout.row, + 0, + 0 + ); + } + + @Override + protected void testReportResult(DataMatrix result) { + assertResultDimension(result, 3, 20, 0, 0); + + int row = 0; + assertResultRow(result, row++, "30/1/2013", "1", "20.0"); + assertResultRow(result, row++, "1/2/2013", "2", null); + assertResultRow(result, row++, "2/2/2013", "1", null); + assertResultRow(result, row++, "3/2/2013", "2", null); + assertResultRow(result, row++, "4/2/2013", "1", null); + assertResultRow(result, row++, "5/2/2013", "1", "7.8"); + assertResultRow(result, row++, "6/2/2013", "2", "36.0"); + assertResultRow(result, row++, "7/2/2013", "2", "27.0"); + assertResultRow(result, row++, "8/2/2013", "3", "14.0"); + assertResultRow(result, row++, "9/2/2013", "3", "46.0"); + assertResultRow(result, row++, "10/2/2013", "1", "7.0"); + assertResultRow(result, row++, "11/2/2013", "3", "30.41"); + assertResultRow(result, row++, "15/2/2013", "1", "0.07"); + assertResultRow(result, row++, "16/2/2013", "1", "11.005"); + assertResultRow(result, row++, "17/2/2013", "2", "40.7"); + assertResultRow(result, row++, "19/2/2013", "3", "134.701"); + assertResultRow(result, row++, "23/2/2013", "3", "197.44"); + assertResultRow(result, row++, "24/2/2013", "1", "12.0"); + assertResultRow(result, row++, "25/2/2013", "1", "48.075"); + assertResultRow(result, row++, "26/2/2013", "1", "13.7"); + + } +} diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDcpUsageTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDcpUsageTest.java new file mode 100644 index 0000000..530d467 --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDcpUsageTest.java @@ -0,0 +1,142 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report; + +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import org.junit.Assert; + +/** + * Pour tester le report {@code dcpUsage}. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.9 + */ +public class ReportDcpUsageTest extends AbstractReportServiceTopiaTest { + + @Override + protected String getReportId() { + return "dcpUsage"; + } + + @Override + protected void testReportSyntax(Report report) { + Assert.assertNotNull(report); + assertReportName( + report, + "Utilisation des DCP", + "Tableau récapitulatif du nombre de DCP visités selon l’action effectuée (visites avec et sans pêche, mis à l’eau, récuperation), et tortues observées" + ); + + assertReportDimension( + report, + -1, + 7, + new String[]{"Type de DCP (Tableau 8)", + "Nombre visités", + "Nombre pêchés", + "Nombre mis à l’eau seuls", + "Nombre renforcés par radeau balisé", + "Récupéré sans pêche", + "Nombre de tortues associées" + }, + null + ); + + assertReportNbRequests(report, 7); + + ReportRequest[] requests = report.getRequests(); + ReportRequest request; + + request = requests[0]; + assertReportRequestDimension( + request, + ReportRequest.RequestLayout.row, + 0, + 0 + ); + + request = requests[1]; + assertReportRequestDimension( + request, + ReportRequest.RequestLayout.row, + 1, + 0 + ); + + request = requests[2]; + assertReportRequestDimension( + request, + ReportRequest.RequestLayout.row, + 2, + 0 + ); + request = requests[3]; + assertReportRequestDimension( + request, + ReportRequest.RequestLayout.row, + 3, + 0 + ); + + request = requests[4]; + assertReportRequestDimension( + request, + ReportRequest.RequestLayout.row, + 4, + 0 + ); + request = requests[5]; + assertReportRequestDimension( + request, + ReportRequest.RequestLayout.row, + 5, + 0 + ); + request = requests[6]; + assertReportRequestDimension( + request, + ReportRequest.RequestLayout.row, + 6, + 0 + ); + } + + @Override + protected void testReportResult(DataMatrix result) { + + // 4 DCP dans une maree + assertResultDimension(result, 7, 8, 0, 0); + + int row = 0; + assertResultRow(result, row++, "10 - Caisse ou grosse planche", "1", "0", "0", "0", "0", null); + assertResultRow(result, row++, "11 - Cordage, câble", "2", "0", "0", "0", "0", null); + assertResultRow(result, row++, "13 - Objet de plastique (à préciser dans les notes)", "2", "0", "0", "0", "0", null); + assertResultRow(result, row++, "14 - Un des antérieurs (du 10 à 13) balisé", "1", "0", "0", "0", "0", null); + assertResultRow(result, row++, "16 - Radeau ou bouée en dérive", "2", "0", "0", "0", "0", null); + assertResultRow(result, row++, "3 - Arbre (ou branche)", "3", "0", "0", "0", "0", null); + assertResultRow(result, row++, "6 - Radeau balisé en dérive (bambou et filet)", "19", "6", "13", "0", "0", null); + assertResultRow(result, row++, "99 - Autre (à préciser dans les notes)", "2", "0", "0", "0", "0", null); + + } +} diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociation2Test.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociation2Test.java new file mode 100644 index 0000000..18c1b48 --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociation2Test.java @@ -0,0 +1,50 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report; + + +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import org.junit.Ignore; + +/** + * Pour tester le report {@code dailySetAndCapture}. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.9 + */ +@Ignore +public class ReportSetByAssociation2Test extends ReportSetByAssociationTest { + + @Override + protected void testReportResult(DataMatrix result) { + assertResultDimension(result, 5, 3, 0, 0); + + // les 8 sets qu test 1 + // 10 calées representant chaque cas (set +, -) sur les 4 types + // d'association (le cas du BL sans 11 est traité 2 fois : une fois + // sans SO et une fois avec un BL spécifié) + assertResultRow(result, 0, "3", "2", "2", "2", "9"); + assertResultRow(result, 1, "3", "2", "2", "2", "9"); + assertResultRow(result, 2, "6", "4", "4", "4", "18"); + + } +} diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociationTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociationTest.java new file mode 100644 index 0000000..d29f976 --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociationTest.java @@ -0,0 +1,128 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report; + +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import org.junit.Assert; + +/** + * Pour tester le report {@code setByAssociation}. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.9 + */ +public class ReportSetByAssociationTest extends AbstractReportServiceTopiaTest { + + @Override + protected String getReportId() { + return "setByAssociation"; + } + + @Override + protected void testReportSyntax(Report report) { + Assert.assertNotNull(report); + assertReportName( + report, + "Nombre de calées selon le type d’association", + "Afficher la répartitions des calées selon le type d’association l’issue du coup. Les coups sur BL baleine et BO requin-baleine sont spécifiés." + ); + + assertReportDimension( + report, + 3, + 5, + new String[]{"BL sans baleine", + "BL avec baleine", + "BO avec requin-baleine", + "BO sans requin-baleine", + "Total" + }, + new String[]{"Coups positifs", "Coups nuls", "Total"} + ); + + assertReportNbRequests(report, 8); + + ReportRequest[] requests = report.getRequests(); + + assertReportRequestDimension( + requests[0], + ReportRequest.RequestLayout.column, + 0, + 0 + ); + assertReportRequestDimension( + requests[1], + ReportRequest.RequestLayout.column, + 0, + 1 + ); + assertReportRequestDimension( + requests[2], + ReportRequest.RequestLayout.column, + 1, + 0 + ); + assertReportRequestDimension( + requests[3], + ReportRequest.RequestLayout.column, + 1, + 1 + ); + assertReportRequestDimension( + requests[4], + ReportRequest.RequestLayout.column, + 2, + 0 + ); + assertReportRequestDimension( + requests[5], + ReportRequest.RequestLayout.column, + 2, + 1 + ); + assertReportRequestDimension( + requests[6], + ReportRequest.RequestLayout.column, + 3, + 0 + ); + assertReportRequestDimension( + requests[7], + ReportRequest.RequestLayout.column, + 3, + 1 + ); + } + + @Override + protected void testReportResult(DataMatrix result) { + assertResultDimension(result, 5, 3, 0, 0); + + int row = 0; + assertResultRow(result, row++, "19" ,"1" ,"0" ,"6" ,"26"); + assertResultRow(result, row++, "9", "0", "0", "0", "9"); + assertResultRow(result, row++, "28" ,"1" ,"0" ,"6" ,"35"); + + } +} diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetCatchByAssociationTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetCatchByAssociationTest.java new file mode 100644 index 0000000..e75dd69 --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetCatchByAssociationTest.java @@ -0,0 +1,116 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report; + +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import org.junit.Assert; + +/** + * Test le report {@code targetCatchByAssociation}. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.9 + */ +public class ReportTargetCatchByAssociationTest extends AbstractReportServiceTopiaTest { + + @Override + protected String getReportId() { + return "targetCatchByAssociation"; + } + + @Override + protected void testReportSyntax(Report report) { + Assert.assertNotNull(report); + assertReportName( + report, + "Capture de thon selon le type d'association (en t)", + "Afficher la répartitions des captures de thons selon le type d'association" + ); + + assertReportDimension( + report, + 5, + 7, + new String[]{"YFT", + "SKJ", + "BET", + "LTA", + "FRI", + "Autres", + "Total" + }, + new String[]{"BL sans baleine", + "BL avec baleine", + "BO avec requin-baleine", + "BO sans requin-baleine", + "Total" + } + ); + + assertReportNbRequests(report, 4); + + ReportRequest[] requests = report.getRequests(); + + assertReportRequestDimension( + requests[0], + ReportRequest.RequestLayout.row, + 0, + 0 + ); + + assertReportRequestDimension( + requests[1], + ReportRequest.RequestLayout.row, + 0, + 1 + ); + + assertReportRequestDimension( + requests[2], + ReportRequest.RequestLayout.row, + 0, + 2 + ); + + assertReportRequestDimension( + requests[3], + ReportRequest.RequestLayout.row, + 0, + 3 + ); + } + + @Override + protected void testReportResult(DataMatrix result) { + assertResultDimension(result, 7, 5, 0, 0); + + int row = 0; + assertResultRow(result, row++, "455.2", "0.0", "40.0", "0.0", "0.0", "2.2", "497.4"); + assertResultRow(result, row++, "26.0", "0.0", "0.0", "0.0", "0.0", "0.0", "26.0"); + assertResultRow(result, row++, null, null, null, null, null, null, "0.0"); + assertResultRow(result, row++, "32.0", "71.0", "10.0", "0.0", "0.0", "0.0", "113.0"); + assertResultRow(result, row++, "513.2", "71.0", "50.0", "0.0", "0.0", "2.2", "636.4"); + + } +} diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetDiscardedByAssociationTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetDiscardedByAssociationTest.java new file mode 100644 index 0000000..7d1ca56 --- /dev/null +++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetDiscardedByAssociationTest.java @@ -0,0 +1,116 @@ +/* + * #%L + * ObServe :: Business + * %% + * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/gpl-3.0.html>. + * #L% + */ +package fr.ird.observe.services.service.actions.report; + +import fr.ird.observe.services.service.actions.report.model.DataMatrix; +import fr.ird.observe.services.service.actions.report.model.Report; +import fr.ird.observe.services.service.actions.report.model.ReportRequest; +import org.junit.Assert; + +/** + * Test le report {@code targetDiscardedByAssociation}. + * + * @author Tony Chemit - chemit@codelutin.com + * @since 1.9 + */ +public class ReportTargetDiscardedByAssociationTest extends AbstractReportServiceTopiaTest { + + @Override + protected String getReportId() { + return "targetDiscardedByAssociation"; + } + + @Override + protected void testReportSyntax(Report report) { + Assert.assertNotNull(report); + assertReportName( + report, + "Rejets de thons selon le type d’association (en t)", + "Afficher la répartitions des rejets de thons selon le type d'association" + ); + + assertReportDimension( + report, + 5, + 7, + new String[]{"YFT", + "SKJ", + "BET", + "LTA", + "FRI", + "Autres", + "Total" + }, + new String[]{"BL sans baleine", + "BL avec baleine", + "BO avec requin-baleine", + "BO sans requin-baleine", + "Total" + } + ); + + assertReportNbRequests(report, 4); + + ReportRequest[] requests = report.getRequests(); + + assertReportRequestDimension( + requests[0], + ReportRequest.RequestLayout.row, + 0, + 0 + ); + + assertReportRequestDimension( + requests[1], + ReportRequest.RequestLayout.row, + 0, + 1 + ); + + assertReportRequestDimension( + requests[2], + ReportRequest.RequestLayout.row, + 0, + 2 + ); + + assertReportRequestDimension( + requests[3], + ReportRequest.RequestLayout.row, + 0, + 3 + ); + } + + @Override + protected void testReportResult(DataMatrix result) { + assertResultDimension(result, 7, 5, 0, 0); + + int row = 0; + assertResultRow(result, row++, "0.841", "0.0", "0.29", "0.0", "0.08", "0.01", "1.221"); + assertResultRow(result, row++, null, null, null, null, null, null, "0.0"); + assertResultRow(result, row++, null, null, null, null, null, null, "0.0"); + assertResultRow(result, row++, "2.775", "5.405", "0.0", "0.0", "0.0", "0.1", "8.28"); + assertResultRow(result, row++, "3.6159999999999997", "5.405", "0.29", "0.0", "0.08", "0.11", "9.501"); + + } +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.
This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository observe. See http://git.codelutin.com/observe.git commit 9f49fbf654ccbba2f3f57256cee2332414b1be24 Author: Sylvain Bavencoff <bavencoff@codelutin.com> Date: Thu Sep 3 10:12:20 2015 +0200 implantation du service de generation des rapport + test (refs #7498) --- .../src/main/filters/observe-reports.properties | 854 +++++++++++++++++++++ 1 file changed, 854 insertions(+) diff --git a/observe-services-api/src/main/filters/observe-reports.properties b/observe-services-api/src/main/filters/observe-reports.properties new file mode 100644 index 0000000..732b367 --- /dev/null +++ b/observe-services-api/src/main/filters/observe-reports.properties @@ -0,0 +1,854 @@ +### +# #%L +# ObServe :: Business +# %% +# Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit +# %% +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public +# License along with this program. If not, see +# <http://www.gnu.org/licenses/gpl-3.0.html>. +# #L% +### + +################################################################################ +## Liste des activit\u00e9s avec des comments +################################################################################ + +report.activityWithComment.name=Activit\u00e9s avec comment et leurs positions +report.activityWithComment.description=Afficher les activit\u00e9s avec comment et leurs positions g\u00e9ographiques +report.activityWithComment.columns=Jour - Heure observation, Latitude, Longitude, Activit\u00e9, Commentaire +report.activityWithComment.request.1=0,0|row|\ + Select concat(day(r.date), '/', month(r.date), '/', year(r.date), ' ', hour(a.time), ':', minute(a.time)), a.latitude, a.longitude, ab.label2, a.comment \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.vesselActivitySeine ab \ + Where \ + m.id = :tripId \ + and a.comment is not null \ + Order By r.date, a.time + +################################################################################ +## Liste de toutes les activit\u00e9s et leurs positions +################################################################################ + +report.allActivitys.name=Toutes les activit\u00e9s et leurs positions +report.allActivitys.description=Afficher toutes les activit\u00e9s et leurs positions g\u00e9ographiques +report.allActivitys.columns=Jour - Heure observation, Latitude, Longitude, Activit\u00e9, Commentaire +report.allActivitys.request.1=0,0|row|\ + Select concat(day(r.date), '/', month(r.date), '/', year(r.date), ' ', hour(a.time), ':', minute(a.time)), a.latitude, a.longitude, ab.label2, a.comment \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.vesselActivitySeine ab \ + Where \ + m.id = :tripId \ + Order By r.date, a.time + +################################################################################ +## Nombre de cal\u00e9es et captures journali\u00e8res d'une mar\u00e9e +################################################################################ + +report.dailySetAndCatch.name=Nombre de cal\u00e9es et captures journali\u00e8res d'une mar\u00e9e +report.dailySetAndCatch.description=Afficher le nombre de cal\u00e9es et les captures journali\u00e8res d\u2019une cal\u00e9e +report.dailySetAndCatch.columns=Jour observation,Nombre de cal\u00e9es ,Captures thon +report.dailySetAndCatch.request.1=0,0|row|\ + Select concat(day(r.date), '/', month(r.date), '/', year(r.date)), Count(distinct a), Sum(ct.catchWeight) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.setSeine s \ + left join s.targetCatch as ct \ + Where \ + m.id = :tripId \ + Group By r.date \ + Order By r.date + +################################################################################ +## Utilisation des DCP +################################################################################ + +report.dcpUsage.name=Utilisation des DCP +report.dcpUsage.description=Tableau r\u00e9capitulatif du nombre de DCP visit\u00e9s selon l\u2019action effectu\u00e9e (visites avec et sans p\u00eache, mis \u00e0 l\u2019eau, r\u00e9cuperation), et tortues observ\u00e9es +report.dcpUsage.columns=Type de DCP (Tableau 8),Nombre visit\u00e9s,Nombre p\u00each\u00e9s,Nombre mis \u00e0 l\u2019eau seuls,Nombre renforc\u00e9s par radeau balis\u00e9,R\u00e9cup\u00e9r\u00e9 sans p\u00eache,Nombre de tortues associ\u00e9es +report.dcpUsage.repeatVariable.typeObjetId=java.lang.String|\ + Select to.id \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.floatingObject dcp \ + Join dcp.objectType to \ + Where \ + m.id = :tripId \ + Order by to.code + +report.dcpUsage.request.1=0,0|row|\ + Select concat(str(to.code) , ' - ', to.label2) \ + From ObjectTypeImpl to \ + Where \ + to.id = :typeObjetId +report.dcpUsage.request.1.repeat=typeObjetId|column + +report.dcpUsage.request.2=1,0|row|\ + Select Count(dcp) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.floatingObject dcp \ + Where \ + m.id = :tripId \ + and dcp.objectType.id = :typeObjetId \ + and dcp.objectOperation.id = 'fr.ird.observe.entities.referentiel.seine.ObjectOperation#1239832686249#0.8268884472438458' +report.dcpUsage.request.2.repeat=typeObjetId|column + +report.dcpUsage.request.3=2,0|row|\ + Select Count(dcp) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.floatingObject dcp \ + Where \ + m.id = :tripId \ + and dcp.objectType.id = :typeObjetId \ + and dcp.objectOperation.id = 'fr.ird.observe.entities.referentiel.seine.ObjectOperation#1239832686249#0.8431519556575698' +report.dcpUsage.request.3.repeat=typeObjetId|column + +report.dcpUsage.request.4=3,0|row|\ + Select Count(dcp) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.floatingObject dcp \ + Where \ + m.id = :tripId \ + and dcp.objectType.id = :typeObjetId \ + and dcp.objectOperation.id = 'fr.ird.observe.entities.referentiel.seine.ObjectOperation#1239832686248#0.8669327599318251' +report.dcpUsage.request.4.repeat=typeObjetId|column + +report.dcpUsage.request.5=4,0|row|\ + Select Count(dcp) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.floatingObject dcp \ + Where \ + m.id = :tripId \ + and dcp.objectType.id = :typeObjetId \ + and dcp.objectFate.id = 'fr.ird.observe.entities.referentiel.seine.ObjectFate#1396860761530#0.8869464242156488' \ + and dcp.objectOperation.id != 'fr.ird.observe.entities.referentiel.seine.ObjectOperation#1239832686248#0.8669327599318251' +report.dcpUsage.request.5.repeat=typeObjetId|column + +report.dcpUsage.request.6=5,0|row|\ + Select Count(dcp) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.floatingObject dcp \ + Where \ + m.id = :tripId \ + and dcp.objectType.id = :typeObjetId \ + and dcp.objectOperation.code = 'fr.ird.observe.entities.referentiel.seine.ObjectOperation#1239832686249#0.7838704130950722' +report.dcpUsage.request.6.repeat=typeObjetId|column + +report.dcpUsage.request.7=6,0|row| \ + Select Sum(efo.count) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.floatingObject dcp \ + Join dcp.objectObservedSpecies efo \ + Where \ + m.id = :tripId \ + and dcp.objectType.id = :typeObjetId \ + and efo.species.speciesGroup.id = 'fr.ird.observe.entities.referentiel.SpeciesGroup#1239832683690#0.24333033683679461' +report.dcpUsage.request.7.repeat=typeObjetId|column + +################################################################################ +## Nombre des cal\u00e9es selon le type d'association +################################################################################ + +report.setByAssociation.name=Nombre de cal\u00e9es selon le type d\u2019association +report.setByAssociation.description=Afficher la r\u00e9partitions des cal\u00e9es selon le type d\u2019association l\u2019issue du coup. Les coups sur BL baleine et BO requin-baleine sont sp\u00e9cifi\u00e9s. +report.setByAssociation.columns=BL sans baleine, BL avec baleine, BO avec requin-baleine, BO sans requin-baleine, Total +report.setByAssociation.rows=Coups positifs, Coups nuls, Total +report.setByAssociation.operations.1=SumIntRow +report.setByAssociation.operations.2=SumIntColumn +report.setByAssociation.request.1=0,0|column|\ + Select Count(a) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and a.setSeine.schoolType = 2 \ + and a.setSeine.reasonForNullSet is null \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9395222812356602' \ + and os not in elements(a.observedSystem) + +report.setByAssociation.request.2=0,1|column|\ + Select Count(a) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and a.setSeine.schoolType = 2 \ + and a.setSeine.reasonForNullSet is not null \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9395222812356602' \ + and os not in elements(a.observedSystem) + +report.setByAssociation.request.3=1,0|column|\ + Select Count(a) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and a.setSeine.schoolType = 2 \ + and a.setSeine.reasonForNullSet is null \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9395222812356602' \ + and os in elements(a.observedSystem) + +report.setByAssociation.request.4=1,1|column|\ + Select Count(a) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and a.setSeine.schoolType = 2 \ + and a.setSeine.reasonForNullSet is not null \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9395222812356602' \ + and os in elements(a.observedSystem) + +report.setByAssociation.request.5=2,0|column|\ + Select Count(a) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and a.setSeine.schoolType = 1 \ + and a.setSeine.reasonForNullSet is null \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9217864901728908' \ + and os in elements(a.observedSystem) + +report.setByAssociation.request.6=2,1|column|\ + Select Count(a) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and a.setSeine.schoolType = 1 \ + and a.setSeine.reasonForNullSet is not null \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9217864901728908' \ + and os in elements(a.observedSystem) + +report.setByAssociation.request.7=3,0|column|\ + Select Count(a) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and a.setSeine.schoolType = 1 \ + and a.setSeine.reasonForNullSet is null \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9217864901728908' \ + and os not in elements(a.observedSystem) + +report.setByAssociation.request.8=3,1|column|\ + Select Count(a) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and a.setSeine.schoolType = 1 \ + and a.setSeine.reasonForNullSet is not null \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9217864901728908' \ + and os not in elements(a.observedSystem) + +################################################################################ +## Captures thon par type d'association +################################################################################ + +report.targetCatchByAssociation.name=Capture de thon selon le type d'association (en t) +report.targetCatchByAssociation.description=Afficher la r\u00e9partitions des captures de thons selon le type d'association +report.targetCatchByAssociation.columns=YFT, SKJ, BET, LTA, FRI, Autres, Total +report.targetCatchByAssociation.rows=BL sans baleine, BL avec baleine, BO avec requin-baleine, BO sans requin-baleine, Total +report.targetCatchByAssociation.operations.1=SumRow +report.targetCatchByAssociation.operations.2=SumColumn + +# ligne 1 +report.targetCatchByAssociation.request.1=0,0|row|\ + Select \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then 0.0 \ + Else ct.catchWeight End) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.setSeine c \ + with c.schoolType = 2 \ + Join c.targetCatch ct \ + with ct.discarded = false, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9395222812356602' \ + and os not in elements(a.observedSystem) + +# ligne 2 +report.targetCatchByAssociation.request.7=0,1|row|\ + Select \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then 0.0 \ + Else ct.catchWeight End) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.setSeine c \ + with c.schoolType = 2 \ + Join c.targetCatch ct \ + with ct.discarded = false, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9395222812356602' \ + and os in elements(a.observedSystem) + +# ligne 3 +report.targetCatchByAssociation.request.13=0,2|row|\ + Select \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then 0.0 \ + Else ct.catchWeight End) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.setSeine c \ + with c.schoolType = 1 \ + Join c.targetCatch ct \ + with ct.discarded = false, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9217864901728908' \ + and os in elements(a.observedSystem) + +# ligne 4 +report.targetCatchByAssociation.request.19=0,3|row|\ + Select \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then 0.0 \ + Else ct.catchWeight End) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.setSeine c \ + with c.schoolType = 1 \ + Join c.targetCatch ct \ + with ct.discarded = false, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9217864901728908' \ + and os not in elements(a.observedSystem) + +################################################################################ +## Rejets thons selon le type d'association +################################################################################ + +report.targetDiscardedByAssociation.name=Rejets de thons selon le type d\u2019association (en t) +report.targetDiscardedByAssociation.description=Afficher la r\u00e9partitions des rejets de thons selon le type d'association +report.targetDiscardedByAssociation.columns=YFT, SKJ, BET, LTA, FRI, Autres, Total +report.targetDiscardedByAssociation.rows=BL sans baleine, BL avec baleine, BO avec requin-baleine, BO sans requin-baleine, Total +report.targetDiscardedByAssociation.operations.1=SumRow +report.targetDiscardedByAssociation.operations.2=SumColumn + +# ligne 1 +report.targetDiscardedByAssociation.request.1=0,0|row|\ + Select \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then 0.0 \ + Else ct.catchWeight End) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.setSeine c \ + with c.schoolType = 2 \ + Join c.targetCatch ct \ + with ct.discarded = true, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9395222812356602' \ + and os not in elements(a.observedSystem) + +# ligne 2 +report.targetDiscardedByAssociation.request.7=0,1|row|\ + Select \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then 0.0 \ + Else ct.catchWeight End) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.setSeine c \ + with c.schoolType = 2 \ + Join c.targetCatch ct \ + with ct.discarded = true, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9395222812356602' \ + and os in elements(a.observedSystem) + +# ligne 3 +report.targetDiscardedByAssociation.request.13=0,2|row|\ + Select \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then 0.0 \ + Else ct.catchWeight End) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.setSeine c \ + with c.schoolType = 1 \ + Join c.targetCatch ct \ + with ct.discarded = true, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9217864901728908' \ + and os in elements(a.observedSystem) + +# ligne 4 +report.targetDiscardedByAssociation.request.19=0,3|row|\ + Select \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then ct.catchWeight \ + Else 0.0 End), \ + Sum(CASE ct.weightCategory.species.topiaId When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.8943253454598569' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685474#0.975344121171992' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685475#0.13349466123905152' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.8024257002747615' Then 0.0 \ + When 'fr.ird.observe.entities.referentiel.Species#1239832685477#0.3846921632590058' Then 0.0 \ + Else ct.catchWeight End) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.setSeine c \ + with c.schoolType = 1 \ + Join c.targetCatch ct \ + with ct.discarded = true, \ + ObservedSystemImpl os \ + Where \ + m.id = :tripId \ + and os.topiaId = 'fr.ird.observe.entities.referentiel.seine.ObservedSystem#1239832686428#0.9217864901728908' \ + and os not in elements(a.observedSystem) + +################################################################################ +## Captures accessoires observ\u00e9es +################################################################################ + + +report.accessoryCatch.name=Liste des captures accessoires selon le type de banc, filtr\u00e9es par groupe +report.accessoryCatch.description=Afficher les captures accessoires par groupe d'esp\u00e8ce\nLes poids sont exprim\u00e9s en tonnes. +report.accessoryCatch.columns=Esp\u00e8ce, Banc libre, Banc objet +report.accessoryCatch.variable.speciesGroup=fr.ird.observe.services.dto.referential.SpeciesGroupDto|From SpeciesGroupImpl ge Order By ge.code +report.accessoryCatch.repeatVariable.speciesId=java.lang.String|\ + Select e.id From SpeciesImpl e \ + Where e.speciesGroup.id = :speciesGroup \ + Order By e.homeId + +report.accessoryCatch.request.1=0,0|row|\ + Select \ + concat('[FAO]', (case when e.faoCode is not null then e.faoCode else '-' end), \ + ' [sc]', (case when e.scientificLabel is not null then e.scientificLabel else '-' end), \ + ' [fr]', (case when e.label2 is not null then e.label2 else '-' end)) \ + From SpeciesImpl e \ + Where e.id = :speciesId +report.accessoryCatch.request.1.repeat=speciesId|column + +report.accessoryCatch.request.2=1,0|row|\ + Select \ + case when Count(ca) > 0 then \ + concat('+', \ + case when Sum(ca.totalCount) is not null then concat(' Effectif : ', str(Sum(ca.totalCount))) else '' end , \ + case when Sum(ca.catchWeight) is not null then concat(' Poids total (t) : ' , str(Sum(ca.catchWeight))) else '' end ) \ + else '-' end \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.setSeine c \ + with c.schoolType = 2 \ + Join c.nonTargetCatch ca \ + with ca.species.id = :speciesId \ + Where m.id = :tripId +report.accessoryCatch.request.2.repeat=speciesId|column + +report.accessoryCatch.request.3=2,0|row|\ + Select \ + case when Count(ca) > 0 then \ + concat('+', \ + case when Sum(ca.totalCount) is not null then concat(' Effectif : ', str(Sum(ca.totalCount))) else '' end , \ + case when Sum(ca.catchWeight) is not null then concat(' Poids total (t) : ' , str(Sum(ca.catchWeight))) else '' end ) \ + else '-' end \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.setSeine c \ + with c.schoolType = 1 \ + Join c.nonTargetCatch ca \ + with ca.species.id = :speciesId \ + Where m.id = :tripId +report.accessoryCatch.request.3.repeat=speciesId|column + +################################################################################ +## Captures accessoires par speciesGroup d'esp\u00e8ces +################################################################################ + +report.accessoryCatchByGroup.name=D\u00e9nombrement des captures accessoires et devenir, filtr\u00e9s par groupe +report.accessoryCatchByGroup.description=Afficher les nombres de captures accessoires par groupe d'esp\u00e8ce selon le type de banc et le devenir +report.accessoryCatchByGroup.columns=Esp\u00e8ce, Total BL, Total BO, Sorti vivant/\u00e9chapp\u00e9, Sorti mort, Rejet\u00e9 vivant, Rejet\u00e9 mort, Partiellement conserv\u00e9, Cuve, Cuisine, Autre +report.accessoryCatchByGroup.variable.speciesGroup=fr.ird.observe.services.dto.referential.SpeciesGroupDto|From SpeciesGroupImpl ge Order By ge.code + +report.accessoryCatchByGroup.request.1=0,0|row|\ + Select \ + concat(\ + '[FAO]', (case when e.faoCode is not null then e.faoCode else '-' end), \ + ' [sc]', (case when e.scientificLabel is not null then e.scientificLabel else '-' end), \ + ' [fr]', (case when e.label2 is not null then e.label2 else '-' end)), \ + Sum(case c.schoolType when 2 then ca.totalCount else 0.0 end), \ + Sum(case c.schoolType when 1 then ca.totalCount else 0.0 end), \ + Sum(case ca.speciesFate.id when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683619#0.9931091059863436' then ca.totalCount \ + when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683618#0.06155887805368032' then ca.totalCount \ + else 0.0 end), \ + Sum(case ca.speciesFate.id when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683619#0.11883784875534997' then ca.totalCount \ + else 0.0 end), \ + Sum(case ca.speciesFate.id when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683619#0.5308862132841506' then ca.totalCount \ + else 0.0 end), \ + Sum(case ca.speciesFate.id when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683619#0.6250731662108877' then ca.totalCount \ + else 0.0 end), \ + Sum(case ca.speciesFate.id when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683620#0.46609703818634485' then ca.totalCount \ + else 0.0 end), \ + Sum(case ca.speciesFate.id when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683619#0.5722739932065866' then ca.totalCount \ + else 0.0 end), \ + Sum(case ca.speciesFate.id when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683621#0.6728026426066158' then ca.totalCount \ + else 0.0 end), \ + Sum(case ca.speciesFate.id when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683619#0.9931091059863436' then 0.0 \ + when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683618#0.06155887805368032' then 0.0 \ + when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683619#0.11883784875534997' then 0.0 \ + when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683619#0.5308862132841506' then 0.0 \ + when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683619#0.6250731662108877' then 0.0 \ + when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683620#0.46609703818634485' then 0.0 \ + when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683619#0.5722739932065866' then 0.0 \ + when 'fr.ird.observe.entities.referentiel.seine.SpeciesFate#1239832683621#0.6728026426066158' then 0.0 \ + else ca.totalCount end) \ + From TripSeineImpl m \ + Join m.route r \ + Join r.activitySeine a \ + Join a.setSeine c \ + Join c.nonTargetCatch ca \ + Join ca.species e \ + with e.speciesGroup.id = :speciesGroup \ + Where m.id = :tripId \ + Group by e \ + Order By e.homeId + +########################################################### +## Distribution des tailles par espèces non ciblées +########################################################### + +report.nonTargetDistributionLengths.name=Distribution des tailles par esp\u00e8ces non cibl\u00e9es +report.nonTargetDistributionLengths.description=Afficher la nombre d'individus mesur\u00e9s par classe de taille pour les esp\u00e8ces non cibl\u00e9es +report.nonTargetDistributionLengths.columns=Classe de taille,Effectif +report.nonTargetDistributionLengths.operations.1=GroupByLength +report.nonTargetDistributionLengths.variable.speciesId=fr.ird.observe.entities.referentiel.Species|\ +Select distinct ntl.species \ +From TripSeineImpl t \ +Join t.route r \ +Join r.activitySeine a \ +Join a.setSeine.nonTargetSample nts \ +Join nts.nonTargetLength ntl \ +Where t.id = :tripId +report.nonTargetDistributionLengths.request.1=0,0|row| \ +Select ntl.length, sum(ntl.count) \ +From TripSeineImpl t \ +Join t.route r \ +Join r.activitySeine a \ +Join a.setSeine.nonTargetSample nts \ +Join nts.nonTargetLength ntl \ +Where t.id = :tripId \ +And ntl.species.id = :speciesId \ +Group By ntl.length \ +Order By ntl.length + +#################################################################### +## Distribution des tailles des conservés par espèces ciblées (LD1) +#################################################################### + +report.targetStoredDistributionLengthsLD1.name=Distribution des tailles des captures par esp\u00e8ces cibl\u00e9es (mesure LD1) +report.targetStoredDistributionLengthsLD1.description=Afficher le nombre d'individus captur\u00e9s, mesur\u00e9s par classe de taille LD1 pour les esp\u00e8ces cibl\u00e9es +report.targetStoredDistributionLengthsLD1.columns=Classe de taille,Effectif +report.targetStoredDistributionLengthsLD1.operations.1=GroupByLength +report.targetStoredDistributionLengthsLD1.variable.speciesId=fr.ird.observe.entities.referentiel.Species|\ +Select distinct tl.species \ +From TripSeineImpl t \ +Join t.route r \ +Join r.activitySeine a \ +Join a.setSeine.targetSample ts \ +Join ts.targetLength tl \ +Where t.id = :tripId \ +And tl.measureType = 1 \ +And ts.discarded = false +report.targetStoredDistributionLengthsLD1.request.1=0,0|row| \ +Select tl.length , Sum(tl.count) \ +From TripSeineImpl t \ +Join t.route r \ +Join r.activitySeine a \ +Join a.setSeine.targetSample ts \ +Join ts.targetLength tl \ +Where t.id = :tripId \ + And tl.species.id = :speciesId \ + And tl.measureType = 1 \ + And ts.discarded = false \ +Group By tl.length \ +Order By tl.length + +################################################################ +## Distribution des tailles des rejets par espèces ciblées (LD1) +################################################################ + +report.targetDiscardedDistributionLengthsLD1.name=Distribution des tailles des rejets par esp\u00e8ces cibl\u00e9es (mesure LD1) +report.targetDiscardedDistributionLengthsLD1.description=Afficher la nombre d'individus rejet\u00e9s, mesur\u00e9s par classe de taille LD1 pour les esp\u00e8ces cibl\u00e9es +report.targetDiscardedDistributionLengthsLD1.columns=Classe de taille,Effectif +report.targetDiscardedDistributionLengthsLD1.operations.1=GroupByLength +report.targetDiscardedDistributionLengthsLD1.variable.speciesId=fr.ird.observe.entities.referentiel.Species|\ +Select distinct tl.species \ +From TripSeineImpl t \ +Join t.route r \ +Join r.activitySeine a \ +Join a.setSeine.targetSample ts \ +Join ts.targetLength tl \ +Where t.id = :tripId \ +And tl.measureType = 1 \ +And ts.discarded = true +report.targetDiscardedDistributionLengthsLD1.request.1=0,0|row| \ +Select tl.length , Sum(tl.count) \ +From TripSeineImpl t \ +Join t.route r \ +Join r.activitySeine a \ +Join a.setSeine.targetSample ts \ +Join ts.targetLength tl \ +Where t.id = :tripId \ + And tl.species.id = :speciesId \ + And tl.measureType = 1\ + And ts.discarded = true \ +Group By tl.length \ +Order By tl.length + +############################################################### +## Distribution des tailles des conservés par espèces ciblées (LF) +############################################################### + +report.targetStoredDistributionLengthsLF.name=Distribution des tailles des captures par esp\u00e8ces cibl\u00e9es (mesure LF) +report.targetStoredDistributionLengthsLF.description=Afficher le nombre d'individus captur\u00e9s, mesur\u00e9s par classe de taille LF pour les esp\u00e8ces cibl\u00e9es +report.targetStoredDistributionLengthsLF.columns=Classe de taille,Effectif +report.targetStoredDistributionLengthsLF.operations.1=GroupByLength +report.targetStoredDistributionLengthsLF.variable.speciesId=fr.ird.observe.entities.referentiel.Species|\ +Select distinct tl.species \ +From TripSeineImpl t \ +Join t.route r \ +Join r.activitySeine a \ +Join a.setSeine.targetSample ts \ +Join ts.targetLength tl \ +Where t.id = :tripId \ +And tl.measureType = 2 \ +And ts.discarded = false +report.targetStoredDistributionLengthsLF.request.1=0,0|row| \ +Select tl.length , Sum(tl.count) \ +From TripSeineImpl t \ +Join t.route r \ +Join r.activitySeine a \ +Join a.setSeine.targetSample ts \ +Join ts.targetLength tl \ +Where t.id = :tripId \ + And tl.species.id = :speciesId \ + And tl.measureType = 2 \ + And ts.discarded = false \ +Group By tl.length \ +Order By tl.length + +############################################################### +## Distribution des tailles des rejets par espèces ciblées (LF) +############################################################### + +report.targetDiscardedDistributionLengthsLF.name=Distribution des tailles des rejets par esp\u00e8ces cibl\u00e9es (mesure LF) +report.targetDiscardedDistributionLengthsLF.description=Afficher le nombre d'individus rejet\u00e9s, mesur\u00e9s par classe de taille LF pour les esp\u00e8ces cibl\u00e9es +report.targetDiscardedDistributionLengthsLF.columns=Classe de taille,Effectif +report.targetDiscardedDistributionLengthsLF.operations.1=GroupByLength +report.targetDiscardedDistributionLengthsLF.variable.speciesId=fr.ird.observe.entities.referentiel.Species|\ +Select distinct tl.species \ +From TripSeineImpl t \ +Join t.route r \ +Join r.activitySeine a \ +Join a.setSeine.targetSample ts \ +Join ts.targetLength tl \ +Where t.id = :tripId \ +And tl.measureType = 2 \ +And ts.discarded = true +report.targetDiscardedDistributionLengthsLF.request.1=0,0|row| \ +Select tl.length , Sum(tl.count) \ +From TripSeineImpl t \ +Join t.route r \ +Join r.activitySeine a \ +Join a.setSeine.targetSample ts \ +Join ts.targetLength tl \ +Where t.id = :tripId \ + And tl.species.id = :speciesId \ + And tl.measureType = 2 \ + And ts.discarded = true \ +Group By tl.length \ +Order By tl.length + +############################################ +## Répartition des calées par cuves +############################################ + +report.repartionCaleeParCuve.name=R\u00e9partition des cal\u00e9es par cuves +report.repartionCaleeParCuve.description=R\u00e9partition des cal\u00e9es par cuves, type de banc et esp\u00e8ce +report.repartionCaleeParCuve.columns=Jour - Heure observation,Latitude,Longitude,Type de banc,Esp\u00e8ce,Tonnage,Cuve +report.repartionCaleeParCuve.request.1=0,0|row| \ +Select concat(day(r.date), '/', month(r.date), '/', year(r.date), ' ', hour(a.time), ':', minute(a.time)), \ + a.latitude, \ + a.longitude, \ + case when a.setSeine.schoolType = 1 then 'BO' else 'BL' end, \ + tc.weightCategory.species.faoCode, \ + Sum(tc.catchWeight), \ + case when tc.discarded = true then 'Rejet\u00e9' else tc.well end \ +From TripSeineImpl t \ +Join t.route r \ +Join r.activitySeine a \ +Join a.setSeine.targetCatch tc \ +Where t.id = :tripId \ +Group By r.date, a.time, a.latitude, a.longitude, tc.weightCategory.species, tc.weightCategory.species.faoCode, tc.well, a.setSeine.schoolType \ +Order By r.date, a.time, tc.weightCategory.species, tc.well -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.
This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository observe. See http://git.codelutin.com/observe.git commit dd58708693aa0e18c8fb86466417a53c7543fceb Merge: 70d655b 9f49fbf Author: Tony CHEMIT <chemit@codelutin.com> Date: Thu Sep 3 16:19:32 2015 +0200 Merge sur develop (termine #7498) .../fr/ird/observe/AbstractObserveTopiaDao.java | 18 + observe-services-api/pom.xml | 24 +- .../src/main/filters/observe-reports.properties | 854 +++++++++++++++++++ .../service/actions/report/ReportBuilder.java | 489 +++++++++++ .../service/actions/report/ReportService.java | 20 + .../service/actions/report/model/DataMatrix.java | 259 ++++++ .../service/actions/report/model/Report.java | 157 ++++ .../actions/report/model/ReportOperation.java | 106 +++ .../actions/report/model/ReportRequest.java | 406 +++++++++ .../actions/report/model/ReportVariable.java | 80 ++ .../report/model/operations/ExecuteRequests.java | 120 +++ .../report/model/operations/GroupByLength.java | 111 +++ .../actions/report/model/operations/SumColumn.java | 129 +++ .../report/model/operations/SumIntColumn.java | 129 +++ .../actions/report/model/operations/SumIntRow.java | 129 +++ .../actions/report/model/operations/SumRow.java | 129 +++ ...es.service.actions.report.model.ReportOperation | 6 + .../service/actions/report/ReportBuilderTest.java | 130 +++ .../actions/report/observe-reports-test.properties | 27 + .../service/actions/report/ReportServiceTopia.java | 207 +++++ .../report/AbstractReportServiceTopiaTest.java | 242 ++++++ .../actions/report/ReportAccessoryCatch2Test.java | 199 +++++ .../report/ReportAccessoryCatchByGroup2Test.java | 68 ++ .../report/ReportAccessoryCatchByGroupTest.java | 100 +++ .../actions/report/ReportAccessoryCatchTest.java | 156 ++++ .../report/ReportActivityWithCommentTest.java | 348 ++++++++ .../actions/report/ReportAllActivitysTest.java | 943 +++++++++++++++++++++ .../actions/report/ReportDailySetAndCatchTest.java | 103 +++ .../service/actions/report/ReportDcpUsageTest.java | 142 ++++ .../report/ReportSetByAssociation2Test.java | 50 ++ .../actions/report/ReportSetByAssociationTest.java | 128 +++ .../report/ReportTargetCatchByAssociationTest.java | 116 +++ .../ReportTargetDiscardedByAssociationTest.java | 116 +++ 33 files changed, 6240 insertions(+), 1 deletion(-) -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.
participants (1)
-
codelutin.com scm