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

# Activité Script de fractionnement

> Utilisez une activité Script de fractionnement pour diviser les pages d’une transaction en plusieurs documents de sortie à l’aide d’un JavaScript personnalisé qui s’exécute sur l’ensemble des pages en une seule fois.

Si vous créez une Skill Document Splitter, le flux de traitement du document se terminera par une activité Script de fractionnement. Cette étape finale permet de fractionner le flux de pages d’une transaction en un ensemble de documents.

Contrairement aux autres activités, cette activité traite toutes les pages d’une transaction en une seule fois.

<div id="set-up-the-activity">
  ## Configurer l’activité
</div>

<Steps>
  <Step title="Ajouter des types de documents">
    Ajoutez les types de documents possibles en cliquant sur l’icône « plus » dans le volet **Splitter Script Properties**, puis créez les classes une par une.
  </Step>

  <Step title="Ouvrir le Script Editor">
    Cliquez sur **Script Editor** dans le volet **Splitter Script Properties**.
  </Step>

  <Step title="Configurer le script">
    Créez un script qui détermine comment les pages sont assemblées en documents. Le script a accès à toutes les pages d’une transaction. Le scénario le plus courant consiste à parcourir les pages et, à chaque fois, à vérifier si une page commence un nouveau document. Sinon, elle est ajoutée au document précédent. Pour une description détaillée des objets utilisables dans votre script, consultez [Object model](/fr/vantage/documentation/advanced-designer/activities/splitter-script/object-model).
  </Step>

  <Step title="Enregistrer">
    Cliquez sur **Save**.
  </Step>
</Steps>

<div id="sample-scripts">
  ## Scripts d’exemple
</div>

Dans cette section, vous trouverez des scripts d’exemple correspondant à divers cas d’utilisation du Skill Document Splitter. Tous les exemples de script ci-dessous partent du principe qu’un champ nommé « ResultClassId » existe dans la définition du document. Ce champ doit contenir la classe du document.

<div id="separate-documents-of-the-same-type">
  ### Séparer des documents du même type
</div>

Le fichier d’entrée contient des factures d’un fournisseur pour une période donnée. La première page de chaque facture contient le numéro de facture.

La première page d’un document peut contenir des données spécifiques, par exemple un titre ou un numéro de facture. Pour déterminer que la page actuelle est la première page d’un nouveau document, vous devez vérifier si le champ correspondant a été détecté sur la page. Vous pouvez également analyser les valeurs des champs sur les pages consécutives (par exemple, les numéros de page ou les numéros de facture).

Dans l’exemple suivant, nous comparons les numéros de facture trouvés sur deux pages consécutives et vérifions si le champ "FirstPageMarker" a été détecté sur la page actuelle. Si le champ a été trouvé ou si le numéro de facture diffère, la page actuelle est considérée comme la première page d’un nouveau document.

```javascript theme={null}
var documents = [];
var currentDocument = null;
var currentInvoiceNumber = "";

for (let i = 0; i < Context.Pages.length; i++)
{
    const page = Context.Pages[i];
    let invoiceNumberField = page.GetField("InvoiceNumber");
    let invoiceNumberNormalized = invoiceNumberField.Text.replace(/[. -]/g, '');
    let firstPageMarker = page.GetField("FirstPageMarker");
    var hasInvoiceNumber = invoiceNumberField !== null &&  invoiceNumberNormalized !== "";
    var hasNewInvoiceNumber = hasInvoiceNumber && invoiceNumberNormalized !== currentInvoiceNumber;
    var hasFirstPageMarker = firstPageMarker !== null && firstPageMarker.Text;

    if (!currentDocument || hasNewInvoiceNumber || (!hasInvoiceNumber && hasFirstPageMarker))
    { 
        currentDocument = new Document('invoice');
        documents.push(currentDocument);
    }

    if (hasInvoiceNumber)
    {
        currentInvoiceNumber =  invoiceNumberNormalized;
    }
 
    currentDocument.Pages.push(page);
}

return documents;
```

<div id="separate-documents-and-remove-annexes">
  ### Séparer les documents et supprimer les annexes
</div>

Le document contient une annexe ou des pages vides qui doivent être conservées sans extraction de données.

Pour déterminer si le document comporte une annexe ou des pages vides, vérifiez s’il existe des pages sur lesquelles aucune donnée utile n’est présente. Par exemple, ajoutez un champ qui détecte n’importe quel mot et considérez comme vides toutes les pages sur lesquelles aucun mot n’a été trouvé.

Dans l’exemple suivant, nous séparons les pages vides des pages non vides en nous basant sur le texte d’un champ.

