Ce module propose une vue unique des fiches de différents annuaires. Les fiches affichées par cette vue peuvent ensuite être filtrées grâce à différents filtres ainsi que par une barre de recherche qui permet de rechercher directement un terme présent parmis les réponses d'une fiche.
Il est possible de cliquer sur chacune des lignes du tableau afin d'accéder au détail de la fiche concernée. On accède alors à toutes les informations de la fiche ainsi qu'à la possibilité de réaliser diverses actions en fonction de celles associées au workflow auquel la fiche est liée.
Il est possible de modifier les templates des tâches pour une action du workflow afin de lui indiquer s'il faut revenir sur la page de la fiche de l'annuaire ou sur la liste de toutes les fiches une fois l'action exécutée. La page de retour de l'action par défaut sera la page de la fiche sur laquelle l'action a été faite.
Tous les éléments de la vue sont configurables via le fichier de contexte du module. Pour ce faire, il suffit d'ajouter le bean correspondant à l'élément voulu dans le fichier de contexte du module souhaitant modifier le tableau.
Il existe plusieurs types d'éléments:
Les panneaux
Les panneaux permettent de basculer la vue d'un mode à l'autre en cliquant directement sur l'onglet qui lui est associé en haut du tableau. Un panneau contient un ensemble d'initialiseurs de panneaux qui seront appliqués automatiquement sur la vue lorsque celui-ci sera activé. Il doit toujours y avoir un panneau de définit dans un fichier de contexte, si ce n'est pas le cas, le tableau ne s'affichera pas.
Les initialiseurs de panneaux
Ce sont les éléments qui rajouteront des conditions à appliquer lorsqu'un panneau sera sélectionné afin de restreindre les fiches à afficher dans la vue à l'ensemble voulu. Ces éléments n'ont aucune partie graphique et ne peuvent pas être modifié via l'IHM.
Les colonnes
Les colonnes représentent les éléments centraux du tableau. Ce sont elles qui contiennent les informations des fiches à afficher à l'utilisateur. Chaque colonne affiche une information particulière de la fiche (par exemple l'annuaire auquel elle est rattachée, ou sa date de création). Si aucune colonne n'est définie dans un fichier de contexte, le tableau ne s'affichera pas.
Les filtres
Les filtres conditionnent les fiches à sélectionner pour l'affichage dans le tableau. Ils correspondent à des listes déroulantes de valeurs liées à un élément particulier d'une fiche (par exemple le nom de l'annuaire auquelle la fiche est rattachée). Les filtres se situent au-dessus des panneaux.
Il existe deux catégories de filtres:
Les valeurs de filtres peuvent varier. Certains possèdent des valeurs fixes définies à partir des informations contenues dans les fiches obtenues par le panneau n'utilisant pas d'initialiseurs et sans qu'aucun filtre n'ai de valeurs sélectionnées. D'autres possèdent des valeurs indépendantes des fiches affichées (par exemple le filtre sur les annuaires qui permettra de filtrer sur tous les annuaires existant en base même si ceux-ci n'ont pas de fiche asociée). D'autres encore possèdent des valeurs conditionnées par d'autre filtre (par exemple le filtre sur l'état d'un workflow qui n'apparaît que lorsqu'une valeur a été choisie pour le filtre sur l'annuaire).
Il est tout à fait possible de n'avoir aucun filtre sur la vue du tableau.
Prérequis : la configuration des différents workflow utilisés ainsi que des annuaires doit être en place.
Chaque élément du tableau définit dans la partie "Introduction" nécessite une configuration particulière. Il existe divers types d'objets à implémenter pour pouvoir configurer correctement les éléments du tableau.
Les configurations
Il existe plusieurs types d'objets à utiliser pour faire de la configuration:
Configuration des panneaux: fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.configuration.RecordPanelConfiguration
Cette configuration est associée à un objet de type fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.IRecordPanel. Elle possède toutes les informations liées à un panneau:
Configuration des filtres: fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.configuration.RecordFilterConfiguration
Cette configuration est associée à un objet de type fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.IRecordFilter. Elle possède toutes les informations liées à un filtre pour son affichage à l'IHM:
Configuration des filtres liés à des valeurs d'entrées d'annuaire: fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.configuration.RecordFilterEntryConfiguration
Cette configuration est aussi associé à un objet de type de filtre mais pour un filtre lié à des entrées d'annuaire. Elle hérite de fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.configuration.RecordFilterConfiguration mais possède en plus un objet de type fr.paris.lutece.plugins.directory.modules.multiview.business.record.column.IRecordColumn. C'est l'objet IRecordColumn qui contient la liste des entrées sur lesquelles le filtre doit se baser pour retrouver les différentes valeurs sur lesquelles l'utilisateur va pouvoir filtrer les fiches à afficher à l'IHM.
Note: toutes les configurations doivent être définies en tant que bean dans le fichier de contexte.
Les QueryParts
Les objets de types QueryParts servent à rajouter des parties de requête SQL qui seront utilisées pour construire la requête globale qui servira à récupérer toutes les fiches du tableau. Il existe plusieurs types de QueryParts en fonction de l'élément sur lequel elle se base:
Les affichages
Les objects gérant les affichages sont utilisés pour récupérer les informations contenues and la requête pour les donner à l'objet qu'il représente (afin de construire la partie de requête associée plus tard) et de construire leurs templates. Il existe plusieurs types d'objets gérant les affichagaes en fonction du type de l'élément sur lequel il se base:
Les Factories
Il existe deux types de Factories:
les Factories liées aux objets de types "QueryParts": ces Factories sont utilisées au moment de la construction de la requête globale qui sera exécutée pour retrouver toutes les fiches à afficher dans le tableau. Il existe un type de Factory lié à chaque type d'élément du tableau:
Chaque Factory de QueryPart récupérera l'élément du type dont elle est associée et elle retrouvera les parties de requête à utiliser.
les Factories liées aux affichages des éléments: ces Factories servent à construire les objets liés aux affichages des éléments dont ils sont associés. Il existe plusieurs types de ces Factories en fonction du type dont il appartient:
Note: toutes les Factories doivent être définies en tant que bean dans le fichier de contexte.
Il est possible d'effectuer une recherche par terme sur une fiche via la barre de recherche. Pour qu'elle fonctionne correctement, il est nécessaire que les fiches des annuaires soient au préalable indexées.
Nous allons maintenant détailler comment créer chacun des différents éléments de la partie "Introduction" avec les composants définis dans la partie "Configuration".
Les panneaux
Pour définir un nouveau panneau il suffit d'ajouter une nouvelle implémentation de l'interface fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.IRecordPanel ou d'hériter de la classe abstraite fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.impl.AbstractRecordPanel pour n'avoir qu'à implémenter les méthodes spécifiques à chaque panneau. Il est ensuite nécessaire de lui donner une RecordPanelConfiguration à utiliser.
Un exemple complet de déclaration d'un panneau sera de la forme:
<bean id="directory-multiview.panelRecords" class="fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.impl.RecordPanelRecords"> <constructor-arg name="recordPanelConfiguration" type="fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.configuration.RecordPanelConfiguration" ref="directory-multiview.recordsPanel.panelConfiguration"/> </bean>
La configuration à définir sera de la forme:
<bean id="directory-multiview.recordsPanel.panelConfiguration" class="fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.configuration.RecordPanelConfiguration"> <constructor-arg name="strTechnicalCode" type="java.lang.String" value="records"/> <constructor-arg name="nPosition" type="int" value="1"/> <constructor-arg name="strTitle" type="java.lang.String" value="Démarche(s)"/> <constructor-arg name="listRecordPanelInitializer"> <list value-type="fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.initializer.IRecordPanelInitializer"> <ref bean="directory-multiview.recordPanelInitializer.panelDirectory"/> <ref bean="directory-multiview.recordPanelInitializer.panelRecords"/> <ref bean="directory-multiviewgra.recordPanelInitializer.panelMyUnitAssignment"/> </list> </constructor-arg> </bean>
Comme cela a été détaillé plus haut, la configuration contient toutes les informations liées au panneau dont la liste des initialiseurs de panneau qui lui sont propres. La création d'un initialiseur de panneau sera expliquée ci-après.
Il reste ensuite à faire une implémentation de la partie gérant l'affichage du panneau. Pour ce faire, il suffit d'implémenter l'interface fr.paris.lutece.plugins.directory.modules.multiview.web.record.panel.display.IRecordPanelDisplay ou d'hériter de la classe fr.paris.lutece.plugins.directory.modules.multiview.web.record.panel.display.impl.AbstractRecordPanelDisplay. Il est conseillé d'hériter de la classe abstraite plutôt que d'implémenter directement l'interface.
La classe fr.paris.lutece.plugins.directory.modules.multiview.web.record.panel.display.impl.RecordPanelRecordsDisplay est un exemple d'implémentation de cette interface.
Note: Il n'est pas nécessaire de déclarer ce bean dans le fichier de contexte du plugin.
Ces informations permettent de créer un nouveau type de panneau ainsi qu'un panneau de ce type. Pour créer un panneau d'un type existant il suffit de déclarer un bean correspondant à la configuration du panneau et déclarer un bean correspond au panneau utilisant le type souhaité ainsi que la configuration créée.
Les initialiseurs de panneaux
Pour créer un nouvel initialiseur de panneau il suffit d'ajouter une implémentation de l'interface fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.initializer.IRecordPanelInitializer ou d'hériter de la classe fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.initializer.impl.AbstractRecordPanelInitializer. Sauf pour des besoins spécifiques, il est conseillé d'utilisé directement la classe abstraite plutôt que d'implémenter l'interface.
Un exemple de déclaration complet d'un initialiseur de panneau sera de la forme:
<bean id="directory-multiview.recordPanelInitializer.panelDirectory" class="fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.initializer.impl.RecordPanelDirectoryInitializer"/>
Une fois la déclaration faite il faut ajouter une implémentation de fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.initializer.querypart.IRecordPanelInitializerQueryPart ou bien hériter de la classe fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.initializer.querypart.impl.AbstractRecordPanelInitializerQueryPart. Cette implémentation indiquera quelles sont les parties de requête à utiliser, pour cet initialiseur, lors de la construction de la requête globale qui sera utilisée pour construire l'ensemble des fiches à afficher dans le tableau.
La classe fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.initializer.querypart.impl.RecordPanelDirectoryInitializerQueryPart est un exemple d'implémentation de cette interface.
Note: Il n'est pas nécessaire de déclarer cette implémentation en tant que bean dans un fichier de contexte.
Une fois cette implémentation faite, il est ensuite nécessaire d'implémenter une Factory pour la QueryPart associé à ce bean. Pour ce faire, il suffit de réaliser une implémentation de l'interface fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.initializer.querypart.factory.IRecordPanelInitializerQueryPartFactory. Un exemple de déclaration d'une telle Factory est de la forme:
<bean id="directory-multiview.recordPanelInitializer.panelDirectory.queryPart.factory" class="fr.paris.lutece.plugins.directory.modules.multiview.business.record.panel.initializer.querypart.factory.impl.RecordPanelDirectoryInitializerQueryPartFactory"/>
Il reste ensuite la partie correspondant aux éléments "web" de l'initialiseur à savoir, la récupération des informations dont il a besoin depuis la requête. Pour ce faire il faut implémenter l'interface fr.paris.lutece.plugins.directory.modules.multiview.web.record.panel.display.initializer.IRecordPanelDisplayInitializer ou bien hériter de la classe fr.paris.lutece.plugins.directory.modules.multiview.web.record.panel.display.initializer.impl.AbstractRecordPanelDisplayInitializer. Cette implémentation va permettre de créer un objet de type fr.paris.lutece.plugins.directory.modules.multiview.business.record.RecordParameters qui contiendra toutes les données nécessaires à la construction de la requête.
La classe fr.paris.lutece.plugins.directory.modules.multiview.web.record.panel.display.initializer.impl.RecordPanelDirectoryDisplayInitializer est un exemple d'implémentation de cette interface.
Note: Il n'est pas nécessaire de déclarer cette implémentation dans un fichier de contexte.
La dernière étape pour finir de créer un initialiseur de panneau est de créer une Factory correspondant à cette implémentation. Il faut réaliser une implémentation de l'interface fr.paris.lutece.plugins.directory.modules.multiview.web.record.panel.display.initializer.IRecordPanelDisplayInitializer ou bien hériter de la classe abstraite fr.paris.lutece.plugins.directory.modules.multiview.web.record.panel.display.initializer.impl.AbstractRecordPanelDisplayInitializer.
Un exemple de déclaration de ce type de Factory est de la forme:
<bean id="directory-multiview.recordsPanelInitializer.panelDirectory.display.factory" class="fr.paris.lutece.plugins.directory.modules.multiview.web.record.panel.display.initializer.factory.impl.RecordPanelDirectoryDisplayInitializerFactory"/>
Ces informations permettent de créer un nouveau type d'initialiseur de panneau et un bean de ce type. Pour créer un initialiseur de panneau d'un type existant il suffit de déclarer un bean du type de l'initialiseur souhaité.
Les colonnes
Pour créer une nouvelle colonne il faut implémenter l'interface fr.paris.lutece.plugins.directory.modules.multiview.business.record.column.IRecordColumn ou bien hériter de la classe abstraite fr.paris.lutece.plugins.directory.modules.multiview.business.record.column.impl.AbstractRecordColumn. Une colonne se déclare de la façon suivante:
<bean id="directory-multiview.workflowState.column" class="fr.paris.lutece.plugins.directory.modules.multiview.business.record.column.impl.RecordColumnWorkflowState"> <constructor-arg name="nRecordColumnPosition" type="int" value="1"/> <constructor-arg name="strRecordColumnTitle" type="java.lang.String" value="État"/> </bean>
Le constructeur d'une colonne doit prendre en argument:
Les colonnes peuvent être associées à des valeurs d'entrées d'annuaire. Pour cela, il est nécessaire de rajouter un argument suplémentaire au constructeur de la colonne qui est une liste de java.lang.String où chaque String correspond à un titre d'entrée.
Un exemple d'ajout de cette liste au bean précédent consistera à rajouter un paramètre de la forme de cet exemple:
<constructor-arg name="listEntryTitle"> <list value-type="java.lang.String"> <value>Votre prénom</value> <value>Votre nom</value> </list> </constructor-arg>
Une fois la colonne définie il faut maintenant réaliser l'implémentation de la QueryPart qui lui est asociée. Il faut implémenter l'interface fr.paris.lutece.plugins.directory.modules.multiview.business.record.column.querypart.IRecordColumnQueryPart ou bien hériter de la classe abstraite fr.paris.lutece.plugins.directory.modules.multiview.business.record.column.querypart.impl.AbstractRecordColumnQueryPart. Sauf pour des besoins spécifiques, il est conseillé d'hériter de la classe abstraite plutôt que d'implémenter l'interface directement.
La classe fr.paris.lutece.plugins.directory.modules.multiview.business.record.column.querypart.impl.RecordColumnDirectoryQueryPart est un exemple d'implémentation de cette interface.
Note: Il n'est pas nécessaire de déclarer ce bean dans un fichier de contexte.
Une fois la QueryPart définie, il faut réaliser l'implémentation de la Factory liée à la QueryPart de cette colonne. Il suffit d'implémenter l'interface fr.paris.lutece.plugins.directory.modules.multiview.business.record.column.querypart.factory.IRecordColumnQueryPartFactory. Il reste à déclarer le bean dans le fichier de contexte comme suit:
<bean id="directory-multiview.recordColumn.workflowState.queryPart.factory" class="fr.paris.lutece.plugins.directory.modules.multiview.business.record.column.querypart.factory.impl.RecordColumnWorkflowStateQueryPartFactory"/>
Il faut ensuite réaliser une implémentation du bean qui va gérer l'affichage de la colonne. Il faut implémenter l'interface fr.paris.lutece.plugins.directory.modules.multiview.web.record.column.display.IRecordColumnDisplay ou bien hériter de la classe abstraite fr.paris.lutece.plugins.directory.modules.multiview.web.record.column.display.impl.AbstractRecordColumnDisplay. Sauf pour des besoins spécifiques, il est conseillé d'hériter de la classe abstraite plutôt que d'implémenter directement l'interface.
La classe fr.paris.lutece.plugins.directory.modules.multiview.web.record.column.display.impl.RecordColumnDisplayDirectory est un exemple d'implémentation de cette interface.
Note: il n'est pas nécessaire de définir ce bean dans le fichier de contexte.
La dernière étape est de créer une Factory associée à l'affichage de cette colonne, pour ce faire il faut implémenter l'interface fr.paris.lutece.plugins.directory.modules.multiview.web.record.column.display.factory.IRecordColumnDisplayFactory.
Un exemple de déclaration d'une Factory pour l'affichage d'une colonne est de la forme:
<bean id="directory-multiview.workflowState.column.display.factory" class="fr.paris.lutece.plugins.directory.modules.multiview.web.record.column.display.factory.RecordColumnDisplayWorkflowStateFactory"/>
Pour toutes les nouvelles colonnes créées il est nécessaire de modifier le fichier de context du plugin (le fichier directory-multiview_context.xml). Il faut modifier la déclaration du bean directory-multiview.recordColumn.factory afin de configurer la liste de toutes les colonnes à utiliser dans le tableau.
Ces informations permettent de créer un nouveau type de colonne ainsi qu'une colonne de ce type. Pour créer une colonne d'un type existant il suffit de déclarer un bean associé au type de colonne souhaité.
Les filtres
La première étape pour créer un filtre est de créer la configuration qui lui sera associée. Pour ce faire il suffit de déclarer un bean dans le fichier de contexte possédant les informations du filtre.
Un exemple de déclaration d'un tel bean:
<bean id="directory-multiview.directoryRecord.filterConfiguration" class="fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.configuration.RecordFilterConfiguration"> <constructor-arg name="nPosition" type="int" value="1"/> <constructor-arg name="strRecordFilterLabel" type="java.lang.String" value="-"/> </bean>
Il faut ensuite créer le filtre lui-même en implémentant l'interface fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.IRecordFilter ou bien en héritant de la classe abstraite fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.impl.AbstractRecordFilter. Sauf pour des besoins vraiment spécifique, il est conseillé d'utilisé directement la classe abstraite plutôt que d'implémenter l'interface.
On va déclarer le bean au niveau du fichier de contexte en lui passant en paramètre la configuration que l'on a créée précédemment. L'exemple suivant illustre la façon de déclarer ce bean:
<bean id="directory-multiview.direcoryRecord.filter" class="fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.impl.RecordFilterDirectory"> <constructor-arg name="recordFilterConfiguration" type="fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.configuration.RecordFilterConfiguration" ref="directory-multiview.directoryRecord.filterConfiguration"/> </bean>
Une fois le filtre définit, il faut maintenant implémenter la QueryPart associée. Pour ce faire, il suffit d'implémenter l'interface fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.querypart.IRecordFilterQueryPart ou bien d'hériter de la classe abstraite fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.querypart.impl.AbstractRecordFilterQueryPart. Sauf pour des besoins spécifiques, il est conseillé d'hériter de la classe abstraite plutôt que d'implémenter l'interface directement.
La classe fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.querypart.impl.RecordFilterDisplayDirectory est un exemple d'implémentation de cette interface.
Note: il n'est pas nécessaire de déclarer ce bean dans un fichier de contexte.
L'étape suivante est de créer la Factory liée à la QueryPart qui vient d'être définie. Pour ce faire, il suffit d'implémenter l'interface fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.querypart.factory.IRecordFilterQueryPartFactory. Le bean doit ensuite être déclaré comme suit:
<bean id="directory-multiview.recordFilter.directoryRecord.queryPart.factory" class="fr.paris.lutece.plugins.directory.modules.multiview.business.record.filter.querypart.factory.impl.RecordFilterDirectoryQueryPartFactory"/>
Pour définir le bean gérant l'affichage du filtre il faut implémenter l'interface fr.paris.lutece.plugins.directory.modules.multiview.web.record.filter.display.IRecordFilterDisplay ou bien hériter de la classe abstraite fr.paris.lutece.plugins.directory.modules.multiview.web.record.filter.display.impl.AbstractRecordFilterDisplay. Sauf pour un besoin explicite il est conseillé d'hériter de la classe abstraite plutôt que d'implémenter directement l'interface.
La classe fr.paris.lutece.plugins.directory.modules.multiview.web.record.filter.display.impl.RecordFilterDisplayDirectory est un exemple d'implémentation de cette interface.
Note: il n'est pas nécessaire de déclarer ce bean dans un fichier de contexte.
Il ne reste plus qu'à créer la Factory liée à l'affichage. Pour ce faire, il faut réaliser une implémentation de l'interface fr.paris.lutece.plugins.directory.modules.multiview.web.record.filter.display.factory.IRecordFilterDisplayFactory. Ci-dessous un exemple de déclaration du bean:
<bean id="directory-multiview.directoryRecord.filter.display.factory" class="fr.paris.lutece.plugins.directory.modules.multiview.web.record.filter.display.factory.RecordFilterDisplayDirectoryFactory"/>
Ces informations permettent de créer un nouveau type de filtre ainsi qu'un filtre de ce type. Pour créer un filtre à partir d'un type existant il suffit de déclarer un bean représentant la configuration de ce filtre ainsi qu'un bean associé au filtre du type souhaité avec cette configuration.
Gestion des redirections
Pour faire la redirection vers la page souhaitée une fois l'action du workflow terminée, il suffit de rajouter la ligne suivante dans le template de la tâche: <input type="hidden" name="workflow_action_redirection" value="list"/>. Il existe deux valeurs possibles pour ce paramètre:
Génération du modèle du template
Il est possible de rajouter dynamiquement des données dans le modèle qui sera utilisé pour la création du template gérant la page contenant les informations d'une fiche. Pour ce faire, il faut réaliser une implémentation de l'interface fr.paris.lutece.plugins.directory.modules.multiview.web.record.view.IRecordViewModelProcessor. Une fois l'implémentation réalisée, il est nécessaire de la déclarer dans un fichier de contexte. Le contrôleur utilisera toutes les implémentations définit dans les fichiers de contexte pour construire le modèle à utiliser par le template d'une fiche.
Note: Toute implémentation non déclarée dans un fichier de contexte ne sera pas utilisé lors de la génération du modèle.
