Scripts de ejemplo para la exportación

Obtener valores de campos durante la exportación

Este código de ejemplo muestra cómo puede obtener el valor de un campo durante la exportación. Puede usar este valor para asignar nombres a los archivos a los que se exportan imágenes o datos. Si ese campo no existe en el documento, se producirá un error.La estructura del documento que se va a exportar:

Section 1
            Field1
            …

Group1
                        Field2
                        …

…
            FieldN

Section 2
            Field1
            …
            FieldK

[VBScript]

Dim field1Value, field2Value

' Obtiene el valor de Field1 en Section 1
if Not IsNull( me.Field( "Section 1\Field1" ).Value ) then
    field1Value = me.Field( "Section 1\Field1" ).Value
end if

' Obtiene el valor de Field2 en 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

' Obtiene el valor de Field1 en Section 1 si la sección tiene varias instancias
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]

// Obtiene el valor de Field1 en Section 1
if( Field("Section 1\\Field1").Value != null ) {
var field1Value = Field("Section 1\\Field1").Value;
}

// Obtiene el valor de Field2 en Group1 de Section 1
if( Field("Section 1\\Group1\\Field2").Value != null ) {
var field2Value = Field("Section 1\\Group1\\Field2").Value;
}

// Obtiene el valor de Field1 en Section 1 si la sección tiene varias instancias
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;
                }
            }

}
    }
}

Exportación de imágenes de páginas

El código de este ejemplo muestra cómo exportar imágenes de todas las páginas del documento usando el formato de archivo, el modo de color y la resolución requeridos. Las imágenes se guardan por página, es decir, cada página en un archivo independiente.Los archivos de este ejemplo se llaman “page1.tif”, “page2.tif”, etc. Puede cambiar la convención de nombres de archivo si es necesario. Por ejemplo, puede crear nombres de archivo basados en el valor de un campo.

[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

' Establece el nombre y la extensión deseados para el archivo en función del formato seleccionado
    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++ ) {

// Establece el nombre y la extensión deseados para el archivo en función del formato seleccionado
    var fileName = fso.BuildPath( folderName, "page" + (i+1) + ".tif" );
    Pages.Item(i).SaveAs( fileName, imageOptions );
}

Exportación de una tabla

Este ejemplo muestra cómo exportar una tabla a un archivo *.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();

Exportar un documento con cualquier nivel de anidamiento

Este ejemplo muestra cómo exportar campos de un documento de cualquier nivel de anidamiento mediante funciones personalizadas del módulo de exportación global. Si necesita exportar campos de documento con anidamiento variable, se recomienda utilizar un componente COM externo (consulte el siguiente ejemplo).

Código de exportación principal

[VBScript]
Export.ExportDocument me, FCTools

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

El código de las funciones del módulo de exportación global

[VBScript]

' El procedimiento realiza la exportación: crea una carpeta de exportación y
' guarda en ella los archivos de imagen de página, el archivo de texto con los campos del documento
' e información sobre el documento

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

On Error Resume Next
    set fso = CreateObject("Scripting.FileSystemObject")
    ' creando la carpeta de exportación
    folderName = CreateExportFolder(docObj.DefinitionName, fso)

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

docObj.Action.ErrorMessage = "Error al crear la carpeta de exportación: " + Err.Description
        Err.Clear
        Exit Subub
    End if

' exportando imágenes
    ExportImages docObj, FCTools, folderName, fso
    if Err.Number <> 0 then
        docObj.Action.Succeeded = false

docObj.Action.ErrorMessage = "Error al exportar imágenes: " + Err.Description
        Err.Clear
        Exit Sub
    End if

' creando el archivo de texto
    fileName = fso.BuildPath(folderName, "doc.txt")
    Set txtFile = fso.CreateTextFile(fileName, True)

' exportar información sobre el documento
    ExportDocInfo docObj, txtFile

' exportando campos
    txtFile.WriteLine "Fields:"
    ExportFields docObj.Children, txtFile, ""
    txtFile.Close

