Adaptive Planning-Funktionen

Funktion Verbindung testen

Kontextparameter

Die Verbindung testen wird mit dem 1-Parameter "context" bereitgestellt.

Methode	Parameter	Rückgabeart	Beschreibung
getDataSource()		ai.dataSource	Gibt die aktive Datenquelle zurück.
getCalendar()		ai.calendar	Gibt zurück Adaptive Planning Kalender

Beispiel

function testConnection(context) {
    // Step 1: Create a https request to send to Earthquake USGS API
    var url = 'https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/all_hour.atom';
    var method = 'GET';
    var body = ``;
    var headers = {};
    // Step 2: Send request and receive response
    try{
    
        var response = ai.https.request(url, method, body, headers);
        ai.log.logInfo("Test Connection Successful");
       }
    catch(e)
    {
    
        ai.log.logInfo("Test Connection Failed");
    }
    // Step 3: Interrogate response to see if it was successful. Return true or false depending on the result.
    if (response.getHttpCode() == '200') {
        var body = response.getBody();
        return true;
    } else {
        return false;
    }
}

Funktion „Struktur importieren“.

Kontextparameter

Die Funktion "Struktur importieren" wird mit dem Parameter "context" bereitgestellt.

Methode	Parameter	Rückgabeart	Beschreibung
getDataSource()		ai.dataSource	Gibt die aktive Datenquelle zurück.
getProgressManager()		ai.progressManager	Gibt ein Objekt zurück, mit dem der Fertigstellungsgrad der Aufgabe Struktur importieren aktualisiert werden kann.
getStructureBuilder()		ai.structure.structureBuilder	Gibt ein Objekt zurück, das zum Erstellen der Datenquellenstruktur verwendet wird – Tabellen, Spalten, Parameter usw.
getCalendar()		ai.calendar	Gibt zurück Adaptive Planning Kalender

Beispiel

function importStructure(context) {
    //getDataSource
    var dataSource=context.getDataSource();
    // getStructureBuilder
    var builder = context.getStructureBuilder();
    //getCalendar
    var calendar= context.getCalendar();
  }

ai.progressManager

Mit dem Objekt ai.progressManager kann ein Benutzer den Fertigstellungsgrad der Aufgabe, die das Skript Struktur importieren ausführt, manuell festlegen. Auf die Skriptausführung entfällt 70 % des Gesamtprozentsatzes der Aufgabe. Daher werden die über ai.progressManager definierten Fortschrittswerte skaliert, um den Fortschritt der Gesamtaufgabe darzustellen. Beispiel: Wenn Sie den Fertigstellungsgrad für ai.progressManager auf 100 % setzen, entspräche dies 70 % der laufenden Aufgabe, 50 % entspräche 35 % der laufenden Aufgabe und so weiter.

Funktionen

Methode	Parameter	Rückgabeart	Beschreibung
getProgress()		Zahl	Gibt den Fertigstellungsgrad des Skripts zurück, der vom Benutzer definiert wurde. Wenn der Benutzer den Fertigstellungsgrad zuvor nicht festgelegt hat, gibt diese Funktion 0 zurück.
setProgress( value )	value: Zahlenwert, auf den der Prozentsatz für die Fertigstellung des Skripts festgelegt werden soll		Legt den Fertigstellungsgrad des Skripts fest. Das funktioniert wie folgt: Es werden nur numerische Werte akzeptiert, z. B. 0, 10, 22,5 100, 110. Werte größer als 100 werden als 100 behandelt. Werte, die kleiner sind als der aktuelle Skriptfortschritt, werden ignoriert. Beispiel: Rufen Sie setProgress(50) gefolgt von setProgress(40) auf. Dies führt dazu, dass der Prozentsatz für den Fertigstellungsgrad des Skripts 50 % beträgt. Alle anderen Eingabearten für "Wert" haben keine Auswirkungen auf den Fortschritt des Skripts.

Beispiel

