> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Beispielskripte

> JavaScript-Beispiele für gängige Szenarien mit Benutzerdefinierten Aktivitäten — OAuth, externe Exporte, Feldänderungen, Tabellenbearbeitung und JSON-Generierung.

Die folgenden JavaScript-Beispiele zeigen gängige Muster für Skripte in Benutzerdefinierten Aktivitäten — OAuth-Autorisierung, das Senden von Exporten an externe Dienste, das Ändern extrahierter Felder, das Bearbeiten von Tabellen, das Generieren von benutzerdefiniertem JSON und das Abrufen von Dateinamen der Quelldateien. Kopieren Sie sie und passen Sie sie an Ihre eigenen Feldnamen und Endpunkte an.

<div id="authorize-via-oauth-and-send-export-data-to-an-external-service">
  ## Über OAuth authentifizieren und Exportdaten an einen externen Dienst senden
</div>

Das folgende Skript authentifiziert sich mit einem Token, das über den Resource Owner Password Flow bezogen wurde, und sendet anschließend die Exportdaten an einen externen Dienst:

```javascript theme={null}
// Dieses Beispiel für ein benutzerdefiniertes Export-Skript zeigt, wie eine Autorisierungsanfrage für OAuth 2.0 Resource Owner Password Flow gesendet wird, das Token empfangen wird,
// und dann Exportergebnisse an das externe System im JSON-Format gesendet werden

// Bereiten Sie den Schlüssel-Wert-Body für die Autorisierungsanfrage vor (Parameter und ihre Werte können unterschiedlich sein). Die entsprechende Umgebungsvariable sollte vorher erstellt werden.
var authDataContent = {};
authDataContent.grant_type = Context.GetSecret("password_secretName");
authDataContent.scope = "openid permissions";

// Übertragen Sie sensible Daten über Umgebungsvariablen. Die entsprechenden Variablen sollten vorher erstellt werden.
authDataContent.client_id = Context.GetSecret("client_id_secretName");
authDataContent.client_secret = Context.GetSecret("client_secret_secretName");
authDataContent.password = Context.GetSecret("password_secretName");
authDataContent.username = Context.GetSecret("username_secretName");

// Erstellen Sie die Anfrage und senden Sie die Daten
var request = Context.CreateHttpRequest();
request.Url = "https://my_auth_service.com/auth2/connect/token"
request.Method = "POST";

// Erstellen Sie Inhaltsdaten für die Autorisierungsanfrage
request.SetUrlFormEncodedContent(authDataContent);
request.Send();
var authResponseObject = JSON.parse(request.ResponseText);

// Alle Exporte aus dem Dokument abrufen
var exports = Context.Transaction.Documents[0].Exports;

// Das JSON-Exportergebnis auswählen
var extractedDataExportResult = exports.find(element => element.ExportFormat === ExportFormat.Json);
var pdfExportResult = exports.find(element => element.ExportFormat === ExportFormat.Pdf);

// Inhaltsdaten für die Anfrage erstellen
var multiPartRequest = Context.CreateMultipartFormDataRequest();
multiPartRequest.Url = "https://my_service.com/api/v1.0/process_method"
multiPartRequest.Method = "POST";
multiPartRequest.AuthToken = authResponseObject.access_token;
multiPartRequest.AuthScheme = "Bearer";

// Extrahierte Daten zum Exportergebnis hinzufügen
multiPartRequest.AppendStringContent(extractedDataExportResult.ToJson(), "jsonData");

// Die exportierte PDF hinzufügen
multiPartRequest.AppendFileContent(pdfExportResult, "binaryData");

// Eine Anfrage an den Service senden
multiPartRequest.Send();

// Ein deserialisiertes Antwortergebnis abrufen
var responseObject = JSON.parse(multiPartRequest.ResponseText);
```

<div id="send-export-data-to-an-external-service">
  ## Exportdaten an einen externen Dienst senden
</div>

Das folgende Skript benennt die exportierte Datei nach der Rechnungsnummer und sendet die Exportdaten anschließend an einen externen Dienst (in diesem Fall Dropbox):

