> For the complete documentation index, see [llms.txt](https://doc.commandersact.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://doc.commandersact.com/fr/fonctionnalites/destinations/destination-builder/javascript-destination-builder/serverside-js-helpers.md).

# Aides Javascript server-side

Cet article décrit les API de destination server-side.

## `decodeURI` <a href="#getalleventdata" id="getalleventdata"></a>

Décode tous les caractères encodés dans l’URI fourni. Renvoie une **chaîne** qui représente l’URI décodé. Renvoie `undefined` si l’entrée fournie est invalide.

**Syntaxe**

```javascript
decodeUri(encoded_uri);
```

**Exemple**

```javascript
const decodeUri = require('decodeUri');

const decodedUrl = decodeUri(data.encodedUrl);
if (decodedUrl) {
  // ...
}
```

| Paramètre         | Type     | Description                                                                                                                                  |
| ----------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| **`encoded_uri`** | *string* | Un URI encodé avec [`encodeUri()`](https://developers.google.com/tag-platform/tag-manager/server-side/api#encodeuri) ou par d’autres moyens. |

## `decodeUriComponent` <a href="#decodeuricomponent" id="decodeuricomponent"></a>

Décode tous les caractères encodés dans le composant d’URI fourni. Renvoie une **chaîne** qui représente le composant d’URI décodé. Renvoie `undefined` si l’entrée fournie est invalide.

**Syntaxe**

```javascript
decodeUriComponent(encoded_uri_component);
```

**Exemple**

```javascript
const decodeUriComponent = require('decodeUriComponent');

const decodedQuery = decodeUriComponent(data.query);
if (decodedQuery) {
  // ...
}
```

| Paramètre                   | Type     | Description                                                                                                                                                                |
| --------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`encoded_uri_component`** | *string* | Un composant d’URI encodé avec [`encodeUriComponent()`](https://developers.google.com/tag-platform/tag-manager/server-side/api#encodeuricomponent) ou par d’autres moyens. |

## `encodeUri` <a href="#getalleventdata" id="getalleventdata"></a>

Renvoie un identifiant uniforme de ressource (URI) encodé en échappant les caractères spéciaux. Renvoie une **chaîne** qui représente la chaîne fournie, encodée en URI.

**Syntaxe**

```javascript
encodeUri(uri);
```

**Exemple**

```javascript
const encodeUri = require('encodeUri');
const sendHttpGet = require('sendHttpGet');

sendHttpGet('https://www.example.com/' + encodeUri(pathInput));
```

| Paramètre | Type     | Description     |
| --------- | -------- | --------------- |
| `uri`     | *string* | Un URI complet. |

## `encodeUriComponent` <a href="#encodeuricomponent" id="encodeuricomponent"></a>

Renvoie un identifiant uniforme de ressource (URI) encodé en échappant les caractères spéciaux. Renvoie une **chaîne** qui représente la chaîne fournie, encodée en URI.

**Syntaxe**

```javascript
encodeUriComponent(str);
```

**Exemple**

```javascript
const encodeUriComponent = require('encodeUriComponent');
const sendHttpGet = require('sendHttpGet');

sendHttpGet('https://www.example.com/?' + encodeUriComponent(queryInput));
```

| Paramètre | Type     | Description         |
| --------- | -------- | ------------------- |
| **`str`** | *string* | Un composant d’URI. |

## `fromBase64` <a href="#frombase64" id="frombase64"></a>

Décode une chaîne encodée en base64. Renvoie `undefined` si l’entrée est invalide.

**Syntaxe**

```javascript
fromBase64(base64EncodedString);
```

**Exemple**

```javascript
const fromBase64 = require('fromBase64');

const greeting = fromBase64('aGVsbG8=');
if (greeting === 'hello') {
  // ...
}
```

| Paramètre                 | Type     | Description               |
| ------------------------- | -------- | ------------------------- |
| **`base64EncodedString`** | *string* | Chaîne encodée en Base64. |

## `generateRandom` <a href="#generaterandom" id="generaterandom"></a>

Renvoie un **nombre** (entier) dans la plage indiquée.

**Syntaxe**

```javascript
generateRandom(min, max);
```

**Exemple**

```javascript
const generateRandom = require('generateRandom');

const randomValue = generateRandom(0, 10000000);
```

| Paramètre | Type     | Description                                             |
| --------- | -------- | ------------------------------------------------------- |
| **`min`** | *nombre* | Valeur minimale possible de l'entier renvoyé (incluse). |
| **`max`** | *nombre* | Valeur maximale possible de l'entier renvoyé (incluse). |

## `getAllEventData` <a href="#getalleventdata" id="getalleventdata"></a>

Renvoie une copie des données de l’événement.

**Syntaxe**

```javascript
getAllEventData();
```

**Exemple d’utilisation**

```javascript
const getAllEventData= require('getAllEventData');
const eventModel = getAllEventData();
//build body request from event properties 
const body = {
    crm_id:eventModel.user.id,
    currency:eventModel.currency
};
```

{% hint style="info" %}
Notez que les données de l’événement peuvent contenir davantage de propriétés que celles que vous avez envoyées initialement, car des propriétés système sont ajoutées automatiquement aux [événements web](https://doc.commandersact.com/fr/developpeurs/tracking-and-integrations/tracking/about-events/js-sdk-event-specificity.md) et aux [événements app sdk](https://doc.commandersact.com/fr/developpeurs/tracking-and-integrations/tracking/about-events/mobile-sdk-event-specificity.md#event-specificity-for-mobile-app).
{% endhint %}

**Exemple de données :**

Si vous envoyez cet événement web :

```javascript
cact('trigger', 'search', {
  "search_term": "blue t-shirt",
  "user": {
    "id": "12345",
    "email": "anakin.skywalker@domain.com",
    "consent_categories": ["1","3"]
  }
);
```

La fonction getAllEventData() renverra alors cet objet :

```json
{
   "event_name": "search",
   "search_term": "blue t-shirt",
   "user": {
      "id": "12345",
      "email": "anakin.skywalker@domain.com",
      "consent_categories": ["1","3"]
   },
   "url": "https://www.mywebsite.com/path1/path2/", //Ajouté automatiquement s’il manque
   "path": "/path1/path2/", //Ajouté automatiquement
   "referrer": "https:///www.google.fr", //Ajouté automatiquement
   "title": "My page title", //Ajouté automatiquement s’il manque
   "context": {
      "event_id": "202110130000000000", //Ajouté automatiquement
      "generatorVersion": "10.0", //Ajouté automatiquement
      "containerVersion": "3.1", //Ajouté automatiquement
      "event_timestamp": "1639044446636", //Ajouté automatiquement
      "page": { //Ajouté automatiquement
         "title": "Search page", //Ajouté automatiquement
         "url": "https://shop.com/search?q=...", //Ajouté automatiquement
         "lang": "en", //Ajouté automatiquement
         "referrer": "https:///www.google.fr", //Ajouté automatiquement
         "viewport": { //Ajouté automatiquement
            "width": 320, //Ajouté automatiquement
            "height": 568 //Ajouté automatiquement
         }
      },
      "device": { //Ajouté automatiquement
         "user_agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36",//Ajouté automatiquement
         "ip": "102.3.4.56",//Copié automatiquement depuis l’en-tête de la requête
         "lang": "fr",//Ajouté automatiquement
         "cookie": "_fbp=123; _fbc=456; _ga=789",//Ajouté automatiquement
         "timezone": "Europe/Paris"//Ajouté automatiquement
      }
   }
}
```

## `getCookieValues` <a href="#getcookievalues" id="getcookievalues"></a>

Renvoie un tableau contenant les valeurs de tous les cookies portant le nom indiqué.

**Syntaxe**

```
getCookieValues(name[, noDecode]);
```

**Exemple**

```javascript
const getCookieValues = require('getCookieValues');
const facebook_fbp = getCookieValues('fbp')[0];
if (facebook_fbp ) {  // ...}
```

***

**Paramètres**

| Paramètre      | Type      | Description                                                                                                       |
| -------------- | --------- | ----------------------------------------------------------------------------------------------------------------- |
| **`name`**     | *string*  | Nom du cookie.                                                                                                    |
| **`noDecode`** | *booléen* | Si `true`, les valeurs du cookie ne seront pas décodées avant d’être renvoyées. La valeur par défaut est `false`. |

## `getEventData` <a href="#geteventdata" id="geteventdata"></a>

Renvoie une copie de la valeur située au chemin indiqué dans les données de l’événement. Renvoie `undefined` s’il n’y a pas de données d’événement ou si aucune valeur n’existe au chemin indiqué.

**Syntaxe**

```
getEventData(keyPath);
```

**Exemple**

```javascript
const getEventData = require('getEventData');

const campaignId = getEventData('campaign.id');
const itemId = getEventData('items.0.id');
const referrer = getEventData('page_referrer');
```

**Paramètres**

| Paramètre     | Type  | Description                                                                                                                                                                                                                        |
| ------------- | ----- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`keyPath`** | *any* | Le chemin de la clé, dont les composants sont séparés par des points. Les composants du chemin peuvent être des clés d’un objet ou des indices d’un tableau. Si `keyPath` n’est pas une chaîne, sa valeur est convertie en chaîne. |

## `getRemoteAddress` <a href="#getremoteaddress" id="getremoteaddress"></a>

Renvoie une **string** représentation de l’adresse IP à l’origine de la requête, par exemple `62.123.65.780` pour IPv4 ou `2001:0db8:85a3:0:0:8a2e:0370:1234` pour IPv6

**Syntaxe**

```
getRemoteAddress();
```

## `getTimestamp` <a href="#gettimestamp" id="gettimestamp"></a>

**Obsolète.** Utilisez de préférence [getTimestampMillis](https://developers.google.com/tag-platform/tag-manager/server-side/api#gettimestampmillis).

Renvoie un **number** qui représente l’heure actuelle en millisecondes depuis l’époque Unix, telle que renvoyée par `Date.now()`.

**Syntaxe**

```
getTimestamp();
```

## `getTimestampMillis` <a href="#gettimestampmillis" id="gettimestampmillis"></a>

Renvoie un **number** qui représente l’heure actuelle en millisecondes depuis l’époque Unix, telle que renvoyée par `Date.now()`.

**Syntaxe**

```
getTimestampMillis();
```

## `getType` <a href="#gettype" id="gettype"></a>

Renvoie une chaîne décrivant le type de la valeur indiquée.

| Type d’entrée | Valeur renvoyée |
| ------------- | --------------- |
| *string*      | 'string'        |
| *nombre*      | 'number'        |
| *booléen*     | 'boolean'       |
| *null*        | 'null'          |
| *undefined*   | 'undefined'     |
| *Tableau*     | 'array'         |
| *Object*      | 'object'        |
| *Function*    | 'function'      |

**Syntaxe**

```
getType(value);
```

**Exemple**

```javascript
const getType = require('getType');

const type = getType(value);
if (type === 'string') {
  // Traiter une entrée de type chaîne.
} else if (type === 'number') {
  // Traiter une entrée numérique.
} else {
  logToConsole('Unsupported input type: ', type);
}
```

**Paramètres**

| Paramètre   | Type  | Description      |
| ----------- | ----- | ---------------- |
| **`value`** | *any* | Valeur d’entrée. |

## `logToConsole` <a href="#logtoconsole" id="logtoconsole"></a>

Affiche son ou ses arguments dans la console.

Ces journaux sont visibles dans la console de Destination Builder.

**Exemple**

```
const logToConsole = require('logToConsole');

const product_color= "red";
const product_price= 10;
logToConsole('color is: ', product_color, ' and price is: ', product_price);
```

**Syntaxe**

```
logToConsole(argument1[, argument2, ...]);
```

**Paramètres**

La fonction accepte un ou plusieurs arguments, convertis chacun en chaîne si nécessaire, puis affichés dans la console.

## `makeInteger` <a href="#makeinteger" id="makeinteger"></a>

Convertit la valeur donnée en un **nombre** (entier).

**Syntaxe**

```
makeInteger(value);
```

**Paramètres**

| Paramètre   | Type        | Description         |
| ----------- | ----------- | ------------------- |
| **`value`** | *tout type* | Valeur à convertir. |

## `makeNumber` <a href="#makenumber" id="makenumber"></a>

Convertit la valeur donnée en un **nombre**.

**Syntaxe**

```
makeNumber(value);
```

**Paramètres**

| Paramètre   | Type        | Description         |
| ----------- | ----------- | ------------------- |
| **`value`** | *tout type* | Valeur à convertir. |

## `makeString` <a href="#makestring" id="makestring"></a>

Renvoie la valeur donnée sous forme de **chaîne**.

**Syntaxe**

```
makeString(value);
```

**Paramètres**

| Paramètre   | Type        | Description         |
| ----------- | ----------- | ------------------- |
| **`value`** | *tout type* | Valeur à convertir. |

## `parseUrl` <a href="#parseurl" id="parseurl"></a>

Renvoie un objet contenant toutes les composantes d’une URL donnée, comme l’objet `URL` .

Cette API renvoie `undefined` pour toute URL mal formée. Pour les URL correctement formatées, les champs absents de la chaîne d’URL auront une valeur de chaîne vide, ou, dans le cas de `searchParams`, un objet vide.

L’objet renvoyé contient les champs suivants :

```
{  
    href: string,  
    origin: string, 
    protocol: string,  
    username: string,  
    password: string,  
    host: string,  
    hostname: string,  
    port: string,  
    pathname: string,  
    search: string,  
    searchParams: Object<string, (string|Array)>,  
    hash: string,
}
```

**Syntaxe**

```
parseUrl(url);
```

**Exemple**

```
const parseUrl = require('parseUrl');const urlObject = parseUrl('https://abc:xyz@example.com:8080/foo?param=val%2Cue#bar');
```

**Paramètres**

| Paramètre | Type     | Description                       |
| --------- | -------- | --------------------------------- |
| **`url`** | *string* | L’URL complète qui sera analysée. |

## `sha256` <a href="#sha256" id="sha256"></a>

Calcule le condensat SHA-256 de l’entrée et appelle une fonction de rappel avec le condensat encodé en base64, sauf si l’objet `options` spécifie un encodage de sortie différent.

Cette signature et ce comportement d’API correspondent à l’API [`sha256`](https://developers.google.com/tag-platform/tag-manager/templates/api#sha256) pour les conteneurs Web ; toutefois, dans les conteneurs serveur, les modèles personnalisés doivent utiliser l’API [`sha256Sync`](https://developers.google.com/tag-platform/tag-manager/server-side/api#sha256sync) pour simplifier le code.

**Syntaxe**

```
sha256(input, onSuccess, options = undefined);
```

**Exemple**

```
const encodeUriComponent = require('encodeUriComponent');const sendHttpGet = require('sendHttpGet');const sha256 = require('sha256');sha256('inputString', (digest) => {  sendHttpGet('https://example.com/collect?id=' + encodeUriComponent(digest));});sha256('inputString', (digest) => {  sendHttpGet('https://example.com/collect?id=' + encodeUriComponent(digest));}, {outputEncoding: 'hex'});
```

**Paramètres**

| Paramètre       | Type       | Description                                                                                                                                                                                                            |
| --------------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`input`**     | *string*   | La chaîne à hacher.                                                                                                                                                                                                    |
| **`onSuccess`** | *fonction* | Appelée avec le condensat obtenu, encodé en base64, sauf si l’objet `options` spécifie un encodage de sortie différent.                                                                                                |
| **`options`**   | *objet*    | *Facultatif* Objet options facultatif permettant de spécifier l’encodage de sortie. S’il est spécifié, l’objet doit contenir la clé `outputEncoding` avec pour valeur l’une des options suivantes : `base64` ou `hex`. |

## `sha256Sync` <a href="#sha256sync" id="sha256sync"></a>

Calcule et renvoie le condensat SHA-256 de l’entrée, encodé en base64, sauf si l’objet `options` spécifie un encodage de sortie différent.

**Syntaxe**

```
sha256Sync(input, options = undefined);
```

**Exemple**

```
const encodeUriComponent = require('encodeUriComponent');const sendHttpGet = require('sendHttpGet');const sha256Sync = require('sha256Sync');const digestBase64 = sha256Sync('inputString');const digestHex = sha256Sync('inputString', {outputEncoding: 'hex'});sendHttpGet('https://example.com/collect?id=' + encodeUriComponent(digestBase64));sendHttpGet('https://example.com/collect?id=' + encodeUriComponent(digestHex));
```

**Paramètres**

| Paramètre     | Type     | Description                                                                                                                                                                                                            |
| ------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`input`**   | *string* | La chaîne à hacher.                                                                                                                                                                                                    |
| **`options`** | *objet*  | *Facultatif* Objet options facultatif permettant de spécifier l’encodage de sortie. S’il est spécifié, l’objet doit contenir la clé `outputEncoding` avec pour valeur l’une des options suivantes : `base64` ou `hex`. |

## `signHmac` <a href="#signhmac" id="signhmac"></a>

Génère une signature HMAC pour le payload fourni, à l’aide de `sha256` et de l’encodage `base64` par défaut, sauf si l’objet `options` spécifie une autre option. Les objets transmis comme payload sont automatiquement convertis en chaîne avec `JSON.stringify`'d. Renvoie une **chaîne**.

**Syntaxe**

```javascript
signHmac(payload, secret, options = undefined);
```

**Exemple**

```javascript
const signHmac = require('signHmac');

// Signer une chaîne avec les options par défaut (sha256 + base64)
const signature = signHmac('my payload', 'mySecretKey');

// Signer avec un algorithme et un encodage personnalisés
const signatureHex = signHmac('my payload', 'mySecretKey', { alg: 'sha1', outputEncoding: 'hex' });

// Signer un objet (converti automatiquement en chaîne JSON)
const objectSignature = signHmac({ key: 'value' }, 'mySecretKey');
```

**Paramètres**

| Paramètre     | Type             | Description                                                                                                                           |
| ------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| **`payload`** | *string\|object* | Les données à signer. Les objets sont automatiquement convertis en chaînes JSON.                                                      |
| **`secret`**  | *string*         | La clé secrète utilisée pour générer le HMAC.                                                                                         |
| **`options`** | *objet*          | *Facultatif* Objet options permettant de personnaliser l’algorithme et l’encodage de sortie. Voir les détails des options ci-dessous. |

**Options**

| Propriété            | Type     | Par défaut | Description                                                                                                                                           |
| -------------------- | -------- | ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`alg`**            | *string* | `'sha256'` | L’algorithme de hachage. Valeurs prises en charge : `'sha256'`, `'sha1'`, `'sha512'`, `'sha384'`, `'md5'` et d’autres algorithmes de hachage OpenSSL. |
| **`outputEncoding`** | *string* | `'base64'` | L’encodage de sortie. Valeurs prises en charge : `'base64'`, `'base64url'`, `'hex'`, `'binary'` (`latin1`).                                           |

## `toBase64` <a href="#tobase64" id="tobase64"></a>

Encode une chaîne en base64.

**Syntaxe**

```
toBase64(input);
```

**Exemple**

```
const toBase64 = require('toBase64');const base64Hello = toBase64('hello');
```

**Paramètres**

| Paramètre   | Type     | Description       |
| ----------- | -------- | ----------------- |
| **`input`** | *string* | Chaîne à encoder. |

## `JSON` <a href="#json" id="json"></a>

Renvoie un objet qui fournit des fonctions JSON.

La fonction `parse()` analyse une chaîne JSON pour construire la valeur ou l’objet qu’elle décrit. Si la valeur ne peut pas être analysée (JSON malformé), la fonction renvoie `undefined`. Si la valeur d’entrée n’est pas une chaîne, elle est convertie en chaîne.

La fonction `stringify()` convertit la valeur d’entrée en chaîne JSON. Si la valeur ne peut pas être convertie (par exemple, si l’objet contient un cycle), la méthode renvoie `undefined`.

**Syntaxe**

```
JSON.parse(yourString);
JSON.stringify(yourObject);
```

**Exemple**

```
const JSON = require('JSON');
// La chaîne JSON d'entrée est convertie en objet.
const object = JSON.parse('{"foo":"bar"}');
// L'objet d'entrée est converti en chaîne JSON.
const str = JSON.stringify({foo: 'bar'});
```

***

## `Math` <a href="#math" id="math"></a>

Un objet qui fournit des `Math` fonctions.

**Syntaxe**

```
const Math = require('Math');
// Récupérer la valeur absolue.
const absolute = Math.abs(-5);
// Arrondir la valeur d'entrée à l'entier inférieur le plus proche.
const roundedDown = Math.floor(4.6);
// Arrondir la valeur d'entrée à l'entier supérieur le plus proche.
const roundedUp = Math.ceil(2.1);
// Arrondir la valeur d'entrée à l'entier le plus proche.
const rounded = Math.round(4.2);
// Renvoyer l'argument le plus grand.
const biggest = Math.max(1, 4);
// Renvoyer l'argument le plus petit.
const smallest = Math.min(4, 5);
// Renvoyer le premier argument élevé à la puissance du second argument.
const powerful = Math.pow(4, 2);
// Renvoyer la racine carrée de l'argument.
const unsquared = Math.sqrt(81);
```

**Paramètres**

Les paramètres des fonctions Math sont convertis en nombres.

## `sendHttpGet` <a href="#sendhttpget" id="sendhttpget"></a>

Effectue une requête HTTP GET à l'URL spécifiée et appelle une fonction de rappel avec la réponse lorsque la requête se termine ou expire.

**Syntaxe**

```javascript
sendHttpGet(url[, callback[, options]]);
```

**Exemple**

```javascript
const sendHttpGet = require('sendHttpGet');
// Envoie une requête GET et désigne la réponse// en fonction de la réponse à la requête GET 
sendHttpGet('https://example.com/collect', function(statusCode, headers, body) {
    if (statusCode != 200) {yourCallbackFunction();}
}, {
    headers: {key: 'value'},
    timeout: 500
});
```

**Paramètres**

| Paramètre      | Type       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| -------------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`url`**      | *string*   | L'URL de la requête.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| **`callback`** | *fonction* | <p>Une fonction de rappel facultative à appeler lorsque la requête se termine, échoue ou expire.<br><br>Elle est appelée avec le <strong>code d'état de la réponse</strong>, les <strong>en-têtes de la réponse</strong>, et le <strong>corps de la réponse</strong> (ou undefined si la réponse ne comporte pas de corps).<br>Si la requête échoue (par exemple, URL non valide, absence de route vers l'hôte, échec de la négociation SSL, etc.), la fonction de rappel est appelée avec un <strong>code d'état de réponse égal à zéro</strong>, <strong>aucun en-tête</strong>, et un corps <strong>undefined</strong>.<br>Si la <code>'timeout'</code> option a été définie et que la requête a expiré, le callback sera appelé avec un <strong>code d’état de réponse de -1</strong>, <strong>aucun en-tête</strong>, et un corps <strong>undefined</strong>.</p> |
| **`options`**  | *objet*    | Options de requête facultatives. Les options prises en charge sont **headers**, **timeout**. Des options avancées peuvent être ajoutées dans **extraOptions**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |

#### **Options**

* **headers**: En-têtes de requête supplémentaires représentés sous forme d’objet.
* **timeout**: Délai d’attente, en millisecondes, avant l’abandon de la requête.
* **extraOptions**: Options avancées (ex. : {strictSSL:true})

## `sendHttpRequest` <a href="#sendhttprequest" id="sendhttprequest"></a>

Effectue une requête HTTP à l’URL spécifiée et appelle un callback avec la réponse une fois la requête terminée ou expirée.

**Syntaxe**

```
sendHttpRequest(url[, callback[, options[, body]]]);
```

**Exemple**

```javascript
const sendHttpRequest = require('sendHttpRequest');
const body = {
    user_type:'vip',
    account:'123'
};
// Envoie une requête POST 
sendHttpRequest('https://example.com/collect', function(statusCode, headers, body) {
    //votre code de callback...
}, {
    headers: {
        token: '123456789'
    },
    method: 'POST',
    timeout: 1000
},  JSON.stringify(body));
```

**Paramètres**

| Paramètre      | Type       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| -------------- | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **`url`**      | *string*   | L'URL de la requête.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| **`callback`** | *fonction* | <p>Une fonction de rappel facultative à appeler lorsque la requête se termine, échoue ou expire.<br><br>Elle est appelée avec le <strong>code d'état de la réponse</strong>, les <strong>en-têtes de la réponse</strong>, et le <strong>corps de la réponse</strong> (ou undefined si la réponse ne comporte pas de corps).<br>Si la requête échoue (par exemple, URL non valide, absence de route vers l'hôte, échec de la négociation SSL, etc.), la fonction de rappel est appelée avec un <strong>code d'état de réponse égal à zéro</strong>, <strong>aucun en-tête</strong>, et un corps <strong>undefined</strong>.<br>Si l’option 'timeout' a été définie et que la requête a expiré, le callback sera appelé avec un <strong>code d’état de réponse de -1</strong>, <strong>aucun en-tête</strong>, et un corps <strong>undefined</strong>.</p> |
| **`options`**  | *objet*    | Options de requête facultatives. Les options prises en charge sont : **headers**, **method**, et **timeout**. Les clés d’option inconnues sont ignorées. Des options avancées peuvent être ajoutées dans **extraOptions.**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| **`body`**     | *string*   | Corps de requête facultatif.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |

**Options**

* **headers**: En-têtes de requête supplémentaires.
* **method**: Méthode de la requête, GET par défaut.
* **timeout**: Délai d’attente, en millisecondes, avant l’abandon de la requête.
* **extraOptions**: Options avancées (ex. : {strictSSL:true})

## `md5Sync`

Calcule et renvoie le `md5` digest de l’entrée.

**Syntaxe**

```
md5Sync(input);
```

**Exemple**

```javascript
const md5Sync= require('md5Sync');
const email = {};
email.md5 = md5Sync(user.user_email);
sendHttpGet('https://example.com/collect?e5=' + email.md5);
```

## `templateDataStorage` <a href="#templatedatastorage" id="templatedatastorage"></a>

Le `templateDataStorage` helper permet de stocker et de récupérer temporairement des données, comme des jetons API, pendant l’exécution d’un script. Il est particulièrement utile pour mettre en cache des données réutilisables et réduire les appels API redondants. Les données stockées dans `templateDataStorage` persistent sur le serveur qui exécute le template. Comme les templates s’exécutent sur plusieurs serveurs, et que chaque serveur peut avoir plusieurs instances, il n’est pas garanti que les données stockées soient accessibles lors de toutes les exécutions ultérieures du template.

**Syntaxe**

```javascript
templateDataStorage.setItemCopy(key, value);
templateDataStorage.getItemCopy(key);
templateDataStorage.removeItemCopy(key);
```

**Exemple : gestion des jetons API**

```javascript
const sendHttpRequest = require('sendHttpRequest');
const templateDataStorage = require('templateDataStorage');

const tokenKey = 'apiToken';

function fetchNewToken(callback) {
  sendHttpRequest('https://example.com/api/token', function (status, _, body) {
    if (status === 200) {
      const { accessToken, expiresIn } = JSON.parse(body);
      const tokenData = { token: accessToken, expiry: Date.now() + expiresIn * 1000 };
      templateDataStorage.setItemCopy(tokenKey, tokenData);
      callback(accessToken);
    } else {
      callback(null);
    }
  }, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ clientId: 'id', clientSecret: 'secret' }) });
}

function sendEvent(eventData) {
  const cachedToken = templateDataStorage.getItemCopy(tokenKey);
  const token = cachedToken && cachedToken.expiry > Date.now() ? cachedToken.token : null;

  sendHttpRequest('https://example.com/api/events', function (status) {
    if (status === 401) {
      fetchNewToken(function (newToken) {
        if (newToken) {
          sendHttpRequest('https://example.com/api/events', () => {}, { method: 'POST', headers: { Authorization: `Bearer ${newToken}` }, body: JSON.stringify(eventData) });
        }
      });
    }
  }, { method: 'POST', headers: { Authorization: `Bearer ${token}` }, body: JSON.stringify(eventData) });
}

sendEvent({ eventName: 'purchase', value: 100 });
```

| Méthode                       | Description                                                                                 |
| ----------------------------- | ------------------------------------------------------------------------------------------- |
| **`setItemCopy(key, value)`** | Stocke une valeur sous la clé spécifiée. Remplace la valeur si la clé existe déjà.          |
| **`getItemCopy(key)`**        | Récupère la valeur associée à la clé spécifiée. Renvoie `undefined` si la clé n’existe pas. |
| **`removeItemCopy(key)`**     | Supprime la valeur associée à la clé spécifiée.                                             |

| Paramètre   | Type     | Description                                              |
| ----------- | -------- | -------------------------------------------------------- |
| **`key`**   | *string* | Identifiant unique des données à stocker ou à récupérer. |
| **`value`** | *any*    | Les données à stocker (pour `setItemCopy`).              |


---

# 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://doc.commandersact.com/fr/fonctionnalites/destinations/destination-builder/javascript-destination-builder/serverside-js-helpers.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.