```javascript theme={null}
var empty = new Document('empty'); 
var invoice = new Document('invoice'); 

for (let i = 0; i < Context.Pages.length; i++) { 
    const page = Context.Pages[i]; 

    // Obtenir la valeur texte de la propriété "Field" de la page actuelle 
    var currentResult = page.GetField("Field").Text; 

    // Vérifier si le résultat actuel a une longueur supérieure à 0 
    if (currentResult.length > 0) { 
        invoice.Pages.push(page); 
    } else { 
        empty.Pages.push(page); 
    } 
}

return [invoice, empty];
```

<div id="separate-documents-and-determine-their-type">
  ### Séparer les documents et déterminer leur type
</div>

<div id="case-1-each-document-type-is-represented-by-a-single-document">
  #### Cas 1. Chaque type de document est représenté par un seul document
</div>

Une demande de prêt contient des documents de types différents. Chaque type est représenté par un seul document. Tous les documents sont fournis dans un seul fichier.

Pour déterminer que la page actuelle est la première page d’un nouveau document, vous pouvez simplement comparer sa classe à celle de la page précédente.

```javascript theme={null}
var documents = [];
var currentResultClassId = null;
var currentDocument = null;

for (let i = 0; i < Context.Pages.length; i++)
{
    const page = Context.Pages[i];
    const pageResultClassId = page.GetField('ResultClassId').Text;

    // Vérifiez si la page actuelle a la même classe que la page précédente. Si ce n'est pas le cas, commencez un nouveau document.
    if (pageResultClassId != currentResultClassId || !currentDocument)
    {
        currentResultClassId = pageResultClassId;
        currentDocument = new Document(pageResultClassId);
        documents.push(currentDocument);
    }

    currentDocument.Pages.push(page);
}

return documents;
```

<div id="case-2-each-document-type-is-represented-by-one-or-several-documents">
  #### Cas 2. Chaque type de Document est représenté par un ou plusieurs documents
</div>

Une demande de prêt soumise par deux coemprunteurs contient un grand nombre de documents de types différents. Chaque type peut être représenté par plusieurs documents consécutifs. Par exemple, une demande peut contenir les images des pièces d’identité des deux coemprunteurs, plusieurs relevés bancaires, etc.

Pour déterminer que la Page actuelle est la première Page d’un nouveau document, vous devez combiner les deux stratégies décrites ci-dessus.

Dans l’exemple suivant, nous comparons d’abord les classes des deux Pages consécutives. Si la classe a changé, la Page actuelle est considérée comme la première Page d’un nouveau document. Si les Pages appartiennent à la même classe, nous vérifions si le champ "title" a été trouvé sur la Page actuelle. La Page sur laquelle ce champ a été trouvé est considérée comme la première Page d’un nouveau document.

```javascript theme={null}
var documents = [];
var currentResultClassId = null;
var currentDocument = null;

for (let i = 0; i < Context.Pages.length; i++)
{
    const page = Context.Pages[i];
    const pageResultClassId = page.GetField('ResultClassId').Text;

    // Vérifier si la page actuelle a la même classe que la page précédente. Si ce n'est pas le cas, commencer un nouveau document.
    if (pageResultClassId != currentResultClassId)
    {
        currentResultClassId = pageResultClassId;
        currentDocument = new Document(pageResultClassId);
        documents.push(currentDocument);
    }
    // Commencer un nouveau document si le champ "Title" a été trouvé sur la page actuelle.
    else if (page.GetField("Title").Text || !currentDocument)
    {
        currentDocument = new Document(pageResultClassId);
        documents.push(currentDocument);
    }

    currentDocument.Pages.push(page);
}

return documents;
```

<div id="reorder-pages-and-remove-empty-pages">
  ### Réordonner les pages et supprimer les pages vides
</div>

Le document contient des pages dans un ordre incorrect. Chaque page comporte un champ indiquant son numéro (par exemple « Page 1 sur 10 »). Pour organiser les pages, vous devez créer un champ qui extrait les numéros de page.

Vous pouvez également créer un champ qui indique si une page est vierge ou non en recherchant la présence de texte sur cette page. Cela permet d’écarter les pages vierges ou parasites (par exemple celles issues de la numérisation en mode recto verso de plis avec un verso vide), comme décrit dans la section [Séparer les documents et supprimer les annexes](#separate-documents-and-remove-annexes).

Dans l’exemple suivant, nous réordonnons les pages selon leur numéro.

```javascript theme={null}
var documents = new Document('document'); 
var currentDocument = null; 
let arr = []; 

for (let i = 0; i < Context.Pages.length; i++) { 
    arr[i] = Context.Pages[i]; 
} 

// Trier le tableau "arr" en fonction des valeurs numériques d'un champ spécifique de chaque page 
arr.sort((page1, page2) => parseInt(page1.GetField("Field").Text) - parseInt(page2.GetField("Field").Text)); 

// Parcourir le tableau "arr" trié et ajouter chaque objet "page" à la propriété "Pages" du document "documents" 
for (let i = 0; i < arr.length; i++) { 
    const page = arr[i]; 
    documents.Pages.push(page); 
} 

return [documents];
```