```javascript theme={null}
// Dieses benutzerdefinierte Export-Beispielskript zeigt, wie eine Datei an Dropbox gesendet
// und der Dateiname anhand des Werts eines extrahierten Datenfelds festgelegt wird.

// Exportergebnis des Dokuments abrufen
var exports = Context.Transaction.Documents[0].Exports;
var extractedDataExportResult = exports.find(element => element.ExportFormat === ExportFormat.Json);

// Zugriffstoken für die DropBox-API abrufen (https://developers.dropbox.com/en-us/oauth-guide). Die entsprechende Umgebungsvariable muss vorab erstellt werden.
var token = Context.GetSecret("access_token_secretName");

// „Rechnungsnummer" aus den extrahierten Daten abrufen
var invoiceNumberField = Context.Transaction.Documents[0].GetField("Invoice Number");
var invoiceNumber = invoiceNumberField.Value;

// Dateinamen für die Ergebnisdatei erstellen
var jsonFileName = `ExtractedData_${invoiceNumber}.json`;

// JSON-Datei mit den extrahierten Daten an DropBox senden
var httpRequest = Context.CreateHttpRequest();
httpRequest.Url = "https://content.dropboxapi.com/2/files/upload"
httpRequest.Method = "POST";
httpRequest.AuthScheme = "Bearer";
httpRequest.AuthToken = token;
httpRequest.SetHeader("Dropbox-API-Arg", `{"path": "/Files/${jsonFileName}", "mode": "add", "autorename": true, "mute": false, "strict_conflict": false}`);
httpRequest.SetFileContent(extractedDataExportResult, "application/octet-stream");
httpRequest.Send();
```

<div id="modify-extracted-data">
  ## Extrahierte Daten ändern
</div>

Das folgende Skript ändert den Wert eines vorhandenen Felds und fügt mithilfe von Informationen aus der Antwort eines externen Dienstes neue Werte für ein Wiederholungsfeld hinzu:

```javascript theme={null}
// Dieses Beispielskript für eine benutzerdefinierte Aktivität zeigt, wie ein vorhandenes Feld geändert
// und ein neuer Feldwert basierend auf den Ergebnissen eines externen Aufrufs erstellt wird.

// Alle Exporte aus dem Dokument abrufen
var exports = Context.Transaction.Documents[0].Exports;

// Das JSON-Exportergebnis aus den Exporten abrufen
var extractedDataExportResult = exports.find(element => element.ExportFormat === ExportFormat.Json);

// Das PDF-Exportergebnis aus den Exporten abrufen
var pdfExportResult = exports.find(element => element.ExportFormat === ExportFormat.Pdf);

// Eine HTTP-Anfrage erstellen und die erforderlichen Anfrageeigenschaften angeben
var multipartFormDataRequest = Context.CreateMultipartFormDataRequest();
multipartFormDataRequest.Url = "http://my_service/api/v1.0/apimethod/"
multipartFormDataRequest.Method = "POST";

// Extrahierte Daten aus dem JSON-Exportergebnis zur Anfrage hinzufügen
multipartFormDataRequest.AppendStringContent(extractedDataExportResult.ToJson(), "jsonData");
// Das PDF aus den Exportergebnissen zur Anfrage hinzufügen
multipartFormDataRequest.AppendFileContent(pdfExportResult, "binaryData");

// Das Timeout für den Abschluss der HTTP-Anfrage festlegen (in Minuten).
// Standardmäßig ist das Timeout auf 1 Minute festgelegt.
multipartFormDataRequest.Timeout = 1;

// Eine Anfrage an den Dienst senden
multipartFormDataRequest.Send();

// Das Antwortergebnis abrufen
var newJsonDataObject = JSON.parse(multipartFormDataRequest.ResponseText);

// Angenommen, folgendes JSON wurde im Antwortergebnis zurückgegeben:
/* {
    "DocumentData": {
        "Fields": {
            "InvoiceNumber": "706-222-3151",
            "InvoiceDate": "15.05.2020",
            "PurchaseOrder": [
                {
                    "OrderNumber": "25646788",
                    "Total": "540.54"
                },
                {
                    "OrderNumber": "24516684",
                    "Total": "138.43"
                }
            ]
        }
    }
}*/

// Den Wert eines vorhandenen Vantage-Dokumentfelds basierend auf Daten aus einem externen Aufruf ändern
var document = Context.Transaction.Documents[0];
var invoiceNumber = document.GetField("Invoice Number");
if (invoiceNumber.InstanceId === undefined || invoiceNumber.InstanceId === null)
    invoiceNumber.AddInstance();
invoiceNumber.Value = newJsonDataObject.DocumentData.Fields.InvoiceNumber;

// Neue Vantage-Dokumentfeldwerte basierend auf Daten aus einem externen Aufruf hinzufügen
var poOrder = Context.Transaction.Documents[0].GetField("Purchase Order");
let orderNumberFieldId = document.GetField("Purchase Order/Order Number").Id;
let totalFieldId = document.GetField("Purchase Order/Total").Id;
newJsonDataObject.DocumentData.Fields.PurchaseOrder.forEach(function (elem) {
    var newOrder = poOrder.AddInstance();
    var orderNumber = newOrder.Children.find(x => x.Id === orderNumberFieldId);
    orderNumber.Value = elem.OrderNumber;
    var total = newOrder.Children.find(x => x.Id === totalFieldId);
    total.Value = elem.Total;
});
```

