Classe lrServer¶

Role

Configuration et exécution d’un serveur LightREST (HTTP/HTTPS), routage, timeouts, headers globaux, hooks (niveau serveur et route), et chiffrement/déchiffrement d’identifiants.

Membres et propriétés

¶

Nom	Type	Usage
`IPAndPort`	chaîne	Interface réseau et port d’écoute. Si on indique une IP = 0.0.0.0, le serveur LightREST écoutera toutes les interfaces (dont 127.0.0.1). Exemple : 0.0.0.0:9000 ou 192.168.1.150:8888
`CustomData`	Variant	Données personnalisées associées au serveur, qui seront transmises automatiquement à chaque requête dans le propriété lrRequest:ServerCustomData. Utile par exemple pour y stocker des paramètres globaux et éviter de les relire à chaque exécution d'une requête.
`HTTPMode`	Énumération enHTTPMode	Mode de chiffrement de la communication. Selon le mode HTTP choisi, il conviendra de déterminer les paramètres de gestion du certificat SSL avec ces méthodes: - HTTP : Aucun chiffrement. Mode par défaut (utile pour développer en mode local, déconseillé en production) - HTTPS_CERT : SSL avec certificat fourni avec la méthode SetHTTPSCertificate - HTTPS_SELF : SSL avec certificat auto-généré, paramètres fournis avec la méthode SetSelfCertificateParameters - HTTPS_LETS_ENCRYPT : SSL avec certificat Let's Encrypt auto-renouvelé, paramètres fournis avec la méthode SetLetsEncryptParameters
`State`	Enumération enServerState	État courant du serveur (lecture seule). Valeurs possibles : STARTING, STARTED, STOPPING, STOPPED.
`TempFolder`	chaîne	Répertoire temporaire utilisé par le serveur. Par défaut = le répertoire temporaire du user (retourné par la fonction WinDev fRépertoireTemp()). Sert au stockage de fichiers temporaires par le composant.

Ciphering & RegEx¶

Nom	Type	Usage
`CipheringKey`	Buffer	Clé de chiffrement utilisée par les méthodes CipherID et DecipherID. Une clé est définie par défaut lors de l'instanciation de l'objet. En cas de redémarrage du serveur, une nouvelle clé sera affectée. Donc si des clients envoient des requêtes REST comprenant des IDs chiffrés avec la clé initiale, ceux-ci seront inexploitables. Pour s'en prémunir, il faut donc affecter une clé fixe, ou bien avec une rotation régulière; ainsi les IDs chiffrées resteront valides en cas de redémarrage.
`NoRegex`	Booleen	Désactive la vérification RegEx de la syntaxe des routes lors de leur ajout avec la méthode :AddRoute. Valeur par défaut = Faux

Timeouts & MaxRequests¶

Nom	Type	Usage
`IdleTimeout`	Durée	Timeout d’inactivité entre deux requêtes sur une même connexion HTTP (keep-alive). Valeur par défaut = 60s (constante :DEFAULT_IDLE_TIMEOUT) Ce délai s’applique uniquement lorsqu’aucune requête n’est en cours et que le serveur attend une nouvelle requête sur la même connexion. Lorsque la rêquête suivante arrive, elle est traitée immédiatement dans renégociation de la connexion, donc gain de performances. En cas de dépassement du délai, le serveur ferme proprement la connexion et libère les ressources associées. IdleTimeout ne limite pas la durée d’exécution maximale d’une route. Pour cela, utiliser WriteTimeout (et/ou un timeout spécifique à la route).
`ReadTimeout`	Durée	Timeout de lecture sur la connexion du client REST. Valeur par défaut = 30s (constante :DEFAULT_READ_TIMEOUT) En cas de dépassement, les ressources sont liblibérées côté serveur. Aucune erreur n'est renvoyée au client (car on considère que la connexion est tombée, donc communication impossible).
`RequestTimeout`	Durée	Timeout par défaut appliqué aux routes. Valeur par défaut = 30s (constante :DEFAULT_REQUEST_TIMEOUT) En cas de dépassement, l'exécution du Handler REST WinDev est annulée et une erreur HTTP 408 (StatusRequestTimeout) est envoyée au client. Peut être surchargé spécifiquement sur une route avec la propriété lrRoute:Timeout
`WriteTimeout`	Durée	Timeout d'écriture sur la connexion du client REST. Valeur par défaut = 30s (constante :DEFAULT_WRITE_TIMEOUT). En cas de dépassement, les ressources sont libérées côté serveur. Aucune erreur n'est renvoyée au client (car on considère que la connexion est tombée, donc communication impossible). WriteTimeout doit être supérieur au plus grand timeout des routes (ou du serveur) + une marge pour laisser le temps d'envoyer les entêtes. Si WriteTimeout < Timeout route, la connexion avec le client sera coupée avant que le timeout soit arrivé à échéance.
`MaxRequests`	entier	Nombre maximum de requêtes traitées simultanément par le serveur. Valeur par défaut : 100 (constante :DEFAULT_MAX_REQUEST) Permet d'éviter la surcharge du serveur. Lorsque le nombre de requête maximal est atteint, une erreur HTTP 503 (StatusServiceUnavailable) est envoyée au client.

