> 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/designer-html.md).

# Designer HTML

## Autres sources d'informations

* Guide du concepteur, fonctions avancées : contient des informations détaillées sur des fonctions permettant de régler finement le fonctionnement des applications de Workflow à partir de la modélisation.
* Manuel de référence de l'atelier de modélisation : définit systématiquement tous les concepts implémentés dans l'atelier de modélisation.
* Trucs et astuces : liste de documents contenant des informations utiles aux concepteurs, aux administrateurs et aux utilisateurs d'applications générées avec Workey.
* Sur le Web : le site [http://www.support.efalia.com/](https://support.efalia.com/)contient la dernière version à jour des différents guides Workey.

## Connexion au Designer

**Si vous utilisez Workey Designer**

Démarrez votre **serveur web** et rendez-vous à l'adresse de workey-designer dans votre navigateur (contactez votre administrateur réseau si vous ignorez la bonne adresse).

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

Connectez-vous à Workey Designer avec un utilisateur qui à un rôle défini dans l'administration de workey comme le **Gestionnaire de flux de travail**.

En cas de doute, sur les identifiants à entrer, contactez votre administrateur réseau ou la personne qui à installé Workey.

Vous pourrez ensuite vérifier dans votre console d'administration de Workey quels utilisateurs peuvent se connecter à l'interface.

Normalement, la page de connexion s'affiche dans la langue configuré par défaut dans le navigateur mais vous pouvez choisir une autre langue dans le menu **langue**.

## Ouvrir / réaffecter un projet (version online uniquement)

Les différents projets sont nominatifs et sont enregistrés en base de données. Pour ouvrir un projet existant cliquer sur Fichier / Ouvrir.

Sélectionner le projet à ouvrir.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-5b88cb5e5822bb15017f7e921292c4529c5095fe%2Fprocess-config-designer-html-02.webp?alt=media" alt=""><figcaption></figcaption></figure>

Si vous êtes connecté en tant qu'**utilisateur simple** vous pouvez :

* Ouvrir ses projets
* Supprimer ses projets

Si vous êtes connectés en tant qu'**administrateur**, vous avez la possibilité de voir les différents projets de la base sans pour autant en être l'auteur.

Vous pouvez ainsi :

* Ouvrir des projets d'un autre auteur
* Supprimer des projets d'un autre auteur
* Réaffecter des projets : Pour cela, sélectionner un utilisateur depuis la liste déroulante "Assigner à". L'utilisateur sélectionné, devient alors le nouveau propriétaire de projet. Pour qu'un utilisateur figure dans cette liste, il suffit que l'utilisateur se soit connecté au moins une fois à Workey Designer.

Vous pouvez également récupérer les projets réalisés avec le designer flash en important une sauvegarde flash.

## IHM

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-226d57ea4eadfb1daf03dddb3468d23603ee214d%2Fprocess-config-designer-html-03.webp?alt=media" alt=""><figcaption></figcaption></figure>

L'interface de Workey Designer se compose de plusieurs panneaux :

| Une **barre de menus** qui regroupe les principales fonctions de manipulation sur les fichiers et applications externes,une **barre d'outils** regroupant des icônes et fonctions de manipulation des objets Workey,un panneau des **Projets**et un **Explorateur**de projets, un panneau des **messages** d'erreur et avertissements de la console Workey designer et enfinun panneau **principal**de construction des graphes. | <p><br>Pour un meilleur confort d'utilisation de l'application, nous recommandons d'utiliser Workey Designer en plein écran et en haute résolution.</p> |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |

### Manipulation des objets

***

Les objets Workey se manipulent grâce au bouton gauche de la souris.On peut ***cliquer*** un objet pour le sélectionner, les ***cliquer-déplacer*** pour modifier leur position dans les graphes, les ***double-cliquer*** ou les \_**maj-cliquer(en maintenant la touche \[Maj ou Shift] appuyée avant de les cliquer)\_pour ouvrir leur fenêtre d'édition ou encore les \_control-cliquer**(en maintenant la touche \[Ctrl] appuyée avant de les cliquer)\_pour créer un graphe associé.

Pour effectuer une **sélection multiple** des objets dans un graphe, un simple cliqué-déplacé suffit. Cliquez à un endroit du graphe, déplacez la souris en maintenant le bouton gauche appuyé vers un autre endroit puis relâchez le bouton de la souris. Tous les objets se trouvant dans la zone de déplacement seront automatiquement sélectionnés. On peut aussi cliquer directement les objets désirés en maintenant la touche Ctrl du clavier enfoncée pour les sélectionner. Ctrl-cliquer un objet sélectionné le retirera de la zone de sélection.

Pour sélectionner d'un coup tous les objets du graphe courant, utilisez le raccourci Ctrl+A.

### Panneau principal

Le panneau Principal affiche les graphes ouverts et les présente sous divers onglets. Les libellés des onglets reprennent le nom du graphe affiché. En cliquant sur le libellé d'un onglet, on affiche le graphe dans le panneau principal tandis qu'en cliquant sur la croix à droite de l'onglet, on le ferme.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-4d51b0293642279d27ef8f1e9e09fe063546a932%2Fprocess-config-designer-html-04.webp?alt=media" alt=""><figcaption></figcaption></figure>

#### Navigation dans les graphes

Afin de naviguer facilement dans les graphes, plusieurs possibilités sont mises à disposition des concepteurs:

* Des barres de défilements horizontale et verticale pour faire défiler les contenu affiché
* Des boutons pour zoomer et dézoomer le graph (voir plus de détails dans la Barre d'Outils)

Une autre solution pour naviguer est d'utiliser le composant d'aperçu, ici positionné en bas à gauche du graphe:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-29a448edb0fb6d0b8c11693310384dd522c4fd0e%2Fprocess-config-designer-html-05.webp?alt=media" alt=""><figcaption></figcaption></figure>

Cliquer sur le bouton ![](https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-7b4ff9160d4404f2a541d81405d5603caa85b428%2Fprocess-config-designer-html-06.png?alt=media)

afin d'afficher ou masquer l'aperçu. Celui-ci permet les actions de navigation suivantes:

* se déplacer dans le graphe : maintenir clic-gauche enfoncé sur le rectangle bleu et le glisser pour se déplacer dans le graphe
* zoomer/dézoomer : positionner le curseur de la souris au dessus de l'apercu et actionner la molette de votre souris vers l'avant ou vers l'arrière
* centrer le graphe : effectuer un clic-gauche sur l'aperçu pour centrer le graphe sur le point cliqué

## Menus

La barre de menu de Workey regroupe les fonctions de manipulation des fichiers et applications externes.

### Projet

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-c2b655d5fe697494d75239d8c8b253f5a44e8a47%2Fprocess-config-designer-html-07.webp?alt=media" alt=""><figcaption></figcaption></figure>

* **Nouveau** : Créé un nouvel élément pour l'objet sélectionné dans le panneau Projets. En fonction du type de modèle, l'icône affiché sera différent.
* **Ouvrir** : Ouvre la fenêtre de sélection d'un projet existant dans la base de données.(version on line uniquement)
* **Enregistrer**: Enregistre (Insert) le projet courament sélectionné vers la base de données. (version on line uniquement)
* **Fermer**: Ferme le projet courant
* **Supprimer** : Supprime l'objet courament sélectionné.
* **Vérifier** : Lance l'outil de vérification de l'intégrité des règles de modélisation pour le projet couramment sélectionné. (version on line uniquement)
* **Déployer** vers Workey Engine : Lance l'outil de génération du projet courament sélectionné et prépare le déploiement du processus vers le serveur de workflow Workey Engine. (version on line uniquement)
* **Réindexer le projet** :Vérifie et corrige les incohérences du contenu du projet.
* **Importer** : Permet l'import d'une sauvegarde .wky ou bien l'import d'une sauvegarde issue d'un designer Flash
* **Exporter** : Permet l'export d'un projet au format .wky
* **Migrer** : Permet la récupération d'un fichier .xml issu d'un projet au format workey V5 (.gti)

### Édition

* **Dupliquer** : Permet la duplication (copie) de l'objet sélectionné
* **Supprimer** : Permet la suppression de l'objet sélectionné
* **Rechercher** : Permet l'accès au menu de recherche afin de retrouver un objet de la modélisation

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-96a1c014fc6256a9082e7ef9345b713a822f3c28%2Fprocess-config-designer-html-08.webp?alt=media" alt=""><figcaption></figcaption></figure>

### Outils

* **Domaines…** : Affiche une liste interactive des domaines de champs

## Barre d'outils

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-d2964bdfa927276f24fdb07d7377c45b53155f75%2Fprocess-config-designer-html-09.webp?alt=media" alt=""><figcaption></figcaption></figure>

La barre d'outils regroupe les fonctions majeures de manipulation des objets.

### Icônes

**Projet** :

* **Nouveau** : Créé un nouvel élément pour l'objet sélectionné dans le panneau Projets. En fonction du type de modèle, l'icône affiché sera différent.
* **Ouvrir** : Ouvre la fenêtre de sélection d'un projet existant dans la base de données.(version on line uniquement)
* **Enregistrer**: Enregistre (Insert) le projet courament sélectionné vers la base de données. (version on line uniquement)
* **Supprimer** : Supprime l'objet courament sélectionné.
* **Vérifier** : Lance l'outil de vérification de l'intégrité des règles de modélisation pour le projet couramment sélectionné. (version on line uniquement)
* **Déployer** vers Workey Engine : Lance l'outil de génération du projet courament sélectionné et prépare le déploiement du processus vers le serveur de workflow Workey Engine. (version on line uniquement)
* **Dupliquer** : Permet la duplication (copie) de l'objet sélectionné
* **Relations Processus/procédures**: Affiche la relation entre les processus/procédures ainsi que leur description
* **Graphes Parents** : Permet de remonter d'un graphe et ainsi d'atteindre le graphe parent d'une procédure.
* **Mode contrainte** : Affiche la vue contraintes organisationnelles associés au graphes
* **Graphe Zoom** : Permets le zoom d'une procédure depuis un processus
* **Zoom +**: Agrandit l'échelle d'affichage du graphe courant.
* \*\***Zoom 1:1** :\*\*Réinitialise l'échelle d'affichage du graphe courant à 1:1 (original).
* **Zoom** – : Réduit l'échelle d'affichage du graphe courant.
* **Ajuster la taille** : Optimise l'échelle d'affichage du graphe courant pour qu'il soit entièrement visible dans le panneau central de composition.

Attention certaines restrictions sont imposées par l'outil :certains objets ne peuvent être coupés dans un graphe certains objets ne peuvent être collés dans un graphe (car la modélisation l'interdit)

Lors de l'action coller, le modélisateur pour informera que des objets n'ont pu être collés.

**Modèle de Processus**

* **Graphes Parents** : Effectue un *Zoom arrière* vers le graphe portant le graphe courant.
* **Dupliquer**: Permet de dupliquer l'objet sélectionné
* **Graphe Zoom** : Permet d'effectuer un Zoom avant vers le graphe décrivant l'objet sélectionné.

**Procédures**

* **Contraintes** : Affiche le graphe courant en mode Contraintes.
* **Zoom +** : Agrandit l'échelle d'affichage du graphe courant.
* **Zoom –** : Réduit l'échelle d'affichage du graphe courant.
* **Zoom 1:1** : Réinitialise l'échelle d'affichage du graphe courant à 1:1 (original).
* **Ajuster la taille** : Optimise l'échelle d'affichage du graphe courant pour qu'il soit entièrement visible dans le panneau central de composition.

## Messages

Lorsqu'une fonctionnalité d'un processus est modélisée, il est bon de prendre l'habitude de vérifier fréquemment que les règles de génération prévues par le moteur sont respectées, afin d'avoir le moins possible d'erreur au moment où vous déciderez de générer l'application.

Habituellement, ce message est affiché :

mais de temps en temps, quelques éléments inattendus peuvent se produire, comme par exemple :

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-76ed2cadd03b3730639aa9f06f6ad72479df7670%2Fprocess-config-designer-html-10.webp?alt=media" alt=""><figcaption></figcaption></figure>

La fenêtre des erreurs liste les éléments qu'il faut vérifier et corriger pour qu'un projet puisse être déployé sur le serveur web de workflow pour être testé. Il suffit de cliquer sur une ligne d'erreur pour sélectionner automatiquement l'objet correspondant dans le panneau central de composition de graphe ou le formulaire.

## Projets et Explorateur

Un projet regroupe tous les graphes et formulaires liés à un projet spécifique. Chaque section peut être **dépliée**ou **repliée**pour afficher/masquer la liste des objets la composant.

Le panneau **Explorateur**permet de visualiser pour un projet donné l'ensemble des objets créés. Les objets y sont organisée par processus et par procédure. L'explorer donne un meilleur aperçu des objets créés en fonction de leur utilisationn, ainsi que de leur hiérarchie dans la modélisation.

## Composants

Le panneau des Composants permet de composer un graphe ou un formulaire en y ajoutant des objets.

Chaque type de graphe à des Composants spécifiques disponibles. Certains composants seront masqués lorsqu'ils ne sont pas compatibles avec le graphe choisi et affichés lorsqu'ils le sont.

* Exemple : On ne peut pas ajouter de Vue embarquée dans un Organigramme. Le composant Vue embarquée sera donc masqué lorsque le graphe Organigramme est sélectionné.

### Objets

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-dc9cfd74f340c3743f392756c0f771b4fd9c0e87%2Fprocess-config-designer-html-11.webp?alt=media" alt=""><figcaption></figcaption></figure>

Le premier volet du panneau des Composants regroupe les objets qui sont utilisables pour le graphe sélectionné.

En fonction du mode sélectionné, les objets disponibles varieront.

Par exemple, les objets définissant des contraintes ne seront disponibles que lorsque le mode contrainte est activé et les objets de champs ne seront disponibles que lorsqu'un formulaire sera sélectionné.

Afin de construire un graphe, cliquez avec le bouton gauche de la souris sur le composant désiré et faites glisser l'objet dans le panneau central de composition du graphe.

### Navigation entre graphes

Workey propose un mécanisme de navigation entre graphes permettant depuis un graphe d'opérations, d'ouvrir le graphe d'opérations avec lequel il communique. A tout moment, on peut retrouver le graphe principal auquel l'objet courant est lié en cliquant sur l'icône "Graphes Parents" (image ci-dessous) sur la barre d'actions de Workey Designer.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-3947900f4b973b3197df3aaf994dcfb24493acb6%2Fprocess-config-designer-html-12.png?alt=media" alt=""><figcaption></figcaption></figure>

Il est aussi possible d'effectuer un zoom sur un objet pour créer ou accèder au graphe lui correspondant. Pour cela, double-cliquez sur l'objet en maintenant la touche \[Ctrl] du clavier appuyée, puis relachez la touche.

### Liens

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-2b207cea6b480b9b55e168533061e06d6887e57d%2Fprocess-config-designer-html-13.webp?alt=media" alt=""><figcaption></figcaption></figure>

Tout comme pour les objets, les liens du panneau des composants varient selon l'objet sélectionné.

Certains types de liens ne peuvent être utilisés que dans des conditions spécifiques. Workey interdira les liaisons invalides en masquant un type de lien qui ne peut pas être utilisé dans un graphe.

### Annotations

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-c4c13d6e2f576cd06c46c18b5a1ccb8de2e8759d%2Fprocess-config-designer-html-14.png?alt=media" alt=""><figcaption></figcaption></figure>

Pour plus de précision, plus de clarté et pour une meilleur présentation des idées, il est possible d'ajouter dans tous les graphes, des dessins de description.

Ceux-ci sont purement descriptifs et n'ont aucune influence sur la génération des règles du processus.

Ajouter des dessins descriptifs améliorera grandement le travail collaboratif et la communication sur les projets. Chaque dessin possède ses propres propriétés visuelles (Rectangle, Ellipse, Triangle, Cercle) pour mieux personnaliser vos graphes. Ainsi que les propriétés graphiques associées telles que la couleur, les coins arrondis, la taille du texte associée et ses propriétés, la bordure ou le degré de remplissage.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-5a7c2f08dc578f9827d30a1f04b1c3febc087edf%2Fprocess-config-designer-html-15.webp?alt=media" alt=""><figcaption></figcaption></figure>

Vous avez aussi la possibilité d'insérer une image directement au sein d'un modèle via cet icone :

**Attention**: la taille de l'image est limitée à 100Ko.

Lorsque vous déposez une annotation dans un graphe, celle-ci se place automatiquement au premier plan. Afin de pouvoir cliquer sur les objets qui se retrouvent derrière (image-ci dessous), Cliquez sur le bouton "descendre la sélection à l'arrière plan" Cela enverra l'annotation à l'arrière plan du graphe.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-fcf40f7d282124c76ed4d25f9e3037f84c12bab9%2Fprocess-config-designer-html-16.png?alt=media" alt=""><figcaption></figcaption></figure>

### Propriétés

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-f6355ed9b7580735ec4f25ea7a8f3ccf0b0fc4e5%2Fprocess-config-modelisation-creer-une-procedure-14.png?alt=media" alt=""><figcaption></figcaption></figure>

Chaque objet Workey possède ses propres propriétés. Selon le type d'objet, toutes les propriétés ne seront pas affichées. Il en existe en totalité six ;

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-d7fd15a850e56f26515f6ee28b44b0ae1dc5f890%2Fprocess-config-modelisation-creer-un-projet-08.png?alt=media" alt=""><figcaption></figcaption></figure>

Le symbole "maison" selon l'objet utilisé dispose plus au moins d'attributs

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-d262c96f30ad6fb7c7f576136736d02c0bf7f6cf%2Fprocess-config-modelisation-creer-une-procedure-15.webp?alt=media" alt=""><figcaption></figcaption></figure>

En général, le libellé et le nom interne sont les deux propriétés standard associées ce symbole. Si on prends l'exemple d'un formulaire, il vous sera proposé également ces deux attributs. De plus on pourra également sélectionner le document associé au formulaire, activer l'aperçu des pièces jointes, ainsi que le champ pièce jointe à prévisualiser. L'ensemble de ce détail sera communiqué ultérieurement dans la suite de la documentation en fonction des objets décrits.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-a89b1db5ca12e16a74038005fce7960d2997fdbd%2Fprocess-config-modelisation-creer-une-procedure-16.webp?alt=media" alt=""><figcaption></figcaption></figure>

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-240154be4130784ecbe33031a4daa07c19a12ebc%2Fprocess-config-modelisation-creer-un-projet-09.png?alt=media" alt=""><figcaption></figcaption></figure>

Le logo manuscrit permet de saisir les informations relatives à la description ou l'aide de l'objet concerné

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-8de00bb441f951413f280f6b486d5f66244bf9dd%2Fprocess-config-modelisation-creer-une-procedure-17.webp?alt=media" alt=""><figcaption></figcaption></figure>

<img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-1f034e712733c8fe8216d5ee4851e6118e17db10%2Fprocess-config-modelisation-creer-une-procedure-18.png?alt=media" alt="" width="24">

Ce symbole permet d'indentifier les informations techniques relatives à l'objet concerné

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-44bf6fcd447f988175cbbaee53a0be42cb946d39%2Fprocess-config-modelisation-creer-une-procedure-19.webp?alt=media" alt=""><figcaption></figcaption></figure>

<img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-006ea0f9f0da4e261178df0ffe98a30618f60cf4%2Fprocess-config-modelisation-creer-une-procedure-20.png?alt=media" alt="" width="24">

Ce symbole est associé aux états des documents ainsi qu'à ses propriétés

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-23f9f99fdd2120e3faf394fa51777e268f8bc344%2Fprocess-config-modelisation-creer-une-procedure-21.webp?alt=media" alt=""><figcaption></figcaption></figure>

Il permet de sélectionner le nom de l'état ou bien d'en saisir un nouvel état personnalisé (voir image ci-dessous).

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-4a594eca092ffb9992bfa1d10d26ba50da882d97%2Fprocess-config-modelisation-creer-un-projet-06.webp?alt=media" alt=""><figcaption></figcaption></figure>

Ou bien de renommer un nom d'état existant en utilisant l'unicité de cette information sur l'ensemble des états présents sur le projet. En d'autres termes, si l'état "Pour facturation" est présent trois fois et qu'on renomme l'état en "Facturation" avec la case "Modifier tous les états : Pour facturation" de cochée préalablement, alors, l'état "Pour facturation" sera renommé en "Facturation" sur l'ensemble du projet.

La description de l'état permet de documenter l'état.

Le libellé visible de l'état remplacera le libellé standard de l'état.

Le rang permet de définir l'ordre de priorité d'un état. Cela permet de choisir quel état sera affiché en premier à l'utilisateur.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-384dc83c7f6dbb3a7a924ba63d7d093667dbc7ea%2Fprocess-config-modelisation-creer-une-procedure-22.png?alt=media" alt=""><figcaption></figcaption></figure>

Le symbole formulaire permet de visualiser l'ensemble des formulaires associés à un document. A ce stade on peut redéfinir ou définir les formulaires par défaut en archivage "A", lecture "L", écriture "E" aasociés au document.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-da3507d2cfb8f7c3d6305beaa1e29ba37b2a2417%2Fprocess-config-modelisation-creer-une-procedure-23.webp?alt=media" alt=""><figcaption></figcaption></figure>

A l'aide du bouton

on peut créer un nouveau formulaire à associer au document. Quant au bouton

<img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-03828a41366f478935d225f5e1277b7dc2033e4a%2Fprocess-config-modelisation-creer-une-procedure-25.png?alt=media" alt="" width="24">

il permet le rattachement d'un formulaire non rattaché à un document.

<img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-8b42f4061aa26d55808f44c1993bbe5f17abed1e%2Fprocess-config-modelisation-creer-un-projet-12.png?alt=media" alt="" width="24">

Ce symbole indique les connecteurs sur opération (en pré-connecteur ou post-connecteur) existants, ou bien il permet la création/destruction d'un connecteur.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-703e4f220b3a1efef83c955ebeed14971f0b0190%2Fprocess-config-modelisation-creer-une-procedure-26.webp?alt=media" alt=""><figcaption></figcaption></figure>

Les connecteurs sont de deux types (SQL ou classe java). La fenêtre de paramétrage permet de sléectionner les champs impactés par les données d'entrée et de sortie définies par la requête ou la classe java appellée.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-43ccf9aa1ccf34f5fd4d689570114601b70fd9db%2Fprocess-config-modelisation-creer-un-projet-13.webp?alt=media" alt=""><figcaption></figcaption></figure>

## Domaines

Certains champs nécessitent la définition d'un domaine de valeurs prédéfinies.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-f454f3730a1f67768b40f98dacbf5dee8a7773b8%2Fprocess-config-modelisation-creer-un-projet-05.webp?alt=media" alt=""><figcaption></figcaption></figure>

| <p>Nouveau domaine.</p><p><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-840db044e06d66ec85cb9ed3bdda40989cf98951%2Fprocess-config-modelisation-creer-une-procedure-24.png?alt=media" alt="" data-size="original"></p><p><br><br>Editer un domaine<br></p><p><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-7e877b99e8cae17a1de723294b1a04d4d53598e9%2Fprocess-config-modelisation-domaines-01.png?alt=media" alt="" data-size="original"></p><p><br><br><br>Supprimer un domaine<br></p><p><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-4d559575e3f3c8feaa721e4d8766354514178571%2Fprocess-config-modelisation-domaines-02.png?alt=media" alt="" data-size="original"></p> | <p><strong>Nom</strong> : Nom du domaine de valeurs.<br><strong>Source</strong> : Spécifie où Workey cherchera les valeurs du domaine<br><strong>Type</strong> : Définit que le domaine de valeurs sera de type chaîne de caractères ou numérique.<br><strong>Liste</strong> : Permet d'entrer manuellement les valeurs du domaine pour un type Texte.<br><strong>Requête SQL</strong> : Permet de rédiger une requête vers la base socle ou vers une base de données externe.<br><strong>Plage</strong> : Pour les types nombre, permet de définir une valeur minimum et maximum ainsi qu'un format pour décrire une plage de valeurs.<br><strong>Acteurs</strong> : Pour les types texte, permet de sélectionner un acteur existant ou une unité organisationnelle en précisant son degré hiérarchique.<br>Ouvre la même fenêtre pour un domaine existant, figurant dans la liste.</p> |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

Pour ouvrir la fenêtre des domaines, choisissez l'option **Domaines**dans le menu **Outils**.

**Valeurs par défaut**

Workey Designer offre des possibilités de contrôle offertes par la spécification de valeurs par défaut pour des champs possédant un domaine de valeurs.

**Définition d´un domaine et valeur par défaut**

Pour un champ dont les valeurs sont prises dans un domaine, plusieurs possibilités se présentent pour la spécification d´une valeur par défaut:

1. aucune valeur par défaut: dans ce cas la première valeur présente dans le domaine sera considérée comme la valeur par défaut. Par exemple, si le domaine est «A,B,C», la liste présentée est simplement «A,B,C».
2. une valeur par défaut faisant partie du domaine des valeurs: c´est cette valeur qui sera considérée par défaut et présentée en premier dans la liste des valeurs du domaine. Dans l´exemple, si «B» est la valeur indiquée par défaut, alors la liste présentée sera «B,A,C».
3. une valeur par défaut ne **faisant pas partie** du domaine: cette valeur est présentée avant la liste complète des valeurs du domaine. Dans l´exemple, si la valeur par défaut est «Z», alors la liste présentée sera «Z,A,B,C»

**Vérifications effectuées au moment de la soumission d´un document**

A la soumission du document, la valeur renseignée pour le champ est vérifiée. La vérification dépend de la règle d´édition posée sur le champ comportant le domaine.

* Le champ est défini comme «obligatoire»

1. Dans la situation «1» (pas de valeur par défaut), vérification ok, la première valeur du domaine sera la valeur persistée.
2. Dans la situation «2» (valeur par défaut dans le domaine), vérification ok, cette valeur sera la valeur persistée.
3. Dans la situation «3» (valeur par défaut hors du domaine), la règle de vérification du champ ne sera pas satisfaite si c´est cette valeur qui est sélectionnée (message d´erreur explicite et avortement de la soumission du document).

* Le champ n´est pas défini comme «obligatoire»

Seule la situation «3» donne lieu à vérification: la valeur du champ ne sera pas persistée, mais n´empêche pas la soumission du document.

**Conséquences des règles de vérification**

Il résulte des conditions présentées est que le moyen le plus simple de définir une règle imposant à un utilisateur un choix explicite d´une valeur, dans le cas d´un champ avec domaine, est :

* de définir une valeur par défaut en dehors des valeurs du domaine (par exemple, «?»),
* de définir le champ comme obligatoire.

A l´ouverture du document, le symbole «?» sera le premier affiché dans la liste. Si l´utilisateur n´effectue aucune saisie, la soumission du document sera empêchée, avec un message d´erreur explicite.

Ce simple mécanisme présente deux avantages:

* le «non-choix» est clairement présenté à l´utilisateur,
* aucune règle traitant explicitement cette situation n´est à envisager par ailleurs.

## Prérequis

### Préambule

Workey Designer est une solution de modélisation de processus d´entreprise.[#Workey-Designer-HTML](#Workey-Designer-HTML)

Dans les deux modes, l´accès à l´application s´effectue depuis un navigateur web sans plugin particulier.

Un écran ayant une résolution 1600×900 est vivement recommandée.

### Workey Designer HTML

La version HTML propose l´ensemble des fonctionnalités à savoir :

* Sauvegarde en base de données
* Déploiement d'un processus sur le serveur Workey Engine si celui-ci dispose d´une licence d´éxécution

La version nécessite l´installation du serveur Workey, composé des éléments suivants :

* Workey Engine R6 minimum
* Serveur d'application Tomcat 7
* OS : Windows, Linux, Unix
* Base de données supportées par la solution : Mysql
* Connexion à un annuaire Ldap

Cette version est livrée sous forme d'un installeur pour les composants suivants :

* Workey Engine
* Serveur d´application Tomcat 7

L´utilisation de l'application Workey Designer s'effectue via :

* Une connexion serveur depuis un navigateur

L'activation de Workey Engine pour l´automatisation des processus nécessite une clé logicielle adaptée. Ainsi le droit d'utiliser Workey Designer, ne donne pas de fait, le droit d'utiliser Workey Engine.

### Navigateurs

Workey Designer fonctionne avec tous les navigateurs.

## Formulaires

### Présentation

Dans un processus, Workey permet, à l'aide du concept d'état, de modéliser le cycle de vie d'un document (Gestion de contrats fournisseurs, Demande d'achat, Fiche produit, Réclamation client, …) associé au document.

Dans un objectif d'automatisation et de dématérialisation d'un processus, il est nécessaire de dématérialiser aussi le document sous la forme d'un formulaire électronique.

Workey ne se limite pas à préciser les différents champs composant le document, mais il permet aussi de préciser les règles de visibilité (lecture, caché, édition) de l'information en fonction de différents critères : rôle, opération ou état du document.

Un document est composé d'un ensemble d'objets ( Composants) contenant des champs qui sont rendus accessibles à l'utilisateur par l'intermédiaire de formulaires. Ainsi, il est possible d'associer à un document donné, plusieurs formulaires qui partageront cet ensemble de champs afin de gérer très finement les règles de visibilité en fonction du rôle, de l'opération réalisée et de l'état du document. Workey propose un outil de création de formulaire permettant :

* la création de **sections**(regroupement logique de champs)
* la création de **composants**
* la création de **tables**et de **tableaux dynamiques**

Ces composants possèdent une série de propriétés qui permettent de gérer leur comportement et par conséquent le comportement des formulaires.

Après avoir modélisé le flux et le(s) formulaire(s), le modélisateur, par action sur n'importe quel document, peut choisir son formulaire. Dans le cas où il ne le ferait pas, Workey prendrait alors le premier formulaire créé et le positionnerait par défaut.

### Création d'un formulaire

La création d'un formulaire associé à un document s'effectue soit depuis les propriétés d'un document, soit dans la section **Formulaires**du panneau de Projets.

#### A partir des propriétés d'un document

Pour créer un formulaire associé à un document dans un graphe de procédures ou processus il suffit de sélectionner les propriétés d'un document et cliquer sur le bouton **Formulaire** et ensuite sur le bouton **Nouveau**.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-928571f32032916e900692b524d66e785686a619%2Fprocess-config-designer-html-formulaires-01.webp?alt=media" alt=""><figcaption></figcaption></figure>

Il est possible également de **rattacher** un formulaire "orphelin" au document courant en cliquant sur le bouton Rattacher un formulaire inutilisé.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-a25748e633dd16ffc641143e4af15b49734eb646%2Fprocess-config-designer-html-formulaires-02.webp?alt=media" alt=""><figcaption></figcaption></figure>

Pour **accéder** au formulaire existant ou en création il suffit de cliquer sur le lien existant dans la liste ce qui permettra d'ouvrir l'interface de conception du formulaire.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-5aadd03593a4f7959d167db14f02dc114a3c3c0e%2Fprocess-config-designer-html-formulaires-03.webp?alt=media" alt=""><figcaption></figcaption></figure>

Les droits pour accéder au formulaire peuvent être définis également dans ce panneau:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-5024cee819fb09b52670e63a4c82d7bfe6a03c7e%2Fprocess-config-designer-html-formulaires-04.webp?alt=media" alt=""><figcaption></figcaption></figure>

Ces droits sont identifiés avec une lettre dans l'en-tête de la colonne et correspondent aux définitions suivantes:

* **Archivage**(A) : Permet de définir le formulaire sélectionné comme celui qui sera présenté par le module d'archivage
* **Lecture par défaut** (L) : Permet de définir le formulaire sélectionné comme celui qui sera présenté par défaut en lecture
* **Écriture par défaut** (E) : Permet de définir le formulaire sélectionné comme celui qui sera présenté par défaut en écriture

#### A partir du panneau Projets

Il est possible également de cliquer sur la croix qui s'affiche à droite de la section **Formulaires** dans le panneau **Projets**pour créer un nouveau formulaire, puis l'associer au document souhaité.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-3424a1a6785b670bb3e34f031102687c55e780b0%2Fprocess-config-designer-html-formulaires-05.webp?alt=media" alt=""><figcaption></figcaption></figure>

### Sélection d'un formulaire existant en entrée d'une opération

Pour sélectionner à une étape de la modélisation un formulaire spécifique, il suffit d'éditer les propriétés du lien qui devra porter ce formulaire en entrée d'une opération.

Sélectionner ensuite le formulaire.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-d2c08c400d9eec2d7b9522b4be4ba74d4ae53fb1%2Fprocess-config-designer-html-formulaires-06.webp?alt=media" alt=""><figcaption></figcaption></figure>

{% hint style="success" %}
**Conseil** Pour afficher l'ensemble des noms de formulaire sur chaque lien d'une modèle de procédure, appuyer sur le touche "F". Pour masquer, appuyer à nouveau sur la touche "F"
{% endhint %}

### Détermination du formulaire d'ouverture d'un document

#### Principes généraux

**Définition**

Le formulaire d'ouverture est le formulaire sélectionné par Workey lors de l'ouverture d'un document par un utilisateur. La sélection s'effectue en suivant les règles énoncées par le concepteur du processus.

**Accès en lecture ou en écriture**

En réponse à une demande d'ouverture d'un document, Workey est en mesure de déterminer si l'utilisateur peut accéder au document pour le modifier et changer son état, ou bien seulement pour une lecture de son contenu.

**Détermination du rôle**

La sélection du formulaire adéquat sera automatique dés que le rôle que peut et désire jouer l'utilisateur est connu. Dans la plupart des situations, un seul rôle est possible, ou bien plusieurs mais utilisant le même formulaire. Dans ce cas, l'ouverture du document s'effectue automatiquement avec le formulaire adapté, sans intervention de l'utilisateur.

Si un utilisateur joue plusieurs rôles opérationnels sur le document il se verra demander de choisir le rôle avant l'ouverture du document. Une fois celui-ci choisi, la détermination du formulaire est automatique.

Dans certains cas (l'utilisateur étant un "manager" du processus, ou bien jouant plusieurs rôles opérationnels sur le document dans son état présent), l'utilisateur se verra demander de choisir le rôle pour l'ouverture du document. Un fois celui-ci choisi, la détermination du formulaire est automatique.

**Utilisateurs, formulaire et vues**

L'utilisateur peut également jouer un rôle de "workflow manager" ou de "process manager" pour le processus auquel participe le document. Dans ce cas, ce rôle est également proposé à l'utilisateur comme rôle d'ouverture, en plus des rôles opérationnels déterminés ci-dessus

Si l'utilisateur n'a pas un droit d'écriture sur le document, la liste des rôles lui permettant de lire le document est constituée.

S'il n'a qu'un seul rôle ou que ces rôles utilisent le même formulaire de lecture, le rôle d'ouverture est déterminé.

Sinon, l'utilisateur devra sélectionner parmi les rôles possibles. Il est également possible que l'utilisateur possède un droit de lecture "privé" sur le document, c'est à dire attaché à son identité d'acteur. Dans ce cas, le rôle et le formulaire d'ouverture seront automatiquement déterminés par la suite.

Si le document est ouvert en tant que workflow ou process manager, le formulaire d'ouverture est le formulaire spécifié comme le formulaire par défaut en écriture pour le type de document concerné.

Si le document est ouvert en tant qu'acteur d'un rôle opérationnel, le formulaire d'ouverture est celui éventuellement spécifié pour les opérations concernées par ce rôle.

Si aucun formulaire n'a été spécifié pour ces opérations, le formulaire par défaut en écriture pour le type de document concerné est retenu.

Si le document est ouvert par un utilisateur possédant un droit de lecture sur le document provenant d'un rôle opérationnel, le formulaire d'ouverture est celui spécifié par défaut pour ce rôle.

#### La sélection du rôle d'ouverture

**Accès en écriture**

L'utilisateur peut figurer parmi les prochains intervenants sur le document en voie d'ouverture. Il peut donc accéder en écriture au document pour y effectuer une ou plusieurs opérations, au titre de un ou plusieurs rôles. Pour chacune de ces opérations, le concepteur du processus peut avoir prévu un formulaire particulier, ce formulaire sera alors inséré dans la liste des formulaires possibles.

Sinon, le formulaire spécifié comme le formulaire par défaut pour le rôle effectuant l'opération sera inséré dans cette liste.

S'il n'y a qu'un seul rôle, ou que tous ces rôles utilisent le même formulaire,le rôle opérationnel d'ouverture est déterminé. Sinon, le rôle devra être sélectionné par l'utilisateur. Le cas le plus courant est donc très simple: l'utilisateur ouvre le document avec le formulaire prévu pour l'opération qu'il doit effectuer.

**Prise en compte des rôles de "manager"**

L'utilisateur peut également jouer un rôle de "workflow manager" ou de "process manager" pour le processus auquel participe le document. Dans ce cas, ce rôle est également proposé à l'utilisateur comme rôle d'ouverture, en plus des rôles opérationnels déterminés ci-dessus.

**Accès en lecture par le rôle**

Si l'utilisateur n'a pas un droit d'écriture sur le document, la liste des rôles lui permettant de lire le document est constituée. S'il n'a qu'un seul rôle ou que ces rôles utilisent le même formulaire de lecture, le rôle d'ouverture est déterminé. Sinon, l'utilisateur devra sélectionner parmi les rôles possibles.

**Accès en lecture personnalisé**

Il est également possible que l'utilisateur possède un droit de lecture "privé" sur le document, c'est à dire attaché à son identité d'acteur. Dans ce cas, le rôle et le formulaire d'ouverture seront automatiquement déterminés par la suite

#### La détermination du formulaire

**Accès en écriture**

Si le document est ouvert en tant que workflow ou process manager, le formulaire d'ouverture est le formulaire spécifié comme le formulaire par défaut en écriture pour le type de document concerné. Si le document est ouvert en tant qu'acteur d'un rôle opérationnel, le formulaire d'ouverture est celui éventuellement spécifié pour les opérations concernées par ce rôle. Si aucun formulaire n'a été spécifié pour ces opérations, le formulaire par défaut en écriture pour le type de document concerné est retenu.

**Accès en lecture par le rôle**

Si le document est ouvert par un utilisateur possédant un droit de lecture sur le document provenant d'un rôle opérationnel, le formulaire d'ouverture est celui spécifié par défaut pour ce rôle.

### Propriétés d'un formulaire

Les propriétés de chaque formulaire sont affichées lors de sa sélection dans l'interface.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-2384254745e33d07b9cceea1ae73498b3a0cf115%2Fprocess-config-designer-html-formulaires-07.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Général**

**Libellé** : Permet de saisir un libellé pour le formulaire **Nom interne** : Attribut designer\_name de l'objet **Nom calculé automatiquement** : Coché par défaut, cette option permet de garantir l'unicité des noms d'objets.**Document** : Permet de sélectionner le document associé au formulaire. Par défaut c'est le document pour lequel est défini le formulaire

**Description** Permet de saisir une description détaillée pour l'opération ainsi qu'un texte d'aide.Étendue permet de pointer vers un fichier externe contenant le texte de description. **Liens** Il est aussi possible de joindre des liens logiques dans les propriétés des formulaires.

### Composants d'un formulaire

Workey Designer propose plusieurs objets ou composants à placer et personnaliser pour composer vos formulaires.

Les objets qu'il est possible d'utiliser dans les formulaires sont affichés lorsque l'utilisateur clique sur l'onglet "Composants".

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-a1ca81698676e6c1624c95bee555c590a75001fc%2Fprocess-config-designer-html-formulaires-08.webp?alt=media" alt=""><figcaption></figcaption></figure>

Pour placer, un composant afin de créer un formulaire, il vous suffit de glisser/déposer le composant.

**Règles**

* Aucun composant ne peut être placé à l'exterieur d'une section
* Certains types de champs sont interdits dans un tableau dynamique

Pour déplacer un composant au sein d'une section, inter section, table, table dynamique, il vous suffit de glisser/déplacer le composant.

Un indicateur visuel, horizontal ou vertical lors de la phase "glisser", vous permet de connaître l'emplacement futur du composant, une fois que vous avez "déposé" le composant.

Chaque composant sélectionné dispose de **propriétés** sont groupées dans six chapitres:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-658b7d0ed22ca49615aad9b273d7120854dc1f82%2Fprocess-config-designer-html-formulaires-09.webp?alt=media" alt=""><figcaption></figcaption></figure>

1. Général
2. Réglages
3. Scripts
4. Connecteurs
5. Description/Aide
6. Informations

Selon le type de compostant plusieurs propriétés peuvent être proposées:

* **description**et texte d'aide
* **type**(texte, nombre, date, …)
* **mono**ou **multivalué**
* **apparence**(zone de texte, radio bouton, …)
* **domaine**de valeurs (liste de valeurs fixes ou dynamiques)
* **contrôle**(règle de gestion sur le champ)
* **valeur par défaut**
* règle de **visibilité**(lecture, caché, édition, obligatoire)
* gestion de l'**historique**sur les modifications des valeurs
* inclus ou non dans l'**index**(pour la recherche et les rapports)
* **synchronisé**ou non (comportement lors de synchronisations)
* **liens**(descriptions et présentations)
* **connecteurs**(Java, SQL, stockée)

Les paragraphes suivants décrivent les différents objets qui peuvent être utilisés dans les formulaires ainsi que ses caractéristiques. Cette description montre pour chaque objet les onglets caractéristiques à chaque objet et qui permettent de le configurer.

Sur chaque objet sélectionné les propriétés proposées peuvent varier, néanmoins il existe deux onglets communs à tous les objets: Description/Aide et Informations. Ces deux onglets sont décrits ci-après:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-0bf2e54e73c0bebe0f2a84fa3c5b448dc6854943%2Fprocess-config-designer-html-formulaires-10.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Section**

Une section permet de regrouper un ensemble de champs au sein d'une zone qui peut être soit dépliée ou pliée. Aucun composant ne peut être placé à l'extérieure d'une section.

Une section comporte un libellé.

L'apparence permet de préciser :

* les règles de visibilité de la section, et donc des différents champs qui la compose
* son apparence lors de l'ouverture du formulaire

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-702cf69ee6bdbb42bae746564ea4e635df46bfee%2Fprocess-config-designer-html-formulaires-11.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Ligne simple**

Le composant ligne simple est une zone de saisie où l'utilisateur peut entrer du texte. Ce champ peut aussi avoir une valeur par défaut ou un domaine de valeurs que l'utilisateur n'aura pas nécessairement besoin de modifier. Il peut être présenté en lecture seule ou en écriture avec une taille personnalisée. La **Valeur** par défaut prise par ce champ au chargement de la page peut être vide ou prédéfinie. Une **Expr**ession Stalk sera évaluée une seule fois au chargement de la page. Une **Expr**ession **calculée** sera réévaluée au chargement, à chaque rafraichissements et à la soumission de la page. Une expression Stalk de **Contrôle**du champ peut assurer l'intégrité de la valeur. Il est possible de lui associer un **Connecteur**Java, Sql ou une procédure stockée.

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-fa8f29543f86638b4f786ab3d315ef7272b5a5a6%2Fprocess-config-designer-html-formulaires-12.webp?alt=media" alt=""><figcaption></figcaption></figure>

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-d2063f4319ce925230b82aa5e7cc62de3a460675%2Fprocess-config-designer-html-formulaires-13.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Multi-lignes**

Le champ Multi-lignes est une zone de texte (textarea) où l'utilisateur peut entrer des paragraphes de texte. Son **type**est obligatoirement texte. Ce champ peut aussi avoir une valeur par défaut que l'utilisateur n'aura pas nécessairement besoin de modifier.Il peut être présenté en lecture seule ou en écriture avec une taille personnalisée. La **Valeur** par défaut prise par ce champ au chargement de la page peut être vide ou prédéfinie.Une **Expr**ession Stalk sera évaluée une seule fois au chargement de la page.Une **Expr**ession **calculée** sera réévaluée au chargement, à chaque rafraichissements et à la soumission de la page. Une expression Stalk de **Contrôle**du champ peut assurer l'intégrité de la valeur. Il est possible de lui associer un **Connecteur**Java, Sql ou une procédure stockée.

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-1daa3b9ab585f0e6a69e94044204706d804143a6%2Fprocess-config-designer-html-formulaires-14.webp?alt=media" alt=""><figcaption></figcaption></figure>

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-640c8349cc3d90b0b0e838babbeec6374ab7224d%2Fprocess-config-designer-html-formulaires-15.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Bouton ratio**

Le champ Bouton radio est une liste de choix dans laquelle l'utilisateur pourra sélectionner un élément. Son **type**est obligatoirement texte. Ce champ peut une valeur par défaut que l'utilisateur n'aura pas nécessairement besoin de modifier et doit obligatoirement avoir un domaine de valeurs associé.Il peut être présenté en lecture seule ou en écriture. On peut aussi le définir comme obligatoire, le formulaire ne serait pas soumis si sa valeur était vide. La **Valeur** par défaut prise par ce champ au chargement de la page peut être vide ou prédéfinie.Une **Expr**ession Stalk sera évaluée une seule fois au chargement de la page.Une **Expr**ession **calculée** sera réévaluée au chargement, à chaque rafraîchissements et à la soumission de la page. Une expression Stalk de **Contrôle**du champ peut assurer l'intégrité de la valeur. Il est possible de lui associer un **Connecteur**Java, Sql ou une procédure stockée.

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-9decfd1798bff40690fef66b534c1d2b3934232e%2Fprocess-config-designer-html-formulaires-16.webp?alt=media" alt=""><figcaption></figcaption></figure>

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-f28825d3be587fa571d755a03c46ef295768679e%2Fprocess-config-designer-html-formulaires-17.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Liste**

Le champ Liste est une liste de choix dans laquelle l'utilisateur pourra sélectionner un ou plusieurs éléments. Son **type**est obligatoirement texte. L'utilisateur peut effectuer une multi sélection des valeurs en maintenant la touche Ctrl du clavier appuyée. Ce champ peut une valeur par défaut que l'utilisateur n'aura pas nécessairement besoin de modifier et doit obligatoirement avoir un domaine de valeurs associé.Il peut être présenté en lecture seule ou en écriture. On peut aussi le définir comme obligatoire, le formulaire ne serait pas soumis si sa valeur était vide. La **Valeur** par défaut prise par ce champ au chargement de la page peut être vide ou prédéfinie.Une **Expr**ession Stalk sera évaluée une seule fois au chargement de la page.Une **Expr**ession **calculée** sera réévaluée au chargement, à chaque rafraîchissements et à la soumission de la page. Une expression Stalk de **Contrôle**du champ peut assurer l'intégrité de la valeur. Il est possible de lui associer un **Connecteur**Java, Sql ou une procédure stockée.

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-6b3789e53ec94929e97c23c4e9371e27c60b236c%2Fprocess-config-designer-html-formulaires-18.webp?alt=media" alt=""><figcaption></figcaption></figure>

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-46a3d8d2973d743f1232b6c3c52579c71d592ab6%2Fprocess-config-designer-html-formulaires-19.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Liste à cocher**

Le champ Liste à cocher est une liste de choix dans laquelle l'utilisateur pourra choisir un ou plusieurs éléments. Son **type**est obligatoirement texte. Ce champ peut avoir une valeur par défaut vide ou prédéfinie que l'utilisateur n'aura pas nécessairement besoin de modifier.Il peut être présenté en lecture seule ou en écriture. On peut aussi le définir comme obligatoire, le formulaire ne serait pas soumis si sa valeur était vide. La **Valeur** par défaut prise par ce champ au chargement de la page peut être vide ou prédéfinie.Une **Expr**ession Stalk sera évaluée une seule fois au chargement de la page.Une **Expr**ession **calculée** sera réévaluée au chargement, à chaque rafraîchissements et à la soumission de la page. Une expression Stalk de **Contrôle**du champ peut assurer l'intégrité de la valeur. Il est possible de lui associer un **Connecteur**Java, Sql ou une procédure stockée.

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-43812a599a346270027a965a2d9a106d8d1cae8d%2Fprocess-config-designer-html-formulaires-20.webp?alt=media" alt=""><figcaption></figcaption></figure>

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-c7e315d6a853be2bf888fcf322d2ff453493f5a1%2Fprocess-config-designer-html-formulaires-21.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Liste déroulante**

Le champ Liste déroulante est une liste de choix dans laquelle l'utilisateur pourra sélectionner un élément. Son **type**est obligatoirement texte. Ce champ peut avoir une valeur par défaut vide ou prédéfinie que l'utilisateur n'aura pas nécessairement besoin de modifier.Il peut être présenté en **lecture**seule ou en **écriture**. On peut aussi le définir comme **obligatoire**, le formulaire ne serait pas soumis si sa valeur était vide.Un **Domaine**de valeurs doit obligatoirement y être associé. La **Valeur** par défaut prise par ce champ au chargement de la page peut être vide ou prédéfinie.Une **Expr**ession Stalk sera évaluée une seule fois au chargement de la page.Une **Expr**ession **calculée** sera réévaluée au chargement, à chaque rafraîchissements et à la soumission de la page. Une expression Stalk de **Contrôle**du champ peut assurer l'intégrité de la valeur. Il est possible de lui associer un **Connecteur**Java, Sql ou une procédure stockée.

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-4824c4cc78c6716922f5bea811f45a15a0326418%2Fprocess-config-designer-html-formulaires-22.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Calendrier**

Calendrier est un champ de type Date dans lequel l'utilisateur peut sélectionner une date spécifique. Son **type**est obligatoirement date. Ce champ peut avoir une valeur par défaut vide ou prédéfinie que l'utilisateur n'aura pas nécessairement besoin de modifier.Il peut être présenté en **lecture**seule ou en **écriture**. On peut aussi le définir comme **obligatoire**, le formulaire ne serait pas soumis si sa valeur était vide. La **Valeur** par défaut prise par ce champ au chargement de la page peut être vide ou prédéfinie.Une **Expr**ession Stalk sera évaluée une seule fois au chargement de la page.Une **Expr**ession **calculée** sera réévaluée au chargement, à chaque rafraîchissements et à la soumission de la page. Une expression Stalk de **Contrôle**du champ peut assurer l'intégrité de la valeur. Il est possible de lui associer un **Connecteur**Java, Sql ou une procédure stockée.

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-e9f20406cebda962ccc10f68827c273214cb97bf%2Fprocess-config-designer-html-formulaires-23.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Pièce jointe**

Le champ Fichier donne la possibilité à l'utilisateur d'attacher au formulaire un ou plusieurs fichiers externes. Son **type**est obligatoirement pièce jointe.Ce champ peut avoir une valeur par défaut vide ou prédéfinie que l'utilisateur n'aura pas nécessairement besoin de modifier.Il peut être présenté en **lecture**seule ou en **écriture**. On peut aussi le définir comme **obligatoire**, le formulaire ne serait pas soumis si sa valeur était vide. La **Valeur** par défaut prise par ce champ au chargement de la page peut être vide ou prédéfinie.Une **Expr**ession Stalk sera évaluée une seule fois au chargement de la page.Une **Expr**ession **calculée** sera réévaluée au chargement, à chaque rafraîchissements et à la soumission de la page. Une expression Stalk de **Contrôle**du champ peut assurer l'intégrité de la valeur. Il est possible de lui associer un **Connecteur**Java, Sql ou une procédure stockée.

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-46d370cdfb0782950496d5ac70425f6c61649a21%2Fprocess-config-designer-html-formulaires-24.webp?alt=media" alt=""><figcaption></figcaption></figure>

**URL**

Le champ URL permet d'insérer dans le formulaire un lien vers un site ou une page externe. Son **type**est obligatoirement texte. Ce champ peut avoir une valeur par défaut vide ou prédéfinie que l'utilisateur n'aura pas nécessairement besoin de modifier.Il peut être présenté en **lecture**seule ou en **écriture**. On peut aussi le définir comme **obligatoire**, le formulaire ne serait pas soumis si sa valeur était vide. La **Valeur** par défaut prise par ce champ au chargement de la page peut être vide ou prédéfinie.Une **Expr**ession Stalk sera évaluée une seule fois au chargement de la page.Une **Expr**ession **calculée** sera réévaluée au chargement, à chaque rafraîchissements et à la soumission de la page. Une expression Stalk de **Contrôle**du champ peut assurer l'intégrité de la valeur. Il est possible de lui associer un **Connecteur**Java, Sql ou une procédure stockée.

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-8177de9625471945114ccb1448d6e4af43fbb137%2Fprocess-config-designer-html-formulaires-25.webp?alt=media" alt=""><figcaption></figcaption></figure>

#### Table simple

Pour aligner des champs horizontalement vous pouvez utiliser le composant table. Une table peut intégrer tous les composants par glisser déposer à l'exception : – d'une section – d'une table – d'un tableau dynamique – d'une vue embarquée

La césure permet de spécifier le nombre de composants par ligne

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-eca3fe066e40f89dc935bba296306b49da3c8a55%2Fprocess-config-designer-html-formulaires-26.webp?alt=media" alt=""><figcaption></figcaption></figure>

#### Tableau dynamique

Un **tableau dynamique**est constitué d'un ensemble de colonnes, correspondant chacune à un champ du document dans laquelle le tableau apparaît, et d'un ensemble de lignes correspondant aux différentes valeurs de ces champs. Pour le construire :

– glisser/déposer le composant tableau dynamique

– glisser/déposer un à un les composants que vous souhaitez intégrer dans le tableau afin de constituer les différentes colonnes du tableau

La cellule à l'intersection de la i-ème ligne et de la j-ème colonne représente la i-ème valeur du champ attribué à la j-ème colonne.

Une **table dynamique** est une table dans laquelle le nombre de lignes n'est pas pré-déterminé, mais varie suivant le choix de l'utilisateur qui peut ajouter ou enlever des lignes à la table en utilisant les boutons **ajouter**et **supprimer**à gauche du tableau.

Le champ Table dyn. permet de construire un tableau muni d'une infinité de lignes. Il peut être présenté en **lecture**seule ou en **écriture** ou **caché**à l'affichage. On défini les champs composant les colonnes du tableau et c'est l'utilisateur qui créera autant de lignes qu'il lui est nécessaire. Tous les champs présents à l'intérieur doivent être définis comme multivalués. Les champs que l'on peut créer à l'intérieur d'un tel tableau sont :Ligne simpleMulti-ligneListeLes valeurs par défaut ne sont pas prises en considération.

Ce type d'objet autorise aussi l'utilisation du langage STALK notamment pour effectuer des calculs sur une ligne ou bien par colonne.

Il est possible de pré-remplir des tableaux dynamique par l'utilisation des pré-connecteurs.

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-219f02837646ee5f8f1a83fc814047d3c33b7830%2Fprocess-config-designer-html-formulaires-27.webp?alt=media" alt=""><figcaption></figcaption></figure>

#### Vue embarquée

Le champ Vue embarquée permet de réserver dans un formulaire l'emplacement pour une vue construite dans une procédure. Il peut être présenté en **lecture**seule ou en **écriture** ou **caché**à l'affichage.

Les colonnes de la vue sont construites dans un graphe de procédures, pas dans un formulaire.On défini ici l'objet vue qui est associé au champ en le sélectionnant dans la liste déroulante des vues existantes.Il faut donc modéliser la vue avant de lui créer un champ de formulaire.

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-6c2a970c14cfd9f30014d24f99faadfa418df3c8%2Fprocess-config-designer-html-formulaires-28.webp?alt=media" alt=""><figcaption></figcaption></figure>

#### Contrôle d'intégrité des champs

Grâce au scripts STalk, vous pouvez entrer des règles de validation pour chaque champ.Ce contrôle est vérifié avant le changement d'état (Lors de l'enregistrement).Notez que cette finalité est complémentaire aux règles de changement d'état .Toutes les valeurs et expressions sont des phrases STalk.

#### Intégration de code HTML et de JavaScript

Il est possible d'inclure du code JavaScript dans les formulaire. Celui-ci sera interprété par le navigateur lorsque l'objet le portant est chargé.

Ajoutez un champ multi-lignes dans le formulaire et éditez ses propriétés.Dans la section apparence choisir l'option "non éditable".Dans la section **Initialisation**, choisissez l'option **Valeur**et saisissez du code JavaScript ou HTML.

Pour une combinaison de champs internes au formulaire avec du code HTML, choisissez l'option Expression calculée pour que Workey évalue la valeur du ou des champs au rafraichissement de la page.

Exemple :

### Visibilité des formulaires

**Accès en lecture**

L'utilisateur peut figurer parmi les prochains intervenants sur le document en voie d'ouverture. Il peut donc accéder en écriture au document pour y effectuer une ou plusieurs opérations, au titre de un ou plusieurs rôles.Pour chacune de ces opérations, le concepteur du processus peut avoir prévu un formulaire particulier, ce formulaire sera alors inséré dans la liste des formulaires possibles. Sinon, le formulaire spécifié comme le formulaire par défaut pour le rôle effectuant l'opération sera inséré dans cette liste.S'il n'y a qu'un seul rôle, ou que tous ces rôles utilisent le même formulaire, le rôle opérationnel d'ouverture est déterminé. Sinon, le rôle devra être sélectionné par l'utilisateur.

Le cas le plus courant est donc très simple: l'utilisateur ouvre le document avec le formulaire prévu pour l'opération qu'il doit effectuer

**Accès en écriture**

Si le document est ouvert en tant que workflow ou process manager, le formulaire d'ouverture est le formulaire spécifié comme le formulaire par défaut en écriture pour le type de document concerné. Si le document est ouvert en tant qu'acteur d'un rôle opérationnel, le formulaire d'ouverture est celui éventuellement spécifié pour les opérations concernées par ce rôle. Si aucun formulaire n'a été spécifié pour ces opérations, le formulaire par défaut en écriture pour le type de document concerné est retenu

**Accès en lecture pour le rôle**

Si le document est ouvert par un utilisateur possédant un droit de lecture sur le document provenant d'un rôle opérationnel, le formulaire d'ouverture est celui spécifié par défaut pour ce rôle.

#### Par rôle

{% hint style="success" %}
**Conseil** Pour définir un formulaire présenté par défaut à un rôle, éditer les propriétés de l'objet rôle dans une procédure.Dans la section Général, sélectionnez le formulaire désiré.
{% endhint %}

**Prise en compte des rôles de manager**

L'utilisateur peut jouer un rôle de "workflow manager" ou de "process manager" pour le processus auquel participe le document. Dans ce cas, ce rôle est également proposé à l'utilisateur comme rôle d'ouverture, en plus des rôles opérationnels déterminés ci-dessus.

**Accès en lecture par le rôle**

Si l'utilisateur n'a pas un droit d'écriture sur le document, la liste des rôles lui permettant de lire le document est constituée. S'il n'a qu'un seul rôle ou que ces rôles utilisent le même formulaire de lecture, le rôle d'ouverture est déterminé. Sinon, l'utilisateur devra sélectionner parmi les rôles possibles.

**Accès en lecture personnalisée**

Il est également possible que l'utilisateur possède un droit de lecture "privé" sur le document, c'est à dire attaché à son identité d'acteur. Dans ce cas, le rôle et le formulaire d'ouverture seront automatiquement déterminés par la suite.

#### Par opération

Pour définir un formulaire présenté par défaut pour une opération spécifique dans un conteneur de parallélisme, éditer les propriétés de l'objet **opération**dans conteneur de parallélisme.Dans la section Général, sélectionnez le formulaire désiré.

#### Par document

Pour associer un ou des formulaires à des objets document, ajoutez-les dans les propriétés du document.Dans la section Formulaires, choisissez le formulaire qui sera affiché par défaut : en lectureen écriture

## Événements liés aux Données

Ce chapitre décrit la notion d'évènements pouvant se déclencher dans un processus à la suite de circonstances créés par certaines données.

Par exemple, dans un processus d'accueil de nouveaux collaborateurs, les données comme "le contrat est un CDD" et "la date de fin de contrat est le 15 janvier" pourrait donner naissance à un évènement "Fin de CDD". Cet évènement devrait être porté à la connaissance des intervenants du processus pour les en rendre attentifs.

#### Modélisation d'un évènement lié aux données

Dans la modélisation d'une Procédure, aller dans l'onglet "Composants" et sélectionner le composant "Tâche programmée" pour créer un nouvel évènement:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-ef5f14ac356a2369b51a0b29e2c74b8e54743108%2Fprocess-config-designer-html-evenements-lies-aux-donnees-01.webp?alt=media" alt=""><figcaption></figcaption></figure>

\*Création d'une tâche programmée\*

**Les propriétés d'un évènement**

La configuration d'un évènement comporte plusieurs volets.

**Propriétés**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-264368d062d1305f1bc52fbc6edc49c285b14ac6%2Fprocess-config-designer-html-evenements-lies-aux-donnees-02.webp?alt=media" alt=""><figcaption></figcaption></figure>

\*\*Libellé :\*\*Renseigner le nom de l'évènement **Unité de temps** : Choisir l'unité de temps utilisée pour le calcul de l'échéancier des avertissements.

**Déclenchement**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-34a7b7e41009ac921a7bbfeab094bdc918c9788a%2Fprocess-config-designer-html-evenements-lies-aux-donnees-03.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Date d'occurrence** : Éditer le script retournant la date à laquelle l'évènement aura lieu. Dans l'exemple, cette date est celle du traitement prévu. **Message** : Éditer le script retournant le texte du message expédié aux intervenants concernés lors de la survenance de l'évènement.Dans l'exemple, le script suivant a pour objet de rappeler la date de traitement prévue : `"Intervention " + Niveau_criticite + " à effectuer avant le " + Date_traitement`

**Condition** : Éditer le script décrivant la condition de déclenchement de l'évènement. Ce script doit retourner une valeur "vraie" si les données actuellement présentes dans le document permettent la survenance (ou la pertinence) de l'évènement.

Dans l'exemple suivant , le script exprime que l'évènement survient pour un cas jugé très critique et dont la date de traitement prévue est dans moins de 3 jours : `(Niveau_criticite="Très critique") && ((Date_traitement-now()) < 3)`

**Avertissements**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-15355b6ffa3e4781dc999f772c8d6aa4644bda0d%2Fprocess-config-designer-html-evenements-lies-aux-donnees-04.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Echéances des avertissements**

Renseigner le nombre d'unités de temps pour l'envoi des notifications relatives à l'évènement, avant et éventuellement après la survenance de l'évènement.

Dans l'exemple ci-dessus, un avertissement sera envoyé un jour avant et un jour après l'évènement.

Pour renseigner plusieurs échéances, séparer les valeurs par des point-virgules\*\*\*\*\*.

**Message** Éditer le script permettant de constituer le texte du message d'avertissement. Il peut donc être différent du texte de message envoyé lors de la survenance.

(\*) La syntaxe de chaque valeur de planification des avertissements est: `laps de temps [ ; laps de temps ]`

Le laps de temps permet d'indiquer, par rapport à l'instant de l'évènement, le moment où sera envoyé l'avertissement.

Pour un avertissement avant l'évènement, basé sur une unité de temps "jour", la valeur 10 indique qu'un avertissement doit être lancé 10 jours avant.

Il est possible de définir plusieurs avertissements. Les laps de temps devront alors être séparés par des point-virgules.

Exemple:

> `5;3;1` indique que des avertissements seront émis à 5 jours, puis à 3 jours et finalement 1 jour avant la date finale (la date à laquelle l'évènement va survenir.)

{% hint style="warning" %}
Il est de la responsabilité du concepteur de spécifier un échéancier d'avertissements compatible avec la date de survenance prévisible de l'évènement.
{% endhint %}

**Notifications**

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-cf25093506db579d1f7396bb4b8ad4dc4a31be96%2Fprocess-config-designer-html-evenements-lies-aux-donnees-05.webp?alt=media" alt=""><figcaption></figcaption></figure>

Les notifications et avertissements relatifs à l'évènement peuvent être adressés à différents ensembles d'intervenants.

Dans le cas de notifications "aux acteurs des rôles", celles-ci ne seront adressées qu'aux seuls acteurs (du ou des rôles désignés) étant intervenus sur le document (au regards de son historique). Si pour un rôle désigné, aucun des acteurs du rôle n'est intervenu sur le document concerné par l'évènement, alors ce sera l'ensemble des acteurs de ce rôle qui sera notifié.

**Le positionnement de l'évènement**

L'évènement doit être lié à une opération. La signification du lien est: lorsque l'opération est réalisée, l'évènement est créé et considéré comme potentiellement activé. Il ne le sera que si sa condition d'existence est vérifiée par les données à ce moment-là:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-ed73fdca0d548816819d34c7fff9bfd1bec9fbc5%2Fprocess-config-designer-html-evenements-lies-aux-donnees-06.webp?alt=media" alt=""><figcaption></figcaption></figure>

**La disparition d'un évènement**

Dans certaines situations pratiques, l'évènement peut ne plus avoir de sens ou ne plus présenter d'intérêt dés qu'une opération particulière a été effectuée.

Par exemple, dans le cas de l'évènement lié à la fin d'un contrat CDD, l'opération "changer le contrat en CDI" doit entraîner la suppression de l'évènement.

La modélisation de cette situation s'effectue en liant l'opération à l'évènement à supprimer, puis en changeant la propriété du lien de "Lancer" à "Stopper" :

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-a7b873d96915d67f32dd09d7a7579e639efccd37%2Fprocess-config-designer-html-evenements-lies-aux-donnees-07.webp?alt=media" alt=""><figcaption></figcaption></figure>

L'évènement "Intervention très critique urgente" va être supprimé par la réalisation de l'opération "Clôturer la demande d'intervention".

#### Scénario de prise en compte d'un évènement dans un processus

Pour une exécution particulière d'un processus comportant la modélisation d'un évènement, le scénario-type est le suivant.

```mermaid
flowchart TD
    A["1. Opération déclenchante réalisée<br/>Évènement créé et activé (date de survenance déterminée)"] --> B["2. Notifications d'avertissement<br/>envoyées avant la survenance"]
    B --> C{"3. Ré-évaluation à chaque opération<br/>du processus"}
    C -->|Condition non remplie| D["Évènement désactivé"]
    D --> C
    C -->|Opération de suppression réalisée| E["4. Évènement supprimé"]
    C -->|Date de survenance atteinte,<br/>évènement encore actif| F["5. Notification de survenance envoyée"]
    F --> G["6. Notifications après survenance<br/>selon l'échéancier"]
    G --> H["7. Fin de vie du document<br/>Évènement supprimé s'il existe encore"]
```

1. L'opération déclenchant l'évènement est effectuée : l'évènement est créé, avec sa date de survenance déterminée. Si les données le permettent, il est déclaré activé.
2. Selon l'échéancier prévu pour la période précédant sa survenance, des notifications d'avertissement sont envoyées aux intervenants prévus.
3. Lors de chaque opération survenant durant le processus, la condition d'existence de l'évènement est re-calculée. Ainsi, l'évènement peut être désactivé ou ré-activé plusieurs fois dans le parcours de vie du processus.
4. Si une opération prévoyant la suppression de l'évènement est réalisée, l'évènement est supprimé.
5. A la date de survenance prévue, si l'évènement est encore actif, des notifications sur la survenance du message sont envoyées aux intervenants prévus.
6. Selon l'échéancier prévu pour la période après sa survenance, des notifications de survenance de l'évènement sont envoyées aux intervenants prévus.
7. A la fin du parcours de vie du document, l'évènement est supprimé, s'il existe encore.

## Fonctions Avancées

Objectifs, contenu et structure de ce guide

La définition de base des différents concepts de modélisation de Workey est adaptée à la plupart des procédures de travail simples. Elle doit être complétée dès que les règles du processus sont plus complexes. C'est la raison pour laquelle des fonctions avancées ont été définies pour permettre au concepteur de spécifier notamment des règles concernant les domaines suivants :

1. les opérations et leurs enchaînements,
2. les rôles, les acteurs et les affectations des opérations,
3. les formulaires
4. les documents, leur contenu et leur visibilité,
5. les délégations.

A partir du moment où l'on peut spécifier des règles dont la combinaison peut déboucher sur des situations parfois très complexes, un module de vérification est automatiquement activé, pour s'assurer de l'*exécutabilité* des procédures et, le cas échéant, évaluer les risques de blocage. La présentation des fonctions avancées est structurée en fonction des domaines ci-dessus. L'utilisation des fonctions avancées est illustrée part de nombreux exemples pour lesquels, chaque fois que cela est pertinent, l'incidence du choix du concepteur sur l'application générée et l'interface utilisateur (Web) est présentée en détail.

Types d´opérations et enchaînement

On peut distinguer deux types d'opérations:

* les opérations séquentielles: elles sont affectées à un seul rôle et s'enchaînent suivant les états spécifiés en entrée et en sortie,
* les opérations parallèles: elles sont effectuées en parallèle par plusieurs acteurs, et se terminent quand tous les acteurs sont intervenus.

### Les opérations séquentielles

Une opération séquentielle laisse un document dans un état donné. Depuis cet état, une autre opération peut à son tour être effectuée, constituant ainsi une séquence d'opérations.

**Contexte d'exécution**

Une opération séquentielle peut se dérouler dans plusieurs types de contexte d'exécution.

* un seul type de document, dans l'état "Nouveau", en entrée de l'opération: l'opération permet de créer un nouveau document du type spécifié en entrée,
* un seul type de document en entrée de l'opération: l'opération ne peut être effectuée que sur un document dans l'état spécifié,
* une condition "OU" figure au-dessus de l'opération: plusieurs types et états de document permettent d'effectuer l'opération,
* une condition "ET" figure au-dessus de l'opération: l'opération ne peut s'effectuer que si une ou plusieurs règles de synchronisation sont respectées.

**Contexte de sortie**

Le résultat d'une opération peut également prendre plusieurs formes, plus ou moins complexes suivant ce qu'il est nécessaire d'exprimer.

* un seul type de document en sortie de l'opération: le résultat de l'opération est de mettre le document en sortie dans l'état spécifié,
* une condition "OU" figure en dessous de l'opération: plusieurs états de document sont possibles en sortie de l'opération, le choix d'un état sera effectué soit par l'acteur effectuant l'opération, soit par une règle automatique,
* une condition "ET" figure en dessous de l'opération: un ou plusieurs documents seront créés en résultat de l'opération, donnant lieu à autant de sous-processus (ou documents dérivés).

**Exemples**

\*L'opération crée un nouveau document:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-3d2093d89b90b60523f216a7ad0203ef887ca170%2Fprocess-config-designer-html-fonctions-avancees-01.png?alt=media" alt=""><figcaption></figcaption></figure>

\*L'opération modifie l'état d'un document existant:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-e5d5214065a395fc648310bac4d3d8f59e037554%2Fprocess-config-designer-html-fonctions-avancees-02.png?alt=media" alt=""><figcaption></figcaption></figure>

\*L'opération peut s'effectuer sur un document possédant l'un ou l'autre des états:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-0f76433772663aca412f04c8c5160a6e03a006c2%2Fprocess-config-designer-html-fonctions-avancees-03.png?alt=media" alt=""><figcaption></figcaption></figure>

L'opération peut s'effectuer sur un document dans un état donné,mais seulement si un autre document a atteint un état donné dans son parcours de vie(synchronisation):

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-059f48afb08aac644d954193f25c306be9681f9b%2Fprocess-config-designer-html-fonctions-avancees-04.png?alt=media" alt=""><figcaption></figcaption></figure>

\*L'opération peut modifier l'état du document dans un des états spécifiés:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-b76a6ad73d12c2c3eef37cf8b4aef9dd5455afcf%2Fprocess-config-designer-html-fonctions-avancees-05.webp?alt=media" alt=""><figcaption></figcaption></figure>

L'opération crée une instance d'un autre type de document (lancement de sous-processus).

(Dérivation d'un document fils)

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-6239299b536596f1c9f6031874bf72c972752b08%2Fprocess-config-designer-html-fonctions-avancees-06.webp?alt=media" alt=""><figcaption></figcaption></figure>

### Les opérations parallèles

Une opération parallèle est une opération effectuée par plusieurs intervenants qui interviennent sans ordre pré-établi, donc de manière non séquentielle.

Une opération parallèle comprend donc plusieurs opérations simples, affectées chacune à un rôle différent. Comme une opération séquentielle, elle est exécutable depuis un ou plusieurs types de document dans un état donné, et produit en sortie un type de document dans un état donné. Cet état ne sera atteint que lorsque **toutes** les opérations prévues dans le cadre de l'opération parallèle ont été effectuées.

Par exemple: L'opération parallèle (*image ci-dessous*) comprend deux opérations simples:Valider (effectuée par les acteurs du rôle "Resp technique",Définir paramètres techniques (effectuée par les acteurs du rôle "technicien")L'opération est exécutable depuis un document du type "fiche d'actions" dans un état "éditée" et change l'état de ce document en "validé" lorque les deux opérations ont été effectuées.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-c5da7d46a545fb6e48e746bf0acf83291a7f064e%2Fprocess-config-designer-html-fonctions-avancees-07.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Ajout d'une opération dans une opération parallèle**

Pour ajouter une opération dans une opération parallèle, glisser déposer le composant "opération" dans le cadre de l'opération paralléle et pour la colonne du rôle en charge de l'opération.

#### Les propriétés d'une opération au sein d'une opération paralléle

En éditant une opération, il est possible de renseigner des propriétés pour compléter le comportement attendu de cette opération. En plus des propriétés standards d'une opération, l'opération au sein d'une opération paralléle dispose d'une propriété supplémentaire : Le formulaire. Vous pouvez ainsi préciser pour chaque opération un formulaire distinct.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-e1d8ecda2b4afc455a8a1e6ba83e1b43de8d2669%2Fprocess-config-designer-html-fonctions-avancees-08.png?alt=media" alt=""><figcaption></figcaption></figure>

### Opération avec règles de contrainte

Le lien de sortie d'une opération vers un document dans un état donné peut être assorti d'une règle, spécifiant la condition nécessaire pour la sélection de cet état. La propriété ![](https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-d7fd15a850e56f26515f6ee28b44b0ae1dc5f890%2Fprocess-config-modelisation-creer-un-projet-08.png?alt=media)

du lien permet de spécifier une règle. Il est ensuite possible de choisir un graphe de règles existant ou d'en créer un nouveau. Consulter le point traitant de la modélisation des règles dans cette documentation.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-bc2ada1aebacafc2a7f53fc4d7e5bb337ef4bbbc%2Fprocess-config-designer-html-fonctions-avancees-09.webp?alt=media" alt=""><figcaption></figcaption></figure>

#### Opération automatique

Une opération prévoyant plusieurs états en sortie peut être déclarée **automatique**si des règles d'évaluation ont été définies.Pour spécifier une opération automatique, choisir la propriété "Automatique".Cette propriété est présente si et seulement si une pré-condition OU est précisée en sortie de l'opération.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-8037d941b005a67056542d2d2888ba82092638b9%2Fprocess-config-designer-html-fonctions-avancees-10.webp?alt=media" alt=""><figcaption></figcaption></figure>

Dans ce cas, les règles de sélection de chacun des états possibles seront analysées dans leur ordre de **priorité**. La **première**règle présentant une évaluation **positive**sera retenue et l'état correspondant sera sélectionné. Si aucune des règles n'est retenue, l'état ne comportant pas de règle, s'il existe, est retenu.

Une conséquence de ce comportement est qu'il n'est pas possible dans le cas d'une opération automatique de laisser plus d'une branche de sélection d'état sans règle à évaluer (Workey ne saurait pas comment choisir l'état).

Il est par contre tout à fait possible de spécifier une règle pour tous les états: dans ce cas, on peut se trouver dans la situation où aucune des règles n'est satisfaite au moment de soumettre le document. Si c'est le cas, l'utilisateur, averti de l'échec de la vérification, peut modifier les données du document en cours et tenter une nouvelle soumission. Il peut également sauvegarder le document sous forme de brouillon et effectuer les corrections nécessaires plus tard.

### Règles de création de sous-processus (ou documents dérivés)

**Dérivation automatique**

Lorsque dans un modèle d'opérations, une opération est suivie d'une post-condition de type ET et qu'elle produit un document différent de celui qui est spécifié en entrée, on parle de "**dérivation**". Cette situation est illustrée par l'exemple ci-contre. L'opération "Editer un plan d'actions" s'effectue sur des documents du type "Réclamation client" marqués "pour action". Le document "Réclamation client" est le "**principal**" dans cette opération. Cette opération aura deux effets:le changement d'état du document principal en "en attente de TT" la création d'un nouveau document de type "Fiche d'action", qui est le document "**dérivé**" par cet opération. Le document dérivé démarre un sous-processus, en accord avec les règles modélisées pour ce type de document.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-6239299b536596f1c9f6031874bf72c972752b08%2Fprocess-config-designer-html-fonctions-avancees-06.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Héritage des informations**

Lors de la dérivation, les valeurs des champs du document principal sont automatiquement copiées dans les champs portant le même nom dans le document dérivé.

Pour supprimer cet automatisme, décocher la case "Peut hériter sa valeur" dans le champ du document dérivé:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-21ecd4ed1227b2b006b139724440c9073de32579%2Fprocess-config-designer-html-fonctions-avancees-11.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Propriétés d'une dérivation**

La dérivation de documents est un élément modélisable.Les propriétés du lien de dérivation sont présentées ci-contre :

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-475fb32248670cb05d55baf378de776d437899d1%2Fprocess-config-designer-html-fonctions-avancees-12.webp?alt=media" alt=""><figcaption></figcaption></figure>

Cette option est celle par défaut, elle est automatiquement renseignée par Workey en fonction de l'environnement de la dérivation.

Dans ce cas, la dérivation de nouveaux documents est automatiquement assurée par Workey lors de la réalisation de l'opération.

Les options possibles dans ce cas sont:

* au choix de l'utilisateur: l'utilisateur pourra décider si le ou les documents dérivés seront effectivement créés,

```
(par défaut, dérivation: cocher cette case si le choix par défaut présenté à l'utilisateur sera la création de document)
```

* un document pour chaque acteur: un document dérivé sera créé pour chaque acteur sélectionné,
* démarre un nouveau processus: si cette case est cochée, les documents dérivés seront considérés comme des nouveaux processus, et non plus comme des sous-processus, ce qui implique qu'aucun lien de filiation ne sera enregistré entre le document principal et les documents dérivés.

#### Dérivation manuelle par une vue embarquée

**Définitions**

Une vue embarquée est une vue visible dans un document, donc comme "embarquée" dans ce document. C'est une vue qui permet de créer des documents fils à partir d'un formulaire et de montrer des documents créés à partir de ce document de référence.

A la différence d'une vue autonome, une vue embarquée doit être créée dans un formulaire attaché à un document. La même vue peut apparaître dans plusieurs formulaires du même type de document, elle devient de ce fait visible par les utilisateurs accédant par ces formulaires. De plus, la création de documents via une vue embarquée doit être spécifiée dans le modèle d'opérations, pour préciser à quel étape du flux, et donc à travers quel rôle, pourront être créés ces documents.

Lors de la création du lien depuis le document vers la vue embarquée, Workey vérifie si la vue est bien présente dans un formulaire attaché au document.

La modélisation d'une vue embarquée comporte donc trois phases:

* la création de la vue depuis "Vue embarquée" dans l'arborescence du projet

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-8d3f14b0e7a2a074ed4ba563bd4b4d4706da5589%2Fprocess-config-designer-html-fonctions-avancees-13.webp?alt=media" alt=""><figcaption></figcaption></figure>

* la création de la vue dans le modèle conceptuel, afin de spécifier les états du document pére permettant la création du document fils

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-8bb41db2c21d284e17557bd2f48bc1574b1146a1%2Fprocess-config-designer-html-fonctions-avancees-14.png?alt=media" alt=""><figcaption></figcaption></figure>

* l'association de la vue dans le ou les formulaire(s)

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-f1c08b7c799423cd6de87ebb110b3ad67ab1536e%2Fprocess-config-designer-html-fonctions-avancees-15.webp?alt=media" alt=""><figcaption></figcaption></figure>

Ce chapitre décrit la manière de spécifier l´utilisation des vues embarquées pour créer des documents dans le cours d´un processus. Une vue embarquée étant définie dans un formulaire, il reste en effet à préciser à quel(s) moment(s) du déroulement d´un processus les intervenants autorisés pourront créer des documents au moyen de cette vue embarquée, et quel sera le type des documents ainsi dérivés.

**Rappel sur les vues embarquées**

Il est nécessaire de rappeler qu´une vue embarquée est une vue au sens Workey, c´est à dire la spécification d´un ensemble de champs (les colonnes de la vue) qui sont évalués pour un ensemble de documents sélectionnés (les lignes de la vue). Une vue embarquée est définie dans un l'arborescence du projet, et associée à un formulaire, qui précise la mise en page de cette vue dans l´espace visible du document.

**Accessibilité d´une vue embarquée**

Un formulaire pouvant être attaché à un ou plusieurs types de document, un vue embarquée dans un formulaire est ainsi accessible pour tous les types de document utilisant ce formulaire.

**Documents présentés**

Une vue embarquée présente uniquement les documents créés depuis le document courant, s´ils sont du type précisé dans les conditions d´utilisation de la vue.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-49b10d02c5e599421d138714b196a02f8efc901c%2Fprocess-config-designer-html-creation-de-tableaux-de-bord-les-vues-utilisateur-10.png?alt=media" alt=""><figcaption></figcaption></figure>

**Modélisation**

Dans un graphe de type procédure, ajoutez un Composant puis liez l'objet en sortie d'un document et en entrée d'un ou plusieurs autre documents.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-8bb41db2c21d284e17557bd2f48bc1574b1146a1%2Fprocess-config-designer-html-fonctions-avancees-14.png?alt=media" alt=""><figcaption></figcaption></figure>

La sémantique exacte exprimée par cet exemple est la suivante : depuis un document de type « Demande d'intervention » dans un état « pour action », il est possible de créer, par la vue nommée « Création de plan d'actions» des documents de type « plan d'actions» dans un état initial « éditée ».

**Propriétés d'une vue embarquée**:

**Libellé**: Permet de saisir un nom visible pour le vue

**Nom interne** : Attribut *Designer\_name* de l'objet (Ce nom doit être unique)

**Nom interne calculé automatiquement** : Permet de garantir l'unicité des noms interne d'objets en laissant Workey les définir

**Max Docs** : Défini le nombre de documents dérivés qu'il sera possible pour l'utilisateur de créer à partir de la vue.

**Doc dérivé** : Spécifie le type de document à créer. Le document doit être existant dans la modélisation.

**Description**: Permet de saisir un texte de description pour la vue

**Aide**: Permet d'entrer un texte d'aide Il est aussi possible d'ajouter des liens logiques aux objets Vue embarquée.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-78d3963bcbed904dc3c12aabf5f527332cd7264f%2Fprocess-config-designer-html-fonctions-avancees-16.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Définir la vue embarquée**

Une fois la vue embarquée positionnée dans la procédure, il faut définir son contenu. Pour ce faire, maintenir la touche ctrl et double-cliquez sur le composant ou sélectionnez le et cliquez sur le bouton "Graphe Zoom" du menu

Vous pourrez ainsi définir votre vue embarquée telle qu'elle sera présentée dans le formulaire

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-81ae5153cb824fe478e0ee532c9f23f5de7081ce%2Fprocess-config-designer-html-fonctions-avancees-18.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Insertion d'une vue embarquée dans un formulaire**

Dans un formulaire, ajoutez le composant "vue embarquée" .

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-49b10d02c5e599421d138714b196a02f8efc901c%2Fprocess-config-designer-html-creation-de-tableaux-de-bord-les-vues-utilisateur-10.png?alt=media" alt=""><figcaption></figcaption></figure>

Il n'est pas possible de modifier manuellement les colonnes d'une vue embarquée dans un formulaire ni dans le graphe, seulement dans l'arborescence du projet. Le formulaire prévoit l'emplacement de la vue et l'objet est entièrement créé entre la procédure et l'emplacement dédié dans les vues embarquées.

#### Règles de synchronisation

**Principe**

Une synchronisation est une règle spécifiant qu'une opération ne peut s'exécuter que si des documents dérivés du document principal ont atteint ou sont passés par un état donné.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-059f48afb08aac644d954193f25c306be9681f9b%2Fprocess-config-designer-html-fonctions-avancees-04.png?alt=media" alt=""><figcaption></figcaption></figure>

Dans cet exemple, l'opération "Cloturer la demande" est soumise à une synchronisation avec les documents du type "Bon de commande", qui sont créés par dérivation depuis un document "Demande d'achat" plus en amont dans le déroulement du processus.

L'opération ne pourra s'effectuer que si tous les documents dérivés de type "Bon de commande", créés depuis la "Demande d'achat", sont au moins passés une fois pas l'état "action OK" (ils peuvent se trouver maintenant dans un autre état).

Dans certaines modélisations, il peut se trouver qu'il n'y ait aucun document dérivé créé (cas d'un dérivation optionnelle, par exemple). Dans cette situation, la régle de synchronisation est considérée comme vérifiée: l'opération pourra s'exécuter.

**Cas de plusieurs synchronisations**

Une opération peut être mise en attente de plusieurs synchronisations. Dans ce cas, l'interprétation est que la satisfaction d'une seule de ces synchronisations suffit à rendre exécutable l'opération (interprétation de type "OU").

Plus généralement, une synchronisation peut intervenir entre deux documents ayant un ancêtre commun. Ceci couvre donc les cas de synchronisation d'un document "père" avec ses "petits-fils", ou l'inverse, de documents "cousins", etc…

Synchronisation des données

Lors de la synchronisation, c'est à dire au moment où le document attendu par l'opération atteint l'état requis, les champs de ce document peuvent venir compléter les champs de même nom présent dans le document en attente de la synchronisation.

Pour activer cette synchronisation des champs, cocher la case "Synchronisé" des champs pour lesquels elle est désirée:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-423415a24d933fbf88cb90f68678ed4f53ee0ae2%2Fprocess-config-designer-html-fonctions-avancees-19.webp?alt=media" alt=""><figcaption></figcaption></figure>

### Gestion des délais

**Principe**

Il est possible avec Workey de spécifier à partir d'une opération quelle est l'action à entreprendre en cas de dépassement d'un délai fixé par le concepteur. Un dépassement de délai permet:

* de positionner un document dans un état déjà présent dans le parcours du processus,
* de positionner un document dans un état spécialement prévu pour un dépassement de délai,
* de créer un nouveau document.

**Modélisation**

Sélectionner le type de lien "délai" parmi la liste des liens du panneau de droite.faire partir le lien "délai" depuis l'opération soumise au délai et pointer sur un document/etat.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-e0af7581edf6710345e837ff6a991b5cddb94be4%2Fprocess-config-designer-html-fonctions-avancees-20.png?alt=media" alt=""><figcaption></figcaption></figure>

\*Pour éditer les propriétés de la gestion de délai, cliquer sur le lien précedement modélisé.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-6f5c96af2a8a823479a2a7cb689334f5a37d881e%2Fprocess-config-designer-html-fonctions-avancees-21.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Choix de l'unité de temps:**

Une unité de temps est nécessaire pour le calcul des délais (Jour ou Heure).

Toutes les durées exprimées dans la gestion de délais seront supposées exprimées dans cette unité de temps.

**Changement automatique de l'état du document**

La date à laquelle le document sera mis dans l'état spécifié peut être spécifiée de deux manières différentes:

* Après un nombre spécifié d'unité de temps:

le délai (N) est fourni en nombre de jours ou d'heures, suivant l'unité de temps choisi.

* Détermination de la date à partir de laquelle court le délai

Cette date peut être renseignée de deux manières

1. date de la dernière opération
2. date à laquelle le document a atteint un état spécifié

```
cette option permet par exemple de spécifier par exemple que le délai court depuis la création du document
```

* A la date lue dans un champ spécifié

une liste de champs disponibles est affichée pour le choix de ce champ (en cochant la case "champs de type date seulement", seuls les champs de ce type sont présentés)

**Avertissements (éventuels)**

Avant la date de mise autoritaire du document concerné par la gestion des délais dans l'état spécifié, un certain nombre d'avertissements peut éventuellement être adressé au personnel en charge de l'opération concernée. Jusqu'à 3 avertissements peuvent être prévus, en indiquant pour chacun le nombre d'unités de temps avant la date de changement d'état.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-ff080c49d38e94a3d0a5c2ba4507c57b1ea0ea18%2Fprocess-config-modelisation-creer-une-procedure-10.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Personnalisation du corps des messages**

Les mails sont construits sous forme de Messages MIME multipart. L'encodage des caractères dans le sujet du mail et dans le corps du message peut être spécifié à l'aide de la propriété `com.clog.workey.engine.NotificationSender.mailCharset` (lorsque cette propriété n'est pas présente, la valeur par défaut est utf-8). Lorsque l'identité utilisé pour l'envoi de notification email est **SERVER**, alors le **PERSONAL** (l'identité apparente dans l'entête du mail) sera celui renseigné avec la propriété `com.clog.workey.engine.NotificationSender.mailerName`.

Les messages envoyés automatiquement par la gestion des délais peuvent être personnalisés.

Les boutons "Codifier le message d'avertissement" et "Codifier le message de survenance" permettent de saisir des formules exprimées en script STalk, le résultat de l'exécution de ces formules venant remplacer le texte du corps de ces messages (par défaut, le corps du message est le sujet du document).

### Modélisation d'opérations réalisables depuis tout état d'un document

Une opération peut être modélisée comme étant réalisable depuis n'importe quel état d'un document.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-d958ed0bee5d38b6030a600f5f18ce60ea03a4a6%2Fprocess-config-designer-html-fonctions-avancees-22.png?alt=media" alt=""><figcaption></figcaption></figure>

#### Déclaration de "tout état"

Dans le dialogue de création/modification d'une instance de document, il est possible de choisir "\<Tout état>" comme nom de l'état.

Les mails sont construits sous forme de Messages MIME multipart. L'encodage des caractères dans le sujet du mail et dans le corps du message peut être spécifié à l'aide de la propriété `com.clog.workey.engine.NotificationSender.mailCharset` (lorsque cette propriété n'est pas présente, la valeur par défaut est utf-8). Lorsque l'identité utilisé pour l'envoi de notification email est **SERVER**, alors le **PERSONAL** (l'identité apparente dans l'entête du mail) sera celui renseigné avec la propriété `com.clog.workey.engine.NotificationSender.mailerName`.

#### Conséquence dans le flux de travail

La conséquence de la modélisation "tout état" est que la ou les opérations concernées (en sortie de cet état particulier) seront proposées tout au long du parcours de vie du document à tous les acteurs jouant le rôle adéquat.

### Gel et destruction de documents

* l'état générique "\<Détruit>" utilisé en sortie d'une opération permet de modéliser la destruction volontaire d'un document par un acteur.
* l'état générique "\<Gelé>" utilisé en sortie d'une opération permet de modéliser le gel volontaire d'un document par un acteur.

#### Destruction de documents dans le workflow

La possibilité pour les utilisateurs de détruire des documents participant au Workflow a été intégrée de la même manière que toute autre opération : elle est entièrement modélisable.

**Destruction manuelle**

Un état de document générique : **\<Détruit>** figure dans la liste des états possibles pour tout type de document, et peut donc être sélectionné en sortie d´une opération quelconque :

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-04e916547e57772f08f51609fcdf2c46b588ca15%2Fprocess-config-designer-html-fonctions-avancees-23.png?alt=media" alt=""><figcaption></figcaption></figure>

Naturellement, plusieurs opérations de destruction de document peuvent être spécifiées, et il peut s´avérer commode de grouper toutes les possibilités de destruction d´un processus dans un seul graphe « Destruction de documents » .

Lors de la génération des règles de flux, la règle suivante est vérifiée :

```
L´état <Détruit> doit être un état terminal
```

Dans l´application web, la sélection de cet état par l´utilisateur entraîne la destruction du document:

**Destruction automatisée**

Le document en fin de vie sera détruit à une date calculée par une règle. Par exemple, 15 jours ouvrables après la date de la dernière opération, ou bien encore, au 31 décembre de l´année suivant son année de création. Naturellement, cette règle peut varier en fonction du contenu du document. Elle est spécifique au métier abordé par le processus.

La modélisation de cette destruction différée est le **meilleur outil** pour maîtriser le volume de documents présents dans le système, tout en offrant aux utilisateurs une possibilité de consulter directement les documents en fin de vie pendant une durée jugée opérationnellement utile.

Elle peut prendre deux formes :

* Une opération de destruction spécifique à un type de document confiée à un rôle agent dans le processus

Dans cet exemple, la règle « statut clos » pourra spécifier la condition qui doit être vérifiéepour qu´un document de ce type puisse être détruit.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-acdd56aadd0e96d4a6ee4b6d12c77d95513f17d5%2Fprocess-config-designer-html-fonctions-avancees-24.png?alt=media" alt=""><figcaption></figcaption></figure>

Un processus particulier dans lequel un agent utilise un connecteur pour détruire un ensemble de documents, apparaissant éventuellement dans d´autres processus. Ceci est modélisable dans les propriétés du document à détruire.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-c1f387083b98b88dd08b284354970aebab982aad%2Fprocess-config-designer-html-fonctions-avancees-25.webp?alt=media" alt=""><figcaption></figcaption></figure>

Dans cet exemple, l´outil « Terminator » est un connecteur Java chargé de la destruction des documents, suivant des règles embarquées dans le code de ce connecteur.

**Destruction après Archivage**

L'outil Workey Archiver se charge de détruire les documents qui ont été archivés automatiquement.

### Groupage et dégroupage de documents

La fonction de groupage/dégroupage permet de regrouper des documents afin de leur faire suivre un même flux.

Cette fonction est activée à la création d'une vue permettant d'afficher les éléments groupables.

**Document groupe** : Est nommé *document groupe*, le document qui contiendra les documents groupés

**Documents groupés** : Sont nommés *documents groupés*, les documents contenu dans le document groupe

#### Construction de la vue

Double-cliquer sur Vues dans le panneau des projets pour créer une nouvelle vue.

Cette vue filtre les types de document dits "*groupables*" par le choix de la collection initiale : ***type de document***. En spécifiant le ou les états de document, le filtre sera plus efficace.

### Opération annulable

Définir l´annulation d´une opération et les conditions pour effectuer cette annulation.

**Annulation** : L´annulation d´une opération consiste à remettre le document dans l´état qui précédait l´opération annulée. Les documents dérivés qui auraient pu être créés par l´opération annulée sont détruits.

**Annulabilité** : Une opération est annulable si le concepteur du processus a spécifié son annulabilité (voir ci-après). Par défaut, une opération n´est pas annulable.

**Historique** : L´annulation d´une opération est une opération comme une autre, et sa trace est donc enregistrée dans l´historique du document. La trace de l´opération annulée ne persiste pas dans l´historique du document. Cette dernière est donc supprimée de l´historique.

**Droit d´annulation** : L´annulation d´une opération ne peut être effectuée que par l´utilisateur qui a effectué cette opération.

**Reversibilité des données** : lors de l'annulation d'une opération, les données sont conservées dans leurs états. Les modifications sur les données ne seront pas annulées.

#### Spécification

**Objectif** : Montrer la manière de spécifier l´annulation d´une opération.

**Boîte de dialogue**

Pour spécifier le caractère annulable d´une opération, lancer la création ou l´édition d´une opération, et cocher la case adéquate.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-74e12c1f37e9a770ae78c12efcde1e9c6533998e%2Fprocess-config-designer-html-fonctions-avancees-26.webp?alt=media" alt=""><figcaption></figcaption></figure>

#### Utilisation

**Objectif**

Énoncer les conditions d´annulation et illustrer un cas d´annulation dans l´exécution d´un processus.

**Visibilité**

Dans l´application Web, l´annulation de l´opération apparaîtra comme une opération supplémentaire à disposition :

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-b5ab47413513cc4b01b7f141b05a3e490f778b0a%2Fprocess-config-designer-html-fonctions-avancees-27.webp?alt=media" alt=""><figcaption></figcaption></figure>

La possibilité d´annuler l´opération ne sera pas montrée si celle-ci n´est pas réalisable :car le document a évolué vers d´autres états que celui immédiatement atteint après l´opération annulablecar des documents dérivés, créés par l´opération annulable, ont évolué vers d´autres états que leur état primitif lors de leur dérivationcar le document est ouvert par un acteur différent de celui qui a effectué l´opération annulable. Lors de l´annulation d´un document, ce dernier est replacé dans l´état précédent, mais il est réaffecté à l´ensemble des acteurs du rôle. certes les contraintes sont recalculées mais les sélections d´acteurs des opérations précédentes ne seront pas prise en compte. Lors de l´annulation d´un document, les données ne sont pas restituées à leurs valeurs d'origines.

Rôles, acteurs et affectation des opérations

Un acteur peut jouer un ou plusieurs rôles. Un acteur disposant de plusieurs rôles peut réaliser toutes les opérations de ces rôles.

L'affectation des rôles aux acteurs est fondamentale pour le bon fonctionnement de l'application.

Dans les graphes d'opérations, les rôles sont placés en tête de page. Les marques de séparations entre les rôles( en pointillé) sont automatiquement créées. Les opérations situées dans la colonne d'un rôle sont déclarées pouvoir être réalisées uniquement par des acteurs de ce rôle. Il résulte de cette définition que :

* tous les acteurs d'un rôle sont interchangeables : ils peuvent réaliser toutes les opérations affectées à ce rôle sur n'importe quel document.
* tous les documents traitables par un rôle figurent dans l'espace de travail (et sont traitables) de tous les acteurs de ce rôle.

Un rôle est un ensemble de responsabilités confiées à un ou plusieurs acteurs (personnes physiques ou agents).

Un acteur peut jouer un ou plusieurs rôles. Un acteur disposant de plusieurs rôles peut réaliser toutes les opérations de ces rôles.

Cette gestion utilisant exclusivement les rôles ne tient pas compte de la structure administrative de l'entreprise, qui intervient dans des règles de gestion telles que:

* seul le créateur d'un document a le droit de le modifier lorsque celui est dans l'état "à corriger",
* c'est au traducteur d'un document de décider qui sera (parmi les acteurs du rôle "réviseur") la personne qui révisera le document,
* un acteur du rôle "demandeur" est forcément acteur du rôle "chef de service",
* un acteur du rôle "contrôleur" ne peut pas être acteur du rôle "directeur",
* un acteur de "service commercial" doit faire signer sa demande par son chef de service.

Les fonctions avancées permettent au concepteur de spécifier des règles de ce type. La définition de contraintes entre opérations portant sur les acteurs permettent d'exprimer les deux premières règles, les notions de sélection d'acteurs et de notifications couvrent les cas illustrés par la troisième règle, les deux suivantes sont implémentées grâce aux graphes d'interdépendance entre rôles, enfin la dernière est gérée par la gestion des règles de hiérarchie et de contraintes entre opérations portant sur les unités.Ces différentes fonctions avancées permettent de spécifier des règles de gestion parfois complexes. Elles doivent être utilisées en connaissance de cause dans la mesure où elles peuvent aisément mener à des blocages dans l'exécution du Workflow.

Le cas le plus fréquent est la combinaison de contraintes d'interdiction et de sélection d'acteurs menant à des situation telles qu'un document ne peut plus être traité par aucun acteur. Le gestionnaire de la base, pourra cependant à tout instant débloquer de telles situations.

### Le mode de définition des contraintes organisationnelles

Afin de ne pas surcharger le modèle d'opérations, Workey permet de se placer dans un plan différent, qui permet de visualiser uniquement les rôles et les opérations. Dans ce plan, il n'est pas permis pas de créer de nouveaux objets ni de les déplacer. Par contre, les liens permettant d'exprimer des contraintes y sont autorisés.

Par exemple, soit le modèle d'opérations suivant:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-7d29ab02ad79cac2d20769c0d43173b133bd1026%2Fprocess-config-designer-html-fonctions-avancees-28.webp?alt=media" alt=""><figcaption></figcaption></figure>

Pour passer dans le plan "Contraintes",cliquer sur l'icône

. ainsi le modèle suivant apparaît :

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-07f9635c656c01a862c2b4e88eb0367bd128a691%2Fprocess-config-designer-html-fonctions-avancees-30.webp?alt=media" alt=""><figcaption></figcaption></figure>

Pour revenir dans le plan initial, il vous suffit de cliquer à nouveau sur l'icône

A partir du plan *Contraintes*, vous pouvez exprimer des contraintes portant sur les opérations afin de préciser par exemple les règles suivantes:

* seul le créateur d'un document a le droit de le modifier lorsque celui est dans l'état "à corriger",
* même s'il joue les deux rôles, un acteur ne peut pas être à la fois l'auteur et le contrôleur d'un document,
* un acteur du rôle demandeur appartenant au service commercial doit faire contrôler sa demande par le chef de service de son unité.

Le calcul des autorisations d´accès à la modification des documents et à leur avancement dans le flux de travail s´effectue en premier lieu dans Workey au moyen du concept de rôle: seuls les acteurs jouant le rôle voulu peuvent effectuer une opération sur un document dans un état donné. Le concept de contrainte organisationnelle permet d´affiner ce mécanisme en prenant en compte l´appartenance des acteurs aux unités organisationnelles: parmi les acteurs jouant le rôle voulu, seuls ceux appartenant à des unités bien spécifiées seront autorisés à effectuer l´opération. Ce mécanisme ne remplace donc pas celui basé sur les rôles, mais le complète et l´affine. Il est basé sur la modélisation des unités et de leur liens de dépendance.

Pour spécifier une contrainte entre deux opérations, il faut lier ces deux opérations.

Une contrainte organisationnelle entre deux opérations "A" et "B" du cycle de vie étendu d´un document exprime que l´ensemble des acteurs pouvant effectuer l´opération "B" dépend de l´acteur particulier ayant effectué l´opération "A". Cette dépendance est définie par une contrainte faisant intervenir les unités organisationnelles, d´où le nom de **contrainte organisationnelle**.

Une contrainte est une liaison orientée, et n'exprime donc pas la même sémantique suivant l'origine et le destination du lien.

Si "Acteur A" désigne l'acteur ayant effectué l'opération "A", et "Acteur B" un acteur autorisé à effectuer l'opération "B", il est possible de spécifier une des contraintes suivantes:

* "Acteur B" doit être uniquement "Acteur A" (c´est le même acteur qui fait les deux opérations),
* "Acteur B" ne peut pas être "Acteur A" (le même acteur ne peut pas effectuer les deux opérations),
* "Acteur B" doit appartenir à une des unités auxquelles appartient "Acteur A",
* "Acteur B" doit appartenir à une unité hiérarchiquement supérieure (ou inférieure) aux unités auxquelles appartient "Acteur A".

Les deux premiers cas montrent que la définition de l´ensemble des acteurs autorisés peut soit s´opérer "en positif" (en spécifiant l´ensemble des possibles) ou en "négatif" (en spécifiant l´ensemble des exclus).

Dans les deux derniers cas, il est possible de spécifier le nombre de niveaux hiérarchiques pouvant être parcourus (1,2, ou N), un nombre négatif désignant un niveau hiérarchique inférieur.

Par exemple, une contrainte portant sur un intervalle \[-1, +2] signifie que l'unité de "Acteur B" doit être soit, d'un niveau immédiatement inférieur à l'unité de "Acteur A", soit égal, soit supérieur de 1 ou 2 niveaux.

Il est également possible de spécifier directement l´ensemble des acteurs possibles pour une opération en indiquant dans le document lui-même l´unité ou les unités autorisées. Un champ du document est désigné pour être renseigné sur le choix d´une ou plusieurs unités, lors des opérations précédentes.

Dans le cas de contrainte (d´acteur ou d´unité), si Workey n´arrive pas à affecter un document, le document sera automatiquement affecté au Process Manager. Dans le cas où aucun Process Manager ne serait défini, le document sera affecté au Workflow Manager.

#### Contraintes entre opérations portant sur les acteurs

**Définitions**

Il existe deux types de contraintes entre opérations:

* les contraintes d'obligation,
* les contraintes d'interdiction.

Obligation: opération 1 "oblige" opération 2 signifie que, pour un document donné, l'acteur y ayant réalisé l'opération 1 fera partie des acteurs seuls autorisés à y réaliser l'opération 2.

Interdiction: opération 1 "interdit" opération 2 signifie que pour un document donné, l'acteur y ayant réalisé l'opération 1 n'aura pas le droit d'y réaliser l'opération 2.

####

**Modélisation d'une contrainte d'acteurs**

Pour modéliser une contrainte, il faut d'abord se placer dans le plan "*Contraintes*" du modèle d'opérations. Ensuite, à partir d'une opération donnée, il faut définir quelles sont les opérations "obligées" ou "interdites" selon la définition ci-dessus, en liant cette opération aux opérations concernées.

Deux objets et deux types de lien sont disponibles dans les Composants d'un modèle de contraintes.

**Champ**: Permet de définir un champ existant sur la valeur duquel portera la contrainte, ou d'en créer un nouveau.

**Opération externe** : Permet de définir une opération existante dans une autre procédure dont le traitement conditionnera la contrainte. **Restriction**: Restreint l'exécution de l'opération à un acteur précis ou une unité d'acteurs.

**Interdiction**: Interdit l'exécution de l'opération à un acteur précis ou une unité d'acteurs.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-8f2cec8f5fd3a9844ab18f76e5862d7be29d34b3%2Fprocess-config-designer-html-fonctions-avancees-31.png?alt=media" alt=""><figcaption></figcaption></figure>

Dans notre exemple nous souhaitons exprimer la contrainte suivante :

```
C'est le même acteur du rôle Responsable support qui créé les fiches d'actions et qui clôture la fiche d'incidents.
```

Pour exprimer cette contrainte vous devez effectuer les actions suivantes :

1. dans la zone type de lien : choisir l'objet "Restriction",
2. dans les propriétés du Lien de restriction, choisir l'option "Acteur" dans la section Général.

Dans notre exemple nous souhaitons maintenant exprimer la contrainte suivante :

```
Si un acteur joue le rôle Support, il ne peut pas traiter une action et aussi la valider.
```

Pour exprimer cette contrainte vous devez relier les deux opérations traiter l'action et valider puis effectuer les actions suivantes :

* dans la zone type de lien : l'objet "Interdiction",
* dans les propriétés du Lien d'interdiction, choisir l'option "Acteur" dans la section Général

**Portée de la contrainte**

Une contrainte telle que décrite ci-dessus est définie localement dans la procédure: on ne pourra obliger ou interdire que les opérations de la même procédure.Pour exprimer des contraintes portant sur des opérations présentes dans d'autres procédures, dans l'ensemble du projet, vous devez surcharger le modèle en intégrant des opérations "externes" provenant d'autres procédures.

Ajoutez un objet **opération externe** dans la colonne de l'opération concernée.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-9c2cd352d2d222deb5cdb6cac053ab46753e0fce%2Fprocess-config-designer-html-fonctions-avancees-32.webp?alt=media" alt=""><figcaption></figcaption></figure>

Choisissez la **procédure** contenant l'opération et l'**opération**en question.

Une fois l'opération externe présente dans le graphe vous pouvez exprimer les contraintes organisationnelles comme précédemment. Pour spécifier par exemple que le représentant de la *Hot line* qui a déclaré un incident doit être celui qui valide la fiche d'actions correspondante, ajoutez l'opération externe "*déclarer*", puis liez-la à l'opération "*valider*" avec un lien de *restriction*.A partir des contraintes déclarées par le concepteur, Workey déduit logiquement par symétrie ou transitivité toutes les autres contraintes que l'on peut en déduire.

On notera la présence d'un icône en bas à droite de l'objet Opération venant d'être lié ![](https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-aa33491368e90827b291499c81d3d935367a1a38%2Fprocess-config-designer-html-fonctions-avancees-33.png?alt=media)

. Cette icône sera affichée tant qu'au moins 1 lien de restriction ou d'interdiction entrera sur l'opération.

**Impact au niveau de l'utilisation de l'application**

Pour l'utilisateur de l'application générée, la présence de contraintes d'interdiction ou d'obligation entre opérations est parfaitement transparente.

Lorsqu'il est le seul à pouvoir réaliser une opération sur un document donné (généralement à cause d'une contrainte d'obligation) l'icône en regard du document dans la vue l'en informe. Lorsqu'en raison d'une contrainte d'interdiction il ne peut réaliser une opération donnée sur un document, celui-ci n'apparaît tout simplement pas dans sa liste de documents à traiter.

### Contraintes entre opérations portant sur les unités organisationnelles

Les contraintes organisationnelles portant sur les unités permettent d'exprimer des règles de type :

* la note de frais d'un acteur appartenant à l'unité "Département des ventes" doit être contrôlée par l'acteur jouant le rôle de Contrôleur mais faisant partie de la même unité organisationnelle que celui-ci,
* une demande d'achat doit être validée par son supérieur hiérarchique, puis approuvée par le niveau N+2.

Ce mécanisme vient en complément du mécanisme de rôle et du mécanisme de contraintes portant sur les acteurs.

#### Modélisation d'une contrainte d'unité organisationnelle

Modéliser une contrainte consiste à de placer d'abord dans le plan "*Contraintes*" .

Ensuite, à partir d'une opération donnée, lier cette opération aux autres opérations concernées par ces règles hiérarchiques.

Après la création du lien, choisissez l'option "**Unités**" dans la section Général, puis ajustez le niveau hiérarchique désiré de l'unité.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-9e6b474520ec37186fd521c03431a984e0ff7376%2Fprocess-config-designer-html-fonctions-avancees-34.png?alt=media" alt=""><figcaption></figcaption></figure>

Tout comme une contrainte d'obligation ou d'interdiction, les contraintes hiérarchiques peuvent être définies **localement**dans la procédure ou **globalement**pour l'ensemble du projet.

#### Impact sur l'utilisation de l'application

Pour l'utilisateur de l'application générée, la présence de contraintes hiérarchiques entre opérations est parfaitement transparente. En mode client Web, les droits d'accès aux opérations sont calculés automatiquement en fonction des contraintes et des unités organisationnelles.

Lorsqu'il est le seul à pouvoir réaliser une opération sur un document donné l'icône en regard du document dans la vue l'en informe. Si un acteur ne peut réaliser une opération donnée sur un document, celui-ci n'apparaît tout simplement pas dans sa liste de documents à traiter.

### Calcul dynamique des unités et des acteurs (contrainte sur valeur de champ)

#### Principe

La liste des acteurs ou des unités éligibles pour opérer sur un document donné est calculée par Workey en fonction des règles exprimées dans le modèle :

* règles portant sur les acteurs,
* règles portant sur les unités.

Il est parfois intéressant de calculer cette liste dynamiquement en fonction de champs présents dans le formulaire.Par exemple, un acteur précise dans le formulaire quel est le département chargé de prendre en compte son document. Dans ce cas, Workey utilise cette information comme une nouvelle contrainte lui permettant de calculer cette liste d'acteurs éligibles.Ce mécanisme s'appliquant aussi bien pour les acteurs que pour les unités, il est ainsi possible de préciser, en renseignant un champ du document, quel acteur peut prendre en compte le document pour une opération donnée.

#### Calcul automatique de l'unité

Workey offre la possibilité de spécifier directement l´ensemble des acteurs possibles pour une opération en indiquant dans le document lui-même l´unité ou les unités autorisées.

Par exemple, dans un formulaire, un champ peut être réservé , soit pour saisir directement le nom d'une unité, soit pour retourner par le résultat d'un script le nom d'une unité. Ce champ doit naturellement être renseigné avant l'opération concernée par la contrainte.

Pour préciser ce type de mécanisme, vous devez rester dans le plan "Contraintes" d'un modèle d'opérations.

Soit le modèle suivant :

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-09a692f78c5c9b8a3e7abed483c18ec9d0835df3%2Fprocess-config-designer-html-fonctions-avancees-35.png?alt=media" alt=""><figcaption></figcaption></figure>

Pour préciser que l'opération "Préparer paiement", affectée au rôle "Aide comptable", doit être réalisée par les acteurs de ce rôle, mais appartenant également à une unité organisationnelle précisée dans un champ du formulaire, vous devez insérer le champ dans le modèle, en utilisant le menu "Créer" et l'item "Champ".

Par exemple, le champ "DEPARTEMENT" pourra être créé, avec un domaine de valeurs proposant une liste d'unités.

Par exemple, le service France qui dépend du Département Ventes, qui dépend lui-même de la Direction Générale, s´écrit :

```
ou=Service France,ou=Département Ventes,ou=Direction Générale.
```

Pour préciser ensuite la règle organisationnelle, lier le champ "DEPARTEMENT" et l'opération "Préparer paiement".

Dans la boîte de dialogue, préciser ensuite le type de contrainte, dans cet exemple :

1. type : Restriction
2. portée de la contrainte, l'unité "0" à+ "0".

Cela signifie que l'on retiendra uniquement les acteurs du rôle appartenant à l'unité retournée par le champ DEPARTEMENT.

**Exemple**

Un formulaire de "Demande d'achat" comporte un champ "NATURE". Ce champ pssède une domaine de valeurs "logiciel" ou matériel". En fonction de la nature renseignée pour l'achat, logiciel ou matériel, il doit être géré par le service informatique ou le service logistique, respectivement.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-0d4b2d234e48887915dc1309bd49898faf065b00%2Fprocess-config-designer-html-fonctions-avancees-36.png?alt=media" alt=""><figcaption></figcaption></figure>

L'opération "Approuver" est contrainte par le champ "NATURE".

Au niveau de l'Organigramme, il suffit maintenant de créer deux unités :

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-8602203df4b83c54c9c17d1b19f8ddfce47f95d0%2Fprocess-config-designer-html-fonctions-avancees-37.png?alt=media" alt=""><figcaption></figcaption></figure>

Il n'est pas nécessaire dans ce cas, de préciser le type d'unité (direction, service) ni même un lien de hiérarchie.

#### Calcul automatique de l'acteur

Le principe est identique à celui précisé pour une unité. La différence est que la portée de la contrainte précisée dans la boite de dialogue doit être renseignée à "Acteur". Le champ utilisé pour exprimer la contrainte doit quant à lui retourner un nom d'acteur (distinguished name dans le ldap).

Le nom de l'acteur doit être présent dans le Ldap (distinguished name).

Le rôle "agent"

Un rôle au sein d'une procédure peut être confié à un agent, c'est à dire à un **programme s'exécutant sur le serveur**, déclenché selon une certaine **fréquence** (par exemple, à chaque heure, au début de chaque jour, le premier jour du mois, etc..).Le comportement précis engendré par la déclaration d´un agent jouant un rôle est le suivant :un agent **de même nom que le rôle est enregistré**,cet agent est reconnu comme **un nouvel acteur jouant ce rôle**, la **période de déclenchement de l´agent est définie**, ainsi que l´instant de sa première exécution (selon les règles définies ci-dessous),à chaque exécution de l´agent, celui-ci effectue les opérations prévues **par son rôle**, sur **tous** les documents pour lesquels il y est autorisé,après chaque exécution, la date de la prochaine exécution est déterminée suivant **la périodicité**.

Workey permet la définition et l´activation de plusieurs types d´agents, ici, nous traitons uniquement des agents pouvant exécuter des tâches dans les processus.

### Modélisation

Afin de définir dans une procédure un agent jouant un rôle spécifique, ajoutez le rôle existant désiré et éditez ses **Propriétés**.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-83b3b7862042e0524e071ca8aab05389317b8dda%2Fprocess-config-modelisation-creer-un-projet-07.png?alt=media" alt=""><figcaption></figcaption></figure>

Cochez l'option **Agent**et remarquez que l'objet rôle à maintenant une couleur bleue signifiant l'activation de la fonction de rôle agent.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-71259738269430ba42381ee0231612ce932fc340%2Fprocess-config-designer-html-fonctions-avancees-38.webp?alt=media" alt=""><figcaption></figcaption></figure>

Propriétés de l'objet **Rôle**

**Général Libellé**: Permet de saisir un nom visible pour le rôle

**Nom interne** : Attribut *Designer\_name* de l'objet (Ce nom doit être unique)

**Nom interne calculé automatiquement** : Permet de garantir l'unicité des noms interne d'objets en laissant Workey les définir

**TypePublic** : tous les acteurs du rôle pourront avoir accès au document, qu'ils aient ou non traité ce document

**Privé** : seul les acteurs ayant effectué une opération en jouant ce rôle auront accès au document

**Agent** : défini qu'un agent s'exécutera la ou les opération en utilisant les accès du rôle

**Périodicité** : Spécifie le type de fréquence d'exécution de l'agent en Heure, Jours ou Mois

**Formulaire** : Spécifie un formulaire présenté à l'acteur du rôle

**Description** : Permet de saisir un texte de description pour le rôle, poiter vers un fichier externe contenant le texte de description et entrer un texte d'aide. Il est aussi possible d'ajouter des Liens logiques aux objets Rôle.

La fréquence exacte (par exemple toutes les 2 heures), ainsi que la date de chaque déclenchement (le 15 de chaque mois) sera ensuite affinée au niveau de la base générée via la Console d'administration.

L'agent crée dans vôtre procédure sera crée par Workey automatiquement dès le déploiement du processus.

Une restriction évidente est imposée quant au type d'opérations à la charge d'un agent : il ne peut traiter des opérations faisant intervenir un choix libre parmi plusieurs possibilités. En conséquence, la génération de la base Notes ne pourra être effectuée si une des opérations faisant partie de la tâche de l'agent est assortie d'une post-condition de type "OU" sans règle de calcul de l'état suivantEn corollaire sont donc autorisées :

* les opérations « simples » (sans post-condition)
* les opérations avec une post-condition "ET", permettant ainsi la dérivation automatique de un ou plusieurs documents
* les opérations avec une post-condition "OU" "automatiques", c'est à dire avec un ensemble de règles de calcul permettant de déterminer un et un seul état possible dans toutes les situations

### Règle de déclenchement

L´instant de la première exécution est déterminé par les règles suivantes:

* pour une période de type « Jour », le premier déclenchement est fixé au lendemain matin, après 2 heures du matin et un nombre de minutes déterminés de manière aléatoire (par exemple, 2h 18)
* pour une période de type « Heure », le premier déclenchement est fixé au début de l´heure suivante additionné d´un nombre de minutes déterminés de manière aléatoire.

### Modifications des caractéristiques de l´agent

La date de la prochaine exécution de l´agent, ainsi que sa périodicité, peuvent être re-définis par les administrateurs des processus.

(voir le document Console d'administration)

### Exécution des connecteurs

Tout comme les opérations effectuées par les acteurs humains, les opérations effectuées par des agents provoquent la mise en oeuvre de tous les connecteurs prévus pour cette opération.

### Notifications

Les notifications aux acteurs prévues pour l´opération sont également prises en compte par l´agent, qui envoie les e-mails correspondants en utilisant sa propre adresse.

### Ré-utilisation des agents lors de l´évolution des processus

Lors de la mise à jour d´un processus, les agents existants et jouant déjà un rôle dans la version précédente du processus sont conservés et affectés à la nouvelle version de ces rôles.

### Administration des agents

La **console d'administration** permet de configurer vos agents ainsi que de superviser leurs activités — voir [Agents Process](https://documentation.efalia.com/produit/efalia-process/administration/agents-process.md).

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-a2395de4e5f7b7dd87eea9030ff8b42d6753b875%2Fprocess-config-designer-html-fonctions-avancees-39.webp?alt=media" alt=""><figcaption></figcaption></figure>

A partir de la Console d'administration, vous allez pouvoir définir pour l'agent créé en modélisation comme décrit ci-dessus les éléments suivants :

**Options**

* **Journalisation de l'activité** Permet de construire une trace de l'activité de l'agent
* **Autoriser les instances multiples** Permet d'utiliser plusieurs de ces agents simultanément

**Tâche**

* **Activer/Désactiver** (Utilisé) Permet d'activer ou suspendre l'activité le l'agent
* **Valeur** Permet de préciser la taille du batch

**Déclenchement**

* **Mode d'exécution**
  * **Répétition à intervalle régulier** : Permet de définir une fréquence régulière selon l'unité de temps choisie
    * **Intervale de temps** : Défini l'unité de temps de la fréquence d'exécution de l'agent
  * **Expression CRON** : Permet de spécifier une expression CRON de planification personnalisée du déclenchement
* **Mode de démarrage**
  * **Dès que possible** : Exécute l'agent aussitôt que l'état de disponibilité du serveur web le permet
  * **Compte-à-rebours** : Permet de spécifier un laps de temps entre 1 et 120 minutes avant l'exécution de la tâche de l'agent
  * **Heure fixe** : Spécifie une heure exacte à pour l'exécution de l'agent
  * **Date Fixe** : Permet de choisir dans un calendrier une date précise pour le déclenchement

**Exclusion**

* **Utiliser calendrier** : Permet de choisir un calendrier personnalisé pour exclure des dates et/ou heures dans la planification du déclenchement de l'agent

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-717a724582c4973ac2379bd12d81f3ed8cd3e882%2Fprocess-config-designer-html-fonctions-avancees-40.webp?alt=media" alt=""><figcaption></figcaption></figure>

Notification / Sélection d'acteurs

Il peut être souhaitable, à certaines étapes du processus, de laisser le libre choix des intervenants suivants aux acteurs eux-mêmes.

Ce choix s'effectue dans une ensemble d'acteurs qui est peut-être le résultat du calcul des différentes contraintes exprimées : appartenance au rôle voulu, contraintes organisationnelles de différents types. C'est sur cette liste éventuellement restreinte que pourra s'effectuer le choix par l'acteur.

Avec ce choix, vient en général le souhait de notifier les acteurs ou les intervenants choisis Au niveau de la modélisation, c'est dans les propriétés définies comme suit sur le(s) lien(s) en sortie d'une opération que les notifications sont définies.

### Sélection d'acteurs

Dans les **Propriétés**d'un lien de sortie d'une opération, il est possible de spécifier des critères de sélection des acteurs pour l'opération suivante.

**Aucun acteur** : Spécifie qu'aucune sélection automatique d'acteur est active. Les acteurs suivants sont tous les acteurs de la liste des candidats.

**Un acteur** : Spécifie que l'utilisateur devra sélectionner un (un seul) acteur spécifique dans la liste des candidats pour exécuter la prochaine opération.

**Plusieurs acteurs** : Spécifie que l'utilisateur devra choisir un ou plusieurs acteurs spécifiques dans la liste des candidats pour exécuter la prochaine opération. En cas de non-sélection, la liste de candidats toute entière est retenue. Vous pouvez préciser un nombre minimum ainsi qu'un nombre maximum d'acteurs

**Groupe de travail** : Possibilité de choisir un nombre quelconque d'acteurs dans la liste des candidats pour définir un groupe de travail autour du document concerné (tous les acteurs du groupe devront avoir "fait suivre" le document pour que le document passe à l'étape suivante). Vous pouvez préciser un nombre minimum ainsi qu'un nombre maximum d'acteurs.Tous les acteurs du groupe de travail devront alors faire envoyer sur le document pour que ce dernier puisse changer d'état. On notera que le document sera placé dans le dernier état choisi. Il faut donc ne pas proposer plusieurs états (par un OU) en sortie d'une opération parallèle. – si aucun minimum et aucun maximum n'est défini (zone vide). Tous les acteurs du rôle seront nominés pour participer au groupe de travail. – si un minimum et un maximum sont définis, alors un choix sera proposé à l'utilisateur pour qu'il désigne les acteurs qui devront participer au groupe de travail.Dans l'historique sera renseigné l'action de chaque acteur du groupe mais sous l'opération Groupe de travail. Lors de la participation à un groupe de travail le document comportera une zone indiquant les acteurs ayant ou non déjà réalisé leur actions.

**Afficher les unités** : Spécifie que la sélection d'acteurs concerne des unités organisationnelles et non des acteurs spécifiques.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-f1ae4fb9b57bec8c09f4c4ee9b52436ef8018af9%2Fprocess-config-modelisation-creer-une-procedure-03.webp?alt=media" alt=""><figcaption></figcaption></figure>

On définit par "liste des candidats" la liste des acteurs jouant le rôle concerné par l'opération suivante dans le flux, après la prise en compte de contraintes éventuelles d'obligation ou d'interdiction sur cette opération (voir le point "Contraintes entre opérations" ).

### Notification d'acteurs

Il est utile d´informer les acteurs du processus par le biais d´**e-mails**. Pour ce faire, il est possible de choisir les acteurs que l´on désire notifier des actions en cours.

Acteurs candidats

**Acteurs suivants** : Tous les acteurs potentiels suivants recevront un courriel les informant qu´ils ont une action à mener.

**Automatiquement** : (uniquement valide dans ce cas) permet de rendre automatique l´envoi d´un courriel ; si cette option n´est pas choisie, l´utilisateur pourra décider lui-même de l'envoi de ce courriel.

**Acteur précédant** : Un courriel d´information sera envoyé automatiquement à l´acteur ayant réalisé l´opération précédente.

**Acteurs intermédiaires** : Un courriel d´information sera envoyé automatiquement aux acteurs ayant réalisé les opérations précédentes depuis la création du document.

**Auteur du document** : Un courriel d´information sera envoyé automatiquement à l´acteur ayant créé le document.

**Superviseurs** : Un courriel d´information sera envoyé automatiquement aux acteurs étant définis comme Superviseur du processus.

**Utilisateurs du champ** : Un courriel d´information sera envoyé automatiquement aux acteurs étant renseignés un la valeur du champ spécifié. On notera que ce champ peut être multivalué.

***Mode de notification***

**Par messagerie** : Un courriel d´information sera envoyé.

**Par alerte** : Un pop-up d´information sera envoyé sur le poste du candidat.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-fc41abb4313fe7ae06e081596696ec782211f93b%2Fprocess-config-designer-html-fonctions-avancees-41.webp?alt=media" alt=""><figcaption></figcaption></figure>

### Notification personnalisée

Les mails sont construits sous forme de Messages MIME multipart. L'encodage des caractères dans le sujet du mail et dans le corps du message peut être spécifié à l'aide de la propriété `com.clog.workey.engine.NotificationSender.mailCharset` (lorsque cette propriété n'est pas présente, la valeur par défaut est utf-8). Lorsque l'identité utilisé pour l'envoi de notification email est **SERVER**, alors le **PERSONAL** (l'identité apparente dans l'entête du mail) sera celui renseigné avec la propriété `com.clog.workey.engine.NotificationSender.mailerName`.

**Les champs magiques**

Il est possible de personnaliser le contenu des e-mails de notification, en spécifiant un traitement particulier pour les éléments du courriel envoyé (sujet, corps, etc…).

Pour mettre en oeuvre cette personnalisation des mails, il faut suffit de créer dans le formulaire des champs dont le nom respecte une syntaxe particulière. Cette syntaxe définira le champ comme étant un champ "magique", en ce sens que le contenu de ce champ modifiera comme par magie l'e-mail de notification.

Si « myField » désigne un nom valide de champ, les syntaxes suivantes sont reconnues:

* myFiel&#x64;**\_cc** : les e-adresses présentes dans ce champ sont ajoutées au champ **carbon copy** du message (de préférence, utiliser pour ce champ, obligatoirement du type texte, une apparence Text Area avec plusieurs lignes, les adresses peuvent être séparées par des retours de ligne ou des point-virgules)
* myFiel&#x64;**\_bcc** : les e-adresses présentes dans ce champ sont ajoutées au champ **blind carbon copy** du message (même remarque)
* myFiel&#x64;**\_subject** : le texte contenu dans le champ alimentera le champ **subject**du message (en lieu et place du message par défaut)
* myFiel&#x64;**\_body** : le texte contenu dans le champ alimentera le champ **body**du message
* myFiel&#x64;**\_attach** : le texte contenu dans le champ alimentera les **pièces jointes** au message.

La notification aura lieu lors du changement d´état et le courriel sera constitué (personnalisé) avec les éléments spécifiques.

### Notification par alerte

A partir de la version 4 de Workey, il est possible de choisir un mode de notification complémentaire : Alerte. Cette notification vient en complément des notification par mail.

Le principe est d'envoyer la même information que celle présente dans le mail à une application client installé sur le poste utilisateur. Cette fonction nécessite au préalable l'installation de ce client sur le poste utilisateur soit manuellement soit par déploiement automatique via la page d'accueil Workey.

Mémo

Les Mémos servent à intervenir lors du déroulement d'un processus au moyen d'annotations à destination des intervenants.

Le sens précis de ces annotations résulte du nom choisi pour l'opération qui va les créer. En utilisant le verbe "relancer", par exemple, ces annotations pourront être interprétées comme des injonctions visant à relancer l'activité du processus.

Tout acteur ayant obtenu un droit de lecture sur un document du processus peut être muni du droit d'effectuer ces annotations, qui sont enregistrées dans l'histoire du processus.

Ces annotations pourront être diffusées par un des moyens installés (e-mails ou alertes sur les postes de travail).

Elles seront directement visibles par les personnes concernées lors de l'ouverture des documents en ayant fait l'objet.

### La modélisation

La modélisation consiste tout d'abord à déterminer:

* qui peut effectuer ces annotations,
* quand peuvent-elles être effectuées.

Dans l'onglet des Composants, choisissez l'objet et glissez-le dans le graphe de procédure.

**Général Libellé**: Permet de saisir un nom visible pour l'objet.

**Nom interne** : Attribut *Designer\_name* de l'objet (Ce nom doit être unique).

**Nom interne calculé automatiquement** : Permet de garantir l'unicité des noms interne d'objets en laissant Workey les définir.

**Mémo** : Permet d'entrer un texte informatif.

**Diffusion privée** : Permet de restreindre la diffusion du message

**Par alerte** : Permet d'installer une alerte pop-up sur le poste du destinataire du message.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-8dd64499b01feb0365ef446c4e576b4b287a70c4%2Fprocess-config-designer-html-fonctions-avancees-42.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Description** : Permet de saisir un texte de description, pointer vers un fichier externe contenant le texte de description et entrer un texte d'aide. Il est aussi possible d'ajouter des Liens logiques aux objets Mémo.

Le mémo est une opération particulière et comme toute opération,

* elle est placée sous le rôle permettant de l'effectuer,
* elle est reliée à l'état de document à partir duquel elle est possible.

La modélisation permet:

* de nommer cette opération en accord avec le but recherché,
* de préciser si les annotations sont en accès:

1. privé (elles ne seront visibles que par les personnes explicitement désignées comme destinataires, et par celles qui les ont créées)
2. ou public (elles seront visibles par toute personne auorisée à lire le document),

* de préciser son mode de diffusion (par défaut, la diffusion se fait par l'envoi d' e-mails, il est possible de spécifier une diffusion par alertes).

### L'utilisation

* A l'ouverture du document, une section "Annotations" est affichée, montrant à l'utilisateur courant les annonces reçues et émises par lui. La colonne 'Objet' reprend les 120 premiers caractères de la relance.
*

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-6371f8aa36b51c4a6fba8655300e31a9ad7d2082%2Fprocess-config-designer-html-fonctions-avancees-43.webp?alt=media" alt=""><figcaption></figcaption></figure>

(les "process managers" ou "workflow managers" voient toutes les annonces effectuées).

* Si les conditions le permettent (l'utilisateur joue un des rôles prévus et le document se trouve dans un des états prévus), une zone de saisie lui permet de saisir le texte du message, puis de diffuser l'annonce:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-df9cc27d12725f45b8f87937865500ec29348310%2Fprocess-config-designer-html-fonctions-avancees-44.webp?alt=media" alt=""><figcaption></figcaption></figure>

* Dans la vue "Actions possibles", les utilisateurs jouant le rôle voulu peuvent visualiser tous les documents qu'ils sont en mesure d'annoter:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-1b0bdb2a302bdc1e23c5e6962500fb553be43867%2Fprocess-config-designer-html-fonctions-avancees-45.webp?alt=media" alt=""><figcaption></figcaption></figure>

### Gestion des délais et annotations

La gestion des délais à respecter dans un processus est confiée à un agent. Il est possible de spécifier que les notifications envoyées par cet agent aux acteurs donnent automatiquement lieu à des annotations reprenant les termes de ces notifications. Ceci aura pour effet de conserver ces messages et de les rendre visibles aux acteurs concernés. Dans l'outil de conception, il faut afficher la page du graphe du processus et éditer ses propriétés.

Tâche programmées / Evénements liés aux données

Ce chapitre décrit la notion d'événements pouvant se déclencher dans un processus à la suite de circonstances créés par certaines données.

Par exemple, dans un processus d'accueil de nouveaux collaborateurs, les données comme "le contrat est un CDD" et "la date de fin de contrat est le 15 janvier" pourrait donner naissance à un événement "Fin de CDD". Cet événement devrait être porté à la connaissance des intervenants du processus pour les en rendre attentifs.

### Modélisation

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-3d324f08412b3691cc3d673c4b4d5d7d27fc33af%2Fprocess-config-designer-html-fonctions-avancees-46.png?alt=media" alt=""><figcaption></figcaption></figure>

Dans un modèle de procédures, faites glisser un objet **Tâche programmée**, puis liez-le à une opération.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-d5028addad93c2428dae12a6bbee141c269860d1%2Fprocess-config-modelisation-creer-un-processus-02.webp?alt=media" alt=""><figcaption></figcaption></figure>

```
L'événement doit être lié en sortie d'une opération.
La signification du lien est : lorsque l'opération est réalisée, l'événement est créé
et considéré comme potentiellement activé.
Il ne le sera que lorsque sa condition d'existence (définie dans les propriétés de l'objet)
sera vérifiée par les données.
```

**Propriétés d'un objet tâche**

**Général**

Permet de spécifier le libellé de l'objet et son nom interne.Unité: Défini la fréquence d´exécution de la tâche en jour ou en heure.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-e514db21195c2392e2d2c411f97817e86dad006c%2Fprocess-config-designer-html-fonctions-avancees-47.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Lancement**

Date d´occurrence : Permet de saisir une date spécifique, pointer sur un champ de date ou d'entrer une instruction de calcul de date.Message : Permet de composer un message personnalisé.Condition : Permet de conditionner grâce à une fonction Stalk l'exécution de la tâche.Classe Java : Permet d´appeler une classe Java lors du déclenchement de la tâche.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-b6b170e22fcd9c1e9a763c6ec1ef3d9b97e434ef%2Fprocess-config-designer-html-fonctions-avancees-49.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Avertissements**

Échéancier d'avertissements : Permet de définir un nombre d'unité de temps (spécifiée dans la section Général) avant et/ou après le déclenchement de la tâche pour l'envoie d'avertissements par mail.Message : Permet de composer un message personnalisé.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-d675200b7c74bfada55749acabb6314cf6638f2a%2Fprocess-config-designer-html-fonctions-avancees-51.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Notifications**

Intervenants futurs : Envoie une notification aux acteurs définis pour les rôles agissant sur les opération suivantes.Intervenants passés : Envoie une notification aux acteurs ayant déjà agi sur le document.Auteur du document : Envoie une notification à l'acteur qui à crée le document.Superviseurs : Envoie une notification aux acteurs définis pour le rôle de Superviseur.Utilisateurs du champ : Permet de définir un champ existant dans un formulaire et contenant un ou plusieurs destinataires pour une notification.Acteurs du rôle : Permet de sélectionner un rôle existant en modélisation pour informer les acteurs définis pour ce rôle.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-daf14b8f23796a420e8bf19792df1a45eb165925%2Fprocess-config-modelisation-creer-une-procedure-04.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Description** ![](https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-240154be4130784ecbe33031a4daa07c19a12ebc%2Fprocess-config-modelisation-creer-un-projet-09.png?alt=media)

Description : Saisissez une description de la fonctionnalité de la tâche.

Étendue : Permet de pointer sur un fichier du texte de description.

Aide : Permet de saisir un texte d'aide pour la tâche.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-c109d10cbae3fc6391888ebaa3a6459c826774e3%2Fprocess-config-designer-html-fonctions-avancees-53.webp?alt=media" alt=""><figcaption></figcaption></figure>

Lorsque l'on lie une opération à une tâche, Workey colore automatiquement le lien en vert foncé, couleur significative de des tâche actives.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-bf5b0f3ee678b42326a006bd52f3f3386f58902b%2Fprocess-config-designer-html-fonctions-avancees-54.png?alt=media" alt=""><figcaption></figcaption></figure>

### La disparition d'un événement

Dans certaines situations pratiques, l'événement peut ne plus avoir de sens ou ne plus présenter d'intérêt dés qu'une opération particulière a été effectuée.

Par exemple, dans le cas de l'événement lié à la fin d'un contrat CDD, l'opération "changer le contrat en CDI" doit entraîner la suppression de l'événement.

La modélisation d'une fin de tâche s'effectue dans les propriétés du lien venant de son opération. **Type** : Spécifie le type de lien géré sur l'opération courante

**Lancer** : Détermine la création d'une tâche

**Stopper** : Détermine l'arrêt d'une tâche

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-a52eb8755544ffa59ec3e3405f31882dbb84b2c8%2Fprocess-config-designer-html-fonctions-avancees-55.png?alt=media" alt=""><figcaption></figcaption></figure>

Lorsque l'option **Stopper** est activée, Workey colore automatiquement le lien en rouge foncé, couleur significative des tâches inactives.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-90d08ed6a1d0b6f7170c90d3b6ae7e0f924cd2a4%2Fprocess-config-designer-html-fonctions-avancees-56.png?alt=media" alt=""><figcaption></figcaption></figure>

### Scénario de prise en compte d'une tâche dans un processus

Pour une exécution particulière d'un processus comportant la modélisation d'une tâche programmée, le scénario-type est le suivant.

```mermaid
flowchart TD
    A["1. Opération déclenchante réalisée<br/>Tâche créée et activée (date de survenance déterminée)"] --> B["2. Notifications d'avertissement<br/>envoyées avant la survenance"]
    B --> C{"3. Ré-évaluation à chaque opération<br/>du processus"}
    C -->|Condition non remplie| D["Tâche désactivée"]
    D --> C
    C -->|Opération de suppression réalisée| E["4. Tâche supprimée"]
    C -->|Date de survenance atteinte,<br/>tâche encore active| F["5. Notification de survenance envoyée"]
    F --> G["6. Notifications après survenance<br/>selon l'échéancier"]
    G --> H["7. Fin de vie du document<br/>Tâche supprimée si elle existe encore"]
```

1. L'opération déclenchant la tâche est effectuée: la tâche est créée, avec sa date de survenance déterminée. Si les données le permettent, elle est déclaré activée.
2. Selon l'échéancier prévu pour la période précédant sa survenance, des notifications d'avertissement sont envoyées aux intervenants prévus.
3. A chaque opération survenant dans la suite du processus, la condition d'existence de la tâche est re-calculée: la tâche peut donc être désactivée ou ré-activée plusieurs fois dans le parcours de vie du processus.
4. Si une opération prévoyant la suppression de la tâche est réalisée, la tâche est supprimée.
5. A la date de survenance prévue, si la tâche est encore active, des notifications sur la survenance du message sont envoyées aux intervenants prévus.
6. Selon l'échéancier prévu pour la période après sa survenance, des notifications de survenance de la tâche sont envoyées aux intervenants prévus.
7. A la fin du parcours de vie du document, la tâche est supprimée, si elle existe encore.

Événements prédéfinis

Workey Designer propose aussi une série de classes d'événements prédéfinies que l'on peut appeler depuis une procédure.

A partir de la version 4.0 de Workey, le moteur gère la gestion des évènements. Le principe de fonctionnement est le suivant :

1. On crée un classe d'événements correspondant à l'événement que l'on souhaite intercepter (les interfaces sont dans le package `com.clog.workey.events`). Ces classes ressemblent beaucoup au connecteurs
2. On déclare les événements dans le fichier `properties-service.xml` (voir exemple ci-dessous)
3. Les classes ainsi déclarées seront exécutées à chaque fois que l'événément se produit dans le moteur. A charge au développeur de la classe de déterminer si celle-ci doit s'exécuter (en fonction du processus ou document, par exemple)

Exemple de configuration dans `properties-service.xml` sous Jboss 4 ou `workey.properties` sous Jboss 6 ou catalina.properties sous Tomcat 7 :

```
#; événement lancé après l'ouverture d'un document
#; implemente la classe com.clog.workey.events.IPostOpenDocumentEvent
com.clog.workey.events.postOpenDocument=com.client.PostOpenDocument
#; événement lancé après la soumission d'un document, plusieurs classes peuvent être appelées (séquentiellement)
com.clog.workey.events.postSubmitDocument=com.client.PostSubmitDocument,com.client.AnotherPostSubmitDocument
```

### Evénements disponibles

**DeployProcess**

Classes à implémenter:

* Pre: `com.clog.workey.events.IPreDeployProcess`
* Post: `com.clog.workey.events.IPostDeployProcess`

Méthodes à implémenter :

* PreDeployProcess(String) : Document XML à deployer.
* PostDeployProcess(List) : List des processus déployés.

**OpenDocument**

Classes à implémenter:

* `com.clog.workey.events.IPreOpenDocument`
* `com.clog.workey.events.IPostOpenDocument`

*pas encore implémenté.*

**OpenView**

Classes à implémenter:

* Pre: `com.clog.workey.events.IPreOpenView`
* Post: `com.clog.workey.events.IPostOpenView`

*pas encore implémenté.*

**SubmitDocument**

Classes à implémenter:

* Pre: `com.clog.workey.events.IPreSubmitDocument`
* Post: `com.clog.workey.events.IPostSubmitDocument`

Méthodes à implémenter :

* PreSubmitDocument(CoreDocument, UserAuth)
* PostSubmitDocument(CoreDocument, UserAuth)

**SaveDocument**

Classes à implémenter:

* Pre: `com.clog.workey.events.IPreSaveDocument`
* Post: `com.clog.workey.events.IPostSaveDocument`

*pas encore implémenté.*

**Attach**

Classes à implémenter :

* Pre: `com.clog.workey.events.IPreAttach`
* Post: `com.clog.workey.events.IPostAttach`

Méthodes à implémenter :

* PreSubmitAttach(Actor, Attachment)
* PostSubmitAttach(Actor, Attachment, java.io.File attachedFile)

**Notification**

Classes à implémenter:

* Pre: `com.clog.workey.events.IPreNotification`

Méthodes à implémenter :

* PreNotification(javax.mail.Message, Notification)

## Déploiement et Automatisation d'un Processus

### Vérification des règles de processus

Lorsque la génération de l'application est demandée, Workey commence par vérifier les éléments suivants et s'arrête en renvoyant [une erreur](http://jawa/wiki/index.php/Manuel_Workey_6.0_-_Session_de_travail_avec_Workey_Designer#Messages) s'ils ne sont pas respectés. Si vous obtenez une ou plusieurs erreurs résultant de cette vérification, consultez [la référence](http://jawa/wiki/index.php/Manuel_Workey_4.0_-_Annexe_:_messages_d%E2%80%99erreur_a_la_generation_des_regles) des messages retournés par Workey, pour vous aider à y remédier.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-9d83c93c391b1edc7239c4c2c061951cc6dbff17%2Fprocess-config-modelisation-verification-de-coherence-02.webp?alt=media" alt=""><figcaption></figcaption></figure>

#### Vérification du cycle de vie

* Tous les états des documents sont atteignables
* Il n'existe pas d'opération isolée

#### Vérification des graphes

* Tout Procédure doit être rattaché à un Processus même si le graphe de ce dernier ne contient qu'un seul élément qui est la procédure.

#### Vérification des champs

Règle : le champ doit avoir un type SQL spécifié.

Règle : pour un champ de type booléen, un domaine de type "liste" doit être associé, et doit avoir exactement 2 valeurs.

Règle : pour un domaine de type "sql", une data-source doit être spécifiée.

#### Vérification des domaines

* un domaine doit avoir un type spécifié
* un domaine de type "Acteurs" doit être associé à un ou plusieurs "Rôle"s.

#### Vérification des vues

* une vue doit avoir au moins une colonne
* pour les collections initiales du type : types de documents, états, type de processus, une expression de filtre doit être présente,
* les vues déclarées comme "sub-view" (sous vues) doivent avoir au moins une colonne qui se réfère à une vue principale

### vérification des sections

* une section ne peut être vide : elle doit comporter un ou plusieurs champs, tables ou vues embarquées

### Vérification des tables

* une table ne peut être vide: elle doit comporter au moins un champ

### Vérification des états de document

* un état "\<Détruit>" doit être un état terminal : aucun lien vers une opération n'est autorisé depuis cet état

### Vérification des opérations

* dans la liste des opérations pour un rôle donné, le nom d'une opération est unique (pas d'opérations de même nom pour un rôle donné)
* dans un graphe de contraintes, un lien entre une opération et une opération d'une autre procédure doit concerner des opérations du même processus.
* pour une opération affectée à un agent :

1. les liens de notification aux acteurs suivants doivent avoir l'option "automatique"
2. si l'opération n'est pas déclarée automatique, un seul état en sortie est autorisé
3. les liens de notification autres qu'aux acteurs suivants ne sont pas autorisés
4. la constitution d'un groupe de travail ne doit pas comporter un nombre minimum ou maximum d'acteurs
5. la dérivation de documents doit être automatique (non optionnelle)

### Vérification des rôles

* Un "designer name" (nom interne) de rôle ne peut être un des noms réservés: Superviseur, WorkflowManager, ProcessManager, DataManager
* Signaler (erreur non fatale) si un rôle joué à la demande ne peut pas créer de document

### Vérification des graphes de règles

* Un graphe de règles doit contenir au moins un objet "Message"

### Vérification des relations entre unités

* Un graphe de liens sémantiques entre les unités ne doit comporter un cycle, pour chaque sémantique exprimée

Déploiement du processus

Le déploiement d'un processus consiste à automatiser le processus modélisé c'est à dire obtenir une application de workflow conforme au processus modélisé.

Cela nécessite en pré-requis la licence Workey Engine.

Lorsque la génération de l'application est demandée, Workey commence par vérifier les éléments suivants et s'arrête en renvoyant [une erreur](http://jawa/wiki/index.php/Manuel_Workey_6.0_-_Session_de_travail_avec_Workey_Designer#Messages) s'ils ne sont pas respectés. Si vous obtenez une ou plusieurs erreurs résultant de cette vérification, consultez [la référence](http://jawa/wiki/index.php/Manuel_Workey_4.0_-_Annexe_:_messages_d%E2%80%99erreur_a_la_generation_des_regles) des messages retournés par Workey, pour vous aider à y remédier.

Nettoyer le projet

De temps en temps, il peut se produire des incohérences dans le projet. La fonction de nettoyage du projet permet de détecter et corriger ces incohérences qui empêchent le déploiement du processus sur le serveur web.Une boîte de dialogue s'ouvrira alors indiquant les corrections effectuées.

## Tutoriel — Fil de Discussion Intégré aux Formulaires

Workey propose un système de fil de discussion que vous pouvez intégrer à votre document pour permettre aux différents intervenants d'écrire des commentaires et y répondre suivant le principe d'un chat.

#### Mise en place

Vous avez besoin de deux champs **multi-lignes** pour réaliser votre fil de discussion. Ils peuvent être placés dans la section que vous désirez ou une section dédiée.

* Un champ multi-lignes servant à l'utilisateur pour écrire son commentaire dont il faut activer l'option "Historisé". L'utilisateur peut écrire plusieurs lignes mais un seul commentaire par opération.
* Un second champ multi-lignes utilisé pour retenir les interventions au fur et à mesure. Dans les paramètres (2nd onglet) il doit être flaggé à "Non éditable (HTML, JS…)" et doit être affublé d'une expression calculée à chaque ouverture qui mentionne htmlHistoryOf("\<nom du champ où on écrit les commentaires>")

{% hint style="warning" %}
Bien penser aux guillemets encadrant le nom du champ dans cette expression STalk, d'habitude on n'en met pas !
{% endhint %}

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-68931fa95033181408b82557f3b93d694658046d%2Fprocess-config-tutoriels-fil-de-discussion-chat-integre-aux-formulaires-01.png?alt=media" alt=""><figcaption></figcaption></figure>

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-8661f8264ae0384a33cc511f94fc0ee434dc6e0b%2Fprocess-config-tutoriels-fil-de-discussion-chat-integre-aux-formulaires-02.webp?alt=media" alt=""><figcaption></figcaption></figure>

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-527681483adb302ffdfd41ca98450e8fd30ed33c%2Fprocess-config-tutoriels-fil-de-discussion-chat-integre-aux-formulaires-03.webp?alt=media" alt=""><figcaption></figcaption></figure>

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-5711a09031b8608d50692b1f83788ab2f9e041aa%2Fprocess-config-tutoriels-fil-de-discussion-chat-integre-aux-formulaires-04.webp?alt=media" alt=""><figcaption></figcaption></figure>

#### A l'usage

Lorsqu'un message est inscrit dans le champ servant de réceptacle qui est automatiquement vidé à chaque début d'opération, son contenu sera traité par le moteur à la soumission pour enrichir le fil de discussion. Chaque message sera précédé du nom de l'utilisateur l'ayant renseigné et de la date de rédaction.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-3cc35b888bdb463b3fc6730142f111d001b6a668%2Fprocess-config-tutoriels-fil-de-discussion-chat-integre-aux-formulaires-05.webp?alt=media" alt=""><figcaption></figcaption></figure>

## Migration d'un Fichier GTI vers un Fichier WKY

Ce chapitre a pour objet de vous permettre de migrer vos anciens projets créés sous GraphTalk vers un format de données compatible avec le récent Workey Designer HTML.

{% hint style="warning" %}
La migration de projet gti en wky n'est pas un processus vous garantissant le fonctionnement à 100% de votre projet mais il vous permet de ne pas avoir à modéliser de nouveau l'intégralité de vos graphes dans Workey Designer HTML. Il est indispensable de procéder à une vérification de votre projet afin de détecter d'éventuelles pertes d'informations.
{% endhint %}

{% stepper %}
{% step %}
**Vérifier la version du projet**

Après avoir lancé l'atelier GraphTalk et y avoir ouvert votre projet, il faut tout d'abord s'assurer que votre fichier gti est bien dans la version **50006**.

Pour cela, allez dans le menu "Actions -> Divers". Une boîte de dialogue s'ouvre. Cliquez sur "**Vérifier la version de l'outil"**.

{% hint style="warning" %}
🚧 Capture manquante — Boîte de dialogue "Vérifier la version de l'outil" (menu Actions -> Divers)
{% endhint %}

Si la version indiquée n'est pas la **50006**, il est indispensable de migrer votre gti vers cette version avant d'aller plus loin.
{% endstep %}

{% step %}
**Migrer un gti**

Si votre gti n'est pas en version 50006, depuis la précédente boîte de dialogue (menu "Actions -> Divers"), cliquez sur "**Migrer le projet vers la nouvelle version de l'outil**". Votre gti est maintenant dans la version **50006**.
{% endstep %}

{% step %}
**Exporter le projet en xml**

Il faut maintenant exporter votre projet. Depuis la précédente boîte de dialogue ("Actions -> Divers"), cliquez sur la première entrée "**Exportation en xml**":

{% hint style="warning" %}
🚧 Capture manquante — Entrée "Exportation en xml" de la boîte de dialogue Actions -> Divers
{% endhint %}

Et enregistrez le fichier généré sur votre poste.
{% endstep %}

{% step %}
**Importer le projet dans Workey Designer HTML**

Ouvrir Workey Designer HTML dans votre navigateur internet et cliquez sur l'icône de menu puis accédez au menu "Projet -> Migrer":

![](https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-c3fe24efddf2f4305fbe6b16af589ba5e703aa19%2Fprocess-config-designer-html-migration-dun-fichier-gti-vers-un-fichier-wky-2-01.png?alt=media)

Sélectionnez le fichier xml précédemment migré et exporté de GraphTalk dans la boîte de dialogue de sélection de fichiers qui s'ouvre.
{% endstep %}

{% step %}
**Confirmer la migration du projet**

Une fois le fichier à migrer choisi, validez que vous souhaitez le migrer vers la version courante de Workey Designer HTML:

![](https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-3ecb6e6740644e0f227def3f05081ada94a3d8a7%2Fprocess-config-designer-html-migration-dun-fichier-gti-vers-un-fichier-wky-2-02.png?alt=media)
{% endstep %}

{% step %}
**Vérifier le projet**

Le projet migré est maintenant ouvert dans Workey Designer HTML. Il est nécessaire de vérifier celui-ci. En effet, certaines fonctionnalités et propriétés n'existaient pas dans les projets sous l'atelier GraphTalk. La vérification se fait via le menu "Projet -> Vérifier":

![](https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-b9e3f99e28668f492f931768224698bd9d661114%2Fprocess-config-designer-html-migration-dun-fichier-gti-vers-un-fichier-wky-2-03.png?alt=media)

Le compte rendu de vérification présente les erreurs détectées en bas de l'écran principal.
{% endstep %}

{% step %}
**Enregistrer le projet**

N'oubliez pas d'enregistrer le projet après qu'il ait été migré.
{% endstep %}
{% endstepper %}

{% hint style="warning" %}
Parmi les vérifications et actions à apporter après la vérification du projet, quelques unes sont connues: – Les liens de dérivation de Post Condition ET ne sont pas migrés. Il est nécessaire de les refaire unitairement en prenant garde de ne pas oublier les options de dérivations, les règles et les notifications. – Chaque document doit avoir un formulaire par défaut en écriture, lecture et archivage défini.
{% endhint %}

## Migration d'un Projet Flash vers HTML

Il y a deux manières différentes de migrer un projet du modélisateur Flash vers le modélisateur HTML.

### Importer un projet depuis le serveur Workey

Si vos projets sont enregistrés sur votre serveur Workey, l'import est très simple. Il vous suffit d'ouvrir le menu et d'accéder à "**Projet** > **Importer** > **Une sauvegarde Workey (Flash)**".

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-d6d26f0a3acbd125e49c4b418b56268c5ae932d2%2Fprocess-config-designer-html-migration-dun-projet-flash-vers-html-01.png?alt=media" alt=""><figcaption></figcaption></figure>

Une fenêtre s'ouvre et vous propose les projets en Flash que vous avez enregistrés sur le serveur Workey.

{% hint style="success" %}
**Conseil** Si vous avez les droits d'accès de **Workflow Manage**r, vous pouvez voir tous les projets enregistrés en cliquant sur "Voir les projets de tout le monde". Vous pourrez ainsi migrer les projets de vos utilisateurs.
{% endhint %}

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-32c1ef4177385c1177c62404ab6ff04785ddd999%2Fprocess-config-designer-html-migration-dun-projet-flash-vers-html-02.webp?alt=media" alt=""><figcaption></figcaption></figure>

Utilisez les cases à cocher de la première colonne afin de sélectionner un des projets à migrer puis cliquez sur "Ouvrir".

### Importer un wky enregistré en local

Il vous est également possible d'importer un projet Flash enregistré sur votre poste. Pour cela, accédez au menu "**Projet**> **Importer**> **Un projet Workey**"

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-bc306a2da6399de196a79bfe08a47a2dff26761e%2Fprocess-config-designer-html-migration-dun-projet-flash-vers-html-03.webp?alt=media" alt=""><figcaption></figcaption></figure>

Une boîte de dialogue de sélection de fichiers s'ouvre. Sélectionnez un projet avec l'extension "wky" en local et faites "OK".

### Ouverture du projet migré

Après avoir effectué l'ouverture d'un projet wky situé sur le serveur ou en local sur votre poste, une boîte de dialogue vous demandera de confirmer la migration du projet sélectionné:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-4e7e78a7a35885e85ffd7c4d82444f9a51c08cf3%2Fprocess-config-designer-html-migration-dun-projet-flash-vers-html-04.png?alt=media" alt=""><figcaption></figcaption></figure>

Après confirmation, votre projet s'ouvre:

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-5a1b1ed723ba59ff0f22187a854160636fb2eb98%2Fprocess-config-designer-html-migration-dun-projet-flash-vers-html-05.png?alt=media" alt=""><figcaption></figcaption></figure>

{% hint style="warning" %}
N'oubliez pas d'enregistrer votre projet avant de poursuivre vos imports.
{% endhint %}


---

# 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/designer-html.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.
