> 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/developpeurs/reference-wkyjs.md).

# Référence WKYJS

## Préambule

Lors de vos différentes modélisations au sein de Workey Designer, vous êtes souvent amenés à améliorer vos projets à l'aide de Javascript. Le but de ce document est donc de détailler les méthodes mises à votre disposition pour y parvenir. Elles sont fournies par la librairie WKYJS qui est disponible avec l'application Workey. Elles sont donc toutes préfixées avec le terme *WKYJS.* Elles permettent d'effectuer des opérations lors de l'affichage des documents dans votre navigateur. Il y a donc des méthodes pour le document, les sections et les champs. Dans un second temps, nous verrons qu'il est possible d'externaliser le javascript des modélisations à l'aide de fichiers.

## Insertion de code Javascript dans un formulaire

Pour ce faire, lors de la modélisation d'un formulaire :

1. Il faut créer un champ de type **Script JS** dans le Designer.
2. Vous pouvez saisir directement le code Javascript directement dans la zone **Valeur/Script d'initialisation**.
3. Vous pouvez cliquez sur l'icône d'édition du code Javascipt qui permet d'ouvrir une boite de dialogue d'assistance à la saisie du scipt (image ci-dessous).

Lorsque c'est possible, il est conseillé de créer une section technique qui regroupe les Javascripts du formulaire. La visibilité de la section doit être cachée pour ne pas être affiché à l'écran.

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

Dans cette boite de dialogue vous y trouvez :

1. les différents objets à insérer dans votre code Javascript.
2. une zone d'édition du code Javascript.
3. les différentes méthodes disponibles avec la librairie WKYJS.
4. l'icône d'aide qui affiche cette documentation

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

## Les méthodes de document

### Les méthodes d'action utilisateur

Ces méthodes simulent, la plupart du temps, un clic sur un bouton qui effectue une action sur le document.

#### La méthode submit

Cette méthode permet de soumettre le document. Elle simule un clic sur le bouton *Soumettre*.

```javascript
WKYJS.submit();
```

#### La méthode save

Cette méthode permet d'enregistrer le document sans le soumettre. Elle simule un clic sur le bouton *Enregistrer*.

```javascript
WKYJS.save();
```

#### La méthode cancel

Cette méthode permet d'annuler la saisie en cours sur le document. Elle simule un clic sur le bouton *Annuler*.

```javascript
WKYJS.cancel();
```

#### La méthode takeInCharge

Cette méthode permet de prendre en charge le document. Elle simule un clic sur le bouton *Prendre en charge*.

```javascript
WKYJS.takeInCharge();
```

#### La méthode releaseTakeInCharge

Cette méthode permet de libérer la prise en charge sur le document. Elle simule un clic sur le bouton *Libérer la prise en charge*.

```javascript
WKYJS.releaseTakeInCharge();
```

#### La méthode deleteDraft

Cette méthode permet de supprimer le brouillon. Elle simule un clic sur le bouton *Supprimer le brouillon*.

```javascript
WKYJS.deleteDraft();
```

#### La méthode refresh

Elle permet de rafraichir les données du document. Elles sont envoyées au serveur où les connecteurs sont exécutés. Une fois les données traitées, elles sont de nouveau réaffichées.

Exemple d'un *refresh* avec un bouton :

```html
<button class="btn btn-primary" onClick="WKYJS.refresh()">Rafraichir le document</button>
```

Cette méthode peut prendre éventuellement des paramètres comme la méthode *refreshOnChange*, cela permet de contrôler les champs qui seront impactés. Par contre les paramètres passés sont sous forme d'objet JSON.

```json
{
  "log": "Texte permettant de laisser une trace dans les devTools du navigateur",
  "source": "Num_de_dosssier",
  "targets": ["Nom_du_dossier", "status", "montant"],
  "scrollTo": "commentaires"
}
```

Le passage de paramètres à *refresh* permet de décomposer/contrôler la méthode *refreshOnChange*.

#### La méthode selectStateByOperationNameAndStateName

Cette méthode permet de sélectionner le prochain état du document. Elle simule le clic de l'utilisateur sur une coche qui est en regard de l'état souhaité. Il faut spécifier le nom interne de l'opération en cours et le nom interne du prochain état.

```javascript
WKYJS.selectStateByOperationNameAndStateName("Controler", "Controlee");
```

#### La méthode selectFirstState

Cette méthode permet de sélectionner le premier état affiché dans le document. Elle simule le clic de l'utilisateur sur la coche qui est en regard du premier état.

```javascript
WKYJS.selectFirstState();
```

### Les écouteurs d'action

Ces méthodes permettent d'enregistrer des traitements pour des évènements. Elles acceptent en paramètre une fonction contenant vos traitements et les enregistrent dans le système d'évènements dans l'ordre ou elles apparaissent dans le navigateur. Les traitements sont ensuite exécutés lorsque les évènements sont déclenchés dans le document. Pour la plupart des méthodes, les évènements sont déclenchés juste avant l'action, sauf pour les fonctions *onLoad,* *onRefresh* et *onChangeState*.

#### La méthode onSubmit

Elle permet d'exécuter du code Javascript juste avant la soumission du document.

```javascript
WKYJS.onSubmit(function () {
    // votre code ici
});
```

Si une des fonctions, déclenchées par le onSubmit, renvoie la valeur false la soumission du document est stoppée. Ceci peut permettre d'effectuer des contrôles, juste avant la soumission.

#### La méthode onSave

Elle permet d'exécuter du code Javascript juste avant la sauvegarde du brouillon.

```javascript
WKYJS.onSave(function () {
    // votre code ici
});
```

Si une des fonctions, déclenchées par le *onSave*, renvoie la valeur *false* la sauvegarde du brouillon est stoppée. Ceci peut permettre d'effectuer des contrôles, juste avant l'enregistrement.

#### La méthode onCancel

Elle permet d'exécuter du code Javascript juste avant l'annulation de la saisie.

```javascript
WKYJS.onCancel(function () {
    // votre code ici
});
```

Si une des fonctions, déclenchées par le *onCancel*, renvoie la valeur *false* l'annulation du document est stoppée. Ceci peut permettre d'effectuer des contrôles, juste avant l'annulation.

#### La méthode onTakeInCharge

