> ## 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 häufige Szenarien mit erweiterten Skriptregeln — Feldvorhandensein, numerische Vergleiche, bedingte Anforderungen und Tabellenvalidierung.

Die folgenden JavaScript-Beispiele veranschaulichen gängige Muster für erweiterte Skriptregeln — das Prüfen, ob ein Feld vorhanden ist, das Vergleichen numerischer Werte, das Anwenden bedingter Validierungen und das Validieren von Tabellendaten. Kopieren Sie sie und passen Sie sie an Ihre eigenen Feldnamen und Geschäftsregeln an.

<div id="check-that-a-field-is-present">
  ## Prüfen, ob ein Feld vorhanden ist
</div>

Prüfen Sie zum Beispiel, ob das Feld `MyField` gefunden wurde und ausgefüllt ist:

```javascript theme={null}
var field = Context.GetField("MyField");

if (!field) {
  Context.CheckSucceeded = false;
  Context.ErrorMessage = 'MyField-Feld nicht gefunden';
} else if (!field.Value) {
  Context.CheckSucceeded = false;
  Context.ErrorMessage = 'MyField-Feld ist leer';
}
```

<div id="compare-floating-point-numbers">
  ## Gleitkommazahlen vergleichen
</div>

Der direkte Vergleich von Gleitkommazahlen kann zu unvorhersehbaren Ergebnissen führen. Verwenden Sie Methoden des integrierten `Math`-Objekts, um Zahlen – insbesondere Geldbeträge – zuverlässig zu vergleichen.

```javascript theme={null}
// zwei Gleitkommazahlen vergleichen
var floatField1 = Context.GetField("Number Field 1");
var floatField2 = Context.GetField("Number Field 2");
var floatVal1 = floatField1.Value;
var floatVal2 = floatField2.Value;

if (Math.round(floatVal1) === Math.round(floatVal2)) {
    return;
} else {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = 'The values are different';
}

// zwei Geldwerte vergleichen
var moneyField1 = Context.GetField("Money Field 1");
var moneyField2 = Context.GetField("Money Field 2");
var value1 = moneyField1.Value.Amount;
var value2 = moneyField2.Value.Amount;

if (Math.abs(value1 - value2) <= 0.0001) {
    return;
} else {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = 'The values are different';
}
```

<div id="require-a-non-empty-value-depending-on-another-field">
  ## Je nach anderem Feld einen nicht leeren Wert verlangen
</div>

Ein optionales Feld kann erforderlich werden, wenn der Wert eines anderen Felds dies nötig macht. Wenn `MaritalStatus` den Wert `Married` hat, sollten die Felder für den Vor- und Nachnamen des Ehepartners ausgefüllt sein.

Diese Skriptregel stellt sicher, dass sowohl `SpouseFirstName` als auch `SpouseLastName` ausgefüllt sind, wenn `MaritalStatus` den Wert `Married` hat:

```javascript theme={null}
function checkFieldValuePresence(field) {
    if (!field.Value) {
        Context.ErrorMessage = 'Wert des Felds ' + field.Name + ' darf nicht leer sein';
        return false;
    }
    return true;
}

var conditionField = Context.GetField("MaritalStatus");

if (conditionField === null) {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = 'Feld MaritalStatus nicht gefunden';
} else if (checkFieldValuePresence(conditionField)) {
    var lastName = Context.GetField("SpouseLastName");
    var firstName = Context.GetField("SpouseFirstName");
    if (conditionField.Text === "Married") {
        if (lastName === null || firstName === null) {
            Context.CheckSucceeded = false;
            Context.ErrorMessage = 'Feld für Ehepartnername nicht gefunden';
        } else if (!checkFieldValuePresence(lastName) || !checkFieldValuePresence(firstName)) {
            Context.CheckSucceeded = false;
        }
    }
} else { // Familienstand nicht ausgefüllt, Prüfung fehlgeschlagen
    Context.CheckSucceeded = false;
}
```

<div id="check-that-a-field-is-located-on-the-document">
  ## Prüfen, ob ein Feld auf dem Dokument vorhanden ist
</div>