Monitoring & log¶

Nom	Type	Usage
`Logger`	booléen	Active ou désactive le logger interne du moteur LightREST. Par défaut = Faux. Chronophage et verbeux, à n'utiliser principalement qu'en phase de debug du composant. Ecrit par défaut dans le fichier lr_log situé dans le répertoire de l'exécutable. Pour indiquer un autre nom, utiliser la propriété :LoggerFile.
`LoggerFile`	chaîne	Chemin du fichier de log lorsque le logger est activé.
`Monitoring`	booléen	Active le monitoring des requêtes. Valeur par défaut = Faux Ajoute dans le HEADER de chaque réponse les temps : - global du traitement de la requête dans Chrono-Global-Millisec - d'exécution du Handler REST WinDev dans Chrono-Methode-Millisec
`WindevErrorDetails`	entier	Niveau de détail pour des erreurs retournées au client. Défaut = ErrComplet (constante :DEFAULT_WINDEV_ERROR_LEVEL) Contrôle la verbosité des erreurs WinDev envoyées au client REST. LightREST récupère (dans la mesure du possible) les erreurs et exceptions survenues lors de l'exécution des méthodes REST, et envoie automatiquement au client une erreur HTTP 500 (StatusInternalServerError) accompagné du contenu de ErreurInfo() ou ExceptionInfo(). Le membre :WindevErrorDetails permet de choisir le niveau de détail de l'erreur envoyée, pour éviter par exemple d'exposer des informations techniques sensibles). Il doit correspondre à une des constantes Err* supportées par WinDev^®^.

Types

enServerState — État du serveur

🏷️ Type

Enumération

📘 Présentation

Indique l'état actuel du serveur LightREST. Type retourné par la propriété propriété :State

📋 Valeurs

Valeur	Usage
`STARTING`	En cours de démarrage
`STARTED`	Démarré, prêt pour exécuter les requêtes
`STOPPING`	En cours d'arrêt (généralement en attente de terminaison des requêtes en cours)
`STOPPED`	Arrêté

lrSSLCertificate — Définition du certificat SSL

🏷️ Type

Structure

📘 Présentation

Détermine le contenu du certificat SSL et de sa clé privée lorsque :HttpMode = HTTPS_CERTIFICATE. Structure passée en paramètre à la méthode :SetHTTPSCertificate().

🔧 Structure

Nom	Type	Usage
`Certificate`	chaîne	Contenu du certificat SSL
`PrivateKey`	chaîne	Clé privée

stLogger — Paramètres de journalisation

🏷️ Type

Structure

📘 Présentation

Paramètres de la journalisation bas niveau (moteur LightREST GO)

🔧 Structure

Nom	Type	Usage
`bLogger`	booléen	Activation de la journalisation Chronophage, à réserver au debug du composant.
`sLoggerFile`	chaîne	Nom du fichier de log

lrLetsEncrypt — Paramètres Let's Encrypt

🏷️ Type

Structure

📘 Présentation

Structure passée en paramètre à la méthode :SetLetsEncryptParameters()

🔧 Structure

