Feldwerte während des Exports abrufen
Feldwerte während des Exports abrufen
Dieser Beispielcode zeigt, wie Sie während des Exports den Wert eines Felds abrufen können. Sie können diesen Wert verwenden, um die Dateien zu benennen, in die Bilder oder Daten exportiert werden. Wenn ein solches Feld im Dokument nicht vorhanden ist, tritt ein Fehler auf.Die Struktur des zu exportierenden Dokuments:
Section 1
Field1
…
Group1
Field2
…
…
FieldN
Section 2
Field1
…
FieldK
[VBScript]
Dim field1Value, field2Value
' Ruft den Wert von Field1 in Section 1 ab
if Not IsNull( me.Field( "Section 1\Field1" ).Value ) then
field1Value = me.Field( "Section 1\Field1" ).Value
end if
' Ruft den Wert von Field2 in Group1 in Section 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 von Field1 in Section 1 ab, wenn der Abschnitt mehrere Instanzen hat
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 von Field1 in Section 1 ab
if( Field("Section 1\\Field1").Value != null ) {
var field1Value = Field("Section 1\\Field1").Value;
}
// Ruft den Wert von Field2 in Group1 in Section 1 ab
if( Field("Section 1\\Group1\\Field2").Value != null ) {
var field2Value = Field("Section 1\\Group1\\Field2").Value;
}
// Ruft den Wert von Field1 in Section 1 ab, wenn der Abschnitt mehrere Instanzen hat
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;
}
}
}
}
}
Export von Seitenbildern
Export von Seitenbildern
Der Code in diesem Beispiel zeigt, wie Bilder aller Dokumentseiten im gewünschten Dateiformat, Farbschema und mit der gewünschten Auflösung exportiert werden. Die Bilder werden seitenweise gespeichert, d. h. jede Seite in einer separaten Datei.Die Dateien in diesem Beispiel heißen „page1.tif“, „page2.tif“ usw. Bei Bedarf können Sie das Schema für die Dateibenennung ändern. Sie können Dateinamen beispielsweise 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 Namen und die Dateierweiterung abhängig 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 Namen und die Dateierweiterung abhängig vom ausgewählten Format fest
var fileName = fso.BuildPath( folderName, "page" + (i+1) + ".tif" );
Pages.Item(i).SaveAs( fileName, imageOptions );
}
Export einer Tabelle
Export einer Tabelle
Dieses Beispiel zeigt, wie eine Tabelle in eine TXT-Datei (*.txt) exportiert wird.
[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
Exportieren eines Dokuments mit beliebiger Verschachtelungstiefe
Dieses Beispiel zeigt, wie Felder eines Dokuments beliebiger Verschachtelungstiefe mithilfe benutzerdefinierter Funktionen aus dem globalen Export-Modul exportiert werden. Wenn Sie Dokumentfelder mit variabler Verschachtelungstiefe exportieren müssen, empfiehlt es sich, eine externe COM-Komponente zu verwenden (siehe nächstes Beispiel).
Kern-Export-Code
[VBScript]
Export.ExportDocument me, FCTools
[JScript]
Export.ExportDocument( this, FCTools );
Der Code der Funktionen des globalen Export-Moduls
[VBScript]
' Die Prozedur führt den Export durch: erstellt einen Exportordner und
' speichert darin Seitenbilddateien, die Textdatei mit den Dokumentfeldern
' sowie 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")
' Exportordner erstellen
folderName = CreateExportFolder(docObj.DefinitionName, fso)
if Err.Number <> 0 then
docObj.Action.Succeeded = false
docObj.Action.ErrorMessage = "Fehler beim Erstellen des Exportordners: " + 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 = "Fehler beim Exportieren von Bildern: " + Err.Description
Err.Clear
Exit Sub
End if
' Textdatei erstellen
fileName = fso.BuildPath(folderName, "doc.txt")
Set txtFile = fso.CreateTextFile(fileName, True)
' Dokumentinformationen 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 = "Fehler beim Exportieren der Daten: " + 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
' Exporteinstellungen festlegen
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
' Die Prozedur, die Informationen über das Dokument exportiert
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
' Die Prozedur, die Felder aus der fields-Sammlung exportiert
Sub ExportFields(ByRef fields, ByRef txtFile, ByVal indent)
Dim curField
For Each curField In fields
ExportField curField, txtFile, indent
Next
End Sub
' Prüft, ob der Wert der Felder null ist
' Wenn der Feldwert ungültig ist, kann jeder Versuch, auf dieses Feld zuzugreifen (auch
' um zu prüfen, ob es null ist), 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
' Feld-Exportprozedur
Sub ExportField(ByRef field, ByRef txtFile, ByVal indent)
' Feldnamen speichern
txtFile.Write (indent & field.Name)
' Feldwert speichern, wenn zugänglich
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 den vollständigen Pfad zu diesem Ordner 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 angegebenen Document Definition
docFolder = fso.BuildPath(exportFolder, definitionName)
If fso.FolderExists(docFolder) = False Then
fso.CreateFolder (docFolder)
End If
' der Ordner des exportierten Dokuments
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 Funktion führt den Export durch: erstellt einen Exportordner und
// speichert darin Seitenbilddateien, die Textdatei mit den Dokumentfeldern
// sowie Informationen über das Dokument
function ExportDocument(docObj, exportImageTools)
{
var folderName
var txtFile, fileName
var fso
fso = new ActiveXObject("Scripting.FileSystemObject");
// Exportordner erstellen
try {
folderName = CreateExportFolder(docObj.DefinitionName, fso);
} catch( e ) {
docObj.Action.Succeeded = false;
docObj.Action.ErrorMessage = "Fehler beim Erstellen des Exportordners: " + e.description;
return;n;
}
// Bilder exportieren
try {
ExportImages(docObj, exportImageTools, folderName, fso);
} catch( e ) {
docObj.Action.Succeeded = false;
docObj.Action.ErrorMessage = "Fehler beim Exportieren von Bildern: " + e.description;
return;
}
// Textdatei erstellen
fileName = fso.BuildPath(folderName, "doc.txt");
txtFile = fso.CreateTextFile(fileName, true);
// Exportiert Informationen über das Document
ExportDocInfo( docObj, txtFile );
// Felder exportieren
txtFile.WriteLine( "Fields:" );
try {
ExportFields( docObj.Children, txtFile, "" );
} catch( e ) { {
docObj.Action.Succeeded = false;
docObj.Action.ErrorMessage = "Fehler beim Exportieren der Daten: " + e.description;
txtFile.Close();
return;
}
txtFile.Close();
txtFile = 0;
fso = 0;
}
// Bildexportfunktion. Wenn beim Exportieren von Bildern ein Fehler auftritt,
// wird eine Fehlermeldung zurückgegeben; andernfalls wird ein leerer string zurückgegeben
function ExportImages( docObj, exportImageTools, exportFolder, fso )
{
// Exporteinstellungen festlegen
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 );
}
}
// Die Prozedur, die Informationen über das Document exportiert
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();
}
// Die Prozedur, die Felder aus der Felder-Sammlung exportiert
function ExportFields(fields, txtFile, indent)
{
var i
for( i = 0; i < fields.Count; i++ ) {
ExportField( fields.Item(i), txtFile, indent );
}
}
// Prüft, ob der Feldwert null ist
// Wenn der Feldwert ungültig ist, kann jeder Versuch, auf dieses Feld zuzugreifen (auch
// um zu prüfen, ob es null ist), eine Ausnahme auslösen
function IsNullFieldValue( field )
{
try {
return ( field.Value == null );
} catch( e ) {
return true;
}
}
// Feld-Exportprozedur
function ExportField(field, txtFile, indent)
{
// Dateinamen speichern
txtFile.Write(indent + field.Name);
// Feldwert speichern, wenn darauf zugegriffen werden kann
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 ) {
// Feld-Instanzen exportieren
ExportFields( field.Items, txtFile, indent + " " );
}
}
// Die Funktion erstellt einen Exportordner und gibt den vollständigen Pfad zu diesem Ordner zurück
function CreateExportFolder(definitionName, fso)
{
var docFolder, folderName
// Hauptordner
var exportFolder = "d:\\ScriptExport";
if( !fso.FolderExists(exportFolder) ) {
fso.CreateFolder (exportFolder);
} }
// der Ordner der angegebenen Document Definition
docFolder = fso.BuildPath(exportFolder, definitionName);
if( !fso.FolderExists(docFolder) ) {
fso.CreateFolder(docFolder);
}
// der Ordner des exportierten Dokuments
var i = 1;
folderName = fso.BuildPath(docFolder, i);
while( fso.FolderExists(folderName) ) {
i++;
folderName = fso.BuildPath(docFolder, i);
}
fso.CreateFolder(folderName);
return folderName;
}
Verwendung einer externen COM-Komponente
Verwendung 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
Nachfolgend ist der Code der Exporter-Klasse aus dem AutomationExport-Projekt aufgeführt, der in den oben genannten Skripten verwendet wird.OptionExplicit
Dim mFso AsNew Scripting.FileSystemObject
' Die Prozedur führt den Document-Export durch: erstellt einen Export-Ordner und
' speichert darin Seitenbilddateien, die Textdatei mit Dokumentfeldern,
' 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
' Exportordner wird erstellt
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)
' Textdatei wird erstellt
fileName = mFso.BuildPath(folderName, "doc.txt")
Set txtFile = mFso.CreateTextFile(fileName, True)
' Informationen zu Problemen beim Bildexport speichern
If imageExportResult <> "" Then
txtFile.WriteLine imageExportResult
errMessage = errMessage & imageExportResult
EndIf
' Informationen über das Document 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 beim Export Fehler auftreten, zurücksetzen
' Erfolgsflag für Export auf False setzen
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
' Image-Exportfunktion. Wenn beim Exportieren von Images ein Fehler auftritt,
' Es gibt eine Fehlermeldung zurück, andernfalls einen leeren string
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 = ""
' Exporteinstellungen angeben
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
Nächste Seite
ExitFunction
err_h:
exportImages = Err.Description
EndFunction
' Die Prozedur, die Informationen über das Document exportiert
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
' Die Prozedur, die Felder aus der fields-Sammlung exportiert
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
' Prüft, ob der Feldwert null ist
' Wenn der Wert ungültig ist, führt jeder Versuch, auf dieses Feld zuzugreifen (selbst
' um zu prüfen, ob es null ist) kann eine Ausnahme verursachen
Function IsNullFieldValue(ByRef field As Object) AsBoolean
OnErrorGoTo err_h
IsNullFieldValue = IsNull(field.Value)
ExitFunction
err_h:
IsNullFieldValue = True
EndFunction
' Feld-Exportfunktion
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 speichern, wenn zugänglich
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
' Feld-Instanzen 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 den vollständigen Pfad zu diesem Ordner 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 angegebenen Document Definition
docFolder = mFso.BuildPath(exportFolder, definitionName)
If mFso.FolderExists(docFolder) = FalseThen
mFso.CreateFolder (docFolder)
EndIf
' der Ordner des exportierten Dokuments
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
Verwendung einer externen Komponente in .NET( C# )
Gehen Sie folgendermaßen vor, um eine in .Net geschriebene externe Komponente zu verwenden:- Erstellen Sie ein Projekt des Typs ClassLibrary
- Fügen Sie dem Projekt die Datei ControllerInterop.dll als Verweis hinzu. ABBYY.FlexiCapture wird in der Liste Verweise angezeigt, und alle Schnittstellen der Skriptobjekte stehen im Projekt zur Verfügung.
- Definieren Sie das
disp-Interface und die Klasse, die dieses Interface implementiert, sowie die ProgId (dadurch wird es möglich, mit der .Net-Komponente genauso wie mit ActiveX aus dem Code des Skripts zu arbeiten). - Nach dem Erstellen des Projekts registrieren Sie die generierte Typbibliothek (dies kann automatisch erfolgen, wenn Sie die entsprechende Option in den Projekteigenschaften aktivieren).
- Rufen Sie im Export-Code die Methode der Komponente wie gewohnt auf:
[VBScript]
dim autoExport
set autoExport = CreateObject( "ExportLibrary1.Export" )
autoExport.ExportDocument me, FCTools
[JScript]
var autoExport = new ActiveXObject("ExportLibrary1.Export"); autoExport.ExportDocument( this, FCTools );
using System;
using System.Runtime.InteropServices;
using System.IO;
using ABBYY.FlexiCapture;
namespace ExportLibrary1
{
// Die Schnittstelle der Export-Komponente, auf die über das Skript zugegriffen werden kann
// Beim Erstellen einer neuen Komponente eine neue GUID generieren
[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 Funktionalität der Export-Komponente implementiert
// Beim Erstellen einer neuen Komponente eine neue GUID generieren
// und die ProgId festlegen
[Guid("3BA19BD7-C6DC-4f63-BC08-0D95254DADC3")]
[ClassInterface(ClassInterfaceType.None)]
[ProgId("ExportLibrary1.Export")]
[ComVisible(true)]
public class Export : _cExport
{
public Export()
{
}
// Die Funktion führt den Document-Export durch: erstellt einen Export-Ordner und
// speichert darin Seiten-Bilddateien,
// die Textdatei mit Dokumentfeldern und Informationen zum Dokument
public void ExportDocument( ref IExportDocument docRef, ref FCTools FCTools )
{
try
{
string exportFolder = createExportFolder( docRef.DefinitionName );
exportImages( docRef, FCTools, exportFolder );
// Textdatei erstellen
string fileName = exportFolder + "//" + "doc.txt";
StreamWriter sw = File.CreateText( fileName );
// Dokumentinformationen 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 den vollständigen Pfad zu diesem Ordner zurück
privatestring createExportFolder(string definitionName )
{
string docFolder, folderName;
// Hauptordner
string exportFolder = "d:\\DotNetExport";
if( !Directory.Exists(exportFolder) )
{
Directory.CreateDirectory(exportFolder);
}
// der Ordner der angegebenen Document Definition
docFolder = exportFolder + "\\" + definitionName;
if( !Directory.Exists(docFolder) )
{
Directory.CreateDirectory( docFolder );
}
// der Ordner des exportierten Dokuments
int i = 1;
folderName = docFolder + "\\" + i;
while( Directory.Exists(folderName) )
{
i++;
folderName = docFolder + "\\" + i;
}
Directory.CreateDirectory(folderName);
return folderName;
}
// Funktion zum Exportieren von Bildern
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++;
}
}
// Dokumentinformationen 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();
}
// Feld-Sammlung exportieren
private void exportFields( IExportFields fields, StreamWriter sw, string indent )
{
foreach( IExportField curField in fields )
{
exportField( curField, sw, indent );
}
}
// Prüft, ob der Feldwert null ist
// Wenn der Feldwert ungültig ist, kann jeder Zugriffsversuch auf dieses Feld (auch
// um zu prüfen, ob es null ist) eine Ausnahme auslösen
privatebool IsNullFieldValue( IExportField field )
{
try
{
return ( field.Value == null );
}
catch( Exception e )
{
returntrue;
}
}
// Das angegebene Feld exportieren
private void exportField( IExportField field, StreamWriter sw, string indent )
{
// Feldnamen speichern
sw.Write( indent + field.Name );
// Feldwert speichern, wenn zugänglich
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 )
{
// Feld-Instanzen exportieren
exportFields( field.Items, sw, indent + " " );
}
}
}
}
Export-Handler
Export-Handler
Dieser Beispielcode zeigt einen einfachen Export-Handler, der Informationen zu exportierten Dokumenten und Exportergebnissen in Textdateien speichert. In diesem Beispiel werden zwei Textdateien verwendet: eine mit einer Liste der erfolgreich exportierten Dokumente und eine mit einer Liste der Dokumente, bei deren Export Fehler aufgetreten sind.
[VBScript]
dim curDoc
dim fso, fileErrorName, txtErrorFile, fileSucceedName, txtSucceedFile
set fso = CreateObject("Scripting.FileSystemObject")
' Erstellen der Datei mit fehlgeschlagenen Dokumenten
fileErrorName = "d:\ExportResults\ErrorsDocuments.txt"
set txtErrorFile = fso.CreateTextFile( fileErrorName, true )
' Erstellen der Datei mit erfolgreich exportierten Dokumenten
fileSucceedName = "d:\ExportResults\SucceedDocuments.txt"
set txtSucceedFile = fso.CreateTextFile( fileSucceedName, true )
dim i, exprortResult, docInfo
' Durchlaufen der Sammlung exportierter Dokumente
for i = 0 Tome.Count - 1
set exportResult = me.Item(i)
docInfo = "DocumentId:" & exportResult.Document.Id
if exportResult.Succeeded then
docInfo = docInfo & " - Erfolgreich exportiert."
txtSucceedFile.WriteLine docInfo
else
docInfo = docInfo & " - Exportfehler: " & exportResult.ErrorMessage
txtErrorFile.WriteLine docInfo
endif
next
txtErrorFile.Close
txtSucceedFile.Close
[JScript]
var fso = new ActiveXObject("Scripting.FileSystemObject");
// Erstellen der Datei mit fehlgeschlagenen Dokumenten
var fileErrorName = "d:\\ExportResults\\ErrorsDocuments.txt";
var txtErrorFile = fso.CreateTextFile( fileErrorName, true );
// Erstellen der Datei mit erfolgreich exportierten Dokumenten
var fileSucceedName = "d:\\ExportResults\\SucceedDocuments.txt"
var txtSucceedFile = fso.CreateTextFile( fileSucceedName, true );
var i
// Durchlaufen der Sammlung exportierter Dokumente
for( i = 0; i < Documents.Count; i++ ) {
var curDoc = Documents.Item( i );
var docInfo = "DocumentId: " + curDoc.Id;
if( curDoc.Action.Succeeded ) {
docInfo = docInfo + ". Erfolgreich exportiert. Result:" + curDoc.Action.Result;
txtSucceedFile.WriteLine( docInfo );
} else {
docInfo = docInfo + ". Exportfehler: " + curDoc.Action.ErrorMessage + " Result:" + curDoc.Action.Result;
txtErrorFile.WriteLine( docInfo );
}
}
txtErrorFile.Close();
txtSucceedFile.Close();
Zugriff auf Quelldateien in gängigen Office-Formaten
Zugriff auf Quelldateien in gängigen Office-Formaten
Dieses Beispielskript zeigt, wie Sie die Quelldateien beim Exportieren von Dokumenten speichern können. Die Quelldateien müssen in einem der unterstützten gängigen Office-Formate vorliegen und eindeutige Namen erhalten, um Namenskonflikte zu vermeiden.
using System;
using System.IO;
using System.Collections.Generic;
// Die Seiten durchlaufen.
for( int i = 0; i<Document.Pages.Count; i++ ) {
IPage page = Document.Pages[i];
// Prüfen, ob eine Quelldatei vorhanden ist.
if( page.SourceFileGUID == "" ) {
continue;
}
// Der ursprüngliche Dateiname.
string sourceFileName = @"";
// Den ursprünglichen Dateinamen festlegen.
if( page.ImageSourceType == @"File" ) {
sourceFileName = Path.GetFileName( page.ImageSource );
} else if( page.ImageSourceType == @"Scanner" || page.ImageSourceType == @"Custom" ) {
sourceFileName = Path.GetFileName( page.ImageSourceFileSubPath );
}
// Die Dateierweiterung aus dem Dateinamen entfernen.
if( sourceFileName != @"" ) {
sourceFileName = Path.GetFileNameWithoutExtension( sourceFileName ) + @".";
}
// Eindeutiger Quelldateiname (ursprünglicher Name + GUID).
string sourceFileUniqueName = sourceFileName + page.SourceFileGUID;
// Der Pfad zu dem Ordner, in dem die Quelldatei gespeichert werden soll.
string sourceFilePath = Document.Batch.Project.ExportRootPath + @"\" + sourceFileUniqueName;
// Sicherstellen, dass die Datei noch nicht vorhanden ist.
if( File.Exists( sourceFilePath ) ) {
continue;
}
// Die Datei speichern.
Processing.ReportMessage( "Saving source file: " + sourceFileUniqueName );
page.SaveSourceFile( sourceFilePath );
}