[comment]: # translation:outdated

[comment]: # ({d3accdff-d3accdff})
# Objets JavaScript supplémentaires

[comment]: # ({/d3accdff-d3accdff})

[comment]: # ({dfa8c394-ab8bd378})
### Aperçu

Cette section décrit les ajouts de Zabbix au langage JavaScript implémentés avec Duktape et les fonctions JavaScript globales prises en charge.

[comment]: # ({/dfa8c394-ab8bd378})

[comment]: # ({c73f2449-c73f2449})
### Objets intégrés

[comment]: # ({/c73f2449-c73f2449})

[comment]: # ({500e2fca-e5dc8dd0})
#### Zabbix

L'objet Zabbix fournit une interaction avec la fonctionnalité interne de Zabbix.

|Méthode|Description|
|--|--------|
|`log(loglevel, message)`|Écrit <message> dans le journal Zabbix en utilisant le niveau de journalisation <loglevel> (voir le paramètre DebugLevel du fichier de configuration).|

Exemple :

    Zabbix.log(3, "this is a log entry written with 'Warning' log level")

Vous pouvez utiliser les alias suivants :

|Alias|Alias vers |
|-----|--------|
|console.log(object)|Zabbix.log(4, JSON.stringify(object))|
|console.warn(object)|Zabbix.log(3, JSON.stringify(object))|
|console.error(object)|Zabbix.log(2, JSON.stringify(object))|

::: noteimportant
La taille totale de tous les messages consignés est limitée à 8 Mo par exécution de script.
:::

|Méthode|Description|
|--|--------|
|`sleep(delay)`|Retarde l'exécution de JavaScript de `delay` millisecondes. |