Nom	Type	Usage
`Domains`	tableau de chaînes	Domaines pour lesquels le certificat Let's Encrypt doit être généré.
`Email`	chaîne	Email de l'administrateur
`CertificatePath`	chaîne	Chemin de stockage du certificat
`RenewDelay`	entier	Délai de renouvellement (en nombre de jours avant l'expiration)

lrSelfCertificate — Paramètres du certificat auto-signé

🏷️ Type

Structure

📘 Présentation

Structure passée en paramètre à la méthode :SetSelfCertificateParameters()

🔧 Structure

Nom	Type	Usage
`KeySize`	entier	Taille de la clé (2048 par défaut)

enHTTPMode — Mode de fonctionnement HTTP/HTTPS

🏷️ Type

Enumération

📘 Présentation

Permet de déterminer le mode de fonctionnement HTTP/HTTPS. Voir la propriété :HTTPMode

📋 Valeurs

Valeur	Usage
`HTTP`	Pas de chiffrement de la communication, pas de certificat
`HTTPS_CERT`	Certificat SSL fourni (voir :SetHTTPSCertificate())
`HTTPS_SELF`	Certificat SSL auto généré. (voir :SetSelfCertificateParameters())
`HTTPS_LETS_ENCRYPT`	Certificat Let's Encrypt (voir :SetLetsEncryptParameters())

Constantes

Nom	Type	Usage
`ROUTE_REGEX`	chaîne	Expression régulière pour vérification de la syntaxe des routes REST par la méthode :AddRoute() Valeur : "^/($\|([A-Za-z0-9_-]+\|{[A-Za-z0-9_]+})(/([A-Za-z0-9_-]+\|{[A-Za-z0-9_]+}))*$)"

Méthodes HTTP¶

Nom	Type	Usage
`MethodGET`	chaîne	Méthode REST GET
`MethodPOST`	chaîne	Méthode REST POST
`MethodPUT`	chaîne	Méthode REST PUT
`MethodDELETE`	chaîne	Méthode REST DELETE
`MethodHEAD`	chaîne	Méthode REST HEAD
`MethodPATCH`	chaîne	Méthode REST PATCH
`MethodOPTIONS`	chaîne	Méthode REST OPTIONS
`MethodTRACE`	chaîne	Méthode REST TRACE

Valeurs par défaut¶

Nom	Type	Usage
`DEFAULT_MAX_REQUEST`	entier	Valeur par défaut du membre :MaxRequests
`DEFAULT_REQUEST_TIMEOUT`	Durée	Valeur par défaut du membre :RequestTimeout
`DEFAULT_READ_TIMEOUT`	Durée	Valeur par défaut du membre :ReadTimeout
`DEFAULT_WRITE_TIMEOUT`	Durée	Valeur par défaut du membre :WriteTimeout
`DEFAULT_IDLE_TIMEOUT`	Durée	Valeur par défaut du membre :IdleTimeout
`DEFAULT_WINDEV_ERROR_LEVEL`	Entier	Valeur par défaut du membre :WindevErrorDetails

Méthodes¶

Routing / Hooks¶

AddRoute

📘 Présentation

Ajoute une route REST au serveur en lui associant une fonction Handler.

Avant ajout, la syntaxe de la route est vérifiée avec une expression régulière (:ROUTE_REGEX). Pour désactiver cette vérification, positionner la propriété :NoRegex=vrai.

🧩 Prototypage

Syntaxe 1            : AddRoute(poRoute est objet lrRoute) : (booléen, chaîne)
Syntaxe 2 (dépréciée): AddRoute(pRoute est chaine, pMethod est chaine, pFunction est procedure(lrRequest), pTimeout est duree = :RequestTimeout) : (booléen, chaîne)

🔧 Paramètres

Nom	Type	Usage
`poRoute`	Objet lrRoute	Définition complète de la route (méthode, route, handler, timeout, hooks, ...)

↩️ Valeurs retournées

Type	Usage
booléen	Vrai si la route est ajoutée.
chaîne	Message d’erreur (vide si succès).

🧪 Exemple

Démarrage d'un serveur LightREST sur le port 9876
Création d'une route /ping qui renvoie l'heure système et l'hôte du client REST

oServer est objet lrServer
oRoute  est objet lrRoute
bOK     est booléen
sErr    est chaîne

oServer:IPAndPort = "127.0.0.1:9876"

oRoute.Method  = lrRoute::MethodGET
oRoute.Route   = "/ping"
oRoute.Handler = piPing

(bOK, sErr) = oServer:AddRoute(oRoute)
SI PAS bOK ALORS
    Erreur("Erreur lors de la création de la route : ", sErr)
    RETOUR
FIN

(bOK, sErr) = oServer:Start()
SI PAS bOK ALORS
    Erreur("Erreur lors du démarrage : ", sErr)
    RETOUR
FIN

Info("Call http://[%oServer:IPAndPort%][%oRoute:Route%]", CRLF+"Click on OK to close LightREST server")

oServer:Terminate()

////////////////////////////////////////////

PROCEDURE INTERNE piPing(pRequest est objet lrRequest) : objet lrResponse
    oResp est objet lrResponse

    oResp.Body        = "Sending pong to host " + pRequest.Host + " at " + DateVersChaîne(DateHeureSys())
    oResp.ContentType = lrResponse::ContentTXT
    oResp:Status      = lrResponse::StatusOK

    RENVOYER oResp
FIN

AddHook

📘 Présentation

Ajout de hook(s) serveur (interception d'événements). Déclenchement automatique de(s) hook en fonction des évènements définis dans chaque objet lrHook (ouverture d'une connexion, réception requête, avant/après méthode, résultat, warning, error, panic, etc...).

Pour un hook spécifique à une seule route (ou un ordre différent), utiliser lrRoute:AddHook().

🧩 Prototypage

AddHook(poHook est objet lrHook, [poHook2 est objet lrHook, poHook3, ....])

🔧 Paramètres

Nom	Type	Usage
`poHook`	Objet lrHook	Hook(s) à ajouter (type d’évènements, handler, options d’action sur la requête/réponse).

↩️ Valeurs retournées

(aucune)

🧪 Exemple

Ajout d’un hook global
Le handler de Hook, lancé automatiquement à chaque réception d'une requête REST, ajoute un header sur les réponses
Retourne EVE_OK pour poursuivre l'exécution

oServer est objet lrServer
oHook   est objet lrHook

oHook:Events  = lrHook::EVE_RECEIVED
oHook:Handler = fnHook

oServer:AddHook(oHook)

PROCEDURE INTERNE fnHook(pEventInfo est lrHook:EventInfo) : lrHook:EventReturn)

  // pEventInfo dépend de lrHook (évènement, request, response, message...)
  SI pEventInfo.Response <> Null ALORS
    pEventInfo.Response:SetHeaderValue("X-LightREST-Hook", "1")
  FIN

  RENVOYER lrHook::EVE_OK
