Scripting-Server 

Einführung

Der XTEND-Server bietet eine Scripting-Funktion , mit der JavaScript-Skripte auf dem Server ausgeführt werden können, um HTML-Seiten auf dieselbe Art dynamisch aufzubauen wie PHP-Skripte.

Wir empfehlen das Scripting, wenn der zu generierende HTML-Code nicht per Einfügen von Token bearbeitet werden kann.

Die Serverskripte können auch von AJAX -Abfragen ausgeführt werden, die vom Browser abgesetzt werden.

Einfügen des Skripts

Das Skript muss innerhalb eines <script>-Tags in die HTML-Seite eingefügt werden, und zwar an der Stelle, wo der HTML-Code generiert werden soll.

Um ein Serverskript zu identifizieren, muss in das Tag <script adx="MyTokenField"></script> ein <field>-Token

eingefügt werden. Mit nachstehendem Beispiel wird eine Seite angezeigt, derenText mit einem Serverskript generiert wird

.
<html><body>
<script adx="TestScript1">
    print("<b>Text wird von einem Serverskript generiert</b>");
</script>

</body></html>Verwendung von Bibliotheken

Mit der XTEND-Scripting-Engine können über die Anweisung #include 'pathLib'Bibliotheken (Datei JavaScript) in den Code eingefügt werden.

pathLib ist dabei der Zugriffspfad auf die Bibliotheksdatei im Wurzelverzeichnis der Serverskripte , wie es in den Parametern der Websitedefiniert ist.

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

Mit der Standardversion ausgelieferte Bibliotheken

Die Scripting-Bibliotheken sind in folgendem Verzeichnis verfügbar:

WebTools\TOOLS\XTEND\HTMRSRC\LIB\SCRIPTING
WebTools (Verzeichnis der Installationswerkzeuge des X3WEB-Servers)

xtdPrototype.js

Bei dieser Bibliothek handelt es sich um die Anpassung einer prototype.js-Bibliothek, Version 1.3.0.2, ohne die Funktionalitäten für die Verarbeitung von Grafikobjekten (DOM).

Mit dieser Bibliothek steht dem Entwickler eine Reihe sehr nützlicher Funktionen und Klassen zur Verfügung, darunter Klassenverwaltung mit Vererbung, Tabellenverwaltung und HashMaps.

xtdWsvc.js

Umfasst Werkzeuge für den Aufruf von XTEND-Webservices und für die Bearbeitung von JSON-Daten (Parameter und Ergebnis).

Zur Verwendung dieser Bibliotheken müssen diese lediglich in das Verzeichnis der Serverskripte der Website kopiert und per #includein den JavaScript-Code inkludiert werden.

Programmierung

Aufbau des HTML-Textes

Das Prinzip des Scripting basiert auf dem dynamischen Aufbau des HTML-Textes per Ausführung von JavaScript-Anweisungen.

Mit der print() -Funktion kann der HTML-Text an den Browser gesendet werden.

Diese Funktion füllt einen Textbuffer, der nach Ausführung des Codes dort in die HTML-Seite eingefügt wird, wo sich das Skript befindet. Zugriff auf den Kontext der XTEND-Engine

Mit dem globalen Objekt

XTD_CTX kann über eine Reihe von Methoden auf den Kontext der XTEND-Engine zugegriffen werden. // Auskunft über das Benutzerkonto

