Exemples de scripts pour l’Export

Obtention des valeurs de champ lors de l’Export

Cet exemple de code montre comment obtenir la valeur d’un champ lors de l’Export. Vous pouvez utiliser cette valeur pour nommer les fichiers dans lesquels les images ou les données sont exportées. Si le document ne contient pas ce champ, une erreur se produira.La structure du document à exporter :

Section 1
            Field1
            …

Group1
                        Field2
                        …

…
            FieldN

Section 2
            Field1
            …
            FieldK

[VBScript]

Dim field1Value, field2Value

' Obtient la valeur de Field1 dans Section 1
if Not IsNull( me.Field( "Section 1\Field1" ).Value ) then
    field1Value = me.Field( "Section 1\Field1" ).Value
end if

' Obtient la valeur de Field2 dans Group1 de Section 1
if Not IsNull( me.FIELD( "Section 1\Group1\Field2" ).Value ) then
    field2Value = me.Field( "Section 1\Group1\Field2" ).Value
end if

' Obtient la valeur de Field1 dans Section 1 si la section comporte plusieurs instances
if Not me.Field( "Section 1" ).Items Is Nothing then
    dim curPage

for each curPage in me.Field( "Section 1" ).Items
        if Not curPage.Children Is Nothing then
            dim curField

for each curField in curPage.Children
                if curField.Name = "Field1" And Not IsNull( curField.Value )  then
                     field1Value = curField.Value
                     exit for

end if

next

end if

next

end if

[JScript]

// Obtient la valeur de Field1 dans Section 1
if( Field("Section 1\\Field1").Value != null ) {
var field1Value = Field("Section 1\\Field1").Value;
}

// Obtient la valeur de Field2 dans Group1 de Section 1
if( Field("Section 1\\Group1\\Field2").Value != null ) {
var field2Value = Field("Section 1\\Group1\\Field2").Value;
}

// Obtient la valeur de Field1 dans Section 1 si la section comporte plusieurs instances
if( Field( "Section 1" ).Items != null ) {
    var i, j;

for( i = 0; i < Field( "Section 1" ).Items.Count; i++ ) {
        var curPage = Field( "Section 1" ).Items.Item( i );

if( curPage.Children != null ) {

for( j = 0; j < curPage.Children.Count; j++ ) { 
                var curField = curPage.Children.Item( j );

if( curField.Name == "Field1" && curField.Value != null ) {
                     var field1Value  = curField.Value;
                     break;
                }
            }

}
    }
}

exportation des images de page

Le code de cet exemple montre comment exporter les images de toutes les pages du document à l’aide du format de fichier, du mode colorimétrique et de la résolution requis. Les images sont enregistrées page par page, c’est-à-dire qu’une page correspond à un fichier distinct.Dans cet exemple, les fichiers sont nommés “page1.tif”, “page2.tif”, etc. Vous pouvez modifier le mode de nommage des fichiers si nécessaire. Par exemple, vous pouvez créer des noms de fichier à partir de la valeur d’un champ.

[VBScript]

dim fso, folderName
set fso = CreateObject("Scripting.FileSystemObject")
folderName = "d:\ExportImages"

if Not fso.FolderExists( folderName ) then
    fso.CreateFolder folderName
end if

dim imageOptions
set imageOptions = FCTools.NewImageSavingOptions
imageOptions.Format = "tif"

imageOptions.ColorType = "BlackAndWhite"
imageOptions.Resolution = 600
dim i

for i = 0 to me.Pages.Count - 1
    dim fileName

' Définit le nom et l’extension du fichier selon le format sélectionné
    fileName = fso.BuildPath( folderName, "page" & (i+1) & ".tif" )
    me.Pages.Item(i).SaveAs fileName, imageOptions
next

[JScript]

var fso = new ActiveXObject("Scripting.FileSystemObject");
var folderName = "d:\\ExportImages";

if( !fso.FolderExists( folderName ) ) {
    fso.CreateFolder( folderName );
}

var imageOptions = FCTools.NewImageSavingOptions();
imageOptions.Format = "tif";
imageOptions.ColorType = "BlackAndWhite";

imageOptions.Resolution = 600;
var i;

for( i = 0; i < Pages.Count; i++ ) {

// Définit le nom et l’extension du fichier selon le format sélectionné
    var fileName = fso.BuildPath( folderName, "page" + (i+1) + ".tif" );
    Pages.Item(i).SaveAs( fileName, imageOptions );
}

exportation d’un tableau

Cet exemple montre comment exporter un tableau dans un fichier *.txt.