function importStructure(context) {    
    ..........
 
 
    var progressManager = context.getProgressManager();
 
 
    // Set script progress % to 10
    progressManager.setProgress(10);
 
 
    // Increase script progress % to 50
    progressManager.setProgress(50.0);
 
 
    // Set progress to 100 by using value greater than 100
    progressManager.setProgress(230);
    progressManager.getProgress(); // returns 100
 
 
    // Increase progress by 10% based on current progress
    progressManager.setProgress(progressManager.getProgress() + 10);
 
 
 
 
    ..........
    return builder;
 }

ai.structure.structureBuilder

Funktionen

Methode	Parameter	Retouren	Beschreibung
addTable(Tabellen-ID)	tableId: Zeichenfolge Eindeutige ID der Tabelle	ai.structure.editableTable	Erstellt eine neue Tabelle für die Datenquelle und gibt sie zurück.

Beispiel

Bietet die Möglichkeit, die Tabellen und Spaltenstrukturen zu definieren, die mit Daten ausgefüllt werden.

function importStructure(context) {
........
//getStructureBuilder
    var builder = context.getStructureBuilder();
//Example addTable( tableId )-"Sample"
    var table = builder.addTable("Sample");
....... 
}

ai.structure.editableTable

Funktionen

Methode	Parameter	Retouren	Beschreibung
setAnzeigeName(AnzeigeName)	displayName: Zeichenfolgenwert, um die Eigenschaft „Anzeigename“ der Tabelle auf „Anzeigen“ zu setzen.	ai.structure.editableTable	Legt den Anzeigenamen der Tabelle fest.
addColumn( columnId )	columnId: Zeichenfolge RemoteId der Spalte	ai.structure.editableColumn	Erstellt eine neue untergeordnete Spalte der Tabelle und gibt sie zurück.
addRequiredParameter( parameterId )	parameterId: Zeichenfolgen-ID des Parameters	ai.structure.editableParameter	Erstellt einen neuen erforderlichen Parameter für die Tabelle und gibt ihn zurück. Ein zuweisbarer Parameter muss als Wert eines erforderlichen Parameters festgelegt werden, wenn diese Tabelle als Teil von ImportData oder ImportStructure verwendet wird.

ai.structure.editableColumn

Funktionen

Methode	Parameter	Retouren	Beschreibung
setDisplayName( value )	value: Zeichenfolgenwert, um die Anzeigenamen-Eigenschaft der Spalten auf zu setzen	ai.structure.editableColumn	Legt den Anzeigenamen der Spalte fest.
setDisplayOrder( value )	value: Zeichenfolgenwert, um die displayOrder-Eigenschaft der Spalten auf zu setzen	ai.structure.editableColumn	Legt die Anzeigereihenfolge der Spalte fest.
setIncludeByDefault( Wert)	value: Boolescher Wert, um die Spalteneigenschaft IsEnabled auf zu setzen	ai.structure.editableColumn	Legt fest, dass die Spalte für den Datenimport aktiviert werden soll.
setIncludeInKey( Wert)	value: Boolescher Wert, um die Eigenschaft includeInKey der Spalten auf zu setzen	ai.structure.editableColumn	Gibt an, ob die Spalte Teil des Tabellenschlüssels ist.
setMandatoryForImports( Wert)	value: Boolescher Wert, um anzugeben, ob diese Spalte für den Datenimport obligatorisch aktiviert ist	ai.structure.editableColumn	Legt fest, dass die Spalte so, dass sie für den Datenimport obligatorisch aktiviert wird.
setNonFilterable(Wert)	value: Boolescher Wert, um die Eigenschaft nonFilterable der Spalten auf zu setzen	ai.structure.editableColumn	Gibt an, ob die Spalte in einer Remote-Abfrage enthalten sein kann.
setRemoteColumnType( value )	value: Zeichenfolgenwert, um die Eigenschaft „remoteColumnType“ der Spalte auf zu setzen	ai.structure.editableColumn	Legt den Remote-Datentyp der Spalte fest, z. B. "Zeichenfolge", "Integer" usw
setTextColumnType( length )	Length: Ganzzahl - Maximale Länge der Werte, die diese Spalte enthalten kann	ai.structure.editableColumn	Macht die Spalte zu einer Textspalte.
setIntegerColumnType()		ai.structure.editableColumn	Macht die Spalte zu einer Ganzzahl-Spalte.
setFloatColumnType()		ai.structure.editableColumn	Macht die Spalte zu einer Spalte mit doppelter Genauigkeit.
setBooleanColumnType()		ai.structure.editableColumn	Macht die Spalte zu einer booleschen Spalte.
setDateTimeColumnType()		ai.structure.editableColumn	Macht die Spalte zu einer Datums-/Zeitspalte.

