> For the complete documentation index, see [llms.txt](https://documentation.efalia.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://documentation.efalia.com/produit/efalia-process/administration/annexes-techniques.md).

# Annexes Techniques

## Annexe A — Propriétés Serveur

Les propriétés détaillées dans cette section permettent de configurer les différentes parties fonctionnelles du serveur Workey. Elles doivent être présentes dans le fichier `<CATALINA_HOME>/conf/catalina.properties`.

Ce fichier défini un ensemble de propriétés (des couples clef – valeur) qui seront ajoutées aux propriétés système Java au lancement de *Tomcat*.

Cette liste de propriétés sera chargée à l´aide de la méthode *load* de la classe `java.util.Properties`.

| <p>Les lignes du fichier commençant par <strong>#</strong> sont considérées comme des <strong>commentaires</strong>.<br><br>Les espaces précédant une valeur sont ignorés. En revanche la chaîne de caractère qui est retenue comme valeur s´étend du premier caractère (autre qu´un espace) jusqu´à la fin de ligne (les espaces après la valeur sont conservés).<br><br>Si une URL doit être spécifiée, elle devra aussi respecter la norme <strong>RFC 3986</strong>.Exemple : échappement du caractère d´espacement à l´aide de <strong>%20</strong><br><br>Si un chemin sur le système de fichier doit être spécifié, le caractère <strong>/</strong> devra être utilisé comme séparateur de répertoire. Il est toutefois possible d´utiliser des <em>\* mais il sera alors nécessaire de les échapper par un autre \*\*\*</em>.<br>Exemple :<br><code>C:\Tomcat\workey\my\_folder</code><br>ou<br><code>..\workey\my\_folder</code><br><strong>Mise en garde sur l'utilisation de chemins relatifs</strong>.<br>-> selon que le serveur Workey est lancé en tant que service ou en console, le répertoire d'exécution (spécifique à l'identité utilisée) est susceptible d'être différent. Ceci pourrait potentiellement fausser la résolution des chemins relatifs. Les fichiers de propriétés java standards <strong>ne</strong> supportent <strong>pas</strong> la substitution de variables.</p> |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

### Journalisation

Pour la journalisation, le serveur Workey utilise le framework *Log4J*. Celui-ci embarque, dans sa librairie, son propre fichier de configuration par défaut. La configuration de celui-ci se fait par le biais d'un fichier de propriété spécifique. Pour spécifier une configuration différente, il est nécessaire de lui indiquer, à l'aide de la propriété siuvante, le chemin vers un autre fichier de configuration :

* **log4j.configuration**

Pour renseigner cette propriété avec le chemin d'un fichier de configuration alternatif, il est nécessaire de préciser que ce chemin est accessible via le système de fichier (en préfixant le chemin avec `file:`) Dans le cas contraire, [le fichier sera d'abord recherché sur le classpath du classloader](http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PropertyConfigurator.html). Exemple:`log4j.configuration=file:../conf/log4j.properties`

De nombreuses ressources sont disponibles sur Internet pour vous aider dans la configuration de ce framework de journalisation (cf. Annexe E – Ressources externes).

### Répertoires

