> ## 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 zum Erstellen benutzerdefinierter Regeln

> Beispielhafter VBScript-, JScript- und C#-Code für benutzerdefinierte FlexiCapture-Regeln: Prüfungen von Tabellendaten, Suchen in Wertelisten, Häkchengruppen und Adresszerlegung.

Dieser Artikel enthält Beispielskripte für gängige Szenarien mit benutzerdefinierten Regeln in ABBYY FlexiCapture. Gegebenenfalls enthält jedes Beispiel sowohl eine VBScript- als auch eine JScript-Version.

<div id="automation-rule">
  ## Automatisierungsregel
</div>

Dieses Beispiel zeigt eine Prüfung von Tabellendaten. Die Regel prüft, ob die Tabellendaten mit dem Wert im Ergebnisfeld übereinstimmen. Die Tabelle hat Spalten mit Preisen und Mengen von Waren. Die Regel ist auf der Ebene eines Abschnitts geschrieben, der die Tabelle und das Ergebnisfeld enthält.

<CodeGroup>
  ```vb VBScript theme={null}
  dim autoRule
  set autoRule = CreateObject( "AutomationRule.CheckDoc" )
  autoRule.CheckResult me.FIELD("cost"), me.FIELD("number"), me.FIELD("Result"), me
  ```

  ```javascript JScript theme={null}
  var autoRule = new ActiveXObject( "AutomationRule.CheckDoc" );
  autoRule.CheckResult( Field("cost"), Field("number"),
      Field("Result"), this );
  ```
</CodeGroup>

<div id="code-of-an-activex-component">
  ### Code einer ActiveX-Komponente
</div>

Der folgende Code zeigt den Klassencode von `CheckDoc` aus dem Projekt `AutomationRule`, der in den obigen Skripten verwendet wird.

```vb theme={null}
Option Explicit

' Prüft, ob die Tabellendaten mit dem Ergebnis übereinstimmen
' column1 - Preisspalte
' column2 - Mengenspalte
' resultField - Ergebnisfeld (<Total> oder Äquivalent)
' docObj - zu prüfender Dokumentknoten
Public Sub CheckResult(ByRef column1 As Object, ByRef column2 As Object, _
ByRef resultField As Object, ByRef docObj As Object)
On Error GoTo err_h
Dim costItems AsObject, numItems AsObject
Dim curCost AsDouble, curNum AsLong, sum AsDouble
Dim result AsDouble
Dim i AsLong
Set costItems = column1.Items
Set numItems = column2.Items
' Tabellendaten aufsummieren
    sum = 0
For i = 0 To costItems.Count - 1
        curCost = costItems.Item(i).Value
        curNum = numItems.Item(i).Value
        sum = sum + curNum * curCost
Next
   ' Vergleichsergebnis auf 2 Dezimalstellen gerundet
    result = resultField.Value
If (Round(result, 2) = Round(sum, 2)) Then
        docObj.CheckSucceeded = True
Else
        docObj.CheckSucceeded = False
docObj.ErrorMessage = "Table data does not match the resulting value"
        resultField.Suggest sum
   End If
Exit Sub
err_h:
docObj.ErrorMessage = Err.Description
    docObj.CheckSucceeded = False
End Sub
```

<div id="search-in-the-variants-list">
  ## In der Variantenliste suchen
</div>

Diese Regel prüft, ob der Feldwert einem der Werte in einer Liste entspricht. Ist das nicht der Fall, wird ein Regelfehler-Flag angezeigt und dem Feld eine Liste vorgeschlagener Werte zugewiesen. Je nach Prüfergebnis wird das Feld als mit hoher oder niedriger Sicherheit erkannt markiert.

<CodeGroup>
  ```vb VBScript theme={null}
  'Feldwert speichern
  Dim fieldValue
  fieldValue = me.Field("Field6").Value
  'Liste mit Werten für die Prüfung erstellen
  Dim list(5)
  dim i
  for i = 0 to 4
      list(i) = "2" & i
  next
  dim success
  success = false
  'prüfen, ob der Feldwert einem der Werte in der Liste entspricht
  for i = 0 to 4
  if list(i) = fieldValue Then
          success = true
          exit for
  end if
  next
  'je nach Prüfergebnis den entsprechenden Sicherheitsstatus für das Feld festlegen
  me.Field("Field6").IsVerified = success
  'die Vorschlagsliste für das Feld füllen; ein Vorschlag kann einer der
  'geeigneten Werte sein
  if success = false then
      for i = 0 to 4
  me.Field("Field6").Suggest( list(i) )
      next
  end if
  'Fehler-Flag setzen
  me.CheckSucceeded = success
  ```

  ```javascript JScript theme={null}
  // Feldwert speichern
  var fieldValue = Field("Field6").Value;
  // Liste mit Werten für die Prüfung erstellen
  var list = new Array(5);
  for( i = 0; i < 5; i++ ) {
      list[i] = "2" + i
  }
  var success = false;
  // prüfen, ob der Feldwert einem der Werte in der Liste entspricht
  for( i = 0; i < 5; i++ ) {
  if( list[i] == fieldValue ) {
          success = true;
          break;
  }
  }
  // je nach Prüfergebnis den entsprechenden Sicherheitsstatus für das Feld festlegen
  Field("Field6").IsVerified = success;
  // die Vorschlagsliste für das Feld füllen; ein Vorschlag kann einer der
  // geeigneten Werte sein
  if( !success ) {
  for( i = 0; i < 5; i++ ) {
          Field("Field6").Suggest( list[i] );
      }
  }
  // Fehler-Flag setzen
  CheckSucceeded = success;
  ```
