> 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/langages-process.md).

# Langages Process

Efalia Process propose deux langages pour personnaliser le comportement des processus modélisés dans le Designer.

## STalk

STalk est un langage permettant l'écriture d'expressions intervenant dans plusieurs fonctionnalités d'Efalia Process : règles de comportement des opérations automatiques, règles de calcul des champs, sujet des documents, calcul des colonnes des vues créées par les utilisateurs, etc.

L'objectif de STalk est de fournir un langage suffisamment simple et bien intégré à Efalia Process, évitant l'écriture de code Java pour spécifier les expressions souvent très simples intervenant dans les règles de gestion des processus. STalk possède beaucoup de caractéristiques d'un langage de programmation complet, mais ne peut être considéré comme un langage « universel », car il ne permet pas de déclarer des structures répétitives (« tant que », par exemple).

Pour la référence complète du langage (types, objets, fonctions), voir [Référence STalk](https://documentation.efalia.com/produit/efalia-process/developpeurs/reference-stalk.md).

## WKYJS

WKYJS est la bibliothèque JavaScript côté client d'Efalia Process, disponible dans les composants Script JS des formulaires pour contrôler dynamiquement l'interface utilisateur (masquage de champs, rafraîchissement, contrôle de saisie…).

Pour la référence complète de la bibliothèque, voir [Référence WKYJS](https://documentation.efalia.com/produit/efalia-process/developpeurs/reference-wkyjs.md).

## Règles du Dictionnaire

### La construction d'une règle

Une règle est la déclaration d'une condition devant être vérifiée par un document pour progresser vers un état particulier d'un processus.

Dans la modélisation des opérations, il est possible d'ajouter des formules de calcul pour tester un ou plusieurs champs dans un formulaire. Ces formules de calcul sont réalisées par la modélisation de règles sous forme graphique.

Dans notre exemple, nous désirons aiguiller le document incident de façon automatique vers l'état **escaladé**ou vers l'état **clôturé**lorsque le Support niveau 1 exécute l'opération **traiter**.

Pour se faire, insérons dans le formulaire **Support**un champ "statut" qui permettra à l'utilisateur de choisir une valeur "Incident clos" ou "Incident actif". En fonction de la valeur choisie par le représentant du support pour ce champ, le document pourra atteindre l'état clôturé ou l'état escaladé. Les objets Bouton radio, Liste, Liste à cocher ou Liste déroulante permettent d'implémenter facilement un tel champ.

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

Cliquez sur le symbole (+) à) coté de l'item "Règles" dans le panneau des projets pour créer une nouvelle règle.

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

Choisissez l'objet Expression sur l'onglet des Composants et ajoutez-le à votre Graphe, puis éditez les propriétés de l'objet.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-905bed0a333030f1fba575e1483d24e949e5f9a9%2Fprocess-config-designer-html-regles-du-dictionnaire-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-85169b105d3b8ba2d79aa07ab895d1c78249cc7e%2Fprocess-config-designer-html-regles-du-dictionnaire-04.webp?alt=media" alt=""><figcaption></figcaption></figure>

Dans la section Codification des propriétés, cliquez sur l'icône d'édition de l'expression.

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

Sélectionner le champ "Statut".

Une formule peut porter sur des champs, des documents, des états, des rôles, des opérations, des processus. En fonction de la portée, workey vous liste les composants éligibles.

Construisez alors votre formule à l'aide des composants éligibles et des fonctions stalk disponible sur le panneau de droite.

**Exemple**

Cliquer sur le champ **Statut**dans la colonne. Modifier ensuite l'expression pour spécifier une valeur égale à la chaîne "Actif".

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

Choisissez l'objet Succès dans les composants disponibles pour ajouter une action positive, puis éditez les propriétés de l'objet si vous désirez le personnaliser.

Liez l'expression vers l'action grâce à un cliquer-déplacer de la souris, puis éditez les propriétés du lien si vous souhaitez les personnaliser.

Dans la procédure Déclaration et qualification d'un incident, cliquez sur le lien liant l'opération traiter à l'état escaladé pour en éditer les 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-a2218a68f4f9d04a10b9033fe3720621e6f85b67%2Fprocess-config-designer-html-regles-du-dictionnaire-07.webp?alt=media" alt=""><figcaption></figcaption></figure>

Dans la section Options, cliquez sur l'icône de sélection d'une condition.

Choisissez la règle **Statut == "Actif"** que vous venez de créer.

Maintenant, créez une deuxième règle de la même façon contenant l'expression **Statut == "Clos"** et ajoutez-la sur le lien liant l'opération traiter à l'état clôturé.

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

**Composants disponibles** :

* **Expression** : Permet de saisir une expression Stalk.
* **ET** : Défini une condition de type ET liant deux expressions ou plus qui devront toutes retourner vrai pour que la règle soit vérifiée.
* **OU** : Défini une condition de type OU inclusif liant deux expressions ou plus. Si une des expression retourne vrai, alors la règle sera vérifiée.
* **Succès** : Défini un message de succès du contrôle de la règle (retour vrai) qui peut être personnalisé.
* **Échec** : Défini un message d'échec du contrôle de la règle (retour faux) qui peut être personnalisé.

Une règle est positionnée sur le lien aboutissant à cet état et comporte :

* un nom, par exemple : « risque acceptable »
* une expression logique, décrite dans un graphe propre à cette règle

L'expression logique de la règle doit stipuler un résultat vrai ou faux. Si le résultat est vrai, alors la règle est vérifiée, et l'état concerné est atteignable dans le processus.

***

#### Exemple

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

L'interprétation de cette expression logique est simple : Si le MontantEmprunt est inférieur à 100000, ou s'il est inférieur à 300000 mais que le RevenuClient est plus élevé que 2000, alors la règle est vérifiée.

Sinon, une message d'erreur sera émis. Dans certains cas (opération automatique), ce message ne sera pas visible par l'utilisateur final, ce qui ne change rien au niveau de l'expression de la règle elle-même.

***

### Modélisation d'une règle

La modélisation d'une règle s'effectue soit :

* **depuis le panneau de gauche** en double cliquant sur "Règles"

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

* **depuis les propriétés d'un lien sortant** d'une opération, reportez vous à l'item "option".

Icônes à votre disposition :

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

1. Visualiser la règle
2. Créer une nouvelle règle
3. Détacher la règle sélectionnée du lien
4. Sélectionner une règle pour l'ajouter au lien

**Création d'une expression**

Une graphe de règle vide est maintenant à votre disposition.

Depuis l'onglet propriété, nommez votre règle afin de la retrouver plus facilement dans votre dictionnaire.

Une règle est composée d'expression et d'opérateurs.

Placer une expression dans le graphe par glisser/déposer

Depuis la fenêtre de propriété de l'expression :

* préciser un libellé compréhensible
* préciser depuis la section "codification" le contenu de l'expression en cliquant sur l'icône :

Construisez ensuite votre expression à l'aide des différents composants mis à votre disposition en combinant les données du processus et le langage de formule Stalk.

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

**Combiner des expressions à l'aide d'opérateurs logiques**

Une règle peut comporter différentes expressions reliées entre elle par des opérateurs logiques.

1. créer différentes expressions que vous placer dans la page centrale
2. glisser déposer l'opérateur logique de votre choix "ET" "OU".
3. relier l'expression ou les expressions à l'opérateur
4. relier éventuellement un opérateur à un autre opérateur

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

**Saisie d'un message dans une expression**

La saisie d'un message, permet :

* dans le cas d'une opération avec contrainte de règles : d'afficher ce dernier à l'utilisateur si la règle est vérifiée et d'interdire l'état sur lequel la règle est positionnée.
* dans le cas d'une opération avec état automatique : sans effet.
* dans tous les cas, d'afficher la formule, sur le lien

La saisie d'un message est obligatoire pour valider une règle. Au niveau Web il sera affiché quand l'expression sera vérifiée.

Si la formule est utilisée dans le cadre d'une opération avec contrainte de règle, et que la règle pointe sur un **succès**alors :

\==> le message est affiché à l'utilisateur si la formule n'est pas vérifiée

Si la formule est utilisée dans le cadre d'une opération avec contrainte de règle, et que la règle pointe sur un **echec**alors :

\==> le message est affiché à l'utilisateur si la règle est vérifiée

Si la formule est utilisée dans le cadre d'une opération avec changement d'état automatique, aucun message ne s'affiche :

* si la règle est vérifiée alors, le changement d'état est automatique
* si la règle n'est pas vérifier, évaluation de la prochaine règle
* si aucune règle n'est pas appliquée, alors le message de la dernière règle évaluée sera affichée

***

### Ordre de priorité des règles

**Principe**

Ce mécanisme permet de préciser l'ordre d'évaluation des formules de règle dans le cadre d'opération avec états automatiques.

Depuis les propriétés du lien qui porte la règle, préciser dans la section "Options" la priorité de la règle par rapport aux autres branches.

La priorité est affichée ensuite sur le lien.

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

### Vérification des règles

Pour pouvoir déployer votre processus sur le serveur de workflow, il est indispensable que vos règles soient syntaxiquement correctes par rapport au langage de formule Stalk.

Pour vérifier vos règles, et donc la cohérence de projet, depuis la barre des menus du projet cliquer sur l'icône :

En cas d'erreur, une fenêtre d'erreur est présentée avec la liste des erreurs.

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

Double cliquer ensuite sur chaque ligne pour obtenir le détail de l'erreur et corriger en conséquence.

## Base de Connaissances JavaScript

### Rafraîchir un formulaire à la sortie d'un champ

Permet de simuler le clique sur le bouton "Rafraîchir" lors de la sortie de l'édition d'un champ.

**Code JS**

```
  <a name="Refresh1"></a>
  <script type="text/javascript">
  $('Field_NOMDUCHAMP').onblur = function (){
      document.Form0.action=document.Form0.action+'#Refresh1';
      document.getElementById('buttonRefresh').click();
  }
  </script>
```

```js
  <a name="Refresh1"></a>
  <script type="text/javascript">
  $('Field_NOMDUCHAMP').onblur = function (){
      document.Form0.action=document.Form0.action+'#Refresh1';
      document.getElementById('buttonRefresh').click();
  }
  </script>
```

Remplacez **NOMDUCHAMP** par le nom interne du champ concerné.

### Masquer une section

Permet de masquer définitivement une section en javascipt.**Code JS** En V5

```
<script type="text/javascript">$('Section_XXXXX').parentNode.parentNode.style.display = "none"</script>
```

En V6

```
<script type="text/javascript">
WKYJS.hideSection('XXXXX');
</script>
```

### Contrôle de la visibilité des sections par les valeurs renseignées pour un champ

En cliquant sur un bouton radio représentant une valeur d'un champ, rendre possible de montrer ou de masquer une ou plusieurs sections d'un formulaire.

**Code JS**

En V6

Une nouvelle librairie a été développé pour permettre de faciliter le masquage des champs et des sections.

Merci de vous référencer à **WKYJS**.

En V5

```
<script type="text/javascript">
 var sectionElements = [];
 function make_sectionswitch(i, show) {
 return function () {
 for (var j = 0; j > sectionElements.length; j++) {
 if (sectionElements[j] != null) sectionElements[j].style.display = getDisplay((i == j), show);
 }
 }
 }
 function getDisplay(condition, show) {
 if (condition) return show ? "" : "none";
 else return show ? "none" : "";
 }
 function setSectionsDisplay(fieldName, sectionNames, fieldValues, show) {
 var radios = document.getElementById("Field_" + fieldName).getElementsByTagName("input");
 var index = sectionElements.length;
 for (i = 0; i > radios.length; i++) {
 var v = radios[i].value;
 for (j = 0; j > fieldValues.length; j++) {
 if (fieldValues[j] == v) {
 sectionElements[index] = document.getElementById("Section_" + sectionNames[j]);
 if (sectionElements[index] != null) {
 radios[i].onclick = make_sectionswitch([index], show);
 sectionElements[index].style.display = getDisplay(radios[i].checked, show);
 }
 break;
 }
 }
 index++;
 }
 }
</script>
```

**Exemple**

```
setSectionsDisplay ("ChoixDuTypeDeContrat", ["Assurance Vie", "Assurance Habitation"], ["1", "2"], true);
```

Pour un click sur le bouton 1 du champ ChoixDuTypeDeContrat, la section "Assurance Vie" seule est montrée. Pour un click sur le bouton 2 du champ ChoixDuTypeDeContrat, la section "Assurance Habitation" seule est montrée.

\[Fichier:hideSectionsByRadio.zip]\(

### Masquer l'ajout de ligne d'un tableau dynamique

En ajoutant le code dans le formulaire, il n'est plus possible d'ajouter ou supprimer des lignes.

Remplacer dans le code le "tab\_dyn" par le nom de votre table dynamique

**Code CSS**

```
<style type="text/css">
 table.dynamicTable td.actionColumn { display: none; }
 #FormFields tfoot { display: none; }
</style>
```

OU BIEN

```
<style type="text/css">
#Table_tab_dyn tfoot, #Table_tab_dyn td.actionColumn { display: none; }
</style>
```

### Colorer le tour des champs qui ont le focus

Il est possible de colorer la bordure des champs qui ont le focus dans les formulaires en manipulant la feuille de style principale de workey. Pour se faire, il vous faut modifier le fichier **workey-style.css**.

Voici la déclaration courante que nous avons choisi pour nos champs de texte du support, pour vous donner un ordre d'idée sur le type de modification à effectuer.

```
textarea:focus, select:focus, input:focus {
border-color: rgba(82, 168, 236, 0.8);
box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1) inset, 0 0 8px rgba(82, 168, 236, 0.6);
outline: 0 none;
}
```

### Masquer/Afficher des champs en fonction du changement de valeur d'autre champs

Ce script permet d'afficher des champs en fonction du changement de valeur d'un autre champ. Il est possible d'ajouter des conditions pour obtenir l'affichage en fonction d'une valeur spécifique.

**showLists.js**

```
/**
 *  Affiche un champ lorsque la valeur d'un autre champ change
 *  Copyleft C-Log International - 2012
 */

document.observe('dom:loaded', function() 	// Attend que les objets de la page soient chargés pour exécuter le script
{
	function hideSecunda() { $('Field_Secunda').hide(); }	// Cache le champ
	function hideTertia() { $('Field_Tertia').hide(); }	// Cache le champ
	function hideQuarta() { $('Field_Quarta').hide(); }	// Cache le champ
	function showSecunda() { $('Field_Secunda').show(); }	// Affiche le champ
	function showTertia() { $('Field_Tertia').show(); }	// Affiche le champ
	function showQuarta() { $('Field_Quarta').show(); }	// Affiche le champ

	hideQuarta(); hideTertia(); hideSecunda();	// Cache les champs
	var selectPrima=document.getElementById("Field_Prima"), selectSecunda=document.getElementById("Field_Secunda"),
	selectTertia=document.getElementById("Field_Tertia"), selectQuarta=document.getElementById("Field_Quarta");
	selectPrima.onchange=function showSecunda() { $('Field_Secunda').show(); }	// Affiche 2 quand 1 change
	selectSecunda.onchange=function showTertia() { $('Field_Tertia').show(); }	// Affiche 3 quand 2 change
	selectTertia.onchange=function showQuarta() { $('Field_Quarta').show(); }	// Affiche 4 quand 3 change
});
```

**Usage**

Voici un fichier .gti (version 4.2) illustrant le fonctionnement du script.

Fichier:showlists.zip

### Définir la taille d'une colonne dans un tableau dynamique

Il est possible de définir une taille fixe pour une colonne d'un tableau dynamique en ajoutant un champ texte non éditable avec le code suivant.

**Code JS**

```
<style type="text/css">
#Field_Activite { display: block; min-width: 600px; }
</style>
```

Field\_Activite : Activite est le nom du champ de la colonne.

### Envoyer un document en cliquant sur un état

En ajoutant ce code dans un formulaire, il est possible d'envoyer directement un document en cliquant sur l'état.

Modifier le fichier JS "clog-workey.war\scripts\*\*hideableblock.js\*\*" et ajouter la ligne suivante :

```
 openTableLoginPassword (idxClicked);
 document.getElementById("buttonSubmit").click(); // *** Ligne à ajouter ***
 return true;
```

### Présélectionner le premier état et cacher la sélection des états suivants

Ajouter le code suivant dans un champ JS du formulaire à simplifier :

```
<script type="text/javascript"> document.observe('dom:loaded', function(){ $('NextStateSelection').hide();
document.getElementsByName('nextStateRadio')[0].checked = true;});</script>
```

### Définir la taille d'une colonne dans un tableau dynamique

Pour ajouter dans un formulaire un bouton

Ajouter un champ de type texte non-éditable avec comme valeur par défaut :

* Avant la 3.5 :

```
<a name="Bouton1"></a>
<a href="javascript:document.Form0.action=document.Form0.action+'#Bouton1';submitLink(document.Form0,'$LinkSubmit$1');">
 <img style="border:0px;" src="/images/refresh.gif"/>
</a>
```

* A partir de la 3.5 :

```
<a name="Bouton1"></a>
<a href="javascript:document.Form0.action=document.Form0.action+'#Bouton1';document.getElementById('buttonRefresh').click();">
 <img style="border:0px;" src="/images/refresh.gif"/>
</a>
```

### Rendre un champ obligatoire par JS (dans un tableau dynamique) :

Voilà le code JS à ajouter pour vérifier que le champ Composante\_5 est toujours rempli :

```
<script type="text/javascript">
(function () {
 var submit = document.getElementByName("$LinkSubmit$1");
 var old_onclick = submit.onclick;
 submit.onclick = function () {
 var v = document.getElementById("Field_Composante_5").value;
 if (v === null || v === "") {
 alert("Le champ 'Composante' doit être rempli.");
 return;
 }
 old_onclick();
 };
})();
</script>
```

### Auto-complétion à partir d'un Ldap :

Deux objectifs :

* Rendre un champ en auto-complétion à partir d'un Ldap
* Renseigner d'autres champs à partir de ce champ.

Voici un GTI illustratif et un WAR à placer sous /deploy.

Fichier:TestLdap.zip

### Sélection du premier état par défaut

Sélection d'un état par défaut, Le premier.Code expression par défaut à mettre dans un champ texte non éditable.

```
<script type="text/javascript">
 (function(){var radio = document.getElementsByName("nextStateRadio")[0]; radio.checked=true; radioStateClick(radio);})();
</script>
```

Voilà le nouveau script — il s'exécute au moment du `window.onload()` lorsque tout les éléments de la page son présent.

```
<script type="text/javascript">
(function(){
	var old_onload=window.onload;window.onload=function(){
		old_onload();
		var radio=document.getElementsByName("nextStateRadio")[0];if(radio===null)return;radio.checked=true;
		radioStateClick(radio);
		}
	})();
</script>
```

### Afficher des infobulles sur un ou des objets

Affichages de bulles d'aide lorsque le curseur de la souris passe sur des liens, paragraphes ou autres objets.

**infobulles.js**

Voici le code source à sauvegarder dans clog-workey.war.

```
document.observe('dom:loaded', function() {
	// Installation de l'infobulle sur le champ  Field_FormIM_datecons
	infoBulle($('Field_FormIM_datecons'),
			"<b>Quel temps fait il ?</b><br/>Il fait beau et chaud, les nuages vont vers l\'ouest."
	);
	// Installation de l'infobulle sur le champ  Field_Form_IM_datefinval
	infoBulle($('Field_Form_IM_datefinval'),
			"<b>Que dois-je renseigner dans le champ Date de fin ?</b><br/>Indiquer la date de fin de la prestation."
	);
});
function infoBulle(elt, text){
	var bulle = new Element('div', {
				id:    elt.id + '_infobulle',
				style: 'padding:3px; border: solid 1px black; background-color:#EEE; color:black; display: none; position:absolute; top:0; left:0;'
		}
	);
	bulle.innerHTML = text;
	var epos = elt.positionedOffset();
	bulle.style.top  = (epos.top  + 20) + "px";
	bulle.style.left = (epos.left + 10) + "px";
	elt.insert({'after':bulle});

	Event.observe(elt, "mouseover", function(){ bulle.style.display = '' });
	Event.observe(elt, "mouseout", function(){ bulle.style.display = 'none' });
}
```

**Appel des fonctions sur les objets**

Dans un formulaire Workey:

* Créer un champ de type chaîne de caractères en lecture seule non éditable
* Valeur par défaut du champ: `<script type="text/javascript" src="/js/infobulles.js"></script>`

### Afficher les sections de formulaires dans des onglets séparés.

Ce script permet d'afficher les sections d'un formulaire à l'horizontal dans des onglets presque indépendants.

**sections\_to\_tabs.js**

```
/* Conversion des sections de formulaire en onglets placés en haut du formulaire .
 *
 * (c) 2009 - C-Log International
 */
(function(){
    // Recherche des sections du formulaires (éléments <table> dont l'Id commence par "Section_"
    // XXX Actuellement, on recherche toutes les sections du formulaire. On pourrait choisir de
    // ne parcourir les sections directement à la racine du formulaire ou bien ne sélectionner
    // que les section commençant par "Section_TAB_" (par exemple)
    var tables   = document.getElementById("FormFields").getElementsByTagName("table");
    var sections = [];
    var firstSet = false;
    for (var i = 0; i < tables.length; i++)
    {
        if (tables[i].id && tables[i].id.match("^Section_.*$"))
        {
            var cap = tables[i].getElementsByTagName("caption")[0];
            // IE ne supporte pas textContent
            var txt = cap.innerText || cap.textContent;
            var name = txt.replace(/^\s+/m, "").replace(/\s+$/,"");
            sections[name] = tables[i];
            if (firstSet === true)
            {
                tables[i].style.display = "none";
            }
            firstSet = true;
            tables[i].className = "collapsable tabs";
        }
    }
    var formFieldBody = document.getElementById("FormFields").getElementsByTagName("tbody")[0];
    // Ajout d'une ligne dans le formulaire contenant les onglets
    var tabsRow  = document.createElement("tr");
    var tabsCell = document.createElement("td");
    tabsCell.colSpan = 2;
    tabsCell.id = "FormTabs";
    //var tabsLink = document.createElement("a");
    //tabsLink.setAttribute("name", "FormTabsLink");
    //tabsCell.appendChild(tabsLink);
    var tabsUl = document.createElement("ul");
    tabsUl.setAttribute("class", "workeyTabs");
    firstSet = false;
    var selectedTab = null;
    var hash     = window.location.hash;
	//alert("hash: [" + hash + "] / f1: [" + window.location + "]");
    for (var x in sections)
    {
    	if(typeof sections == 'function') { continue; }
        // Création d'un onglet par section
        var tabsLi = document.createElement("li");
        tabsLi.id = "TAB_" + x;
        var hashPart = "#" + sections.id;
        if (firstSet === false)
        {
            if (hash)
            {
                if (hash == hashPart)
                {
                    tabsLi.className = "tabSelected";
                    selectedTab = sections;
                    firstSet = true;
                }
            }
            else
            {
                tabsLi.className = "tabSelected";
                selectedTab = sections;
                firstSet = true;
            }
        }
        var tabsA = document.createElement("a");
        tabsA.setAttribute("href", hashPart);
//AA        tabsA.observe("click", function(ev){
        tabsA.onclick = function(){
            var form = document.getElementById('workeyForm');

            var cleanAction = form.action.replace(/#.*/, '');
            form.action = cleanAction + this.hash;
            // Action lors de la sélection d'un onglet, affichage de la section et coloration de l'onglet sélectionné
            for (var y in sections)
            {
        		if(typeof sections[y] == 'function') { continue }
                if (y == this.innerText || y == this.textContent)
                {
                    sections[y].style.display = "";
                    document.getElementById("TAB_" + y).className = "tabSelected";
                }
                else
                {
                    sections[y].style.display = "none";
                    document.getElementById("TAB_" + y).className = "";
                }
            }
            return false;
        }
//AA    );
        var link = document.createTextNode(x);
        tabsA.appendChild(link);
        tabsLi.appendChild(tabsA);
        tabsUl.appendChild(tabsLi);
    }
    tabsCell.appendChild(tabsUl);
    tabsRow.appendChild(tabsCell);
    var firstRow = formFieldBody.getElementsByTagName("tr")[0];
    formFieldBody.insertBefore(tabsRow, firstRow);
  if (selectedTab)
  {
      for (var y in sections)
      {
          if (sections[y].style) { sections[y].style.display = selectedTab == sections[y] ? "" : "none"; }
      }
  }
}());
```

**sections\_to\_tabs.css**

```
/* http://htmldog.com/articles/tabs/ */
#FormTabs {
    width: 100%;
    border-bottom: Solid 1px Black;
    padding: 0.5em 0.5em 0 1em;
}
#FormTabs ul {
	list-style: none;
	padding:    0;
	margin:     0;
}
#FormTabs li {
	display: inline;
	border: solid;
    white-space: nowrap;
	border-width: 1px 1px 0 1px;
	margin: 0 0.5em 0 0;
}
#FormTabs li a {
	padding: 0 .5em;
    text-decoration: none;
}
#FormTabs li.tabSelected {
    background-color: #DDD;
}
table.tabs caption {
    display: none;
}
```

**Appel de la fonction dans un formulaire**

Créer un champ de type text non éditable et ayant comme valeur par défaut:

```
<script type="text/javascript" src="/js/sections_to_tabs.js"></script>
<link type="text/css" rel="stylesheet" href="/js/sections_to_tabs.css"/>
```

Ce champ doit être placé en bas de formulaire afin que le script s'exécute après que les autres objets de la page soient chargés.

### Convertir les retours chariots pour un transfert RTF

Ce script permet de convertir les caractères de retour chariots venant d'une zone de texte simple en retour chariots compatibles avec un format RTF.

#### CR.js

**Champs**: Champ1 (zone de texte avec retour à la ligne automatique), Champ2 (insertion du script JavaScript), Champ3 (zone de texte avec retour à la ligne automatique).

```
function updatechamp3()
{
   var reg=new RegExp("\n", "gi");
   var source = $(Field_Champ1).value;
   $(Field_Champ3).value=source.replace(reg,"\\par");
}
```

**Exemple**: Fichier:CR.zip

### WorkeyFormCustomizer

This document shows how to customize forms generated by Workey. It is aimed at developers with Javascript and DOM skills.


---

# 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/langages-process.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.