if Err.Number <> 0 then
        docObj.Action.Succeeded = false
        docObj.Action.ErrorMessage = "Error durante la exportación de datos: " + Err.Description
        Err.Clear
        Exit Sub
    End if

Set txtFile = Nothing
    Set fso = Nothing
End Sub

' Función de exportación de imágenes
Function ExportImages( ByRef docObj, ByRef FCTools, ByVal exportFolder, ByRef fso )
    Dim pages, page, imageOptions
    Dim fileName, pageNum

' especificando la configuración de exportación
    Set imageOptions = FCTools.NewImageSavingOptions
    imageOptions.Format = "bmp"

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

' exportación página por página
    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

' Procedimiento que exporta información sobre el documento
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

' El procedimiento que exporta los campos de la colección de campos
Sub ExportFields(ByRef fields, ByRef txtFile, ByVal indent)
    Dim curField

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

End Sub

' Comprueba si el valor de los fields es null
' Si el valor del campo no es válido, cualquier intento de acceder a este campo (incluso
' para comprobar si es null) puede provocar una excepción

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

' Procedimiento de exportación de campo
Sub ExportField(ByRef field, ByRef txtFile, ByVal indent)

' guardando el nombre del campo
    txtFile.Write (indent & field.Name)

' guardar el valor del campo si es accesible
    If IsNullFieldValue(field) Then
        txtFile.WriteLine
    Else

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

If Not field.Children Is Nothing Then
        ' exportando campos secundarios
        ExportFields field.Children, txtFile, indent & "    "

ElseIf Not field.Items Is Nothing Then
        ' exportando instancias de campo
        ExportFields field.Items, txtFile, indent & "    "
    End If

End Sub

' La función crea una carpeta de exportación y devuelve la ruta completa a esta carpeta
Function CreateExportFolder(ByVal definitionName, ByRef fso)
    Dim docFolder, folderName

' carpeta principal
    exportFolder = "d:\ScriptExport"

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

' la carpeta de la Definición de Document especificada
    docFolder = fso.BuildPath(exportFolder, definitionName)

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

' la carpeta del documento exportado
    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 función realiza la exportación: crea una carpeta de exportación y
// guarda en ella los archivos de imagen de página, el archivo de texto con los campos del documento
// e información sobre el documento
function ExportDocument(docObj, exportImageTools)
{

var folderName
    var txtFile, fileName
    var fso

fso = new ActiveXObject("Scripting.FileSystemObject");
    // creando carpetas de exportación
    try {

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

docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Error al crear la carpeta de exportación: " + e.description;
        return;n;

// exportando imágenes
    try {

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

docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Error durante la exportación de imágenes: " + e.description;
        return;
    }

// creación del archivo de texto
    fileName = fso.BuildPath(folderName, "doc.txt");
    txtFile = fso.CreateTextFile(fileName, true);

// exportando información sobre el documento
    ExportDocInfo( docObj, txtFile );

// exportando campos
    txtFile.WriteLine( "Fields:" );
    try {

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

docObj.Action.Succeeded = false;
        docObj.Action.ErrorMessage = "Error durante la exportación de datos: " + e.description;
        txtFile.Close();
        return;
    }

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

// Función de exportación de imágenes. Si se produce un error al exportar imágenes,
// devuelve un mensaje sobre el error; de lo contrario, devuelve una cadena vacía
function ExportImages( docObj, exportImageTools, exportFolder, fso )
{

// especificando la configuración de exportación
    var imageOptions = exportImageTools.NewImageSavingOptions();
    imageOptions.Format = "bmp";
    imageOptions.ColorType = "FullColor";
    imageOptions.Resolution = 100;

// exportación página por página
    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 );
    }
}

// Procedimiento que exporta información sobre el documento
function ExportDocInfo(docObj, txtFile)
{

txtFile.WriteLine( "Información del documento:" );
    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();
}