<div id="retrieve-data-from-a-specific-table-column">
  ## Daten aus einer bestimmten Tabellenspalte abrufen
</div>

Das folgende Skript schreibt alle Werte (Zeilen) aus der Tabellenspalte **Description** in das Ereignisprotokoll des Vorgangs:

```javascript theme={null}
// Erstes Dokument in einem Vorgang abrufen
var document = Context.Transaction.Documents[0];
var descriptionFieldId = document.GetField("Line Items/Description").Id;

// Tabellenobjekt abrufen
var table = document.GetField("Line Items");

for (var i = 0; i < table.Instances.length; i++) {
  // 'Description'-Spaltenobjekt für jede Tabellenzeile abrufen und Werte in das Vorgangsereignisprotokoll schreiben
  var columnDescription = table.Instances[i].Children.find(x => x.Id === descriptionFieldId);
  Context.LogMessage("Description. Row " + i + ": " + columnDescription.Value);
}
```

<div id="retrieve-data-from-all-table-columns">
  ## Daten aus allen Tabellenspalten abrufen
</div>

Das folgende Skript schreibt alle Werte (Zeilen) aus allen Tabellenspalten in das Ereignisprotokoll des Vorgangs:

```javascript theme={null}
// Erstes Dokument in einem Vorgang abrufen
var document = Context.Transaction.Documents[0];

// Tabellenobjekt abrufen
var table = document.GetField("Line Items");

// Alle Tabellendaten in das Ereignisprotokoll des Vorgangs schreiben
for (var i = 0; i < table.Instances.length; i++) {
    for (var j = 0; j < table.Instances[i].Children.length; j++) {
        Context.LogMessage("Table row "+i+". Column "+table.Instances[i].Children[j].Name+": "+table.Instances[i].Children[j].Value);
    }
}
```

<div id="add-rows-to-a-table">
  ## Zeilen zu einer Tabelle hinzufügen
</div>

Das folgende Skript fügt neue Tabellenzeilen hinzu und legt Werte für die Tabellenspalten **Beschreibung** und **Menge** fest:

```javascript theme={null}
// Erstes Dokument in einem Vorgang abrufen
var document = Context.Transaction.Documents[0];

// Tabellenobjekt abrufen
var table = document.GetField("Line Items");
var descriptionFieldId = document.GetField("Line Items/Description").Id;
var quantityFieldId = document.GetField("Line Items/Quantity").Id;
var tableRowCount = table.Instances.length;

// Funktion erstellen, um eine Tabellenzeile hinzuzufügen und Werte für die Spalten „Description" und „Quantity" festzulegen
function addRow(valueDescription, valueQuantity, index) {
    table.AddInstance();
    var columnDescription = table.Instances[index].Children.find(x => x.Id === descriptionFieldId);
    columnDescription.Value = valueDescription;
    var columnQuantity = table.Instances[index].Children.find(x => x.Id === quantityFieldId);
    columnQuantity.Value = valueQuantity;
}

// Drei Zeilen hinzufügen und Werte festlegen
addRow("49910 - Gloves or mittens, NOI, in boxes", 4, tableRowCount++);
addRow("15560 - Bulk, NOI, inflated", 42, tableRowCount++);
addRow("15520 - Athletic or Sporting Goods, NOI", 24, tableRowCount++);
```

<div id="delete-rows-from-a-table">
  ## Zeilen einer Tabelle löschen
</div>

Das folgende Skript löscht alle Zeilen einer Tabelle:

```javascript theme={null}
// Das erste Dokument in einem Vorgang abrufen
var document = Context.Transaction.Documents[0];

// Das Tabellenobjekt abrufen
var table = document.GetField("Line Items");
var indexCount = table.Instances.length - 1;

// Alle Zeilen anhand ihrer Indizes löschen
for (var i = indexCount; i >= 0 ; i--) {
  table.Instances[i].Remove();
}

// Oder die gesamte Tabelle löschen
table.Remove();
```