FIN

SetAuthenticationCheckFunction

📘 Présentation

(Déprécié)
Définit une fonction appelée pour valider l’authentification avant l’exécution de la route.
Si la fonction de contrôle retourne Faux, la requête est rejetée avec un statut 401 - StatusUnauthorized.

Préférer un hook ajouté via :AddHook() ou lrRoute:AddHook() ce qui permet un filtrage fin et un ordre d’exécution contrôlé.

🧩 Prototypage

SetAuthenticationCheckFunction(pFunction est procédure)

🔧 Paramètres

Nom	Type	Usage
`pFunction`	procédure	Procédure de contrôle qui reçoit un lrRequest et retourne un booléen (Vrai/Faux).

↩️ Valeurs retournées

(aucune)

🧪 Exemple

Ajout d’un contrôle d’accès simple basé sur un header X-API-KEY
La fonction sera appelée automatiquement avant chaque exécution de requête REST

oServer est objet lrServer

oServer:SetAuthenticationCheckFunction(fnAuth)

PROCEDURE INTERNE fnAuth(pRequest est objet lrRequest) : booléen
    sKey est chaîne = pRequest:GetHeaderValue("X-API-KEY")
    RENVOYER (sKey="MY_SECRET_KEY")
FIN

Contrôle du serveur¶

Start

📘 Présentation

Démarre le serveur LigthREST

🧩 Prototypage

Start() : (booléen, chaîne)

🔧 Paramètres

(aucun)

↩️ Valeurs retournées

Type	Usage
booléen	Vrai si démarrage réussi.
chaîne	Message d’erreur (vide si succès).

🧪 Exemple

Démarrage d'un serveur LightREST sur le port 9876
Création d'une route /ping qui renvoie l'heure système et l'hôte du client REST

oServer est objet lrServer
oRoute  est objet lrRoute
bOK     est booléen
sErr    est chaîne

oServer:IPAndPort = "127.0.0.1:9876"

oRoute.Method  = lrRoute::MethodGET
oRoute.Route   = "/ping"
oRoute.Handler = piPing

(bOK, sErr) = oServer:AddRoute(oRoute)
SI PAS bOK ALORS
    Erreur("Erreur lors de la création de la route : ", sErr)
    RETOUR
FIN

(bOK, sErr) = oServer:Start()
SI PAS bOK ALORS
    Erreur("Erreur lors du démarrage : ", sErr)
    RETOUR
FIN

Info("Call http://[%oServer:IPAndPort%][%oRoute:Route%]", CRLF+"Click on OK to close LightREST server")

oServer:Terminate()

////////////////////////////////////////////

PROCEDURE INTERNE piPing(pRequest est objet lrRequest) : objet lrResponse
    oResp est objet lrResponse

    oResp.Body        = "Sending pong to host " + pRequest.Host + " at " + DateVersChaîne(DateHeureSys())
    oResp.ContentType = lrResponse::ContentTXT
    oResp:Status      = lrResponse::StatusOK

    RENVOYER oResp
FIN

Kill

📘 Présentation

Arrêt forcé du serveur.

Les routes REST en cours d'exécution sont interrompues abruptement. Pour un arrêt "propre", préférer la méthode :Terminate()

🧩 Prototypage

Kill() : (booléen, chaîne)

🔧 Paramètres

(aucun)

↩️ Valeurs retournées

Type	Usage
booléen	Vrai si arrêt forcé réussi.
chaîne	Message d’erreur (vide si succès).

🧪 Exemple

Arrêt abrupt du serveur
À utiliser en dernier recours (debug / shutdown forcé)

oSrv est objet lrServer
bOK  est booléen
sErr est chaîne

(bOK, sErr) = oSrv:Kill()
SI PAS bOK ALORS
  ExceptionDeclenche(exceptionAvertissement, sErr)
FIN

Terminate