// El procedimiento que exporta fields de la colección de fields
function ExportFields(fields, txtFile, indent)
{

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

// Comprueba si el valor del campo es nulo
// Si el valor del campo no es válido, cualquier intento de acceder a este campo (incluso
// para comprobar si es nulo) puede provocar una excepción
function IsNullFieldValue( field )
{

try {

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

return true;
    }
}

// Procedimiento de exportación de campo
function ExportField(field, txtFile, indent)
{

// guardando el nombre del archivo
    txtFile.Write(indent + field.Name);

// guardando el valor del campo, si es accesible
    if( IsNullFieldValue( field ) ) {
        txtFile.WriteLine();
    } else {

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

if( field.Children != null ) {
        // exportando campos secundarios
        ExportFields( field.Children, txtFile, indent + "    " );

} else if( field.Items != null ) {
        // exportando instancias de campo
        ExportFields( field.Items, txtFile, indent + "    " );
    }
}

// La función crea una carpeta de exportación y devuelve la ruta completa a esta carpeta
function CreateExportFolder(definitionName, fso)
{
    var docFolder, folderName

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

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

// la carpeta de la Definición de Document especificada
    docFolder = fso.BuildPath(exportFolder, definitionName);

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

// la carpeta del documento exportado
    var i = 1;
    folderName = fso.BuildPath(docFolder, i);

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

fso.CreateFolder(folderName);
    return folderName;
}

Uso de un componente COM externo

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

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

Código de un componente ActiveX en VisualBasic

A continuación se muestra el código de la clase Exporter del proyecto AutomationExport, que se utiliza en los scripts mencionados anteriormente.

OptionExplicit

Dim mFso AsNew Scripting.FileSystemObject

' El procedimiento realiza la exportación del documento: crea una carpeta de exportación y

' guarda en él los archivos de imagen de página, el archivo de texto con los campos del documento,

' and information about the 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

' creando la carpeta de exportación

folderName = createExportFolder(docObj.definitionName)

If folderName = "" Then

docObj.Action.Succeeded = False

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

ExitSub

EndIf

' exportando imágenes

imageExportResult = exportImages(docObj, FCTools, folderName)

' creando el archivo de texto

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

Set txtFile = mFso.CreateTextFile(fileName, True)

' guardando información sobre problemas de exportación de imágenes

If imageExportResult <> "" Then

txtFile.WriteLine imageExportResult

errMessage = errMessage & imageExportResult

EndIf

' exportando información sobre el documento

exportDocInfo docObj, txtFile

' exporting fields

txtFile.WriteLine "Fields:"

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

errMessage = errMessage & " Error during export data"

EndIf

txtFile.Close

' si se producen errores durante la exportación, restablecer el

' establecer el indicador de éxito de exportación en 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

' Función de exportación de Image. Si se produce un error al exportar imágenes,

' devuelve un mensaje sobre el error; de lo contrario, devuelve una cadena vacía

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

' especificando la configuración de exportación

Set imageOptions = FCTools.NewImageSavingOptions

imageOptions.Format = "png"

imageOptions.ColorType = "GrayScale"

imageOptions.Resolution = 300

' exportación página por página

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

Página siguiente

ExitFunction

err_h:

exportImages = Err.Description

EndFunction

' El procedimiento que exporta información sobre el documento

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

' El procedimiento que exporta fields de la colección de 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

' Comprueba si el valor del campo es nulo

' Si el valor no es válido, cualquier intento de acceder a este campo (incluso

' para verificar si es nulo) puede generar una excepción

Function IsNullFieldValue(ByRef field As Object) AsBoolean

OnErrorGoTo err_h

IsNullFieldValue = IsNull(field.Value)

ExitFunction

err_h:

IsNullFieldValue = True

EndFunction

' Función de exportación de campo

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

ByVal indent AsString) AsBoolean

OnErrorGoTo err_h

Dim result AsBoolean

result = True

' guardando nombre de campo

txtFile.Write (indent & field.Name)

' guardando el valor del campo si es accesible

IfNot IsNullFieldValue(field) Then

txtFile.WriteLine ("    " & field.Value)

Else

txtFile.WriteLine

EndIf

IfNot field.Children Is NothingThen

' exportando campos secundarios

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

ElseIfNot field.Items IsNothingThen

' exportando instancias de campo

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

EndIf

exportField = result

ExitFunction

err_h:

txtFile.WriteLine Err.Description

exportField = False

EndFunction

' La función crea una carpeta de exportación y devuelve la ruta completa a dicha carpeta

PrivateFunction createExportFolder(ByVal definitionName AsString) AsString

OnErrorGoTo err_h

Dim docFolder AsString, folderName AsString

' carpeta principal

Const exportFolder = "d:\AutomationExport"

If mFso.FolderExists(exportFolder) = FalseThen

mFso.CreateFolder (exportFolder)

EndIf

' la carpeta de la Definición de Document especificada

docFolder = mFso.BuildPath(exportFolder, definitionName)

If mFso.FolderExists(docFolder) = FalseThen

mFso.CreateFolder (docFolder)

EndIf

' la carpeta del documento exportado

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

Uso de un componente externo escrito en .Net( C# )

Para usar un componente externo escrito en .Net, haga lo siguiente:

Cree un proyecto del tipo ClassLibrary
Agregue ControllerInterop.dll a las referencias del proyecto; ABBYY.FlexiCapture aparecerá en la lista References y todas las interfaces de los objetos de script estarán disponibles en el proyecto.
Defina la interfaz disp y la clase que la implementa, así como ProgId (esto permitirá trabajar con el componente .Net desde el código del script igual que con ActiveX).
Después de compilar el proyecto, registre la biblioteca de tipos generada (esto puede hacerse automáticamente al habilitar la opción correspondiente en las Propiedades del proyecto).
En el código de exportación, llame al método del componente de la forma habitual:

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

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

A continuación se muestra el código de dicho componente:

using System;

using System.Runtime.InteropServices;

using System.IO;

using ABBYY.FlexiCapture;

namespace ExportLibrary1

// La interfaz del componente de exportación a la que se puede acceder desde el script
      // Al crear un nuevo componente, genere un nuevo GUID
      [Guid("32B10C3B-EEA3-4194-B0A0-E358C310225A")]
      [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]

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

// La clase que implementa la funcionalidad del componente de exportación
      // Al crear un nuevo componente, genere un nuevo GUID
// y configure su ProgId
      [Guid("3BA19BD7-C6DC-4f63-BC08-0D95254DADC3")]
      [ClassInterface(ClassInterfaceType.None)]

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

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

// La función realiza la exportación del documento: crea una carpeta de exportación y
// guarda en ella los archivos de imagen de página,

// el archivo de texto con los campos del documento e información sobre el documento
            public void ExportDocument( ref IExportDocument docRef, ref FCTools FCTools )

try
                  {

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

// creación del archivo de texto
                        string fileName = exportFolder + "//" + "doc.txt";
                        StreamWriter sw = File.CreateText( fileName );

// exportando información sobre el documento
                        exportDocInfo( docRef, sw );

// exportando campos
                        sw.WriteLine( "Fields:" );
                        exportFields( docRef.Children, sw, "" );
                        sw.Close();
                  }

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

// La función crea una carpeta de exportación y devuelve la ruta completa a esta carpeta
            privatestring createExportFolder(string definitionName )
            {
                  string docFolder, folderName;

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

// la carpeta de la Definición de Document especificada
                  docFolder = exportFolder + "\\" + definitionName;
                  if( !Directory.Exists(docFolder) )
                  {
                        Directory.CreateDirectory( docFolder ); 
                  }

// la carpeta del documento exportado
                  int i = 1;
                  folderName = docFolder + "\\" + i;

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

Directory.CreateDirectory(folderName);
                  return folderName;
            }

// Función de exportación de imágenes
            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++;
                  }
            }