| <p>Au démarrage, le serveur Workey vérifie qu'il dispose d'un ensemble de chemins vers ses répertoires de travail.<br><br>Ci-contre, l'arborescence des répertoires qui seront créés au démarrage du serveur Workey.<br>La mise en place de cette arborescence découle du comportement suivant:<br>– Lorsqu'un répertoire n'est pas présent, et que la <strong>propriété correspondante n'a pas été renseignée</strong> :<br>-> alors il sera créé au regard du chemin par défaut.<br><br>– En revanche, tout chemin <strong>expressément renseigné</strong> devra pointer vers un répertoire <strong>existant</strong> et <strong>accessible</strong> :<br>-> celui-ci ne sera pas créé.<br><br><br>Ci-après, la liste des propriétés permettant de stipuler les emplacements des différents répertoires de travail du serveur Workey.</p> | <p><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-e34e45a078b886f795ddd65efd8320f44a54edc0%2Fprocess-deploy-annexes-proprietes-serveur-workey-01.webp?alt=media" alt=""><br>Arborescence de Workey (à partir de 6.2.0)</p> |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| **Propriété**                                                                                                                                          | **Description**                                                                                                                                                                                                                                                                      | **Chemin par défaut**                                                                                                                                                                                                                                                                                                   |
| ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `com.clog.workey.directory`                                                                                                                            | <p>-> <strong>Répertoire racine de Workey</strong>.<br>Il sert de base à l'arborescence par défaut des sous-répertoires dédiés aux diverses parties fonctionnelles de Workey.Le fichier de licence <code>workey-license.xml</code> doit être placé à la racine de ce répertoire.</p> | <p>Création d'un répertoire <code>/workey</code><br>sous le chemin désigné par la propriété java <code>catalina.home</code>.Cette propriété java est renseignée avec le chemin contenu dans la variable d'environnement <code>\<CATALINA\_HOME></code> qui désigne le répertoire d'installation de <em>Tomcat</em>.</p> |
| `com.clog.workey.directory.archives`                                                                                                                   | -> Répertoire d'**export des documents** Workey **archivés**.                                                                                                                                                                                                                        | <p>Création d'un répertoire <code>/archives</code><br>sous le <code>répertoire racine de Workey</code>.</p>                                                                                                                                                                                                             |
| `com.clog.workey.directory.attachments`                                                                                                                | -> Répertoire de *stockage* des **pièce jointes des documents** Workey.                                                                                                                                                                                                              | <p>Création d'un répertoire <code>/attachments</code><br>sous le <code>répertoire racine de Workey</code>.</p>                                                                                                                                                                                                          |
| `com.clog.workey.directory.deployed`                                                                                                                   | -> Répertoire de *stockage* des **XML des processus déployés**.                                                                                                                                                                                                                      | <p>Création d'un répertoire <code>/deployed</code><br>sous le <code>répertoire racine de Workey</code>.</p>                                                                                                                                                                                                             |
| `com.clog.workey.directory.designer`                                                                                                                   | -> **Répertoire racine du modélisateur** Workey.                                                                                                                                                                                                                                     | <p>Création d'un répertoire <code>/designer</code><br>sous le <code>répertoire racine de Workey</code>.</p>                                                                                                                                                                                                             |
| `com.clog.workey.directory.designer.attachments`                                                                                                       | -> Répertoire de *stockage* des **fichiers joints aux projets modélisés**.                                                                                                                                                                                                           | <p>Création d'un répertoire <code>/attachments</code><br>sous le <code>répertoire racine du modélisateur</code>.</p>                                                                                                                                                                                                    |
| <p><code>com.clog.workey.directory.designer.docTemplates</code><br>(Cette propriété n'est disponible qu'à partir de Workey <strong>6.2.0</strong>)</p> | -> Répertoire de *stockage* des fichiers de modèles pour la génération de la **documentation** au format **Word**.                                                                                                                                                                   | <p>Création d'un répertoire <code>/doc-templates</code><br>sous le <code>répertoire racine du modélisateur</code>.</p>                                                                                                                                                                                                  |
| `com.clog.workey.directory.designer.genDoc`                                                                                                            | -> Répertoire *temporaire* de génération de **documentation** au format **Word**.                                                                                                                                                                                                    | <p>Création d'un répertoire <code>/doc</code><br>sous le <code>répertoire racine du modélisateur</code>.</p>                                                                                                                                                                                                            |
| `com.clog.workey.directory.designer.genHTML`                                                                                                           | -> Répertoire *temporaire* de génération de **documentation** au format **HTML**                                                                                                                                                                                                     | <p>Création d'un répertoire <code>/html</code><br>sous le <code>répertoire racine du modélisateur</code>.</p>                                                                                                                                                                                                           |
| `com.clog.workey.directory.designer.projects`                                                                                                          | -> Répertoire de *stockage* des **projets modélisés**.                                                                                                                                                                                                                               | <p>Création d'un répertoire <code>/projects</code><br>sous le <code>répertoire racine du modélisateur</code>.</p>                                                                                                                                                                                                       |
| `com.clog.workey.directory.index`                                                                                                                      | -> Répertoire de *stockage* des **index Lucene** de Workey.                                                                                                                                                                                                                          | <p>Création d'un répertoire <code>/index</code><br>sous le <code>répertoire racine de Workey</code>.</p>                                                                                                                                                                                                                |
| `com.clog.workey.directory.libs`                                                                                                                       | -> Répertoire de **librairies supplémentaires**.                                                                                                                                                                                                                                     | <p>Création d'un répertoire <code>/libs</code><br>sous le <code>répertoire racine de Workey</code>.</p>                                                                                                                                                                                                                 |
| <p><code>com.clog.workey.directory.scripts</code><br>(Cette propriété n'est disponible qu'à partir de Workey <strong>6.4.0</strong>)</p>               | -> Répertoire contenant les scripts utilisateurs (utilisé notemment par le connecteur ScriptConnector).                                                                                                                                                                              | <p>Création d'un répertoire <code>/scripts</code><br>sous le <code>répertoire racine de Workey</code>.</p>                                                                                                                                                                                                              |
| `com.clog.workey.directory.thumbnails`                                                                                                                 | -> Répertoire de *stockage* des **vignettes** (*thumbnails*) des pièces jointes de documents Workey.                                                                                                                                                                                 | <p>Création d'un répertoire <code>/thumbnails</code><br>sous le <code>répertoire racine de Workey</code>.</p>                                                                                                                                                                                                           |
| `com.clog.workey.directory.velocity-templates`                                                                                                         | -> Répertoire de *stockage* des **templates velocity**utilisés pour les besoins de **fusion HTML**.                                                                                                                                                                                  | <p>Création d'un répertoire <code>/velocity-templates</code><br>sous le <code>répertoire racine de Workey</code>.</p>                                                                                                                                                                                                   |
| `com.clog.workey.directory.web-sessions`                                                                                                               | -> Répertoire utilisé pour les création de **fichiers temporaires**liées aux **sessions des utilisateurs de l'Application Web** de Workey.                                                                                                                                           | <p>Création d'un répertoire <code>/web-sessions</code><br>sous le <code>répertoire racine de Workey</code>.</p>                                                                                                                                                                                                         |

| <p><strong>NE JAMAIS UTILISER UN MÊME RÉPERTOIRE DE STOCKAGE DES PIÈCES JOINTES ENTRE DIFFÉRENTES INSTANCES DE WORKEY.</strong><br>D'autre part, il doit être distinct du répertoire de stockage des vignettes.</p> |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| <p><strong>NE JAMAIS UTILISER UN MÊME RÉPERTOIRE DE STOCKAGE DES VIGNETTES ENTRE DIFFÉRENTES INSTANCES DE WORKEY</strong>.<br>D'autre part, il doit être distinct du répertoire de stockage des pièces jointes.</p> |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

### Annuaires LDAP

| Avant d'aborder la section suivante, il est nécessaire de comprendre l'interaction entre le serveur Workey et les différents annuaires.-> Pour cela, vous pouvez vous reporter à l'**Annexe B – Annuaires LDAP**. |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

#### Propriétés de connexion aux annuaires

* Rappel :

-> Les propriétés `com.clog.login.*` permettent de décrire l'annuaire utilisé pour la phase d'authentification des utilisateurs.-> Les propriétés `com.clog.userDirectory.*` permettent de décrire l'annuaire contenant les informations relatives aux utilisateurs authentifiés.

* Ces ensembles de propriétés doivent être définis.

Toutefois, si votre environnement n´utilise qu´un seul annuaire, alors ces deux jeux de propriétés devront être renseignés de manière à être en phase et désigner ainsi votre annuaire unique.

