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

Commits:

6 changed files:

Changes:

  • 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 
    +**TODO**
    \ No newline at end of file

  • src/site/markdown/report/embedded-reports.md
    1 
    +# Documentation des rapports embarqués par l'application
    2 
    +
    3 
    +**TODO**
    \ 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; concretement cela va ajouter une liste déroulante dans l'interface graphique, l'utilisateur devra
    28 
    +alors choisir une valeur parmis celles calculées 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.
    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éfinie 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 chainé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 chainé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 à joueur ainsi que les opérations 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.
    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 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épendant 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 embarques 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 globale.
    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 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-tetes des colonnes du rapport (séparées par des virgules) [Optionnel]
    61 
    +report.xxx.rows=En-tetes 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 les 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'assitant.
    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'assitant.
    76 
    +
    77 
    +```report.xxx.colomns``` **[Optionnel]** permet de définir les en-tetes de colonnes de manière fixe.
    78 
    +
    79 
    +```report.xxx.rows``` **[Optionnel]** permet de définir les en-tetes de lignes de manière fixe.
    80 
    +
    81 
    +Il est possible de ne pas les indiquer si le rapport n'a pas d'en-tetes de colonnes ou de lignes fixes; Ces en-tetes
    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 est important, 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 
    +* le nom de la donnée à afficher
    130 
    +* comment décorer la donnée
    131 
    +* comment transformer l'entité
    132 
    +
    133 
    +```report.xxx.variable.1.request``` définit la requête **hql** pour récupérer l'univers des valeurs de
    134 
    +la variable.
    135 
    +
    136 
    +Il est possible de documenter cette variable en utilise une quatrième ligne optionnelle :
    137 
    +
    138 
    +```properties
    139 
    +report.xxx.variable.1.comment=Un commentaire optionnel pour documenter la variable
    140 
    +```
    141 
    +
    142 
    +**À noter que l'utilisation d'une variable dans le reste du rapport se fait toujours via son identifiant technique
    143 
    +(*topiaId*), ce qui ne sera pas le cas d'une variable de répétition qui elle utilisera toujours le type décrit.**
    144 
    +
    145 
    +**À noter aussi que l'on peut utiliser pour décrire une variable, de la variable spéciale *tripId* qui reflète la
    146 
    +sélection des marées sur lequel on veut appliquer le rapport**.
    147 
    +
    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 la seconde soit calculée...**
    220 
    +
    221 
    +Il est possible de documenter cette variable de répétition en utilisant une ligne optionnelle :
    222 
    +
    223 
    +```properties
    224 
    +report.xxx.repeatVariable.1.comment=Un commentaire optionnel pour documenter la variable de répétition
    225 
    +```
    226 
    +
    227 
    +### requêtes d'un rapport
    228 
    +
    229 
    +On distingue deux types de requêtes :
    230 
    +
    231 
    +* des requêtes *simples*
    232 
    +* 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)
    233 
    +
    234 
    +Les deux types de requêtes nécessitent les trois lignes, comme décrit dans l'exemple suivant :
    235 
    +
    236 
    +```properties
    237 
    +report.xxx.request.1.location=0,0
    238 
    +report.xxx.request.1.layout=row
    239 
    +report.xxx.request.1.request=Select \
    240 
    +concat(CASE When g.gear.code IS NULL Then 'Aucun code' Else  g.gear.code End, ' - ', g.gear.label2), \
    241 
    +g.number, \
    242 
    +( CASE g.usedInTrip When true Then 'Oui' Else Case g.usedInTrip When false Then 'Non' Else 'Indéterminé' End End )\
    243 
    +From fr.ird.observe.entities.data.ll.common.GearUseFeaturesImpl g \
    244 
    +Where g.id = :gearUseFeaturesId
    245 
    +```
    246 
    +
    247 
    +```report.xxx.request.1.location``` définit la position dans le résultat final où positionner le résultat de cette requête.
    248 
    +
    249 
    +```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 :
    250 
    +
    251 
    +* **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
    252 
    +* **column** pour signifier que le résultat de la requête sera positionne 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
    253 
    +
    254 
    +```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
    255 
    +
    256 
    +Pour une requête avec variable de répétition, il faut alors ajouter les deux lignes suivantes :
    257 
    +
    258 
    +```properties
    259 
    +report.xxx.request.1.repeat.name=gearUseFeaturesId
    260 
    +report.xxx.request.1.repeat.layout=column
    261 
    +```
    262 
    +
    263 
    +```report.xxx.request.1.repeat.name``` définit le nom de la variable de répétition à utiliser. La requête sera exécutée
    264 
    +autant de fois qu'il y a de valeurs dans l'univers calculé de la variable de répétition.
    265 
    +
    266 
    +**À 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...**
    267 
    +
    268 
    +```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 :
    269 
    +
    270 
    +* **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;
    271 
    +* **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.
    272 
    +
    273 
    +**À noter qu'aucune vérification n'est effectuée sur la cohérence entre la disposition de la requête et la disposition
    274 
    +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.**
    275 
    +
    276 
    +Il est possible de documenter cette requête en utilisant une ligne optionnelle :
    277 
    +
    278 
    +```properties
    279 
    +report.xxx.request.1.comment=Un commentaire optionnel pour documenter la requête
    280 
    +```
    281 
    +
    282 
    +### Opérations d'un rapport
    283 
    +
    284 
    +On distingue deux types d'opérations :
    285 
    +
    286 
    +* celles sans paramétrage (une seule ligne est alors nécessaire)
    287 
    +* celles savec paramétrage (dans ce cas deux lignes sont nécessaires pour la décrire).
    288 
    +
    289 
    +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
    290 
    +dans l'exemple suivant :
    291 
    +
    292 
    +```properties
    293 
    +report.xxx.operations.1.type=SumIntRow
    294 
    +```
    295 
    +
    296 
    +```report.xxx.operations.1.type``` définit le type d'opération à réaliser.
    297 
    +
    298 
    +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 :
    299 
    +
    300 
    +```properties
    301 
    +report.xxx.operations.1.parameters=0|1
    302 
    +```
    303 
    +
    304 
    +```report.xxx.operations.1.parameters``` définit alors le paramétrage à utiliser pour exécuter l'opération.
    305 
    +
    306 
    +Il est possible de documenter cette opération en utilisant une ligne optionnelle :
    307 
    +
    308 
    +```properties
    309 
    +report.xxx.operations.1.comment=Un commentaire optionnel pour documenter l'opération
    310 
    +```
    311 
    +
    312 
    +Les opérations disponibles et leur documentation est décrite dans le document [suivant](./embedded-operations.html).
    313 
    +
    314 
    +## Pour aller plus loin
    315 
    +
    316 
    +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"/>

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