// Exportando información sobre el documento
            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();
            }

// Exportar colección de campos
             private void exportFields( IExportFields fields, StreamWriter sw, string indent )
            {

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

// Comprueba si el valor del campo es nulo
            // Si el valor del campo no es válido, cualquier intento de acceder a este campo (incluso
// para comprobar si es nulo) puede provocar una excepción
            privatebool IsNullFieldValue( IExportField field )
            {

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

catch( Exception e )
                  {
                        returntrue;
                  }
            }

// Exportación del campo especificado
            private void exportField( IExportField field, StreamWriter sw, string indent )
            {

// guardando el nombre del campo
                  sw.Write( indent + field.Name );

// guardar el valor del campo si se puede acceder a él
                  if( IsNullFieldValue( field ) )
                  {
                        sw.WriteLine();
                  }

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

if( field.Children != null )
                  {
                        // exportando campos secundarios
                        exportFields( field.Children, sw, indent + "    " );
                  }

else if( field.Items != null )
                  {

// exportando instancias de campo
                        exportFields( field.Items, sw, indent + "    " );
                  }
                  }
      }
            }

Manejador de exportación

Este código de ejemplo muestra un manejador de exportación sencillo que guarda información sobre los documentos exportados y los resultados de exportación en archivos de texto. En este ejemplo se usan dos archivos de texto: uno que contiene la lista de documentos exportados correctamente y otro que contiene la lista de documentos que devolvieron errores durante la exportación.