Exemple (retarder l'exécution de 15 secondes) :

    Zabbix.sleep(15000)
  

[comment]: # ({/500e2fca-e5dc8dd0})

[comment]: # ({new-413974f8})
#### HttpRequest

This object encapsulates cURL handle allowing to make simple HTTP
requests. Errors are thrown as exceptions.

::: noteimportant
HttpRequest is a new name for this object since
Zabbix 5.4. Previously it used to be called CurlHttpRequest. Method
names have also been changed in Zabbix 5.4. The old object/method names
are now deprecated and their support will be discontinued after Zabbix
6.0.
:::

|Method|Description|
|------|-----------|
|`addHeader(name, value)`|Adds HTTP header field. This field is used for all following requests until cleared with the clearHeader() method.|
|`clearHeader()`|Clears HTTP header. If no header fields are set, HttpRequest will set Content-Type to application/json if the data being posted is JSON-formatted; text/plain otherwise.|
|`connect(url)`|Sends HTTP CONNECT request to the URL and returns the response.|
|`customRequest(method, url, data)`|Allows to specify any HTTP method in the first parameter. Sends the method request to the URL with optional *data* payload and returns the response.|
|`delete(url, data)`|Sends HTTP DELETE request to the URL with optional *data* payload and returns the response.|
|`getHeaders()`|Returns object of received HTTP header fields.|
|`get(url, data)`|Sends HTTP GET request to the URL with optional *data* payload and returns the response.|
|`head(url)`|Sends HTTP HEAD request to the URL and returns the response.|
|`options(url)`|Sends HTTP OPTIONS request to the URL and returns the response.|
|`patch(url, data)`|Sends HTTP PATCH request to the URL with optional *data* payload and returns the response.|
|`put(url, data)`|Sends HTTP PUT request to the URL with optional *data* payload and returns the response.|
|`post(url, data)`|Sends HTTP POST request to the URL with optional *data* payload and returns the response.|
|`getStatus()`|Returns the status code of the last HTTP request.|
|`setProxy(proxy)`|Sets HTTP proxy to "proxy" value. If this parameter is empty then no proxy is used.|
|`setHttpAuth(bitmask, username, password)`|Sets enabled HTTP authentication methods (HTTPAUTH\_BASIC, HTTPAUTH\_DIGEST, HTTPAUTH\_NEGOTIATE, HTTPAUTH\_NTLM, HTTPAUTH\_NONE) in the 'bitmask' parameter.<br>The HTTPAUTH\_NONE flag allows to disable HTTP authentication.<br>Examples:<br>`request.setHttpAuth(HTTPAUTH_NTLM \| HTTPAUTH_BASIC, username, password)`<br>`request.setHttpAuth(HTTPAUTH_NONE)`|
|`trace(url, data)`|Sends HTTP TRACE request to the URL with optional *data* payload and returns the response.|

Example:

``` {.java}
try {
    Zabbix.log(4, 'jira webhook script value='+value);
  
    var result = {
        'tags': {
            'endpoint': 'jira'
        }
    },
    params = JSON.parse(value),
    req = new HttpRequest(),
    fields = {},
    resp;
  
    req.addHeader('Content-Type: application/json');
    req.addHeader('Authorization: Basic '+params.authentication);
  
    fields.summary = params.summary;
    fields.description = params.description;
    fields.project = {"key": params.project_key};
    fields.issuetype = {"id": params.issue_id};
    resp = req.post('https://tsupport.zabbix.lan/rest/api/2/issue/',
        JSON.stringify({"fields": fields})
    );
  
    if (req.getStatus() != 201) {
        throw 'Response code: '+req.getStatus();
    }
  
    resp = JSON.parse(resp);
    result.tags.issue_id = resp.id;
    result.tags.issue_key = resp.key;
} catch (error) {
    Zabbix.log(4, 'jira issue creation failed json : '+JSON.stringify({"fields": fields}));
    Zabbix.log(4, 'jira issue creation failed : '+error);
  
    result = {};
}
  
return JSON.stringify(result);
```

[comment]: # ({/new-413974f8})

[comment]: # ({73df7bc5-06cac1ca})
#### XML

L'objet XML permet le traitement des données XML dans l'élément et le prétraitement de découverte de bas niveau et les webhooks.

::: noteimportant
 Pour utiliser l'objet XML, le serveur/proxy doit être compilé avec le support libxml2.
:::

|Méthode|Description|
|--|--------|
|`XML.query(data, expression)`|Récupère le contenu du nœud à l'aide de XPath. Renvoie null si le nœud n'est pas trouvé.<br>**expression** - une expression XPath ;<br>**data** - données XML sous forme de chaîne.|
|`XML.toJson(data)`|Convertit les données au format XML en JSON.|
|`XML.fromJson(object)`|Convertit les données au format JSON en XML.|

Exemple :

*Entrée :*

    <menu>
        <food type = "breakfast">
            <name>Chocolate</name>
            <price>$5.95</price>
            <description></description>
            <calories>650</calories>
        </food>
    </menu>

*Sortie :*

```json
{
    "menu": {
        "food": {
            "@type": "breakfast",
            "name": "Chocolate",
            "price": "$5.95",
            "description": null,
            "calories": "650"
        }
    }
}
```

[comment]: # ({/73df7bc5-06cac1ca})

[comment]: # ({9e03c929-a12fbdc2})
##### Règles de sérialisation

La conversion XML vers JSON sera traitée selon les règles suivantes (pour les conversions JSON vers XML, des règles inversées sont appliquées) :

1\. Les attributs XML seront convertis en clés dont les noms seront précédés de '@'.

Exemple :

*Entrée:*

     <xml foo="FOO">
       <bar>
         <baz>BAZ</baz>
       </bar>
     </xml>

*Sortie :*

```json
 {
   "xml": {
     "@foo": "FOO",
     "bar": {
       "baz": "BAZ"
     }
   }
 }
```

2\. Les éléments à fermeture automatique (\<foo/\>) seront convertis comme ayant une valeur 'null'.

Exemple :

*Entrée:*

    <xml>
      <foo/>
    </xml>

*Sortie :*

```json
{
  "xml": {
    "foo": null
  }
}
```

3\. Les attributs vides (avec la valeur "") seront convertis comme ayant une valeur de chaîne vide ('').

Exemple :

*Entrée:*

    <xml>
      <foo bar="" />
    </xml>

*Sortie :*

```json
{
  "xml": {
    "foo": {
      "@bar": ""
    }
  }
}
```

4\. Plusieurs nœuds enfants avec le même nom d'élément seront convertis en une seule clé qui a un tableau de valeurs comme valeur.

Exemple :

*Entrée:*

    <xml>
      <foo>BAR</foo>
      <foo>BAZ</foo>
      <foo>QUX</foo>
    </xml>

*Sortie :*

```json
{
  "xml": {
    "foo": ["BAR", "BAZ", "QUX"]
  }
}
```

5\. Si un élément de texte n'a ni attribut ni enfant, il sera converti en chaîne.

Exemple :

*Entrée:*

    <xml>
        <foo>BAZ</foo>
    </xml>

*Sortie :*

```json
{
  "xml": {
    "foo": "BAZ"
   }
}
```

6\. Si un élément de texte n'a pas d'enfant, mais possède des attributs : le contenu du texte sera converti en un élément avec la clé '\#text' et le contenu comme valeur ; les attributs seront convertis comme décrit dans la règle de sérialisation 1.

Exemple :

*Entrée:*

    <xml>
      <foo bar="BAR">
        BAZ
      </foo>
    </xml>

*Sortie :*

```json
{
  "xml": {
    "foo": {
      "@bar": "BAR",
      "#text": "BAZ"
    }
  }
}
```

[comment]: # ({/9e03c929-a12fbdc2})

[comment]: # ({ce2f01e2-1368a2b0})
### Fonctions JavaScript globales

Des fonctions JavaScript globales supplémentaires ont été implémentées avec Duktape :

-   btoa(string) - encode la chaîne en chaîne base64
-   atob(base64\_string) - décode la chaîne base64

```javascript
try {
    b64 = btoa("utf8 string");
    utf8 = atob(b64);
} 
catch (error) {
    return {'error.name' : error.name, 'error.message' : error.message}
}
```

-   md5(données) -  calcule le hachage MD5 d'une chaîne
-   sha256(données) - calcule le hachage SHA256 d'une chaîne
-   mac('\<ype de hachage\>',clé,données) - renvoie le hachage HMAC sous forme de chaîne au format hexadécimal ;
    Les types de hachage MD5 et SHA256 sont pris en charge ;
    Les paramètres de clé et de données prennent en charge les données binaires. Exemples :
    -    `hmac('md5',clé,données)`
    -    `hmac('sha256',clé,données)`
-   sign(hachage,clé,données) - renvoie la signature calculée (signature RSA avec SHA-256) sous forme de chaîne, où :<br>
    **hash** - seul 'sha256' est autorisé, sinon une erreur est renvoyée ;<br>
    **clé** - la clé privée. Il doit correspondre à la norme PKCS#1 ou PKCS#8. La clé peut être fournie sous différentes formes :<br>
    -    avec des espaces au lieu de retours à la ligne ;
    -    avec des '\n' échappés ou non au lieu de nouvelles lignes ;
    -    sans aucun retour à la ligne sous la forme d'une chaîne à une seule ligne ;
    -    sous forme de chaîne au format JSON.

    La clé peut également être chargée à partir d'une macro utilisateur/macro secrète/coffre.

    **data** - les données qui seront signées. Il peut s'agir d'une chaîne (les données binaires sont également prises en charge) ou d'un tampon (Uint8Array/ArrayBuffer).<br>
    OpenSSL ou GnuTLS est utilisé pour calculer les signatures. Si Zabbix a été compilé sans aucune de ces bibliothèques de chiffrement, une erreur sera générée ("bibliothèque OpenSSL ou GnuTLS manquante").<br>Cette fonction est prise en charge depuis Zabbix 6.0.15.

[comment]: # ({/ce2f01e2-1368a2b0})