</CodeGroup>

<div id="field-match-check">
  ## Prüfung der Feldübereinstimmung
</div>

Diese Regel prüft, ob das Feld zugeordnet wurde.

<CodeGroup>
  ```vb VBScript theme={null}
  if me.Field("InvoiceNumber").IsMatched then
   me.CheckSucceeded = true
  else
   me.CheckSucceeded = false
   me.ErrorMessage = "Feld InvoiceNumber wurde nicht zugeordnet"
  end if
  ```

  ```javascript JScript theme={null}
  if( Field("InvoiceNumber ").IsMatched ) {
   CheckSucceeded = true;
  } else {
  CheckSucceeded = false;
   ErrorMessage = "Feld InvoiceNumber wurde nicht zugeordnet";
  }
  ```
</CodeGroup>

<div id="checkmark-check">
  ## Prüfung des Häkchens
</div>

Diese Regel prüft, ob das Häkchen gesetzt ist.

<CodeGroup>
  ```vb VBScript theme={null}
  if me.Field("Page status").Value then
      me.CheckSucceeded = true
  else
      me.CheckSucceeded = false
      me.ErrorMessage = "Page status ist nicht markiert"
    me.FocusedField = me.Field(Page status)  ""
  end if
  ```

  ```javascript JScript theme={null}
  if( Field("Page status").Value ) {
      CheckSucceeded = true;
  } else {
  CheckSucceeded = false;
      ErrorMessage = "Page status ist nicht markiert";
      FocusedField = Field("Page status");
  }
  ```
</CodeGroup>

<div id="checkmark-group-check">
  ## Prüfung von Häkchengruppen
</div>

Diese Regel iteriert über alle Häkchen in der Gruppe und wählt das erste aus, wenn keines markiert ist. Die Regel ist auf der Ebene der Häkchengruppe definiert. Alle Häkchen in der Gruppe wurden der Liste der in der Regel enthaltenen Felder hinzugefügt, die Gruppe selbst wurde aus der Liste ausgeschlossen. Für das Standardhäkchen (das erste) wurde das ReadOnly-Flag deaktiviert. Wenn die Gruppe keine Häkchen enthält, wird ein Regelfehler-Flag aktiviert.

Dieses Beispiel iteriert über alle in der Regel enthaltenen Felder. Da keine Feldnamen angegeben sind, kann der Code für jede Häkchengruppe verwendet werden.

<CodeGroup>
  ```vb VBScript theme={null}
  if me.Fields.Count = 0 then
      me.CheckSucceeded = false
      me.ErrorMessage = "There are no checkmarks in the group"
  else
      dim isChosen, i
      isChosen = false
  for i = 0 to me.Fields.Count - 1
         if me.Fields.Item( i ).Value then
              isChosen = true
              exit for
  end if
  next
  if Not isChosen then
          me.Fields.Item(0).Value = true
      end if
  me.CheckSucceeded = true
  end if
  ```

  ```javascript JScript theme={null}
  if( Fields.Count == 0 ) {
      CheckSucceeded = false;
      ErrorMessage = "There are no checkmarks in the group";
  } else {
      var isChosen = false;
      var i;
  for( i = 0; i < Fields.Count; i++ ) {
          if( Fields.Item( i ).Value ) {
              isChosen = true;
              break;
  }
  }
  if( !isChosen ) {
          Fields.Item(0).Value = true;
      }
  CheckSucceeded = true;
  }
  ```
</CodeGroup>

<div id="field-reliability-check">
  ## Zuverlässigkeitsprüfung des Feldes
</div>

Diese Regel prüft, wie viele unsichere Zeichen das Feld enthält, und leert das Feld, wenn es drei oder mehr sind. Dies ist ein Autokorrekturskript.

<CodeGroup>
  ```vb VBScript theme={null}
  Dim totQty, suspQty
  Dim i
  totQty = me.Symbols.Count
  suspQty = 0
  for i = 0 to totQty - 1
    if me.Symbols.Item(i).IsSuspicious = true then
      suspQty = suspQty + 1
    end if
  next
  if suspQty >= 3 then
    me.Text = ""
  end if
  ```

  ```javascript JScript theme={null}
  var susp, qty, strpos, i, SC, strposPrev
  strposPrev = 1
  qty = 0
  SC = "1"
  susp = SuspiciousSymbols
  for ( i = 0; i < susp.length; i++) {
      strpos = susp.indexOf (SC,i)
  if ((strpos != strposPrev) && (strpos != -1)) {
        qty = qty + 1
        strposPrev = strpos
      }
  }
  if (qty >= 3) {
    text = ""
  }
  ```