public boolean
userLogged ();public String
userCode ();public String
userProfile ();public String
userLang ();// Gibt einen Block zurück
// Das <block>-Token muss für die Deklaration in die Seite eingefügt werden,
// jedoch möglichst ohne Abgeleitete <!adx="monBlock"><!adx="monBlock">
public IXtdJsTokenBlock
getTokenBlock (String aBlockId);// Gibt eine Aktions- oder Sitzungsentität zurück
public IXtdJsActEntity
getActionEntity (String aId);// Gibt die URL des aktuellen Servlets im Secure-Modus (https) oder im ungesicherten Modus zurück
public String
getServletUrl (boolean aSecured);// Gibt die vollständige URL für den Zugriff auf eine Seite zurück
public String
getPageUrl (String aPage);// Gibt die vollständige URL für die Ausführung eines dynamischen Links mit der GET-Methode zurück
public String
getDlkUrl (String aDynLink);// Gibt das Tag <a href='' onclick='xtdDoDlk(..)'> zurück, das dem dynamischen Link zugeordnet ist
// Das Tag </a> muss im Scripting hinzugefügt worden sein
public String
getDlkAnchor (String aDynLink,String aClass);// Gibt das <input>-Tag zurück <input type='button' onclick='xtdDoDlk(..)'>
//, das dem dynamischen Link zugeordnet ist
public String
getDlkButton (String aDynLink,String aValue,String aClass);// Gibt die von XTEND für die Verarbeitung der
// dynamischen Links generierten JS-Funktionen zurück
public String
getDlkOnclick (String aDynLink, boolean aIsInputTag);public String
getDlkOnSubmit (String aDynLink);// Berücksichtigung der <input>-Tags vom Typ Checkbox in Javascript
//, sofern sie in den Aktionen verwendet werden
//Xtend generiert einen für nicht aktivierte Kontrollkästchen verborgenen Inhalt
public void
checkBoxAdd (String aInputName);public void
checkBoxAdd (String aInputName,String aUncheckedValue);Beispiel

Im Beispiel gibt das LOGIN-Unterprogramm das Feld "SITES" zurück. Dieses wird in der Sitzung gespeichert (Kontodaten) und enthält eine Liste der Websites, für die der Benutzer berechtigt ist.

Die Liste der Websites wird in Form eines Query Strings vom Typ

Clé1=valeur&Clé2=valeur zurückgegeben.Mit dem Skript soll aus den Daten des Feldes SITES ein <select>-Tag aufgebaut werden.

Dies ist mit einem Token nicht möglich und setzt die Verwendung eines Skriptservers voraus.

Die Dekodierung kann auch mit einem JavaScript-Skript durchgeführt werden, wobei in diesem Fall kein Zugriff auf den Datenkontext der XTEND-Sitzung möglich ist.
Skript

<div id="testscript">