[VBScript]

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

' crea el archivo con los documentos cuya exportación falló
fileErrorName = "d:\ExportResults\ErrorsDocuments.txt"
set txtErrorFile = fso.CreateTextFile( fileErrorName, true )

' crea el archivo con los documentos exportados correctamente
fileSucceedName = "d:\ExportResults\SucceedDocuments.txt"
set txtSucceedFile = fso.CreateTextFile( fileSucceedName, true )
dim i, exprortResult, docInfo

' recorre la colección de documentos exportados
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");

// crea el archivo con los documentos cuya exportación falló
var fileErrorName = "d:\\ExportResults\\ErrorsDocuments.txt";
var txtErrorFile = fso.CreateTextFile( fileErrorName, true );

// crea el archivo con los documentos exportados correctamente
var fileSucceedName = "d:\\ExportResults\\SucceedDocuments.txt"
var txtSucceedFile = fso.CreateTextFile( fileSucceedName, true );
var i

// recorre la colección de documentos exportados
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();

Acceso a archivos de origen en formatos ofimáticos comunes

Este script de ejemplo muestra cómo guardar los archivos de origen al exportar documentos. Los archivos de origen deben estar en cualquiera de los formatos ofimáticos comunes compatibles y deben tener nombres únicos para evitar conflictos de nombres.

using System;

using System.IO;

using System.Collections.Generic;

// Recorrer las páginas.

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

IPage page = Document.Pages[i];

// Comprobar si existe un archivo de origen.

if( page.SourceFileGUID == "" ) {

continue;

// El nombre original del archivo.

string sourceFileName = @"";

// Especificar el nombre original del archivo.

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

sourceFileName = Path.GetFileName( page.ImageSource );

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

sourceFileName = Path.GetFileName( page.ImageSourceFileSubPath );

// Quitar la extensión del nombre del archivo.

if( sourceFileName != @"" ) {

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

// Nombre único del archivo de origen (nombre original + GUID).

string sourceFileUniqueName = sourceFileName + page.SourceFileGUID;

// La ruta de la carpeta donde debe guardarse el archivo de origen.

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

// Asegurarse de que el archivo no exista.

if( File.Exists( sourceFilePath ) ) {

continue;

// Guardar el archivo.

Processing.ReportMessage( "Guardando archivo de origen: " + sourceFileUniqueName );

page.SaveSourceFile( sourceFilePath );

​Código de exportación principal

​El código de las funciones del módulo de exportación global

​Código de un componente ActiveX en VisualBasic

​Uso de un componente externo escrito en .Net( C# )

Código de exportación principal

El código de las funciones del módulo de exportación global

Código de un componente ActiveX en VisualBasic

Uso de un componente externo escrito en .Net( C# )