</CodeGroup>

<div id="character-replacement-without-losing-regions-and-verification-flags">
  ## Zeichenersetzung ohne Verlust von Regionen und Verifizierungs-Flags
</div>

Das Skript ersetzt `+` durch `&`, ohne Informationen über Regionen und Verifizierungs-Flags zu verlieren. Dies ist ein Autokorrekturskript.

```vb theme={null}
Dim totQty
Dim i
totQty = me.Symbols.Count
for i = 0 to totQty - 1
if me.Symbols(i).Symbol = "+" then
    me.Symbols(i).Symbol = "&"
end if
next
```

<div id="batch-integrity-check">
  ## Batch-Integritätsprüfung
</div>

Prüft, ob die auf der Kontrollseite angegebene Anzahl von Dokumenten mit dem Batch-Bestand und der Anzahl der tatsächlich verarbeiteten Dokumente übereinstimmt. Stimmen die Zahlen nicht überein, wird ein Fehler zurückgegeben.

<CodeGroup>
  ```vb VBScript theme={null}
  dim DQty
  dim i
  for i = 0 to me.Batch.Documents.Count - 1
    if me.Batch.Documents.Item(i).DefinitionName = "Inv" then
      DQty = me.Batch.Documents.Item(i).IndexedItemValue("DocQty")
      exit for
  end if
  next
  dim AcQty
  AcQty = me.Batch.Documents.Count
  if acqty <> DQty then
    me.CheckSucceeded = false
    me.ErrorMessage = "Incorrect number of documents in the batch:" & " " & AcQty& ". " & "Expected number:" & " " & DQty & "!"
  end if
  ```

  ```javascript JScript theme={null}
  for ( i = 0; i < [Batch.Documents.Count - 1]; i++ ) {
  var TemplName = Batch.Documents.Item(0).DefinitionName;
    if (TemplName = "Inv") {
      var DQty = Batch.Documents.Item(i).IndexedItemValue("DocQty");
      break ;
  }
  }
  var AcQty = Batch.Documents.Count -1
  if (AcQty != DQty) {
      CheckSucceeded = false;
      ErrorMessage = "Incorrect number of documents in the batch:" + " " + AcQty + "." + "Expected number:" + " " + DQty +"!" ;
  }
  ```
</CodeGroup>

<div id="counting-the-number-of-documents-and-pages-in-a-document-set">
  ## Zählen von Dokumenten und Seiten in einem Dokumentensatz
</div>

Dieses Skript zählt die Anzahl der Dokumente und Seiten in einem Dokumentensatz und löst einen Fehler aus, wenn der Dokumentensatz ein Element eines unbekannten Typs enthält.

```csharp theme={null}
int subDocumentsCount = 0;
int pagesCount = 0;
IBatchItem asBatchItem = Context.Document.AsBatchItem;
IBatchItems items = asBatchItem.ChildItems;
foreach (IBatchItem item in items)
{
if ( item.Type == TBatchItemType.BIT_Page )
{   pagesCount ++;  }
else if( item.Type == TBatchItemType.BIT_Document )
{   subDocumentsCount ++; }
else
{
Context.CheckSucceeded = false;
Context.ErrorMessage = "Unknown type of element in set";
}
}
Context.Field("Field").Text = subDocumentsCount.ToString() + " " + pagesCount.ToString();
```

<div id="address-parsing">
  ## Adresszerlegung
</div>

Das Skript zerlegt die Adresse in die folgenden Komponenten: Postleitzahl, Land, Stadt und Straße. Es wird auf einen Teil des Quellfelds angewendet.

```csharp theme={null}
//-----------------------------------------
var collectionName = "";
IFieldExtractor extractor = Context.GetFieldExtractor();
extractor.ParseAddress();
var city = extractor.ExtractedObjects( collectionName, "NerCity" );
var country = extractor.ExtractedObjects( collectionName, "NerCountry" );
var zip = extractor.ExtractedObjects( collectionName, "NerZipCode" );
var street = extractor.ExtractedObjects( collectionName, "NerStreet" );
for( var i = 0; i < city.Count; i++ ) {
extractor.PutSpanToField( city.Item(i).Span, Context.Field("City") );
}
for( var i = 0; i < country.Count; i++ ) {
extractor.PutSpanToField( country.Item(i).Span, Context.Field("Country") );
}
for( var i = 0; i < zip.Count; i++ ) {
extractor.PutSpanToField( zip.Item(i).Span, Context.Field("ZIP") );
}
for( var i = 0; i < street.Count; i++ ) {
extractor.PutSpanToField( street.Item(i).Span, Context.Field("Street") );
}
//-------------------------------------
```