[comment]: # translation:outdated

[comment]: # ({96feb912-d3accdff})
# 1 Extra JavaScript-objecten

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

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

Deze sectie beschrijft Zabbix-toevoegingen aan de JavaScript-taal die zijn geïmplementeerd met Duktape en ondersteunde globale JavaScript-functies.

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

[comment]: # ({c73f2449-c73f2449})
### Ingebouwde objecten

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

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

Het Zabbix-object biedt interactie met de interne Zabbix-functionaliteit.

|Methode|Omschrijving|
|--|--------|
|`log(loglevel, message)`|Schrijft <message> in het Zabbix-logboek met gebruik van het logniveau <loglevel> (zie configuratiebestand DebugLevel parameter).|

Voorbeeld:

    Zabbix.log(3, "dit is een logboekvermelding geschreven met het logniveau 'Waarschuwing'")

Je kunt de volgende aliassen gebruiken:

|Alias|Alias voor|
|-----|--------|
|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
De totale grootte van alle gelogde berichten is beperkt tot 8 MB per scriptuitvoering.
:::

|Methode|Omschrijving|
|--|--------|
|`sleep(delay)`|Vertraagt de uitvoering van JavaScript met `delay` milliseconden.|

Voorbeeld (vertraagt de uitvoering 15 seconden):

    Zabbix.sleep(15000)

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

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

Dit object omvat een cURL-handle waarmee eenvoudige HTTP-verzoeken kunnen worden gedaan. Fouten worden als uitzonderingen gegooid.

::: noteimportant
Het initialiseren van meerdere `HttpRequest`-objecten is beperkt tot 10 per uitvoering van het script.
:::

|Methode|Beschrijving|
|--|--------|
|`addHeader(value)`|Voegt een HTTP-header veld toe. Dit veld wordt gebruikt voor alle volgende verzoeken totdat het wordt gewist met de methode `clearHeader()`.<br>De totale lengte van de header velden die aan een enkel `HttpRequest`-object kunnen worden toegevoegd, is beperkt tot 128 Kbytes (speciale tekens en kopernamen inbegrepen).|
|`clearHeader()`|Wist de HTTP-header. Als er geen header velden zijn ingesteld, zal `HttpRequest` Content-Type instellen op application/json als de te verzenden data in JSON-formaat is; anders text/plain.|
|`connect(url)`|Verzendt een HTTP CONNECT-verzoek naar de URL en geeft de respons terug.|
|`customRequest(method, url, data)`|Maakt het mogelijk om een willekeurige HTTP-methode op te geven in de eerste parameter. Verzendt het methode-verzoek naar de URL met een optioneel *data* payload en geeft de respons terug.|
|`delete(url, data)`|Verzendt een HTTP DELETE-verzoek naar de URL met een optionele *data* payload en geeft de respons terug.|
|`getHeaders(<asArray>)`|Geeft het object van ontvangen HTTP-header velden terug.<br>De parameter `asArray` kan worden ingesteld op "true" (bijv. `getHeaders(true)`), "false" of ongedefinieerd zijn. Als het op "true" is ingesteld, worden de waarden van de ontvangen HTTP-header velden geretourneerd als arrays; dit moet worden gebruikt om de veldwaarden van meerdere headers met dezelfde naam op te halen.<br>Als het niet is ingesteld of ingesteld op "false", worden de waarden van de ontvangen HTTP-header velden geretourneerd als strings.|
|`get(url, data)`|Verzendt een HTTP GET-verzoek naar de URL met een optionele *data* payload en geeft de respons terug.|
|`head(url)`|Verzendt een HTTP HEAD-verzoek naar de URL en geeft de respons terug.|
|`options(url)`|Verzendt een HTTP OPTIONS-verzoek naar de URL en geeft de respons terug.|
|`patch(url, data)`|Verzendt een HTTP PATCH-verzoek naar de URL met een optionele *data* payload en geeft de respons terug.|
|`put(url, data)`|Verzendt een HTTP PUT-verzoek naar de URL met een optionele *data* payload en geeft de respons terug.|
|`post(url, data)`|Verzendt een HTTP POST-verzoek naar de URL met een optionele *data* payload en geeft de respons terug.|
|`getStatus()`|Geeft de statuscode van het laatste HTTP-verzoek terug.|
|`setProxy(proxy)`|Stelt de HTTP-proxy in op de waarde "proxy". Als deze parameter leeg is, wordt geen proxy gebruikt.|
|`setHttpAuth(bitmask, username, password)`|Stelt ingeschakelde HTTP-authenticatiemethoden (HTTPAUTH_BASIC, HTTPAUTH_DIGEST, HTTPAUTH_NEGOTIATE, HTTPAUTH_NTLM, HTTPAUTH_NONE) in de parameter 'bitmask' in.<br>De HTTPAUTH_NONE-vlag maakt het mogelijk om HTTP-authenticatie uit te schakelen.<br>Voorbeelden:<br>`request.setHttpAuth(HTTPAUTH_NTLM \| HTTPAUTH_BASIC, username, password)`<br>`request.setHttpAuth(HTTPAUTH_NONE)`|
|`trace(url, data)`|Verzendt een HTTP TRACE-verzoek naar de URL met een optionele *data* payload en geeft de respons terug.|