| <p><strong>Propriété d'annuaire</strong><br>(respectivement d'authentification ou informationnel)</p>                          | **Description**                                                                                                                                                                                                                                                                                                                                                                                                                                | **Remarque**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <p><code>com.clog.login.providerUrl</code><br><code>com.clog.workey.userDirectory.providerUrl</code></p>                       | <p>-> <strong>URL de connexion à l´annuaire</strong>.<br>La syntaxe est la suivante:<br><code>protocole://adresseIP/DN\_racine</code><br>ou<br><code>protocole://nom\_de\_machine:port/DN\_racine</code><br>où <code>DN\_racine</code> est le chemin, depuis la racine de l´annuaire, du point d'entrée dans l'arborescence. Il définit ainsi le <em>contexte racine</em>.<br>Exemple : <code>ldap\://127.0.0.1:389/dc=c-log,dc=com</code></p> | <p>Si ce paramètre est absent ou laissé vide, Workey utilisera l'URL : <code>ldap\://localhost:389</code><br><br>Workey <strong>ne pourra voir que la sous-arborescence</strong> à partir de ce point d'entrée. Il en résultera que les utilisateurs situés en amont de cette arborescence ne pourront pas être vus. Il en sera de même pour les utilisateurs qui se trouveraient dans des sous-arborescences qui ne seraient pas en aval du point d'entrée.-> <em>Le contexte racine doit impérativement être spécifié dans l'URL de connexion.</em></p> |
| <p><code>com.clog.login.workeyPrincipal</code><br><code>com.clog.workey.userDirectory.workeyPrincipal</code></p>               | <p>-> <strong>L´identité utilisée par le serveur Workey</strong> pour établir les connexions à l´annuaire. C'est-à-dire le compte utilisateur (aussi désigné par le terme <code>principal</code>).<br>Exemple : <em>cn=admin,dc=c-log,dc=com</em></p>                                                                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| <p><code>com.clog.login.workeyCredentials</code><br><code>com.clog.workey.userDirectory.workeyCredentials</code></p>           | -> **Le mot de passe associé au principal** utilisé par le serveur Workey pour établir les connexions à l´annuaire.                                                                                                                                                                                                                                                                                                                            | Les connections sont établies avec des mots de passe en clair. -> Il est donc indispensable que le serveur Workey et l´annuaire LDAP soient **sur un réseau sécurisé**.                                                                                                                                                                                                                                                                                                                                                                                   |
| <p>com.clog.login.<strong>useTLS</strong> (optionnel)<br>com.clog.workey.userDirectory.<strong>useTLS</strong> (optionnel)</p> | -> **Utilisation de la négociation TLS** lors des connexions à l´annuaire.                                                                                                                                                                                                                                                                                                                                                                     | Pour activer la négociation TLS, la propriété doit être présente et égale à la chaîne \`\`true\`´.                                                                                                                                                                                                                                                                                                                                                                                                                                                        |

#### Paramétrage de la « clef utilisateur »

| A titre de rappel, un annuaire respectant le modèle X.500, interrogé via le protocole LDAP, est structuré comme suit:une entrée est constituée d'un ensemble d'attributsun attribut est nommé et a une (ou plusieurs) valeur(s)chaque entrée a un identifiant unique: son **DN** (Distinguished Name). Celui-ci est constitué de son **DN relatif**, construit depuis un ou plusieurs de ses attributs, suivi du DN de son parent. |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

Du fait que les utilisateurs soient des entrées de l'annuaire, le choix de la "clef utilisateur" est primordial. Gardez à l'esprit que le DN peut changer pendant la durée de vie d'une entrée, par exemple, quand les entrées sont déplacées dans l'arborescence de l´annuaire. Afin d'identifier les entrées de manière fiable et non ambigüe, un identifiant **unique** et **invariant** pourrait faire partie des attributs de chaque entrée.

Une fois ces considérations prises en compte, il faut indiquer pour le(s) annuaire(s) si la clef des utilisateurs sera leur DN ou bien la valeur de l´un de leurs attributs.

| <p><strong>Propriété d'annuaire</strong><br>(respectivement d´authentification ou informationnel)</p>              | **Description**                                                                                                                                                                                                                                                                                                                                                                            | **Remarque**                                                                                                                                                                                                                                              |
| ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <p><code>com.clog.login.userKeyAttribute</code><br><code>com.clog.workey.userDirectory.userKeyAttribute</code></p> | <p>-> <strong>Spécifie le nom de l'attribut LDAP contenant la clef</strong> à utiliser pour l´identification des utilisateurs.<br>-> Si ce paramètre est <strong>absent</strong> ou <strong>laissé vide</strong>, alors les utilisateurs seront identifiés/retrouvés par leur chemin (relatif) à partir du point d'entrée dans le LDAP (c´est-à-dire, par rapport au contexte racine).</p> | Il est impératif que la **valeur récupérée de l'annuaire**, pour l'attribut LDAP spécifié, soit :`clef` : à défaut, ce sera le premier élément correspondant qui sera retenu (l'ordre des résultats ne pouvant pas être garanti par Workey).`invariante`. |

#### Propriétés spécifiques à l'annuaire d'authentification

| **Propriété d'annuaire**                            | **Description**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | **Remarque**                                                                                                                                                                                                                                      |
| --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `com.clog.login.aliasNameAttribute`                 | <p>-> Permet de spécifier le <strong>nom de l'attribut contenant le login</strong> de l'utilisateur.<br>-> S'il est absent ou laissé vide, Workey tentera d'utiliser l'attribut '<code>cn</code>'.</p>                                                                                                                                                                                                                                                                                                                                                                              | <p>Pour un ADS (Active Directory Service), le login de session Windows correspond à l'attribut <code>sAMAccountName</code>.<br>-> Pour MSExchange 5.5, il conviendra d'utiliser l'attribut <code>rdn</code>.</p>                                  |
| `com.clog.login.userPrincipalAttribute` (optionnel) | <p>-> Cette option concerne la seconde phase de l'authentification: la validation du mot de passe. Il indique à Workey l'<strong>attribut</strong> qui devra être récupéré afin de disposer du "<strong>principal</strong>" nécessaire à la seconde connexion au LDAP : celle qui validera le couple <em>"principal"</em> – mot de passe.<br>-> Si cette propriété est <strong>absente</strong> ou <strong>laissée vide</strong>, Workey utilisera le <strong>DN absolu</strong> (chemin depuis la racine de l'annuaire) de l'utilisateur identifié par son <code>login</code>.</p> | <p>-> Cette option se doit d'être laissée vide pour un OpenLDAP, car ce sera alors le DN absolu qui sera utilisé pour tenter la connexion.<br>-> En revanche, pour ADS il est conseillé d'utiliser l'attribut <code>distinguishedName</code>.</p> |

#### Propriétés spécifiques à l'annuaire informationnel

| **Propriété d'annuaire**                                         | **Description**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | **Remarque**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| ---------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `com.clog.workey.userDirectory.emailAttribute` (optionnel)       | -> Désigne l´**attribut LDAP contenant l'adresse email** des utilisateurs.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | -> En l'absence de paramétrage valide de cette propriété, l'attribut utilisé sera: `mail`                                                                                                                                                                                                                                                                                                                                                                                                       |
| `com.clog.workey.userDirectory.displayNameAttribute` (optionnel) | -> Désigne l´**attribut LDAP contenant le nom complet** de l´utilisateur affichable dans l´interface Workey.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | -> En l'absence de paramétrage valide de cette propriété, l'attribut utilisé sera: `cn`                                                                                                                                                                                                                                                                                                                                                                                                         |
| `com.clog.workey.userDirectory.userFilter` (optionnel)           | <p>-> Cette propriété défini le <strong>filtre LDAP</strong> à appliquer pour identifier, dans l´arborescence de l´annuaire informationnel, les noeuds correspondants à des utilisateurs.<br>-> Les annuaires de type ADS (Active Directory Service) peuvent stocker des objets binaires de très grande taille, susceptibles d'excéder la taille que peut gérer l'API LDAP utilisée par Workey. Il est donc important de spécifier un filtre efficace pour ne pas tenir compte de ces types d´objet.</p>                                                                                                                                                                                                                            | <p>-> En l'absence de paramétrage valide de cette propriété, le filtre utilisé sera :<br><code>(&(objectclass=person)(objectclass=user))</code><br><br>-> <em>Par le biais de la console d'administration, il est possible de spécifier un autre filtre pour rechercher directement les utilisateurs.</em><br>-> <em>Afin de renseigner la propriété avec un filtre adéquat, il est recommandé de tester ce dernier à l'aide d'un client LDAP (par exemple le programme LDAP Browser).</em></p> |
| `com.clog.workey.userDirectory.cacheMaxAge` (optionnel)          | <p>-> Les adresses e-mail et les noms complets des utilisateurs, contenus dans l´annuaire informationnel et accédés par Workey, sont mis en cache.<br>Par défaut, <strong>l´âge maximum d´une entrée mise en cache</strong> est de <strong>600 secondes</strong>. Il est possible de spécifier une période différente en indiquant un nombre (entier positif) de seconde pour cette propriété.<br><em>Une valeur négative entrainera une durée de validité perpétuelle pour les entrées mise en cache.</em><br><em>Une valeur nulle reviendra à indiquer à Workey d´ignorer la valeur mise en cache et de systématiquement réinterroger l´annuaire. Un tel paramétrage doit exclusivement être réservé à des fins de test.</em></p> | -> *Les caches peuvent être vidés manuellement via la console d´administration.*                                                                                                                                                                                                                                                                                                                                                                                                                |
| `com.clog.workey.userDirectory.connectTimeout` (optionnel)       | <p>-> Permet de spécifier le <strong>timeout</strong> d'intérrogation de l'annuaire (en millisecondes).<br>-> <em>Ce nombre entier doit être plus grand que 0 (zéro). Un entier négatif ou nul signifie qu'il n'y aura aucun timeout. Toute requête LDAP attendra indéfiniement une réponse.</em></p>                                                                                                                                                                                                                                                                                                                                                                                                                               | -> *En l'absence de timeout explicitement spécifié, ce sera le timeout du réseau sous-jacent qui interrompera les requêtes.*                                                                                                                                                                                                                                                                                                                                                                    |

### Notification Email

La configuration de l'envoi d'email par le serveur Workey est scindée en deux parties distinctes:

* la configuration du gestionnaire de sessions email,
* la configuration des notifications email Workey.

#### Gestion des sessions email

Une session mail est créée à chaque envoi d'email par le serveur Workey. L'obtention et la gestion de cette session sont délégués à l'API `javamail`. Les paramètres de création de session seront fournis tels quels à l'api. Ces paramètres doivent être explicités sous forme de propriétés java (spécifiques à l'API `javamail`) à définir dans le fichier `catalina.properties`. L'ensemble des propriétés supportées sont décrites dans la [documentation officielle de **`javamail`**](https://javamail.java.net/nonav/docs/api/overview-summary.html#overview_description).

Le serveur Workey utilise l'API `javamail` uniquement pour de l'envoi d'email. Il n'est donc pas nécessaire de configurer les éléments relatifs à la récupération d'email.

Exemple : pour se connecter à un serveur SMTP standard, l'ensemble suivant de propriétés doit être défini :

> `mail.transport.protocol=smtpmail.smtp.host=my.smtp.servermail.smtp.port=25mail.user=user@my.domain.commail.password=secret`

Note : le protocole de transport utilisé, par défaut, pour l'envoi d'email est `smtp` (spécifié par la propriété `mail.transport.protocol`). A partir de Workey 6.5.1, il est vivement recommandé de mettre-à-jour le paramétrage des envois d'email, du fait de l'obsolescence de certaines propriétés. Cf. la section ci-après.

#### Sessions mail avec authentification

Depuis la version 1.4.4 de `JavaMail`, il n'est plus possible de spécifier, en standard, les informations d'authentification par le biais des propriétés `mail.*`. Toutefois, l'authentification pour l'envoi d'email, dans Workey, peut être paramétrée de la manière suivante.

* Indiquer qu'une authentification est requise en renseignant à `true` la propriété `mail.<protocol>.auth`

`<protocol>` étant le protocole utilisé pour l'envoi des emails.

* Spécifier les nom d'utilisateur et mot de passe, respectivement à l'aide des propriétés:

-> `mail.<protocol>.user`-> `mail.<protocol>.password`Exemple :

> `mail.transport.protocol=smtpmail.smtp.auth=truemail.smtp.user=user@my.domain.commail.smtp.password=secret`

Note : en l'absence des propriétés `mail.<protocol>.user` et `mail.<protocol>.password`,les identifiants seront récupérés depuis les propriétés obsolètes `mail.user` et `mail.password`.

#### Configuration de la génération des emails

Lorsqu'un email de notification est envoyé par le serveur Workey, les nom et adresse de l'émetteur doivent être spécifiés. Dans l'exemple suivant, le serveur à renseigné les informations de l'expéditeur avec les informations relative à l'Acteur Workey à l'origine de la notification.

Exemple :

```
From: "Eric FRANCK" <ef@c-log.com>
```

'Eric FRANCK', le *personal*, correspondra au nom affichable de l'utilisateur-> récupéré depuis l'annuaire via l´attribut spécifié par la propriété com.clog.workey.userDirectory.**displayNameAttribute**'<ef@c-log.com>' correspondra à l'adresse e-mail de l'utilisateur-> récupérée depuis l'annuaire via l´attribut spécifié par la propriété com.clog.workey.userDirectory.**emailAttribute**

Les propriétés suivantes permettent de paramétrer les informations sur l'expéditeur.

Les emails envoyés sont construits sous forme de [message Mime multi-partie](http://fr.wikipedia.org/wiki/Multipurpose_Internet_Mail_Extensions#Message_en_plusieurs_parties). Il est possible de préciser l'encodage utilisé pour le sujet, le corps du message et les éventuelles pièces jointes.

| **Propriété**                                                              | **Description**                                                                                                                                                                                                                                                                                                                                                                                                                    | **Remarque**                                                                                                                                                                |
| -------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `com.clog.workey.engine.NotificationSender.senderIdentity`                 | <p>-> Indique l'<strong>identité</strong> qui sera utilisée pour renseigner l'entête de l'expéditeur.<br>Deux valeurs sont possibles :<br><code>SERVER</code> : le moteur Workey utilisera son identité pour indiquer l´expéditeur dans les entêtes des e-mails.<br><code>ACTOR</code> : le moteur Workey utilisera l'identité de l'acteur qui est à l´origine de l´envoi de mail (tel qu´une notification sur une opération).</p> | -> Si `senderIdentity` n´est pas renseigné (ou bien renseigné avec une valeur autre que `SERVER` ou `ACTOR`), alors le moteur considèrera qu´il doit être en mode `SERVER`. |
| `com.clog.workey.engine.NotificationSender.mailerName` (optionnel)         | -> Spécifie le **le nom complet** qui sera indiqué en tant qu'expéditeur lorsque le `senderIdentity` est `SERVER`.                                                                                                                                                                                                                                                                                                                 | -> Valeur par défaut `<WORKEY SERVER>`                                                                                                                                      |
| `com.clog.workey.engine.NotificationSender.mailerAddress` (optionnel)      | -> Spécifie l'**adresse e-mail** qui sera indiquée en tant qu'expéditeur lorsque le `senderIdentity` est `SERVER`.                                                                                                                                                                                                                                                                                                                 | <p>-> Il n'y a pas de valeur par défaut pour cette propriété. Elle devra être impérativement renseignée.<br>Exemple : <code><noreply@mydomain.com></code></p>               |
| `com.clog.workey.engine.NotificationSender.mailCharset` (optionnel)        | -> Spécifie l'**encodage du sujet et du corps** de la notification email.                                                                                                                                                                                                                                                                                                                                                          | -> Valeur par défaut : `utf-8`                                                                                                                                              |
| `com.clog.workey.engine.NotificationSender.attachmentEncoding` (optionnel) | -> Spécifie l'**encodage des pièces jointes** des notifications email.                                                                                                                                                                                                                                                                                                                                                             | -> Valeur par défaut : `base64`                                                                                                                                             |

### Contexte des URLs (générées par Workey)

| Les e-mails de notification sont susceptibles de contenir des URL qui désignent des documents Workey. Ces URL pointent sur l'application Web de Workey. Toutefois, le destinataire du mail n'est pas forcément sur l'intranet. En conséquence, l'URL doit être construite au regard du chemin d'accès que devra emprunter le destinataire pour atteindre le document. Le moteur ne pouvant pas savoir qu'il y a une indirection, il est nécessaire de le lui indiquer en précisant le contexte sous lequel est accessible l'application Web. |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

* `com.clog.workey.engine.ExternalURL.serverContext` (optionnel)

> Concrètement, le `serverContext` correspond au début de l'URL. La partie restante de l'URL (correspondant alors au chemin relatif depuis la racine de l'application Web) sera calculée et concaténée au `serverContext`.Exemple : `com.clog.workey.engine.ExternalURL.serverContext=http://mydomain:12345/myContext/workey`Si la propriété est absente ou laissée vide, un contexte par défaut sera utilisé : `http://localhost:8080/workey/workey`Attention, quel que soit le contexte, il doit se terminer par : **/workey***On notera que cette propriété est également utilisée lors de la construction des liens d´accès aux documents exposés dans le résultat des recherches.*