<script adx="UserSites">
// Test, ob es sich um einen signierten Benutzer handelt
if (XTD_CTX.userLogged())
{
    // Werkzeugbibliothek
    #include 'libs\xtdWsvc.js'
   
    // Liest das Feld SITES, das den Query String umfasst
    //-> "site1=S1&site2=S2&site3=S3"
    var wQs=new String(XTD_CTX.getField("SITES"));
   
    // Parst den String für die Erstellung des Objekts JavaScript(siehe prototype.js)
    //-> {site1:"S1",site2:"S2",site3:"S3"}
    var wObj=wQs.parseQuery();
   
    // Werkzeugobjekt für den Aufbau des auf die Seite einzufügenden HTMLs
    //-> Librairie xtdWsvc.js
    var wHtml=new XTENDWSVC.classHTMLBuffer();
    // Das HTML ist ein <select>-Tag
    wHtml.select(["value","SITES","class","xtendInput"]);
   
    // Wertetabelle (siehe prototype.js)
    var wValues=Object.values(wObj);
    // Schlüsseltabelle (siehe prototype.js)
    var wKeys=Object.keys(wObj);
    // Hinzufügen der Optionen
    for (i=0;i<wKeys.length;i++)
        wHtml.option(wValues[i],wKeys[i]);
    wHtml.endSelect();
   
    // Schreiben der HTML-Antwort
    print(wHtml.html());
</script>
</div>
Ergebnis

Ergebnis mit folgendem Feldwert für 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>
Zugriff auf die Seitenblöcke

Die Funktion

XTD_CTX.getTokenBlock(BlockID) gibt eine IXtdJsTokenBlock -Schnittstelle zurück, über die auf die Methoden und Eigenschaften eines in die HTML-Seite eingefügten <block>-Tokens zugegriffen werden kann. Dieses muss für die Deklaration in die Seite eingefügt werden, jedoch ohne unbedingt eine Ableitung hinzuzufügen:

<!adx="BlockId"><!adx="BlockId"> .

Schnittstelle

public interface IXtdJsTokenBlock extends IXtdJsData
{
    // Gibt eine Laufvariable für die Blockzeilen zurück
    public IXtdJsDataIterator getLines();
}

Die Schnittstelle IXtdJsTokenBlock zeigt auf den Block und bietet Zugriff auf die Blockfelder.

Mit der Schnittstelle IXtdJsDataIterator kann über die Zeilen eines Blocks iteriert werden.

Beispiel

<Html><body>
<!--Blockdeklaration-->
<!adx="MyBlock"><!adx="MyBlock">
<!--Anzeige der Blockzeilen-->
<script adx="TestScript">
    var wBlock=XTD_CTX.getTokenBlock("MyBlock");
    var wLines=wBlock.getLines();
    print ("Nombre de page="+wBlock.getField("APAGENB")+"<br>");
    print ("Anzahl Zeilen="+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>

Zugriff auf die Aktions-Entitäten

Die Funktion XTD_CTX.getActionEntity(EntityID) gibt eine IXtdJsActEntity -Schnittstelle zurück, über die auf die Methoden und Eigenschaften der Entität zugegriffen werden kann.

Nur die Entitäten vom Typ Sitzung oder Aktion sind direkt zugänglich (ohne Umweg über das <block>-Token), da sie in der (persistenten) Benutzersitzung gespeichert werden.

Die Entitäten vom Typ Zugriff sind nicht direkt, sondern nur über ein <block>-Token zugänglich.

Schnittstelle

public interface IXtdJsActEntity
{
    // Gibt den Code der Entität zurück
    public String getCode();
    // Gibt den Iterator für die Entitäten zurück
    public IXtdJsDataIterator<IXtdJsActEntityData> getIterator();
    // Fügt eine Entität hinzu und gibt die Schnittstelle zu dieser Entität zurück
    // --> Es müssen dann die Felder hinzugefügt werden
    public IXtdJsActEntityData addData();
    // Löscht die Id-Entität ald
    public IXtdJsActEntityData removeData(String aId);
    // Gibt die Id-Entität ald zurück
    public IXtdJsActEntityData getData(String aId);
}
public interface IXtdJsActEntityData extends IXtdJsData
{
    // Gibt die Entität zurück, die die Methode getID
    // zur Standardschnittstelle IXtdJsData hinzufügt
    public String getId();  
}

Die Schnittstelle IXtdJsTokenBlock zeigt auf den Block und bietet Zugriff auf die Blockfelder.

Mit der Schnittstelle IXtdJsDataIterator kann über die Zeilen eines Blocks iteriert werden.

Beispiel

<Html><body>
<!--Blockdeklaration-->
<!adx="MyBlock"><!adx="MyBlock">
<!--Anzeige der Blockzeilen-->
<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>

Iteration über die Zeilen eines Blocks oder über Aktionsentitäten

Mit der Schnittstelle IXtdJsDataIterator kann über die Zeilen eines Blocks oder über Aktionsentitäten iteriert werden.

Schnittstelle

public interface IXtdJsDataIterator
{
    // Gibt die Anzahl der Daten zurück
    public int size();
    // True, wenn der Iterator Daten enthält
    public boolean hasNext();
    // Gibt die aktuellen Daten zurück und inkrementiert
    public IXtdJsData next();
    // Gibt den Iterator im JSON-Format zurück
    public String toJSON();
}

Beispiel

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>");
}

Iteration über die Zeilen eines Blocks oder über Aktionsentitäten

Schnittstelle

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();
}

Zugriff auf die Felder einer Blockzeile oder auf Entitätsfelder

Mit der Schnittstelle IXtdJsData kann auf die Felder einer Blockzeile oder auf Entitätsfelder zugegriffen werden.

Schnittstelle

public interface IXtdJsData
{
    // Löscht das Feld aFieldName
    public void removeField(String aFieldName);
    // Belegt das Feld aFieldName mit aValue
    public void setField(String aFieldName, String aValue);
    // Gibt den X3-Wert des Feldes aFieldName zurück
    public String getField(String aFieldName);
    // Gibt den formatierten Wert des Feldes aFieldName zurück
    public String getField(String aFieldName, boolean aFormated);
    // Gibt den Wert des Feldes aFieldName zurück, formatiert mit aFormat
    public String getField(String aFieldName, String aFormat);
    // Gibt das Label eines MenuLocal aFieldName-Feldes zurück
    public String getMenuLabel(String aFieldName);
    // Gibt das Feld aFieldName im JSON-Format zurück
    public String getFieldJSON(String aFieldName);
    // Gibt den Datenblock im Format AJSON zurück
    public String toJSON();
}

Beispiel

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

Aufruf eines Webservice

Mit der Schnittstelle IXtdJsWsvcCall kann ein X3-Webservice als Scriptingserver aufgerufen werden.

