Beispielskripte für die Exportbeschreibung
Abrufen von Feldwerten beim Export
Dieser Beispielcode veranschaulicht, wie Sie den Wert eines Felds beim Export abrufen. Sie können mit diesem Wert die Dateien benennen, in die die Bilder oder Daten exportiert werden. Ist kein entsprechendes Feld im Dokument enthalten, tritt ein Fehler auf.
Die Struktur des in diesem Beispiel exportierten Dokuments sieht wie folgt aus:
Section 1
Field1
…
Group1
Field2
…
…
FieldN
Section 2
Field1
…
FieldK
[VBScript]
Dim field1Value, field2Value
' Ruft den Wert des Field1 in Abschnitt 1 ab
if Not IsNull( me.Field( "Section 1\Field1" ).Value ) then
field1Value = me.Field( "Section 1\Field1" ).Value
end if
' Ruft den Wert des Feld2 in Gruppe1 in Abschnitt 1 ab
if Not IsNull( me.FIELD( "Section 1\Group1\Field2" ).Value ) then
field2Value = me.Field( "Section 1\Group1\Field2" ).Value
end if
' Ruft den Wert des Field1 in Abschnitt 1 ab, wenn der Abschnitt mehrere Instanzen enthält
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]
// Ruft den Wert des Field1 in Abschnitt 1 ab
if( Field("Section 1\\Field1").Value != null ) {
var field1Value = Field("Section 1\\Field1").Value;
}
// Ruft den Wert des Feld2 in Gruppe1 in Abschnitt 1 ab
if( Field("Section 1\\Group1\\Field2").Value != null ) {
var field2Value = Field("Section 1\\Group1\\Field2").Value;
}
// Ruft den Wert des Field1 in Abschnitt 1 ab, wenn der Abschnitt mehrere Instanzen enthält
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;
}
}
}
}
}
Exportieren von Seitenbildern
Anhand des Codes in diesem Beispiel wird das Exportieren von Bildern aller Dokumentseiten mit dem erforderlichen Dateiformat, dem Farbschema und der Auflösung veranschaulicht. Die Bilder werden seitenweise gespeichert, so dass jede Seite in einer eigenen Datei gespeichert wird.
Die Dateien in diesem Beispiel werden mit "page1.tif", "page2.tif" usw. bezeichnet, Sie können das Benennungsschema für die Dateien aber ggf. ändern, indem Sie beispielsweise die Dateinamen auf Grundlage des Werts eines Felds erstellen.
[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
' Legt den gewünschten Dateinamen und die Erweiterung in Abhängigkeit vom ausgewählten Format fest
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++ ) {
// Legt den gewünschten Dateinamen und die Erweiterung in Abhängigkeit vom ausgewählten Format fest
var fileName = fso.BuildPath( folderName, "page" + (i+1) + ".tif" );
Pages.Item(i).SaveAs( fileName, imageOptions );
}
Exportieren einer Tabelle
In diesem Beispiel wird das Exportieren einer Tabelle in eine TXT-Datei veranschaulicht.
[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();
Exportieren eines Dokuments mit beliebiger Verschachtelungstiefe
Dieses Beispiel zeigt, wie Felder eines Dokuments mit beliebiger Verschachtelungstiefe mithilfe benutzerdefinierter Funktionen aus dem globalen Exportmodul exportiert werden. Wenn Sie Dokumentfelder mit variabler Verschachtelung exportieren möchten, sollten Sie eine externe COM-Komponente verwenden. (Weitere Informationen finden Sie im nächsten Beispiel.)
Kerncode für den Export
[VBScript]
Export.ExportDocument me, FCTools
[JScript]
Export.ExportDocument( this, FCTools );
Der Code der Funktionen des globalen Exportmoduls
[VBScript]
' Die Prozedur führt den Export durch: Sie erstellt einen Exportordner und
' speichert in ihm Seitenbilddateien, die Textdatei mit den Dokumentfeldern
' und Informationen über das Dokument
Sub ExportDocument(ByRef docObj, ByRef FCTools)
Dim folderName
Dim txtFile, fileName
Dim fso
On Error Resume Next
set fso = CreateObject("Scripting.FileSystemObject")
' Erstellen des Exportordners
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
' Bilder exportieren
ExportImages docObj, FCTools, folderName, fso
if Err.Number <> 0 then
docObj.Action.Succeeded = false
docObj.Action.ErrorMessage = "Error during export images: " + Err.Description
Err.Clear
Exit Sub
End if
' Die Textdatei erstellen
fileName = fso.BuildPath(folderName, "doc.txt")
Set txtFile = fso.CreateTextFile(fileName, True)
' Informationen über das Dokument exportieren
ExportDocInfo docObj, txtFile
' Felder exportieren
txtFile.WriteLine "Fields:"
ExportFields docObj.Children, txtFile, ""
txtFile.Close
if Err.Number <> 0 then
docObj.Action.Succeeded = false
docObj.Action.ErrorMessage = "Error during export data: " + Err.Description
Err.Clear
Exit Sub
End if
Set txtFile = Nothing
Set fso = Nothing
End Sub
' Bildexportfunktion
Function ExportImages( ByRef docObj, ByRef FCTools, ByVal exportFolder, ByRef fso )
Dim pages, page, imageOptions
Dim fileName, pageNum
' Spezifizierung der Exporteinstellungen
Set imageOptions = FCTools.NewImageSavingOptions
imageOptions.Format = "bmp"
imageOptions.ColorType = "FullColor"
imageOptions.Resolution = 100
' Seitenweiser Export
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
' Prozedur zum Exportieren der Informationen über das Dokument
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
' Prozedur zum Exportieren von Feldern aus der Auflistung von Feldern
Sub ExportFields(ByRef fields, ByRef txtFile, ByVal indent)
Dim curField
For Each curField In fields
ExportField curField, txtFile, indent
Next
End Sub
' Überprüft, ob der Wert des Felds NULL ist
' Wenn der Feldwert ungültig ist, dann kann jeder Zugriffsversuch (auch
' die Überprüfung auf NULL) kann eine Ausnahme auslösen
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
' Feldexportprozedur
Sub ExportField(ByRef field, ByRef txtFile, ByVal indent)
' Feldnamen speichern
txtFile.Write (indent & field.Name)
' Feldwert, sofern verfügbar, speichern
If IsNullFieldValue(field) Then
txtFile.WriteLine
Else
txtFile.WriteLine (" " & field.Text)
End If
If Not field.Children Is Nothing Then
' untergeordnete Felder exportieren
ExportFields field.Children, txtFile, indent & " "
ElseIf Not field.Items Is Nothing Then
' Feldinstanzen exportieren
ExportFields field.Items, txtFile, indent & " "
End If
End Sub
' Die Funktion erstellt einen Exportordner und gibt seinen vollständigen Pfad zurück
Function CreateExportFolder(ByVal definitionName, ByRef fso)
Dim docFolder, folderName
' Hauptordner
exportFolder = "d:\ScriptExport"
If fso.FolderExists(exportFolder) = False Then
fso.CreateFolder (exportFolder)
End If
' der Ordner der spezifizierten Dokumentdefinition
docFolder = fso.BuildPath(exportFolder, definitionName)
If fso.FolderExists(docFolder) = False Then
fso.CreateFolder (docFolder)
End If
' der Ordner für das exportierte Dokument
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]
// Die Prozedur führt den Export durch: Sie erstellt einen Exportordner und
// speichert in ihm Seitenbilddateien, die Textdatei mit den Dokumentfeldern
// und Informationen über das Dokument
function ExportDocument(docObj, exportImageTools)
{
var folderName
var txtFile, fileName
var fso
fso = new ActiveXObject("Scripting.FileSystemObject");
// Erstellen des Exportordners
try {
folderName = CreateExportFolder(docObj.DefinitionName, fso);
} catch( e ) {
docObj.Action.Succeeded = false;
docObj.Action.ErrorMessage = "Error during create export folder: " + e.description;
return;n;
}
// Bilder exportieren
try {
ExportImages(docObj, exportImageTools, folderName, fso);
} catch( e ) {
docObj.Action.Succeeded = false;
docObj.Action.ErrorMessage = "Error during export images: " + e.description;
return;
}
// Die Textdatei erstellen
fileName = fso.BuildPath(folderName, "doc.txt");
txtFile = fso.CreateTextFile(fileName, true);
// Informationen über das Dokument exportieren
ExportDocInfo( docObj, txtFile );
// Felder exportieren
txtFile.WriteLine( "Fields:" );
try {
ExportFields( docObj.Children, txtFile, "" );
} catch( e ) { {
docObj.Action.Succeeded = false;
docObj.Action.ErrorMessage = "Error during export data: " + e.description;
txtFile.Close();
return;
}
txtFile.Close();
txtFile = 0;
fso = 0;
}
// Bildexportfunktion. Wenn während des Bildexports ein Fehler auftritt,
// dann wird eine Meldung über den Fehler zurückgegeben, andernfalls eine leere Zeichenfolge
function ExportImages( docObj, exportImageTools, exportFolder, fso )
{
// Spezifizierung der Exporteinstellungen
var imageOptions = exportImageTools.NewImageSavingOptions();
imageOptions.Format = "bmp";
imageOptions.ColorType = "FullColor";
imageOptions.Resolution = 100;
// Seitenweiser Export
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 );
}
}
// Prozedur zum Exportieren der Informationen über das Dokument
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();
}
// Prozedur zum Exportieren von Feldern aus der Auflistung von Feldern
function ExportFields(fields, txtFile, indent)
{
var i
for( i = 0; i < fields.Count; i++ ) {
ExportField( fields.Item(i), txtFile, indent );
}
}
// Überprüft, ob der Wert des Felds NULL ist
// Wenn der Feldwert ungültig ist, dann kann jeder Zugriffsversuch (auch
// die Überprüfung auf NULL) eine Ausnahme auslösen
function IsNullFieldValue( field )
{
try {
return ( field.Value == null );
} catch( e ) {
return true;
}
}
// Feldexportprozedur
function ExportField(field, txtFile, indent)
{
// Feldnamen speichern
txtFile.Write(indent + field.Name);
// Feldwert, sofern verfügbar, speichern
if( IsNullFieldValue( field ) ) {
txtFile.WriteLine();
} else {
txtFile.WriteLine(" " + field.Text);
} }
if( field.Children != null ) {
// untergeordnete Felder exportieren
ExportFields( field.Children, txtFile, indent + " " );
} else if( field.Items != null ) {
// Export von Feldinstanzen
ExportFields( field.Items, txtFile, indent + " " );
}
}
// Die Funktion erstellt einen Exportordner und gibt seinen vollständigen Pfad zurück
function CreateExportFolder(definitionName, fso)
{
var docFolder, folderName
// Hauptordner
var exportFolder = "d:\\ScriptExport";
if( !fso.FolderExists(exportFolder) ) {
fso.CreateFolder (exportFolder);
} }
// der Ordner der spezifizierten Dokumentdefinition
docFolder = fso.BuildPath(exportFolder, definitionName);
if( !fso.FolderExists(docFolder) ) {
fso.CreateFolder(docFolder);
}
// der Ordner für das exportierte Dokument
var i = 1;
folderName = fso.BuildPath(docFolder, i);
while( fso.FolderExists(folderName) ) {
i++;
folderName = fso.BuildPath(docFolder, i);
}
fso.CreateFolder(folderName);
return folderName;
}
Verwenden einer externen COM-Komponente
[VBScript]
dim autoExport
set autoExport = CreateObject( "AutomationExport.Exporter" )
autoExport.Export me, FCTools
[JScript]
var autoExport = new ActiveXObject("AutomationExport.Exporter");
autoExport.Export( this, FCTools );
Code einer ActiveX-Komponente in VisualBasic
Im Folgenden sehen Sie Code einer Exporter-Klasse aus dem Projekt "AutomationExport", das bereits in den oben beschriebenen Skripten verwendet wurde.
ExpliziteOption
Dim mFso AsNew Scripting.FileSystemObject
' Die Prozedur führt den Export durch: Sie erstellt einen Exportordner und
' speichert in ihm Seitenbilddateien, die Textdatei mit den Dokumentfeldern
' und Informationen über das Dokument
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
' Exportordner erstellen
folderName = createExportFolder(docObj.definitionName)
If folderName = "" Then
docObj.Action.Succeeded = False
docObj.Action.ErrorMessage = "Cannot create export folder"
ExitSub
EndIf
' Bilder exportieren
imageExportResult = exportImages(docObj, FCTools, folderName)
' Die Textdatei erstellen
fileName = mFso.BuildPath(folderName, "doc.txt")
Set txtFile = mFso.CreateTextFile(fileName, True)
Informationen über Probleme beim Bildexport speichern
If imageExportResult <> "" Then
txtFile.WriteLine imageExportResult
errMessage = errMessage & imageExportResult
EndIf
' Informationen über das Dokument exportieren
exportDocInfo docObj, txtFile
' Felder exportieren
txtFile.WriteLine "Fields:"
IfNot exportFields(docObj.Children, txtFile, "") Then
errMessage = errMessage & " Error during export data"
EndIf
txtFile.Close
' Wenn Fehler während des Exports auftreten,
' das Flag für erfolgreichen Export auf False zurücksetzen
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
' Bildexportfunktion. Wenn während des Bildexports ein Fehler auftritt,
' dann wird eine Meldung über den Fehler zurückgegeben, andernfalls eine leere Zeichenfolge
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 = ""
' Spezifizierung der Exporteinstellungen
Set imageOptions = FCTools.NewImageSavingOptions
imageOptions.Format = "png"
imageOptions.ColorType = "GrayScale"
imageOptions.Resolution = 300
' Seitenweiser Export
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
' Prozedur zum Exportieren der Informationen über das Dokument
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
' Prozedur zum Exportieren von Feldern aus der Auflistung von Feldern
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
' Überprüft, ob der Wert des Felds NULL ist
' Wenn der Feldwert ungültig ist, dann kann jeder Zugriffsversuch (auch
' die Überprüfung auf NULL) eine Ausnahme auslösen
Function IsNullFieldValue(ByRef field As Object) AsBoolean
OnErrorGoTo err_h
IsNullFieldValue = IsNull(field.Value)
ExitFunction
err_h:
IsNullFieldValue = True
EndFunction
' Feldexportfunktion
PrivateFunction exportField(ByRef field As Object, ByRef txtFile As TextStream, _
ByVal indent AsString) AsBoolean
OnErrorGoTo err_h
Dim result AsBoolean
result = True
' Feldnamen speichern
txtFile.Write (indent & field.Name)
' Feldwert, sofern verfügbar, speichern
IfNot IsNullFieldValue(field) Then
txtFile.WriteLine (" " & field.Value)
Else
txtFile.WriteLine
EndIf
IfNot field.Children Is NothingThen
' untergeordnete Felder exportieren
result = result And exportFields(field.Children, txtFile, indent & " ")
ElseIfNot field.Items IsNothingThen
' Feldinstanzen exportieren
result = result And exportFields(field.Items, txtFile, indent & " ")
EndIf
exportField = result
ExitFunction
err_h:
txtFile.WriteLine Err.Description
exportField = False
EndFunction
' Die Funktion erstellt einen Exportordner und gibt seinen vollständigen Pfad zurück
PrivateFunction createExportFolder(ByVal definitionName AsString) AsString
OnErrorGoTo err_h
Dim docFolder AsString, folderName AsString
' Hauptordner
Const exportFolder = "d:\AutomationExport"
If mFso.FolderExists(exportFolder) = FalseThen
mFso.CreateFolder (exportFolder)
EndIf
' der Ordner der spezifizierten Dokumentdefinition
docFolder = mFso.BuildPath(exportFolder, definitionName)
If mFso.FolderExists(docFolder) = FalseThen
mFso.CreateFolder (docFolder)
EndIf
' Ordner für das exportierte Dokument
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
Verwenden einer externen Komponente, die in .Net (C#) geschrieben ist
So verwenden Sie eine externe Komponente, die in .Net (C#) geschrieben ist:
- Erstellen Sie ein Projekt des Typs ClassLibrary.
- Fügen Sie die ControllerInterop.dll zu den Referenzen des Projekts hinzu. ABBYY FlexiCapture wird in der Liste References aufgeführt, und alle Schnittstellen der Skriptobjekte werden im Projekt verfügbar.
- Definieren Sie die Schnittstelle disp und die Klasse, die diese Schnittstelle implementiert, sowie ProgId (dadurch wird es möglich, im Code des Skripts mit der .Net-Komponente so zu arbeiten wie mit ActiveX).
- Registrieren Sie nach dem Aufbau des Projekts die Library der generierten Typen (das kann auch automatisch durch das Aktivieren der entsprechenden Option in den Projekteigenschaften erfolgen).
- Rufen Sie vom Exportcode aus die Methode der Komponente auf die übliche Weise auf:
[VBScript]
dim autoExport
set autoExport = CreateObject( "ExportLibrary1.Export" )
autoExport.ExportDocument me, FCTools
[JScript]
var autoExport = new ActiveXObject("ExportLibrary1.Export"); autoExport.ExportDocument( this, FCTools );
Below follows the code of such a component:
using System;
using System.Runtime.InteropServices;
using System.IO;
using ABBYY.FlexiCapture;
namespace ExportLibrary1
{
// Die Schnittstelle der Exportkomponente, auf die vom Skript aus zugegriffen werden kann
// Beim Erstellen einer neuen Komponente eine neue GUID erstellen
[Guid("32B10C3B-EEA3-4194-B0A0-E358C310225A")]
[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
public interface _cExport
{
[DispId(1)]
void ExportDocument(ref IExportDocument DocRef, ref FCTools Tools);
}
// Die Klasse, die die Funktion der Exportkomponente implementiert
// Beim Erstellen einer neuen Komponente eine neue GUID erstellen
// und Ihre ProgId festlegen
[Guid("3BA19BD7-C6DC-4f63-BC08-0D95254DADC3")]
[ClassInterface(ClassInterfaceType.None)]
[ProgId("ExportLibrary1.Export")]
[ComVisible(true)]
public class Export : _cExport
{
public Export()
{
}
// Die Prozedur führt den Export durch: Sie erstellt einen Exportordner und
// speichert in ihm Seitenbilddateien,
// die Textdatei mit Dokumentfeldern und Informationen über das Dokument
public void ExportDocument( ref IExportDocument docRef, ref FCTools FCTools )
{
try
{
string exportFolder = createExportFolder( docRef.DefinitionName );
exportImages( docRef, FCTools, exportFolder );
// Die Textdatei erstellen
string fileName = exportFolder + "//" + "doc.txt";
StreamWriter sw = File.CreateText( fileName );
// Informationen über das Dokument exportieren
exportDocInfo( docRef, sw );
// Felder exportieren
sw.WriteLine( "Fields:" );
exportFields( docRef.Children, sw, "" );
sw.Close();
}
catch( Exception e )
{
docRef.Action.Succeeded = false;
docRef.Action.ErrorMessage = e.ToString();
}
}
// Die Funktion erstellt einen Exportordner und gibt seinen vollständigen Pfad zurück
privatestring createExportFolder(string definitionName )
{
string docFolder, folderName;
// Hauptordner
string exportFolder = "d:\\DotNetExport";
if( !Directory.Exists(exportFolder) )
{
Directory.CreateDirectory(exportFolder);
}
// der Ordner der spezifizierten Dokumentdefinition
docFolder = exportFolder + "\\" + definitionName;
if( !Directory.Exists(docFolder) )
{
Directory.CreateDirectory( docFolder );
}
// Ordner für das exportierte Dokument
int i = 1;
folderName = docFolder + "\\" + i;
while( Directory.Exists(folderName) )
{
i++;
folderName = docFolder + "\\" + i;
}
Directory.CreateDirectory(folderName);
return folderName;
}
// Bildexportfunktion
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++;
}
}
// Informationen über das Dokument exportieren
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();
}
// Auflistung von Feldern exportieren
private void exportFields( IExportFields fields, StreamWriter sw, string indent )
{
foreach( IExportField curField in fields )
{
exportField( curField, sw, indent );
}
}
// Überprüft, ob der Wert des Felds Null ist
// Wenn der Feldwert ungültig ist, dann kann jeder Zugriffsversuch (auch
// die Überprüfung auf NULL) eine Ausnahme auslösen
privatebool IsNullFieldValue( IExportField field )
{
try
{
return ( field.Value == null );
}
catch( Exception e )
{
returntrue;
}
}
// Angegebenes Feld exportieren
private void exportField( IExportField field, StreamWriter sw, string indent )
{
// Angegebenes Feld exportieren
sw.Write( indent + field.Name );
// Feldwert, sofern verfügbar, speichern
if( IsNullFieldValue( field ) )
{
sw.WriteLine();
}
else
{
sw.WriteLine( " " + field.Text );
}
if( field.Children != null )
{
// untergeordnete Felder exportieren
exportFields( field.Children, sw, indent + " " );
}
else if( field.Items != null )
{
// Feldinstanzen exportieren
exportFields( field.Items, sw, indent + " " );
}
}
}
}
Export handler
Dieser Beispielcode zeigt eine einfache Exportsteuerung, die Informationen über die exportierten Dokumente und Exportergebnisse in Textdateien speichert. In diesem Beispiel werden zwei Textdateien verwendet: Eine Datei enthält die Liste der erfolgreich exportierten Dokumente und die andere die Liste der Dokumente, bei denen während des Exports Fehler aufgetreten sind.
[VBScript]
dim curDoc
dim fso, fileErrorName, txtErrorFile, fileSucceedName, txtSucceedFile
set fso = CreateObject("Scripting.FileSystemObject")
' Datei mit der Liste fehlgeschlagener Dokumente erstellen
fileErrorName = "d:\ExportResults\ErrorsDocuments.txt"
set txtErrorFile = fso.CreateTextFile( fileErrorName, true )
' Datei mit der Liste erfolgreich exportierter Dokumente erstellen
fileSucceedName = "d:\ExportResults\SucceedDocuments.txt"
set txtSucceedFile = fso.CreateTextFile( fileSucceedName, true )
dim i, exprortResult, docInfo
' Auflistung der exportierten Dokumente durchlaufen
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");
// Datei mit der Liste fehlgeschlagener Dokumente erstellen
var fileErrorName = "d:\\ExportResults\\ErrorsDocuments.txt";
var txtErrorFile = fso.CreateTextFile( fileErrorName, true );
// Datei mit der Liste erfolgreich exportierter Dokumente erstellen
var fileSucceedName = "d:\\ExportResults\\SucceedDocuments.txt"
var txtSucceedFile = fso.CreateTextFile( fileSucceedName, true );
var i
// Auflistung der exportierten Dokumente durchlaufen
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();
Zugriff auf Quelldateien gebräuchlicher Office-Formate
Dieses Beispielskript zeigt, wie Sie die Quelldateien beim Exportieren von Dokumenten speichern können. Die Quelldateien müssen in einem der unterstützten gebräuchlichen Office-Formate vorliegen und müssen eindeutige Namen haben, damit Namenskonflikte vermieden werden.
using System;
using System.IO;
using System.Collections.Generic;
// Blättern Sie durch die Seiten.
for( int i = 0; i<Document.Pages.Count; i++ ) {
IPage page = Document.Pages[i];
// Prüfen Sie, ob eine Quelldatei vorhanden ist.
if( page.SourceFileGUID == "" ) {
continue;
}
// Der ursprüngliche Name der Datei.
string sourceFileName = @"";
// Ursprünglichen Dateinamen angeben.
if( page.ImageSourceType == @"File" ) {
sourceFileName = Path.GetFileName( page.ImageSource );
} else if( page.ImageSourceType == @"Scanner" || page.ImageSourceType == @"Custom" ) {
sourceFileName = Path.GetFileName( page.ImageSourceFileSubPath );
}
// Entfernen der Dateierweiterung aus dem Dateinamen.
if( sourceFileName != @"" ) {
sourceFileName = Path.GetFileNameWithoutExtension( sourceFileName ) + @".";
}
// Eindeutiger Name der Quelldatei (ursprünglicher Name + guid).
string sourceFileUniqueName = sourceFileName + page.SourceFileGUID;
// Der Pfad zu dem Ordner, in dem die Quelldatei gespeichert werden muss.
string sourceFilePath = Document.Batch.Project.ExportRootPath + @"\" + sourceFileUniqueName;
// Die Datei darf nicht enthalten sein.
if( File.Exists( sourceFilePath ) ) {
continue;
}
// Speichern Sie die Datei.
Processing.ReportMessage( "Saving source file: " + sourceFileUniqueName );
page.SaveSourceFile( sourceFilePath );
}
12.04.2024 18:16:01