[VBScript]

dim fso, txtFile, fileName
set fso = CreateObject("Scripting.FileSystemObject")
fileName = "d:\TestExportTable.txt"

set txtFile = fso.CreateTextFile( fileName, true )
txtFile.WriteLine "Table"
dim table, row, cell, rowNumber

set table = me.Field("Page 1\Table")
rowNumber = 1

for each row in table.Items
   txtFile.WriteLine "RowNumber = " & rowNumber

for each cell in row.Children
        txtFile.Write cell.Value & "   "
    next

txtFile.WriteBlankLines 1
    rowNumber = rowNumber + 1
next

txtFile.Close
set txtFile = nothing
set fso = nothing

[JScript]

var fso, txtFile, fileName;
fso = new ActiveXObject("Scripting.FileSystemObject");
fileName = "d:\\TestExportTable1.txt";

txtFile = fso.CreateTextFile( fileName, true );
txtFile.WriteLine( "Table" );

var table, i, j;
table = Field("Page 1\\Table");
var rows = table.Items;

for( i = 0; i < rows.Count; i++ ) {
    txtFile.WriteLine( "RowNumber = " + ( i+1 ) );
    var cells = rows.Item(i).Children;

for( j = 0; j < cells.Count; j++ ) {
       txtFile.Write( cells.Item(j).Value + "   " );
    }

txtFile.WriteBlankLines(1);
}
txtFile.Close();

Exportation d’un document, quel que soit son niveau d’imbrication

Cet exemple montre comment exporter les champs d’un document à n’importe quel niveau d’imbrication à l’aide de fonctions personnalisées issues du module d’export global. Si vous devez exporter des champs de document avec un niveau d’imbrication variable, il est recommandé d’utiliser un composant COM externe (voir l’exemple suivant).

Code d’export principal

[VBScript]
Export.ExportDocument me, FCTools

[JScript]
Export.ExportDocument( this, FCTools );

Le code des fonctions du module d’export global

[VBScript]

' La procédure effectue l'export : crée un dossier d'export et
' y enregistre les fichiers image de page, le fichier texte avec les champs du document,
' ainsi que les informations relatives au document

Sub ExportDocument(ByRef docObj, ByRef FCTools)
    Dim folderName
    Dim txtFile, fileName
    Dim fso

On Error Resume Next
    set fso = CreateObject("Scripting.FileSystemObject")
    ' création du dossier d'exportation
    folderName = CreateExportFolder(docObj.DefinitionName, fso)

if Err.Number <> 0 then
        docObj.Action.Succeeded = false

docObj.Action.ErrorMessage = "Erreur lors de la création du dossier d'exportation : " + Err.Description
        Err.Clear
        Exit Subub
    End if

' exportation des images
    ExportImages docObj, FCTools, folderName, fso
    if Err.Number <> 0 then
        docObj.Action.Succeeded = false

docObj.Action.ErrorMessage = "Erreur lors de l'exportation des images : " + Err.Description
        Err.Clear
        Exit Sub
    End if

' création du fichier texte
    fileName = fso.BuildPath(folderName, "doc.txt")
    Set txtFile = fso.CreateTextFile(fileName, True)

' exportation des informations sur le document
    ExportDocInfo docObj, txtFile

' exportation des champs
    txtFile.WriteLine "Fields:"
    ExportFields docObj.Children, txtFile, ""
    txtFile.Close

if Err.Number <> 0 then
        docObj.Action.Succeeded = false
        docObj.Action.ErrorMessage = "Erreur lors de l'exportation des données : " + Err.Description
        Err.Clear
        Exit Sub
    End if

Set txtFile = Nothing
    Set fso = Nothing
End Sub

' Fonction d'exportation d'images
Function ExportImages( ByRef docObj, ByRef FCTools, ByVal exportFolder, ByRef fso )
    Dim pages, page, imageOptions
    Dim fileName, pageNum

' spécification des paramètres d'export
    Set imageOptions = FCTools.NewImageSavingOptions
    imageOptions.Format = "bmp"

imageOptions.ColorType = "FullColor"
    imageOptions.Resolution = 100

' export page par page
    Set pages = docObj.Pages
    pageNum = 1

For Each page In pageses
        fileName = fso.BuildPath(exportFolder, "page" & pageNum & ".bmp")
        page.SaveAs fileName, imageOptions
        pageNum = pageNum + 1
    Next

End Function

' Procédure qui exporte les informations relatives au document
Sub ExportDocInfo(ByRef docObj, ByRef txtFile)
    txtFile.WriteLine "Doc info:"
    txtFile.WriteLine ("DocumentId " & docObj.Id)