Elle permet d'exécuter du code Javascript juste avant la prise en charge du document.

```javascript
WKYJS.onTakeInCharge(function () {
    // votre code ici
});
```

Si une des fonctions, déclenchées par le *onTakeInCharge*, renvoie la valeur *false* la prise en charge est stoppée. Ceci peut permettre d'effectuer des contrôles.

#### La méthode onReleaseTakeInCharge

Elle permet d'exécuter du code Javascript juste avant la libération de la prise en charge du document.

```javascript
WKYJS.onReleaseTakeInCharge(function () {
    // votre code ici
});
```

Si une des fonctions, déclenchées par le *onReleaseTakeInCharge*, renvoie la valeur *false* la libération de la prise en charge est stoppée. Ceci peut permettre d'effectuer des contrôles.

#### La méthode onDeleteDraft

Elle permet d'exécuter du code Javascript juste avant la suppression du brouillon.

```javascript
WKYJS.onDeleteDraf(function () {
    // votre code ici
});
```

Si une des fonctions, déclenchées par le *onDeleteDraft*, renvoie la valeur *false* la suppression du brouillon est stoppée. Ceci peut permettre d'effectuer des contrôles.

#### La méthode onLoad

Elle permet d'exécuter du Javascript une fois que le document est affiché. A ce moment-là, tous les champs du formulaire sont accessibles dans vos développements Javascript.

Exemple :

```javascript
WKYJS.onLoad(function () {
    // votre code ici
});
```

#### La méthode onRefresh

Cette méthode permet d'exécuter du Javascript une fois que le document a été rafraichi. Attention de ne pas lancer un *refresh* dans cette méthode, car le navigateur ne répondrait plus (boucle infinie de *refresh*).

Exemple :

```javascript
WKYJS.onRefresh(function () {
    // votre code ici
});
```

#### La méthode onChangeState

Cette méthode permet d'exécuter du Javascript lorsque l'utilisateur change l'état du document. La fonction de callback récupère en paramètre le nom interne de l'état sélectionné.

Exemple :

```javascript
WKYJS.onChangeState(function(stateName) {
    // votre code ici
});
```

### Les méthodes de formulaires

Ces méthodes permettent de masquer/afficher des zones dans le document affiché. Elles peuvent aussi rajouter des zones.

#### La méthode addSubmitButton

Cette méthode ajoute une barre de bouton pour la soumission du document.

```javascript
WKYJS.addSubmitButton();
```

Appelé sans paramètres, vous obtenez la barre suivante.

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

Vous pouvez customiser les boutons en passant un objet JS composé de paramètres à la méthode *addSubmitButton*.

Les paramètres par défaut sont les suivants :

```json
{
    "vertical":"bottom",
    "horizontal":"right",
    "text":wui.localize("Submit"),
    "cancelable":true,
    "savable":true
}
```

Liste des propriétés de paramétrage :

**vertical** : La propriété positionne verticalement les boutons dans le formulaire, la valeur par défaut est *bottom*. Les boutons son donc en bas de formulaire. Cette propriété peut prendre deux valeurs : *bottom* ou *top*.

**horizontal** : La propriété positionne horizontalement les boutons dans le formulaire, la valeur par défaut est *right*. Les boutons son donc alignés à droite du formulaire. Cette propriété peut prendre deux valeurs : *right* ou *left*.