Dieser Webservice muss zuvor als XTEND-Schnittstelle deklariert worden sein.

Die Methoden dieser Schnittstelle übergeben die JSON -Daten an die X3-Webservices.

Die X3-Webservices akzeptieren sowohl XML- als auch JSON-Daten als "data"-Parameter, wobei das JSON-Format in JavaScript einfacher zu bearbeiten ist als das XML-Format, denn die JSON-Darstellung für Strings entspricht der der JavaScript-Objekte (Object literals).

Aufrufschnittstellen

public interface IXtdJsWsvcCall
{
    /*------------ Parameter ------------*/
    // aInterface: Code der aufzurufenden Schnittstelle
    // aJSONData    : JSON-Daten
    // aFailOnX3Err : True für die Generierung einer Ausnahme
    //                X3 gibt eine Fehlermeldung zurück
    /*------------ Unterprogramm ------------*/
    // Gibt die Standardparameter PARCOD/PARVAL für den Unterprogrammaufruf zurück
    public String[][] callSpgGetAXPAR();
    // ------------------------------------------
    // Aufruf eines Unterprogramm-Webservice
    public IXtdAjaxResult callSpgRun(
            String aInterface,
            String aJSONData,
            boolean aFailOnX3Err
        ) throws Exception;
    /*------------ X3-Objekt ------------*/
    // Methode Create
    public IXtdAjaxResult callObjCreate(
           String aInterface,
           String aJSONData,
           boolean aFailOnX3Err
        ) throws Exception;
    // ------------------------------------------
    // Methode Read
    public IXtdAjaxResult callObjRead(
           String aInterface,
           String aQsKeys,
           boolean aFailOnX3Err
        )throws Exception;
    // ------------------------------------------
    // Methode Update
    public IXtdAjaxResult callObjUpdate(
            String aInterface,
            String aQsKeys,
            String aJSONData,
            boolean aFailOnX3Err
        ) throws Exception;
    // ------------------------------------------
    // Methode Delete
    public IXtdAjaxResult callObjDelete(
            String aInterface,
            String aQsKeys,
            boolean aFailOnX3Err
        )throws Exception;
    // ------------------------------------------
    // Andere Methode (aMethod) mit Schlüssel wie Parameter
    public IXtdAjaxResult callObjActionKey(
            String aInterface,
            String aMethod,
            String aQsKeys,
            boolean aFailOnX3Err
        )throws Exception;
    // ------------------------------------------
    // Andere Methode (aMethod) mit XML-Objektdaten wie Parameter
    public IXtdAjaxResult callObjActionData(
            String aInterface,
            String aMethod,
            String aJSONData,
            boolean aFailOnX3Err
        )throws Exception;
    // ------------------------------------------
    //Aufruf Auswahlliste links
    public IXtdAjaxResult callObjQuery(
            String aInterface,
            String aQsKeys,
            boolean aFailOnX3Err
        )throws Exception;
    /*------------ Trace ------------*/
    // XTEND-Protokoll, im Zugriff über den Browser
    // True, wenn das Protokoll aktiviert ist
    public boolean traceOn();
    // ------------------------------------------
    // Beginn eines Protokollblocks
    public void traceBeginStep(String aTrace);
    // ------------------------------------------
    // Protkoll
    public void traceWrite(String aTrace);
    // ------------------------------------------
    // Ende eines Protokollblocks
    public void traceEndStep();
    /*------------ Sonstiges------------*/
    // Gibt die Zugriffs-URL auf die XTEND-Webanwendung zurück
    //http://host:port/xtend - ouhttps://host:portssl/xtend
    public String getWebApplicationUrl(boolean aSecure);
}

Ergebnisschnittstelle

public interface IXtdAjaxResult
{
    // ------------------------------------------
    // Vom Webservice zurückgegebene JSON-Daten
    public String getResponseBody();
    // ------------------------------------------
    // Länge der JSON-Daten
    public int getResponseBodyLength();
    // ------------------------------------------
    // True, wenn X3-Meldung
    public boolean hasMessage();
    // ------------------------------------------
    //True, wenn X3-Fehlermeldung
    public boolean hasMsgErr();
    // ------------------------------------------
    //True, wenn X3-Warnung
    public boolean hasMsgWarn();
    // ------------------------------------------
    //True, wenn X3-Hinweis
    public boolean hasMsgInfo();
    // ------------------------------------------
    // Liste der X3-Fehlermeldungen
    public String[] getMsgErrLst();
    // ------------------------------------------
    // Liste der X3-Warnungen
    public String[] getMsgWarnLst();
    // ------------------------------------------
    // Liste der X3-Hinweise
    public String[] getMsgInfoLst();
}

