Beispielskripte zum Erstellen benutzerdefinierter Regeln

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.

Automatisierungsregel

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.

dim autoRule
set autoRule = CreateObject( "AutomationRule.CheckDoc" )
autoRule.CheckResult me.FIELD("cost"), me.FIELD("number"), me.FIELD("Result"), me

var autoRule = new ActiveXObject( "AutomationRule.CheckDoc" );
autoRule.CheckResult( Field("cost"), Field("number"),
    Field("Result"), this );

Code einer ActiveX-Komponente

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

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

In der Variantenliste suchen

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.

'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

// 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;

Prüfung der Feldübereinstimmung

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

if me.Field("InvoiceNumber").IsMatched then
 me.CheckSucceeded = true
else
 me.CheckSucceeded = false
 me.ErrorMessage = "Feld InvoiceNumber wurde nicht zugeordnet"
end if

if( Field("InvoiceNumber ").IsMatched ) {
 CheckSucceeded = true;
} else {
CheckSucceeded = false;
 ErrorMessage = "Feld InvoiceNumber wurde nicht zugeordnet";
}

Prüfung des Häkchens

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

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

if( Field("Page status").Value ) {
    CheckSucceeded = true;
} else {
CheckSucceeded = false;
    ErrorMessage = "Page status ist nicht markiert";
    FocusedField = Field("Page status");
}

Prüfung von Häkchengruppen

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.

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

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

Zuverlässigkeitsprüfung des Feldes

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.

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

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 = ""
}

Zeichenersetzung ohne Verlust von Regionen und Verifizierungs-Flags

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

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

Batch-Integritätsprüfung

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.

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

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 +"!" ;
}

Zählen von Dokumenten und Seiten in einem Dokumentensatz

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.

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

Adresszerlegung

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

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

​Automatisierungsregel

​Code einer ActiveX-Komponente

​In der Variantenliste suchen

​Prüfung der Feldübereinstimmung

​Prüfung des Häkchens

​Prüfung von Häkchengruppen

​Zuverlässigkeitsprüfung des Feldes

​Zeichenersetzung ohne Verlust von Regionen und Verifizierungs-Flags

​Batch-Integritätsprüfung

​Zählen von Dokumenten und Seiten in einem Dokumentensatz

​Adresszerlegung