> ## 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.

# Exemples de scripts pour créer des règles personnalisées

> Exemples de code VBScript, JScript et C# pour des règles FlexiCapture personnalisées : vérifications des données d’un tableau, recherches dans des listes de valeurs, groupes de coches et analyse d’adresses.

Cet article présente des exemples de scripts pour des scénarios courants de règles personnalisées dans ABBYY FlexiCapture. Le cas échéant, chaque exemple comprend à la fois une version VBScript et une version JScript.

<div id="automation-rule">
  ## Règle d’automatisation
</div>

Cet exemple montre une vérification des données d’un tableau. La règle vérifie si les données du tableau correspondent à la valeur du champ de résultat. Le tableau comporte des colonnes contenant les prix et les quantités des articles. La règle est écrite au niveau d’une section contenant le tableau et le champ de résultat.

<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 d’un composant ActiveX
</div>

Le code ci-dessous est celui de la classe `CheckDoc` du projet `AutomationRule`, utilisée dans les scripts ci-dessus.

```vb theme={null}
Option Explicit

' Vérifie si les données du tableau correspondent au résultat
' column1 - colonne des prix
' column2 - colonne des quantités
' resultField - champ de résultat (<Total> ou équivalent)
' docObj - nœud de document en cours de vérification
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
' calcul de la somme des données du tableau
    sum = 0
For i = 0 To costItems.Count - 1
        curCost = costItems.Item(i).Value
        curNum = numItems.Item(i).Value
        sum = sum + curNum * curCost
Next
   ' résultat de la comparaison arrondi au 2e chiffre après la virgule
    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">
  ## Recherche dans la liste de variantes
</div>

Cette règle vérifie si la valeur du champ correspond à l’une des valeurs d’une liste. Si ce n’est pas le cas, un indicateur d’erreur de règle apparaît et une liste de valeurs suggérées est fournie pour le champ. Selon le résultat de la vérification, le champ est marqué comme reconnu avec confiance ou sans confiance.

<CodeGroup>
  ```vb VBScript theme={null}
  'mémoriser la valeur du champ
  Dim fieldValue
  fieldValue = me.Field("Field6").Value
  'créer une liste de valeurs pour la vérification
  Dim list(5)
  dim i
  for i = 0 to 4
      list(i) = "2" & i
  next
  dim success
  success = false
  'vérifier si la valeur du champ correspond à l'une des valeurs de la liste
  for i = 0 to 4
  if list(i) = fieldValue Then
          success = true
          exit for
  end if
  next
  'selon le résultat de la vérification, définir l'état de certitude correspondant pour le champ
  me.Field("Field6").IsVerified = success
  'remplir la liste des suggestions pour le champ ; une suggestion peut être l'une des
  'valeurs appropriées
  if success = false then
      for i = 0 to 4
  me.Field("Field6").Suggest( list(i) )
      next
  end if
  'placer un indicateur d'erreur
  me.CheckSucceeded = success
  ```

  ```javascript JScript theme={null}
  // mémoriser la valeur du champ
  var fieldValue = Field("Field6").Value;
  // créer une liste de valeurs pour la vérification
  var list = new Array(5);
  for( i = 0; i < 5; i++ ) {
      list[i] = "2" + i
  }
  var success = false;
  // vérifier si la valeur du champ correspond à l'une des valeurs de la liste
  for( i = 0; i < 5; i++ ) {
  if( list[i] == fieldValue ) {
          success = true;
          break;
  }
  }
  // selon le résultat de la vérification, définir l'état de certitude correspondant pour le champ
  Field("Field6").IsVerified = success;
  // remplir la liste des suggestions pour le champ ; une suggestion peut être l'une des
  // valeurs appropriées
  if( !success ) {
  for( i = 0; i < 5; i++ ) {
          Field("Field6").Suggest( list[i] );
      }
  }
  // placer un indicateur d'erreur
  CheckSucceeded = success;
  ```
</CodeGroup>

<div id="field-match-check">
  ## Vérification de la correspondance du champ
</div>

Cette règle vérifie si le champ a été trouvé.

<CodeGroup>
  ```vb VBScript theme={null}
  if me.Field("InvoiceNumber").IsMatched then
   me.CheckSucceeded = true
  else
   me.CheckSucceeded = false
   me.ErrorMessage = "Le champ InvoiceNumber n'a pas été trouvé"
  end if
  ```

  ```javascript JScript theme={null}
  if( Field("InvoiceNumber ").IsMatched ) {
   CheckSucceeded = true;
  } else {
  CheckSucceeded = false;
   ErrorMessage = "Le champ InvoiceNumber n'a pas été trouvé";
  }
  ```
</CodeGroup>

<div id="checkmark-check">
  ## Vérification de la coche
</div>

Cette règle vérifie si la coche est sélectionnée ou non.

<CodeGroup>
  ```vb VBScript theme={null}
  if me.Field("Page status").Value then
      me.CheckSucceeded = true
  else
      me.CheckSucceeded = false
      me.ErrorMessage = "Page status n'est pas cochée"
    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 n'est pas cochée";
      FocusedField = Field("Page status");
  }
  ```
</CodeGroup>

<div id="checkmark-group-check">
  ## Vérification du groupe de coches
</div>

Cette règle parcourt toutes les coches du groupe et, si aucune n’est sélectionnée, sélectionne la première. Elle est écrite au niveau du groupe de coches. Toutes les coches du groupe ont été ajoutées à la liste des champs inclus dans la règle, et le groupe lui-même a été exclu de cette liste. Pour la coche par défaut (la première), l’indicateur ReadOnly a été désactivé. S’il n’y a aucune coche dans le groupe, un indicateur d’erreur de règle est activé.

Cet exemple parcourt tous les champs inclus dans la règle. Comme les noms des champs ne sont pas spécifiés, le code peut être utilisé pour n’importe quel groupe de coches.

<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">
  ## Vérification de la fiabilité du champ
</div>

Cette règle vérifie le nombre de caractères incertains dans le champ et vide le champ si ce nombre est de trois ou plus. Il s'agit d'un script d'autocorrection.

<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">
  ## Remplacement de caractères sans perdre les régions et les indicateurs de vérification
</div>

Le script remplace `+` par `&` sans perdre les informations sur les régions ni les indicateurs de vérification. Il s’agit d’un script d’autocorrection.

```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">
  ## Contrôle de l’intégrité du lot
</div>

Vérifie si le nombre de documents indiqué sur la page de contrôle correspond à l’inventaire du lot ainsi qu’au nombre de documents réellement traités. Si les nombres ne correspondent pas, une erreur est renvoyée.

<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">
  ## Compter le nombre de documents et de pages dans un jeu de documents
</div>

Ce script compte le nombre de documents et de pages dans un jeu de documents et génère une erreur si le jeu contient un élément de type inconnu.

```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">
  ## Analyse d’adresse
</div>

Le script décompose l’adresse en composants suivants : code postal, pays, ville et rue. Il s’applique à une partie du champ source.

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