Librairie xtdWsvc.js

Diese Bibliothek umfasst Bearbeitungswerkzeuge für:

  • Aufrufparameter der Webservices
  • JSON-Ergebnis eines Webservice-Aufrufs
  • generiertes HTML

Diese Bibliothek verwendet die Bibliothek xtdPrototype.js.

Parameter- und Ergebnisverwaltung

/*------------------ INCLUDE ------------------*/
// Die Bibliothek muss immer inkludiert werden xtdPrototype.js
#include "xtdPrototype.js"

/*------------------ OBJETS JAVA/JAVASCRIPT -------------------*/
// Gibt true zurück, wenn es sich bei aObj um ein JAVA-Objekt handelt
// Gibt false zurück, wenn es sich bei aObj um ein JavaScript-Objekt handelt
Object.xtdIsJava(aObj);
//-----------------------------------------------
// Ermöglicht die Umwandlung eines Java- oder JavaScript-Objektes in einen String.
Object.xtdToString(aObj);

/*------------------ PARAMETRES ------------------*/
// Gibt die Parameter für den Aufruf eines Webservice zurück
//Classe XTENDWSVC.classParam
//aOptionsJson = JSON-Optionen (Classe XTENDWSVC.classJsonOpt)
XTENDWSVC.newParam(aOptionsJson);
//-----------------------------------------------
// Gibt die Parameter für den Aufruf eines X3-OBJEKT-Webservice zurück
// Klasse XTENDWSVC.classParamObject
//->aTimeStampX3 ist ein String, der den TimeStamp des X3-Objekts enthält
//->aTimeStampX3 ="", falls kein TimeStamp
XTENDWSVC.newParamXtdObject(aTimeStampX3,aOptionsJson);
//-----------------------------------------------
// Gibt die Parameter für den Aufruf eines Unterprogramm-Webservice zurück
// Klasse XTENDWSVC.classParamXtdSpg
XTENDWSVC.newParamXtdSpg(aOptionsJson);
//-----------------------------------------------
// Gibt die Parameter für den Aufruf eines Unterprogramm-Webservice
// vom Typ 'Datenzugriff' zurück. Fügt die spezifischen Parameter hinzu
// Klasse XTENDWSVC.classParamXtdSpgAccess
//->aNbLines enthält die Anzahl der zurückzugebenden Zeilen
//->aStartAt enthält den Rang der Startzeile (Seitenumbruch)
XTENDWSVC.newParamXtdSpgAccess(aNbLines,aStartAt,aOptionsJson);

/*------------------ ERGEBNIS ------------------*/
// Wertet die Zeichenkette aJSON als Ergebnis eines X3-Webservice aus
// Gibt ein JavaScript-Objekt zurück
XTENDWSVC.evalResult(aJSON);
//-----------------------------------------------
// Wertet das Ergebnis eines Unterprogramms aus
// Fügt dem Ergebnistyp spezifische Methoden hinzu
// Methoden XTENDWSVC.methodsResultSpg
XTENDWSVC.evalResultSpg(aJSON);
//-----------------------------------------------
// Wertet das Ergebnis eines "Datenzugriff"-Unterprogramms aus
// Fügt dem Ergebnistyp spezifische Methoden hinzu
//Methoden XTENDWSVC.methodsResultSpg
XTENDWSVC.evalResultSpgAccess(aJSON);
//-----------------------------------------------
// Wertet das Ergebnis eines Objekt-Webservice aus
// Fügt dem Ergebnistyp spezifische Methoden hinzu
// Methoden XTENDWSVC.methodsResultObject
XTENDWSVC.evalResultObject(aJSON);

/*------------------ PARAMETERKLASSEN -------------------*/
XTENDWSVC.classParam=Class.create({
    // Gibt die JSON-Optionen zurück
    options:function();
    // Fügt den Parameter aCode mit dem Wert aValue hinzu
    add:function(aCode,aValue);
});
//-----------------------------------------------
XTENDWSVC.classParamXtdSpg=Class.create(XTENDWSVC.classParam,{
    // Fügt der Gruppe AXPAR einen Parameter e aCode hinzu
    addAXPAR:function(aCode,aValue);   
});