txtFile.WriteLine ("IsAssembled " & docObj.IsAssembled)
    txtFile.WriteLine ("IsVerified " & docObj.IsVerified)
    txtFile.WriteLine ("IsExported " & docObj.IsExported)

txtFile.WriteLine ("ProcessingErrors " & docObj.ProcessingErrors)
    txtFile.WriteLine ("ProcessingWarnings " & docObj.ProcessingWarnings)
    txtFile.WriteLine ("TotalSymbolsCount " & docObj.TotalSymbolsCount)

txtFile.WriteLine ("RecognizedSymbolsCount " & docObj.RecognizedSymbolsCount)
    txtFile.WriteLine ("UncertainSymbolsCount " & docObj.UncertainSymbolsCount)
    txtFile.WriteLine
End Sub

' La procédure qui exporte les fields depuis la collection fields
Sub ExportFields(ByRef fields, ByRef txtFile, ByVal indent)
    Dim curField

For Each curField In fields
        ExportField curField, txtFile, indent
    Next

End Sub

' Vérifie si la valeur des fields est null
' Si la valeur du champ est invalide, toute tentative d'accès à ce champ (même
' pour vérifier si elle est null) peut provoquer une exception

Function IsNullFieldValue( ByRef field )
    on error resume next
    IsNullFieldValue = IsNull( field.Value )

if Err.Number <> 0 then
        IsNullFieldValue = True
        Err.Clear
    End if

End Function

' Procédure d'exportation de champ
Sub ExportField(ByRef field, ByRef txtFile, ByVal indent)

' enregistrement du nom du champ
    txtFile.Write (indent & field.Name)

' enregistrement de la valeur du champ si elle est accessible
    If IsNullFieldValue(field) Then
        txtFile.WriteLine
    Else

txtFile.WriteLine ("    " & field.Text)
    End If

If Not field.Children Is Nothing Then
        ' exportation des champs enfants
        ExportFields field.Children, txtFile, indent & "    "

ElseIf Not field.Items Is Nothing Then
        ' exportation des instances de champ
        ExportFields field.Items, txtFile, indent & "    "
    End If

End Sub

' La fonction crée un dossier d'export et retourne le chemin complet vers ce dossier
Function CreateExportFolder(ByVal definitionName, ByRef fso)
    Dim docFolder, folderName

' dossier principal
    exportFolder = "d:\ScriptExport"

If fso.FolderExists(exportFolder) = False Then
        fso.CreateFolder (exportFolder)
    End If

' le dossier de la définition de document spécifiée
    docFolder = fso.BuildPath(exportFolder, definitionName)

If fso.FolderExists(docFolder) = False Then
        fso.CreateFolder (docFolder)
    End If

' le dossier du document exporté
    Dim i
    i = 1
    folderName = fso.BuildPath(docFolder, i)

While fso.FolderExists(folderName)
        i = i + 1
        folderName = fso.BuildPath(docFolder, i)
    Wend

fso.CreateFolder (folderName)
    CreateExportFolder = folderName
End Function

[JScript]

// La fonction effectue l'export : crée un dossier d'export et
// y enregistre les fichiers d'images de page, le fichier texte avec les champs du document,
// ainsi que les informations relatives au document
function ExportDocument(docObj, exportImageTools)
{

var folderName
    var txtFile, fileName
    var fso

fso = new ActiveXObject("Scripting.FileSystemObject");
    // création des dossiers d'exportation
    try {

folderName = CreateExportFolder(docObj.DefinitionName, fso);
    } catch( e ) {

docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Erreur lors de la création du dossier d'exportation : " + e.description;
        return;n;

// exportation des images
    try {

ExportImages(docObj, exportImageTools, folderName, fso);
    } catch( e ) {

docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Erreur lors de l'exportation des images : " + e.description;
        return;
    }

// création du fichier texte
    fileName = fso.BuildPath(folderName, "doc.txt");
    txtFile = fso.CreateTextFile(fileName, true);

// exportation des informations sur le document
    ExportDocInfo( docObj, txtFile );

// exportation des champs
    txtFile.WriteLine( "Fields:" );
    try {

ExportFields( docObj.Children, txtFile, "" );
    } catch( e ) { {

docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Erreur lors de l'exportation des données : " + e.description;
        txtFile.Close();
        return;
    }

txtFile.Close();
    txtFile = 0;
    fso = 0;
}

// Fonction d'exportation d'images. Si une erreur se produit lors de l'exportation des images,
// elle renvoie un message décrivant l'erreur ; sinon, elle renvoie une chaîne vide
function ExportImages( docObj, exportImageTools, exportFolder, fso )
{

// spécification des paramètres d'export
    var imageOptions = exportImageTools.NewImageSavingOptions();
    imageOptions.Format = "bmp";
    imageOptions.ColorType = "FullColor";
    imageOptions.Resolution = 100;

// export page par page
    var pages = docObj.Pages;
    var i

for( i = 0; i < pages.Count; i++ ) {
        var fileName = fso.BuildPath( exportFolder, "page" + (i+1) + ".bmp" );
        pages.Item(i).SaveAs( fileName, imageOptions );
    }
}

// Procédure qui exporte les informations relatives au document
function ExportDocInfo(docObj, txtFile)
{

txtFile.WriteLine( "Informations du document :" );
    txtFile.WriteLine("IsAssembled " + docObj.IsAssembled);
    txtFile.WriteLine("IsVerified " + docObj.IsVerified);

txtFile.WriteLine("IsExported " + docObj.IsExported);
    txtFile.WriteLine("ProcessingErrors " + docObj.ProcessingErrors);
    txtFile.WriteLine("ProcessingWarnings " + docObj.ProcessingWarnings);

txtFile.WriteLine("TotalSymbolsCount " + docObj.TotalSymbolsCount);
    txtFile.WriteLine("RecognizedSymbolsCount " + docObj.RecognizedSymbolsCount);
    txtFile.WriteLine("UncertainSymbolsCount " + docObj.UncertainSymbolsCount);
    txtFile.WriteLine();
}

// Procédure qui exporte les fields depuis la collection fields
function ExportFields(fields, txtFile, indent)
{

var i
    for( i = 0; i < fields.Count; i++ ) {
        ExportField( fields.Item(i), txtFile, indent );
    }
}

// Vérifie si la valeur du champ est nulle
// Si la valeur du champ est invalide, toute tentative d'accès à ce champ (même
// pour vérifier si elle est nulle) peut lever une exception
function IsNullFieldValue( field )
{

try {

return ( field.Value == null );
    } catch( e ) {

return true;
    }
}

// Procédure d'exportation de champ
function ExportField(field, txtFile, indent)
{

// enregistrement du nom de fichier
    txtFile.Write(indent + field.Name);

// enregistrement de la valeur du champ, si elle est accessible
    if( IsNullFieldValue( field ) ) {
        txtFile.WriteLine();
    } else {

txtFile.WriteLine("    " + field.Text);
    } }

if( field.Children != null ) {
        // exportation des champs enfants
        ExportFields( field.Children, txtFile, indent + "    " );

} else if( field.Items != null ) {
        // exportation des instances de champ
        ExportFields( field.Items, txtFile, indent + "    " );
    }
}

// La fonction crée un dossier d'export et renvoie le chemin complet vers ce dossier
function CreateExportFolder(definitionName, fso)
{
    var docFolder, folderName

// dossier principal
    var exportFolder = "d:\\ScriptExport";

if( !fso.FolderExists(exportFolder) ) {
        fso.CreateFolder (exportFolder);
    } }

// le dossier de la définition de document spécifiée
    docFolder = fso.BuildPath(exportFolder, definitionName);

if( !fso.FolderExists(docFolder) ) {
        fso.CreateFolder(docFolder);
    }

// le dossier du document exporté
    var i = 1;
    folderName = fso.BuildPath(docFolder, i);

while( fso.FolderExists(folderName) ) {
        i++;
        folderName = fso.BuildPath(docFolder, i);
    }

fso.CreateFolder(folderName);
    return folderName;
}

Utilisation d'un composant COM externe

[VBScript]
dim autoExport
set autoExport = CreateObject( "AutomationExport.Exporter" )
autoExport.Export me, FCTools

[JScript]
var autoExport = new ActiveXObject("AutomationExport.Exporter");
autoExport.Export( this, FCTools );

Code d’un composant ActiveX en VisualBasic

Vous trouverez ci-dessous le code de la classe Exporter du projet AutomationExport, utilisé dans les scripts mentionnés ci-dessus.

OptionExplicit

Dim mFso AsNew Scripting.FileSystemObject

' La procédure effectue l'export du document : crée un dossier d'export et

' enregistre les fichiers image de la page, le fichier texte avec les champs du document,

' et informations sur le document

PublicSub Export(ByRef docObj As Object, ByRef FCTools As Object)

OnErrorGoTo err_h

Dim folderName AsString

Dim txtFile As TextStream, fileName AsString

Dim imageExportResult AsString, errMessage AsString

' création du dossier d'exportation

folderName = createExportFolder(docObj.definitionName)

If folderName = "" Then

docObj.Action.Succeeded = False

docObj.Action.ErrorMessage = "Cannot create export folder"

ExitSub

EndIf

' exportation d'images

imageExportResult = exportImages(docObj, FCTools, folderName)

' création du fichier texte

fileName = mFso.BuildPath(folderName, "doc.txt")

Set txtFile = mFso.CreateTextFile(fileName, True)

' enregistrement des informations sur les problèmes d'export d'image

If imageExportResult <> "" Then

txtFile.WriteLine imageExportResult

errMessage = errMessage & imageExportResult

EndIf

' exportation des informations sur le document

exportDocInfo docObj, txtFile

' exporting fields

txtFile.WriteLine "Fields:"

IfNot exportFields(docObj.Children, txtFile, "") Then

errMessage = errMessage & " Error during export data"

EndIf

txtFile.Close

' si des erreurs surviennent lors de l'export, réinitialiser le

' définir l'indicateur de succès d'export à False

If errMessage <> "" Then

docObj.Action.Succeeded = False

docObj.Action.ErrorMessage = errMessage

EndIf

Set txtFile = Nothing

Set mFso = Nothing

ExitSub

err_h:

docObj.Action.Succeeded = False

docObj.Action.ErrorMessage = Err.Description

txtFile.Close

Set mFso = Nothing

EndSub

' Fonction d'exportation d'images. Si une erreur se produit lors de l'exportation des images,

' elle retourne un message décrivant l'erreur, sinon elle retourne une chaîne vide

PrivateFunction exportImages(ByRef docObj As Object, ByRef FCTools As Object, _

ByVal exportFolder AsString) AsString

OnErrorGoTo err_h

Dim pages As Object, page As Object, imageOptions As Object

Dim fileName AsString, pageNum AsLong

exportImages = ""

' spécification des paramètres d'export

Set imageOptions = FCTools.NewImageSavingOptions

imageOptions.Format = "png"

imageOptions.ColorType = "GrayScale"

imageOptions.Resolution = 300

' export page par page

Set pages = docObj.pages

pageNum = 1

ForEach page In pages

fileName = mFso.BuildPath(exportFolder, page.definitionName + "_page" & pageNum & "." & imageOptions.Format)

page.SaveAs fileName, imageOptions

pageNum = pageNum + 1

Page suivante

ExitFunction

err_h:

exportImages = Err.Description

EndFunction

' La procédure qui exporte les informations relatives au document

PrivateSub exportDocInfo(ByRef docObj As Object, ByRef txtFile As TextStream)

OnErrorGoTo err_h

txtFile.WriteLine "Doc info:"

txtFile.WriteLine ("DocumentId " & docObj.Id)

txtFile.WriteLine ("IsAssembled " & docObj.IsAssembled)

txtFile.WriteLine ("IsVerified " & docObj.IsVerified)

txtFile.WriteLine ("IsExported " & docObj.IsExported)

txtFile.WriteLine ("ProcessingErrors " & docObj.ProcessingErrors)

txtFile.WriteLine ("ProcessingWarnings " & docObj.ProcessingWarnings)

txtFile.WriteLine ("TotalSymbolsCount " & docObj.TotalSymbolsCount)

txtFile.WriteLine ("RecognizedSymbolsCount " & docObj.RecognizedSymbolsCount)

txtFile.WriteLine ("UncertainSymbolsCount " & docObj.UncertainSymbolsCount)

txtFile.WriteLine

ExitSub

err_h:

txtFile.WriteLine Err.Description

EndSub

' La procédure qui exporte les fields depuis la collection fields

PrivateFunction exportFields(ByRef fields As Object, ByRef txtFile As TextStream, ByVal indent As String) AsBoolean

OnErrorGoTo err_h

Dim curField As Object

exportFields = True

ForEach curField In fields

IfNot exportField(curField, txtFile, indent) Then

exportFields = False

EndIf

Next curField

ExitFunction

err_h:

txtFile.WriteLine Err.Description

exportFields = False

EndFunction

' Vérifie si la valeur du champ est nulle

' Si la valeur est invalide, toute tentative d'accès à ce champ (même

' pour vérifier si la valeur est null) peut provoquer une exception

Function IsNullFieldValue(ByRef field As Object) AsBoolean

OnErrorGoTo err_h

IsNullFieldValue = IsNull(field.Value)

ExitFunction

err_h:

IsNullFieldValue = True

EndFunction

' Fonction d'export de champ

PrivateFunction exportField(ByRef field As Object, ByRef txtFile As TextStream, _

ByVal indent AsString) AsBoolean

OnErrorGoTo err_h

Dim result AsBoolean

result = True

' enregistrement du nom du champ

txtFile.Write (indent & field.Name)

' enregistrement de la valeur du champ si elle est accessible

IfNot IsNullFieldValue(field) Then

txtFile.WriteLine ("    " & field.Value)

Else

txtFile.WriteLine

EndIf

IfNot field.Children Is NothingThen

' exportation des champs enfants

result = result And exportFields(field.Children, txtFile, indent & "    ")

ElseIfNot field.Items IsNothingThen

' exportation des instances de Field

result = result And exportFields(field.Items, txtFile, indent & "    ")

EndIf

exportField = result

ExitFunction

err_h:

txtFile.WriteLine Err.Description

exportField = False

EndFunction

' La fonction crée un dossier d'export et renvoie le chemin complet vers ce dossier

PrivateFunction createExportFolder(ByVal definitionName AsString) AsString

OnErrorGoTo err_h

Dim docFolder AsString, folderName AsString

' dossier principal

Const exportFolder = "d:\AutomationExport"

If mFso.FolderExists(exportFolder) = FalseThen

mFso.CreateFolder (exportFolder)

EndIf

' le dossier de la définition de document spécifiée

docFolder = mFso.BuildPath(exportFolder, definitionName)

If mFso.FolderExists(docFolder) = FalseThen

mFso.CreateFolder (docFolder)

EndIf

' le dossier du document exporté

Dim i AsLong

i = 1

folderName = mFso.BuildPath(docFolder, i)

While mFso.FolderExists(folderName)

i = i + 1

folderName = mFso.BuildPath(docFolder, i)

Wend

mFso.CreateFolder (folderName)

createExportFolder = folderName

ExitFunction

err_h:

createExportFolder = ""

EndFunction

Utilisation d’un composant externe écrit en .Net( C# )

Pour utiliser un composant externe écrit en .Net, procédez comme suit :

Créez un projet de type ClassLibrary
Ajoutez ControllerInterop.dll aux références du projet. ABBYY.FlexiCapture apparaîtra dans la liste Références et toutes les interfaces des objets de script deviendront disponibles dans le projet.
Définissez l’interface disp, la classe qui l’implémente, ainsi que ProgId (cela permettra d’utiliser le composant .Net depuis le code du script exactement comme un composant ActiveX).
Après avoir compilé le projet, enregistrez la bibliothèque de types générée (cette opération peut être effectuée automatiquement en activant l’option correspondante dans les propriétés du projet).
Dans le code d’export, appelez la méthode du composant comme d’habitude :

[VBScript]
dim autoExport
set autoExport = CreateObject( "ExportLibrary1.Export" )
autoExport.ExportDocument me, FCTools

[JScript]
var autoExport = new ActiveXObject("ExportLibrary1.Export"); autoExport.ExportDocument( this, FCTools );

Voici le code d’un tel composant :

using System;

using System.Runtime.InteropServices;

using System.IO;

using ABBYY.FlexiCapture;

namespace ExportLibrary1

// L'interface du composant d'export accessible depuis le script
      // Lors de la création d'un nouveau composant, générer un nouveau GUID
      [Guid("32B10C3B-EEA3-4194-B0A0-E358C310225A")]
      [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]

public interface _cExport
      {
            [DispId(1)]
            void ExportDocument(ref IExportDocument DocRef, ref FCTools Tools);
      }

// La classe qui implémente la fonctionnalité du composant d'export
      // Lors de la création d'un nouveau composant, générez un nouveau GUID
// et définissez votre ProgId
      [Guid("3BA19BD7-C6DC-4f63-BC08-0D95254DADC3")]
      [ClassInterface(ClassInterfaceType.None)]

[ProgId("ExportLibrary1.Export")]
      [ComVisible(true)]

public class Export : _cExport
      {
            public Export()
            {
            }

// La fonction effectue l'export du document : crée un dossier d'export et
// y enregistre les fichiers d'images de page,

// le fichier texte contenant les champs du document et les informations relatives au document
            public void ExportDocument( ref IExportDocument docRef, ref FCTools FCTools )

try
                  {

string exportFolder = createExportFolder( docRef.DefinitionName );
                        exportImages( docRef, FCTools, exportFolder );

// création du fichier texte
                        string fileName = exportFolder + "//" + "doc.txt";
                        StreamWriter sw = File.CreateText( fileName );

// exportation des informations sur le document
                        exportDocInfo( docRef, sw );

// exportation des champs
                        sw.WriteLine( "Fields:" );
                        exportFields( docRef.Children, sw, "" );
                        sw.Close();
                  }

catch( Exception e )
                  {
                        docRef.Action.Succeeded = false;
                        docRef.Action.ErrorMessage = e.ToString();                      
                  }
            }

// La fonction crée un dossier d'export et renvoie le chemin complet vers ce dossier
            privatestring createExportFolder(string definitionName )
            {
                  string docFolder, folderName;

// dossier principal
                  string exportFolder = "d:\\DotNetExport";
                  if( !Directory.Exists(exportFolder) )
                  {
                        Directory.CreateDirectory(exportFolder);
                  }

// le dossier de la définition de document spécifiée
                  docFolder = exportFolder + "\\" + definitionName;
                  if( !Directory.Exists(docFolder) )
                  {
                        Directory.CreateDirectory( docFolder ); 
                  }

// le dossier du document exporté
                  int i = 1;
                  folderName = docFolder + "\\" + i;

while( Directory.Exists(folderName) )
                  {
                        i++;
                        folderName = docFolder + "\\" + i;
                  }

Directory.CreateDirectory(folderName);
                  return folderName;
            }

// Fonction d'exportation d'images
            private void exportImages( IExportDocument docRef, FCTools FCTools, string exportFolder )
            {

string baseFileName = exportFolder + "\\page_";
                  IExportImageSavingOptions imageOptions = FCTools.NewImageSavingOptions();
                  imageOptions.Format = "bmp";

imageOptions.ColorType = "FullColor";
                  imageOptions.Resolution = 100;
                  int i = 1;
                  foreach( IExportPage curPage in docRef.Pages )
                  {

string fileName = baseFileName + i + ".bmp";
                        curPage.SaveAs( fileName, imageOptions );
                        i++;
                  }
            }

// Exportation des informations sur le document
            private void exportDocInfo( IExportDocument docRef, StreamWriter sw )
            {
                  sw.WriteLine( "Doc info:" );
                  sw.WriteLine("DocumentId " + docRef.Id );

sw.WriteLine("IsAssembled " + docRef.IsAssembled);
                  sw.WriteLine("IsVerified " + docRef.IsVerified);
                  sw.WriteLine("IsExported " + docRef.IsExported);

sw.WriteLine("ProcessingErrors " + docRef.ProcessingErrors);
                  sw.WriteLine("ProcessingWarnings " + docRef.ProcessingWarnings);
                  sw.WriteLine("TotalSymbolsCount " + docRef.TotalSymbolsCount);

sw.WriteLine("RecognizedSymbolsCount " + docRef.RecognizedSymbolsCount);
                  sw.WriteLine("UncertainSymbolsCount " + docRef.UncertainSymbolsCount);
                  sw.WriteLine();
            }

// Exportation de la collection de champs
             private void exportFields( IExportFields fields, StreamWriter sw, string indent )
            {

foreach( IExportField curField in fields )
                  {
                        exportField( curField, sw, indent );
                  }
            }

// Vérifie si la valeur du champ est nulle
            // Si la valeur du champ est invalide, toute tentative d'accès à ce champ (même
// pour vérifier si elle est nulle) risque de provoquer une exception
            privatebool IsNullFieldValue( IExportField field )
            {

try
                  {
                        return ( field.Value == null );
                  }

catch( Exception e )
                  {
                        returntrue;
                  }
            }

// Exportation du champ spécifié
            private void exportField( IExportField field, StreamWriter sw, string indent )
            {

// enregistrement du nom du champ
                  sw.Write( indent + field.Name );

// enregistrement de la valeur du champ si elle est accessible
                  if( IsNullFieldValue( field ) )
                  {
                        sw.WriteLine();
                  }

else
                  {
                        sw.WriteLine( "    " + field.Text );
                  }

if( field.Children != null )
                  {
                        // exportation des champs enfants
                        exportFields( field.Children, sw, indent + "    " );
                  }

else if( field.Items != null )
                  {

// exportation des instances de champ
                        exportFields( field.Items, sw, indent + "    " );
                  }
                  }
      }
            }

Gestionnaire d’export

Cet exemple de code présente un gestionnaire d’export simple qui enregistre dans des fichiers texte des informations sur les documents exportés et les résultats d’export. Deux fichiers texte sont utilisés dans cet exemple : l’un contient la liste des documents exportés avec succès, l’autre la liste des documents ayant généré des erreurs lors de l’export.

[VBScript]

dim curDoc
dim fso, fileErrorName, txtErrorFile, fileSucceedName, txtSucceedFile
set fso = CreateObject("Scripting.FileSystemObject")

' création du fichier contenant les documents en erreur
fileErrorName = "d:\ExportResults\ErrorsDocuments.txt"
set txtErrorFile = fso.CreateTextFile( fileErrorName, true )

' création du fichier contenant les documents exportés avec succès
fileSucceedName = "d:\ExportResults\SucceedDocuments.txt"
set txtSucceedFile = fso.CreateTextFile( fileSucceedName, true )
dim i, exprortResult, docInfo

' parcours de la collection des documents exportés
for i = 0 Tome.Count - 1
    set exportResult = me.Item(i)
    docInfo = "DocumentId:" & exportResult.Document.Id

if exportResult.Succeeded then
        docInfo = docInfo & " - Exported successfully."
        txtSucceedFile.WriteLine docInfo
    else

docInfo = docInfo & " - Export error: " & exportResult.ErrorMessage
        txtErrorFile.WriteLine docInfo
    endif

next

txtErrorFile.Close
txtSucceedFile.Close
[JScript]

var fso = new ActiveXObject("Scripting.FileSystemObject");

// création du fichier contenant les documents en erreur
var fileErrorName = "d:\\ExportResults\\ErrorsDocuments.txt";
var txtErrorFile = fso.CreateTextFile( fileErrorName, true );

// création du fichier contenant les documents exportés avec succès
var fileSucceedName = "d:\\ExportResults\\SucceedDocuments.txt"
var txtSucceedFile = fso.CreateTextFile( fileSucceedName, true );
var i

// parcours de la collection des documents exportés
for( i = 0; i < Documents.Count; i++ ) {
    var curDoc = Documents.Item( i );
    var docInfo = "DocumentId: " + curDoc.Id;

if( curDoc.Action.Succeeded ) {
        docInfo = docInfo + ". Exported successfully.  Result:" + curDoc.Action.Result;
        txtSucceedFile.WriteLine( docInfo );
    } else {

docInfo = docInfo + ". Export error: " + curDoc.Action.ErrorMessage + "  Result:" + curDoc.Action.Result;
        txtErrorFile.WriteLine( docInfo );
    }
}
txtErrorFile.Close();
txtSucceedFile.Close();

Accéder aux fichiers source dans les formats Office courants

Cet exemple de script montre comment enregistrer les fichiers source lors de l’exportation de documents. Les fichiers source doivent être dans l’un des formats Office courants pris en charge et avoir des noms uniques afin d’éviter les conflits de noms.

using System;

using System.IO;

using System.Collections.Generic;

// Parcourir les pages.

for( int i = 0; i<Document.Pages.Count; i++ ) {

IPage page = Document.Pages[i];

// Vérifier si un fichier source existe.

if( page.SourceFileGUID == "" ) {

continue;

// Nom d’origine du fichier.

string sourceFileName = @"";

// Indiquer le nom d’origine du fichier.

if( page.ImageSourceType == @"File" ) {

sourceFileName = Path.GetFileName( page.ImageSource );

} else if( page.ImageSourceType == @"Scanner" || page.ImageSourceType == @"Custom" ) {

sourceFileName = Path.GetFileName( page.ImageSourceFileSubPath );

// Supprimer l’extension du nom de fichier.

if( sourceFileName != @"" ) {

sourceFileName = Path.GetFileNameWithoutExtension( sourceFileName ) + @".";

// Nom de fichier source unique (nom d’origine + guid).

string sourceFileUniqueName = sourceFileName + page.SourceFileGUID;

// Chemin d’accès au dossier où le fichier source doit être enregistré.

string sourceFilePath = Document.Batch.Project.ExportRootPath + @"\" + sourceFileUniqueName;

// Vérifier que le fichier n’existe pas.

if( File.Exists( sourceFilePath ) ) {

continue;

// Enregistrer le fichier.

Processing.ReportMessage( "Saving source file: " + sourceFileUniqueName );

page.SaveSourceFile( sourceFilePath );

​Code d’export principal

​Le code des fonctions du module d’export global

​Code d’un composant ActiveX en VisualBasic

​Utilisation d’un composant externe écrit en .Net( C# )

Code d’export principal

Le code des fonctions du module d’export global

Code d’un composant ActiveX en VisualBasic

Utilisation d’un composant externe écrit en .Net( C# )