📘 Présentation

Arrêt propre du serveur.

Les routes REST en cours d'exécution sont complétées avant arrêt (ou timeout). Pour un arrêt imémdiat, utiliser la méthode :Kill()

🧩 Prototypage

Terminate(pTimeout est Durée = :RequestTimeout) : (booléen, chaîne)

🔧 Paramètres

Nom	Type	Usage
`pTimeout`	Durée	Durée maximale d’attente.

↩️ Valeurs retournées

Type	Usage
booléen	Vrai si arrêt réussi.
chaîne	Message d’erreur (vide si succès).

🧪 Exemple

Arrêt propre du serveur (attente fin des requêtes)
Timeout = 10 secondes

oSrv est objet lrServer
bOK  est booléen
sErr est chaîne

(bOK, sErr) = oSrv:Terminate(10s)

SI PAS bOK ALORS
  ExceptionDeclenche(exceptionAvertissement, sErr)
FIN

SetLoggerOn

📘 Présentation

Active le logger interne et définit le fichier de log.

🧩 Prototypage

SetLoggerOn(pLoggerFile est chaîne) : (booléen, chaîne)

🔧 Paramètres

Nom	Type	Usage
`pLoggerFile`	chaîne	Chemin du fichier de log (vide => fichier par défaut).

↩️ Valeurs retournées

Type	Usage
booléen	Vrai si activation OK.
chaîne	Message d’erreur (vide si succès).

🧪 Exemple

Activation du logger LightREST dans un fichier
Utile pour diagnostiquer un problème en phase de debug

oServer est objet lrServer
bOK     est booléen
sErr    est chaîne

(bOK, sErr) = oServer:SetLoggerOn("c:\temp\lr_log.txt")
SI PAS bOK ALORS
  Erreur("Logger not enabled: ", sErr)
FIN

SetLoggerOff

📘 Présentation

Désactive le logger interne.

🧩 Prototypage

SetLoggerOff() : (booléen, chaîne)

🔧 Paramètres

(aucun)

↩️ Valeurs retournées

Type	Usage
booléen	Vrai si désactivation OK.
chaîne	Message d’erreur (vide si succès).

🧪 Exemple

Désactivation du logger LightREST
À utiliser après une phase de debug pour retrouver les performances nominales

oServer est objet lrServer
bOK     est booléen
sErr    est chaîne

(bOK, sErr) = oServer:SetLoggerOff()
SI PAS bOK ALORS
  Erreur("Logger not disabled: ", sErr)
FIN

ID Ciphering¶

CipherID

📘 Présentation

Chiffre un identifiant de la base de données. Évite le pillage des données en utilisant par exemple une route /{id} en incrémentant simplement une valeur.

La méthode CipherID transformera une simple valeur numérique en un long identifiant chiffré. Il devient alors compliqué voire impossible d'aspirer l'intégralité de la base de données sans connaître la clé de chiffrement.

 Exemple avec une même clé de chiffrement :

 L'ID 1 devient 03980608-5abe9581-7fee65e9-194ae106
 L'ID 2 devient d3e8b3a7-94319945-f7484a0d-aecf776c

Pour chiffrer plusieurs identifiants il est beaucoup plus rapide d'appeler une fois CipherIDs sur un tableau que de boucler unitairement sur CipherID.

Note

La clé de chiffrement des IDs est stockée dans le membre :CipheringKey et initialisée aléatoirement à l'instanciation de l'objet. Cela signifie qu'en cas de redémarrage du serveur, les identifiants chiffrés déjà transmis aux clients seront inexploitables. Pour éviter ceci, il suffira de donner une clé de chiffrement fixe au membre :CipheringKey (dans ce cas on peut imaginer un changement régulier du contenu de la clé, par exemple quotidiennement).

🧩 Prototypage

CipherID(pIDName est chaîne, pIDValue est chaîne) : chaîne

🔧 Paramètres

Nom	Type	Usage
`pIDName`	chaîne	Nom logique de l’identifiant. Utile pour discriminer les IDs identiques sur des tables différents. Généralement égal au nom de la table concernée. Ainsi l'ID 123 des tables CLIENT et USER ne seront pas chiffrés de façon identique.
`pIDValue`	chaîne	Valeur à chiffrer (identifiant unique ou autre valeur à dissimuler)

↩️ Valeurs retournées

Type	Usage
chaîne	Valeur chiffrée format xxxxxxxx-xxxxxxxx-xxxxxxxx-xxxxxxxx

🧪 Exemple