/*------------------ ERGEBNISOBJEKT -------------------*/
// Ergebnis Unterprogrammaufruf
methodsResultSpg:{
    // Gibt den Wert String des Parameters aCode der Gruppe AXPAR zurück
    AXPAR:function(aCode);
    // Gibt den Integerwert des Parameters aCode der Gruppe AXPAR zurück
    // aDefValue = Wert, wenn Parameter nicht gefunden
    AXPARInt:function(aCode,aDefValue);
}
//-----------------------------------------------
//Ergebnis eines "Datenzugriff"-Unterprogramms
// Mit den Methoden kann der Seitenumbruch verwaltet werden
methodsResultSpgAccess:{
    // Anzahl angeforderte Datensätze
    askedRecords:function();
    // Anzahl Datensätze insgesamt
    totalRecords:function();
    // Anzahl zurückgegebene Datensätze
    returnedRecords:function();
    // Startrang
    startRank:function();
    // True, falls weitere Datensätze vorhanden sind
    hasNext:function();
}
//-----------------------------------------------
// Ergebnis des Aufrufs eines Unterprogramms vom Typ "X3-Objekt"
// Mit den Methoden kann auf die Daten der letzten Änderung zugegriffen werden
methodsResultObject:{
    // Gibt den Wert des Feldes aField für die Gruppe ADXTEC zurück
    adxADXTEC:function(aField);
    // Gibt den TimeStamp zurück
    adxTimeStamp:function();
    // Gibt den Code des letzten Benutzers zurück, der das Objekt geändert hat
    adxUser:function();
}

JSON-Optionen

XTENDWSVC.classJsonOpt=Class.create({
    // Keine Veröffentlichungsgruppen als Rückgabe
    // Alle Parameter sind String-Tabellen
    noGroups:function();
    // Keine Zeilen mit dim > 1 in den Tabellen
    // Alle Parameter sind String-Tabellen
    noRows:function();   
    // Keine Labels für Lokale Menüs
    noLabels:function();
    // Clob-Felder werden nicht zurückgegeben
    noClobs:function();
    // Mit Ausnahme der in aValue enthaltenen Gruppen
    //aValue ist ein String oder ein Array of string
    excludeGrp:function(aValue);
    // Inkl. in aValue enthaltene Gruppen
    includeGrp:function(aValue);
    // Mit Ausnahme der in aValue enthaltenen Felder
    //aValue ist ein String oder ein Array of string
    excludeFld:function(aValue);
    // Inkludiert in aValue enthaltene Felder
    includeFld:function(aValue);
});

Beispiel:

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