Regeln können auch Feldwerte befüllen, auch wenn der Wert nicht auf dem Dokument aufgedruckt ist. Wenn beispielsweise mehrere Steuern anfallen, kann die Gesamtsteuer automatisch berechnet werden. In einigen Ländern ist jedoch vorgeschrieben, dass der Gesamtsteuerbetrag auf dem Dokument ausgewiesen ist.

Diese Skriptregel prüft, dass bei Belegen aus Deutschland die Gesamtsteuer im Bild vorhanden ist. Für andere Länder ist keine zusätzliche Prüfung erforderlich, da das Flag **Erforderliches Feld** für das Feld „Gesamtsteuer“ aktiviert ist:

```javascript theme={null}
function checkFieldRegion(field) {
    if (!field || !field.HasRegion) {
        Context.ErrorMessage = 'Das Feld (' + field.Name + ') ist nicht im Dokumentbild vorhanden';
        return false;
    }
    return true;
}

var conditionField = Context.GetField("CountryOfOrigin");

if (!conditionField.Value) {
    Context.ErrorMessage = 'Herkunftsland unbekannt, Steuern können nicht geprüft werden';
    Context.CheckSucceeded = false;
} else {
    var totalTaxField = Context.GetField("TotalTax");
    if (conditionField.Text === "DE" && !checkFieldRegion(totalTaxField)) {
        Context.CheckSucceeded = false;
    }
}
```

<div id="validate-the-data-in-particular-cases">
  ## Daten in besonderen Fällen validieren
</div>

Die Überprüfung, dass die Gesamtsteuer der Summe aller Steuern entspricht, kann mit einer vordefinierten Regel (**Check Sum**) erfolgen. Wenn jedoch in bestimmten Ländern eine der Steuern einen negativen Wert haben kann, lässt sich nur mit einer Skriptregel beiden Fällen gerecht werden — je nach Herkunftsland werden entweder alle Steuern addiert oder eine Rückerstattungssteuer addiert und subtrahiert.

Dieses Skript prüft, dass die Summe zweier Steuern der Gesamtsteuer entspricht, außer wenn der Beleg aus Spanien stammt. In diesem Fall kann entweder die Summe oder die Differenz der beiden der Gesamtsteuer entsprechen:

```javascript theme={null}
var conditionField = Context.GetField("CountryOfOrigin");
var totalTaxField = Context.GetField("TotalTax");
var tax1Field = Context.GetField("Tax1");
var tax2Field = Context.GetField("Tax2");

if (!conditionField.Value || !totalTaxField.Value || !tax1Field.Value || !tax2Field.Value) {
    Context.ErrorMessage = 'Steuern können nicht geprüft werden';
    Context.CheckSucceeded = false;
} else {
    if (conditionField.Text === "ES") {
        Context.CheckSucceeded = ((Math.round(tax1Field.Value - tax2Field.Value) === Math.round(totalTaxField.Value))
            || (Math.round(tax1Field.Value + tax2Field.Value) === Math.round(totalTaxField.Value)));
    } else {
        Context.CheckSucceeded = (Math.round(tax1Field.Value + tax2Field.Value) === Math.round(totalTaxField.Value));
    }
}
```

<div id="compare-a-column-sum-to-an-external-field">
  ## Eine Spaltensumme mit einem externen Feld vergleichen
</div>