<div id="delete-a-specific-instance-of-a-repeating-field">
  ## Eine bestimmte Instanz eines wiederholten Feldes löschen
</div>

Das folgende Skript löscht die letzte Instanz eines wiederholten Feldes:

```javascript theme={null}
// Erstes Dokument in einem Vorgang abrufen
var document = Context.Transaction.Documents[0];

// Objekt des Wiederholungsfelds abrufen
var rField = document.GetField("First Name");

// Prüfen, ob dieses Feld ein Wiederholungsfeld ist
if (rField.IsRepeatable) {
    // Letzte Instanz dieses Felds löschen
    if (rField.Instances.length >= 1) {
        rField.Instances[rField.Instances.length-1].Remove();
    }  
}
else {
    Context.LogMessage(rField.Name + " is not repeating.");
}
```

<div id="generate-a-json-file-and-send-it-to-a-third-party-system">
  ## Eine JSON-Datei erzeugen und an ein System eines Drittanbieters senden
</div>

Das folgende Skript erzeugt eine JSON-Datei in einem benutzerdefinierten Format und sendet sie an ein System eines Drittanbietiers:

```javascript theme={null}
// Dieses Beispiel für ein benutzerdefiniertes Export-Skript zeigt, wie eine JSON-Zeichenkette erstellt wird
// unter Verwendung extrahierter Invoice US-Feldwerte und diese an einen externen Endpunkt gesendet wird.
// Get the first document in the transaction.
var document = Context.Transaction.Documents[0];

// Create a JSON object and set its key/value pairs.
var extractedValues = {};
extractedValues.Total = document.GetField("Total").Value;
extractedValues.Currency = document.GetField("Currency").Value;
extractedValues.Date = document.GetField("Invoice Date").Value;

// Get repeating field values and set them as array JSON values.
extractedValues.PurchaseOrderNumber = [];
var poGroup = document.GetField("Purchase Order");
var orderNumberFieldId = document.GetField("Purchase Order/Order Number").Id;
for (var i = 0; i < poGroup.Instances.length; i++) {
  var poNumber = poGroup.Instances[i].Children.find(x => x.Id === orderNumberFieldId);
  extractedValues.PurchaseOrderNumber.push(poNumber.Value);
}

// The received JSON file is of the following format:
/* {
   "Total": 1819.14,
   "Currency": "USD",
   "Date": "2019-05-23T00:00:00.000Z",
   "PurchaseOrderNumber": [
      "012345678",
      "4500123466"
   ]
}*/

// Send a multipart/form-data request with the JSON created previously as the string content of that request.
var httpRequest = Context.CreateMultipartFormDataRequest();
httpRequest.Method = "POST";
httpRequest.Url = "https://external-endpoint.com/api/v1.0/tasks/1495c913-17bb-48d4-8041-a240e05ca9a4/process";
httpRequest.AppendStringContent(JSON.stringify(extractedValues), "jsonData");
httpRequest.Send();
```

<div id="retrieve-original-file-names">
  ## Originale Dateinamen abrufen
</div>

Das folgende Skript schreibt den ursprünglichen Dateinamen in das Feld **MyField**:

```javascript theme={null}
// Den Namen der Quelldatei abrufen und als Wert des angegebenen Felds ("MyField") festlegen
Context.Transaction.Documents.forEach( doc => {
    // Bei der Scanning Station wird der Name der Quelldatei in einen Registrierungsparameter geschrieben
    var param = doc.RegistrationParameters["SourceFileName"]; 
    doc.GetField("MyField").Value = param != null ?
        param.Value : doc.SourceFiles[0].FileName;
});
```

<div id="related-topics">
  ## Verwandte Themen
</div>

* [Benutzerdefinierte Aktivität](/de/vantage/documentation/skill-designer/process/custom-activity/custom-activity)
* [Objektmodell](/de/vantage/documentation/skill-designer/process/custom-activity/object-model)
* [Context](/de/vantage/documentation/skill-designer/process/custom-activity/context)
* [HttpRequest](/de/vantage/documentation/skill-designer/process/custom-activity/http-request)
* [MultipartFormDataRequest](/de/vantage/documentation/skill-designer/process/custom-activity/multi-part-form-data-request)
* [ExportFormat](/de/vantage/documentation/skill-designer/process/custom-activity/export-format)