Core

Configuration avancée du Core

    Cluster & Redis

    Une installation de Flower dans une configuration de type cluster requiert une instance Redis.

    Cette instance Redis permet de gérer :

    • la persistance des sessions entre les différentes instances de GUI
    • un cache distribué pour le maintien des réservations de composant
    • le renouvellement des caches “statiques” (classes de composant, ACL, configuration GUI…) entre les différentes instances de Core et de GUI
    • la persistance et la distribution des OperationHandler asynchrones
    Propriété Description
    spring.redis.host IP/Nom de domaine de la machine Redis
    spring.redis.port Port utilisé par Redis
    spring.redis.password Mot de passe
    spring.redis.timeout Timeout des échanges avec Redis
    spring.redis.database Index de la base de donnée Redis

    Ce mode s’active grâce à la propriété redis.enabled=true

    Toutes les propriétés commençant par spring.redis. définies par spring-data-redis peuvent être surchargées (Documentation Spring).

    Note : si le mode cluster est activé, l’instance Redis doit être démarrée pour que la GUI puisse démarrer

    Les permissions

    De manière générale, les permissions autorisées sont :

    Permission Description
    CREATE Autorise la création
    READ Autorise l’accès en lecture
    UPDATE Autorise la modification
    DELETE Autorise la suppression
    READ_HISTORY Accès à l’historique
    READ_TASK_HISTORY Accès au suivi des tâches

    Les permissions spécifiques aux documents :

    Permission Description
    READ_CONTENT Accès en lecture du contenu
    UPDATE_CONTENT Modification du contenu
    DOWNLOAD_CONTENT Téléchargement du contenu (visionneuse)
    PRINT Impression (visionneuse)
    CREATE_ANNOTATION Création d’annotation (visionneuse)
    READ_ANNOTATION Lecture des annotations existantes (visionneuse)
    BUILD_NEW_DOCUMENT Activation du découpage de document (visionneuse)

    Les permissions spécifiques aux tâches :

    Permission Description
    APPROPRIATE S’approprier une tâche non-assignée
    APPROPRIATE_ALREADY_ASSIGNED S’approprier une tâche déjà assignée
    ASSIGN Assigner une tâche à un utilisateur
    APPLY_ANSWER Appliquer une réponse
    UPDATE_CONTENT Modification des pièces jointes
    DELETE_CONTENT Suppression d’une pièce jointe
    READ_CONTENT Visualisation des pièces jointes

    Les identités

    Au sens FlowerDocs, une identité est soit un utilisateur, un groupe ou une équipe. La notion d’équipe a été introduite afin de centraliser et mutualiser la gestion des autorisations communes à une ou plusieurs identités.

    ACL Proxy

    Les objets de type ACLProxy permettent d’ajouter un aspect métier à la gestion des habilitations.

    Un proxy est également un SecurityObject permettant de définir la sécurité à appliquer sur un composant. Il s’appuie sur des conditions pour déterminer quelle est l’ACL à appliquer sur un composant.

    Exemple :

    Pour une classe de document Facture, le proxy suivant pourrait être utilisé :

    • si montant < 100€ : tout le monde à le droit de voir / modifier le document
    • si 100€ < montant : tout le monde à le droit de voir en lecture seule le document

    Schéma

                          SecurityObject
                                |
             _______________________________
            |                               |
     AcessControlList  <-----            ACLProxy
            |                |              |
            | 1:N            |              | * rules : List<ACLRule>  ---
            |                |                                           |
    AccessControlEntry       |                                           |
                             |                                           |
                             |           ACLRule  <-----------------------
                             |              |
                             |              | * conditions : List<String>
                             |____1:1_______| * aclId : Id
    

    Rôles

    Les rôles donnent accès à des fonctionnalités Flower à travers la notion d’équipe.

    Pour affecter un rôle à un utilisateur :

    • créer une équipe dont l’identifiant est le nom du rôle
    • ajouter des utilisateurs dans une équipe
    Rôle Description
    ADMIN Administre un scope
    DOCUMENT_CREATOR Accède à l’onglet Insérer

    LDAP par défaut

    Cette partie concerne la configuration d’un annuaire par défaut pour une instance FlowerDocs.

    Cette partie n’est pas à suivre dans le cas d’une configuration de l’annuaire à travers l’interface d’administration.

    Accès

    Pour configurer l’accès à l’annuaire d’entreprise, il nécessaire d’identifier le type nécessaire :

    • simple : LDAP simple de type Apache Directory Server ou OpenLDAP
    • ad : Microsoft Active Directory
    • ad-ds : Microsoft ADLDS
    • embedded : Apache Directory Server embarqué sur le port 3389

    Le type d’annuaire peut ensuite être défini par application WEB :

    • Pour la GUI grâce à la propriété : gui.ldap.type
    • Pour le Core grâce à la propriété : ws.ldap.type

    Exemple : Configuration d’un serveur embarqué

    gui.ldap.type=embedded
    ws.ldap.type=simple
    

    Pour configurer l’accès à l’annuaire LDAP, il est nécessaire de renseigner la propriété ldap.

    Propriété Valeur par défaut Description
    ldap.bind.url ldap://localhost:389 Adresse de l’annuaire
    ldap.bind.root Noeud de base dans la structure LDAP
    ldap.base.dn Base de recherche des utilisateurs

    Nota : Dans le cas où l’annuaire LDAP est embarqué, il est nécessaire d’ajouter la propriété ldap.bind.root correspondant au noeud de base dans la strucutre LDAP.

    Compte d’accès

    Un compte de type admnistrateur doit être configuré permettant d’effectuer des actions :

    • recherche d’utilisateur
    • récupération d’utilisateur
    • authentification
    • etc.
    Propriété Description
    ldap.bind.dn Distinguished Name de l’utilistateur
    ldap.bind.password Mot de passe de l’utilistateur

    Attributs / mapping

    Afin de récupérer (ou authentifier) des utilisateurs contre l’annuaire configuré, il faut également définir :

    Propriété Description
    ldap.attr.id Attribut permettant de récupérer l’identifiant d’un utilisateur

    Exemples :

    • MS Active Directory : sAMAcountName
    • MS Active Directory LDS : uid
    • Apache Directory Server : uid

    D’autres attributs utilisés pour le mapping d’utilisateur peuvent être définis :

    Propriété Description
    ldap.attr.display.name Attribut permettant de récupérer l’identifiant d’un utilisateur
    ldap.attr.password Attribut permettant de récupérer le mot de passe d’un utilisateur

    Administration du LDAP

    Création d’un utilisateur

    Depuis l’interface d’administration, il est possible de créer des utilisateurs avec un mot de passe par défaut. Pour celà, le mot de passe ne doit pas être obligatoire.

    Propriété Description
    ldap.default.password Mot de passe par défaut si aucun n’est défini lors de la création
    ldap.user.password.mandatory Booléen définissant le critère obligatoire du champs mot de passe

    La création d’utilisateur ou de groupe ne peut être effectuée qu’à la racine du noeud d’accès au LDAP.

    Exemple : Pour un MS Active Directory: <domaine>/<base DN>

    Batch

    Pour créer plusieurs utilisateurs en une seule requête, il est possible d’envoyer la requête :

    • Méthode : POST
    <UserBatch xmlns:ns2="http://flower.com/docs/domain/security" xmlns:ns3="http://flower.com/docs/domain/common">
        <users>
            <ns3:id>user_id</ns3:id>
            <ns2:displayName>My Display name</ns2:displayName>
            <ns2:credentialsExpired>false</ns2:credentialsExpired>
        </users>
    </UserBatch>
    

    Exemples de configuration

    LDAP embarqué

    ldap.bind.url=ldap://localhost:3389
    ldap.bind.root=dc=arondor,dc=com
    ldap.base.dn=ou=employees
    ldap.attr.id=uid
    ldap.bind.dn=uid=fadmin,ou=Administrators,ou=employees,dc=arondor,dc=com
    ldap.bind.password=okidoki
    

    ADLDS

    ldap.bind.url=ldap://ldap.company.com:389
    ldap.bind.root=dc=arondor,dc=dev
    ldap.bind.dn=CN=fadmin,OU=Demo,OU=FlowerDocs,DC=arondor,DC=dev
    ldap.bind.password=okidoki
    ldap.base.dn=OU=Demo,OU=FlowerDocs
    ldap.attr.id=CN
    ldap.attr.display.name=displayName
    

    OpenLDAP

    OpenLDAP requiert que le base DN utilisé

    ldap.bind.url=ldap://ldap.company.com:389
    ldap.bind.root=
    ldap.base.dn=dc=arondor,dc=dev
    ldap.attr.id=CN
    ldap.bind.dn=CN=admin,DC=arondor,DC=dev
    ldap.bind.password=okidoki
    ldap.attr.display.name=displayName
    

    Référentiel interne

    FlowerDocs peut se baser sur un référentiel interne d’utilisateurs. Ce référentiel est configuré via Spring.

    Le contexte Spring par défaut embarque un référentiel contenant un seul et unique utilisateur. Ses paramètres de configuration sont les suivants :

    • Activer / Désactiver : security.realm.users.enabled avec false ou true (par défaut)
    • Login : security.realm.users.username dont la valeur par défaut est fsa
    • Mot de passe : security.realm.users.password

    Ce référentiel par défaut peut être changé en utilisant la propriété security.realm.users.config pour définir le chemin vers un fichier de configuration Spring.

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans 
    	http://www.springframework.org/schema/beans/spring-beans.xsd
    	http://www.springframework.org/schema/context 
    	http://www.springframework.org/schema/context/spring-context.xsd">
    
    	<bean id="internalRealmAuthenticationProvider" 
    	  class="com.flower.docs.security.ldap.InternalRealmAuthenticationProvider">
    	  <property name="enabled" value="#{new Boolean('${security.realm.users.enabled:false}')}" />
    	  <property name="users">
    		  <list>
    			<bean class="com.flower.docs.domain.security.AuthenticatedUser">
    			  <property name="username" value="${security.realm.users.username:fsa}" />
    			  <property name="password" value="${security.realm.users.password:0000}" />
    			</bean>
    		  </list>
    	  </property>
    	</bean>
    </beans>
    

    Compte utilisateur système

    Un compte utilisateur système est défini pour l’ensemble de l’application FlowerDocs.

    Il peut être configuré grâce aux paramètres suivants.

    Propriété Valeur par défaut Description
    system.admin.username system Identifiant de l’utilisateur système
    system.admin.password okidoki Mot de passe de l’utilisateur système

    Plusieurs paramètres permettre de configurer la manière dont est généré le jeton :

    • Clé secrète : token.key
    • Mot de passe :
      • Inclusion : token.password.include (valeur par défaut false)
      • Passphrase : token.password.passphrase
      • Iv : token.password.iv
    • Expiration : token.expiration.time en secondes (valeur par défaut 3600)

    Nota : la durée de vie du token doit être supérieure à celle de la session utilisateur pouvant être définie grâce à gui.session.timeout (secondes - valeur par défaut 1800)

    Validation

    La solution FlowerDocs embarque le moteur de règles JBoss Drools permettant d’ajouter une couche de validation métier lors de la création ou la mise à jour de composant. La définition de ces règles métiers s’appuie sur le format DRL (cf. The Rule Language).

    Pour indiquer les règles métiers à appliquer, il faut définir la propriété validation.drl. Cette propriété doit être renseignée selon la syntaxe Spring.

    Pour appliquer des règles présentes sur le système de fichier :

    • Sous Linux : file:///opt/FlowerDocs/drls/*.drl
    • Sous Windows : file:///C:/FlowerDocs/drls/*.drl

    Exemple : règle de validation du montant d’un document

    package com.flower.docs.core.tsp.validation.drools;
    
    import com.flower.docs.domain.component.Component
    import com.flower.docs.domain.document.Document
    import com.flower.docs.core.tsp.validation.Errors
    
    global org.slf4j.Logger logger;
    global com.flower.docs.core.tsp.validation.RuleUtil util;
    
    rule " Refus des montants supérieurs à 3000€"
       when
    	document:Document(util.getTagValue(document,"Montant") > 3000)
    	$errors:Errors()
       then
    	logger.warn("Le document a un montant trop important");
    	$errors.addError(document, "Montant", "Le montant "+util.getTagValue(document,"Montant")+" est trop important");
    end
    

    Légende :

    • Définition d’une variable globale permettant de logger des informations dans les logs applicatifs
    • Définition d’une variable globale exposant des méthodes utilitaires
    • Définition du nom de la règle métier
    • Condition sur le fait que l’objet soit un Document ayant un tag Montant dont la valeur est supérieure à 3000
    • Ajout d’une erreur dans le contexte de validation. Les messages ajoutés seront affichés dans une popup d’erreur présentée aux utilisateurs avec le code d’erreur F00039


    Note : En fonction de la catégorie de composant, des conditions différentes doivent être utilisées :

    • tâche : task:Task() avec l’import com.flower.docs.domain.task.Task
    • dossier : folder:Folder() avec l’import com.flower.docs.domain.folder.Folder
    • dossier virtuel : virtualFolder:VirtualFolder() avec l’import com.flower.docs.domain.virtualfolder.VirtualFodler


    Quelques méthodes sont mises à disposition pour faciliter l’utilisation des objets FlowerDocs au sein de règle Drools :

    Méthode Description
    String getClassId(Component component) Récupère l’identifiant de classe de composant
    String getTagValue(Component component, String tagName) Récupère la valeur d’un tag
    Status getStatus(Component component) Récupère le status d’un composant
    String getAnswerId(Task task) Récupère l’identifiant de la réponse appliquée sur une tâche
    void log(String message) Log une chaîne de caractères

    Identifiants de composant

    Par défaut, les identifiants des composants sont générés, à leur création, au format UUID (2^128).

    Lors de l’injection de composant via WS, les identifiants fournis en entrée sont, par défaut, surchargés au profit d’UUID générés par le Core. Ce comportement peut être modifié en ajoutant la propriété id.generate.force avec la valeur false.

    Cette propriété permet ainsi de forcer l’utilisation par le Core des identifiants fournis en entrée (par exemple par un SI métier). Ce cas peut s’avérer utile lors de migration / reprise de données.

    FlowerDocs permet la génération de deux types d’identifiants différents :

    • UUID (par défaut)
    • Numérique (déconseillé pour les environnements de production)

    Pour changer la configuration par défaut, il faut définir la propriété id.generate.type avec la valeur UUID ou Numeric.