ai.structure.editableParameter

Funktionen

Methode	Parameter	Retouren	Beschreibung
setDisplayName( value )	value: Zeichenfolgenwert, um die displayName-Eigenschaft des Parameters auf zu setzen		Legt den Anzeigenamen des Parameters fest.
setForDataImport( value )	value: Boolescher Wert, der angibt, ob auf den Parameter in einem ImportData-Skript zugegriffen werden kann		Aktiviert den Parameter für den Datenimport.
setTypePeriodRange()			Ändert die Art des Parameters in einen Periodenbereich

Beispiel

function importStructure(context) {
...............
    //addColumn
    var valueColumn= table.addColumn('Value');
    //setDisplayName
    valueColumn.setDisplayName('Value');
    // Set the data type for the column - Can be Integer, Float, DateTime or Boolean values
    valueColumn.setFloatColumnType();
    //setDisplayOrder
    valueColumn.setDisplayOrder('0');
    //setIncludeByDefault
    valueColumn.setIncludeByDefault(true);
    //setRemoteColumnType
    valueColumn.setRemoteColumnType('float');
    // setIncludeInKey
    valueColumn.setIncludeInKey(false);
    //setMandatoryForImports
     valueColumn.setMandatoryForImports(false);
..............
}

Funktion „Daten importieren“.

Kontextparameter

Die Funktion "Daten importieren" wird mit dem Parameter "Kontext" bereitgestellt.

Methode	Parameter	Rückgabeart	Beschreibung
getRowset() Generiert eine API-Veraltungswarnung in den Protokollen, nachdem die Unterstützung von „getRowset(ColumnIds)“ auf Ihre Anforderung mit dem Release 2021R1 aktiviert wurde. Die Methode „getRowset()“ funktioniert weiterhin, ignoriert jedoch alle Parameter.		ai.rowset	Gibt das Rowset-Objekt zurück, zu dem Zeilen hinzugefügt werden. Das Rowset definiert die Tabelle, die Spalten und die MaxRows.
getRowset([columnIds]) Öffnen Sie einen Fall im Workday-Kundencenter, um das Feature Flag „ Benutzerdefinierte Cloud-Services lesen Staging-Tabellen nach angegebenen Spalten “ zu aktivieren.	[Column Ids]	ai.rowset	Gibt das Rowset-Objekt zurück, zu dem Zeilen hinzugefügt werden, in der angegebenen Spaltenreihenfolge. Das Rowset definiert die Tabelle, die Spalten und die MaxRows.
getDataSource()		ai.dataSource	Gibt die aktive Datenquelle zurück.
getCalendar()		ai.calendar	Gibt zurück Adaptive Planning Kalender

Beispiel

In diesem Beispiel wird davon ausgegangen, dass das Rowset eine Ganzzahl-Spalte und eine Text-Spalte in der angegebenen Reihenfolge enthält.

function importData(context) {
...........
   var rowset = context.getRowset();
..........
    var rowset= context.getRowset([ 'NAME', 'ID']);
}

ai.rowset

Das Rowset-Objekt ist der Mechanismus, mit dem „Zeilen“ in einem Benutzerskript in den Integration-Stapel übertragen werden. Ein Zeilensatz modelliert die Form (Spaltennamen und ihre Datentypen, maxRows und tableId) der Tabelle, für die ein Benutzer entweder sein VorschauData- oder ImportData-Skript ausführt.

