Scripting serveur
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 - ouhttps://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éation 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
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);
}