Scripting server
Introduzione
Il server XTEND dispone di una funzione di Scripting che permette di eseguire script JavaScript sul server per costruire in maniera dinamica le pagine HTML così come uno script PHP.
Si consiglia di utilizzare lo scripting quando il codice HTML che si vuole generare non può essere gestito mediante l'inserimento dei token.
Gli script server possono essere eseguiti da query AJAX emesse dal browser.
Inserimento dello script
Lo script deve essere inserito nella pagina HTML all'interno di un tag <script> nel punto in cui si vuole generare il codice HTML.
Per identificare uno script serveur si deve posizionare un token campi nel tag <script adx="MyTokenField"></script>.
L'esempio qui in basso visualizza una pagina con il testo Testo generato da uno script server.
<html><body>
<script adx="TestScript1">
print("<b>Testo generato da uno script server</b>");
</script>
</body></html>
Utilizzo di librerie
Il motore di scripting XTEND permette di includere delle librerie (file JavaScript) nel codice mediante l'istruzione #include 'pathLib'.
pathLib è il percorso di accesso al file libreria in relazione alla directory root degli script serveur definito nella scheda di parametrizzazione del sito.
<script adx="TestScript2">
#include 'libs\xtdWsvc.js''
</script>
Librerie consegnate in standard
Le librerie di scripting sono disponibili sotto la directory qui in basso:
WebTools\TOOLS\XTEND\HTMRSRC\LIB\SCRIPTING
WebTools è la directory Tools di installazione del server X3WEB
xtdPrototype.js
Questa libreria è un adattamento della libreria prototype.js versione 1.6.0.2 privata delle funzioni di manipolazione degli oggetti grafici (DOM).
Mette a disposizione dello sviluppatore un insieme di funzioni e di classi molto utili come la gestione delle classi con eredità, la gestione dei riquadri e HashMaps...
xtdWsvc.js
Propone delle funzioni utility per la chiamata dei web service XTEND e la manipolazione dei dati JSON (parametri e risultati).
Per utilizzare queste librerie basta copiarle sotto la directory degli script server del sito ed includerle nel codice JavaScript mediante l'istruzione #include.
Programmazione
Costruzione dell'HTML
Il principio dello scripting consiste nel costruire in modo dinamico il testo HTML mediante esecuzione delle istruzioni JavaScript.
La funzione print() permette di inviare l'HTML verso il browser.
In realtà la funzione print permette di alimentare un buffer di testo che verrà inserito, dopo l'esecuzione del codice, nella pagina HTML dove si trova lo script.
Accesso al contesto del motore XTEND
L'oggetto di scope globale XTD_CTX dà accesso al contesto del motore XTEND grazie ad un insieme di metodi.
//Informazioni sul account utente
public boolean userLogged();
public String userCode();
public String userProfile();
public String userLang();
//Restituisce un block
//Per essere dichiarato il token block deve essere inserito nella pagina
//senza dover obbligatoriamente aggiungere i figli <!adx="mioBlocco"><!adx="mioBlocco">
public IXtdJsTokenBlock getTokenBlock(String aBlockId);
//Restituisce una entità Action o Session
public IXtdJsActEntity getActionEntity(String aId);
//Restituisce l'url della servlet corrente in modalità protetta (https) o meno
public String getServletUrl(booleano aSecured);
//Restituisce la url completa per accedere ad una pagina
public String getPageUrl(String aPage);
//Restituisce una url completa per eseguire un link dinamico con il metodo GET
public String getDlkUrl(String aDynLink);
//Restituisce il tag <a href='' onclick='xtdDoDlk(..)'> associato al link dinamico
//Il tag </a> deve essere aggiunto in scripting
public String getDlkAnchor(String aDynLink,String aClass);
//Restituisce il tag input <input type='button' onclick='xtdDoDlk(..)'>
//associato al link dinamico
public String getDlkButton(String aDynLink,String aValue,String aClass);
//Restituisce le funzioni JS generate da Xtend per l'elaborazione dei
//link dinamici
public String getDlkOnclick(String aDynLink, boolean aIsInputTag);
public String getDlkOnSubmit(String aDynLink);
//Permette di prendere in considerazione in Javascript dei tag input di tipo checkbox
//utilizzati nelle azioni
//Xtend genera un input hidden per i checkbox non contrassegnati
public void checkBoxAdd(String aInputName);
public void checkBoxAdd(String aInputName,String aUncheckedValue);
Esempio
Si tratta di un esempio in cui il sotto-programma di LOGIN restituisce un campo "SITI" che viene memorizzato nella sessione (informazioni dell'account) e che contiene un elenco di siti autorizzati per l'utente.
L'elenco dei siti viene restituito sotto forma di una query string di tipo Chiave1=valore&Chiave2=valore.
Lo script ha lo scopo di creare un tag select partendo dai dati del campo SITI.
Tale tipo di operazione non può essere effettuato mediante un token e necessita l'impiego di uno script server.
E' possibile realizzare l'operazione di decodifica mediante uno script JavaScript client ma non si ha accesso al contesto dei dati della sessione XTEND.
Script
<div id="testscript">
<script adx="UserSites">
//Test se l'utente è firmato
if (XTD_CTX.userLogged())
{
//Libreria utility
#include 'libs\xtdWsvc.js'
//Legge il campo SITI che contiene la query string
//-> "sito1=S1&sito2=S2&sito3=S3"
var wQs=new String(XTD_CTX.getField("SITES"));
//Parse della String per creare un oggetto JavaScript(vedere prototype.js)
//-> {sito1:"S1",sito2:"S2",sito3:"S3"}
var wObj=wQs.parseQuery();
//Oggetto utility per costituire l'HTML che sarà inserito nella pagina
//-> Libreria xtdWsvc.js
var wHtml=new XTENDWSVC.classHTMLBuffer();
//L'HTML è un tag select
wHtml.select(["value","SITI","class","xtendInput"]);
//Riquadro dei valori(vedere prototype.js)
var wValues=Object.values(wObj);
//Riquadro delle chiavi(vedere prototype.js)
var wKeys=Object.keys(wObj);
//Aggiunta delle opzioni
for (i=0;i<wKeys.length;i++)
wHtml.option(wValues[i],wKeys[i]);
wHtml.endSelect();
//Scrittura della risposta HTML
print(wHtml.html());
</script>
</div>
Risultato
Risultato con valore del campo SITI:
Sito Grenoble=FCYGRE&Sito Parigi=FCYPAR&Sito Lione=FCYLY&Sito Rouen=FCYROU
<div id="testscript">
<select class="xtendInput" value="SITI">
<option value="FCYGRE">Sito Grenoble</option>
<option value="FCYLY">Sito Lione</option>
<option value="FCYROU">Sito Rouen</option>
<option value="FCYPAR">Sito Parigi</option>
</select>
</div>
Accesso ai blocchi della pagina
La funzione XTD_CTX.getTokenBlock(BlockID) restituisce una interfaccia IXtdJsTokenBlock che permette di accedere ai metodi e proprietà di un token blocco inserito nella pagina HTML.
Il token blocco deve essere inserito nella pagina per essere dichiarato senza obbligatoriamente aggiungere figli <!adx="BlockId"><!adx="BlockId">
Interfaccia
public interface IXtdJsTokenBlock extends IXtdJsData
{
// Restituisce un iteratore sulle righe del blocco
public IXtdJsDataIterator getLines();
}
L'interfaccia IXtdJsTokenBlock punta sul blocco e permette di accedere ai campi del blocco.
L'interfaccia IXtdJsDataIterator permette di effettuare una iterazione sulle righe di un blocco.
Esempio
<Html><body>
<!--Dichiarazione del blocco-->
<!adx="MyBlock"><!adx="MyBlock">
<!--Visualizzazione delle righe del blocco-->
<script adx="TestScript">
var wBlock=XTD_CTX.getTokenBlock("MyBlock");
var wLines=wBlock.getLines();
print ("Numero di pagina="+wBlock.getField("APAGENB")+"<br>");
print ("Numero di riga="+wBlock.getField("ABLKNBLINES")+"<br>");
while(wLines.hasNext()){
var wLine=wLines.next();
print("<tr>");
print("<td>"+wLine.getField("PREZZO")+"</td>");
print("<td>"+wLine.getField("STOCK")+"</td>");
print("</tr>");
}
</script>
</body></html>
Accesso alle entità azione
La funzione XTD_CTX.getActionEntity(EntityID) restituisce un'interfaccia IXtdJsActEntity che permette di accedere ai metodi e alle proprietà dell'entità.
Solo le entità di tipo sessione o azione sono accessibili direttamente (senza passare da un token blocco) poiché sono memorizzate nella sessione utente (persistenti).
Le entità di tipo Accesso dati non sono accessibili direttamente ma solo mediante un token blocco.
Interfaccia
public interface IXtdJsActEntity
{
// Restituisce il codice dell'entità
public String getCode();
// Restituisce un iteratore sulle entità
public IXtdJsDataIterator<IXtdJsActEntityData> getIterator();
// Aggiunge un'entità e restituisce l'interfaccia su questa entità
// --> Bisogna in seguito aggiungere i campi
public IXtdJsActEntityData addData();
// Elimina l'entità con identificativo aId
public IXtdJsActEntityData removeData(String aId);
// Restituisce l'entità con identificativo aId
public IXtdJsActEntityData getData(String aId);
}
public interface IXtdJsActEntityData extends IXtdJsData
{
//Dato di una entità che aggiunge il metodo getID
//all'interfaccia standard IXtdJsData
public String getId();
}
L'interfaccia IXtdJsTokenBlock punta sul blocco e permette di accedere ai campi del blocco.
L'interfaccia IXtdJsDataIterator permette di effettuare un'iterazione sulle righe di un blocco.
Esempio
<Html><body>
<!--Dichiarazione del blocco-->
<!adx="MyBlock"><!adx="MyBlock">
<!--Visualizzazione delle righe del blocco-->
<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>
Iterazione sulle righe di un blocco o sulle entità azione
L'interfaccia IXtdJsDataIterator permette di effettuare un'iterazione sulle righe di un blocco o sulle entità azione.
Interfaccia
public interface IXtdJsDataIterator
{
// Restituisce il numero di dati
public int size();
// True se l'iteratore contiene dei dati
public boolean hasNext();
// Restituisce il dato corrente ed incrementa
public IXtdJsData next();
// Restituisce l'iteratore in formato JSON
public String toJSON();
}
Esempio
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>");
}
Iterazione sulle righe di un blocco o sulle entità azione
Interfaccia
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();
}
Accesso ai campi di una riga di un blocco o di un'entità
L'interfaccia IXtdJsData permette di accedere ai campi di un blocco o di una entità.
Interfaccia
public interface IXtdJsData
{
// Cancella il campo aFieldName
public void removeField(String aFieldName);
// Valorizza il campo aFieldName con aValue
public void setField(String aFieldName, String aValue);
// Restituisce il valore X3 del campo aFieldName
public String getField(String aFieldName);
// Restituisce il valore formattato del campo aFieldName
public String getField(String aFieldName, boolean aFormated);
// Restituisce il valore del campo aFieldName formattato con aFormat
public String getField(String aFieldName, String aFormat);
// Restituisce la label di un campo MenuLocal aFieldName
public String getMenuLabel(String aFieldName);
// Restituisce il campo aFieldName in formato JSON
public String getFieldJSON(String aFieldName);
// Restituisce il blocco di dati in formato AJSON
public String toJSON();
}
Esempio
var wItems=XTD_CTX.getTokenBlock("BlkItems");
print(wItems.getField("PREZZO")+"<br>");
print(wItems.getField("PREZZO",true)+"<br>");
Chiamata di un web service
L'interfaccia IXtdJsWsvcCall permette di richiamare un web service X3 in scripting server.
Il web service deve essere già stato dichiarato come un'interfaccia XTEND.
I metodi di questa interfaccia trasmettono dei dati JSON ai web service X3.
I web service X3 accettano i due tipi di dati XML o JSON per il parametro 'data' ma il formato JSON è molto più facile da manipolare in JavaScript del formato XML poiché corrisponde alla rappresentazione String degli oggetti JavaScript (Object literals).
Interfaccia di chiamata
public interface IXtdJsWsvcCall
{
/*------------ Parametri ------------*/
// aInterface : codice dell'interfaccia da richiamare
// aJSONData : Dati JSON
/// aFailOnX3Err : True per generare un eccezione se
// viene emesso un messaggio di errore da X3
/*------------ Sotto-programma ------------*/
// Restituisce i parametri standard PARCOD/PARVAL per la chiamata di un sotto-programma
public String[][] callSpgGetAXPAR();
// ------------------------------------------
// Chiamata di un web service sotto-programma
public IXtdAjaxResult callSpgRun(
String aInterface,
String aJSONData,
boolean aFailOnX3Err
) throws Exception;
/*------------ Oggetto X3 ------------*/
// Metodo Create
public IXtdAjaxResult callObjCreate(
String aInterface,
String aJSONData,
boolean aFailOnX3Err
) throws Exception;
// ------------------------------------------
// Metodo Read
public IXtdAjaxResult callObjRead(
String aInterface,
String aQsKeys,
boolean aFailOnX3Err
)throws Exception;
// ------------------------------------------
// Metodo Update
public IXtdAjaxResult callObjUpdate(
String aInterface,
String aQsKeys,
String aJSONData,
boolean aFailOnX3Err
) throws Exception;
// ------------------------------------------
// Metodo Delete
public IXtdAjaxResult callObjDelete(
String aInterface,
String aQsKeys,
boolean aFailOnX3Err
)throws Exception;
// ------------------------------------------
// Altro metodo (aMethod) con una chiave come parametro
public IXtdAjaxResult callObjActionKey(
String aInterface,
String aMethod,
String aQsKeys,
boolean aFailOnX3Err
)throws Exception;
// ------------------------------------------
// Altro metodo (aMethod) con dati oggetto XML come parametro
public IXtdAjaxResult callObjActionData(
String aInterface,
String aMethod,
String aJSONData,
boolean aFailOnX3Err
)throws Exception;
// ------------------------------------------
//Chiamata lista di selezione
public IXtdAjaxResult callObjQuery(
String aInterface,
String aQsKeys,
boolean aFailOnX3Err
)throws Exception;
/*------------ Traccia ------------*/
// Traccia XTEND accessibile dal browser
// True se la traccia è attivata
public boolean traceOn();
// ------------------------------------------
// Inizio di un blocco di traccia
public void traceBeginStep(String aTrace);
// ------------------------------------------
// Traccia
public void traceWrite(String aTrace);
// ------------------------------------------
// Fine di un blocco di traccia
public void traceEndStep();
/*------------ Diversi -----------*/
// Restuisce la url di accesso alla web application XTEND
//http://host:port/xtend - ohttps://host:portssl/xtend
public String getWebApplicationUrl(boolean aSecure);
}
Interfaccia risultato
public interface IXtdAjaxResult
{
// ------------------------------------------
//Dati JSON restituiti dal web service
public String getResponseBody();
// ------------------------------------------
//Lunghezza dei dati JSON
public int getResponseBodyLength();
// ------------------------------------------
//True se messaggio X3
public boolean hasMessage();
// ------------------------------------------
//True se messaggio errore X3
public boolean hasMsgErr();
// ------------------------------------------
//True se messaggio warning X3
public boolean hasMsgWarn();
// ------------------------------------------
//True se messaggio informativo X3
public boolean hasMsgInfo();
// ------------------------------------------
//Elenco dei messaggi di errore X3
public String[] getMsgErrLst();
// ------------------------------------------
//Elenco dei messaggi warning X3
public String[] getMsgWarnLst();
// ------------------------------------------
//Elenco dei messaggi informativi X3
public String[] getMsgInfoLst();
}
Libreria xtdWsvc.js
Questa libreria propone delle utility per manipolare:
- i parametri di chiamata dei web service
- il risultato JSON di chiamata di un web service
- l'HTML generato
Questa libreria utilizza la libreria xtdPrototype.js.
Gestione parametri e risultato
/*------------------ INCLUDE ------------------*/
//Includere sempre la libreria xtdPrototype.js
#include "xtdPrototype.js"
/*------------------ OGGETTO JAVA/JAVASCRIPT -------------------*/
//Restituisci true se l'oggetto aObj è un oggetto JAVA
//Restituisce false se è un oggetto JavaScript
Object.xtdIsJava(aObj);
//-----------------------------------------------
//Permette di convertire un oggetto Java o JavaScript in String
Object.xtdToString(aObj);
/*------------------ PARAMETRI ------------------*/
//Restituisce i parametri per la chiamata di un web service
//Classe XTENDWSVC.classParam
//aOptionsJson sono le opzioni JSON (Classe XTENDWSVC.classJsonOpt)
XTENDWSVC.newParam(aOptionsJson);
//-----------------------------------------------
//Restituisce i parametri per la chiamata di un web service OGGETTO X3
//Classe XTENDWSVC.classParamObject
//->aTimeStampX3 è una String che contiene il TimeStamp dell'oggetto X3
//->aTimeStampX3 ="" se nessun TimeStamp
XTENDWSVC.newParamXtdObject(aTimeStampX3,aOptionsJson);
//-----------------------------------------------
//Restituisce i parametri per la chiamata di un web service Sotto-Programma
//Classe XTENDWSVC.classParamXtdSpg
XTENDWSVC.newParamXtdSpg(aOptionsJson);
//-----------------------------------------------
//Restituisce i parametri per la chiamata di un web service Sotto-Programma
//di tipo 'Accesso ai dati'. Aggiunge i parametri specifici
//Classe XTENDWSVC.classParamXtdSpgAccess
//->aNbLines è il numero di righe da restituire
//->aStartAt è il range della riga di partenza (paginazione)
XTENDWSVC.newParamXtdSpgAccess(aNbLines,aStartAt,aOptionsJson);
/*------------------ RISULTATO ------------------*/
//Interpreta la stringa di caratteri aJSON risultato di un web service X3
//Restituisce un oggetto JavaScript
XTENDWSVC.evalResult(aJSON);
//-----------------------------------------------
//Interpreta il risultato di un sotto-programma
//Aggiunge i metodi specifici al tipo di risultato
//Metodi XTENDWSVC.methodsResultSpg
XTENDWSVC.evalResultSpg(aJSON);
//-----------------------------------------------
//Interpreta il risultato di un sotto-programma 'Accesso dati'
//Aggiunge i metodi specifici al tipo di risultato
//Metodi XTENDWSVC.methodsResultSpg
XTENDWSVC.evalResultSpgAccess(aJSON);
//-----------------------------------------------
//Interpreta il risultato di un web service Oggetto
//Aggiunge i metodi specifici al tipo di risultato
//Metodi XTENDWSVC.methodsResultObject
XTENDWSVC.evalResultObject(aJSON);
/*------------------ CLASSI PARAMETRO -------------------*/
XTENDWSVC.classParam=Class.create({
//Restitusce le opzioni JSON
opzioni:function();
//Aggiunge il parametro aCode con il valore aValue
add:function(aCode,aValue);
});
//-----------------------------------------------
XTENDWSVC.classParamXtdSpg=Class.create(XTENDWSVC.classParam,{
//Aggiunge un parametro aCode/aValue al gruppo AXPAR
addAXPAR:function(aCode,aValue);
});
/*------------------ OGGETTO RISULTATO -------------------*/
//Risultato chiamata sotto-programma
methodsResultSpg:{
//Restituisce il valore String del parametro aCode del gruppo AXPAR
AXPAR:function(aCode);
//Restituisce il valore Integer del parametro aCode del gruppo AXPAR
//aDefValue è il valore se parametro non trovato
AXPARInt:function(aCode,aDefValue);
}
//-----------------------------------------------
//Risultato chiamata sotto-programma di tipo 'Accesso dati'
//I metodi permettono di gestire la paginazione
methodsResultSpgAccess:{
//Numero di record richiesti
askedRecords:function();
//Numero totale di record
totalRecords:function();
//Numero di record restituiti
returnedRecords:function();
//Range di partenza
startRank:function();
//True se esistono record successivi
hasNext:function();
}
//-----------------------------------------------
//Risultato chiamata sotto-programma di tipo 'Oggetto X3'
//I metodi permettono di accedere alle informazioni dell'ultima modifica
methodsResultObject:{
//Restituisce il valore del campo aField per il gruppo ADXTEC
adxADXTEC:function(aField);
//Restituisce il TimeStamp
adxTimeStamp:function();
//Restituisce l'ultimo codice utente X3 che ha modificato l'oggetto
adxUser:function();
}
Opzioni JSON
XTENDWSVC.classJsonOpt=Class.create({
//Nessun gruppo di pubblicazione in restituzione
//Ogni parametro è un riquadro di String
noGroups:function();
//Nessuna riga nei riquadri con dim>1
//Ogni parametro è un riquadro di String
noRows:function();
//Nessuna label per i menù locali
noLabels:function();
//I campi clob non sono restituiti
noClobs:function();
//Esclude i gruppi contenuti in aValue
//aValue è una String or Array of string
excludeGrp:function(aValue);
//Include i gruppi contentuti in aValue
includeGrp:function(aValue);
//Esclude i campi contenuti in aValue
//aValue è una String or Array of string
excludeFld:function(aValue);
//Include i campi contenuti in aValue
includeFld:function(aValue);
});
Esempio:
// Opzioni JSON
var wJsonOpt=new XTENDWSVC.classJsonOpt().noRoups().noRows().excludeGrp(["GRP1","GRP2");
// Creazione parametro chiamata sotto-programma
var wParams=XTENDWSVC.newParamXtdSpg();
wParams.add("AXUSERCODE",wInput.P1);
wParams.add("AXPWD",wInput.P2);
wParams.options().noGroups().includeGrp(["AXLOG_X3"]
Costruzione dell'HTML
La libreria include una classe XTENDWSVC.classHTMLBuffer che permette di costruire una risposta HTML da restituire al client.
Esempio di chiamata di un sotto-programma
Questo esempio richiama l'interfaccia AXTDLOGIN (sotto-programma di login):
- crea i parametri
- richiama il sotto-programma
- elabora il risultato
- Visualizza gli errori
- Visualizza un riquadro HTML con le informazioni di login X3 restituite dal sotto-programma
Si tratta di un esempio sapendo che in questo caso era molto più semplice usare i token.
#include 'libs\xtdWsvc.js'
function callXTDLogin(){
//Parametri user/password
var wInput={P1:'dis001',P2:'adonix'};
//Traccia attivata ?
var wTraceOn=XTD_CTX.traceOn();
if(wTraceOn){
//Inizio del blocco di traccia dei parametri
XTD_CTX.traceBeginStep("Build WSVC params");
XTD_CTX.traceWrite("P1="+wInput.P1+ " - P2="+wInput.P2);
}
//Creazione oggetto parametro sotto-programma
var wParams=XTENDWSVC.newParamXtdSpg();
//Valorizzazione dei parametri
//AXUSERCODE e APWD sono i nomi dei parametri utilizzati
//per trasmettere user/password
wParams.add("AXUSERCODE",wInput.P1);
wParams.add("AXPWD",wInput.P2);
//Aggiunge le opzioni JSON per la chiamata del sotto-programma
wParams.options().noGroups().includeGrp(["AXLOG_X3"]);
// Parametri JSON passati al web service (come i parametri XML)
wParams=Object.toJSON(wParams);
if(wTraceOn){
//Fine del blocco di traccia dei parametri
XTD_CTX.traceWrite(wParams);
XTD_CTX.traceEndStep();
}
//Inizio del blocco di traccia della chiamata
if(wTraceOn)XTD_CTX.traceBeginStep("Call spg");
//Chiamata del sotto-programma
//->false per elaborare gli errori X3 da programma
var wResult=XTD_CTX.callSpgRun("AXTDLOGIN",wParams,false);
if (wResult.hasMsgErr()){
//Elaborazione degli errori
if(wTraceOn) XTD_CTX.traceWrite("Error message");
var wLst=$A(wResult.getMsgErrLst());
print("<span class='intUserMsg'>"+wLst.join('\n')+"</span>");
}else{
//Elaborazione del risultato
//Interpretazione dei dati JSON
var wJSON=XTENDWSVC.evalResultSpg(wResult.getResponseBody());
//Traccia
if(wTraceOn) XTD_CTX.traceWrite(Object.toJSON(wJSON));
//Costruzione della risposta HTML
//->Riquadro dei codici di accesso dei vari dossier 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++)
//Gestione degli stili con righe alternate
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();
}
}
Chiamata di uno script con AJAX
L'interfaccia IXtdAjaxScriptContext è disponibile mediante l'oggetto XTD_CTX per gli script che sono richiamati da richieste AJAX.
Questa interfaccia permette:
- di chiamare i web service (interfaccia IXtdJsWsvcCall)
- di accedere al contesto sessione
- di leggere il contenuto (body) e parametri della richiesta HTTP
- di aggiornare il ContentType del risultato
Il comando print scrive i dati in un buffer caratteri che sarà inviato al client con il ContentType specificato dal metodo setHttpContenType.
// Eredita dall'interfaccia di chiamata dei web service IXtdJsWsvcCall
public interface IXtdAjaxScriptContext extends IXtdJsWsvcCall
{
//Contenuto {{body}} in formato TESTO della richiesta HTTP
public String getHttpBody();
//Array JSON che contiene il riquadro dei parametri (chiave/valori) della richiesta
//Utile se il formato è application/x-www-form-urlencoded
public String getHttpParams();
//Aggiorna il ContentTYpe della risposta
public void setHttpContenType(String aStr);
// Login utente
public boolean userLogged();
public String userCode();
public String userProfile();
public String userLang();
// Accesso ai campi della sessione
public Object getSessField(String aFieldName);
public Object getSessField(String aFieldName, boolean aFormated);
public void setSessField(String aFieldName, String aValue);
// Restituisce i dati utente
public IXtdJsData getUserInfo();
// Restituisce le variabili utente
public IXtdJsData getUserVariables();
// Restituisce una entità azione
public IXtdJsActEntity getActionEntity(String aEntityCode, boolean aCreate);
// Cancella una entità azione
public void removeActionEntity(String aEntityCode);
// Gestione dei messaggi per la risposta
void addMsgErr(String aMsg);
void addMsgWarn(String aMsg);
void addMsgInfo(String aMsg);
}