Funktionen

Methode	Parameter	Rückgabeart	Beschreibung
addRow( Zellen)	Zellen: Array<Primitive Types> Array von Werten für jede Spalte in der angegebenen Reihenfolge		Fügt ein Array von Zellenwerten als Zeile zum Zeilensatz hinzu. Zellenwerte müssen entweder ein gültiges Objekt vom Typ Zeichenfolge (können null sein), Zahl (endliche Ganzzahl oder Dezimalzahl), Boolesch oder Datum sein. Jede Zellenwertart muss mit dem entsprechenden Spaltendatentyp in der durch getColumnNames definierten Reihenfolge übereinstimmen. Die Anzahl der Zellenwerte muss mit der Anzahl der definierten Spalten übereinstimmen.
getTableId()		String	Gibt die Tabellen-ID der Tabelle zurück, die in der Vorschau angezeigt wird.
getMaxRows()		Ganzzahl	Gibt die maximal zulässige Zeilenanzahl in diesem Rowset zurück. 0 bedeutet unbekannt, wie von ImportData verwendet.
getColumns()		Array<ai.dataSource.table.column>	Gibt die für die Vorschau ausgewählten Tabellenspalten zurück.
setSMartParsingEnabled( val )	val: Boolescher Wert, der angibt, ob dieses Feature aktiviert oder deaktiviert werden soll		Wenn Sie diese Einstellung aktivieren, wird jeder Zeichenfolgenzellenwert während der Funktion addRow() automatisch in den erforderlichen Datentyp der Zielspalten geparst. Dadurch erspart ein Benutzer das Suchen des Datentyps einer Zielspalte und das manuelle Parsing, wenn der Datentyp des Werts für die aktuelle Zelle nicht mit dem Datentyp der Zielspalten übereinstimmt. Dies ist besonders hilfreich, wenn es sich um APIs von Drittanbietern handelt, die alle Zeilenwerte als Zeichenfolgen über JSON oder XML zurückgeben und jeder Zellenwert erfolgreich in Integer-, Float-, Boolesche oder DateTime-Werte geparst werden kann.
getSmartParsingEnabled()		Boolesch	Gibt „true“ zurück, wenn diese Einstellung aktiviert ist. Der Standardwert ist „false“.

function importData(context) {
    var dataSource = context.getDataSource();
    var settings = dataSource.getSettings();
    var rowset = context.getRowset();
    
    //Set and Get SmartParsingEnabled() value
    rowset.setSmartParsingEnabled(true);
    ai.log.logInfo(getSmartParsingEnabled()); //true
    
    //Set a Start date and End date in the Designer Settings tab with the name "Period Range"
    var startDateString = dataSource.getSetting("Period Range").getValue().getFromPeriodStartDateTime().substring(0, 10);
    var endDateString = dataSource.getSetting("Period Range").getValue().getToPeriodEndDateTime().substring(0, 10);
    
    //get columns
    var columns = rowset.getColumns();

    for (var i = 0; i < dataSample.rows.length; i++) {
        var colName;
        var cells = [];
        for (var j = 0; j < columns.length; j++) {
            var colValue;
            var re = /\\\-/g;
            if ((new Date(dataSample.rows[i]["Effective Date"]) >= new Date(startDateString)) && (new Date(dataSample.rows[i]["Effective Date"]) < new Date(endDateString))) {
                colName = columns[j].getId();
                colValue = dataSample.rows[i][colName];
                cells.push(colValue.toString().replace(re, '.'));

            }
        }
        if (cells.length == columns.length) {
            //add rows
            rowset.addRow(cells);
        }
    }
}  

Funktion „Datenvorschau anzeigen“.

Kontextparameter

Die Funktion „Datenvorschau anzeigen“ wird mit dem Parameter "Kontext" bereitgestellt.