### Evènements

Les propriétés suivantes sont **optionnelles**.

| **Propriété**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | **Description**                               | **Remarque**                                                                                                                                                                                                                                                                                                                      |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <p><code>com.clog.workey.events.preDeployProcess</code><br><code>com.clog.workey.events.postDeployProcess</code><br><code>com.clog.workey.events.preAttachment</code><br><code>com.clog.workey.events.postAttachment</code><br><code>com.clog.workey.events.preNotification</code><br><code>com.clog.workey.events.preSubmitDocument</code><br><code>com.clog.workey.events.postSubmitDocument</code><br><code>com.clog.workey.events.preDeleteDocument</code><br><code>com.clog.workey.events.postDeleteDocument</code></p> | cf. **Les évènements pré-définis de Workey**. | <p>-> ces propriétés doivent être renseignées avec des nom de classe java pleinement qualifiés.<br>-> Il est possible de spécifier une liste de noms de classes pour un même évènement, séparés par des '<code>,</code>' (virgule). Les classes d'évènement seront alors appelées de façon chaînée, dans l'ordre de la liste.</p> |

### Fonctionnalités diverses

Les propriétés suivantes sont **optionnelles**.

| **Propriété**                                                                                                | **Description**                                                                                                                                                                                                                                                                                                                                            | **Remarque**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <p><code>com.clog.workey.admin.adminUrl</code><br>(à partir de Workey 6.4.0)</p>                             | -> Permet de spécifier explicitement l'**URL d'accès** à la console d'administration **depuis le serveur**.                                                                                                                                                                                                                                                | <p>Dans le cadre du déploiement de Workey dans votre architecture réseau, vous pouvez être amené à modifier le contexte sous lequel est accessible la console d'administration. Certaines fonctionnalités du moteur s'appuient sur la console d'administration et doivent être en mesure d'y accéder.<br>-Exemple : mécanisme de transformations XSL pour le remplacement d'acteur, le détail d'acteur, …).<br>-Pour assurer leur bon fonctionnement, il vous sera nécessaire d'<strong>ajouter</strong> cette propriété (ou de la décommenter si elle est déjà présente) et de <strong>renseigner</strong> sa valeur avec l'<code>URL</code><strong>de la console d'administration</strong> accessible depuis le serveur Workey\*\*.\*\*-> Par défaut cette propriété est absente/commentée.</p> |
| `com.clog.workey.archive.debug.docLimit`                                                                     | -> Permet de restreindre arbitrairement le **nombre de document à archiver** à chaque itération.                                                                                                                                                                                                                                                           | <p>La limite du nombre de document à archiver doit être un <strong>entier non nul</strong>. Une valeur nulle ou négative ne spécifie aucune limite.<br>-> La valeur par défaut : <code>-1</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `com.clog.workey.index.analyzer`                                                                             | -> Permet de spécifier une **classe d'analyse spécifique pour l'indexation Lucene**.                                                                                                                                                                                                                                                                       | <p>Renseigner la propriété avec le nom de la classe Java (pleinement qualifié).<br>-> La valeur par défaut : <code>com.clog.workey.search.FrenchSnowballAnalyzer</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| <p><code>com.clog.workey.engine.ActorsService.newActorOnRequestRole</code><br>(à partir de Workey 6.3.6)</p> | -> Permet de **débrayer la création automatique d'acteur**, en cas de « Rôle par défaut », lorsqu'un nouvel utilisateur se connecte à l'application.                                                                                                                                                                                                       | <p>Pour désactiver la création automatique, renseigner explicitement la propriété avec <code>no</code><br>-> Dans le cas contraire, la fonctionnalité est toujours activée</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `com.clog.workey.engine.Delegations.taskTransfer`                                                            | -> Permet d'**autoriser le transfert des tâches** dans le cadre des délégations.                                                                                                                                                                                                                                                                           | <p>Pour activer le transfert des tâches, renseigner la propriété avec <code>true</code><br>-> La valeur par défaut : <code>false</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `com.clog.workey.engine.Delegations.allowsForwardedDelegations`                                              | -> Permet d'**autoriser la propagation des délégations**.                                                                                                                                                                                                                                                                                                  | <p>Pour interdire la propagation des délégations, renseigner la propriété avec <code>false</code><br>-> La valeur par défaut : <code>true</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `com.clog.workey.engine.SubmitDoc.takeInChargeRecorder`                                                      | -> Permet d'**activer le suivi de la prise en charge** des documents.                                                                                                                                                                                                                                                                                      | <p>Pour que les prises en charge/libérations des documents soient tracées, renseigner la propriété avec <code>true</code>.<br>-> La valeur par défaut : <code>false</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `com.clog.workey.engine.QueryWorkflow.initialView`                                                           | -> Permet de spécifier la **vue Workey affichée par défaut**.                                                                                                                                                                                                                                                                                              | La vue souhaitée doit être désignée par son `designer name`.-> Par défaut, la vue standard « `A Faire` » sera affichée.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `com.clog.workey.engine.AttachmentRepository.fileExtension`                                                  | -> Permet d'**associer une extension aux fichiers des pièces jointes**.                                                                                                                                                                                                                                                                                    | Dans le cas où une extension est spécifiée, le caractère '**.**' (point) ne doit pas y être présent.-> Par défaut, Workey n'utilise aucune extension pour les fichiers de pièce jointe.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `com.clog.workey.engine.AttachmentRepository.purgeEnabled`                                                   | -> cf. administration des pièces jointes.                                                                                                                                                                                                                                                                                                                  | -> La valeur par défaut : `false`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `com.clog.workey.engine.AttachmentRepository.directoryStrategy`                                              | <p>-> cf. cf. stratégie de gestion des fichiers.<br>Deux stratégies sont disponibles:StandardDirectoryStrategyHashDirectoryStrategy</p>                                                                                                                                                                                                                    | -> La valeur par défaut : `StandardDirectoryStrategy`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `com.clog.workey.engine.ThumbnailRepository.fileExtension`                                                   | -> Permet d'**associer une extension aux fichiers des vignettes**.                                                                                                                                                                                                                                                                                         | Dans le cas où une extension est spécifiée, le caractère '**.**' (point) ne doit pas y être présent.-> Par défaut, Workey n'utilise aucune extension pour les fichiers des vignettes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `com.clog.workey.engine.ThumbnailRepository.purgeEnabled`                                                    | -> cf. administration des vignettes.                                                                                                                                                                                                                                                                                                                       | -> La valeur par défaut : `false`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `com.clog.workey.engine.ThumbnailRepository.directoryStrategy`                                               | <p>-> cf. stratégie de gestion des fichiers.<br>Deux stratégies sont disponibles:StandardDirectoryStrategyHashDirectoryStrategy</p>                                                                                                                                                                                                                        | -> La valeur par défaut : `StandardDirectoryStrategy`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `com.clog.workey.engine.ThumbnailRepository.scalingMethod`                                                   | -> cf. génération des vignettes.                                                                                                                                                                                                                                                                                                                           | -> La valeur par défaut : `AUTOMATIC`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `com.clog.workey.engine.ThumbnailRepository.MIMEType`                                                        | <p>-> cf. type MIME des vignettes.<br>Le type MIME des vignettes générées peut être l'un des suivants:image/png<br>image/gif<br>image/jpeg<br>image/pjpeg</p>                                                                                                                                                                                              | -> La valeur par défaut : `image/png`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `com.clog.workey.engine.ThumbnailRepository.useAntiAliasing`                                                 | -> Permet de désactiver l'usage de l'anti-crénelage pour les vignettes.                                                                                                                                                                                                                                                                                    | <p>-> Renseigner cette propriété avec la valeur <code>false</code> pour <strong>désactiver l'anti-crénelage</strong> (anti-aliasing).<br>-> La valeur par défaut : <code>true</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| <p><code>com.clog.workey.engine.defaultLanguage</code><br>(à partir de Workey 6.0.2)</p>                     | <p>-> Permet de<strong>définir explicitement la langue par défaut</strong> pour le moteur Workey.<br><br>-> cf. <strong>Multilinguisme dans l'interface Web standard</strong>.</p>                                                                                                                                                                         | <p>Si la propriété n'est pas définie alors la langue sera celle définie par la variable Java : <code>user.language</code><br><br>-> <em>Cette langue doit faire partie de la liste des langues supportées</em>.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| <p><code>com.clog.workey.engine.supportedLanguages</code><br>(à partir de Workey 6.0.2)</p>                  | -> Permet de spécifier **la liste des langues supportées** par le moteur Workey.-> cf. **Multilinguisme dans l'interface Web standard**.                                                                                                                                                                                                                   | -> *Cette liste doit contenir la langue par défaut utilisée par le moteur*.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `com.clog.workey.patch.ApplySpeedy.dropConflictingIndexes`                                                   | <p>-> Permet d'<strong>autoriser explicitement la suppression des index</strong> <em>conflictuels</em>.<br><br>A chaque démarrage du serveur Workey, une vérification des index présents sur les tables de la base socle est effectuée afin de s'assurer que l'ensemble des index requis sont présents et que leur définition est bien celle attendue.</p> | <p>Dans les cas où:un index de même nom existe déjà mais a une définition différente (colonne(s) et/ou ordre des colonnes différent),un index de nom différent existe déjà et correspond à la définition requise,-> alors, cet index <em>conflictuel</em> doit être supprimé pour permettre de créer celui attendu.A défaut de pouvoir supprimer les index <em>conflictuels</em>, les index requis ne pourront pas être mis en place.<br>-> Renseigner cette propriété avec la valeur <code>true</code> pour <strong>autoriser la suppresion</strong>.<br>-> La valeur par défaut : <code>false</code></p>                                                                                                                                                                                        |
| `com.clog.workey.web.CustomSkinUrl`                                                                          | -> Permet de spécifier **l'`URL` d'une&#x20;*****servlet*****&#x20;desservant des fichiers personnalisés de CSS et/ou JS** utilisables par l'interface Web standard.                                                                                                                                                                                       | Propriété renseignée avec le contexte d'une *servlet* déployée séparemment (fichier **.war** distinct) dans le serveur *Apache Tomcat*.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `com.clog.workey.web.main.connector.documentClose`                                                           | <p>-> Permet de spécifier <strong>une redirection suite à la soumission d'un document</strong> Workey dans l'interface Web standard.<br>-> <em>Cette propriété relève de développements spécifiques</em>.</p>                                                                                                                                              | Propriété renseignée avec un nom de classe Java (pleinement qualifié).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |

## Annexe B — Annuaires LDAP

### Utilisation de l´annuaire LDAP

Pour identifier les utilisateurs, Workey s'appuie sur un système d´annuaire interrogeable via le protocole **LDAP** (*Lightweight Directory Access Protocol*). Il est possible de dissocier l´annuaire d´authentification (ou « *annuaire système* » contenant login/mot de passe) de l´annuaire informationnel (parfois désigné sous le nom d´« annuaire d´entreprise » contenant par exemple : noms complets, adresse e-mail, …).

Les « Acteurs » (utilisateurs de l´application Workey) sont identifiés par une « **clef utilisateur** » (userKey) **invariante** et **unique**.

Cette « clef utilisateur » est définitivement attribuée à l´Acteur lorsque l´utilisateur correspondant dans l´annuaire est affecté, pour la première fois, soit à un Rôle, soit à une Unité Organisationnelle dans l´application Workey. -> Le moteur Workey ne connaît les utilisateurs que par cette « clef utilisateur ».

-> La valeur de cette « clef utilisateur » provient de l´annuaire informationnel et doit être du type ***chaîne de caractères*** (pas d´objets binaires).

Dans le cas où l´annuaire d´authentification est différent de l´annuaire informationnel, il est essentiel que chaque utilisateur soit présent dans les deux annuaires et associé à une même « clef utilisateur ». Exemple : la « clef utilisateur » pourrait être un numéro d'employé ou un matricule (invariant dans le temps).

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-b9ef000f71c7e9d0a6cce0b59b1e6bacc3cb9ddf%2Fprocess-deploy-annexes-annuaires-ldap-01.webp?alt=media" alt=""><figcaption></figcaption></figure>