Voorbeeld:

```javascript
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]: # ({/cf4a25c5-413974f8})

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

Het XML-object maakt de verwerking van XML-gegevens mogelijk in item- en laagdrempelige detectie-preprocessing en webhooks.

::: noteimportant
Om het XML-object te gebruiken, moet de server/proxy worden gecompileerd met ondersteuning voor libxml2.
:::

|Methode|Beschrijving|
|--|--------|
|`XML.query(data, expression)`|Haalt de inhoud van een knooppunt op met behulp van XPath. Geeft null terug als het knooppunt niet wordt gevonden.<br>**expression** - een XPath-expressie;<br>**data** - XML-gegevens als een tekenreeks.|
|`XML.toJson(data)`|Converteert gegevens in XML-indeling naar JSON.|
|`XML.fromJson(object)`|Converteert gegevens in JSON-indeling naar XML.

Voorbeeld:

*Invoer:*

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

*Uitvoer:*

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

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

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

Bij de conversie van XML naar JSON worden de volgende regels toegepast (voor conversies van JSON naar XML worden omgekeerde regels toegepast):

1\. XML-attributen worden geconverteerd naar sleutels waarvan de namen worden voorafgegaan door '@'.

Voorbeeld:

*Invoer:*

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

*Uitvoer:*

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

2\. Zelfsluitende elementen (<foo/>) worden geconverteerd als zijnde 'null' waarde.

Voorbeeld:

*Invoer:*

    <xml>
      <foo/>
    </xml>

*Uitvoer:*

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

3\. Lege attributen (met "" waarde) worden geconverteerd als zijnde een lege tekenreeks ('') waarde.

Voorbeeld:

*Invoer:*

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

*Uitvoer:*

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

4\. Meerdere kindknooppunten met dezelfde elementnaam worden geconverteerd naar één sleutel met een array van waarden als zijn waarde.

Voorbeeld:

*Invoer:*

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

*Uitvoer:*

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

5\. Als een tekstelement geen attributen en geen kinderen heeft, wordt het geconverteerd als een tekenreeks.

Voorbeeld:

*Invoer:*

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

*Uitvoer:*

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

6\. Als een tekstelement geen kinderen heeft, maar wel attributen heeft: wordt de tekstinhoud geconverteerd naar een element met de sleutel '\#text' en de inhoud als waarde; attributen worden geconverteerd zoals beschreven in regel 1 van de serialisatie.

Voorbeeld:

*Invoer:*

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

*Uitvoer:*

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

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

[comment]: # ({c8e96df2-1368a2b0})
### Globale JavaScript-functies

Aanvullende globale JavaScript-functies zijn geïmplementeerd met Duktape:

-   btoa(data) - codeert de data naar een base64-string
-   atob(base64\_string) - decodeert een base64-string

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

-   md5(data) - berekent de MD5-hash van de data
-   sha256(data) - berekent de SHA256-hash van de data
-   hmac('\<hash type\>',key,data) - geeft de HMAC-hash als een hex-geformatteerde string terug;
    MD5- en SHA256-hash types worden ondersteund;
    sleutel- en dataparameters ondersteunen binair. Voorbeelden:
    -    `hmac('md5',key,data)`
    -    `hmac('sha256',key,data)`
-   sign(hash,key,data) - geeft de berekende handtekening (RSA-handtekening met SHA-256) terug als een string, waarbij:<br>
    **hash** - alleen 'sha256' is toegestaan, anders wordt er een foutmelding weergegeven;<br>
    **key** - de privésleutel. Deze moet overeenkomen met de PKCS#1- of PKCS#8-standaard. De sleutel kan op verschillende manieren worden opgegeven:<br>
    -    met spaties in plaats van nieuwe regels;
    -    met geëscapete of niet-geëscapete '\n's in plaats van nieuwe regels;
    -    zonder enige nieuwe regels als een eenregelige string;
    -    als een JSON-geformatteerde string.

    De sleutel kan ook worden geladen uit een gebruikersmacro/geheime macro/kluis.

    **data** - de data die zal worden ondertekend. Het kan een tekenreeks zijn (ook binair ondersteund) of buffer (Uint8Array/ArrayBuffer).<br>
    OpenSSL of GnuTLS wordt gebruikt om de handtekeningen te berekenen. Als Zabbix is gebouwd zonder een van deze versleutelingsbibliotheken, wordt er een foutmelding weergegeven ('missing OpenSSL or GnuTLS library').<br>Deze functie wordt ondersteund sinds Zabbix 6.4.1.

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