Methode	Parameter	Rückgabeart	Beschreibung
getDataSource()		ai.dataSource	Gibt die aktive Datenquelle zurück.
getRowset()		ai.rowset	Gibt das Rowset-Objekt zurück, zu dem Zeilen hinzugefügt werden. Das Rowset definiert die Tabelle, die Spalten und die MaxRows.
getCalendar()		ai.calendar	Gibt zurück Adaptive Planning Kalender

Beispiel

Bietet die Möglichkeit, eine Vorschau der in der Cloud-Quelle gespeicherten Daten anzuzeigen.

function previewData(context) {

    var dataSource = context.getDataSource();
    var settings = dataSource.getSettings();
    var rowset = context.getRowset();
    
    //Set and Get SmartParsingEnabled() value
    rowset.setSmartParsingEnabled(true);
    ai.log.logInfo(getSmartParsingEnabled()); //true
    
    //Set a Start date and End date in the Designer Settings tab with the name "Period Range"
    var startDateString = dataSource.getSetting("Period Range").getValue().getFromPeriodStartDateTime().substring(0, 10);
    var endDateString = dataSource.getSetting("Period Range").getValue().getToPeriodEndDateTime().substring(0, 10);
    
    //get columns
    var columns = rowset.getColumns();

    for (var i = 0; i < dataSample.rows.length; i++) {
        var colName;
        var cells = [];
        for (var j = 0; j < columns.length; j++) {
            var colValue;
            var re = /\\\-/g;
            if ((new Date(dataSample.rows[i]["Effective Date"]) >= new Date(startDateString)) && (new Date(dataSample.rows[i]["Effective Date"]) < new Date(endDateString))) {
                colName = columns[j].getId();
                colValue = dataSample.rows[i][colName];
                cells.push(colValue.toString().replace(re, '.'));

            }
        }
        if (cells.length == columns.length) {
            //add rows
            rowset.addRow(cells);
        }
    }
}  

Beispiel für kombinierten Verbindungstest, Import und Vorschau von Daten

//Consider a static JSON Data Sample set
dataSample = {
              rows: [
                        {"Value": 10, "Measure": "", "Test": "Palo Alto", "Effective Date": "2018-11-01"},
                        {"Value": 20, "Measure": " ", "Test": "Palo Alto", "Effective Date": "2018-11-01"},
                        {"Value": 30, "Measure": "  ", "Test": "Palo Alto", "Effective Date": "2018-11-01"},
                        {"Value": 40, "Measure": "   ", "Test": "Palo Alto", "Effective Date": "2018-11-01"},
                        {"Value": 50, "Measure": "1 ", "Test": "Pleasanton", "Effective Date": "2018-11-01"},
                        {"Value": 10, "Measure": "2  ", "Test": "Pleasanton", "Effective Date": "2018-12-01"},
                        {"Value": 20, "Measure": "3   ", "Test": "Pleasanton", "Effective Date": "2018-12-01"},
                        {"Value": 30, "Measure": "4    ", "Test": "Pleasanton", "Effective Date": "2018-12-01"},
                        {"Value": 40, "Measure": "5     ", "Test": "Pleasanton", "Effective Date": "2018-12-01"}
                    ]
               };
               
//Table Definition
ExternalMetadataDefinition = {
    Tables: [{
        name: "dataSample",
        displayName: "Sample",
        columns: [{
            name: "Value",
            displayName: "Value",
            type: "float",
            includeByDefault: true
        }, {
            name: "Measure",
            displayName: "Measure",
            includeByDefault: true
        }, {
            name: "Test",
            displayName: "Test",
            includeByDefault: true
        }, {
            name: "Effective Date",
            displayName: "Date",
            type: "datetime",
            includeByDefault: true
        }]
    }]
};                              
//Since this example uses a static data source,testConnection() function can return true
function testConnection(context) {
    return true;
}

