Exemples de scripts décrivant une exportation
Récupération des valeurs de champ pendant une exportation
Cet exemple de code montre comment récupérer la valeur d'un champ pendant une exportation. Vous pouvez utiliser cette valeur pour nommer les fichiers dans lesquels les images ou les données sont exportées. S'il n'y a pas de champ de ce type dans le document, une erreur se produira.will occur.
Structure du document à exporter :
Section 1
Field1
…
Group1
Field2
…
…
FieldN
Section 2
Field1
…
FieldK
[VBScript]
Dim field1Value, field2Value
' Récupère la valeur de Field1 dans la Section 1
if Not IsNull( me.Field( "Section 1\Field1" ).Value ) then
field1Value = me.Field( "Section 1\Field1" ).Value
end if
' Récupère la valeur de Field2 dans Group1 dans la Section 1
if Not IsNull( me.FIELD( "Section 1\Group1\Field2" ).Value ) then
field2Value = me.Field( "Section 1\Group1\Field2" ).Value
end if
' Récupère 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]
// Récupère la valeur de Field1 dans Section 1
if( Field("Section 1\\Field1").Value != null ) {
var field1Value = Field("Section 1\\Field1").Value;
}
// Récupère la valeur de Field2 dans Group1, Section 1
if( Field("Section 1\\Group1\\Field2").Value != null ) {
var field2Value = Field("Section 1\\Group1\\Field2").Value;
}
// Récupère 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 d'images de pages
Le code de cet exemple montre comment exporter des images de toutes les pages d'un document en utilisant le format de fichier requis, le système de couleurs requis et la résolution requise. Les images sont enregistrées page par page. Chaque page est donc stockée dans un fichier distinct.
Les fichiers de cet exemple sont nommés « page1.tif », « page2.tif », etc. Vous pouvez modifier le mécanisme de dénomination des fichiers si nécessaire. Par exemple, vous pouvez créer des noms de fichiers à 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 l'extension et le nom souhaités pour le fichier, en fonction du 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 l'extension et le nom souhaités pour le fichier, en fonction du 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 vers 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 des champs d'un document, quel que soit son niveau d'imbrication, en utilisant des fonctions personnalisées, que vous créez vous-même, à partir du module d'exportation global. S'il vous faut exporter des champs d'un document présentant une imbrication variable, il est recommandé d'utiliser un composant COM externe (voir l'exemple suivant).
Code d'exportation de base
[VBScript]
Export.ExportDocument me, FCTools
[JScript]
Export.ExportDocument( this, FCTools );
Code des fonctions du module d'exportation global
[VBScript]
' La procédure effectue l'exportation : elle crée un dossier d'exportation et
' enregistre dans ce dernier des fichiers image de pages, le fichier texte contenant les champs du document,
' et des 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 = "Error during create export folder: " + Err.Description
Err.Clear
Exit Subub
End if
' exportation d'images
ExportImages docObj, FCTools, folderName, fso
if Err.Number <> 0 then
docObj.Action.Succeeded = false
docObj.Action.ErrorMessage = "Erreur lors de l'exportation d'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 concernant 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 de 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écificationdes paramètres d'exportation
Set imageOptions = FCTools.NewImageSavingOptions
imageOptions.Format = "bmp"
imageOptions.ColorType = "FullColor"
imageOptions.Resolution = 100
' exportation 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 d'exportation des informations concernant le 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
' Procédure d'exportation des champs à partir de l'ensemble de champs
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 du champ est nulle
' Si la valeur du champ n'est pas valide, toute tentative d'accès à ce champ (y compris
' pour en vérifier la nullité) peut générer 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 des champs
Sub ExportField(ByRef field, ByRef txtFile, ByVal indent)
' enregistrement du nom des champs
txtFile.Write (indent & field.Name)
' enregistrement de la valeur des champs accessibles
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 champs
ExportFields field.Items, txtFile, indent & " "
End If
End Sub
' La fonction crée un dossier d'exportation et retourne le chemin d'accès complet de 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'exportation : elle crée un dossier d'exportation et
// enregistre dans ce dernier des fichiers image de pages, le fichier texte contenant les champs du document
// et des 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 l'exportation d'images : " + e.description;
return;n;
}
// exportation d'images
try {
ExportImages(docObj, exportImageTools, folderName, fso);
} catch( e ) {
docObj.Action.Succeeded = false;
docObj.Action.ErrorMessage = "Erreur lors de l'exportation d'images : " + e.description;
return;
}
// création du fichier texte
fileName = fso.BuildPath(folderName, "doc.txt");
txtFile = fso.CreateTextFile(fileName, true);
// exportation des informations concernant 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 d'images : " + e.description;
txtFile.Close();
return;
}
txtFile.Close();
txtFile = 0;
fso = 0;
}
// Fonction d'exportation d'images. If an error occurs when exporting images,
// it returns a message about the error; otherwise, it returns an empty string
function ExportImages( docObj, exportImageTools, exportFolder, fso )
{
// spécification des paramètres d'exportation
var imageOptions = exportImageTools.NewImageSavingOptions();
imageOptions.Format = "bmp";
imageOptions.ColorType = "FullColor";
imageOptions.Resolution = 100;
// exportation 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 d'exportation des informations concernant le document
function ExportDocInfo(docObj, txtFile)
{
txtFile.WriteLine( "Doc info:" );
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 d'exportation des champs à partir de l'ensemble de champs
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 n'est pas valide, toute tentative d'accès à ce champ (y compris
// pour en vérifier la nullité) peut générer une exception
function IsNullFieldValue( field )
{
try {
return ( field.Value == null );
} catch( e ) {
return true;
}
}
// Procédure d'exportation des champs
function ExportField(field, txtFile, indent)
{
// enregistrement du nom des champs
txtFile.Write(indent + field.Name);
// enregistrement de la valeur des champs accessibles
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 champs
ExportFields( field.Items, txtFile, indent + " " );
}
}
// La fonction crée un dossier d'exportation et retourne le chemin d'accès complet de 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 un code de classe Exporter issu du projet AutomationExport, qui est utilisé dans les scripts ci-dessus.
OptionExplicit
Dim mFso AsNew Scripting.FileSystemObject
' La procédure exécute l'exportation du document : elle crée un dossier d'exportation et
' enregistre dans ce dernier des fichiers image de pages, le fichier texte contenant les champs du document
' et des informations relatives au 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 = "Impossible de créer le dossier d'exportation"
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'exportation d'images
If imageExportResult <> "" Then
txtFile.WriteLine imageExportResult
errMessage = errMessage & imageExportResult
EndIf
' exportation des informations concernant le document
exportDocInfo docObj, txtFile
' exportation des champs
txtFile.WriteLine "Fields:"
IfNot exportFields(docObj.Children, txtFile, "") Then
errMessage = errMessage & " Erreur lors de l'exportation des données"
EndIf
txtFile.Close
' si des erreurs surviennent pendant l'exportation, réinitialisez l'indicateur
' d'exportation réussie sur 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 survient pendant l'exportation des images,
' un message relatif à l'erreur est retourné, sinon une chaîne vide est retournée
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'exportation
Set imageOptions = FCTools.NewImageSavingOptions
imageOptions.Format = "png"
imageOptions.ColorType = "GrayScale"
imageOptions.Resolution = 300
' exportation 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
Next page
ExitFunction
err_h:
exportImages = Err.Description
EndFunction
' Procédure d'exportation des informations concernant le 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
' Procédure d'exportation des champs à partir de l'ensemble de champs
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 du champ n'est pas valide, toute tentative d'accès à ce champ (y compris
' pour en vérifier la nullité) peut générer une exception
Function IsNullFieldValue(ByRef field As Object) AsBoolean
OnErrorGoTo err_h
IsNullFieldValue = IsNull(field.Value)
ExitFunction
err_h:
IsNullFieldValue = True
EndFunction
' Fonction d'exportation de champs
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 des champs
txtFile.Write (indent & field.Name)
' enregistrement de la valeur des champs accessibles
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 champs
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'exportation et retourne le chemin d'accès complet de 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
' 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ît dans la liste Références et toutes les interfaces des objets de scripts sont désormais disponibles dans le projet.
- Définissez l'interface disp et la classe implémentant cette interface, ainsi que ProgId (afin de pouvoir utiliser le composant .Net tout comme ActiveX, à partir du code du script).
- Une fois que le projet est créé, enregistrez la bibliothèque de types générée (activez l'option correspondante dans les propriétés du projet pour effectuer cette opération automatiquement).
- À partir du code d'exportation, appelez la méthode du composant comme vous le faites habvituellement :
[VBScript]
dim autoExport
set autoExport = CreateObject( "ExportLibrary1.Export" )
autoExport.ExportDocument me, FCTools
[JScript]
var autoExport = new ActiveXObject("ExportLibrary1.Export"); autoExport.ExportDocument( this, FCTools );
Le code d'un tel composant est illustré ci-dessous :
using System;
using System.Runtime.InteropServices;
using System.IO;
using ABBYY.FlexiCapture;
namespace ExportLibrary1
{
// Interface du composant d'exportation accessible à partir du script
// Lorsque vous créez un nouveau composant, générez 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);
}
// Classe implémentant la fonctionnalité du composant d'exportation
// Lorsque vous créez 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 exécute l'exportation du document : elle crée un dossier d'exportation et
// enregistre dans ce dernier des fichiers image de pages,
// le fichier texte contenant les champs du document et des 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 concernant 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'exportation et retourne le chemin d'accès complet de 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 );
}
// 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 concernant 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 d'un ensemble 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 n'est pas valide, toute tentative d'accès à ce champ (y compris
// pour en vérifier la nullité) peut générer 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 des champs
sw.Write( indent + field.Name );
// enregistrement de la valeur des champs accessibles
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 champs
exportFields( field.Items, sw, indent + " " );
}
}
}
}
Gestionnaire d'exportation
Cet exemple de code illustre un gestionnaire d'exportation élémentaire qui enregistre des informations concernant les documents exportés et exporte les résultats vers des fichiers texte. Deux fichiers texte sont utilisés dans cet exemple : l'un d'eux contient la liste des documents exportés avec succès et l'autre contient la liste des documents pour lesquels des erreurs ont été retournées pendant l'exportation.
[VBScript]
dim curDoc
dim fso, fileErrorName, txtErrorFile, fileSucceedName, txtSucceedFile
set fso = CreateObject("Scripting.FileSystemObject")
' création du fichier pour les documents dont l'exportation a échoué
fileErrorName = "d:\ExportResults\ErrorsDocuments.txt"
set txtErrorFile = fso.CreateTextFile( fileErrorName, true )
' création du fichier pour les documents dont l'exportation a réussi
fileSucceedName = "d:\ExportResults\SucceedDocuments.txt"
set txtSucceedFile = fso.CreateTextFile( fileSucceedName, true )
dim i, exprortResult, docInfo
' itération de l'ensemble de 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 des fichiers pour les documents dont l'exportation a échoués
var fileErrorName = "d:\\ExportResults\\ErrorsDocuments.txt";
var txtErrorFile = fso.CreateTextFile( fileErrorName, true );
// création du fichier pour les documents dont l'exportation a réussi
var fileSucceedName = "d:\\ExportResults\\SucceedDocuments.txt"
var txtSucceedFile = fso.CreateTextFile( fileSucceedName, true );
var i
// itération de l'ensemble de 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 des formats Office courants
Cet exemple de script montre comment vous pouvez 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 un nom unique doit leur être attribué afin d’éviter les conflits de noms.
using System;
using System.IO;
using System.Collections.Generic;
// Répéter sur toutes les pages.
for( int i = 0; i<Document.Pages.Count; i++ ) {
IPage page = Document.Pages[i];
// Vérifier la présence d'un fichier source.
if( page.SourceFileGUID == "" ) {
continue;
}
// Le nom d'origine du fichier.
string sourceFileName = @"";
// Spécifier 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 de fichier du nom du fichier.
if( sourceFileName != @"" ) {
sourceFileName = Path.GetFileNameWithoutExtension( sourceFileName ) + @".";
}
// Nom unique du fichier source (nom d'origine + guid).
string sourceFileUniqueName = sourceFileName + page.SourceFileGUID;
// Le chemin d'accès au dossier dans lequel le fichier source doit être enregistré.
string sourceFilePath = Document.Batch.Project.ExportRootPath + @"\" + sourceFileUniqueName;
// S'assurer que le fichier n'existe pas.
if( File.Exists( sourceFilePath ) ) {
continue;
}
// Enregistrer le fichier.
Processing.ReportMessage( "Enregistrement du fichier source : " + sourceFileUniqueName );
page.SaveSourceFile( sourceFilePath );
}
4/12/2024 6:16:04 PM