**text** : La propriété contient le texte du bouton de soumission qui est affiché. Elle peut être aussi localisée (voir localisation d'un libellé)

**cancelable**: La propriété indique si la barre doit contenir ou non le bouton *Annuler*. Cette propriété peut prendre deux valeurs : *true* ou *false*.

**savable**: La propriété indique si la barre doit contenir ou non le bouton *Sauvegarder*. Cette propriété peut prendre deux valeurs : *true* ou *false*.

#### La méthode addButtonBar

A la différence de *addSubmitButton*, cette méthode ajoute une barre de boutons sans le bouton de soumission. C'est à vous de spécifier un ou des boutons d'actions. Cette méthode est plus complète que addSubmitButton, il est donc préférable de l'utiliser lors que c'est possible.

```javascript
WKYJS.addButtonBar();
```

Appelé sans paramètres, vous obtenez la barre suivante.

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

Vous pouvez remarquer qu'il n'y aucun bouton d'action. Il va falloir les spécifier à l'aide d'un objet JS contenant les paramètres adéquates.

Les paramètres par défaut sont les suivants :

```json
{
    "vertical":"bottom",
    "horizontal":"right",
    "buttons":[],
    "cancelable":true,
    "savable":true,
    "takeInChargable":false,
    "releasable":false,
    "discardable ":false
}
```

Liste des propriétés de paramétrage :

**vertical** : La propriété positionne verticalement les boutons dans le formulaire, la valeur par défaut est *bottom*. Les boutons son donc en bas de formulaire. Cette propriété peut prendre deux valeurs : *bottom* ou *top*.

**horizontal** : La propriété positionne horizontalement les boutons dans le formulaire, la valeur par défaut est *right*. Les boutons son donc alignés à droite du formulaire. Cette propriété peut prendre deux valeurs : *right* ou *left*.

**buttons** : La propriété contient une liste de boutons d'actions. C'est un tableau JS qui contient un ou des objets JS pour chaque bouton.

Un bouton est donc spécifié avec différentes propriétés, il y en a trois :

* ***label*** : cette propriété contient le texte qui va être affiché dans le bouton. Elle peut être aussi localisée (voir localisation d'un libellé)
* ***type*** : cette propriété contient le type de bouton, elle peut prendre différentes valeurs : *default*, *primary, secondary, danger, warning, success ou info*. Un bouton de type *primary* est affiché avec une couleur dominante (action principale par défaut). Avec comme type *default*, le bouton a une couleur plus discrète.
* ***action*** : cette propriété contient la fonction JS à exécuter lorsque l'utilisateur clique sur le bouton. Dans la plupart des cas, la fonction JS spécifiée contient généralement la sélection d'un état et la soumission du document.
* ***bgColor*** : cette propriété permet de spécifier une couleur de bouton. Elle accepte les noms de couleur HTML ou les code HEXA de couleur HTML (par exemple pour rouge : *red* ou *#CC0000*). Elle prend la main sur la propriété *type*.
* ***txtColor*** : cette propriété permet de spécifier la couleur du texte dans le bouton. Elle accepte les noms de couleur HTML ou les code HEXA de couleur HTML (par exemple pour noir: *black* ou *#000000*). Elle prend la main sur la propriété *type*.

**cancelable**: La propriété indique si la barre doit contenir ou non le bouton *Annuler*. Cette propriété peut prendre deux valeurs : *true* ou *false*.

**savable**: La propriété indique si la barre doit contenir ou non le bouton *Sauvegarder*. Cette propriété peut prendre deux valeurs : *true* ou *false*.

**takeInChargable**: La propriété indique si la barre doit contenir ou non le bouton *Prendre en charge*. Cette propriété peut prendre deux valeurs : *true* ou *false*.

**releasable**: La propriété indique si la barre doit contenir ou non le bouton *Libérer la prise en charge*. Cette propriété peut prendre deux valeurs : *true* ou *false*.

**discardable**: La propriété indique si la barre doit contenir ou non le bouton *Supprimer le brouillon*. Cette propriété peut prendre deux valeurs : *true* ou *false*.

L'exemple si dessous affiche une barre de boutons avec deux boutons d'action. Le bouton *Sauvegarder* n'est pas affiché.

```javascript
WKYJS.addButtonBar({
    "buttons":[
    {
        "label":{"fr":"Accepter", "en":"Accept"},
        "type":"primary",
        "action":function() {
            WKYJS.selectStateByOperationNameAndStateName("Traiter", "Accepte");
            WKYJS.submitDoc();
        }
    },
    {
        "label":{"fr":"Rejeter", "en":"Reject"},
        "type":"normal",
        "action":function() {
            WKYJS.selectStateByOperationNameAndStateName("Traiter","Rejete");
            WKYJS.submitDoc();
        }
    }],
    "savable":false
});
```

Vous obtenez la barre de bouton suivante.

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

L'exemple si dessous affiche une barre de boutons de différentes couleurs.

```javascript
WKYJS.addButtonBar({
    buttons: [
        {
            "label": "Primary",
            "type": "primary"
        },
        {
            "label": "Secondary",
            "type": "secondary"
        },
        {
            "label": "Warning",
            "type": "warning"
        },
        {
            "label": "Danger",
            "type": "danger"
        },
        {
            "label": "Success",
            "type": "success"
        },
        {
            "label": "Info",
            "type": "info"
        },
        {
            "label": "I'm darkorchid !",
            "type": "primary",
            "bgColor": "darkorchid"
        },
        {
            "label": "Orange avec texte noir",
            "type": "secondary", //sera surchargé par les deux propriétés suivantes
            "bgColor": "darkorange",
            "txtColor": "#000000"
        }
    ]
});
```

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

#### La méthode showButtonInButtonBar

Cette méthode permet d'afficher un bouton de la barre de boutons ajoutée à l'aide la méthode *addButtonBar*. Elle prend en paramètre le rang du bouton dans la barre. La numérotation du rang au sein de la barre commence à 0.

```javascript
// affiche le 3ème bouton de la barre 
WKYJS.showButtonInButtonBar(2);
```

#### La méthode hideButtonInButtonBar

Cette méthode permet de cacher un bouton de la barre de boutons ajoutée à l'aide la méthode *addButtonBar*. Elle prend en paramètre le rang du bouton dans la barre. La numérotation du rang au sein de la barre commence à 0.

```javascript
// cache le 1er bouton de la barre 
WKYJS.hideButtonInButtonBar(0);
```

#### La méthode showStates

Cette méthode permet de montrer la section *Prochain état*. Elle est très rarement usitée.

#### La méthode hideStates

Cette méthode permet de cacher la section *Prochain état*. Elle est souvent utilisée avec les méthodes *addSubmitButton* et *addButtonBar*.

#### La méthode hideSaveButton

Cette méthode permet de cacher le bouton *Sauvegarder* qui est situé dans la section *Prochain état*.

#### La méthode hideCancelButton

Cette méthode permet de cacher le bouton *Annuler* qui est situé dans la section *Prochain état*.

### Les méthodes de contexte

Ces méthodes permettent de récupérer des données sur le document hors formulaire. Elles renseignent sur le contexte du document affiché.

#### La méthode getWorkeyProcessType

Cette méthode permet d'accéder au nom interne du processus associé au document affiché.

#### La méthode getWorkeyProcessVersion

Cette méthode permet d'accéder au numéro de version processus associé au document affiché.

#### La méthode getWorkeyDocumentType

Cette méthode permet d'accéder au nom interne du document affiché.

#### La méthode getWorkeyForm

Cette méthode permet d'accéder au nom interne du formulaire affiché.

#### La méthode getWorkeyDocumentId

Cette méthode permet d'accéder à l'id du document affiché.

#### La méthode getWorkeyDocumentState

Cette méthode permet d'accéder au nom interne de l'état du document affiché. Elle remplace la méthode `getWorkeyCurrentState` qui est obsolète.

#### La méthode getWorkeyRole

Cette méthode permet d'accéder au nom interne du rôle qui a ouvert le document affiché.

#### La méthode getWorkeyNextStates

Cette méthode permet de renvoyer un tableau contenant les noms internes des prochains états disponibles.

#### La méthode getWorkeySelectedState

Cette méthode permet de renvoyer le nom interne du prochain état qui a été sélectionné dans le document.

#### La méthode getWorkeyUserLanguage

Cette méthode permet d'accéder à la langue utilisée pour l'affichage document.

### Les méthodes de contrôles

#### La méthode isEmailValid

Cette fonction renvoie *true* si l'adresse email passé en paramètre est valide, sinon retourne *false*. Elle possède aussi un second paramètre optionnel qui permet de passer une chaine de caractères représentant une expression régulière. Elle sera utilisée si celle par défaut ne correspond pas à vos attentes.

```javascript
WKYJS.setValue("Email", "john\@company.com");
// valorise le champ Email avec 'john\@company.com'

WKYJS.isEmailValid(WKYJS.getValue("Email"));
// renvoie true
```

#### La méthode isPhoneNumberValid

Cette fonction renvoie *true* si le numéro de téléphone passé en paramètre est valide, sinon retourne *false*. Elle possède aussi un second paramètre optionnel qui permet de passer une chaine de caractères représentant une expression régulière. Elle sera utilisée si celle par défaut ne correspond pas à vos attentes.

```javascript
WKYJS.setValue("Tel", "01 55 85 11 95");
// valorise le champ Tel avec '01 55 85 11 95'

WKYJS.isPhoneNumberValid(WKYJS.getValue("Tel"));
// renvoie true
```

#### La méthode isFieldValueValid

Cette fonction renvoie *true* si la valeur du champ passé en paramètre est valide, sinon retourne *false*. Elle a deux paramètres, le premier est le nom interne du champ concerné, le second est une chaine de caractères représentant une expression régulière.

```javascript
WKYJS.setValue("Code", "12abc99");
// valorise le champ Code avec '12abc99'

WKYJS.isFieldValueValid("Code", "abc");
// renvoie true, le champ Code contient la valeur abc
```

### Les méthodes utiles

#### La méthode msg

Cette méthode permet d'afficher un message éphémère à l'écran.

```javascript
WKYJS.msg("Hello les gens !");
// affiche 'Hello les gens !' comme message à l'écran
```

#### La méthode informationBox

Cette méthode permet d'afficher une boite de dialogue avec un message informatif.

```javascript
WKYJS.informationBox("Hello les gens !");
// affiche 'Hello les gens !' dans une boite de dialogue d'information
```

#### La méthode errorBox

Cette méthode permet d'afficher une boite de dialogue avec un message d'erreur.

```javascript
WKYJS.errorBox("Nom obligatoire");
// affiche 'Nom obligatoire' dans une boite de dialogue d'erreur
```

#### La méthode reopenDocAfterCreation

Cette méthode permet de rouvrir un document, après sa création, à l'étape suivante. En d'autres termes, lorsque l'on soumet un document pour création, il est directement réouvert pour renseigner le formulaire à l'étape suivante.

Cette méthode est surtout utilisée lors des dérivations. Elle permet juste après la création du document père d'enchainer avec la création des documents fils. On évite ainsi le passage par la vue *A Faire*.

A noter que Le document est réouvert par le même utilisateur avec le même rôle utilisé à la création.

```javascript
WKYJS.onLoad(function () {
    WKYJS.reopenDocAfterCreation();
});
```

#### La méthode sqlRequest

```javascript
WKYJS.sqlRequest({
    "sqlName":"...",
    "parameters":[ /* les paramètres ici */ ],
    "parametersType":[ /* les types SQL ici */ ],
    "done":function(data) {
        // Votre code ici
    }
});
```

Cette méthode permet de requêter une source de connée et de récupérer les données.

Pour ce faire, il faut alimenter la méthode avec un objet javascript composé de plusieurs attributs :

***sqlName*** : cet attribut contient le nom de la requête SQL à utiliser. Cette dernière doit être spécifiée dans l'administration dans la rubrique *Requêtes SQL*.

***parameters*** : cet attribut spécifie les valeurs à utiliser pour substituer les placeholders dans la requête. Il est composé d'un tableau de valeurs.

***parametersType*** : cet attribut spécifie les valeurs à utiliser pour les types de données SQL correspondants aux paramètres passés (parameters). Il est composé d'un tableau de valeurs (e.g. "VARCHAR", "BIGINT"...). Il est optionnel, dans ce cas, VARCHAR est utilisé par défaut pour tous les paramètres.

***done*** : cet attribut permet de spécifier la fonction de callback qui est utilisée lors de la récupération les données issues de la requête. La fonction comporte un seul paramètre (*data)* correspondant aux données, c'est un tableau d'objets JSON.

Ci-dessous un exemple qui va chercher les lignes d'une commande.

```javascript
WKYJS.sqlRequest({
    "sqlName":"Ma_req_def_dans_l_admin",    
    "parameters":[WKYJS.getFieldValue("Prenom")],
    "done":function(data) {
        WKYJS.setFieldValue("Lignes", data);
    }
});
```

La requête *Ma\_req\_def\_dans\_l\_admin* définie dans l'administration :

```sql
SELECT id, Prenom, Nom, Age, Description FROM aaa WHERE Prenom LIKE ?
```

La fonction de callback *done*, récupère un tableau composé d'objet javascript. Les objets sont composés d'attributs qui ont pour nom les colonnes de la requête. Dans l'exemple la requête contient des alias, évidemment ils ne sont pas obligatoires, mais nécessaire si l'on veut forcer le nom d'un attribut dans le résultat.

## Les méthodes de section

### La méthode showSection

Cette méthode permet d'afficher une section grâce à son nom interne.

```javascript
WKYJS.showSection("Informations");
// montre la section Informations
```

### La méthode hideSection

Cette méthode permet de cacher une section grâce à son nom interne.

```javascript
WKYJS.hideSection("Informations");
// cache la section Informations
```

### La méthode collapseSection

Cette permet de replier la section définie par le nom interne

```javascript
WKYJS.collapseSection("Informations");
// replie la section Informations
```

### La méthode expandSection

Cette permet de déplier la section définie par le nom interne

```javascript
WKYJS.expandSection("Informations");
// déplie la section Informations
```

### La méthode enabled

Cette méthode permet d'activer ou désactiver tous les champs d'une section. Bien sûr lorsque les champs sont désactivés, il n'est plus possible de modifier leurs valeurs. Cependant cette méthode ne permet de récupérer l'état d'activation de la section.

```javascript
WKYJS.enabled("Infos", false);
// Désactive tous les champs de la section Infos

WKYJS.enabled("Infos");
// Renvoie un avertissement dans la console du navigateur
```

## Les méthodes de champ

### La méthode getFieldValue

Cette méthode permet d'accéder à la valeur du champ grâce à son nom interne.

```javascript
WKYJS.getFieldValue("Nom");
// renvoie la valeur du champ Nom
```

### La méthode setFieldValue

Cette méthode permet de modifier le contenu d'un champ grâce à son nom interne.

```javascript
WKYJS.setFieldValue("Nom", "Jean-Pierre");
// affecte la valeur Jean-Pierre au champ Nom

WKYJS.getFieldValue("Nom");
// renvoie la chaine de caractère "Jean-Pierre"
```

### Manipuler les valeurs de champs

Il faut bien sur respecter les types de données initiés par les champs.

Dans la même logique si un champ est multivalué, il faut manipuler les données à l'aide de tableau Javascript.

Par exemple pour un champ de type liste, représentant une liste de choix de villes, l'expression suivante nous donnes les choix sélectionnés.

```javascript
WKYJS.getFieldValue("Villes");
// renvoie le tableau ["Paris", "Tokyo"] 
```

Vous pouvez aussi utiliser la fonction *setFieldValue* pour valoriser, vider etc.

```javascript
WKYJS.setFieldValue("Villes", ["New-York", "Mumbai"]);
// valorise le champ Villes avec les choix : New-York et Mumbai

WKYJS.getFieldValue("Villes");
// renvoie le tableau ["New-York", "Mumbai"]

WKYJS.setFieldValue("Villes", []);
// vide la liste des choix sélectionnés

WKYJS.getFieldValue("Villes");
// renvoie un tableau vide : [].
```

Si par mégarde, vous valorisez un champ multivalué avec autre chose qu'un tableau JS, une erreur s'affiche à l'écran.

### La méthode showField

Cette méthode permet de montrer un champ grâce à son nom interne.

```javascript
WKYJS.showField("Nom");
// montre le champ Nom
```

### La méthode hideField

Cette méthode permet de cacher un champ grâce à son nom interne.

```javascript
WKYJS.hideField("Nom");
// cache le champ Nom
```

### La méthode onChange

Cette méthode permet d'exécuter du code javascript lorsque la valeur du champ est modifiée. Le champ est identifié par son nom interne.

```javascript
WKYJS.onChange(designerName, function(designerName) {
    // Votre code ici
});
```

### La méthode refreshOnChange

Cette méthode combine la méthode *onChange* d'un champ avec le *refresh* du document. C'est-à-dire que lorsque le champ identifié par son nom interne voit sa valeur modifiée, le document est rafraichi.

```javascript
WKYJS.refreshOnChange (designerName, [cible1, cible2, ... cibleN], scrollTo);
```

Cette méthode accepte deux paramètres optionnels supplémentaires :

Le paramètre *\[cible1, cible2, ... cibleN]* est un tableau JSON qui contient les nom internes des champs qui seront mise à jour avec les nouvelles valeurs issues du refresh.

Le paramètre *scrollTo* est le nom interne d'un champ du formulaire, sur lequel le focus sera appliqué après le rafraichissement. Cette fonctionnalité reste expérimentale et peut parfois donner un résultat non satisfaisant dû à l'évolution dynamique du DOM.

Par exemple, pour des listes de choix cascadée, il faut rafraichir le document pour calculer les autres listes descendantes.

```javascript
WKYJS.refreshOnChange ("Choix_de_la_marque");
```

### La méthode showOrHideElements

```javascript
WKYJS.showOrHideElements(designerName, values, fieldNameTargets);
```

Cette méthode permet d'afficher au de cacher des champs en fonction des valeurs que peut prend un champ.

En d'autres termes, lorsque le champ identifié par son nom interne (*designerName*) a sa valeur égale à une des valeurs contenues dans *values.* Les champs dont le nom internes est contenu dans *fieldNameTargets* sont affiché, et l'inverse dans le cas contraire.

Par exemple, pour l'expression suivante, si l'utilisateur sélectionne un abonnement expert ou premium, une section d'informations sera affichée :

```javascript
WKYJS.showOrHideElements("Choix_abonnement", ["expert", "premium"], ["section_infos_niv_sup"]);
```

### La méthode hideOrShowElements

```javascript
WKYJS.hideOrShowElements(designerName, values, fieldNameTargets);
```

Cette méthode permet de cacher au d'afficher des champs en fonction des valeurs que peut prend un champ.

En d'autres termes, lorsque le champ identifié par son nom interne (*designerName*) a sa valeur égale à une des valeurs contenues dans *values.* Les champs dont le nom internes est contenu dans *fieldNameTargets* sont caché, et l'inverse dans le cas contraire.

Par exemple, pour l'expression suivante, si l'utilisateur sélectionne un abonnement expert ou premium, une section d'informations sera cachée :

```javascript
WKYJS.hideOrShowElements("Choix_abonnement", ["expert", "premium"], ["section_infos_niv_inf"]);
```

### La méthode error

Cette méthode permet d'appliquer ou de retirer le style reflétant une erreur sur un champ.

```javascript
WKYJS.error("Email",true);
// Affiche le champ Email en erreur

WKYJS.error("Email",false);
// Réinitialise le champ sans erreur
```

### La méthode setPlaceholder

Cette méthode permet d'affiche un placeholder sur les champs de saisie de type texte.

```javascript
// affiche 'Veuillez saisir le nom' à l'intérieur du champ de saisie lorsque celui-ci n'est pas renseigné
WKYJS.getField("Nom_du_champ").setPlaceholder("Veuillez saisir le nom");
```

### La méthode autoCompleteSQL

```javascript
WKYJS.autoCompleteSQL({
    "designerName":"...",
    "minLength":2,
    "sqlName":"...",
    "sqlFilter":"...",
    "dataField":"...",
    "select":function(value, dataItem) {

    }
});
```

Cette méthode permet de sélectionner une valeur dans un domaine de valeur externe à Workey. Ce domaine est calculé en fonction du texte saisi par l'utilisateur et est le résultat d'une requête SQL, d'où le nom de la méthode.

Pour implémenter cette fonctionnalité, dans le désigner, il faut l'appliquer à un champ de type Ligne simple monovalué. Le champ sera alors transformé en champ avec complétion automatique.

Pour ce faire, il faut alimenter la méthode avec un objet javascript composé de plusieurs attributs :

***designerName*** : cet attribut contient le nom interne du champ Ligne simple à utiliser dans le formulaire

***minLength*** : cet attribut spécifie le nombre de caractères à saisir avant l'exécution de la requête SQL qui va peupler la liste

***sqlName*** : cet attribut contient le nom de la requête SQL à utiliser. Cette dernière doit être spécifiée dans l'administration dans la rubrique *Requêtes SQL*.

***sqlFilter*** : cet attribut détermine le type de filtre à appliquer. Il peut prendre deux valeurs : `contains` ou `startsWith`. S'il n'est pas spécifié, `contains` est utilisé par défaut.

***dataField*** : cet attribut spécifie la colonne à utiliser qui est retournée par la sélection d'une entrée dans la liste.

***select*** : cet attribut permet de spécifier la fonction de callback qui est utilisée lors de la sélection d'une entrée dans la liste. La fonction comporte deux paramètres :

* la valeur sélectionnée (en accord avec l'attribut *dataField*)
* la ligne correspondante à la valeur sélectionnée (permet de peupler une fiche par ex)

***reset*** : cet attribut permet de spécifier la fonction de callback qui est exécutée lors de la remise à vide du filtre en cliquant sur le bonton ad hoc.

Ci-dessous un exemple qui, à l'ouverture du formulaire, construit un champ autoComplete sur le champ *RechDossier*.

```javascript
WKYJS.onLoad(function () {

    WKYJS.autoCompleteSQL({
        "designerName":"RechDossier",
        "sqlName":"Ma_requete_definie_dans_l_admin",
        "dataField":"Toto",
        "select":function(val, dataItem) {
            WKYJS.setFieldValue("Nom", dataItem.Toto);
            WKYJS.setFieldValue("Prenom", dataItem.Prenom);
            WKYJS.setFieldValue("Age", dataItem.Age);
            WKYJS.setFieldValue("Description", dataItem.Description);
        },
        reset:function(val, dataItem) {
            WKYJS.setFieldValue("Nom", "");
            WKYJS.setFieldValue("Prenom", "");
            WKYJS.setFieldValue("Age", "");
            WKYJS.setFieldValue("Description", "");
        }
    });

});
```

La requête *Ma\_requete\_definie\_dans\_l\_admin* définie dans l'administration :

```sql
select Nom as Toto, Prenom, Age, isAdmin, Description, Passion from aaa where Nom like ? or Prenom like ? order by Nom, Prenom
```

On peut remarquer que la requête utilise un alias Toto pour la colonne Nom, c'est donc pour cela qu'il est utilisé dans l'attribut dataField et la fonction *select*. Le but d'utiliser des alias sera nécessaire pour les requêtes complexes (jointure, group by...). Dans notre exemple l'alias est présent à but informatif, il n'est pas du tout nécessaire et aurait pu être retiré.

On peut remarquer que la fonction de callback select, récupère la ligne sélectionnée sous forme d'objet javascript qui permet ensuite de valoriser les champs d'une fiche. On notera que les attributs sont nommés avec le nom des colonnes de la requête (ou alias si il y a).

### La méthode autoCompleteLDAP

```javascript
WKYJS.autoCompleteLDAP({

    "designerName":"RechUser",
    "minLength":2,
    "filterFields":["uid", "sn"],
    "moreFields":[ "description", "mobile"],
    "filterOpe":"contains",
    "dataField":"dn",
    "select":function(val, dataItem) {
        // Votre code ici
    }
    
});
```

Cette méthode permet de sélectionner une valeur dans un domaine de valeur issu du serveur LDAP utilisé par Workey. Ce domaine est calculé en fonction du texte saisi par l'utilisateur et est le résultat d'une requête LDAP, d'où le nom de la méthode.

Pour implémenter cette fonctionnalité, dans le désigner, il faut l'appliquer à un champ de type Ligne simple monovalué. Le champ sera alors transformé en champ avec complétion automatique.

Pour ce faire, il faut alimenter la méthode avec un objet javascript composé de plusieurs attributs :

***designerName*** : cet attribut contient le nom interne du champ Ligne simple à utiliser dans le formulaire

***minLength*** : cet attribut spécifie le nombre de caractères à saisir avant l'exécution de la requête LDAP qui peuple la liste

***filterFields*** : cet attribut est un tableau JSON qui contient les noms des champs LDAP sur lesquels le filtre de recherche va s'appuyer.

***moreFields*** : cet attribut est un tableau JSON qui contient les noms des champs LDAP à rajouter aux champs déjà récupérés par défaut.

***FilterOpe*** : cet attribut spécifie le type d'action du filtre sur les champs de recherche. Il peut contenir comme valeur : soit *contains* ou *startsWidth.* Pour *contains,* la valeur saisie doit être présente dans le contenu du champ. Pour startsWidth, la valeur saisie doit correspondre au début du contenu du champ.

***dataField*** : cet attribut spécifie le champ LDAP qui est retournée par la sélection d'une entrée dans la liste.

***select*** : cet attribut permet de spécifier la fonction de callback qui est utilisée lors de la sélection d'une entrée dans la liste. La fonction comporte deux paramètres :

* la valeur sélectionnée (en accord avec l'attribut *dataField*)
* la ligne correspondante à la valeur sélectionnée (permet de peupler une fiche par ex)

Ci-dessous un exemple qui, à l'ouverture du formulaire, construit un champ autoComplete sur le champ *RechUser*.

```javascript
WKYJS.onLoad(function () {

    WKYJS.autoCompleteLDAP({
        "designerName":"RechUser",
        "filterFields":["uid", "sn"],
        "moreFields":["description", "mobile"],
        "minLength":2,
        "filterOpe":"contains",
        "dataField":"dn",
        "select":function(val, dataItem) {
            WKYJS.getField("Result").value(wky.jstr(dataItem));
        }
    });

});
```

On peut remarquer que la fonction de callback select, récupère l'utilisateur LDAP sélectionné sous forme d'objet javascript comme dans la méthode autoCompleteSQL. Dans notre cas il sera sérialisé et valorisé dans le champ *Result*.

Attention, si vous spécifiez des champs additionnels à récupérer, par l'attribut *moreFields*, ces derniers seront présents dans la réponse dans l'attribut *fields* de la réponse.

Exemple de réponse :

```json
{
    "cn": "Jean Sérien",
    "mail": "jserien@efalia.com",
    "type": "PERSON",
    "dn": "jserien",
    "fields": {
        "mobile": "+33 6 11 11 12 12",
        "description": "Utilisateur Jean Sérien"
    }
}
```

### La méthode enabled

Cette méthode permet d'activer ou désactiver un champ. Bien sûr lorsque le champ est désactivé, il n'est plus possible de modifier sa valeur.

```javascript
WKYJS.enabled("Email", true);
// Active le champ Email

WKYJS.enabled("Email", false);
// Désactive le champ Email
```

### La méthode required

Cette méthode permet d'ajouter ou de supprimer le caractère obligatoire d'un champ.

```javascript
WKYJS.required("Email", true);
// Active la saisie obligatoire du champ Email

WKYJS.required ("Email", false);
// Désactive la saisie obligatoire du champ Email
```

### La méthode hideColumnInDynTab

Cette méthode permet de cacher une colonne d'une table dynamique.

```javascript
WKYJS.hideColumnInDynTab("Table_des_personnes", "Age");
// Cache la colonne Age de la table dynamique Table_des_personnes
```

### La méthode showColumnInDynTab

Cette méthode permet d'afficher une colonne d'une table dynamique.

```javascript
WKYJS.showColumnInDynTab("Table_des_personnes", "Age");
// Affiche la colonne Age de la table dynamique Table_des_personnes
```

### La méthode getColumnValuesInDynTab

Cette méthode permet de récupérer les valeurs d'une colonne appartenant à une table dynamique.

```javascript
WKYJS.getColumnValuesInDynTab("Table_des_personnes", "Age");
// Retourne les âges de la table dynamique Table_des_personnes
// valeurs retournées sous forme de tableau [25, 33, 40, 18]
```

### La méthode setColumnValuesInDynTab

Cette méthode permet de valoriser les cellules d'une colonne appartenant à une table dynamique.

```javascript
WKYJS.setColumnValuesInDynTab("Table_des_personnes", "Age", [40, 22, 55, 19]);
// Dispatch chacune des valeurs du tableau dans les cellules de la colonne
// Attention le nombre de valeurs doit être égale au nombre de lignes de la table.
```

### La méthode addRowInDynTab

Cette méthode permet d'ajouter une ligne à une table dynamique.

```javascript
WKYJS.addRowInDynTab("Table_des_personnes", {"Prenom":"Jean", "Nom":"Durand", "Age", 33}, true);
// Ajoute une personne à la table Table_des_personnes.
// Attention le deuxième paramètre doit contenir toutes les valeurs de champ déclarées dans la définition de la table.
// Le troisième paramètre force l'évènement de modificiation.
```

### La méthode getFieldLabel

Cette méthode permet de récupérer le libellé d'un champ.

```javascript
WKYJS.getFieldLabel("Nom");
// Récupère le libellé du champ sous forme de chaine de caractères
```

### La méthode setFieldLabel

Cette méthode permet de modifier le libellé d'un champ.

```javascript
WKYJS.setFieldLabel("Nom", "Nom de la personne");
// Remplace le libellé du champ par celui passé en paramètre
```

### La méthode autoRefreshDynTab

Cette méthode permet de modifier le caractère auto-refresh d'un tableau dynamique.

```javascript
WKYJS.autoRefreshDynTab("Table_Dyn", true);
// Activation de l'auto-refresh pour la table Table_Dyn
```

### La méthode previewAttachment

Cette méthode permet de prévisualiser un contenu d'une pièce jointe Workey.

```javascript
WKYJS.previewAttachment("Piece_jointe_1", 0);
// prévisualise le premier contenu de la pièce jointe "Piece_jointe_1"
// le deuxième paramètre est optionnel (0 par défaut), il permet de spécifier le contenu visé.
```

### La méthode getCurrentActor

Cette méthode permet d'obtenir des informations sur l'utilisateur connecté.

```javascript
var actor = WKYJS.getCurrentActor();
console.log(actor.id, actor.name, actor.label);
// 2 'caucoin' 'Clothilde Aucoin'
```

### La méthode getIds

Cette méthode permet d'obtenir les identifiants des documents qui sont contenus dans un composant Pièce Jointe, Dossier MG, Documents MG ou Efalia Docs. Elle renvoie un tableau JSON contenant les valeurs.

```javascript
WKYJS.getIds('Docs_annexes');
// renvoie ['2994d932-44ab-45a1-8add-338b852e7e73', '1704d932-44ab-45a1-8add-108b852e7e73'] 
```

### Les méthode du composant Signataires et Cachets

Les méthodes sont disponibles à partir de la version 6.34.0.

Les propriétés d'un signataires sont les suivantes:

| Propriété | Description                           | Exemple                |
| --------- | ------------------------------------- | ---------------------- |
| name      | Identité du signataire                | Jean-Michel DUPONT     |
| phone     | Téléphone du signatire                | +33 12345678           |
| email     | E-mail du signataire                  | <jmdupont@company.com> |
| reason    | Agrément de la signature              | lu et approuvé         |
| location  | Lieu où est réalisée de la signature  | Londres                |
| imageUrl  | Nom du ficher à utiliser comme cachet | Jean-Michel DUPONT.png |

Elles ne sont pas toutes forcémént utilisées, cela dépend du fournisseur de signature choisi.

#### La méthode addSigner

Cette méthode permet d'ajouter un signataire.

```javascript
WKYJS.addSigner("Stamper", {"name":"John DOE", "email": "djoe@company.com"});
// Ajout du signataire 'John DOE' dans le composant 'Stamper'
```

#### La méthode insertSignerAt

Cette méthode permet d'ajouter un signataire à un rang précis dans la liste des signataires.

```javascript
WKYJS.insertSignerAt("Signers", 0, {"name":"John DOE", "email": "djoe@company.com"});
// Ajout du signataire 'John DOE' dans le composant 'Signers' au début de la liste
```

#### La méthode removeSignerAt

Cette méthode permet de supprimer un signataire dans la liste des signataires.

```javascript
WKYJS.removeSignerAt("Signers", 2);
// Suppression du signataire dans le composant 'Signers' à la 3ème position dans la liste des signataires.
```

#### La méthode modifySignerAt

Cette méthode permet de modifier les données d'un signataire.

```javascript
WKYJS.modifySignerAt("Stamper", 1, {"name":"Joe TRUCMUCHE", "email": "jtrucmuche@company.com"});
// Modification du signataire dans le composant 'Signers' à la 2ème position dans la liste des signataires. 
// Le nom et l'email sont mis à jour.
```

#### La méthode signatureTemplate

Cette méthode permet de récupérer ou de modifier le texte de la signature.

```javascript
WKYJS.signatureTemplate("Signataires_et_cachets", "Signé par {{NAME}}\nle {{DATE}}");
// Modification du texte de la signature qui sera affiché dans le cachet.
WKYJS.signatureTemplate("Signataires_et_cachets");
// Récupération du texte de la signature `Signé par {{NAME}}\nle {{DATE}}`.
```

## Exemples de code Javascript

La liste des exemples de code javascript sera complétée au fur et à mesure.

### Masquage de la section Prochain état avec l'ajout d'une barre de boutons pour soumettre le document.

```javascript
// Masquage de la section Prochain Etat
WKYJS.hideStates();

// Ajout de la soumission
WKYJS.addButtonBar({
    "buttons":[
        {
            "label":"Valider",
            "type":"primary",
            "action":function() {
                WKYJS.selectStateByOperationNameAndStateName("Traiter","Valide");
                WKYJS.submitDoc();
            }
        }
    ],
    "savable":false
});
```

### Ajout d'une zone de prévisualisation d'une pièce jointe

```javascript
WKYJS.onChange("Courrier_numerise" , function (dName) {

    $('[data-iframe-attchment-preview="' + dName + '"]').remove();
    
    let uuid = WKYJS.getField(dName).value();
    
    if (uuid != null) {
        WKYJS.getField(dName).element.append('<iframe data-iframe-attchment-preview="' + dName + '"  width="100%" height="600" src="../api/attachment/' + uuid + '/inline"></iframe>');
    }
});
    
```

### Ajout d'un bouton de rafraîchissement du document

```html
<button class="btn btn-primary" onClick="WKYJS.refresh()">Rafraîchir le document</button>
```

## Externalisation du Javascript

Si vous le souhaitez, en plus du Javascript dans les modélisations, il est possible d'en écrire dans des fichiers. Ces derniers seront chargés au runtime comme s'ils étaient présents dans vos modélisations. Cette fonctionnalité a des avantages et des défauts :

Le pour :

* Plus confortable si votre projet regorge de Javascript.
* Permet l'utilisation d'un éditeur adéquate au développement.
* Permet de modifier le Javascript sans redéployer une nouvelle version de processus.
* Factorise les javascripts des sections techniques à un seul endroit.

Le contre :

* Il faut pouvoir accéder au système de fichiers des clients où Workey est installé.
* Il faut assurer manuellement les versions de fichiers avec celles des modélisations.
* En cas de maintenance il faut pouvoir récupérer ces fichiers.

Il ne faut pas externaliser systématiquement son Javascript, on peut vite comprendre qu'un projet qui utilise très peu la bibliothèque WKYJS sera plus facile à maintenir sans externaliser.

### Localisation des fichiers

Tous les fichiers sont stockés dans des sous-répertoires eux même contenus dans le répertoire */$WORKEY-DATA$/external-js/*.

Les sous répertoires conteneurs respectent une nomenclature/une structure de la forme */$WORKEY-DATA$/external-js/processName/documentType/formName* où *procesName* est le nom interne du processus concerné, *documentType* est le nom interne du document concerné et *formName* le nom interne du formulaire concerné. On peut déjà comprendre que ces sous répertoires vont permettre une granularité d'utilisation du javascript.

Par exemple dans un projet de gestion de contrat, nous pouvons avoir la structure suivante :

*/$WORKEY-DATA$/external-js/Gestion\_des\_contrats/Contrat/F\_enregistrement\_CTR\_SIEGE.*

La structure des sous-répertoires se construit automatiquement et au fur et à mesure de l'affichage des formulaires dans l'application.

### Granularité d'utilisation

De par le dépôt d'un fichier dans un des sous-répertoires va découler son utilisation. En d'autres termes :

* Si un fichier se situe dans le répertoire *processName*, tous les formulaires associés au processus utiliseront le Javascript du fichier.
* Si un fichier se situe dans le répertoire *documentType*, tous les formulaires associés au document utiliseront le Javascript du fichier.
* Si un fichier se situe dans le répertoire *formName*, seul le formulaire concerné utilisera le Javascript.

Pour que les fichiers soient lus automatiquement, il faut qu'ils respectent certaines règles de nommage.

Pour qu'un fichier soit utilisé quel que soit le processus, il faut créer et placer le fichier *\_\_all\_processes.js* dans le répertoire */$WORKEY-DATA$/external-js/*.

### Nommage des fichiers

Le nom des fichiers est normé, il doit être en minuscule, se nommer *process.js* dans le répertoire du processus, se nommer *document.js* dans le répertoire document et pour être original, *form.js* dans le répertoire du formulaire.

Nommés de telle manière, les fichiers sont chargés quelle que soit la version de processus déployée. Si vous souhaitez avoir un fichier Javascript particulier pour une version de processus donnée, il faut rajouter le numéro de version dans le fichier. Par exemple pour un document de la version 5 d'un processus, il faut nommer le fichier *document.5.js*. A savoir que si un fichier Javascript est versionné, les versions supérieures de processus l'utiliseront jusqu'à ce qu'un nouveau numéro de version apparaisse. Il est évident qu'un fichier versionné avec un numéro de version supérieur au processus en cours sera ignoré.

### Edition des fichiers via le Designer

Le Designer propose une interface de gestion des javascripts externalisés. Pour un projet en cours de modélisation, vous pouvez y accéder par le menu déroulant principal.

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

Vous pourrez aussi y accéder depuis le panneau des propriétés des objets Workey qui autorisent les javascripts externes. Il y a trois types d'objets qui permetttent cela, ce sont : les processus, les documents et les formulaires.

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

La fenêtre des **javascripts externalisés** vous permet de créer la structure sur le système de fichier du serveur, de créer / modifier des fichiers, de télécharger des fichiers ou tous les fichiers. Pour des raisons de sécurité vous ne pouvez rien supprimer. Pour pouvoir faire cela, il vous faudra avoir accès au serveur Workey et le faire manuellement.

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

## Annexe

### Localisation d'un libellé

Il est possible sous forme d'un objet JS de localiser un libellé lorsque la fonctionnalité est prévue. Il suffit de spécifier en clé la langue et en valeur le libellé souhaité correspondant à la langue.

Par exemple pour spécifier le français et l'anglais pour un libellé qui exprime la sauvegarde des changements, il faut définir l'objet JS suivant :

```json
{
    "fr":"Sauvegarder les modifications",
    "en":"Save changes"
}
```


---

# 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/developpeurs/reference-wkyjs.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.