Skripte können nicht nur auf reguläre Felder zugreifen, sondern auch auf Tabellenwerte. Um Regelprüfungen zu beschleunigen, empfehlen wir, Tabellen als Variablen zu speichern und anschließend diese Variablen statt der ursprünglichen Tabellen zu verwenden. Wenn eine Variable eine gesamte Tabelle enthält, können Sie die Eigenschaft [`Instances`](/de/vantage/documentation/skill-designer/document/rule-verification/field#instances) nutzen, um auf die Zeilen der Tabelle zuzugreifen, und anschließend [`GetChild`](/de/vantage/documentation/skill-designer/document/rule-verification/field#getchild) verwenden, um eine bestimmte Zelle in einer Zeile zu ermitteln.

Das folgende Beispiel summiert alle Werte in der Spalte `Total Price` und vergleicht das Ergebnis mit dem Feld `Total`:

```javascript theme={null}
var totalField = Context.GetField("Total");
var tableField = Context.GetField("MyTable");

if (!totalField) {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = "Feld Total wurde nicht gefunden";
    return;
}

if (!tableField) {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = "Feld MyTable wurde nicht gefunden";
    return;
}

var sum = 0;

for (var i = 0; i < tableField.Instances.length; i++) {
    var tableTotalField = tableField.Instances[i].GetChild("MyTable/Total Price");
    sum += tableTotalField.Value.Amount;
}

if (Math.abs(sum - totalField.Value.Amount) > 0.02) {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = "Die Summe von Total Price in der Tabelle stimmt nicht mit dem Gesamtbetrag überein";
}
```

<div id="compare-column-cells-to-an-external-field-and-list-failing-rows">
  ## Vergleichen Sie Spaltenzellen mit einem externen Feld und listen Sie fehlerhafte Zeilen auf
</div>

Mit [`Context.GetFields`](/de/vantage/documentation/skill-designer/document/rule-verification/context#getfields) können Sie auf Tabellenspalten verweisen, um jede Zelle in der Spalte abzurufen, was für Schleifen nützlich ist.

Das folgende Beispiel vergleicht den Steuersatz jeder Zeile mit dem Gesamtsteuersatz. Stimmen die Werte nicht überein, wird das Skript nicht sofort abgebrochen, sondern sammelt die Zeilennummern mit Abweichungen und meldet sie in der Fehlermeldung:

```javascript theme={null}
var taxRateFields = Context.GetFields("MyTable/TaxRate");
var taxRateField = Context.GetField("TaxRate");

if (!taxRateFields || !taxRateField)
    return;

var taxRate = taxRateField.Value ? taxRateField.Value : 0;
var wrongLines = [];
for (var i = 0; i < taxRateFields.length; i++) {
    if (taxRateFields[i].Value != taxRate)
        wrongLines.push(i + 1);
}

if (wrongLines.length > 0) {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = "Falscher Steuersatz in Zeilen: " + wrongLines.join(", ");
}
```

<div id="compare-the-product-of-row-values-to-another-row-value">
  ## Vergleichen Sie das Produkt von Werten in einer Zeile mit einem anderen Zeilenwert
</div>

Sie können Operationen für verschiedene Spalten in einer Tabelle zeilenweise ausführen, ohne explizite Schleifen zu verwenden — referenzieren Sie jede Spalte dazu mit [`Context.GetField`](/de/vantage/documentation/skill-designer/document/rule-verification/context#getfield). Dadurch wird eine wiederkehrende Regel erstellt, die automatisch für jede Zeile ausgeführt wird. Alle so referenzierten Spalten müssen zu derselben Tabelle gehören.

Das folgende Beispiel multipliziert für jede Zeile die Stückzahl mit dem Stückpreis und vergleicht das Ergebnis mit dem Gesamtpreis der Position:

```javascript theme={null}
var quantityField = Context.GetField("MyTable/Quantity");
var unitPriceField = Context.GetField("MyTable/Unit Price");
var totalField = Context.GetField("MyTable/Total Price");

if (!quantityField || !unitPriceField || !totalField)
    return;

var quantity = quantityField.Value ? quantityField.Value : 0;
var unitPrice = unitPriceField.Value?.Amount ? unitPriceField.Value.Amount : 0;
var total = totalField.Value?.Amount ? totalField.Value.Amount : 0;

var result = quantity * unitPrice;

if (Math.abs(result - total) > 0.01) {
    Context.CheckSucceeded = false;
    Context.ErrorMessage = "Menge * Stückpreis entspricht nicht dem Gesamtbetrag";
}
```

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

* [Automatisierung von Geschäftsregeln](/de/vantage/documentation/skill-designer/document/rule-verification/business-rules-automation)
* [Objektmodell](/de/vantage/documentation/skill-designer/document/rule-verification/object-model)
* [Context](/de/vantage/documentation/skill-designer/document/rule-verification/context)
* [Field](/de/vantage/documentation/skill-designer/document/rule-verification/field)