Les principaux cas de figure d'utilisation des annuaires par Workey sont :

.**Authentification d'un utilisateur** (annuaire d'authentification)

clef de recherche : le login de l'utilisateur

paramètre supplémentaire : le mot de passe de l'utilisateur

réponse attendue de l'annuaire : la « clef utilisateur », en cas d'authentification réussie.

**Navigation dans l'annuaire informationnel**, afin de définir les utilisateurs qui seront « Acteurs » dans Workey

clef de recherche: aucune

paramètre supplémentaire: utilisation d'un filtre LDAP

réponse attendue de l'annuaire : les noms complets des utilisateurs et leur « clef utilisateur ».

.**Récupération de données depuis l'annuaire informationnel**, pour un « Acteur » donné

clef de recherche: la « clef utilisateur » (userKey associée à l'« Acteur »)

paramètre supplémentaire : le nom de l'attribut contenant l'information souhaitée

réponse attendue de l'annuaire : la valeur de l'attribut contenant l'information recherchée

Dans la **configuration du serveur Workey** : -> Les propriétés `com.clog.login.*` permettent de décrire l'annuaire utilisé pour la phase d'authentification des utilisateurs.

-> Les propriétés `com.clog.userDirectory.*` permettent de décrire l'annuaire contenant les informations relatives aux utilisateurs authentifiés.

Ces ensembles de propriétés doivent être définies. Toutefois, si votre environnement n´utilise qu´un seul annuaire, alors ces deux jeux de propriétés devront être renseignés de manière à être en phase et désigner ainsi votre annuaire unique.

## Annexe C — DataSources

| Nous désignerons par :`<CATALINA_HOME>`, le chemin pointant vers le répertoire de base où est installé le serveur Apache Tomcat. |
| -------------------------------------------------------------------------------------------------------------------------------- |

### Datasources requises

D'une manière générale, les bases de données sont présentées par *Tomcat* comme des ressources (appelées `datasources`) mise à disposition du moteur Workey. L'accès à ces bases est géré par un gestionnaire de connexions. Chacune de ces datasources est nommée.

La définition des datasources s'effecture via le fichier `<CATALINA_HOME>/conf/context.xml`. -> Assurez-vous d´utiliser le fichier **context.xml** correspondant au SGBD utilisé pour la base socle du serveur Workey (cf. **Installation des fichiers du serveur**).

Quelque soit le SGBD retenu pour la base socle, ce fichier déclare par défaut les différentes `datasources` requises par Workey. Celles-ci sont nommées comme suit et devront être configurées pour désigner votre base socle :

* `Workey_RW_DS`
* `Workey_RO_DS`
* `QuartzDS`

### Configuration d'une Datasource

Chaque datasource est prise en charge par un gestionnaire de connexion. Celui-ci va maintenir un pool de connexion vers la base de données désignée (cf. **création de la base de donnée socle**), et a besoin des informations suivantes :

* le **nom du serveur**, ou son **adresse IP** (ci-après référencé par -> `WKY_DB_HOST`)
* le numéro du **port TCP** du SGBD (-> `WKY_DB_PORT`)
* le **nom de la base** de données (-> `WKY_DB_NAME`)
* les identifiants de connexion : le **nom d'utilisateur** (-> `WKY_DB_USER`) et son **mot-de-passe** associé (-> `WKY_DB_PASSWORD`).

{% hint style="info" %}
Avant de définir une datasource, destinée à adresser un SGBD différent de celui de la base socle de Workey, assurez-vous d'avoir copier le(s) fichier(s) du **driver `JDBC`** adéquat(s) dans le répertoire : `<CATALINA_HOME>/lib`
{% endhint %}

La définition d'une datasource se fait à l'aide d'un élément `<Resource>` dans le fichier `context.xml`.

Exemple :

`<Resource name="Workey_RW_DS" auth="Container" type="javax.sql.DataSource"`

`maxActive="100" maxIdle="30" maxWait="10000"`

`username="WKY_DB_USER" password="WKY_DB_PASSWORD" driverClassName="com.mysql.jdbc.Driver"`

`url="jdbc:mysql://WKY_DB_HOST:WKY_DB_PORT/WKY_DB_NAME"`

`validationQuery="SELECT 1" testOnBorrow="true"/>`

-> Note: s'agissant d'un fichier `XML`, nous attirons votre attention sur la nécessité d'[échapper tout caractère non autorisé](http://www.w3.org/TR/2008/REC-xml-20081126/#syntax).

| **Nom de l'attribut** | **Description**                                                                                                                                                                                          | **Remarque**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `name`                | **Nom JNDI** de la datasource.                                                                                                                                                                           | -> Seuls les noms des datasources requises par le moteur Workey sont fixes/imposés.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `auth`                | **Authentification** de la ressource:ApplicationContainer                                                                                                                                                | -> Par défaut, l'authentification est assurée par le gestionnaire : `Container`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `type`                | **Classe Java** de l'objet à générer pour la ressource.                                                                                                                                                  | -> Par défaut, la ressource sera un objet Java de classe `javax.sql.DataSource`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `maxActive`           | Nombre **maximum de connexion actives** simultannées dans le pool.                                                                                                                                       | -> Le nombre maximum de connexion disponible doit permettre d'amortir les pics de charge, sans pour autant grever les ressources mémoire du serveur.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `maxIdle`             | Nombre de **connexion toujours disponible**. La taille du pool de connexion varie dans le temsp au regard de la charge. Ce nombre sera la limite inférieure de connexion maintenue active à tout moment. | -> Le nombre de connexion disponible doit permettre d'amortir les pics de charge, sans pour autant grever les ressources mémoire du serveur.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `maxWait`             | L'acquisition d'une nouvelle connexion pour le pool n'est pas instantannée. **Délai d'attente maximum** en millisecondes pour l'obtention d'une connexion à la base de données.                          | -> Selon les aléas de charge du SGBD, il est conseillé de ne pas spécifier une valeur trop basse afin de laisser l'opportunité à celui-ci de répondre à la requête d'allocation de ressource.                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `username`            | Le **nom d'utilisateur** pour la connexion au SGBD.                                                                                                                                                      | -> A renseigner avec la valeur que nous avons désigné par `WKY_DB_USER`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `password`            | Le **mot-de-passe** associé au nom d'utilisateur pour la connexion au SGBD.                                                                                                                              | -> A renseigner avec la valeur que nous avons désigné par `WKY_DB_PASSWORD`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `driverClassName`     | Le nom de la **classe Java du driver JDBC**.                                                                                                                                                             | <p>-> Le nom de la classe Java est spécifique à chaque driver JDBC :<br>pour mySQL : <code>com.mysql.jdbc.Driver</code><br>pour Oracle : <code>oracle.jdbc.driver.OracleDriver</code><br>pour PostgreSQL : <code>org.postgresql.Driver</code><br>pour Microsoft SQLServer : <code>com.microsoft.sqlserver.jdbc.SQLServerDriver</code></p>                                                                                                                                                                                                                                                                                |
| `url`                 | **URL de connexion JDBC** pointant vers la base de donnée.                                                                                                                                               | <p>-> La syntaxe de l'URL est spécifique à chaque SGBD :<br>pour mySQL : <code>jdbc:mysql://WKY\_DB\_HOST:WKY\_DB\_PORT/WKY\_DB\_NAME</code><br>pour Oracle : <code>jdbc:oracle:thin:@WKY\_DB\_HOST:WKY\_DB\_PORT:WKY\_DB\_NAME</code><br>pour PostgreSQL : <code>jdbc:postgresql://WKY\_DB\_HOST:WKY\_DB\_PORT/WKY\_DB\_NAME</code><br>pour SQLServer : <code>jdbc:sqlserver://WKY\_DB\_HOST:WKY\_DB\_PORT;databaseName=WKY\_DB\_NAME</code><br>-> Ces URLs sont à renseigner à l'aide des valeurs que nous avons désigné par:<code>WKY\_DB\_HOST</code>, <code>WKY\_DB\_PORT</code> et <code>WKY\_DB\_NAME</code>.</p> |
| `validationQuery`     | Permet de spécifier une **requête SQL** qui sera préalablement exécutée afin de s'assurer que la connexion est toujours valide.                                                                          | -> Cette requête doit être simple et peu coûteuse (tout en étant valide au regard du SGBD).Exemple : `SELECT 1` ou `SELECT 1 FROM DUAL` (pour Oracle).                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `testOnBorrow`        | Indique que **chaque connexion** tirée du pool pour être utilisée **doit être testée**.                                                                                                                  | -> A renseigner à `true` pour que la requête spécifiée dans `validationQuery` soit systématiquement exécutée lors de l'utilisation d'une connexion issue du pool.                                                                                                                                                                                                                                                                                                                                                                                                                                                        |

## Annexe E — Ressources Externes

Voici quelques liens pointant sur la documentation officielle de Tomcat (en Anglais) concernant l'administration et la configuration des serveurs.

* Tomcat 7

[User Guide](http://tomcat.apache.org/tomcat-7.0-doc/index.html)

[Migration Guide](http://tomcat.apache.org/migration.html)

[Datasource management](http://tomcat.apache.org/tomcat-7.0-doc/jndi-datasource-examples-howto.html)

[Tomcat en service sous Windows](http://tomcat.apache.org/tomcat-7.0-doc/windows-service-howto.html)

[Utilisation de log4j dans Tomcat](http://tomcat.apache.org/tomcat-7.0-doc/logging.html#Using_Log4j)

* Configuration de Log4J

[Tutoriel de configuration de Log4J](http://www.tutorialspoint.com/log4j/log4j_configuration.htm)

[Tutoriel niveau de journalisation de Log4J](http://www.tutorialspoint.com/log4j/log4j_logging_levels.htm)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://documentation.efalia.com/produit/efalia-process/administration/annexes-techniques.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
