Introduction

Le serveur XTEND dispose d'une fonction de Scripting qui permet d'exécuter des scripts JavaScript sur le serveur pour construire dynamiquement des pages HTML de la même manière qu'un script PHP.

Nous recommandons d'utiliser le scripting lorsque le code HTML que l'on souhaite générer ne peut pas être traité par l'insertion de tokens.

Les scripts serveurs peuvent être aussi exécutés par des requêtes AJAX émises à partir du navigateur.

Insertion du script

Le script doit être inséré dans la page HTML à l'intérieur d'un tag <script> à l'endroit où l'on souhaite générer le code HTML.

Pour identifier un script serveur on doit placer un token champs dans le tag <script adx="MyTokenField"></script>.

L'exemple ci dessous affiche une page avec le texte Texte généré par un script serveur.

<html><body>
<script adx="TestScript1">
    print("<b>Texte généré par un script serveur</b>");
</script>
</body></html>

Utilisation de libraries

Le moteur de scripting XTEND permet d'inclure des librairies (fichier JavaScript) dans le code via l'instruction #include 'pathLib'.

pathLib est le chemin d'accès du fichier libraire par rapport au répertoire racine des scripts serveur défini dans la fiche de paramétrage du site.

<script adx="TestScript2">
    #include 'libs\xtdWsvc.js''
</script>

Librarie livrées en standard

Les libraries de scripting sont disponibles sous le répertoire ci-dessous:

WebTools\TOOLS\XTEND\HTMRSRC\LIB\SCRIPTING
WebTools est le répertoire Tools d'installation du serveur X3WEB

xtdPrototype.js

Cette librairie est une adaptation de la librairie prototype.js version 1.6.0.2 dépouillée des fonctions de manipulation des objets graphiques (DOM).

Elle met à disposition du dévelopeur un ensemble de fonctions et classes très utiles comme la gestion de classes avec héritage, la gestion de tableaux et HashMaps...

xtdWsvc.js

Propose des fonctions utilitaires pour l'appel de web services XTEND et la manipulation des données JSON (paramètres et résultat).

Pour utiliser ces librairies il suffit de les copier sous le répertoire des scrcipts serveur du site et de les inclure dans le code JavaScript via l'instruction #include.

Programmation

Construction du HTML

Le principe du scripting consiste à construire dynamiquement du texte HTML par exécution d'instructions JavaScript.

La fonction print() permet d'envoyer le HTML vers le navigateur.

En réalité la fonction print permet de remplir un buffer texte qui sera inséré, après exécution du code, dans la page HTML à l'emplacement du script.

Accès au contexte du moteur XTEND

L'objet de scope globale XTD_CTX donne accès au contexte du moteur XTEND au travers d'un ensemble de méthodes.

//Informations  sur le compte utilisateur
public boolean userLogged();
public String userCode();
public String userProfile();
public String userLang();
//Renvoie un block
//Le token block doit être inséré dans la page pour le déclarer
//sans forcément ajouter de fils <!adx="monBlock"><!adx="monBlock">
public IXtdJsTokenBlock getTokenBlock(String aBlockId);
//Renvoie une entité Action ou Session
public IXtdJsActEntity getActionEntity(String aId);
//Renvoie l'url de la servlet courante en mode sécurisé (https) ou non
public String getServletUrl(boolean aSecured);
//Renvoie l'url complète pour accéder à une page
public String getPageUrl(String aPage);
//Renvoie l'url complète pour exécuter un lien dynamique en méthode GET
public String getDlkUrl(String aDynLink);
//Renvoie le tag <a href='' onclick='xtdDoDlk(..)'> associé au lien dynamique
//Le tag </a> doit être ajouté en scripting
public String getDlkAnchor(String aDynLink,String aClass);
//Renvoie le tag input <input type='button' onclick='xtdDoDlk(..)'>
//associé au lien dynamique
public String getDlkButton(String aDynLink,String aValue,String aClass);
//Renvoie les fonctions JS générés par Xtend pour le traitement des
//liens dynamiques
public String getDlkOnclick(String aDynLink, boolean aIsInputTag);
public String getDlkOnSubmit(String aDynLink);
//Permet la prise en compte en Javascript des tags input de type checkbox
//utilisés dans les action
//Xtend génère un input hidden pour les checkboxes non cochées
public void checkBoxAdd(String aInputName);
public void checkBoxAdd(String aInputName,String aUncheckedValue);

