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

Commits:

13 changed files:

Changes:

  • client/runner/pom.xml
    ... ... @@ -303,6 +303,14 @@
    303 303 
                 </dependency>
    304 304 
               </dependencies>
    305 305 
             </plugin>
    306 
    +        <plugin>
    307 
    +          <groupId>com.akathist.maven.plugins.launch4j</groupId>
    308 
    +          <artifactId>launch4j-maven-plugin</artifactId>
    309 
    +          <configuration>
    310 
    +            <!-- FIXME Using 2.3.0 does not work, with RC versions... -->
    311 
    +            <disableVersionInfoDefaults>true</disableVersionInfoDefaults>
    312 
    +          </configuration>
    313 
    +        </plugin>
    306 314 
           </plugins>
    307 315 
         </pluginManagement>
    308 316 
         <plugins>

  • core/persistence/report/src/main/resources/observe-reports.properties
    ... ... @@ -962,7 +962,8 @@ Left Join a.vesselActivity vesselActivity \
    962 962 
     Where t.id In :tripId and wa.activity = a and vesselActivity.id = 'fr.ird.referential.ps.common.VesselActivity#1239832675369#0.12552908048322586' \
    963 963 
     Group By vessel.code,vessel.label2,t.startDate,t.endDate,r.date,a.time,a.number \
    964 964 
     Order By vessel.code,t.startDate,r.date,a.time
    965 
    -report.psLogbookWellPlanCheck.operations.1.type=SumFloatColumn
    965 
    +report.psLogbookWellPlanCheck.operations.1.type=SumColumn
    966 
    +report.psLogbookWellPlanCheck.operations.1.parameters=0|6
    966 967 
     report.psObservationActivityWithComment.modelType=PS
    967 968 
     report.psObservationActivityWithComment.name=Observations - Activités avec comment et leurs positions
    968 969 
     report.psObservationActivityWithComment.description=Afficher les activités avec comment et leurs positions géographiques

  • core/services/test/src/main/resources/fixtures/fr/ird/observe/services/service/ReportService-psLogbookWellPlanCheck.properties
    ... ... @@ -20,9 +20,8 @@
    20 20 
     # #L%
    21 21 
     ###
    22 22 
     result.0=483^CAP BOJADOR^30/3/2019^8/4/2019^30/3/2019^1^15:12^0.0^123.0^43.0^0.0^0.0^0.0^0.0^24.0^0.0^0.0^166.0^24.0^142.0
    23 
    -result.1=Total^-^-^-^-^-^-^0^123^43^0^0^0^0^24^0^0^166^24^142
    24 23 
     result.columns=20
    25 
    -result.rows=2
    24 
    +result.rows=1
    26 25 
     syntax.columns=20
    27 26 
     syntax.columnsHeader=Code bateau^Nom bateau^Date départ^Date arrivée^Date de route^Numéro activité^Heure activité^Logbook YFT^Logbook SKJ^Logbook BET^Logbook ALB^Logbook Autres^Plan de cuves YFT^Plan de cuves SKJ^Plan de cuves BET^Plan de cuves ALB^Plan de cuves Autres^Logbook Total^Plan de cuves Total^Différence
    28 27 
     syntax.description=Livre de bord - Vérification des plan de cuves

  • model/src/main/resources/observe-reports-legacy.properties
    ... ... @@ -1405,7 +1405,7 @@ Plan de cuves Autres,\
    1405 1405 
     Logbook Total,\
    1406 1406 
     Plan de cuves Total,\
    1407 1407 
     Différence
    1408 
    -report.psLogbookWellPlanCheck.operations.1=SumFloatColumn
    1408 
    +report.psLogbookWellPlanCheck.operations.1=SumColumn:0|6
    1409 1409 
     report.psLogbookWellPlanCheck.request.1=0,0|row|\
    1410 1410 
     Select vessel.code,\
    1411 1411 
       vessel.label2,\

  • pom.xml
    ... ... @@ -23,7 +23,7 @@
    23 23 
       <parent>
    24 24 
         <groupId>io.ultreia.maven</groupId>
    25 25 
         <artifactId>pom</artifactId>
    26 
    -    <version>2023.2</version>
    26 
    +    <version>2023.3</version>
    27 27 
       </parent>
    28 28 
       <groupId>fr.ird.observe</groupId>
    29 29 
       <artifactId>ird-observe</artifactId>

  • src/site/markdown/index.md
    ... ... @@ -2,7 +2,7 @@
    2 2
    3 3 
     ## Présentation
    4 4
    5 
    -Le logiciel *ObServe*... TODO
    5 
    +Le logiciel *ObServe*... **TODO**
    6 6
    7 7 
     # Les documents
    8 8
    ... ... @@ -13,6 +13,7 @@ Le logiciel *ObServe*... TODO
    13 13 
     - [Administration web (v7)](./server-configuration-application-v7.html)
    14 14 
     - [Configuration client](./observe-client.html)
    15 15 
     - [Configuration server](./observe-server.html)
    16 
    +- [Documentation de l'outil de reporting](./report/index.html)
    16 17
    17 18
    18 19

  • src/site/markdown/report/embedded-operations.md
    1 
    +# Documentation des opérations disponibles
    2 
    +
    3 
    +Ce document décrit toutes les opérations disponibles sur les rapports.
    4 
    +
    5 
    +On en distingue deux types :
    6 
    +
    7 
    + * les opérations génériques : elles peuvent être utilisées pour écrire de nouveaux rapports, leur fonctionnement n'est pas lié au modèle de données d'ObServe
    8 
    + * les opérations spécifiques : elles correspondent à des opérations utilisées sur des rapports embarqués et ne devraient pas être utilisées pour de nouveaux rapports
    9 
    +
    10 
    +## Les opérations génériques
    11 
    +
    12 
    +### ComputeDynamicHeader
    13 
    +
    14 
    +Cette opération permet de construire des en-têtes du résultat à partir de deux choses :
    15 
    +
    16 
    + * une première partie qui est une liste de colonnes fixes
    17 
    + * une seconde partie qui utilise une variable de répétition pour décrire le reste des en-têtes de colonnes de manière dynamique
    18 
    +
    19 
    +**Cette opération requière un paramétrage**.
    20 
    +
    21 
    +Exemple d'utilisation :
    22 
    +
    23 
    +```properties
    24 
    +report.xxx.repeatVariable.1.name=reasonForDiscard
    25 
    +report.xxx.repeatVariable.1.type=fr.ird.observe.entities.referential.ps.observation.ReasonForDiscard
    26 
    +report.xxx.repeatVariable.1.request=Select sf \
    27 
    +From ReasonForDiscardImpl sf \
    28 
    +Order by sf.code
    29 
    +report.xxx.operations.1.type=ComputeDynamicHeader
    30 
    +report.xxx.operations.1.parameters=Espèce,Total BL,Total BO|reasonForDiscard
    31 
    +```
    32 
    +
    33 
    +**À noter que pour décorer les valeurs dynamique, on utilise si c'est une entité de référentiel de type *I18n*, son *label2*, sinon un *toString*.**
    34 
    +
    35 
    +Les décorations pourraient être améliorées pour utiliser les décorateurs associées au type d'entitée, mais nous n'avons pas eu ce besoin pour le moment.
    36 
    +
    37 
    +### CopyRepeatVariableToFirstColumn
    38 
    +
    39 
    +Cette opération permet de recopier dans la première colonne du résultat, l'univers d'une variable de répétition.
    40 
    +
    41 
    +**Cette opération requière un paramétrage**.
    42 
    +
    43 
    +Exemple d'utilisation :
    44 
    +
    45 
    +```properties
    46 
    +report.xxx.repeatVariable.1.name=length
    47 
    +report.xxx.repeatVariable.1.type=java.lang.Float
    48 
    +report.xxx.repeatVariable.1.request=Select distinct ntl.length \
    49 
    +From TripImpl t \
    50 
    +Join t.routeObs r \
    51 
    +Join r.activity a \
    52 
    +Join a.set.sample nts \
    53 
    +Join nts.sampleMeasure ntl with ntl.species.id = :species And ntl.sizeMeasureType.id = :sizeMeasureType \
    54 
    +Where t.id In :tripId \
    55 
    +Order By ntl.length
    56 
    +report.xxx.operations.1.type=CopyRepeatVariableToFirstColumn
    57 
    +report.xxx.operations.1.parameters=length
    58 
    +```
    59 
    +
    60 
    +Le meme mécanisme de décoration que pour l'opération précédente est utilisé.
    61 
    +
    62 
    +### ExecuteRequestAndReorganizeDataByRepeatVariable
    63 
    +
    64 
    +Cette opération permet d'exécuter une requête et ensuite de réorganiser le résultat selon les valeurs définies
    65 
    +via deux variables de répétition, une pour l'axe des abscisses et une par l'axe des ordonnées.
    66 
    +
    67 
    +**Cette opération requière un paramétrage** avec trois valeurs (séparées via des *pipes*) :
    68 
    +
    69 
    + * le premier paramètre indique la variable de répétition pour ordonner sur l'axe des abscisses
    70 
    + * le second paramètre indique la variable de répétition pour ordonner sur l'axe des ordonnées
    71 
    + * le troisième paramètre est la requête à executer
    72 
    +
    73 
    +Exemple d'utilisation
    74 
    +
    75 
    +```properties
    76 
    +report.xxx.repeatVariable.1.name=length
    77 
    +report.xxx.repeatVariable.1.type=java.lang.Float
    78 
    +report.xxx.repeatVariable.1.request=Select distinct ntl.length \
    79 
    +From TripImpl t \
    80 
    +Join t.routeObs r \
    81 
    +Join r.activity a \
    82 
    +Join a.set.sample nts \
    83 
    +Join nts.sampleMeasure ntl with ntl.species.id = :species And ntl.sizeMeasureType.id = :sizeMeasureType \
    84 
    +Where t.id In :tripId \
    85 
    +Order By ntl.length
    86 
    +report.xxx.repeatVariable.2.name=speciesFate
    87 
    +report.xxx.repeatVariable.2.type=fr.ird.observe.entities.referential.ps.common.SpeciesFate
    88 
    +report.xxx.repeatVariable.2.request=Select sf \
    89 
    +From SpeciesFateImpl sf \
    90 
    +Order by sf.discard, sf.code
    91 
    +report.xxx.repeatVariable.2.addNull=true
    92 
    +report.xxx.operations.1.type=ExecuteRequestAndReorganizeDataByRepeatVariable
    93 
    +report.xxx.operations.1.parameters=length|speciesFate|Select ntl.length, sf.id, sum(ntl.count) \
    94 
    +From TripImpl t \
    95 
    +Join t.routeObs r \
    96 
    +Join r.activity a \
    97 
    +Join a.set.sample nts \
    98 
    +Join nts.sampleMeasure ntl With ntl.species.id = :species And ntl.sizeMeasureType.id = :sizeMeasureType \
    99 
    +Left Join ntl.speciesFate sf \
    100 
    +Where t.id In :tripId \
    101 
    +Group By ntl.length, sf \
    102 
    +Order By ntl.length
    103 
    +```
    104 
    +
    105 
    +**À noter que la requête doit produire une résultat avec trois colonnes, la première pour l'axe des abscisses,
    106 
    +la seconde pour l'axe des ordonnées et la troisième pour la valeur effective à replacer à la bonne position**.
    107 
    +
    108 
    +**À noter aussi que les deux variables de répétition doivent être ordonnées afin de produire un résultat invariant.**
    109 
    +### SumColumn
    110 
    +
    111 
    +Cette opération permet de réaliser la somme par colonne, i.e de rajouter une dernière ligne qui fait la somme des
    112 
    +valeurs décimales de chaque colonne.
    113 
    +
    114 
    +Le résultat sera un **entier avec décimales** (on arrondit à 4 décimales).
    115 
    +
    116 
    +**À noter que si une colonne contient des valeurs non numériques, le total n'est pas effectué et la valeur de la
    117 
    +celulle sera *-***.
    118 
    +
    119 
    +**À noter aussi que si on se retrouve avec une seule colonne à sommer, alors la ligne *total* ne sera pas ajoutée**.
    120 
    +
    121 
    +Exemple d'utilisation (sans paramétrage)
    122 
    +
    123 
    +```properties
    124 
    +report.xxx.operations.1.type=SumColumn
    125 
    +```
    126 
    +
    127 
    +L'opéréation peut être paramétrée pour indiquer sur quelle zone on doit effectuer les sommes.
    128 
    +
    129 
    +Le paramétrage est une position sur le résultat final codifié sous la forme ```x|y```.
    130 
    +
    131 
    +Exemple d'utilisation (avec paramétrage)
    132 
    +
    133 
    +```properties
    134 
    +report.xxx.operations.1.type=SumColumn
    135 
    +report.xxx.operations.1.parameters=0|1
    136 
    +```
    137 
    +
    138 
    +Ici on commence la somme à partir de la ligne **0** et la colonne **1**.
    139 
    +
    140 
    +### SumIntColumn
    141 
    +
    142 
    +Cette opération est identique à l'opération précédente, pour des entiers.
    143 
    +
    144 
    +On effectue donc ici une somme d'entiers. Si une des valeurs de la colonne n'est pas un entier, on remplace alors
    145 
    +le résultat par **-**.
    146 
    +
    147 
    +Le paramétrage optionnel est identique aussi.
    148 
    +
    149 
    +Exemple d'utilisation (sans paramétrage)
    150 
    +
    151 
    +```properties
    152 
    +report.xxx.operations.1.type=SumIntColumn
    153 
    +```
    154 
    +Exemple d'utilisation (avec paramétrage)
    155 
    +
    156 
    +```properties
    157 
    +report.xxx.operations.1.type=SumIntColumn
    158 
    +report.xxx.operations.1.parameters=0|1
    159 
    +```
    160 
    +
    161 
    +Ici on commence la somme à partir de la ligne **0** et la colonne **1**.
    162 
    +
    163 
    +### SumRow
    164 
    +
    165 
    +Cette opération permet de réaliser la somme par ligne, i.e de rajouter une dernière colonne qui fait la somme des
    166 
    +valeurs décimales de chaque ligne.
    167 
    +
    168 
    +Le résultat sera un **entier avec décimales** (on arrondit à 4 décimales).
    169 
    +
    170 
    +**À noter que si une ligne contient des valeurs non numériques, le total n'est pas effectué et la valeur de la
    171 
    +celulle sera *-***.
    172 
    +
    173 
    +**À noter aussi que si on se retrouve avec une ligne colonne à sommer, alors la colonne *total* ne sera pas ajoutée**.
    174 
    +
    175 
    +Exemple d'utilisation (sans paramétrage)
    176 
    +
    177 
    +```properties
    178 
    +report.xxx.operations.1.type=SumRow
    179 
    +```
    180 
    +
    181 
    +L'opéréation peut être paramétrée pour indiquer sur quelle zone on doit effectuer les sommes.
    182 
    +
    183 
    +Le paramétrage est une position sur le résultat final codifié sous la forme ```x|y```.
    184 
    +
    185 
    +Exemple d'utilisation (avec paramétrage)
    186 
    +
    187 
    +```properties
    188 
    +report.xxx.operations.1.type=SumRow
    189 
    +report.xxx.operations.1.parameters=0|1
    190 
    +```
    191 
    +
    192 
    +Ici on commence la somme à partir de la ligne **0** et la colonne **1**.
    193 
    +
    194 
    +### SumIntRow
    195 
    +
    196 
    +Cette opération est identique à l'opération précédente, pour des entiers.
    197 
    +
    198 
    +On effectue donc ici une somme d'entiers. Si une des valeurs de la colonne n'est pas un entier, on remplace alors
    199 
    +le résultat par **-**.
    200 
    +
    201 
    +Le paramétrage optionnel est identique aussi.
    202 
    +
    203 
    +Exemple d'utilisation (sans paramétrage)
    204 
    +
    205 
    +```properties
    206 
    +report.xxx.operations.1.type=SumIntRow
    207 
    +```
    208 
    +
    209 
    +Exemple d'utilisation (avec paramétrage)
    210 
    +
    211 
    +```properties
    212 
    +report.xxx.operations.1.type=SumIntRow
    213 
    +report.xxx.operations.1.parameters=0|1
    214 
    +```
    215 
    +
    216 
    +Ici on commence la somme à partir de la ligne **0** et la colonne **1**.
    217 
    +
    218 
    +## Opérations spécifiques à ObServe
    219 
    +
    220 
    +Ces opérations étant utilisées uniquement dans les rapport embarqués, elles ne possèdent aucun paramétrage.
    221 
    +
    222 
    +Nous ne donnerons pas d'exemple d'utilisation, mais le lien vers le rapport qui l'utilise.
    223 
    +
    224 
    +## ComputeMeasurementsLongline
    225 
    +
    226 
    +Cette opération permet pour un équipement déclaré d'une marée (du domaine Palangre), de regrouper les différentes
    227 
    +composantes de cet équipement.
    228 
    +
    229 
    +**Cette opération ne requière aucun paramétrage.**
    230 
    +
    231 
    +Elle est utilisée dans le rapport [llCommonTripGearUseFeatures](./embedded-reports.html#llCommonTripGearUseFeatures).
    232 
    +
    233 
    +## UnionAndSortLlLogbookSamples
    234 
    +
    235 
    +Cette opération permet de regrouper les échantillons du modèle *Senne - Livre de bord* qui existent au niveau des
    236 
    +activités et des marées, puis de les trier.
    237 
    +
    238 
    +**Cette opération ne requière aucun paramétrage.**
    239 
    +
    240 
    +Elle est utilisée dans le rapport [llLogbookSamplesOnBoth](./embedded-reports.html#llLogbookSamplesOnBoth).
    241 
    +
    242 
    +## ComputeLocalmarketSampleWellAndSpeciesMeasure
    243 
    +
    244 
    +Cette opération permet de calculer les distributions d'échantillons du modèle *Senne - Marché local* au niveau des cuves.
    245 
    +
    246 
    +**Cette opération ne requière aucun paramétrage.**
    247 
    +
    248 
    +Elle est utilisée dans le rapport [psLocalmarketSample](./embedded-reports.html#psLocalmarketSample).
    249 
    +
    250 
    +## ComputeLocalmarketSurveyPart
    251 
    +
    252 
    +Cette opération permet de calculer les données des sondages du modèle *Senne - Marché local*.
    253 
    +
    254 
    +**Cette opération ne requière aucun paramétrage.**
    255 
    +
    256 
    +Elle est utilisée dans le rapport [psLocalmarketSurvey](./embedded-reports.html#psLocalmarketSurvey).
    257 
    +
    258 
    +## ComputeMeasurementsSeine
    259 
    +
    260 
    +Cette opération permet pour un équipement déclaré d'une marée (du domaine Senne), de regrouper les différentes
    261 
    +composantes de cet équipement.
    262 
    +
    263 
    +**Cette opération ne requière aucun paramétrage.**
    264 
    +
    265 
    +Elle est utilisée dans le rapport [psCommonTripGearUseFeatures](./embedded-reports.html#psCommonTripGearUseFeatures).
    266 
    +

  • src/site/markdown/report/embedded-reports.md
    1 
    +# Documentation des rapports embarqués par l'application
    2 
    +
    3 
    +Ce document décrit l'ensemble des rapports embarqués par l'application.
    4 
    +
    5 
    +## Modèle Palangre
    6 
    +
    7 
    +### llCommonTripGearUseFeatures
    8 
    +
    9 
    +Liste des équipements
    10 
    +
    11 
    +### llLanding
    12 
    +
    13 
    +Liste des débarquements
    14 
    +
    15 
    +### llLogbookActivities
    16 
    +
    17 
    +Livre de bord - Liste des activités
    18 
    +
    19 
    +### llLogbookCatches
    20 
    +
    21 
    +Livre de bord - Liste des captures
    22 
    +
    23 
    +### llLogbookSamplesOnActivity
    24 
    +
    25 
    +Livre de bord - Liste des échantillons rattachés au niveau calée
    26 
    +
    27 
    +### llLogbookSamplesOnBoth
    28 
    +
    29 
    +Livre de bord - Liste des échantillons
    30 
    +
    31 
    +### llLogbookSamplesOnTrip
    32 
    +
    33 
    +Livre de bord - Liste des échantillons rattachés au niveau marée
    34 
    +
    35 
    +## Modèle Senne
    36 
    +
    37 
    +### psCommonTripGearUseFeatures
    38 
    +
    39 
    +Liste des équipements
    40 
    +
    41 
    +### psLocalmarketBatch
    42 
    +
    43 
    +Marché local - Lots
    44 
    +
    45 
    +### psLocalmarketSample
    46 
    +
    47 
    +Marché local - Échantillons
    48 
    +
    49 
    +### psLocalmarketSurvey
    50 
    +
    51 
    +Marché local - Sondages
    52 
    +
    53 
    +### psLogbookActivity
    54 
    +
    55 
    +Livre de bord - Vérification croisée des captures
    56 
    +
    57 
    +### psLogbookSampleMeasures
    58 
    +
    59 
    +Livre de bord - Mesures par échantillons
    60 
    +
    61 
    +### psLogbookSampleSet
    62 
    +
    63 
    +Livre de bord - Calées des échantillons
    64 
    +
    65 
    +### psLogbookSampleSpeciesMeasures
    66 
    +
    67 
    +Livre de bord - Mesures par sous échantillons
    68 
    +
    69 
    +### psLogbookSampleSpeciesMeasuresCount
    70 
    +
    71 
    +Livre de bord - Nombre de mesures par sous échantillons
    72 
    +
    73 
    +### psLogbookTrip
    74 
    +
    75 
    +Livre de bord - Vérification croisée des données débarquements
    76 
    +
    77 
    +### psLogbookWellPlan
    78 
    +
    79 
    +Livre de bord - Plan de cuves
    80 
    +
    81 
    +### psLogbookWellPlanCheck
    82 
    +
    83 
    +Livre de bord - Vérification des plan de cuves
    84 
    +
    85 
    +### psObservationActivityWithComment
    86 
    +
    87 
    +Observations - Activités avec comment et leurs positions
    88 
    +
    89 
    +### psObservationAllActivities
    90 
    +
    91 
    +Observations - Toutes les activités et leurs positions
    92 
    +
    93 
    +### psObservationCatch
    94 
    +
    95 
    +Observations - Liste des captures selon le type de banc, filtrées par groupe
    96 
    +
    97 
    +### psObservationCatchTotalCountByGroupAndSpeciesFateDiscardPerAssociation
    98 
    +
    99 
    +Observations - Dénombrement des captures selon le type d'association, filtrées par groupe et mode (rejeté/conservé)
    100 
    +
    101 
    +### psObservationCatchTotalCountByGroupPerReasonForDiscard
    102 
    +
    103 
    +Observations - Dénombrement des rejets par type de banc et raison de rejet, filtrés par groupe (en t)
    104 
    +
    105 
    +### psObservationCatchTotalCountByGroupPerSpeciesFate
    106 
    +
    107 
    +Observations - Dénombrement des captures par type de banc et devenir, filtrés par groupe
    108 
    +
    109 
    +### psObservationCatchWeightByGroupAndSpeciesFateDiscardPerAssociation
    110 
    +
    111 
    +Observations - Poids des captures selon le type d'association, filtrées par groupe et mode (rejeté/conservé) (en t)
    112 
    +
    113 
    +### psObservationCatchWeightByGroupPerReasonForDiscard
    114 
    +
    115 
    +Observations - Poids des rejets par type de banc et raison de rejet, filtrés par groupe (en t)
    116 
    +
    117 
    +### psObservationCatchWeightByGroupPerSpeciesFate
    118 
    +
    119 
    +Observations - Poids des captures par type de banc et devenir, filtrés par groupe (en t)
    120 
    +
    121 
    +### psObservationDailySetAndCatch
    122 
    +
    123 
    +Observations - Nombre de calées et captures journalières d'une marée
    124 
    +
    125 
    +### psObservationFobUsageExtended
    126 
    +
    127 
    +Observations - Utilisation des FOB, tableau détaillé
    128 
    +
    129 
    +### psObservationFobUsageMinimal
    130 
    +
    131 
    +Observations - Utilisation des FOB, tableau simplifiée
    132 
    +
    133 
    +### psObservationLengthsDistribution
    134 
    +
    135 
    +Observations - Distribution des tailles par espèces et type de mesure
    136 
    +
    137 
    +### psObservationRepartionCaleeParCuve
    138 
    +
    139 
    +Observations - Répartition des calées par cuves
    140 
    +
    141 
    +### psObservationSetByAssociation
    142 
    +
    143 
    +Observations - Nombre de calées selon le type d’association
    \ No newline at end of file

  • src/site/markdown/report/index.md.vm
    1 
    +# Documentation des rapports
    2 
    +
    3 
    +Ce document décrit les principes de base utilisés sur l'outil de reporting de l'application.
    4 
    +
    5 
    +Les rapports sont utilisables depuis l'assistant **Tableau de synthèse**.
    6 
    +
    7 
    +## De quoi est composé un rapport ?
    8 
    +
    9 
    +Pour décrire un rapport, quatre notions sont à comprendre :
    10 
    +
    11 
    +* les méta-données
    12 
    +* les variables *(1)*
    13 
    +* les variables de répétition *(1)*
    14 
    +* les requêtes *(1)*
    15 
    +* les opérations *(1)*
    16 
    +
    17 
    +*(1)* On peut avoir plusieurs données de ce type pour un même rapport, l'ordre importe, la syntaxe utilise
    18 
    +alors un incrément (qui commence à **1**) pour refléter cet ordre.
    19 
    +
    20 
    +### Les méta-données
    21 
    +
    22 
    +Les méta-données permettent de décrire le domaine métier, le nom, description et les en-têtes du rapport.
    23 
    +
    24 
    +### Les variables
    25 
    +
    26 
    +Une variable **[optionnelle]** permet à l'utilisateur de pouvoir choisir un discriminant sur le rapport parmi un
    27 
    +ensemble de valeurs (son *univers*); concrêtement cela va ajouter une liste déroulante dans l'interface graphique,
    28 
    +l'utilisateur devra alors choisir une *valeur* parmi l'univers calculé via sa définition.
    29 
    +
    30 
    +Depuis la *v9*, les variables peuvent être interdépendantes, ce qui a pour bénéfice de limiter les résultats d'un rapport
    31 
    +à des données réellement utilisées sur la source de données et de ne plus proposer des tuples de variables qui ne
    32 
    +produisent pas de résultats (*faux positifs*).
    33 
    +
    34 
    +**À noter que pour exécuter le rapport, toutes les variables doivent être renseignées dans l'interface graphique.**
    35 
    +
    36 
    +### Les variables de répetition
    37 
    +
    38 
    +Un variable de répétition **[optionnelle]** permet de définir un ensemble de valeurs qui pourront ensuite être utilisées
    39 
    +dans un requête comme discriminant, i.e que la requête sera jouée pour chacune des valeurs de la variable de répétition.
    40 
    +
    41 
    +Depuis la *v9*, les variables de répétitions peuvent utilisées les variables, mais aussi d'autres variables de répétition.
    42 
    +
    43 
    +**À noter que les variables de répétition ne sont calculées que lorsque le rapport va être executé (donc une fois toutes
    44 
    +les variables renseignées par l'utilisateur).**
    45 
    +
    46 
    +### Les requêtes
    47 
    +
    48 
    +Un requête **[optionnelle]** permet de définir une partie du tableau final du rapport. Bien qu'optionnel, dans la pratique
    49 
    +chacun des rapports embarqués par l'application en défini au moins une; on pourrait cependant définir un rapport qui
    50 
    +n'utilise pas de requête mais uniquement des opérations...
    51 
    +
    52 
    +Plusieurs requêtes peuvent être chaînées.
    53 
    +
    54 
    +### Les opérations
    55 
    +
    56 
    +Une opération **[optionnelle]** permet de définir une action à réaliser une fois que toutes les requêtes du rapport
    57 
    +ont été jouées sur le tableau de résultat alors produit. Par exemple, effectuer des totaux par colonne ou lignes.
    58 
    +
    59 
    +Un opération exécute un code *Java* sur le résultat pour en produire un nouveau.
    60 
    +
    61 
    +Plusieurs opérations peuvent être chaînées.
    62 
    +
    63 
    +### Ordre de description
    64 
    +
    65 
    +Comme dit plus haut, l'ordre de description des différents éléments d'un rapport est important :
    66 
    +
    67 
    + * L'ordre de description des variables permet d'ordonner leur affichage, mais aussi pour le calcul de leur univers dans le cas de variable interdépendantes
    68 
    + * Idem pour les variables de répétition
    69 
    + * L'ordre des requêtes ainsi que les opérations à joueur est tout aussi important pour produire le résultat voulu
    70 
    +
    71 
    +## Autres notions à prendre en considération avant d'apprendre à écrire un rapport
    72 
    +
    73 
    +Plusieurs autres points sont à préciser avant de se lancer dans l'écriture d'un rapport :
    74 
    +
    75 
    + * le type de données sur lequel porte le rapport
    76 
    + * la technologie utilisée pour exprimer les requêtes
    77 
    +
    78 
    +### Type de données (variable *tripId*)
    79 
    +
    80 
    +Le type de données de base pour un rapport est la marée, tout rapport (selon son type de modèle) se réfère donc à la
    81 
    +marée de son modèle métier (*Senne*, ou *Palangre*).
    82 
    +
    83 
    +Un variable spéciale nommée **tripId** est utilisable dans la définition des variables, requêtes, opérations et reflète
    84 
    +les identifiants des marées sélectionnées par l'utilisateur dans l'assistant.
    85 
    +
    86 
    +**Ce nom de variable est *protégé* et ne peut donc pas être utilisé pour définir une variable ou variable de répétition.**
    87 
    +
    88 
    +### Technologie utilisée pour exprimer les requêtes
    89 
    +
    90 
    +Nous utilisons le **hql** pour décrire toute requête d'un rapport. Il s'agit d'un language de requetage propre à
    91 
    +Hibernate (librairie *ORM* de persitence surlequel nous nous appuyons).
    92 
    +
    93 
    +Cela nous apporte les bénéfices suivants :
    94 
    +
    95 
    + * pouvoir créer des objets java à partir d'une requête
    96 
    + * effectuer des jointures et remplir plus facilement les objets crées
    97 
    + * *Hibernate* et donc le *hql* ne dépendent pas de la source de données cible (i.e du type de base cible (*H2*, *Posgresql*))
    98 
    +
    99 
    +Cependant cela a aussi des désavantages :
    100 
    +
    101 
    + * les requêtes ne sont pas effectuées sur le modèle physique (*sql*) et donc cela oblige à connaitre le modèle objet Java associé à la couche de persistence
    102 
    + * la syntaxe *sql* permet de faire des choses qu'Hibernate ne sait pas faire (par exemple les *UNION*) avant la version *6*.
    103 
    + * la syntaxe *sql* est connue de tous, *hql* uniquement dans le monde *Java*...
    104 
    +
    105 
    +Ce choix pourrait être remis en question en *v10* pour utiliser directement du *sql*, mais pour ce faire, il faudra
    106 
    +avoir toutes les solutions techniques de remplacement.
    107 
    +
    108 
    +## Où sont les rapports embarqués par l'application ?
    109 
    +
    110 
    +L'application embarque un certain nombre de rapport décrits dans un fichier de type *properties*.
    111 
    +
    112 
    +La syntaxe a été uniformisée en version 9.
    113 
    +
    114 
    +Pour le moment, tous les rapports sont regroupés dans un seul fichier situé dans le répertoire des resources de la
    115 
    +version applicative, à savoir dans
    116 
    +
    117 
    +```.observe/resources-${project.version}/report/observe-reports.properties```
    118 
    +
    119 
    +Dans la configuration de l'assistant, par défaut on utilise ce fichier.
    120 
    +
    121 
    +Il est envisagé en *v10* de faire évoluer cela pour que chaque rapport puisse être décrit dans un fichier séparé.
    122 
    +
    123 
    +Cela aura pour avantage :
    124 
    +
    125 
    + * de pouvoir rajouter des rapports sans à avoir à modifier le fichier des rapports embarqués par l'application.
    126 
    + * de simplifier l'écriture de ceux-ci (on pourra alors supprimer tous les préfixes actuellement utilisés pour identifier un rapport).
    127 
    + * de pouvoir organiser ces rapports par modèle métier, ou par type d'organisation
    128 
    +
    129 
    +## Description du fonctionnement général d'un rapport
    130 
    +
    131 
    +### Prération des variables
    132 
    +
    133 
    +Si un rapport contient des variables, il faut alors dans un premier temps calculer leurs univers de valeurs et présenter
    134 
    +à l'utilisateur ces univers pour qu'il puisse sélectionner **pour chaque variable**, une valeur qui sera ensuite
    135 
    +utilisée pour exécuter le rapport (ou calculer l'univers d'autres variables...).
    136 
    +
    137 
    +Si de plus il existe des variables interdépendantes, les variables qui ont des dépendances sur d'autres variables ne
    138 
    +sont pas accéssibles tant que **toutes** ses dépendances ne sont pas renseignées.
    139 
    +
    140 
    +Une fois toutes les variables renseignées, le rapport est exécuté.
    141 
    +
    142 
    +**À noter que dès que l'utilisateur modifie la valeur d'une variable, le rapport va être de nouveau exécuté.
    143 
    +S'il s'agit d'une variable utilisée par d'autres variables, alors on recalcule l'univers de ces variables, que
    144 
    +l'utilisateur devra alors re-sélectionné parmi le nouvel univers calculé). Le rapport sera alors exécuté de nouveau une
    145 
    +fois toutes les variables renseignées.**
    146 
    +
    147 
    +### Exécution d'un rapport
    148 
    +
    149 
    +L'exécution d'un rapport se fait en trois étapes (elles ne sont pas obligatoires selon la définition du rapport) :
    150 
    +
    151 
    + 1. calcul des variables de répétition (si le rapport en possède)
    152 
    + 2. exécution des requêtes du rapport pour construire le résultat final (si le rapport en possède)
    153 
    + 3. exécution des opérations du rapport (si le rapport en possède) sur le résultat produit à l'étape précédente
    154 
    +
    155 
    +Une fois ces trois étapes exécutées, le résultat obtenu est restitué à l'utilisateur dans un tableau.
    156 
    +
    157 
    +## Pour aller plus loin
    158 
    +
    159 
    +Une fois ces principes de base assimilés, vous pouvez aller voir
    160 
    +
    161 
    +- [la documentation de la syntaxe d'un rapport](./syntax.html)

  • src/site/markdown/report/syntax.md
    1 
    +# Documentation de la syntaxe d'un rapport
    2 
    +
    3 
    +Ce document décrit comment écrire un rapport.
    4 
    +
    5 
    +## Syntaxe d'un rapport
    6 
    +
    7 
    +Comme écrit dans la page de présentation des rapports, ceux-ci sont décrits dans un fichier de type *properties*.
    8 
    +
    9 
    +La syntaxe a été uniformisée en version 9.
    10 
    +
    11 
    +### Identifiant d'un rapport
    12 
    +
    13 
    +Chaque rapport possède un identifiant unique; celui-ci est utilisé pour identifier toute sa description dans le fichier global.
    14 
    +
    15 
    +Voici un premier exemple de rapport pour mieux comprendre comment cela s'organise :
    16 
    +
    17 
    +```properties
    18 
    +report.llCommonTripGearUseFeatures.modelType=LL
    19 
    +report.llCommonTripGearUseFeatures.name=Liste des équipements
    20 
    +report.llCommonTripGearUseFeatures.description=Afficher les équipements
    21 
    +report.llCommonTripGearUseFeatures.columns=Equipement,Nombre,Utilisé dans la marée,Mesures
    22 
    +report.llCommonTripGearUseFeatures.repeatVariable.1.name=gearUseFeaturesId
    23 
    +report.llCommonTripGearUseFeatures.repeatVariable.1.type=java.lang.String
    24 
    +report.llCommonTripGearUseFeatures.repeatVariable.1.request=Select g.id \
    25 
    +From fr.ird.observe.entities.data.ll.common.TripImpl m \
    26 
    +Join m.gearUseFeatures g \
    27 
    +Where \
    28 
    +m.id In :tripId \
    29 
    +and g in elements (m.gearUseFeatures) \
    30 
    +Order By g.gear.label2
    31 
    +report.llCommonTripGearUseFeatures.request.1.location=0,0
    32 
    +report.llCommonTripGearUseFeatures.request.1.layout=row
    33 
    +report.llCommonTripGearUseFeatures.request.1.request=Select \
    34 
    +concat(CASE When g.gear.code IS NULL Then 'Aucun code' Else  g.gear.code End, ' - ', g.gear.label2), \
    35 
    +g.number, \
    36 
    +( CASE g.usedInTrip When true Then 'Oui' Else Case g.usedInTrip When false Then 'Non' Else 'Indéterminé' End End )\
    37 
    +From fr.ird.observe.entities.data.ll.common.GearUseFeaturesImpl g \
    38 
    +Where g.id = :gearUseFeaturesId
    39 
    +report.llCommonTripGearUseFeatures.request.1.repeat.name=gearUseFeaturesId
    40 
    +report.llCommonTripGearUseFeatures.request.1.repeat.layout=column
    41 
    +report.llCommonTripGearUseFeatures.operations.1.type=ComputeMeasurementsLongline
    42 
    +```
    43 
    +
    44 
    +Ici l'identifiant du rapport est ```llCommonTripGearUseFeatures```.
    45 
    +
    46 
    +Par convention, on utilise le domaine métier **ll**, suivi du sous-domaine métier **Common**, puis enfin un suffixe qui
    47 
    +exprime ce que le rapport doit produire **TripGearUseFeatures**.
    48 
    +
    49 
    +Dans le fichier global, toutes les entrées commençants par **report.llCommonTripGearUseFeatures** permettent alors de
    50 
    +décrire le rapport.
    51 
    +
    52 
    +### Méta-données d'un rapport
    53 
    +
    54 
    +Il existe cinq méta-données pour un rapport (dont trois sont obligatoires) :
    55 
    +
    56 
    +```properties
    57 
    +report.xxx.modelType=PS ou LL
    58 
    +report.xxx.name=Nom du rapport
    59 
    +report.xxx.description=Description du rapport
    60 
    +report.xxx.columns=En-têtes des colonnes du rapport (séparées par des virgules) [Optionnel]
    61 
    +report.xxx.rows=En-têtes des lignes du rapport (séparées par des virgules) [Optionnel]
    62 
    +```
    63 
    +
    64 
    +```report.xxx.modelType``` permet de définir le domaine métier sur lequel porte le rapport, valeurs possibles :
    65 
    +
    66 
    +* **PS** pour le domaine *Senne*
    67 
    +* **LL** pour le domaine *Palangre*.
    68 
    +
    69 
    +En *V10*, on ajoutera certainement **COMMON** pour le domaine métier des marées agnostiques.
    70 
    +
    71 
    +```report.xxx.name``` permet de définir le nom du rapport, ce texte est celui affiché dans la liste déroulante des
    72 
    +rapports à sélectionner dans l'assistant.
    73 
    +
    74 
    +```report.xxx.description``` permet de définir une description longue d'un rapport, ce texte est celui affiché
    75 
    +comme description lorsqu'un rapport est sélectionné dans l'assistant.
    76 
    +
    77 
    +```report.xxx.colomns``` **[Optionnel]** permet de définir les en-têtes de colonnes de manière fixe.
    78 
    +
    79 
    +```report.xxx.rows``` **[Optionnel]** permet de définir les en-têtes de lignes de manière fixe.
    80 
    +
    81 
    +Il est possible de ne pas les indiquer si le rapport n'a pas d'en-têtes de colonnes ou de lignes fixes; Ces en-têtes
    82 
    +seront alors définies via les requêtes du rapport.
    83 
    +
    84 
    +### Variables d'un rapport
    85 
    +
    86 
    +Dans notre premier exemple, il n'y avait pas de variable (mais des variables de répétition). La syntaxe de ces deux
    87 
    +notions est exactement la même, au détail près qu'une variable est préfixée par ```variable``` alors qu'une variable de
    88 
    +répétition est préfixée par ```repeatVariable```.
    89 
    +
    90 
    +Comme indiqué dans le préambule, l'ordre de description des variables importe, cet ordre sera utilisé pour :
    91 
    +
    92 
    +* afficher les variables dans l'interface graphique,
    93 
    +* effectuer le calcul de l'univers des variables (dans le cas où des variables sont inter-dépendantes).
    94 
    +
    95 
    +**À noter que l'outil de rapport utilise uniquement l'ordre induit dans la description du rapport, si par exemple la
    96 
    +première variable était dépendante de la seconde, alors le rapport ne pourra jamais être exécuté puisque la première
    97 
    +variable attend que la seconde soit remplie...**
    98 
    +
    99 
    +Pour décrire une variable trois lignes sont nécessaires, comme on peut le voir dans l'exemple suivant :
    100 
    +
    101 
    +```properties
    102 
    +report.xxx.variable.1.name=speciesGroup
    103 
    +report.xxx.variable.1.type=fr.ird.observe.dto.referential.common.SpeciesGroupReference
    104 
    +report.xxx.variable.1.request=Select distinct sg \
    105 
    +From TripImpl t \
    106 
    +Join t.routeObs r \
    107 
    +Join r.activity a \
    108 
    +Join a.set c \
    109 
    +Join c.catches ca with ca.totalCount Is Not Null Or ca.catchWeight Is Not Null \
    110 
    +Join ca.species e \
    111 
    +Join e.speciesGroup sg \
    112 
    +Where t.id In :tripId \
    113 
    +Order By sg.code
    114 
    +```
    115 
    +
    116 
    +```report.xxx.variable.1.name``` définit l'*alias* de la variable que l'on pourra ensuite utiliser dans le
    117 
    +reste de la définition du rapport (par exemple dans d'autres variables, variables de répétition, requêtes ou opérations).
    118 
    +
    119 
    +```report.xxx.variable.1.type``` définit le type de la variable. Ce type doit être un type de *dto* ou une
    120 
    +*référence de dto*. On ne peut pas ici utiliser un type d'*entité*, puisque l'interface graphique (selon le principe de
    121 
    +séparation des couches) n'a pas connaissance du modèle des entités.
    122 
    +
    123 
    +Techniquement, chaque type d'entité possède son type de *dto* et chaque type de *dto* possède un type de *référence*.
    124 
    +
    125 
    +La notion de référence est utilisée dans l'application partout où l'on utilise des listes déroulantes, mais aussi dans
    126 
    +l'arbre de navigation; la notion de *dto* étant utilisée au niveau d'un formulaire.
    127 
    +
    128 
    +À partir d'un type de référence, l'application est capable d'en déduire :
    129 
    +
    130 
    +* le nom de la donnée à afficher
    131 
    +* comment décorer la donnée
    132 
    +* comment transformer l'entité
    133 
    +
    134 
    +```report.xxx.variable.1.request``` définit la requête **hql** pour récupérer l'univers des valeurs de
    135 
    +la variable.
    136 
    +
    137 
    +Il est possible de documenter cette variable en utilise une quatrième ligne optionnelle :
    138 
    +
    139 
    +```properties
    140 
    +report.xxx.variable.1.comment=Un commentaire optionnel pour documenter la variable
    141 
    +```
    142 
    +
    143 
    +**À noter que l'utilisation d'une variable dans le reste du rapport se fait toujours via son identifiant technique
    144 
    +(*topiaId*), ce qui ne sera pas le cas d'une variable de répétition qui elle utilisera toujours le type décrit.**
    145 
    +
    146 
    +**À noter aussi que l'on peut utiliser pour décrire une variable, de la variable spéciale *tripId* qui reflète la
    147 
    +sélection des marées sur lequel on veut appliquer le rapport**.
    148 
    +
    149 
    +Voici un second exemple de deux variables dont la seconde utilise la première :
    150 
    +
    151 
    +```properties
    152 
    +report.xxx.variable.1.name=discardMode
    153 
    +report.xxx.variable.1.type=fr.ird.observe.dto.data.ps.observation.SpeciesFateDiscardModeDto
    154 
    +report.xxx.variable.1.request=Select distinct new fr.ird.observe.dto.data.ps.observation.SpeciesFateDiscardModeDto(sf.discard) \
    155 
    +From TripImpl t \
    156 
    +Join t.routeObs r \
    157 
    +Join r.activity a \
    158 
    +Join a.set c \
    159 
    +Join c.catches ca with ca.totalCount Is Not Null \
    160 
    +Join ca.speciesFate sf \
    161 
    +Where t.id In :tripId \
    162 
    +Order By sf.discard
    163 
    +report.xxx.variable.2.name=speciesGroup
    164 
    +report.xxx.variable.2.type=fr.ird.observe.dto.referential.common.SpeciesGroupReference
    165 
    +report.xxx.variable.2.request=Select distinct sg \
    166 
    +From TripImpl t \
    167 
    +Join t.routeObs r \
    168 
    +Join r.activity a \
    169 
    +Join a.set c \
    170 
    +Join c.catches ca with ca.totalCount Is Not Null \
    171 
    +Join ca.speciesFate sf with sf.discard = :discardMode \
    172 
    +Join ca.species e \
    173 
    +Join e.speciesGroup sg \
    174 
    +Where t.id In :tripId \
    175 
    +Order By sg.code
    176 
    +```
    177 
    +
    178 
    +Cet exemple est intéressant car il nous permet de voir comment utiliser un type qui ne reflète pas exactement une entité.
    179 
    +
    180 
    +Ici **SpeciesFateDiscardModeDto** est un objet que l'on a ajouté dans le code de l'application pour refléter les différents modes de captures :
    181 
    +* conservé (sf.discard = ```false```)
    182 
    +* rejeté (sf.discard = ```true```)
    183 
    +* non connu (sf.discard = ```NULL```)
    184 
    +
    185 
    +### Variables de répétition d'un rapport
    186 
    +
    187 
    +Comme indiqué plus haut, la syntaxe d'une variable de répétition est identique à celle d'une simple variable.
    188 
    +
    189 
    +Pour décrire une variable de répétition, trois lignes sont nécessaires, comme on peut le voir dans l'exemple suivant :
    190 
    +
    191 
    +```properties
    192 
    +report.xxx.repeatVariable.1.name=gearUseFeaturesId
    193 
    +report.xxx.repeatVariable.1.type=java.lang.String
    194 
    +report.xxx.repeatVariable.1.request=Select g.id \
    195 
    +From fr.ird.observe.entities.data.ll.common.TripImpl m \
    196 
    +Join m.gearUseFeatures g \
    197 
    +Where \
    198 
    +m.id In :tripId \
    199 
    +and g in elements (m.gearUseFeatures) \
    200 
    +Order By g.gear.label2
    201 
    +```
    202 
    +
    203 
    +```report.xxx.repeatVariable.1.name``` définit l'*alias* de la variable de répétition à utiliser dans une requête, autre variable de répétition ou opération
    204 
    +
    205 
    +```report.xxx.repeatVariable.1.type``` définit le type de la variable de répétition. Contrairement aux variables, les
    206 
    +variables de répétition sont utilisées en interne pour exécuter le rapport, on peut donc utiliser directement des types d'*entité*,
    207 
    +ou bien des types *simples* qui correspondent aux types d'une colonne en base (**java.lang.String**, **java.lang.Float**, ...)
    208 
    +
    209 
    +**À noter que contrairement aux variables, ici le type de la donnée sera toujours utilisé tel quel dans les autres requêtes :
    210 
    +si on définit une variable de type *entité*, c'est bien l'entité qui sera injectée dans la requête *hql*, et non pas juste son identifiant technique.**
    211 
    +
    212 
    +```report.xxx.repeatVariable.1.request``` définit la requête **hql** pour récupérer l'univers des valeurs de la variable de répétition
    213 
    +
    214 
    +Il est possible d'utiliser dans une requête de variable de répétition, un alias sur toute variable du rapport (dont la
    215 
    +variable spéciale **tripId**), ainsi que tout autre alias de variable de répétition.
    216 
    +
    217 
    +**À noter que l'outil de rapport utilise uniquement l'ordre induit dans la description du rapport, si par exemple la
    218 
    +première variable de répétition était dépendante de la seconde, alors le rapport ne pourra jamais être exécuté puisque la
    219 
    +première variable attend que l'univers de la seconde soit calculée...**
    220 
    +
    221 
    +On peut aussi ajouter une ligne supplémentaire pour indiquer que l'on veut rajouter la valeur **nulle** dans
    222 
    +l'univers de cette variable de répétion, ce qui peut etre utilise (et nous nous en servons), mais que nous ne pouvons
    223 
    +pas décrire via la requete *hql.
    224 
    +
    225 
    +```properties
    226 
    +report.xxx.repeatVariable.1.addNull=true
    227 
    +```
    228 
    +
    229 
    +Il est possible de documenter cette variable de répétition en utilisant une ligne optionnelle :
    230 
    +
    231 
    +```properties
    232 
    +report.xxx.repeatVariable.1.comment=Un commentaire optionnel pour documenter la variable de répétition
    233 
    +```
    234 
    +
    235 
    +### requêtes d'un rapport
    236 
    +
    237 
    +On distingue deux types de requêtes :
    238 
    +
    239 
    +* des requêtes *simples*
    240 
    +* des requêtes utilisant une variable de répétition (pour celles-ci on doit décrire en plus alors la variable de répétition à utiliser)
    241 
    +
    242 
    +Les deux types de requêtes nécessitent les trois lignes, comme décrit dans l'exemple suivant :
    243 
    +
    244 
    +```properties
    245 
    +report.xxx.request.1.location=0,0
    246 
    +report.xxx.request.1.layout=row
    247 
    +report.xxx.request.1.request=Select \
    248 
    +concat(CASE When g.gear.code IS NULL Then 'Aucun code' Else  g.gear.code End, ' - ', g.gear.label2), \
    249 
    +g.number, \
    250 
    +( CASE g.usedInTrip When true Then 'Oui' Else Case g.usedInTrip When false Then 'Non' Else 'Indéterminé' End End )\
    251 
    +From fr.ird.observe.entities.data.ll.common.GearUseFeaturesImpl g \
    252 
    +Where g.id = :gearUseFeaturesId
    253 
    +```
    254 
    +
    255 
    +```report.xxx.request.1.location``` définit la position dans le résultat final où positionner le résultat de cette requête.
    256 
    +
    257 
    +```report.xxx.request.1.layout``` définit la disposition à utiliser pour placer le résultat de cette requête dans le résultat final. Deux valeurs sont possibles :
    258 
    +
    259 
    +* **row** pour signifier que le résultat de la requête sera positionné en ligne à partir de la position précedemment définie. Ce mode correspond exactement au resultat de la requête.
    260 
    +* **column** pour signifier que le résultat de la requête sera positionné en colonne à partir de la position précedemment définie. Ce mode est une transposition du résultat de la requête : une ligne du résultat de la requête sera une colonne dans le résultat final
    261 
    +
    262 
    +```report.xxx.request.1.request``` définit le code **hql** qui permet de construire le résultat à placer ensuite dans le résultat final du rapport
    263 
    +
    264 
    +Pour une requête avec variable de répétition, il faut alors ajouter les deux lignes suivantes :
    265 
    +
    266 
    +```properties
    267 
    +report.xxx.request.1.repeat.name=gearUseFeaturesId
    268 
    +report.xxx.request.1.repeat.layout=column
    269 
    +```
    270 
    +
    271 
    +```report.xxx.request.1.repeat.name``` définit l'*alias* de la variable de répétition à utiliser. La requête sera exécutée
    272 
    +autant de fois qu'il y a de valeurs dans l'univers calculé de la variable de répétition.
    273 
    +
    274 
    +**À noter qu'il faut alors que le corps de cette requête doit utiliser l'alias de cette variable de répétition, même si dans les faits, rien ne l'oblige, mais le résultat sera alors toujours le même...**
    275 
    +
    276 
    +```report.xxx.request.1.repeat.layout``` définit la disposition à utiliser pour constuire le résultat final de la requête appliqué à chaque valeur de la variable de répétition. Deux valeurs sont possibles :
    277 
    +
    278 
    +* **row** pour signifier que pour chaque valeur de l'univers de la variable de répétition, le résultat de la requête sera positionné sur la même ligne;
    279 
    +* **column** pour signifier que pour chaque valeur de l'univers de la variable de répétition, le résultat de la requête sera positionné sur la même colonne.
    280 
    +
    281 
    +**À noter qu'aucune vérification n'est effectuée sur la cohérence entre la disposition de la requête et la disposition
    282 
    +de la variable de répétition. On peut alors obtenir un résultat final de la requête incohérent si les dispositions ne sont pas compatibles.**
    283 
    +
    284 
    +Il est possible de documenter cette requête en utilisant une ligne optionnelle :
    285 
    +
    286 
    +```properties
    287 
    +report.xxx.request.1.comment=Un commentaire optionnel pour documenter la requête
    288 
    +```
    289 
    +
    290 
    +### Opérations d'un rapport
    291 
    +
    292 
    +On distingue deux types d'opérations :
    293 
    +
    294 
    +* celles sans paramétrage (une seule ligne est alors nécessaire)
    295 
    +* celles savec paramétrage (dans ce cas deux lignes sont nécessaires pour la décrire).
    296 
    +
    297 
    +Les deux types d'opération nécessitent une première ligne pour déclarer le type d'opération à exécuter, comme décrit
    298 
    +dans l'exemple suivant :
    299 
    +
    300 
    +```properties
    301 
    +report.xxx.operations.1.type=SumIntRow
    302 
    +```
    303 
    +
    304 
    +```report.xxx.operations.1.type``` définit le type d'opération à réaliser.
    305 
    +
    306 
    +Dans le cas où l'opération est paramétrable, on doit alors ajouter une autre ligne avec le paramétrage de l'opération :
    307 
    +
    308 
    +```properties
    309 
    +report.xxx.operations.1.parameters=0|1
    310 
    +```
    311 
    +
    312 
    +```report.xxx.operations.1.parameters``` définit le paramétrage à utiliser pour exécuter l'opération.
    313 
    +
    314 
    +Il est possible de documenter cette opération en utilisant une ligne optionnelle :
    315 
    +
    316 
    +```properties
    317 
    +report.xxx.operations.1.comment=Un commentaire optionnel pour documenter l'opération
    318 
    +```
    319 
    +
    320 
    +Les opérations disponibles et leur documentation sont décrites dans le document [suivant](./embedded-operations.html).
    321 
    +
    322 
    +## Pour aller plus loin
    323 
    +
    324 
    +Vous pouvez aussi consulter la [documentation des rapports embarqués par l'application](./embedded-reports.html).

  • src/site/site_fr.xml
    ... ... @@ -86,6 +86,11 @@
    86 86 
             <item name="Configuration (fichier d'exemple)" target="_blank" href="./observe-client.conf"/>
    87 87 
             <item name="Filtrage des référentiels" href="./referential-filter.html"/>
    88 88 
             <item name="Synchronisation référentiel avancée" href="./synchro-referential.html"/>
    89 
    +        <item name="Outil de reporting" href="./report/index.html">
    90 
    +          <item name="Syntaxe d'un rapport" href="./report/syntax.html"/>
    91 
    +          <item name="Opérations disponibles pour un rapport" href="./report/embedded-operations.html"/>
    92 
    +          <item name="Rapports embarqués dans l'application" href="./report/embedded-reports.html"/>
    93 
    +        </item>
    89 94 
           </item>
    90 95 
           <item name="Server">
    91 96 
             <item name="Administration Web v9" href="server-configuration-application.html"/>

  • toolkit/api-report/src/main/java/fr/ird/observe/report/operations/GroupByLength.java deleted
    1 
    -package fr.ird.observe.report.operations;
    2 
    -
    3 
    -/*-
    4 
    - * #%L
    5 
    - * ObServe Toolkit :: API :: Report
    6 
    - * %%
    7 
    - * Copyright (C) 2008 - 2023 IRD, Ultreia.io
    8 
    - * %%
    9 
    - * This program is free software: you can redistribute it and/or modify
    10 
    - * it under the terms of the GNU General Public License as
    11 
    - * published by the Free Software Foundation, either version 3 of the
    12 
    - * License, or (at your option) any later version.
    13 
    - *
    14 
    - * This program is distributed in the hope that it will be useful,
    15 
    - * but WITHOUT ANY WARRANTY; without even the implied warranty of
    16 
    - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17 
    - * GNU General Public License for more details.
    18 
    - *
    19 
    - * You should have received a copy of the GNU General Public
    20 
    - * License along with this program.  If not, see
    21 
    - * <http://www.gnu.org/licenses/gpl-3.0.html>.
    22 
    - * #L%
    23 
    - */
    24 
    -
    25 
    -import com.google.auto.service.AutoService;
    26 
    -import fr.ird.observe.report.Report;
    27 
    -import fr.ird.observe.report.ReportOperationConsumer;
    28 
    -import fr.ird.observe.report.ReportRequestExecutor;
    29 
    -import io.ultreia.java4all.util.matrix.DataMatrix;
    30 
    -
    31 
    -import java.util.HashSet;
    32 
    -import java.util.LinkedHashMap;
    33 
    -import java.util.Map;
    34 
    -import java.util.Set;
    35 
    -import java.util.concurrent.atomic.AtomicInteger;
    36 
    -
    37 
    -/**
    38 
    - * Created on 21/09/2021.
    39 
    - *
    40 
    - * @author Tony Chemit - dev@tchemit.fr
    41 
    - * @since 5.0.44
    42 
    - */
    43 
    -@AutoService(ReportOperationConsumer.class)
    44 
    -public class GroupByLength implements ReportOperationConsumer {
    45 
    -
    46 
    -    @Override
    47 
    -    public DataMatrix consume(String parameters, ReportRequestExecutor requestExecutor, Report report, Set<String> tripId, DataMatrix incoming) {
    48 
    -        // Première passe pour grouper par classe de taille
    49 
    -        Map<String, AtomicInteger> data = new LinkedHashMap<>();
    50 
    -        for (int row = 0, nbRows = incoming.getHeight(); row < nbRows; row++) {
    51 
    -            String length = (String) incoming.getValue(0, row);
    52 
    -            int count = Integer.parseInt(incoming.getValue(1, row).toString());
    53 
    -            AtomicInteger mutableInt = data.computeIfAbsent(length, k -> new AtomicInteger());
    54 
    -            mutableInt.addAndGet(count);
    55 
    -        }
    56 
    -        // Deuxième passe pour remplir la matrice
    57 
    -        Set<String> lengths = new HashSet<>();
    58 
    -        for (int row = 0; row < incoming.getHeight(); row++) {
    59 
    -            lengths.add((String) incoming.getValue(0, row));
    60 
    -        }
    61 
    -        DataMatrix result = createTmpMatrix(0, incoming.getHeight(), incoming.getWidth(), lengths.size());
    62 
    -        int row = 0;
    63 
    -        for (Map.Entry<String, AtomicInteger> entry : data.entrySet()) {
    64 
    -            String length = entry.getKey();
    65 
    -            AtomicInteger mutableInt = entry.getValue();
    66 
    -            result.setValue(0, row, length);
    67 
    -            result.setValue(1, row, mutableInt.intValue());
    68 
    -            row++;
    69 
    -        }
    70 
    -        return result;
    71 
    -    }
    72 
    -}

  • toolkit/api-report/src/main/java/fr/ird/observe/report/operations/SumFloatColumn.java deleted
    1 
    -package fr.ird.observe.report.operations;
    2 
    -
    3 
    -/*-
    4 
    - * #%L
    5 
    - * ObServe Toolkit :: API :: Report
    6 
    - * %%
    7 
    - * Copyright (C) 2008 - 2023 IRD, Ultreia.io
    8 
    - * %%
    9 
    - * This program is free software: you can redistribute it and/or modify
    10 
    - * it under the terms of the GNU General Public License as
    11 
    - * published by the Free Software Foundation, either version 3 of the
    12 
    - * License, or (at your option) any later version.
    13 
    - *
    14 
    - * This program is distributed in the hope that it will be useful,
    15 
    - * but WITHOUT ANY WARRANTY; without even the implied warranty of
    16 
    - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17 
    - * GNU General Public License for more details.
    18 
    - *
    19 
    - * You should have received a copy of the GNU General Public
    20 
    - * License along with this program.  If not, see
    21 
    - * <http://www.gnu.org/licenses/gpl-3.0.html>.
    22 
    - * #L%
    23 
    - */
    24 
    -
    25 
    -import com.google.auto.service.AutoService;
    26 
    -import fr.ird.observe.report.ReportOperationConsumer;
    27 
    -import io.ultreia.java4all.util.matrix.DataMatrix;
    28 
    -import org.apache.logging.log4j.LogManager;
    29 
    -import org.apache.logging.log4j.Logger;
    30 
    -
    31 
    -import java.io.Serializable;
    32 
    -
    33 
    -/**
    34 
    - * Created on 21/09/2021.
    35 
    - *
    36 
    - * @author Tony Chemit - dev@tchemit.fr
    37 
    - * @since 5.0.44
    38 
    - */
    39 
    -@AutoService(ReportOperationConsumer.class)
    40 
    -public class SumFloatColumn extends SumColumn implements ReportOperationConsumer {
    41 
    -    private static final Logger log = LogManager.getLogger(SumFloatColumn.class);
    42 
    -
    43 
    -    @Override
    44 
    -    protected Object getSumColumn(int column, int x, DataMatrix incoming) {
    45 
    -        double result = 0d;
    46 
    -        int nbRows = incoming.getHeight();
    47 
    -        for (int row = 0; row < nbRows; row++) {
    48 
    -            Serializable o = incoming.getValue(column, row);
    49 
    -            if (o == null || "null".equals(o)) {
    50 
    -                o = 0;
    51 
    -            }
    52 
    -            try {
    53 
    -                Integer.valueOf(o.toString());
    54 
    -                // real int, don't want it
    55 
    -                return "-";
    56 
    -
    57 
    -            } catch (NumberFormatException ignored) {
    58 
    -            }
    59 
    -            double d;
    60 
    -            try {
    61 
    -                d = Double.parseDouble(o.toString());
    62 
    -            } catch (NumberFormatException e) {
    63 
    -                // une des données de la colonne n'est pas un count on sort directement
    64 
    -                log.debug(String.format("Could not convert %s to number", o), e);
    65 
    -                return "-";
    66 
    -            }
    67 
    -            result += d;
    68 
    -        }
    69 
    -        // FIXME Should we serve a float ?
    70 
    -        return (int) result;
    71 
    -    }
    72 
    -}

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