// AnlageAufrufparameter Unterprogramm
var wParams=XTENDWSVC.newParamXtdSpg();
wParams.add("AXUSERCODE",wInput.P1);
wParams.add("AXPWD",wInput.P2);
wParams.options().noGroups().includeGrp(["AXLOG_X3"]

Aufbau des HTML

Die Bibliothek umfasst die Klasse XTENDWSVC.classHTMLBuffer , mit der eine an den Client zu sendende HTML-Antwort aufgebaut werden kann.

Beispiel für den Aufruf eines Unterprogramms

Dieses Beispiel ruft die Schnittstelle IXTDLOGIN (Unterprogramm zur Anmeldung) auf:

  • Parameter anlegen
  • Unterprogramm aufrufen
  • Ergebnis verarbeiten
      • Fehler Anzeigen
      • Zeigt eine HTML-Tabelle mit den vom Unterprogramm zurückgegebenen X3-Anmeldedaten an.

GESAY_ADV_SCRIPTING_1.jpg

Bei diesem Beispiel wurde berücksichtigt, dass die Verwendung von Token in diesem Fall viel einfacher ist.

#include 'libs\xtdWsvc.js'
function callXTDLogin(){
    // Parameter user/password 
    var wInput={P1:'dis001',P2:'adonix'};
    // Protokoll eingeschaltet?
    var wTraceOn=XTD_CTX.traceOn();
    if(wTraceOn){
    // Beginn Parameterprotokollblock
        XTD_CTX.traceBeginStep("Build WSVC params");
        XTD_CTX.traceWrite("P1="+wInput.P1+ " - P2="+wInput.P2);
    }
    // Anlage Parameterobjekt Unterprogramm
    var wParams=XTENDWSVC.newParamXtdSpg();
    // Parameterbelegung
    // AXUSERCODE und APWD = Namen der verwendeten Parameter
    // Übergabe von user/password
    wParams.add("AXUSERCODE",wInput.P1);
    wParams.add("AXPWD",wInput.P2);
    // Hinzufügung der JSON-Optionen für den Unterprogrammaufruf
    wParams.options().noGroups().includeGrp(["AXLOG_X3"]);
    // Übergabe der JSON-Parameter an den Webservice (wie XML-Parameter)
    wParams=Object.toJSON(wParams);
    if(wTraceOn){
        // Ende Parameterprotokollblock
        XTD_CTX.traceWrite(wParams);
        XTD_CTX.traceEndStep();
    }
    // Beginn Aufrufprotokollblock
    if(wTraceOn)XTD_CTX.traceBeginStep("Call spg");
    // Unterprogrammaufruf
    //->false für die Verarbeitung von X3-Fehlern durch das Programm
    var wResult=XTD_CTX.callSpgRun("AXTDLOGIN",wParams,false);
    if (wResult.hasMsgErr()){
        //Fehlerbehandlung
        if(wTraceOn) XTD_CTX.traceWrite("Error message");
        var wLst=$A(wResult.getMsgErrLst());
        print("<span class='intUserMsg'>"+wLst.join('\n')+"</span>");
    }else{
        // Ergebnisverarbeitung
        // Auswertung der JSON-Daten
        var wJSON=XTENDWSVC.evalResultSpg(wResult.getResponseBody());
        // Protokoll
        if(wTraceOn) XTD_CTX.traceWrite(Object.toJSON(wJSON));
        // Aufbau der HTML-Antwort
        //->Tabelle der Zugriffscodes auf die verschiedenen X3-Ordner 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++)
                // Verwaltung der Stile pro geänderter Zeile
                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();
    }
}

Aufruf eines Skriptes mit AJAX

Die Schnittstelle IXtdAjaxScriptContext für per AJAX-Abfrage aufgerufene Skripte über das Objekt XTD_CTX zur Verfügung.

Schnittstellenfunktionalitäten:

  • Webservice-Aufruf (Schnittstelle IXtdJsWsvcCall)
  • Zugriff auf den Sitzungskontext
  • Lesen des Inhalts (Body) und der Parameter der HTTP-Abfrage
  • Aktualisierung des ContentTypes des Ergebnisses

Mit der print -Anweisung werden die Daten in einen Zeichenbuffer geschrieben, der mit dem über die Methode setHttpContenType spezifizierten ContentTypean den Client zurückgegeben wird.

// Erbt von der Aufrufschnittstelle der IXtdJsWsvcCall-Webservices
public interface IXtdAjaxScriptContext extends IXtdJsWsvcCall
{
    // Inhalt {{body}} der HTTP-Abfrage im TEXT-Format
    public String getHttpBody();
    // JSON-Array, der die Parametertabelle (Schlüssel / Wert) der Abfrage umfasst
    // Nützlich beim Format application/x-www-form-urlencoded
    public String getHttpParams();
    // Aktualisierung des ContenTypes der Antwort
    public void setHttpContenType(String aStr);
    // Anmeldung Benutzer
    public boolean userLogged();
    public String userCode();
    public String userProfile();
    public String userLang();
    // Zugriff auf die Sitzungsfelder
    public Object getSessField(String aFieldName);
    public Object getSessField(String aFieldName, boolean aFormated);
    public void setSessField(String aFieldName, String aValue);
    // Rückgabe der Benutzerdaten
    public IXtdJsData getUserInfo();
    // Rückgabe der Benutzervariablen
    public IXtdJsData getUserVariables();
    // Rückgabe einer Aktions-Entität
    public IXtdJsActEntity getActionEntity(String aEntityCode, boolean aCreate);
    // Löschen einer Aktions-Entität
    public void removeActionEntity(String aEntityCode);
    // Verwaltung der Antwortmeldungen
    void addMsgErr(String aMsg);
    void addMsgWarn(String aMsg);
    void addMsgInfo(String aMsg);
}