Exemple

Il s'agit d'un exemple où le sous-programme de LOGIN renvoie un champ "SITES" qui est stocké dans la session (informations du compte) et qui contient une liste de sites autorisés pour l'utilisateur.

La liste des sites est renvoyée sous la forme d'une query string de type Clé1=valeur&Clé2=valeur.

Le script a pour but de créer un tag select à partir des données du champ SITES.

Ce genre d'opération ne peut pas être effectuée via un token et nécessite l'emploi d'un script serveur.
On peut aussi réaliser l'opération de décodage via un script JavaScript client mais on n'a pas accès au contexte de données de la session XTEND.

Script

<div id="testscript">
<script adx="UserSites">
//Teste si l'utilisateur est signé
if (XTD_CTX.userLogged())
{
    //Librairie utilitaires
    #include 'libs\xtdWsvc.js'
   
    //Lit le champ SITES qui contient la query string
    //-> "site1=S1&site2=S2&site3=S3"
    var wQs=new String(XTD_CTX.getField("SITES"));
   
    //Parse la String pour créer un objet JavaScript(voir prototype.js)
    //-> {site1:"S1",site2:"S2",site3:"S3"}
    var wObj=wQs.parseQuery();
   
    //Objet utilitaire pour constituer le HTML qui sera inséré dans la page
    //-> Librairie xtdWsvc.js
    var wHtml=new XTENDWSVC.classHTMLBuffer();
    //Le HTML est un tag select
    wHtml.select(["value","SITES","class","xtendInput"]);
   
    //Tableau des valeurs(voir prototype.js)
    var wValues=Object.values(wObj);
    //Tableau des clés(voir prototype.js)
    var wKeys=Object.keys(wObj);
    //Ajout des options
    for (i=0;i<wKeys.length;i++)
        wHtml.option(wValues[i],wKeys[i]);
    wHtml.endSelect();
   
    //Ecriture de la réponse HTML
    print(wHtml.html());
</script>
</div>

Résultat

Résultat avec pour la valeur du champ SITES:
Site Grenoble=FCYGRE&Site Paris=FCYPAR&Site Lyon=FCYLY&Site Rouen=FCYROU

<div id="testscript">
    <select class="xtendInput" value="SITES">
        <option value="FCYGRE">Site Grenoble</option>
        <option value="FCYLY">Site Lyon</option>
        <option value="FCYROU">Site Rouen</option>
        <option value="FCYPAR">Site Paris</option>
    </select>
</div>

Accès aux blocs de la page

La fonction XTD_CTX.getTokenBlock(BlockID) renvoie une interface IXtdJsTokenBlock qui permet d'accéder aux méthodes et propriétés d'un token bloc inséré dans la page HTML.

Le token block doit être inséré dans la page pour le déclarer sans forcément ajouter de fils <!adx="BlockId"><!adx="BlockId">

Interface

public interface IXtdJsTokenBlock extends IXtdJsData
{
    // Renvoie un itérateur sur les lignes du bloc
    public IXtdJsDataIterator getLines();
}

L'interface IXtdJsTokenBlock pointe sur le bloc et permet d'accéder aux champs du bloc.

L'interface IXtdJsDataIterator permet d'effectuer une itération sur les lignes d'un bloc.

Exemple

<Html><body>
<!--Déclaration du bloc-->
<!adx="MyBlock"><!adx="MyBlock">
<!--Affichage des lignes du bloc-->
<script adx="TestScript">
    var wBlock=XTD_CTX.getTokenBlock("MyBlock");
    var wLines=wBlock.getLines();
    print ("Nombre de page="+wBlock.getField("APAGENB")+"<br>");
    print ("Nombre de lignes="+wBlock.getField("ABLKNBLINES")+"<br>");
    while(wLines.hasNext()){
        var wLine=wLines.next();
        print("<tr>");
        print("<td>"+wLine.getField("PRIX")+"</td>");
        print("<td>"+wLine.getField("STOCK")+"</td>");
        print("</tr>");
    }
</script>
</body></html>

Accès aux entités action

La fonction XTD_CTX.getActionEntity(EntityID) renvoie une interface IXtdJsActEntity qui permet d'accéder aux méthodes et propriétés de l'entité.

Seules les entités de type session ou action sont accessibles directement (sans passer par un token bloc) car elle sont stockées dans la session utilisateur (persistantes).

Les entités de type Accès données ne sont pas accessibles directement mais seulement au travers d'un token bloc.

Interface

public interface IXtdJsActEntity
{
    // Renvoie le code de l'entité
    public String getCode();
    // Renvoie un itérateur sur les entités
    public IXtdJsDataIterator<IXtdJsActEntityData> getIterator();
    // Ajoute une entité et renvoie l'interface sur cette entité
    // --> Il faut ensuite ajouter les champs
    public IXtdJsActEntityData addData();
    // Supprime l'entité d'identifiant aId
    public IXtdJsActEntityData removeData(String aId);
    // Renvoie l'entité d'identifiant aId
    public IXtdJsActEntityData getData(String aId);
}
public interface IXtdJsActEntityData extends IXtdJsData
{
    //Donnée d'un entité qui ajoute la méthode getID
    //à l'interface standard IXtdJsData
    public String getId();  
}

L'interface IXtdJsTokenBlock pointe sur le bloc et permet d'accéder aux champs du bloc.

L'interface IXtdJsDataIterator permet d'effectuer une itération sur les lignes d'un bloc.

Exemple

<Html><body>
<!--Déclaration du bloc-->
<!adx="MyBlock"><!adx="MyBlock">
<!--Affichage des lignes du bloc-->
<script adx="TestScript">
    var wEntities=XTD_CTX.getActionEntity("XTDLOGINV");
    var wIterator=wEntities.getIterator();
    print("Size="+wIterator.size() + " - Code="+ wEntities.getCode());         
    print("<table><br>");
    while(wIterator.hasNext()){
        var wLine=wIterator.next();
        print("<tr>");
        print("<td>"+wLine.getId()+"</td>");
        print("<td>"+wLine.getField("INVADR1")+"</td>");
        print("<td>"+wLine.getField("INVCITY")+"</td>");
        print("</tr>");
    }
    print("</table>");
</script>
</body></html>

Itération sur les lignes d'un bloc ou entités action

L'interface IXtdJsDataIterator permet d'effectuer une itération sur les lignes d'un bloc ou entités action.

Interface

public interface IXtdJsDataIterator
{
    // Renvoie le nombre de données
    public int size();
    // True si l'itérateur contient des données
    public boolean hasNext();
    // Renvoie la donnée courante et incrémente
    public IXtdJsData next();
    // Renvoie l'itérateur au format JSON
    public String toJSON();
}

Exemple

var wEntities=XTD_CTX.getActionEntity("XTDLOGINV");
var wIterator=wEntities.getIterator();
while(wIterator.hasNext()){
        var wLine=wIterator.next();
        print("<tr>");
        print("<td>"+wLine.getId()+"</td>");
        print("<td>"+wLine.getField("INVADR1")+"</td>");
        print("</tr>");
}

Itération sur les lignes d'un bloc ou entités action

Interface

public interface IXtdJsDataIterator<ClassData extends IXtdJsData>
{
    public boolean hasNext();
    public ClassData next();
    public String toJSON();
}
public interface IXtdJsData
{
    public void removeField(String aFieldName);
    public void setField(String aFieldName, String aValue);
    public String getField(String aFieldName);
    public String getField(String aFieldName, boolean aFormated);
    public String getField(String aFieldName, String aFormat);
    public String getMenuLabel(String aFieldName);
    public String getFieldJSON(String aFieldName);
    public String toJSON();  
}
public interface IXtdJsTokenBlock extends IXtdJsData
{
    public IXtdJsDataIterator getLines();
}

Accès aux champs d'une ligne d'un bloc ou d'une entité

L'interface IXtdJsData permet d'accéder aux champs d'un bloc ou d'une entité.

Interface

public interface IXtdJsData
{
    // Supprime le champ aFieldName
    public void removeField(String aFieldName);
    // Valorise le champ aFieldName avec aValue
    public void setField(String aFieldName, String aValue);
    // Renvoie la valeur X3 du champ aFieldName
    public String getField(String aFieldName);
    // Renvoie la valeur formatée du champ aFieldName
    public String getField(String aFieldName, boolean aFormated);
    // Renvoie la valeur du champ aFieldName formatée avec aFormat
    public String getField(String aFieldName, String aFormat);
    // Renvoie le label d'un champ MenuLocal aFieldName
    public String getMenuLabel(String aFieldName);
    // Renvoie le champ aFieldName au format JSON
    public String getFieldJSON(String aFieldName);
    // Renvoie le bloc de données au format AJSON
    public String toJSON();
}

Exemple

    var wItems=XTD_CTX.getTokenBlock("BlkItems");
   print(wItems.getField("PRIX")+"<br>");    
   print(wItems.getField("PRIX",true)+"<br>");

Appel d'un web service

L'interface IXtdJsWsvcCall permet d'appeler un web service X3 en scripting serveur.

Le web service doit être au préalable déclaré comme une interface XTEND.

Les méthodes de cette interface transmettent des données JSON aux web services X3.

Les web services X3 acceptent les deux types de données XML ou JSON pour le paramètre 'data' mais le format JSON est beaucoup plus facile à manipuler en JavaScript que le format XML car il correspond à la représentation String des objets JavaScript (Object literals).

Interface d'appel

public interface IXtdJsWsvcCall
{
    /*------------ Paramètres ------------*/
    // aInterface   : le code de l'interface à appeler
    // aJSONData    : Données JSON
    // aFailOnX3Err : True pour générer un exception si
    //                un message d'erreur est renvoyé par X3
    /*------------ Sous-programme ------------*/
    // Renvoie les paramètres standards PARCOD/PARVAL pour l'appel d'un sous-programme
    public String[][] callSpgGetAXPAR();
    // ------------------------------------------
    // Appel d'un web service sous-programme
    public IXtdAjaxResult callSpgRun(
            String aInterface,
            String aJSONData,
            boolean aFailOnX3Err
        ) throws Exception;
    /*------------ Objet X3 ------------*/
    // Méthode Create
    public IXtdAjaxResult callObjCreate(
           String aInterface,
           String aJSONData,
           boolean aFailOnX3Err
        ) throws Exception;
    // ------------------------------------------
    // Méthode Read
    public IXtdAjaxResult callObjRead(
           String aInterface,
           String aQsKeys,
           boolean aFailOnX3Err
        )throws Exception;
    // ------------------------------------------
    // Méthode Update
    public IXtdAjaxResult callObjUpdate(
            String aInterface,
            String aQsKeys,
            String aJSONData,
            boolean aFailOnX3Err
        ) throws Exception;
    // ------------------------------------------
    // Méthode Delete
    public IXtdAjaxResult callObjDelete(
            String aInterface,
            String aQsKeys,
            boolean aFailOnX3Err
        )throws Exception;
    // ------------------------------------------
    // Autre méthode (aMethod) avec une clé comme paramètre
    public IXtdAjaxResult callObjActionKey(
            String aInterface,
            String aMethod,
            String aQsKeys,
            boolean aFailOnX3Err
        )throws Exception;
    // ------------------------------------------
    // Autre méthode (aMethod) avec des données objat XML comme paramètre
    public IXtdAjaxResult callObjActionData(
            String aInterface,
            String aMethod,
            String aJSONData,
            boolean aFailOnX3Err
        )throws Exception;
    // ------------------------------------------
    //Appel liste-gauche
    public IXtdAjaxResult callObjQuery(
            String aInterface,
            String aQsKeys,
            boolean aFailOnX3Err
        )throws Exception;
    /*------------ Trace ------------*/
    // Trace XTEND accessible via le navigateur
    // True si trace activée
    public boolean traceOn();
    // ------------------------------------------
    // Début d'un bloc de trace
    public void traceBeginStep(String aTrace);
    // ------------------------------------------
    // Trace
    public void traceWrite(String aTrace);
    // ------------------------------------------
    // Fin d'un bloc de trace
    public void traceEndStep();
    /*------------ Divers ------------*/
    // Renvoie l'url d'accès à la web aplication XTEND
    //
http://host:port/xtend - ou https://host:portssl/xtend
    public String getWebApplicationUrl(boolean aSecure);
}

Interface résultat

public interface IXtdAjaxResult
{
    // ------------------------------------------
    //Données JSON renvoyées par le web service
    public String getResponseBody();
    // ------------------------------------------
    //Longueur des données JSON
    public int getResponseBodyLength();
    // ------------------------------------------
    //True si mesSage X3
    public boolean hasMessage();
    // ------------------------------------------
    //True si message erreur X3
    public boolean hasMsgErr();
    // ------------------------------------------
    //True si message warning X3
    public boolean hasMsgWarn();
    // ------------------------------------------
    //True si message information X3
    public boolean hasMsgInfo();
    // ------------------------------------------
    //Liste des messages d'erreur X3
    public String[] getMsgErrLst();
    // ------------------------------------------
    //Liste des messages warning X3
    public String[] getMsgWarnLst();
    // ------------------------------------------
    //Liste des messages d'information X3
    public String[] getMsgInfoLst();
}

Librairie xtdWsvc.js

Cette librairie propose des utilitaires pour manipuler :

  • les paramètres d'appel des web services
  • le résulat JSON d'appel d'un web service
  • le HTML généré

Cette librairie utilise la librairie xtdPrototype.js.

Gestion paramètres et résultat

/*------------------ INCLUDE ------------------*/
//Toujours inclure la librairie xtdPrototype.js
#include "xtdPrototype.js"

/*------------------ OBJETS JAVA/JAVASCRIPT -------------------*/
//Renvoie true si l'objet aObj est un objet JAVA
//Renvoie false si c'est un objet JavaScript
Object.xtdIsJava(aObj);
//-----------------------------------------------
//Permet de convertir un objet Java ou JavaScript en String
Object.xtdToString(aObj);

/*------------------ PARAMETRES ------------------*/
//Renvoie les paramètres pour l'appel d'un web service
//Classe XTENDWSVC.classParam
//aOptionsJson sont les options JSON (Classe XTENDWSVC.classJsonOpt)
XTENDWSVC.newParam(aOptionsJson);
//-----------------------------------------------
//Renvoie les paramètres pour l'appel d'un web service OBJET X3
//Classe XTENDWSVC.classParamObject
//->aTimeStampX3 est une String qui contient le TimeStamp de l'ojet X3
//->aTimeStampX3 ="" si pas de TimeStamp
XTENDWSVC.newParamXtdObject(aTimeStampX3,aOptionsJson);
//-----------------------------------------------
//Renvoie les paramètres pour l'appel d'un web service Sous-Programme
//Classe XTENDWSVC.classParamXtdSpg
XTENDWSVC.newParamXtdSpg(aOptionsJson);
//-----------------------------------------------
//Renvoie les paramètres pour l'appel d'un web service Sous-Programme
//de type  'Accès données'. Ajoute les paramètres spécifiques
//Classe XTENDWSVC.classParamXtdSpgAccess
//->aNbLines est le nombre de lignes à renvoyer
//->aStartAt est le rang de la ligne de départ (pagination)
XTENDWSVC.newParamXtdSpgAccess(aNbLines,aStartAt,aOptionsJson);

/*------------------ RESULTAT ------------------*/
//Evalue la chaine de caractères aJSON résultat d'un web service X3
//Renvoie un objet JavaScript
XTENDWSVC.evalResult(aJSON);
//-----------------------------------------------
//Evalue le résultat d'un sous-programme
//Ajoute des méthodes spécifique au type de résultat
//Méthodes XTENDWSVC.methodsResultSpg
XTENDWSVC.evalResultSpg(aJSON);
//-----------------------------------------------
//Evalue le résultat d'un sous-programme 'Accès données'
//Ajoute des méthodes spécifique au type de résultat
//Méthodes XTENDWSVC.methodsResultSpg
XTENDWSVC.evalResultSpgAccess(aJSON);
//-----------------------------------------------
//Evalue le résultat d'un web service Objet
//Ajoute des méthodes spécifique au type de résultat
//Méthodes XTENDWSVC.methodsResultObject
XTENDWSVC.evalResultObject(aJSON);

/*------------------ CLASSES PARAMETRE -------------------*/
XTENDWSVC.classParam=Class.create({
    //Renvoie les options JSON
    options:function();
    //Ajoute le paramètre aCode avec la valeur aValue
    add:function(aCode,aValue);
});
//-----------------------------------------------
XTENDWSVC.classParamXtdSpg=Class.create(XTENDWSVC.classParam,{
    //Ajoute un paramètre aCode/aValue au groupe AXPAR
    addAXPAR:function(aCode,aValue);   
});


/*------------------ OBJET RESULTAT -------------------*/
//Résultat appel sous-programme
methodsResultSpg:{
    //Renvoie la valeur String du paramètre aCode du groupe AXPAR
    AXPAR:function(aCode);
    //Renvoie la valeur Integer du paramètre aCode du groupe AXPAR
    //aDefValue est la valeur si paramètre non trouvé
    AXPARInt:function(aCode,aDefValue);
}
//-----------------------------------------------
//Résultat appel sous-programme de type 'Accès données'
//Les méthodes permettent de gérer la pagination
methodsResultSpgAccess:{
    //Nombre de records demandés
    askedRecords:function();
    //Nombre de records total
    totalRecords:function();
    //Nombre de records renvoyés
    returnedRecords:function();
    //Rang de départ
    startRank:function();
    //True si il existe des enregistrements suivants
    hasNext:function();
}
//-----------------------------------------------
//Résultat appel sous-programme de type 'Objet X3'
//Les méthodes permettent d'accéder aux informations de dernière modification
methodsResultObject:{
    //Renvoie la valeur du champ aField pour le groupe ADXTEC
    adxADXTEC:function(aField);
    //Renvoie le TimeStamp
    adxTimeStamp:function();
    //Renvoie le dernier code utilisateur X3 qui a modifié l'objet
    adxUser:function();
}

Options JSON

XTENDWSVC.classJsonOpt=Class.create({
    //Pas de groupes de publication en retour
    //Chaque paramètre est un tableau de String
    noGroups:function();
    //Pas de lignes dans les tableaux avec dim>1
    //Chaque paramètre est un tableau de String
    noRows:function();   
    //Pas de labels pour les menus locaux
    noLabels:function();
    //Les champs clob ne sont pas renvoyés
    noClobs:function();
    //Exclut les groupes contenus dans aValue
    //aValue est une String or Array of string
    excludeGrp:function(aValue);
    //Inclut les groupes contenus dans aValue
    includeGrp:function(aValue);
    //Exclut les champs contenus dans aValue
    //aValue est une String or Array of string
    excludeFld:function(aValue);
    //Inclut les champs contenus dans aValue
    includeFld:function(aValue);
});

Exemple :

// Options JSON
var wJsonOpt=new XTENDWSVC.classJsonOpt().noRoups().noRows().excludeGrp(["GRP1","GRP2");

// Créatio
n paramètre appel sous-programme
var wParams=XTENDWSVC.newParamXtdSpg();
wParams.add("AXUSERCODE",wInput.P1);
wParams.add("AXPWD",wInput.P2);
wParams.options().noGroups().includeGrp(["AXLOG_X3"]

Construction du HTML

La librairie inclut une classe XTENDWSVC.classHTMLBuffer qui permet de construire une réponse HTML à envoyer vers le client.

Exemple d'appel d'un sous-programme

Cet exemple appel l'interface AXTDLOGIN (sous-programme de login) :

  • crée les paramètre
  • appelle le sous-programme
  • traite le résultat
      • Affiche les erreurs
      • Affiche un tableau HTML avec les informations de login X3 renvoyées par le sous-programme

GESAY_ADV_SCRIPTING_1.jpg

Il s'agit d'un exemple sachant qu'il est beaucoup plus simple dans ce cas d'utiliser les tokens.

#include 'libs\xtdWsvc.js'
function callXTDLogin(){
    //Paramètres user/password 
    var wInput={P1:'dis001',P2:'adonix'};
    //Trace activée ?
    var wTraceOn=XTD_CTX.traceOn();
    if(wTraceOn){
    //Début du bloc de trace des paramètres
        XTD_CTX.traceBeginStep("Build WSVC params");
        XTD_CTX.traceWrite("P1="+wInput.P1+ " - P2="+wInput.P2);
    }
    //Création objet paramètre sous-programme
    var wParams=XTENDWSVC.newParamXtdSpg();
    //Valorisation des paramètres
    //AXUSERCODE et APWD sont les noms des paramètres utilisés
    //pour transmettre le user/password
    wParams.add("AXUSERCODE",wInput.P1);
    wParams.add("AXPWD",wInput.P2);
    //Ajout des options JSON pour l'appel du sous-programme
    wParams.options().noGroups().includeGrp(["AXLOG_X3"]);
    // Paramètres JSON passés au web service (comme les paramètres XML)
    wParams=Object.toJSON(wParams);
    if(wTraceOn){
        //Fin du bloc de trace des paramètres
        XTD_CTX.traceWrite(wParams);
        XTD_CTX.traceEndStep();
    }
    //Début du bloc de trace de l'appel
    if(wTraceOn)XTD_CTX.traceBeginStep("Call spg");
    //Appel du sous-programme
    //->false pour traiter les erreurs X3 par programme
    var wResult=XTD_CTX.callSpgRun("AXTDLOGIN",wParams,false);
    if (wResult.hasMsgErr()){
        //Traitement des erreurs
        if(wTraceOn) XTD_CTX.traceWrite("Error message");
        var wLst=$A(wResult.getMsgErrLst());
        print("<span class='intUserMsg'>"+wLst.join('\n')+"</span>");
    }else{
        //Traitement du résultat
        //Evaluation des données JSON
        var wJSON=XTENDWSVC.evalResultSpg(wResult.getResponseBody());
        //Trace
        if(wTraceOn) XTD_CTX.traceWrite(Object.toJSON(wJSON));
        //Construction de la réponse HTML
        //->Tableau des codes d'accès aux différents dossiers X3
        var wHtml=new XTENDWSVC.classHTMLBuffer;
        wHtml.table(["border","0","class","intLine"]);
        wHtml.trFill(["SolutionX3","DossierX3","LangX3","UserX3"],
                     ["class","intRowTitle"]);
        if (wJSON.AX3SOL){
            var wLen=wJSON.AX3SOL.length;
            for(var i=0;i<wLen;i++)
                //Gestion des styles par ligne alternés
                wHtml.trFill([wJSON.AX3SOL[i], wJSON.AX3FLDR[i], wJSON.AX3LANG[i],
                wJSON.AX3USER[i]],["class",i%2==0?"intEvenLine":"intOddLine"]);
                wHtml.endTable();
            }
            print(wHtml.html());
        }
        if(wTraceOn) XTD_CTX.traceEndStep();
    }
}

Appel d'un script via AJAX

L'interface IXtdAjaxScriptContext est disponible via l'objet XTD_CTX pour les scripts qui sont appelés par des requêtes AJAX.

Cet interface permet :

  • d'appeler des web services (interface IXtdJsWsvcCall)
  • d'accéder au contexte session
  • de lire le contenu (body) et parametres de la requête HTTP
  • de mettre à jour le ContentType du résultat

L'instruction print écrit les données dans un buffer caractères qui sera renvoyé vers le client avec le ContentType précisé par la méthode setHttpContenType.

// Hérite de l'interface d'appel des web service IXtdJsWsvcCall
public interface IXtdAjaxScriptContext extends IXtdJsWsvcCall
{
    //Contenu {{body}} au format TEXTE de la requête HTTP
    public String getHttpBody();
    //Array JSON qui contient le tableau des paramètres (clé/valeur) de la requête
    //Utile si le format est application/x-www-form-urlencoded
    public String getHttpParams();
    //Met à jour le ContentTYpe de la réponse
    public void setHttpContenType(String aStr);
    // Login utilisateur
    public boolean userLogged();
    public String userCode();
    public String userProfile();
    public String userLang();
    // Accès aux champs de la session
    public Object getSessField(String aFieldName);
    public Object getSessField(String aFieldName, boolean aFormated);
    public void setSessField(String aFieldName, String aValue);
    // Renvoie les données utilisateur
    public IXtdJsData getUserInfo();
    // Renvoie les variables utilisateurs
    public IXtdJsData getUserVariables();
    // Renvoie une entité action
    public IXtdJsActEntity getActionEntity(String aEntityCode, boolean aCreate);
    // Suprimme une entité action
    public void removeActionEntity(String aEntityCode);
    // Gestion des messages pour la réponse
    void addMsgErr(String aMsg);
    void addMsgWarn(String aMsg);
    void addMsgInfo(String aMsg);
}