//Import Structure
function importStructure(context) {    
        var addColumn = function(table, column, order) 
        {
            var recordColumn = table.addColumn(column.name);
            recordColumn.setDisplayName(column.displayName);
            switch (column.type) 
            {
                case "text":
                    recordColumn.setTextColumnType(column.length);
                break;
                case "int":
                    recordColumn.setIntegerColumnType();
                break;
                case "float":
                    recordColumn.setFloatColumnType();
                break;
                case "boolean":
                    recordColumn.setBooleanColumnType();
                break;
                case "datetime":
                    recordColumn.setDateTimeColumnType();
                break;
                default:
                    recordColumn.setTextColumnType(200);
                break;
          }
            recordColumn.setDisplayOrder(order);
            recordColumn.setIncludeByDefault(column.includeByDefault || false);
            recordColumn.setIncludeInKey(column.includeInKey || false);
            recordColumn.setMandatoryForImports(column.mandatoryForImport || false);
            recordColumn.setRemoteColumnType(column.remoteColumnType || "String");
        };    
     var builder = context.getStructureBuilder();    
     for (var i = 0; i < ExternalMetadataDefinition.Tables.length; i++)
     {
        var externalTable = ExternalMetadataDefinition.Tables[i];
        var table = builder.addTable(externalTable.name);
        table.setDisplayName(externalTable.displayName);        
        for (var j = 0; j < externalTable.columns.length; j++) 
        {
            addColumn(table, externalTable.columns[j], j + 1);
        }
    }
}
function previewData(context) {
    //Since the data is static, previewData() function can invoke importData()
    importData(context);
}
function importData(context) {
    var dataSource = context.getDataSource();
    var settings = dataSource.getSettings();
    var rowset = context.getRowset();
    
    //Set and Get SmartParsingEnabled() value
    rowset.setSmartParsingEnabled(true);
    ai.log.logInfo(getSmartParsingEnabled()); //true
    
    //Set a Start date and End date in the Designer Settings tab with the name "Period Range"
    var startDateString = dataSource.getSetting("Period Range").getValue().getFromPeriodStartDateTime().substring(0, 10);
    var endDateString = dataSource.getSetting("Period Range").getValue().getToPeriodEndDateTime().substring(0, 10);
    
    //get columns
    var columns = rowset.getColumns();

    for (var i = 0; i < dataSample.rows.length; i++) {
        var colName;
        var cells = [];
        for (var j = 0; j < columns.length; j++) {
            var colValue;
            var re = /\\\-/g;
            if ((new Date(dataSample.rows[i]["Effective Date"]) >= new Date(startDateString)) && (new Date(dataSample.rows[i]["Effective Date"]) < new Date(endDateString))) {
                colName = columns[j].getId();
                colValue = dataSample.rows[i][colName];
                cells.push(colValue.toString().replace(re, '.'));

            }
        }
        if (cells.length == columns.length) {
            //add rows
            rowset.addRow(cells);
        }
    }
}  

Funktion „Daten exportieren“ (Nur benutzerdefinierter Cloud-Loader)

Kontextparameter

Die Funktion "Daten exportieren" wird mit dem Parameter "Kontext" bereitgestellt.

Methode	Parameter	Rückgabeart	Beschreibung
createTableReader()	optionales Array von Spaltennamen der Quelltabelle	TableReader	Gibt die aktive Datenquelle zurück. Die Spaltenreihenfolge entspricht der Reihenfolge, die im Parameter angegeben wurde.

TableReader-Objekt

Methode	Parameter	Rückgabeart	Beschreibung
readRow()		Array von Werten	Ein Array von Werten aus der Datenquelle.

Beispiel

// Manually invoke this method via 'Run manually'
function exportData(context) {
  // Step 1: Get the data
  var reader = context.createTableReader();

  // Step 2: Process and export the data
  var row = null;
  // If reader.readRow() returns null, then there are no more records.
  while ((row = reader.readRow()) !== null) {
    // Send the row to the external system or process it for a subsequent bulk update.
    ai.log.logInfo(JSON.stringify(row));
  }
}