Récupération du nom d'un client passé dans l'URL (exemple https://monapi.fr/client?name=dupont)
Envoie une erreur StatusBadRequest si le paramètre n'a pas été reçu
Recherche de l'enregistrement correspondant (si KO, retour StatusNotFound au client)
Conversion de l'enregistrement en Variant (méthode lrResponse:RecordToVariant)
Chiffrement de l'ID de la base de données
Envoi des données au format JSON

FUNCTION ClientGETByName(pRequest est objet lrRequest, poResponse est objet lrResponse)

vClient   est variant
sName     est chaine = pRequest:GetURLValue("name")

SI sName="" ALORS
  poResponse:Body          = "No value provided"
  poResponse:ContentType   = lrResponse::ContentTXT
  poResponse:Status        = lrResponse::StatusBadRequest
SINON
  SI hLitRecherchePremier("CLIENT", "NAME", sName) ALORS
      vClient = lrResponse::RecordToVariant("CLIENT", "NAME,FIRSTNAME,ADRESS,ZIP,CITY")

      vClient.ID = oServer:CipherID("CLIENT", CLIENT.ID)

      poResponse:Body        = VariantVersJSON(vClient)
      poResponse:ContentType = lrResponse::ContentJSON
      poResponse:Status      = lrResponse::StatusOK
  SINON
      poResponse:Status = lrResponse::StatusNotFound
  FIN
FIN

CipherIDs

📘 Présentation

Chiffre un tableau d'identifiants de la base de données.

Pour chiffrer plusieurs identifiants il est beaucoup plus rapide d'appeler une fois CipherIDs sur un tableau que de boucler unitairement sur CipherID.

🧩 Prototypage

Syntaxe 1 : CipherIDs(pIDName est chaîne, pIDValues est tableau de chaines) : tableau de chaînes
Syntaxe 2 : CipherIDs(pIDName est chaîne, pArray est tableau, pClearCol est chaîne, pCipheredCol est chaîne=pClearCol)

🔧 Paramètres

Nom	Type	Usage
`pIDName`	chaîne	Nom logique de l’identifiant.
`pIDValues`	tableau de chaînes	IDs à chiffrer (syntaxe 1).
`pArray`	tableau	Tableau d'éléments contenant l'ID (syntaxe 2).
`pClearCol`	chaîne	Nom du membre qui contient l'ID clair (syntaxe 2).
`pCipheredCol`	chaîne	Nom du membre qui contiendra l'ID chiffré (syntaxe 2).

↩️ Valeurs retournées

Type	Usage
tableau de chaînes (syntaxe 1)	IDs chiffrés format xxxxxxxx-xxxxxxxx-xxxxxxxx-xxxxxxxx.
Aucun (syntaxe 2)	Le tableau pArray est modifié sur place.

🧪 Exemple

Chiffrement d'une liste d'IDs (optimisé par lot)
Renvoi d'un tableau de chaînes chiffrées.

oServer est objet lrServer
tIDs    est tableau de chaînes
tEnc    est tableau de chaînes

tIDs.Ajoute("1")
tIDs.Ajoute("2")
tIDs.Ajoute("3")

tEnc = oServer:CipherIDs("CLIENT", tIDs)

DecipherID

📘 Présentation

Déchiffre un identifiant.

🧩 Prototypage

DecipherID(pIDName est chaîne, pIDValue est chaîne) : chaîne

🔧 Paramètres

Nom	Type	Usage
`pIDName`	chaîne	Nom logique de l’identifiant.
`pIDValue`	chaîne	Valeur chiffrée format xxxxxxxx-xxxxxxxx-xxxxxxxx-xxxxxxxx.

↩️ Valeurs retournées

Type	Usage
chaîne	Valeur déchiffrée (chaîne vide si échec).

🧪 Exemple

Récupération d'un ID chiffré dans la route /client/{id}
Déchiffrement de l'ID
Suppression de l'enregistrement

FONCTION ClientDELETE(pRequest est objet lrRequest, poResponse est objet lrResponse)

sID       est chaine = pRequest:GetRouteValue("id")

SI sID="" ALORS
  poResponse:Body        = "No ID provided"
  poResponse:ContentType = lrResponse::ContentTXT
  poResponse:Status      = lrResponse::StatusBadRequest
SINON
  sID = oServer:DecipherID("CLIENT", sID)
  SI sID="" ALORS
      poResponse:Body        = "illegal or expired ID provided"
      poResponse:ContentType = lrResponse::ContentTXT
      poResponse:Status      = lrResponse::StatusBadRequest
  SINON
      SI hLitRecherchePremier("CLIENT", "ID", sID) ALORS
          hSupprime("CLIENT")
          poResponse:Status = lrResponse::StatusOK
      SINON
          poResponse:Status = lrResponse::StatusNotFound
      FIN
  FIN
FIN

DecipherIDs

📘 Présentation

Déchiffre plusieurs identifiants.

🧩 Prototypage

Syntaxe 1 : DecipherIDs(pIDName est chaîne, pIDValues) : tableau de chaînes
Syntaxe 2 : DecipherIDs(pArray, pIDName est chaîne, pCipheredCol est chaîne, pClearCol est chaîne=pCipheredCol)

🔧 Paramètres

Nom	Type	Usage
`pIDName`	chaîne	Nom logique de l’identifiant.
`pIDValues`	tableau	Valeurs chiffrées (syntaxe 1).
`pArray`	tableau	Tableau d'éléments contenant les IDs chiffrés (syntaxe 2).
`pCipheredCol`	chaîne	Nom du membre contenant l'ID chiffré (syntaxe 2).
`pClearCol`	chaîne	Nom du membre qui contiendra l'ID clair (syntaxe 2).

↩️ Valeurs retournées

Type	Usage
tableau de chaînes (syntaxe 1)	Valeurs déchiffrées format xxxxxxxx-xxxxxxxx-xxxxxxxx-xxxxxxxx.
Aucun (syntaxe 2)	Le tableau pArray est modifié sur place.

🧪 Exemple

Déchiffrement par lot d'un tableau d'IDs
Utile quand tu reçois plusieurs IDs chiffrés dans une même requête

oServer est objet lrServer
tEnc    est tableau de chaînes
tPlain  est tableau de chaînes

tEnc.Ajoute("03980608-5abe9581-7fee65e9-194ae106")
tEnc.Ajoute("d3e8b3a7-94319945-f7484a0d-aecf776c")

tPlain = oServer:DecipherIDs("CLIENT", tEnc)

HTTP Headers¶

SetGlobalHeader

📘 Présentation

Ajoute (ou remplace) un header HTTP global envoyé dans toutes les réponses,

🧩 Prototypage

SetGlobalHeader(pHeader est chaîne, pValue est chaîne)

🔧 Paramètres

Nom	Type	Usage
`pHeader`	chaîne	Nom du header (ex: X-App-Version).
`pValue`	chaîne	Valeur.

↩️ Valeurs retournées

(aucune)

🧪 Exemple

Ajout d’un header global X-App-Version sur toutes les routes
Utile pour le debug client et la traçabilité

oServer est objet lrServer
oServer:SetGlobalHeader("X-App-Version", "LightREST v3")

SetGlobalHeaders

📘 Présentation

Copie un ensemble de headers HTTP globaux (tableau associatif) vers le serveur.

🧩 Prototypage

SetGlobalHeaders(pGlobalHeaders est tableau associatif de chaînes)

🔧 Paramètres

Nom	Type	Usage
`pGlobalHeaders`	tableau associatif de chaînes	Tableau des headers globaux (Tag => Valeur).

↩️ Valeurs retournées

(aucune)

🧪 Exemple

Définition de plusieurs headers globaux en une seule opération
Pratique pour centraliser version, cache, options d’application

oServer est objet lrServer
tas     est tableau associatif de chaînes

tas["X-App-Version"] = "LightREST v3"
tas["X-Server"]      = "CODE LINE"
tas["Cache-Control"] = "no-store"

oServer:SetGlobalHeaders(tas)

SetGlobalOptionsHeader

📘 Présentation

Ajoute (ou remplace) un header global pour les réponses OPTIONS (CORS).

🧩 Prototypage

SetGlobalOptionsHeader(pHeader est chaîne, pValue est chaîne)

🔧 Paramètres

Nom	Type	Usage
`pHeader`	chaîne	Nom du header OPTIONS (ex: Access-Control-Allow-Origin).
`pValue`	chaîne	Valeur.

↩️ Valeurs retournées

(aucune)

🧪 Exemple

Ajout d’un header CORS global pour les réponses OPTIONS
Permet aux clients navigateur d’appeler l’API cross-domain

oServer est objet lrServer
oServer:SetGlobalOptionsHeader("Access-Control-Allow-Origin", "*")

SetGlobalOptionsHeaders

📘 Présentation

Copie un ensemble de headers globaux pour OPTIONS (CORS).

🧩 Prototypage

SetGlobalOptionsHeaders(pGlobalOptionsHeaders est tableau associatif de chaînes)

🔧 Paramètres

Nom	Type	Usage
`pGlobalOptionsHeaders`	tableau associatif de chaînes	Tableau des headers OPTIONS globaux (Tag => Valeur).

↩️ Valeurs retournées

(aucune)

🧪 Exemple

Définition d’un jeu complet de headers CORS (OPTIONS)
Autorise méthodes et headers personnalisés

oServer est objet lrServer
tasOpt  est tableau associatif de chaînes

tasOpt["Access-Control-Allow-Origin"]  = "*"
tasOpt["Access-Control-Allow-Methods"] = "GET,POST,PUT,DELETE,OPTIONS"
tasOpt["Access-Control-Allow-Headers"] = "Content-Type, X-API-KEY, SESSION_ID"

oServer:SetGlobalOptionsHeaders(tasOpt)

Certificats¶

SetHTTPSCertificate

📘 Présentation

Définit le certificat SSL et la clé privée (mode HTTPS_CERT).

🧩 Prototypage

Syntaxe 1 : SetHTTPSCertificate(pCertificate est chaîne, pPrivateKey est chaîne)
Syntaxe 2 : SetHTTPSCertificate(pCertificate est lrSSLCertificate)

🔧 Paramètres

Nom	Type	Usage
`pCertificate`	chaîne / lrSSLCertificate	Certificat (chemin, contenu, ou structure lrSSLCertificate).
`pPrivateKey`	chaîne	Clé privée (syntaxe 1).

↩️ Valeurs retournées

(aucune)

🧪 Exemple

Passage du serveur en HTTPS avec certificat fourni (HTTPS_CERT)
Définition certificat + clé privée
Démarrage du serveur

oServer est objet lrServer
bOK     est booléen
sErr    est chaîne

oServer:IPAndPort = "0.0.0.0:443"
oServer:HTTPMode  = lrServer::HTTPS_CERT

oServer:SetHTTPSCertificate(fChargeTexte("c:\ssl\server.crt"), fChargeTexte("c:\ssl\server.key"))

(bOK, sErr) = oServer:Start()
SI PAS bOK ALORS
  Erreur("HTTPS start failed: ", sErr)
FIN

SetLetsEncryptParameters

📘 Présentation

Configure les paramètres Let's Encrypt (mode HTTPS_LETS_ENCRYPT).

🧩 Prototypage

Syntaxe 1 : SetLetsEncryptParameters(pDomain est chaîne, pEmail est chaîne, pCertificatePath est chaîne = "", pRenewDelay est entier = 0)
Syntaxe 2 : SetLetsEncryptParameters(pDomains est tableau de chaînes, pEmail est chaîne, pCertificatePath est chaîne = "", pRenewDelay est entier = 0)
Syntaxe 3 : SetLetsEncryptParameters(pLetsEncrypt est lrLetsEncrypt)

🔧 Paramètres

Nom	Type	Usage
`pDomain`	chaîne	Domaine principal (syntaxe 1).
`pDomains`	tableau de chaînes	Liste de domaines (syntaxe 2).
`pEmail`	chaîne	Email Let's Encrypt (syntaxe 1 et 2).
`pCertificatePath`	chaîne	Chemin de stockage des certificats (syntaxe 1 et 2, optionnel).
`pRenewDelay`	entier	Délai de renouvellement (syntaxe 1 et 2, optionnel).
`pLetsEncrypt`	lrLetsEncrypt	Structure complète (syntaxe 3).

↩️ Valeurs retournées

(aucune)

🧪 Exemple

Passage en HTTPS avec Let's Encrypt (certificats auto-renouvelés)
Définition du domaine et de l'email
Démarrage du serveur

oServer est objet lrServer
bOK     est booléen
sErr    est chaîne
stLets  est lrLetsEncrypt

oServer:IPAndPort = "0.0.0.0:443"
oServer:HTTPMode  = lrServer::HTTPS_LETS_ENCRYPT

stLets.Domains.Ajoute("api.mondomaine.fr")
stLets.Domains.Ajoute("private.mondomaine.fr")
stLets.Email           = "admin@mondomaine.fr"
stLets.CertificatePath = "./certificates"
stLets.RenewDelay      = 30

oServer:SetLetsEncryptParameters(stLets)

(bOK, sErr) = oServer:Start()
SI PAS bOK ALORS
  Erreur("LetsEncrypt start failed: ", sErr)
FIN

SetSelfCertificateParameters

📘 Présentation

Configure les paramètres du certificat auto-généré (mode HTTPS_SELF).

🧩 Prototypage

SetSelfCertificateParameters(plrSelfCertificate est lrSelfCertificate)

🔧 Paramètres

Nom	Type	Usage
`plrSelfCertificate`	lrSelfCertificate	Structure contenant les paramètres du certificat auto-généré (ex: KeySize).

↩️ Valeurs retournées

(aucune)

🧪 Exemple

Passage en HTTPS avec certificat auto-généré (HTTPS_SELF)
Définition de la taille de clé
Démarrage du serveur

oServer est objet lrServer
stSelf  est lrSelfCertificate
bOK     est booléen
sErr    est chaîne

oServer:IPAndPort = "0.0.0.0:8443"
oServer:HTTPMode  = lrServer::HTTPS_SELF

stSelf.KeySize = 2048

oServer:SetSelfCertificateParameters(stSelf)

(bOK, sErr) = oServer:Start()
SI PAS bOK ALORS
  Erreur("HTTPS self start failed: ", sErr)
FIN