Einführung in Conversion Agent

Einführung in Conversion Agent
Der SAP-Conversion-Agent
von Itemfield
Erste Schritte mit
Conversion Agent
Version 4
Der SAP-Conversion-Agent
von Itemfield
Erste Schritte mit
Conversion Agent
Band 1: Einleitende Übungen
Version 4
Rechtlicher Hinweis
Erste Schritte mit Conversion Agent , Band 1: Einleitende Übungen
Copyright © 2005-2006 Itemfield Inc. Alle Rechte vorbehalten.
Itemfield hat möglicherweise Patente, angemeldete Patente, Marken, Urheberrechte oder sonstige
Rechte an geistigem Eigentum inne, die Inhalte dieses Dokumentes abdecken. Sofern nichts anderes
ausdrücklich in einem schriftlichen Lizenzvertrag mit Itemfield vereinbart wurde, erhalten Sie durch
die Bereitstellung dieses Dokumentes keinerlei Anspruch auf diese Patente, Marken, Urheberrechte
oder auf sonstiges geistiges Eigentum.
Die in diesem Dokument enthaltenen Informationen können jederzeit ohne vorherige Ankündigung
geändert werden. Der Anwender trägt die Verantwortung für die Einhaltung aller anwendbaren
Urheberrechte. Ohne ausdrückliche schriftliche Genehmigung durch Itemfield Inc. darf kein Teil dieses
Dokumentes in irgendeiner Form oder auf irgendeine elektronische oder mechanische Weise zu
irgendeinem Zweck vervielfältigt oder weitergegeben werden.
SAP AG
http://www.sap.com
Angaben zur Veröffentlichung:
Version: 4
Date: September 2006
Erste Schritte mit Conversion Agent, Band 1
Inhalt
Inhalt Band 1
1. Einführung in Conversion Agent.....................................................1
Einführung in XML ................................................................................................................................. 1
Wie der Conversion Agent funktioniert.................................................................................................. 3
Conversion Agent Studio................................................................................................................. 3
Conversion Agent Engine................................................................................................................ 3
Conversion Agent in Integrationsanwendungen einsetzen ................................................................... 4
HL7-Integration................................................................................................................................ 4
PDF-Formulare verarbeiten............................................................................................................. 4
HTML-Seiten in XML umwandeln....................................................................................................5
Wie Sie mit diesem Buch arbeiten......................................................................................................... 5
Aufbau der einzelnen Kapitel .......................................................................................................... 5
Kurzreferenz für Conversion-Agent-Konzepte und -Funktionen ..................................................... 5
Weitere Conversion-Agent-Dokumentation........................................................................................... 8
2. Installation ........................................................................................9
Systemvoraussetzungen ....................................................................................................................... 9
Conversion Agent installieren................................................................................................................ 9
Ordner für Tutorials und Workspace ................................................................................................... 10
Übungen und Lösungen ................................................................................................................10
3. Grundlegende Parsing-Techniken ................................................12
Conversion Agent Studio öffnen.......................................................................................................... 12
Das Projekt Tutorial_1 importieren ...................................................................................................... 13
Ein kurzer Blick auf das Conversion Agent Studio-Fenster .................................................................15
Die Struktur eines Quelldokuments definieren ....................................................................................18
Fehler in der Parser-Konfiguration korrigieren .............................................................................. 25
Techniken zum Definieren von Ankern .........................................................................................26
Das Format Tabulatorbegrenzt .....................................................................................................26
Den Parser ausführen .........................................................................................................................27
Den Parser mit weiteren Quelldokumenten ausführen..................................................................28
Woran Sie denken sollten....................................................................................................................29
Was kommt als Nächstes? ..................................................................................................................30
i
Erste Schritte mit Conversion Agent, Band 1
Inhalt
4. Einen HL7-Parser definieren..........................................................31
Anforderungsanalyse...........................................................................................................................31
HL7-Hintergrund............................................................................................................................ 31
Eingabestruktur für HL7-Nachrichten............................................................................................ 32
XML-Ausgabestruktur....................................................................................................................32
Ein Projekt erstellen.............................................................................................................................33
XSD-Schemas im Conversion Agent verwenden.......................................................................... 36
Die Anker definieren............................................................................................................................ 37
Das IntelliScript bearbeiten..................................................................................................................41
Den Parser testen................................................................................................................................ 41
Woran Sie denken sollten....................................................................................................................45
Index Band 1 .......................................................................................46
ii
Erste Schritte mit Conversion Agent, Band 1
1
1. Einführung in Conversion Agent
Einführung in Conversion Agent
SAP Conversion Agent ist ein Datenumwandlungssystem. Mit dem Conversion
Agent können Sie eine leistungsstarke Schnittstelle zwischen beliebigen
Datenformaten und XML-basierten Systemen erstellen.
Um eine Conversion-Agent-Datenumwandlung zu konfigurieren, verwenden Sie
ein Verfahren, das man Parsen gemäß Beispiel nennt. Bei diesem Verfahren zeigen
Sie Conversion Agent, wie Daten in XML konvertiert werden, indem Sie einfach
ein Beispiel in einer visuellen Editorumgebung markieren. Für die Konvertierung
brauchen Sie nichts zu programmieren. Sie können sogar eine komplizierte
Umwandlung in nur wenigen Stunden oder Tagen konfigurieren, und ersparen
sich wochen- oder monatelanges Programmieren.
Der Conversion Agent kann strukturierte, halbstrukturierte oder unstrukturierte
Daten verarbeiten. Sie können den Conversion Agent so konfigurieren, dass er
Text, binäre Daten, Nachrichten-Formate, HTML-Seiten, PDF-Dokumente,
Textverarbeitungsdateien und jedes beliebige andere Format verarbeiten kann.
Der Conversion Agent kann die Daten parsen und in jedes Standard- oder
benutzerdefinierte XML-Vokabular umwandeln. In der umgekehrten Richtung
kann der Conversion Agent XML-Daten serialisieren, indem er den Inhalt in andere
Formate umwandelt. Die Conversion-Agent-Komponenten, die diese
Umwandlungen durchführen, nennt man Parser bzw. Serializer. Eine weitere
Komponente, der Mapper, kombiniert diese beiden Funktionen und führt
Umwandlungen von XML nach XML durch.
Dieses Buch liefert Ihnen eine praktische Einführung in den Conversion Agent.
Während Sie es lesen, werden Sie mehrere Übungen durchführen, die Ihnen
zeigen, wie Sie den Conversion Agent verwenden, um Ihre eigenen
Datenumwandlungen zu konfigurieren und auszuführen.
Einführung in XML
XML (Extensible Markup Language) ist der De-Facto-Standard für den
plattformübergreifenden Informationsaustausch. Für Conversion-AgentAnwender, denen XML neu ist, bieten wir hier eine kurze Einführung. Wenn Sie
mit XML bereits vertraut sind, können Sie diesen Abschnitt überspringen.
Dies ist ein Beispiel für ein kleines XML-Dokument:
1
Erste Schritte mit Conversion Agent, Band 1
1. Einführung in Conversion Agent
<Company industry="metals">
<Name>Ore Refining Inc.</Name>
<WebSite>http://www.ore_refining.com</WebSite>
<Field>iron and steel</Field>
<Products>
<Product id="1">cast iron</Product>
<Product id="2">stainless steel</Product>
</Products>
</Company>
Dieses Beispiel nennt man ein wohlgeformtes XML-Dokument, weil es den
grundlegenden Regeln der XML-Syntax entspricht. Es weist eine Baumstruktur auf
und besteht aus Elementen. Das Top-Level-Element in diesem Beispiel ist Company,
und die eingebetteten Elemente sind Name, WebSite, Field, Products und Product.
Jedes Element beginnt und endet mit Tags, wie zum Beispiel <Company> und
</Company>. Die Elemente können auch Attribute aufweisen. industry ist
beispielsweise ein Attribut des Elements Company und id ist ein Attribut des
Elements Product.
Um die hierarchische Beziehung zwischen den Elementen zu veranschaulichen,
bezeichnen wir sie auch als Haupt- und Subelemente. Das Element Products ist
beispielsweise das Subelement von Company und das Hauptelement von Product.
Das individuelle System der Elemente und Attribute nennt man ein XMLVokabular. Dieses Vokabular kann für jede Anwendung individuell angepasst
werden. Für unser Beispiel haben wir ein Vokabular erstellt, das etwa für ein
Handelsadressbuch geeignet ist.
Das Vokabular kann in einer Syntax-Spezifikation, die man Schema nennt,
formuliert werden. Das Schema kann beispielsweise angeben, dass Company und
Name erforderliche Elemente sind, dass die anderen Elemente optional sind, und
dass der Wert des Attributs industry einer vordefinierten Liste angehören muss.
Wenn ein XML-Dokument einer rigorosen Schema-Definition entspricht, sagt man,
das Dokument ist gültig und außerdem wohlgeformt.
Um das XML-Dokument leichter lesbar zu machen, haben wir die Zeilen
eingerückt, um zu zeigen, wie die Elemente eingebettet sind. Die Einrückung und
die Leerräume sind keine wesentlichen Bestandteile der XML-Syntax. Wir hätten
genauso gut einen langen, fortlaufenden String wie den folgenden schreiben
können, der keine zusätzlichen Leerräume enthält:
<Company industry="metals"><Name>Ore Refining Inc.</Name><WebSite>
http://www.ore_refining.com</WebSite><Field>iron and steel</Field>
<Products><Product id="1">cast iron</Product><Product id="2">stainless
steel</Product></Products></Company>
Der fortlaufende String entspricht exakt der eingerückten Version. Genau
genommen, speichert ein Computer die XML-Daten in einem String wie diesem.
2
Erste Schritte mit Conversion Agent, Band 1
1. Einführung in Conversion Agent
XML wird üblicherweise in einem Buch oder auf einem Computerbildschirm in
der eingerückten Version dargestellt, weil diese viel leichter zu verstehen ist.
Weitere Informationen
Informationen über XML finden Sie in vielen Büchern, Artikeln oder auf
Webseiten. Ein ausgezeichnetes Tutorial finden Sie unter http://www.w3schools.com.
Abschriften des XML-Standards finden Sie unter http://www.w3.org.
Wie der Conversion Agent funktioniert
Das Conversion-Agent-System besteht aus zwei Hauptkomponenten:
Conversion Agent Studio
Die Entwicklungs- und Konfigurationsumgebung des Conversion Agent.
Conversion Agent Engine
Die Datenumwandlungs-Engine.
Conversion Agent Studio
Conversion Agent Studio ist eine visuelle Editorumgebung, in der Sie
Datenumwandlungen wie Parser, Serializer und Mapper entwickeln und
konfigurieren können.
Sie verwenden Conversion Agent Studio, um Conversion Agent zu beizubringen,
wie Daten eines bestimmten Typs verarbeitet werden sollen. Wenn Sie einen
Parser erstellen, können Sie durch Markieren und Anklicken die Datenfelder in
einem Beispiel-Quelldokument bestimmen und definieren, wie Conversion Agent die
Felder in XML umwandeln soll. Diesen Vorgang nennt man Parsen gemäß Beispiel.
Beachten Sie bitte, dass wir den Begriff Dokument (wie etwa in BeispielQuelldokument) im weitest möglichen Sinne verwenden. Ein Dokument kann Text
oder binäre Daten enthalten und von beliebiger Größe sein. Es kann an einem
beliebigen Ort gespeichert oder aufgerufen werden – in einer Datei, einem Buffer,
einem Stream, einer URL, einer Datenbank, einem Nachrichtensystem.
Conversion Agent Engine
Conversion Agent Engine ist eine leistungsstarke Datenumwandlungs-Engine. Sie
verfügt über keine Benutzerschnittstelle. Sie arbeitet ausschließlich im Hintergrund
und führt die Datenumwandlungen aus, die Sie vorher in Conversion Agent
Studio definiert haben.
Um eine Datenumwandlung vom Conversion Agent Studio in die Conversion
Agent Engine zu verschieben, müssen Sie die Umwandlung als einen ConversionAgent-Dienst verfügbar machen.
Eine Integrationsanwendung kann auf verschiedene Arten Anfragen an
Conversion Agent Engine übergeben, zum Beispiel, indem das Conversion Agent
3
Erste Schritte mit Conversion Agent, Band 1
1. Einführung in Conversion Agent
API aufgerufen wird oder durch eine Übertragung an eine CGI-Schnittstelle. Eine
Anfrage gibt die Daten an, die umgewandelt werden sollen und den ConversionAgent-Dienst, der die Umwandlung durchführt. Conversion Agent Engine führt
die Anfrage aus und gibt die Ausgabe an die aufrufende Anwendung zurück.
Conversion Agent in Integrationsanwendungen
einsetzen
Die folgenden Absätze zeigen ein paar typische Beispiele dafür, wie ConversionAgent-Datenumwandlungen in System-Integrationsanwendungen eingesetzt
werden.
Wenn Sie die Übungen in diesem Buch ausführen, gewinnen Sie an Erfahrung, wie
Conversion Agent für diese Arten von Datenumwandlungen eingesetzt wird. Im
Kapitel Einen HL7-Parser definieren wird beispielsweise erläutert, wie Sie
Conversion Agent einsetzen, um HL7-Meldungen zu parsen. In den Kapiteln
Positionsparsen eines PDF-Dokuments und Word- und HTML-Dokumente parsen
werden Parser beschrieben, die verschiedene Arten von unstrukturierten
Dokumenten verarbeiten.
HL7-Integration
HL7 ist ein Nachrichtenstandard, der im Gesundheitswesen verwendet wird.
HL7-Meldungen haben eine flexible Struktur, die optionale und wiederholt
auftretende Datenfelder unterstützt. Diese Felder werden durch eine Hierarchie
von Delimitern voneinander getrennt.
In einer typischen Anwendung verwendet eine große Gesundheitsorganisation
Conversion Agent, um die Nachrichten, die zu und von ihren HL7-basierten
Informationssystemen übertragen werden, umzuwandeln. Conversion Agent ist so
konfiguriert, dass alle Arten von HL7-Nachrichten verarbeitet werden.
PDF-Formulare verarbeiten
Das Adobe Acrobat (PDF) Dateiformat ist zum Standard für den Austausch
formatierter Dokumente geworden. Mit Hilfe dieses Formats können vollständig
formatierte Dokumente – einschließlich ihres ursprünglichen Layouts, der
Schriftarten, Grafiken usw. – auf einer Vielzahl unterstützter Plattformen angezeigt
werden. Bei Informationsverarbeitungsanwendungen ist das PDF-Format jedoch
weit weniger nützlich als bei visuellen Anwendungen. Der Grund dafür ist, dass
Anwendungen nicht auf die unstrukturierten, binären PDF-Dateien zugreifen und
sie analysieren können.
Der Conversion Agent löst dieses Problem, indem er die Umwandlung von PDFDokumenten in XML-Dateien ermöglicht. Der Conversion Agent kann
beispielsweise Rechnungen, die Lieferanten im PDF-Format schicken, in XML
umwandeln, um sie in einer Datenbank zu speichern.
4
Erste Schritte mit Conversion Agent, Band 1
1. Einführung in Conversion Agent
HTML-Seiten in XML umwandeln
Informationen in HTML-Dokumenten werden üblicherweise in unstrukturierter
und nicht standardisierter Form dargestellt. Zweck eines HTML-Dokuments ist die
visuelle Darstellung und nicht die Informationsverarbeitung.
Der Conversion Agent bietet viele Funktionen, um die Informationen in einem
HTML-Dokument anzusteuern, zu finden und zu speichern. Mit Hilfe des
Conversion Agent können Sie Informationen von HTML in strukturiertes XML
umwandeln, sodass Software-Anwendungen auf diese Informationen zugreifen
können. Händler, die Ihre Waren im Internet anbieten, können beispielsweise die
Informationen in XML umwandeln, sodass sie die Informationen mit einer
Verrechnungsstelle oder anderen Händlern teilen können.
Wie Sie mit diesem Buch arbeiten
Dieses Buch ist ein Tutorial für den Conversion Agent. Während des Lesens
werden Sie mehrere Übungen durchführen, anhand derer Sie lernen, wie Sie den
Conversion Agent für Datenumwandlungen in der Praxis anwenden.
Nachdem Sie die Übungen durchgeführt haben, sind Sie mit den ConversionAgent-Abläufen vertraut und können den Conversion Agent für Ihre eigenen
Datenumwandlungen einsetzen.
Aufbau der einzelnen Kapitel
In den meisten Kapiteln dieses Buches finden Sie Übungen, durch die Sie lernen,
wie Sie Datenumwandlungen erstellen, die Parser, Serializer oder Mapper
verwenden. Wir empfehlen, dass alle Anwender die ersten zwei Übungen
ausführen—Grundlegende Parsing-Techniken und Einen HL7-Parser definieren. Sie
können dann die weiteren Übungen der Reihe nach ausführen oder Sie können die
Kapitel überfliegen und sich nur mit jenen näher befassen, die Sie brauchen.
Im letzten Kapitel, Conversion Agent Engine ausführen, wird erläutert, wie Sie eine
Datenumwandlung als einen Conversion-Agent-Dienst verfügbar machen, und
was Sie machen müssen, damit Conversion Agent Engine den Dienst ausführt. In
diesem Kapitel erfahren Sie auch, wie Sie ein Conversion-Agent-Projekt vom
Entwicklungsstadium in das Produktionsstadium transferieren.
Kurzreferenz für Conversion-Agent-Konzepte und -Funktionen
In der folgenden Tabelle sind die Conversion-Agent-Konzepte und –Funktionen
zusammengefasst, die in jedem Kapitel vorgestellt und erklärt werden.
5
Erste Schritte mit Conversion Agent, Band 1
1. Einführung in Conversion Agent
Konzept
Spezielle Funktion oder
Komponente
Kapitel
Installation
Systemvoraussetzungen
2. Installation
Installationsvorgang
2. Installation
Registrierung
2. Installation
IntelliScript anzeigen
3. Grundlegende Parsing-Techniken
IntelliScript bearbeiten
4. Einen HL7-Parser definieren
Mehrere Skriptdateien
7. Einen Serializer definieren
Farbcodierung für Anker
3. Grundlegende Parsing-Techniken
Grundlegende und erweiterte
Eigenschaften
5. Positionsparsen eines PDF-Dokuments
Globale Komponenten
6. Word- und HTML-Dokumente parsen
Importieren
3. Grundlegende Parsing-Techniken
Erstellen
4. Einen HL7-Parser definieren
Mit mehreren Parsern oder
Serializern
7. Einen Serializer definieren
Projekteigenschaften
7. Einen Serializer definieren
Speicherort des Projektordners
bestimmen
7. Einen Serializer definieren
Beispiel-Quelldokumente
3. Grundlegende Parsing-Techniken
Erstellen
4. Einen HL7-Parser definieren
Ausführen
3. Grundlegende Parsing-Techniken
Ergebnisse anzeigen
3. Grundlegende Parsing-Techniken
Anhand der Beispielquelle
testen
4. Einen HL7-Parser definieren
Anhand zusätzlicher
Quelldokumente testen
3. Grundlegende Parsing-Techniken
Dokumentprozessoren
5. Positionsparsen eines PDF-Dokuments
Mit Conversion
Agent Studio
arbeiten
Projekte
Parser
6. Word- und HTML-Dokumente parsen
6. Word- und HTML-Dokumente parsen
Die einen zweiten Parser
aufrufen
7. Einen Serializer definieren
6
Erste Schritte mit Conversion Agent, Band 1
1. Einführung in Conversion Agent
Konzept
Spezielle Funktion oder
Komponente
Kapitel
Formate
Text
3. Grundlegende Parsing-Techniken
Tabulatorbegrenzt
3. Grundlegende Parsing-Techniken
HL7
4. Einen HL7-Parser definieren
Positional
5. Positionsparsen eines PDF-Dokuments
PDF
5. Positionsparsen eines PDF-Dokuments
Microsoft Word
6. Word- und HTML-Dokumente parsen
HTML
6. Word- und HTML-Dokumente parsen
Die ein XSD-Schema
verwenden
3. Grundlegende Parsing-Techniken
Die einem Projekt ein Schema
hinzufügen
4. Einen HL7-Parser definieren
Schemas erstellen und
bearbeiten
4. Einen HL7-Parser definieren
Die mehrere Schemas
verwenden
8. Einen Mapper definieren
Variablen
6. Word- und HTML-Dokumente parsen
Marker
3. Grundlegende Parsing-Techniken
Marker mit Zähler
6. Word- und HTML-Dokumente parsen
Content
3. Grundlegende Parsing-Techniken
Content mit positionalen
Abständen
5. Positionsparsen eines PDF-Dokuments
Content mit öffnenden und
schließenden Referenzpunkten
6. Word- und HTML-Dokumente parsen
EnclosedGroup
6. Word- und HTML-Dokumente parsen
RepeatingGroup
4. Einen HL7-Parser definieren
Suchbereich
5. Positionsparsen eines PDF-Dokuments
Eingebettete
RepeatingGroup
5. Positionsparsen eines PDF-Dokuments
Zeilenumbrüche als
Referenzpunkte und
Trennzeichen
5. Positionsparsen eines PDF-Dokuments
Standardtransformer
6. Word- und HTML-Dokumente parsen
AddString
6. Word- und HTML-Dokumente parsen
Replace
6. Word- und HTML-Dokumente parsen
Datenbehälter
Anker
Transformer
7
Erste Schritte mit Conversion Agent, Band 1
1. Einführung in Conversion Agent
Konzept
Spezielle Funktion oder
Komponente
Kapitel
Aktionen
SetValue
5. Positionsparsen eines PDF-Dokuments
CalculateValue
5. Positionsparsen eines PDF-Dokuments
Map
8. Einen Mapper definieren
Erstellen
7. Einen Serializer definieren
ContentSerializer
7. Einen Serializer definieren
RepeatingGroupSerialize
r
7. Einen Serializer definieren
EmbeddedSerializer
7. Einen Serializer definieren
Die einen zweiten Serializer
aufrufen
7. Einen Serializer definieren
Mapper und
Mappinganker
Erstellen
8. Einen Mapper definieren
RepeatingGroupMapping
8. Einen Mapper definieren
Testen
Farbcodierung verwenden
4. Einen HL7-Parser definieren
Ereignisse anzeigen
3. Grundlegende Parsing-Techniken
Ereignisse interpretieren
4. Einen HL7-Parser definieren
Techniken zum Testen und
Debuggen
4. Einen HL7-Parser definieren
Auszuführenden Parser oder
Serializer auswählen
7. Einen Serializer definieren
Bereitstellen eines ConversionAgent-Dienstes
9. Conversion Agent Engine ausführen
API
9. Conversion Agent Engine ausführen
Serializer und
Serialisierungsanker
In Conversion
Agent Engine
ausführen
Weitere Conversion-Agent-Dokumentation
Die komplette Conversion-Agent-Dokumentation steht im Online-Hilfeformat zur
Verfügung. Sie können die vollständige Hilfe über den Ordner SAP Conversion
Agent im Startmenü oder über das Hilfemenü in Conversion-Agent Studio
aufrufen.
8
Erste Schritte mit Conversion Agent, Band 1
2
2. Installation
Installation
Bevor Sie mit diesem Buch fortfahren, sollten Sie die Conversion-Agent-Software
installieren (falls Sie das nicht schon getan haben).
Weitere Informationen über die Systemvoraussetzungen, die Installation und die
Registrierung finden Sie im Conversion Agent Administratorhandbuch. In den
folgenden Absätzen erhalten Sie kurze Anweisungen, damit Sie gleich beginnen
können.
Systemvoraussetzungen
Um die Übungen in diesem Buch ausführen zu können, sollten Sie den Conversion
Agent auf einem Computer installieren, der die folgenden minimalen
Voraussetzungen erfüllt:

Microsoft Windows 2000, XP Professional oder 2003 Server.

Microsoft Internet Explorer, Version 6.0 oder höher

Microsoft NET Framework, Version 1,1 oder höher

Mindestens 128 MB RAM
Conversion Agent installieren
Um den Conversion Agent zu installieren, klicken Sie die Setup-Datei doppelt an
und befolgen dann die Anweisungen auf dem Bildschirm. Achten Sie darauf,
mindestens folgende Komponenten zu installieren:
Engine
Die Conversion Agent Engine-Komponente, die für alle Übungen in diesem
Buch benötigt wird.
Entwicklungsumgebung Eclipse
Die Conversion Agent Studio für Eclipse Entwicklungs- und
Konfigurationsumgebung, die für alle Übungen in diesem Buch benötigt wird.
Dokumentprozessoren
Optionale Komponenten, die für die Tutorials in Kapitel 5 und 6 benötigt
werden.
9
Erste Schritte mit Conversion Agent, Band 1
2. Installation
Standard-Installationsordner
Standardmäßig wird Conversion Agent in folgendem Ordner installiert:
c:\Programme\SAP\ConversionAgent
Das Setup-Programm fordert Sie auf, den Ordner zu wechseln, wenn Sie möchten.
Registrierung und Lizenzierung
Je nachdem, welche Version von Conversion Agent Sie verwenden, werden Sie
beim Setup eventuell aufgefordert, die Software zu registrieren und eine Lizenz zu
installieren. Folgen Sie den Anweisungen auf dem Bildschirm, um die
Registrierung durchzuführen. Ausführliche Informationen dazu finden Sie in im
Conversion Agent Administratorhandbuch.
Ordner für Tutorials und Workspace
Für die Übungen in diesem Buch benötigen Sie die Tutorial-Dateien, die sich im
Ordner tutorials Ihres Conversion Agent Programmordners befinden.
Standardmäßig ist der Speicherort:
c:\Programme\SAP\ConversionAgent\tutorials
Beim Ausführen der Übungen werden Sie einen Teil des Inhalts dieses Ordners in
den Conversion Agent Studio Workspace-Ordner importieren oder kopieren. Der
Standardspeicherort für Workspace ist:
Eigene Dateien\SAP\ConversionAgent\4.0\workspace
Sie sollten mit den Kopien im Ordner Workspace arbeiten. Wir empfehlen, die
Originaldateien im Ordner Tutorials nicht zu ändern, für den Fall, dass Sie sie
nochmals benötigen.
Übungen und Lösungen
Der Ordner tutorials enthält zwei Unterordner:
tutorials
Exercises
Solutions to Exercises
Der Ordner Exercises enthält die Dateien, die Sie für die Übungen brauchen. In
diesem ganzen Buch beziehen wir uns auf Dateien in diesem Ordner.
Beim Ausführen der Übungen werden Sie Conversion-Agent-Projekte mit Namen
wie Tutorial_1, Tutorial_2 usw. erstellen. Die Projekte werden in Ihrem
Conversion Agent Studio Workspace-Ordner gespeichet.
10
Erste Schritte mit Conversion Agent, Band 1
2. Installation
Der Ordner Solutions to Exercises enthält die von uns vorgeschlagenen
Lösungen für die Übungen. Die Lösungen sind Projekte mit Namen wie
TutorialSol_1 usw. Sie können die Projekte in Ihren Workspace importieren und
unsere Lösungen mit Ihren vergleichen. Beachten Sie, dass es in vielen Fällen mehr
als eine richtige Lösung gibt.
11
Erste Schritte mit Conversion Agent, Band 1
3
3. Grundlegende Parsing-Techniken
Grundlegende Parsing-Techniken
Damit Sie gleich damit beginnen können den Conversion Agent einzusetzen,
stellen wir Ihnen ein teilweise konfiguriertes Projekt zur Verfügung, das einen
einfachen Parser enthält. Das Projekt heißt Tutorial_1.
Sie arbeiten in Conversion Agent Studio und werden die Konfiguration bearbeiten
und fertig stellen. Dann verwenden Sie den Parser, um ein paar
Beispieltextdokumente in XML umzuwandeln.
Hauptzweck dieser Übung ist es:

Das Parsen gemäß Beispiel mit Conversion Agent zu demonstrieren

Zu lernen, wie man einen Parser definiert und einsetzt
Dabei werden Sie ein paar wichtige Conversion Agent Studio-Funktionen
einsetzen, wie etwa:

Ein Projekt importieren und öffnen

Ein XSD-Schema verwenden, das die Struktur des XML-Ausgabedokuments
definiert

Die Struktur des Quelldokuments mit Marker-Ankern und Content-Ankern
definieren

Einen Parser aufgrund eines Beispiel-Quelldokuments definieren

Den Parser verwenden, um mehrere Quelldokumente in XML umzuwandeln

Die Parsing-Ereignisse anzeigen
Conversion Agent Studio öffnen
Um Conversion Agent Studio für Eclipse zu öffnen, machen Sie Folgendes:
1.
Klicken Sie im Start-Menü auf Programme > SAP Conversion Agent >
Conversion Agent Studio für Eclipse.
2.
Zeigen Sie in Conversion Agent Studio die Perspektive Erstellen an. Die
Perspektive ist eine Gruppe von Fenstern, Menüs und Symbolleisten, mit
denen Sie Conversion-Agent-Projekte in Eclipse bearbeiten können.
Wählen Sie dafür den Menübefehl Fenster > Perspektive öffnen > Andere >
Conversion Agent Studio erstellen.
12
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
3.
Wahlweise können Sie den Befehl Fenster > Perspektive wiederherstellen
ausführen. Das ist eine gute Idee, wenn Sie vorher in Conversion Agent Studio
gearbeitet und die Fenster verschoben oder in der Größe verändert haben. Mit
diesem Befehl werden alle Fenster in ihrer Standardgröße und –Position
wiederhergestellt.
4.
Wahlweise können Sie den Befehl Hilfe > Willkommen ausführen und die
Conversion Agent Studio Willkommensseite auswählen. Diese Seite enthält
einleitende Anweisungen darüber, wie Sie Conversion Agent Studio
verwenden.
Die Willkommensseite schließen Sie, indem Sie das X auf der rechten Seite der
Registerkarte Editor anklicken.
Das Projekt Tutorial_1 importieren
Das teilweise konfigurierte Projekt wird mit der Conversion-Agent-Software
mitgeliefert, aber Sie können es in Conversion Agent Studio für Eclipse nicht direkt
öffnen. Sie müssen das Projekt vielmehr in den Eclipse Workspace importieren.
Gehen Sie dazu wie folgt vor:
1.
Wählen Sie im Menü den Befehl Datei > Importieren. An der
Eingabeaufforderung wählen Sie die Option, mit der Sie ein bestehendes
Conversion-Agent-Projekt in den Workspace importieren.
13
Erste Schritte mit Conversion Agent, Band 1
2.
3. Grundlegende Parsing-Techniken
Klicken Sie auf die Schaltfläche Weiter, und suchen Sie nach folgender Datei
(ersetzen Sie die Angaben mit Ihrem Pfad zum Conversion Agent
Installationsordner):
c:\Programme\SAP\ConversionAgent\tutorials\Exercises\
Tutorial_1\Tutorial_1.cmw
3.
Auf den verbleibenden Seiten des Import-Assistenten können Sie die
Standardeinstellungen übernehmen. Klicken Sie auf Fertigstellen, um den
Import abzuschließen.
Der importierte Tutorial_1-Ordner sollte sich im Eclipse Workspace-Ordner
befinden:
Eigene Dateien\SAP\ConversionAgent\4.0\workspace\Tutorial_1
4.
Im oberen rechten Bereich des Eclipse-Fensters zeigt der Conversion-AgentExplorer die Tutorial_1-Dateien an, die Sie importiert haben.
14
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
Die einzelnen Ordner und Dateien werden im Folgenden kurz beschrieben:
Examples
Dieser Ordner enthält ein Beispiel-Quelldokument, bei dem es sich um ein
Beispiel-Eingabedokument handelt, mit dem Sie den Parser konfigurieren.
Scripts
Eine TGP-Skriptdatei, in der die Parser-Konfiguration gespeichert wird.
XSD
Eine XSD-Schemadatei, die die XML-Struktur definiert, die der Parser
erstellt.
Results
Dieser Ordner ist vorübergehend leer. Wenn Sie den Parser konfigurieren
und ausführen, speichert der Conversion Agent seine Ausgabe in diesem
Ordner.
Beachten Sie bitte, dass es sich bei den meisten dieser Ordner um virtuelle
Ordner handelt. Sie werden dazu verwendet, die angezeigten Dateien zu
kategorisieren, aber sie bestehen nicht wirklich auf Ihrer Festplatte. Nur beim
Ordner Results handelt es sich um physisches Verzeichnis auf Ihrer
Festplatte, aber er ist noch nicht vorhanden, weil Sie noch keine Ausgabe
erzeugt haben.
Wenn Sie sich den Ordner Tutorial_1 im Windows Explorer ansehen, werden
Sie ein paar weitere Dateien entdecken, die im Conversion-Agent-Explorer
nicht angezeigt werden, wie zum Beispiel:
Tutorial_1.cmw
Das ist die Hauptprojektdatei, die die Konfigurationseigenschaften für das
Projekt enthält .
.project
Das ist eine Datei, die von der Eclipse-Entwicklungsumgebung erzeugt
wird. Es handelt sich dabei nicht um eine Conversion-Agent-Datei, aber Sie
benötigen Sie, um das Conversion-Agent-Projekt in Eclipse zu öffnen.
Ein kurzer Blick auf das Conversion Agent StudioFenster
In Conversion Agent Studio werden mehrere Fenster angezeigt. Es gibt dabei zwei
Arten von Fenstern, Ansichten und Editoren. Eine Ansicht dient dazu, Daten zu
einem Projekt anzuzeigen oder bestimmte Operationen auszuführen. In einem
Editor können Sie die Konfiguration eines Projekts frei bearbeiten.
In den folgenden Absätzen werden die einzelnen Ansichten und Editoren
beschrieben, wobei wir links oben beginnen und gegen den Uhrzeigersinn
vorgehen.
15
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
Oben links
Conversion-Agent-Explorer-Ansicht
Zeigt die Projekte und Dateien im Conversion Agent Studio-Workspace an.
Durch einen Rechtsklick oder Doppelklick in dieser Ansicht können Sie einem
Projekt bestehende Dateien hinzufügen, neue Dateien anlegen oder Dateien
zum Bearbeiten öffnen.
Unten links
In der unteren linken Ecke des Conversion-Agent-Fensters werden zwei gestapelte
Ansichten angezeigt. Sie können zwischen den Ansichten wechseln, indem Sie auf
die jeweilige Registerkarte klicken.
Komponentenansicht
Zeigt die Hauptkomponenten an, die in einem Projekt definiert sind, wie zum
Beispiel Parser, Serializer, Mapper, Transformer und Variablen. Durch einen
Rechtsklick oder einen Doppelklick können Sie eine Komponente zum
Bearbeiten öffnen.
Ansicht IntelliScript-Assistent
Mit Hilfe dieser Ansicht können Sie bestimmte Komponenten in der
IntelliScript-Konfiguration einer Datenumwandlung konfigurieren. Eine
nähere Erläuterung dazu finden Sie in der Beschreibung des IntelliScriptEditors weiter unten.
Unten rechts
Unten rechts werden mehrere Ansichten angezeigt, die Sie auswählen, indem Sie
die entsprechende Registerkarte anklicken.
Aufgabenansicht
Zeigt Syntaxfehler in einer Datenumwandlung oder in einem Schema an. Sie
können diese Ansicht auch dafür verwenden, Aufgaben aufzuzeichnen, die
Sie ausführen müssen (eine Aufgabenliste).
16
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
Hilfeansicht
Zeigt einen Hilfetext an, während Sie in einem IntelliScript-Editor. Wenn Sie
im Editor ein Element markieren, erfolgt in der Hilfeansicht automatisch ein
Bildlauf zum entsprechenden Thema.
Hinweis: Sie können die Conversion-Agent-Hilfe auch über das Hilfe-Menü in
Conversion Agent Studio oder über den Ordner SAP Conversion Agent im
Start-Menü aufrufen. Damit können Sie, im Gegensatz zur Anzeige eines
einzelnen Themas in der Hilfeansicht, die gesamte Conversion-AgentDokumentation einsehen.
Ereignisansicht
Zeigt Ereignisse an, die auftreten, während Sie eine Datenumwandlung
ausführen. Die Ereignisse dienen dazu, zu bestätigen, dass eine Umwandlung
korrekt abläuft oder um Probleme zu diagnostizieren.
Ansicht Binärquelle
Zeigt den Binärcode des Beispiel-Quelldokuments an. Das ist nützlich, wenn
Sie eine binäre Eingabe parsen oder wenn Sonderzeichen, wie
Zeilenumbrüche und Tabulatoren, angezeigt werden sollen.
Schema-Ansicht
Zeigt die mit einem Projekt verbundenen XSD-Schemata an. Die Schemas
definieren die XML-Strukturen, die eine Datenumwandlung verarbeiten kann.
Speicheransicht
Zeigt die Conversion-Agent-Dienste an, die für die Ausführung in Conversion
Agent Engine verfügbar gemacht werden.
Oben rechts
Oben rechts zeigt Conversion Agent Studio Editor-Fenster an. Sie können mehrere
Editoren öffnen, und dann zwischen ihnen wechseln, indem Sie die jeweilige
Registerkarte anklicken.
IntelliScript-Editor
Wird verwendet, um eine Datenumwandlung zu konfigurieren. Hier werden
Sie überwiegend arbeiten, wenn Sie die Übungen in diesem Buch ausführen.
Der linke Bereich des IntelliScript-Editors ist der IntelliScript-Bereich. Hier
definieren Sie eine Datenumwandlung. Der IntelliScript-Bereich weist eine
Baumstruktur auf, die die Reihenfolge der Conversion-Agent-Komponenten
definiert, die die Umwandlung durchführen.
Der rechte Bereich ist der Beispielbereich. Er zeigt das Beispiel-Quelldokument
eines Parsers an. In diesem Bereich können Sie einen Parser durch Markierenund-Anklicken konfigurieren.
17
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
Links IntelliScript-Bereich, rechts Beispielbereich
Die Struktur eines Quelldokuments definieren
Sie können jetzt damit beginnen, die Struktur des Quelldokuments zu definieren.
Die Methode, die Sie dafür verwenden, ist das Parsen gemäß Beispiel.
1.
Erweitern Sie im Conversion-Agent-Explorer die Dateien Tutorial_1 files
und klicken Sie die Datei Tutorial_11.tgp doppelt an. Die Datei wird in
einem IntelliScript-Editor geöffnet.
2.
Der IntelliScript-Editor zeigt eine Parser-Komponente namens MyFirstParser
an. Erweitern Sie den IntelliScript-Baum und überprüfen Sie die ParserEigenschaften. Sie enthalten die folgenden Werte, die wir für Sie konfiguriert
haben:
example_source
Das Beispiel-Quelldokument, das Sie verwenden, um den Parser zu
konfigurieren. Wir haben eine Datei namens File1.txt als Beispielquelle
gewählt. Die Datei ist im Projektordner gespeichert.
format
Wir haben für die Beispielquelle das Format TextFormat und TabDelimited
festgelegt. Das bedeutet, dass die Textfelder durch Tabulatoren von
einander getrennt sind.
3.
Die Beispielquelle, File1.txt, sollte im rechten Bereich des Editors angezeigt
werden. Wenn nicht, klicken Sie MyFirstParser im linken Bereich mit der
rechten Maustaste an, und wählen Sie die Option zum Öffnen der
Beispielquelle.
18
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
Hinweis: Sie können zwischen der Anzeige des linken und rechten Bereichs
umschalten. Öffnen Sie dazu das IntelliScript-Menü und wählen Sie
IntelliScript, Beispiel oder Beide. Es gibt auch Symbolleisten-Schaltflächen für
diese Optionen.
4.
Überprüfen Sie die Beispielquelle etwas näher. Sie enthält zwei Arten von
Informationen.
Die Einträge auf der linken Seite. zum Beispiel First Name:, Last Name: und
Id:, sind Marker-Anker, die den Speicherort der Datenfelder angeben. Die
Einträge auf der rechten Seite, zum Beispiel Ron, Lehrer und 547329876, sind
Content-Anker, also die Werte der Datenfelder. Die Marker- und ContentAnker sind durch Tabulatoren abgetrennt, die als Tabulator-Delimiter
bezeichnet werden.
"First Name:" ist ein Marker-Anker. "Ron" ist ein Content-Anker. Die Anker
sind durch Tabulator-Delimiter voneinander getrennt.
Um Ihnen die Arbeit zu erleichtern, haben wir den Parser bereits mit den
grundlegenden Eigenschaften, wie etwa dem Format TabDelimited
konfiguriert. Sie müssen die Konfiguration jetzt noch abschließen, indem Sie
die Anker definieren. Im Folgenden werden Sie den Parser so konfigurieren,
dass er nach jedem Marker-Anker sucht und die Daten aus dem danach
folgenden Content-Anker abruft. Der Parser fügt die Daten dann in die XMLStruktur ein.
Im Laufe dieses Buches lernen Sie noch viele andere Arten von Ankern und
Delimitern kennen. Anker sind jene Stellen, an denen sich der Parser in ein
Quelldokument einklinkt und eine Operation ausführt. Delimiter sind
Zeichen, die die einzelnen Anker voneinander trennen. Mit dem Conversion
Agent können Sie Anker und Delimiter auf viele verschiedene Arten
definieren.
5.
Jetzt können Sie mit dem Parsen gemäß Beispiel beginnen. Ziehen Sie im
Beispielbereich mit der Maus über den Text First Name:, den ersten MarkerAnker.
19
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
6.
Klicken Sie den gerade markierten Text mit der rechten Maustaste an und
wählen Sie Marker einfügen aus dem Popup-Menü.
7.
Im vorigen Arbeitsschritt haben Sie einen Marker-Anker in das IntelliScript
eingefügt. Sie werden jetzt aufgefordet, die erste Eigenschaft, die eine Eingabe
erfordert, nämlich search, anzugeben. Mit dieser Eigenschaft können Sie die
Art der Suche festlegen. Die Standardeinstellung ist TextSearch. Da dies die
gewünschte Einstellung ist, drücken Sie einfach Eingabe.
20
Erste Schritte mit Conversion Agent, Band 1
8.
3. Grundlegende Parsing-Techniken
Sie werden jetzt aufgefordert, die nächste Eigenschaft, die eine Eingabe
erfordert, nämlich den text des Ankers, nach dem der Parser sucht,
anzugeben. Standardmäßig ist das der Text, den Sie in der Beispielquelle
markiert haben. Drücken Sie also wieder Eingabe.
Hinweis: In den hier dargestellten Abbildungen ist die gewählte Eigenschaft
weiß, und der Hintergrund ist grau. Auf Ihrem Bildschirm kann es sein, dass
der Hintergrund weiß ist. Sie können diese Darstellung ändern, indem Sie den
Befehl Fenster > Einstellungen wählen. Auf der Conversion-Agent-Seite des
Einstellungsfensters aktivieren oder deaktivieren Sie die Option Fokussierte
Instanz hervorheben.
9.
Im IntelliScript zeigt Conversion Agent Studio den neuen Marker-Anker als
Teil der Definition von MyFirstParser an. In der Beispielquelle hebt
Conversion Agent Studio den Marker gelb hervor.
Hinweis: Falls die Farbcodierung nicht sofort angezeigt wird, rufen Sie das
IntelliScript-Menü auf und prüfen Sie, ob die Option Beispiel automatisch
lernen markiert ist.
21
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
10. Jetzt können Sie den ersten Content-Anker erstellen. Markieren Sie in der
Beispielquelle das Wort Ron. Klicken Sie den markierten Text mit der rechten
Maustaste an, und wählen Sie Content einfügen aus dem Popup-Menü.
11. Damit fügen Sie einen Content-Anker in das IntelliScript ein und Sie werden
aufgefordert, die erste Eigenschaft, die eine Eingabe erfordert, nämlich value,
anzugeben. Mit Hilfe dieser Eigenschaft können Sie festlegen, wie das Parsing
durchgeführt wird.
Die Standardeinstellung ist LearnByExample, die bewirkt, dass der Parser den
Anker aufgrund der Delimiter findet, die ihn in der Beispielquelle umgeben.
Da dies die gewünschte Einstellung ist, drücken Sie die Eingabetaste.
12. Sie können die Standardwerte der nächsten Eigenschaften (example,
opening_marker und closing-marker) annehmen oder sie überspringen, indem
Sie mit der Maus an eine anderen Stelle klicken.
13. Ihre nächste Aufgabe ist es, anzugeben, wo der Content-Anker die Daten, die
er aus dem Quelldokument extrahiert, speichern soll.
Der Ausgabe-Speicherort wird Datenbehälter genannt. Das ist ein allgemeiner
Begriff, der "ein XML-Element, ein XML-Attribut oder eine Variable" bedeutet.
In dieser Übung verwenden Sie Datenbehälter, bei denen es sich um Elemente
oder Attribute handelt. In einer späteren Übung werden Sie Variablen
verwenden.
Um den Datenbehälter zu definieren, markieren Sie die Eigenschaft
data_holder und klicken sie doppelt an oder drücken Eingabe. Daraufhin
wird eine Schema-Ansicht geöffnet, die die XML-Elemente und –Attribute
anzeigt, die im XSD-Schema des Projekts definiert sind (Person.xsd).
Erweitern Sie den no target namespace-Knoten, und markieren Sie das
Element First. Das bedeutet, dass der Content -Anker seine Ausgabe in einem
XML-Element namens First, wie im Folgenden dargestellt, speichern soll:
<First>Ron</First>
22
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
Genauer gesagt, ist das Element First innerhalb von Name eingebettet, das
wiederum innerhalb von Person eingebettet ist. Die vom Parser erzeugte
Ausgabe-Struktur sieht wie folgt aus:
<Person>
<Name>
<First>Ron</First>
</Name>
</Person>
Einen Datenbehälter wählen
14. Wenn Sie die Schaltfläche OK anklicken, wird der Eigenschaft data_holder
der Wert /Person/*s/Name/*s/First zugewiesen. In der XML-Terminologie
nennt man das XPath-Ausdruck. Es handelt sich dabei um eine Darstellung der
XML-Struktur, die wir oben beschrieben haben.
(Eigentlich lautet der standardmäßige XPath-Ausdruck /Person/Name/First.
Die *s-Symbole sind Conversion-Agent-Erweiterungen der XPath-Syntax, die
Sie ignorieren können.)
Conversion Agent Studio hebt die Content-Anker in der Beispielquelle hervor.
Marker- und Content-Anker haben eine andere Farbe, damit Sie sie leichter
unterscheiden können.
23
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
15. Wählen Sie den Befehle Datei > Speichern oder klicken Sie auf die Schaltfläche
Speichern in der Symbolleiste. Damit wird Ihre Bearbeitung im Projektordner
gespeichert.
16. Bisher haben Sie den Parser angewiesen, den Anker First Name: zu suchen,
den danach folgenden Anker Ron abzurufen und den Inhalt im Element First
des XSD-Schemas zu speichern.
Sie sollten jetzt mit dem Quelldokument fortfahren und die anderen Markerund Content-Anker auf dieselbe Weise definieren. In der folgenden Tabelle
sind die Anker aufgelistet, die Sie definieren müssen.
Anker
Ankertyp
Last Name:
Marker
Lehrer
Content
Id:
Marker
547329876
Content
Age:
Marker
27
Content
Gender:
Marker
M
Content
Datenbehälter
/Person/*s/Name/*s/Last
/Person/*s/Id
/Person/*s/Age
/Person/@gender
Achten Sie darauf, die Anker in der oben angegebenen Reihenfolge zu
definieren, denn das ist die Reihenfolge im Quelldokument. Das ist wichtig,
weil Sie die richtige Beziehung zwischen jedem Marker und dem zugehörigen
Content herstellen müssen. Wenn Sie die Reihenfolge nicht einhalten, kann es
sein, dass der Conversion Agent den Text nicht findet.
24
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
Wenn Sie damit fertig sind, sollte das Conversion Agent Studio-Fenster wie in
der folgenden Abbildung aussehen. Es kann natürlich sein, dass Sie die
Baumstruktur erweitern oder reduzieren müssen, um die abgebildeten Zeilen
anzuzeigen.
17. Speichern Sie das Projekt wieder.
Fehler in der Parser-Konfiguration korrigieren
Beim Definieren der Anker kann es gelegentlich vorkommen, dass Sie einen Fehler
machen, wie etwa, dass Sie den falschen Text markieren oder einem Anker die
falschen Eigenschaftswerte zuweisen.
Wenn Sie einen Fehler machen, können Sie ihn auf mehrere Arten korrigieren:

Im Menü können Sie den Befehl Bearbeiten > Rückgängig aufrufen.

Im IntelliScript-Bereich können Sie einen Anker markieren (oder irgendeine
andere Komponente, die Sie in die Konfiguration eingefügt haben) und die
Taste Entf drücken.

Im IntelliScript-Bereich können Sie den Anker mit der rechten Maustaste
anklicken. Klicken Sie dann im Popup-Menü auf Löschen.
Sobald Sie mehr Erfahrung mit dem IntelliScript-Bereich haben, können Sie noch
folgende Techniken anwenden:

Wenn Sie einen Anker in der falschen Reihenfolge erstellt haben, können Sie
ihn im IntelliScript an die richtige Stelle ziehen.

Wenn Sie vergessen, einen Anker zu definieren, klicken Sie den Anker, vor
dem der ausgelassene Anker platziert werden soll, mit der rechten Maustaste
an und wählen Sie Einfügen.

Im IntelliScript können Sie Komponenten, wie zum Beispiel Anker, kopieren
und einfügen.
25
Erste Schritte mit Conversion Agent, Band 1

3. Grundlegende Parsing-Techniken
Sie können die Eigenschaftswerte im IntelliScript bearbeiten.
Techniken zum Definieren von Ankern
In den oben beschriebenen Schritten wurden Sie angewiesen, einen Anker zu
markieren, ihn mit der rechten Maustaste anzuklicken und den Befehl Marker
einfügen oder Content einfügen zu wählen. Damit fügen Sie einen Anker in das
IntelliScript ein, dem Sie dann Eigenschaften zuweisen.
Es gibt noch eine Reihe alternativer Methoden, um Anker zu definieren:

Sie können einen Content-Anker definieren, indem Sie Text aus der
Beispielquelle in einen Datenbehälter in der Schema-Ansicht ziehen. Damit
fügen Sie den Anker in das IntelliScript ein, in dem die Eigenschaft
data_holder bereits zugewiesen wurde.

Sie können Anker definieren, indem Sie die Angaben in den IntelliScriptBereich eintippen, ohne die Beispielquelle zu verwenden.

Sie können die Eigenschaften von Marker- und Content-Ankern in der Ansicht
IntelliScript-Assistent bearbeiten.
Wir möchten Sie dazu ermutigen, mit diesen Funktionen zu experimentieren.
Weitere Informationen finden Sie im Buch Conversion Agent Studio in Eclipse.
Das Format Tabulatorbegrenzt
Sie erinnern sich vielleicht, dass MyFirstParser mit dem Format TabDelimited
definiert wurde. Die Delimiter definieren, wie der Parser die Beispielquelle
interpretiert. In diesem Fall schließt der Parser daraus, dass die Marker- und
Content-Anker durch Tabulatoren voneinander getrennt sind.
In den Anweisungen empfehlen wir, dass Sie die Marker-Anker einschließlich des
Doppelpunkts markieren. Zum Beispiel:
First Name:
Weil das Format Tabulatorbegrenzt gewählt wurde, ist der Doppelpunkt in diesem
Parser eigentlich nicht von Bedeutung.Wenn Sie First Name (ohne den
Doppelpunkt) markieren, findet der Parser den Marker und den danach folgenden
Tabulator noch immer und liest den Content richtig. Andere Zeichen, wie den
Doppelpunkt, ignoriert er einfach.
Aufgrund des tabulatorbegrenzten Formats können Sie auch einen kurzen
Content-Anker wie etwa Ron wählen, ohne sich um die Feldgröße Gedanken
machen zu müssen. In einem anderen Quelldokument hat eine Person vielleicht
einen langen Vornamen, wie etwa Rumpelstiltskin. Standardmäßig liest ein
tabulatorbegrenzter Parser den gesamten String nach dem Tabulator bis zum
Zeilenumbruch (es sei denn, die Zeile enthält noch einen weiteren Anker oder
Tabulator).
26
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
Den Parser ausführen
Jetzt können Sie den Parser testen, den Sie konfiguriert haben.
1.
Im IntelliScript klicken Sie die Parser-Komponente namens MyFirstParser mit
der rechten Maustaste an. Wählen Sie die Option Als Startkomponente
festlegen.
Das bedeutet, dass Conversion Agent MyFirstParser aktiviert, wenn Sie das
Projekt ausführen.
2.
Im Menü wählen Sie Ausführen > MyFirstParser ausführen.
3.
Nach einigen Sekunden zeigt Conversion Agent Studio die Ereignisansicht an.
Die Ereignisse umfassen beispielsweise alle Marker- und Content-Anker, die
der Parser in der Beispielquelle gefunden hat.
Sie können die Ereignisansicht dazu verwenden, eventuelle Fehler, die
während der Ausführung aufgetreten sind, zu prüfen. Wenn Sie die
Anweisungen sorgfältig befolgt haben, sollte die Ausführung fehlerfrei
erfolgen.
4.
Jetzt können Sie die Ausgabe, die der Parser erzeugt hat, überprüfen.
Erweitern Sie im Conversion-Agent-Explorer den Tutorial_1 files/ResultsKnoten und klicken Sie die Datei output.xml doppelt an.
Conversion Agent Studio zeigt die XML-Datei in einem Internet ExplorerFenster an. Prüfen Sie die Ausgabe sorgfältig und bestätigen Sie, dass die
Ergebnisse richtig sind. Sind die Ergebnisse nicht richtig, überprüfen Sie die
von Ihnen erstellte Parser-Konfiguration, korrigieren Sie eventuelle Fehler und
versuchen Sie es erneut.
27
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
Wenn Sie Windows XP SP2 oder höher verwenden, zeigt der Internet Explorer
eventuell eine Warnung an, die auf aktive Inhalte in der XML-Ergebnisdatei
hinweist. Diese Meldung können Sie bedenkenlos ignorieren.
Machen Sie sich keine Gedanken, wenn die XML-Verarbeitungsanweisung
(<?xml version="1.0" ...?>) fehlt oder von der oben dargestellten abweicht.
Das ist die auf Einstellungen in den Projekteigenschaften zurückzuführen (der
Menübefehl Projekt > Eigenschaften). Sie können dieses Problem im
Augenblick ignorieren.
Den Parser mit weiteren Quelldokumenten ausführen
Um den Parser weiter zu testen, können Sie ihn, abgesehen von der Beispielquelle,
noch mit weiteren Quelldokumenten ausführen.
1.
Klicken Sie rechts von der Parser-Komponente auf das Symbol >>. Damit
werden die erweiterten Eigenschaften der Komponente angezeigt.
Das Symbol >> verändert sich in <<. Sie können die erweiterten Eigenschaften
schließen, indem Sie das Symbol << anklicken.
Die erweiterten Eigenschaften anzeigen
2.
Markieren Sie die Eigenschaft sources_to_extract und klicken Sie sie doppelt
an oder drücken Sie Eingabe. Wählen Sie aus der Dropdown-Liste LocalFile.
28
Erste Schritte mit Conversion Agent, Band 1
3.
3. Grundlegende Parsing-Techniken
Erweitern Sie den LocalFile-Knoten des IntelliScripts und weisen Sie die
Eigenschaft file_name zu. Conversion Agent Studio zeigt das Dialogfeld
Öffnen an, in dem Sie nach der Datei suchen können.
Sie können eine der Test-Dateien verwenden, die wir mitgeliefert haben. Sie
befinden sich im Ordner
tutorials\Exercises\Tutorial_1\Additional source files
Wählen Sei beispielsweise die Datei File2.txt mit folgendem Inhalt:
First Name:
Last Name:
Id:
Age:
Gender:
4.
Dan
Smith
45209875
13
M
Führen Sie den Parser erneut aus. Sie sollten dieselbe XML-Struktur erhalten
wie oben dargestellt, die die Daten enthält, die der Parser in der Testdatei
gefunden hat.
Woran Sie denken sollten
Ein Conversion-Agent-Projekt enthält die Parser-Konfiguration und das XSD-Schema.
Üblicherweise enthält es auch das Beispiel-Quelldokument, dem der Parser die
Dokumentstruktur entnimmt und andere Dateien, wie die Parsing-Ausgabe.
29
Erste Schritte mit Conversion Agent, Band 1
3. Grundlegende Parsing-Techniken
Der Conversion-Agent-Explorer zeigt die Projekte an, die in Ihrem Conversion Agent
Studio-Workspace vorhanden sind. Um ein bestehendes Projekt in den Workspace
zu kopieren, verwenden Sie den Befehl Datei > Importieren.
Um eine Datenumwandlung zur Bearbeitung im IntelliScript-Editor zu öffnen,
klicken Sie ihre TGP-Skriptdatei im Conversion-Agent-Explorer doppelt an. Im
IntelliScript können Sie Komponenten, wie zum Beispiel Anker, hinzufügen. Die
Anker definieren Positionen im Quelldokument, die der Parser sucht und
verarbeitet. Marker-Anker bezeichnen die Datenfelder und Content-Anker
extrahieren die Feldwerte.
Um einen Marker- oder Content-Anker zu definieren, markieren Sie den Quelltext,
klicken ihn mit der rechten Maustaste an und wählen den Ankertyp. Damit fügen
Sie den Anker in das IntelliScript ein, wo Sie seine Eigenschaften festlegen können.
Sie sollten beispielsweise den Datenbehälter festlegen – ein XML-Element oder
Attribut – in dem ein Content-Anker seine Ausgabe speichert.
Verwenden Sie die Farbcodierung, um die Ankerdefinitionen zu überprüfen.
Die Delimiter definieren die Beziehung zwischen den Ankern. Das Format
tabulatorbegrenzt bedeutet, dass die Anker durch Tabulatoren getrennt sind.
Um einen Parser zu testen, legen Sie ihn als Startkomponente fest. Verwenden Sie
dann den Befehl Ausführen im Conversion Agent Studio-Menü. Um die
Ergebnisdatei anzuzeigen, doppelklicken Sie im Conversion-Agent-Explorer auf den
Dateinamen.
Was kommt als Nächstes?
Glückwunsch! Sie haben Ihren ersten Conversion-Agent-Parser konfiguriert und
ausgeführt.
Die für das Parsen verwendeten Quelldokumente hatten natürlich eine sehr
einfache Struktur. Die Dokumente enthielten einige Marker-Anker, denen jeweils
ein Tabulator und Content folgten.
Darüber hinaus hatten alle Dokumente genau dieselben Marker-Anker in derselben
Reihenfolge. Das hat das Parsen sehr erleichtert, weil Sie die möglichen
Abweichungen innerhalb der Quelldokumente nicht berücksichtigen mussten.
Wenn Sie Parser in der Praxis einsetzen, gibt es nur wenige Quelldokumente mit
einer derart einfachen, starren Struktur. In den folgenden Kapiteln werden Sie
lernen, wie Sie komplexe und flexible Dokumentstrukturen mit Hilfe einer
Vielzahl von Parsing-Techniken parsen. Alle diese Techniken basieren jedoch auf
den einfachen Schritten, die Sie in diesem Kapitel gelernt haben.
30
Erste Schritte mit Conversion Agent, Band 1
4
4. Einen HL7-Parser definieren
Einen HL7-Parser definieren
In diesem Kapitel werden Sie eine HL7 -Nachricht parsen. HL7 ist ein
Standardnachrichtenformat, das für medizinische Informationssysteme verwendet
wird. Charakteristisch für seine Struktur ist eine Hierarchie von Delimitern und
sich wiederholenden Elementen. Wenn Sie einmal die Techniken gelernt haben,
mit denen man diese Funktionen verarbeitet, sind Sie imstande eine Vielzahl von
Dokumenten, wie sie in der Praxis verwendet werden, zu parsen.
Wie schon im vorhergehenden Kapitel, stellen wir Ihnen ein komplett
konfiguriertes XML-Schema zur Verfügung. Den Parser müssen Sie jedoch selbst
konfigurieren. Sie werden folgende Techniken lernen:

Ein Projekt erstellen

Einen Parser erstellen

Ein Dokument selektiv parsen, das heißt, ausgewählte Daten abrufen und den
Rest ignorieren

Eine sich wiederholende Gruppe definieren

Delimiter verwenden, um die Quelldokument-Struktur zu definieren

Einen Parser testen und debuggen
Anforderungsanalyse
Bevor Sie mit der Übung beginnen, wollen wir die Eingabe- und
Ausgabeanforderungen des Projekts analysieren. Beim Entwerfen des Parsers
verwenden Sie diese Informationen, die die Konfiguration bestimmen.
HL7-Hintergrund
HL7 ist ein Nachrichtenstandard- und Transaktionsprotokoll für das
Gesundheitswesen. Es wird weltweit in Krankenhäusern und medizinischen
Informationssystemen eingesetzt.
Genauere Informationen über HL7 finden Sie auf der Health Level 7 Webseite,
unter http://www.hl7.de.
31
Erste Schritte mit Conversion Agent, Band 1
4. Einen HL7-Parser definieren
Eingabestruktur für HL7-Nachrichten
Die folgenden Zeilen zeigen eine typische HL7-Nachricht, die Sie als
Quelldokument für das Parsen verwenden werden.
MSH|^~\&|LAB||CDB||||ORU^R01|K172|P
PID|||PATID1234^5^M11||Jones^William||19610613|M
OBR||||80004^Electrolytes
OBX|1|ST|84295^Na||150|mmol/l|136-148|Above high normal|||Final results
OBX|2|ST|84132^K+||4.5|mmol/l|3.5-5|Normal|||Final results
OBX|3|ST|82435^Cl||102|mmol/l|94-105|Normal|||Final results
OBX|4|ST|82374^CO2||27|mmol/l|24-31|Normal|||Final results
Die Meldung besteht aus Segmenten, die durch Zeilenschaltungen getrennt sind.
Jedes Segment hat eine Bezeichnung aus drei Buchstaben, wie zum Beispiel MSH
(Message Header) oder PID (Patientenidentifikation). Jedes Segment enthält eine
vordefinierte Hierarchie von Feldern und Subfeldern, die durch die Zeichen, die
dem MSH-Bezeichner unmittelbar folgen, begrenzt werden (|^~\&).
Der Patientenname (Jones^William) folgt beispielsweise der PID-Bezeichnung und
fünf Delimitern |. Nach- und Vorname (Jones und William) sind durch den
Delimiter ^ voneinander getrennt.
Dieser Nachrichtentyp wird durch in Feld im MSH-Segment festgelegt. Im oben
angegebenen Beispiel ist die Nachricht vom Typ ORU und Untertyp R01, das heißt,
es ist eine unangeforderte Übermittlung eines Befundes. Das OBR-Segment gibt die
Art der Untersuchung an und das OBX-Segment listet die Untersuchungsergebnisse
auf.
In diesem Kapitel werden Sie einen Parser konfigurieren, der ORU-Nachrichten, wie
das oben angeführte Beispiel, verarbeitet. Zu den Hauptpunkten bei der
Parserdefinition gehört, wie die Delimiter definiert und wie die sich
wiederholende OBX-Gruppe verarbeitet wird.
XML-Ausgabestruktur
Zweck dieser Übung ist es, einen Parser zu erstellen, der die obige HL7-Nachricht
in die folgende XML-Ausgabe umwandelt:
<Message type="..." id="...">
<Patient id="..." gender="...">
<f_name>...</f_name>
<l_name>...</l_name>
<birth_date>...</birth_date>
</Patient>
<Test_Type test_id="...">...</Test_Type>
<Result num="...">
<type>...</type>
32
Erste Schritte mit Conversion Agent, Band 1
4. Einen HL7-Parser definieren
<value>...</value>
<range>...</range>
<comment>...</comment>
<status>...</status>
</Result>
<Result num="...">
<type>...</type>
<value>...</value>
<range>...</range>
<comment>...</comment>
<status>...</status>
</Result>
<!-- Additional Result elements as needed -->
</Message>
Das XML hat Elemente, die viele – aber nicht alle – der Daten der HL7Beispielnachricht speichern können. Das ist akzeptabel. In dieser Übung werden
Sie einen Parser erstellen, der die Daten des Quelldokuments selektiv verarbeitet,
das heißt, er ruft die benötigten Informationen ab und ignoriert den Rest. Die
XML-Struktur enthält die Elemente, die für den Abruf benötigt werden.
Beachten Sie das sich wiederholende Element Result. Dieses Element speichert
Daten aus dem sich wiederholenden OBX-Segment der HL7-Nachricht.
Ein Projekt erstellen
Als Erstes wollen wir ein Projekt erstellen, in dem Conversion Agent Studio Ihre
Arbeit speichern kann.
1.
Klicken Sie im Conversion Agent Studio-Menü auf Datei > Neu > Projekt.
Daraufhin wird ein Assistent gestartet, in dem Sie den Projekttyp wählen
können.
2.
Wählen Sie im linken Bereich ein Conversion-Agent-Projekt. Im rechten
Bereich wählen Sie den Eintrag Parser-Projekt.
33
Erste Schritte mit Conversion Agent, Band 1
4. Einen HL7-Parser definieren
3.
Auf der nächsten Seite des Assistenten geben Sie einen Projektnamen, wie
etwa Tutorial_2 ein. Conversion Agent erstellt einen Ordner und eine *.cmw
Konfigurationsdatei mit diesem Namen.
4.
Auf der nächsten Seite des Assistenten tragen Sie einen Namen für die ParserKomponente ein. Da dieser Parser HL7-Nachrichten vom Typ ORU parsen soll,
wollen wir ihn HL7_ORU_Parser nennen.
5.
Geben Sie auf der nächsten Seite einen Namen für die TGP-Skriptdatei ein, die
der Assistent erstellt. Es bietet sich der Name Script_Tutorial_2 an.
6.
Auf der nächsten Seite wählen Sie ein XSD-Schema, das die XML-Struktur
definiert, in der der Parser seine Ausgabe speichert. Wir haben ein Schema für
Sie bereitgestellt. Der Speicherort im Conversion Agent Installationsordner
lautet:
tutorials\Exercises\Files_For_Tutorial_2\HL7_tutorial.xsd
Suchen Sie nach dieser Datei und klicken Sie auf Öffnen. Conversion Agent
Studio kopiert das Schema in den Projektordner.
7.
Auf der nächsten Seite legen Sie den Typ der Beispielquelle fest. In dieser
Übung ist das eine Datei, die wir für Sie zur Verfügung stellen. Wählen Sie
also Datei.
34
Erste Schritte mit Conversion Agent, Band 1
8.
4. Einen HL7-Parser definieren
Auf der nächsten Seite werden Sie aufgefordert, nach der Beispielquelle zu
suchen. Der Speicherort ist:
tutorials\Exercises\Files_For_Tutorial_2\hl7-obs.txt
Conversion Agent Studio kopiert die Datei in den Projektordner.
9.
Auf der nächsten Seite wählen Sie die Codierung des Quelldokuments. In
dieser Übung ist die Codierung ASCII, was ohnehin die Standardeinstellung
ist.
10. Die Dokumentpräprozessor-Seite können Sie überspringen. Für dieses Projekt
brauchen Sie keinen Dokumentpräprozessor.
11. Wählen Sie das Format des Quelldokuments. Bei diesem Projekt ist das
Format HL7.
Das bedeutet, dass der Parser davon ausgehen soll, dass die Nachrichtenfelder
durch die HL7-Begrenzungshierarchie getrennt sind:
newline
|
Other symbols such as ^ and tab
Der Parser lernt zum Beispiel, dass ein bestimmter Content-Anker drei
Delimiter | nach einem Marker beginnt und beim vierten Delimiter | endet.
12. Überprüfen Sie die Zusammenfassung auf der letzten Seite und klicken Sie auf
Fertigstellen.
13. Der Conversion Agent erstellt das neue Projekt. Er zeigt das Projekt im
Conversion-Agent-Explorer an. Er öffnet das Skript, das Sie erstellt haben,
Script_Tutorial_2.tgp, in einem IntelliScript-Editor.
Beachten Sie im IntelliScript, dass die Eigenschaften example_source und
format entsprechend Ihren Angaben zugewiesen wurden.
35
Erste Schritte mit Conversion Agent, Band 1
4. Einen HL7-Parser definieren
Die Beispielquelle sollte angezeigt werden. Wenn sie nicht angezeigt wird,
klicken Sie die Komponente Parser mit der rechten Maustaste an und wählen
„Beispielquelle öffnen“ aus.
XSD-Schemas im Conversion Agent verwenden
Für Conversion-Agent-Datenumwandlungen sind XSD-Schemas erforderlich, die
die Struktur der XML-Dokumente definieren. In Conversion Agent benötigt jedes
Parser-, Serializer- oder Mapper-Projekt mindestens ein Schema.
Für das Ausführen der Tutorial-Übungen in diesem Buch, stellen wir Ihnen die
benötigten Schemas zur Verfügung. Für Ihre eigenen Anwendungen haben Sie
vielleicht bereits Schemas oder Sie müssen neue Schemas erstellen.
XSD lernen
Eine ausgezeichnete Einführung in die XSD-Schemasyntax finden Sie im Tutorial
auf der W3Schools-Webseite, http://www.w3schools.com. Maßgebliche
Referenzinformtionen finden Sie im XML-Schemastandard unter
http://www.w3.org.
Schemas bearbeiten
Sie können die Schemas, die Sie mit Conversion Agent verwenden, mit jedem
beliebigen XSD-Editor erstellen und bearbeiten. Weitere Informationen finden Sie
im Kapitel Datenbehälter im Conversion Agent Studio Benutzerhandbuch.
Sie können den Conversion-Agent-Explorer so konfigurieren, dass er ein Schema
im XSD-Editor Ihrer Wahl öffnet. Anweisungen dazu finden Sie unter Conversion
Agent Studio-Einstellungen im Buch Conversion Agent Studio in Eclipse.
36
Erste Schritte mit Conversion Agent, Band 1
4. Einen HL7-Parser definieren
Die Anker definieren
Jetzt ist es Zeit, mit dem Parsen gemäß Beispiel zu beginnen.
1.
Sie müssen Marker-Anker definieren, die die Position der Felder im
Quelldokument angeben, und Content-Anker, die die Feldwerte identifizieren.
Beginnen wir mit den sich nicht wiederholenden Teilen des Dokuments,
nämlich den ersten drei Zeilen. Die praktischsten Marker-Anker sind die
Segmentbezeichnungen MSH, PID und OBR. Diese Bezeichnungen geben Teile
des Dokuments an, die eine wohlgeformte Struktur haben.
Innerhalb jedes Segments müssen Sie die abzurufenden Datenfelder
bestimmen. Das sind die Content-Anker. Für jeden Marker gibt es mehrere
Content-Anker.
Außerdem müssen Sie die Datenbehälter für alle Content-Anker definieren.
Die Datenbehälter sind Elemente oder Attribute in der XML-Ausgabe, die
oben abgebildet ist.
Wenn Sie die HL7-Nachricht und die XML-Struktur, die erzeugt werden soll,
untersuchen, werden Sie wahrscheinlich herausfinden, welche
Nachrichtenfelder als Anker definiert werden müssen, und Sie können die
Felder ihren entsprechenden Datenbehältern zuordnen. Um Ihnen Zeit zu
ersparen, haben wir das für Sie erledigt. Die Ergebnisse sind in der folgenden
Tabelle dargestellt:
Anker
Ankertyp
Datenbehälter
MSH
Marker
ORU
Content
/Message/@type
K172
Content
/Message/@id
PID
Marker
PATID1234^5^M11
Content
/Message/*s/Patient/@id
Jones
Content
/Message/*s/Patient/*s/l_name
William
Content
/Message/*s/Patient/*s/f_name
19610613
Content
/Message/*s/Patient/*s/birth_date
M
Content
/Message/*s/Patient/@gender
OBR
Marker
80004
Content
/Message/*s/Test_Type/@test_id
Electrolytes
Content
/Message/*s/Test_Type
37
Erste Schritte mit Conversion Agent, Band 1
4. Einen HL7-Parser definieren
Beachten Sie das @-Symbol in einigen der XPath-Ausdrücke, wie etwa
/Message/@type. Das Symbol bedeutet, dass type ein Attribut und kein
Element ist.
Machen Sie jetzt weiter und erstellen Sie die Anker in der Parser-Definition,
wie Sie das im vorangehenden Kapitel gemacht haben. Wenn Sie damit fertig
sind, sollte der IntelliScript-Editor wie in der folgenden Abbildung aussehen.
2.
Jetzt müssen Sie dem Parser beibringen, wie er die OBX-Zeilen im
Quelldokument verarbeiten soll. Es gibt mehrere OBX-Zeilen, die alle dasselbe
Format haben. Der Parser soll für jede OBX-Zeile, die er findet, eine Ausgabe
erstellen.
Dafür definieren Sie einen Anker namens RepeatingGroup. Der Anker teilt
dem Conversion Agent mit, dass er nach einem wiederholten Segme nt suchen
soll. Innerhalb der RepeatingGroup werden Sie mehrere Content-Anker
einbetten, die dem Parser mitteilen, wie er jede Wiederholung des Segments
parsen soll.
Suchen Sie im IntelliScript-Bereich nach dem letzten von Ihnen definierten
Anker (Electrolytes). Unmittelbar unterhalb des Ankers ist ein leerer Knoten
mit drei Punkten (...). Das ist die Stelle, an der Sie den neuen Anker
definieren.
38
Erste Schritte mit Conversion Agent, Band 1
4. Einen HL7-Parser definieren
Definieren Sie die RepeatingGroup am ...-Symbol in der Ankerliste
Markieren Sie die drei Punkte und drücken Sie die Eingabe-Taste. Daraufhin
erscheint eine Dropdown-Liste, in der die Namen der verfügbaren Anker
angezeigt werden.
Wählen Sie in der Liste den RepeatingGroup-Anker. Alternativ dazu können
Sie den Text RepeatingGroup in das Feld eintippen. Nachdem Sie die ersten
paar Buchstaben eingeben, vervollständigt Conversion Agent Studio die
Eingabe automatisch.
Drücken Sie nochmals die Eingabetaste, um den neuen Eintrag zu
übernehmen.
3.
Jetzt müssen Sie die RepeatingGroup konfigurieren, damit sie die sich
wiederholenden Segmente identifizieren kann. Dazu weisen Sie die
Eigenschaft separator zu. Sie geben an, dass die Segmente durch einen
Marker voneinander getrennt sind, nämlich den Text OBX.
Erweitern Sie im IntelliScript-Bereich die RepeatingGroup. Suchen Sie nach der
Zeile, die die Eigenschaft separator definiert.
39
Erste Schritte mit Conversion Agent, Band 1
4. Einen HL7-Parser definieren
Standardmäßig ist der Wert separator leer, was durch ein ...-Symbol
angezeigt wird. Markieren Sie das ...-Symbol, drücken Sie Eingabe und
ändern Sie den Wert auf Marker. Drücken Sie nochmals Eingabe, um den
neuen Wert zu übernehmen. Der Wert Marker bedeutet, dass die sich
wiederholenden Elemente durch einen Marker-Anker voneinander getrennt
sind.
Erweitern Sie die Marker-Eigenschaft und suchen Sie nach ihrer textEigenschaft. Markieren Sie den Wert (standardmäßig "") und drücken Sie
Eingabe. Tippen Sie den Wert OBX ein und drücken Sie wieder Eingabe. Das
bedeutet, dass das Trennzeichen der Marker-Anker OBX ist.
Conversion Agent Studio hebt im Beispielbereich alle OBX-Anker hervor, was
darauf hinweist, dass sie richtig gefunden wurden.
4.
Jetzt fügen Sie die Content-Anker ein, die eine einzelne OBX-Zeile parsen.
Lassen Sie dafür die RepeatingGroup markiert. Sie müssen die Content-Anker
innerhalb der RepeatingGroup einbetten.
Sie sollten die Anker nur in der ersten OBX-Zeile definieren. Weil die Anker in
einer RepeatingGroup eingebettet sind, weiß der Parser, dass er in weiteren
OBX-Zeilen nach denselben Ankern suchen soll.
Definieren Sie die Content-Anker wie folgt:
Anker
Ankertyp
Datenbehälter
1
Content
/Message/*s/Result/@num
Na
Content
/Message/*s/Result/*s/type
150
Content
/Message/*s/Result/*s/value
136-148
Content
/Message/*s/Result/*s/range
Above high
normal
Content
/Message/*s/Result/*s/comment
Final results
Content
/Message/*s/Result/*s/status
40
Erste Schritte mit Conversion Agent, Band 1
4. Einen HL7-Parser definieren
Anker in einer RepeatingGroup einbetten
Wenn Sie fertig sind, sollten die Auszeichnungen im Beispielbereich wie folgt
aussehen:
Das IntelliScript bearbeiten
Die oben beschriebene Vorgehensweise ist die übliche Methode zum Bearbeiten
des IntelliScript.
1.
Markieren Sie die gewünschte Stelle, die bearbeitet werden soll.
2.
Drücken Sie die Eingabetaste. An den meisten Stellen können Sie auch
doppelklicken, statt die Eingabetaste zu drücken.
3.
Wählen Sie einen Typ oder Wert.
4.
Drücken Sie nochmals Eingabe, um den bearbeiteten Wert zu übernehmen.
Den Parser testen
Jetzt wollen wir den Parser testen, um zu prüfen, ob er richtig funktioniert. Dafür
gibt es verschiedene Methoden:

Sie können die Farbcodierung in der Beispielquelle anzeigen. Damit wird die
grundlegende Anker-Konfiguration getestet.
41
Erste Schritte mit Conversion Agent, Band 1
4. Einen HL7-Parser definieren

Sie können den Parser ausführen, bestätigen, dass die Ereignisse fehlerfrei
sind und die XML-Ausgabe anzeigen. Damit wird die Parser-Operation an der
Beispielquelle getestet.

Sie können den Parser mit weiteren Quelldokumenten ausführen Damit wird
bestätigt, dass der Parser beliebige Abweichungen in der Quellstruktur, die
eventuell in den Dokumenten auftreten, verarbeiten kann
In dieser Übung werden Sie die ersten zwei Methoden verwenden, um den Parser
zu testen. Mit der dritten Testmethode befassen wir uns hier nicht. Sie ist aber ganz
einfach auszuführen (siehe Den Parser mit weiteren Quelldokumenten ausführen in
Kapitel 3, Grundlegende Parsing-Techniken).
1.
Wählen Sie im Menü IntelliScript > Beispiel markieren. Alternativ dazu
können Sie die Schaltfläche auf der rechten Seite der Symbolleiste, mit der
Bezeichnung Gesamtes Beispiel entsprechend des aktuellen Skripts markieren,
anklicken.
Beachten Sie, dass die Farbcodierung auf die gesamte Beispielquelle erweitert
wird. Zuvor wurden nur die Anker, die Sie in der ersten Zeile der sich
wiederholenden Gruppe definiert haben, hervorgehoben. Beim Ausführen des
Befehls Beispiel markieren hat der Conversion Agent den Parser ausgeführt
und die Anker in den anderen Zeilen gefunden.
Bestätigen Sie, dass die Markierung Ihren Erwartungen entspricht. Prüfen Sie
beispielsweise, ob der Testwert, -bereich und –kommentar in jeder OBX-Zeile
richtig identifiziert wurden.
Wenn die Markierung nicht stimmt (oder nicht vorhanden ist), ist in der
Parser-Konfiguration ein Fehler. Lesen Sie nochmals die Anweisungen,
korrigieren Sie den Fehler und versuchen Sie es erneut.
2.
Probieren wir versuchsweise aus, was geschieht, wenn Sie in der
Konfiguration absichtlich einen Fehler machen.
Erinnern Sie sich an die Option für HL7-Delimiter, die Sie im Assistenten
„Neuer Parser“ (siehe Ein Projekt erstellen weiter oben ) definiert haben? Geben
wir dieser Option nun einen anderen Wert:
a. Speichern Sie Ihre Arbeit (falls Sie während dieses Experiments einen
schwerwiegenden Fehler machen).
b. Bearbeiten Sie die Eigenschaft delimiters (sie befindet sich unter
Parser/format).
42
Erste Schritte mit Conversion Agent, Band 1
4. Einen HL7-Parser definieren
c. Ändern Sie den Wert von HL7 auf Positional. Dies bedeutet, dass sich die
Content-Anker an festen Positionen (Anzahl von Zeichen) hinter den
Marker-Ankern befinden.
d. Führen Sie den Befehl „Beispiel markieren“ erneut aus. Die Anker werden
nicht richtig identifiziert. In der zweiten OBX-Zeile etwa wird der
Kommentar als rmal|||Final resu statt als Normal angegeben. Dieses
Problem entsteht, weil der Parser annimmt, dass sich die Anker an einer
festen Position in der Zeile befinden.
e. Setzen Sie die Eigenschaft delimiters nun wieder auf HL7. Stellen Sie sicher,
dass „Beispiel markieren“ nun korrekt funktioniert. (Oder klicken Sie
stattdessen auf Bearbeiten > Rückgängig, um die vorherige Konfiguration
wiederherzustellen.)
f. Speichern Sie Ihre Arbeit erneut.
3.
Jetzt können Sie den Parser ausführen. Klicken Sie die Parser-Komponente
mit der rechten Maustaste an und legen Sie sie als Startkomponente fest.
Wählen Sie dann den Befehl Ausführen > Ausführen, um sie auszuführen.
4.
Nach ein paar Sekunden wird die Ereignisansicht angezeigt.
Beachten Sie, dass die meisten Ereignisse mit dem -Symbol versehen sind,
das für eine Ereignisinformation steht. Das ist normal, wenn der Parser keine
Fehler enthält.
Wenn Sie den Ereignisbaum durchsuchen, werden Sie ein Ereignis finden, das
mit einem -Symbol versehen ist, das für einen optionalen Fehler steht. Das
Ereignis befindet sich in der Baumstruktur unter Execution/RepeatingGroup
und trägt die Bezeichnung Separator before 5. Das heißt, dass RepeatingGroup
eine fünfte Wiederholung des OBX-Trennzeichens nicht finden konnte. Das ist
das erwartete Ergebnis, denn die Beispielquelle enthält nur vier
Wiederholungen. Der Fehler wird optional genannt, weil es erlaubt ist, dass
das Trennzeichen am Ende der Wiederholungen fehlt.
Innerhalb des optionalen Fehlerereignisses ist ein -Symbol eingebettet, das
für einen Fehler steht. Das Ereignis bedeutet, dass Conversion Agent den
Marker-Anker nicht gefunden hat, der das OBX-Trennzeichen definiert. Da der
Fehler in einen optionalen Fehler eingebettet ist, besteht kein Grund zur Sorge.
Im Allgemeinen sollten Sie einem Fehlerereignis aber Beachtung schenken
und seiner Ursache auf den Grund gehen. Ein Fehler weist häufig auf ein
Problem im Parser hin.
43
Erste Schritte mit Conversion Agent, Band 1
4. Einen HL7-Parser definieren
Neben Fehlerereignissen sollten Sie
(Warnung)-Ereignissen und
(schwerwiegender Fehler)-Ereignissen Beachtung schenken. Warnungen sind
weniger schwerwiegend als Fehler. Schwerwiegende Fehler sind am
gravierendsten; sie brechen die Datenumwandlung ab.
5.
Versuchen Sie im rechten Bereich der Ereignisansicht eines der Marker- oder
Content-Ereignisse doppelt anzuklicken.
Daraufhin hebt der Conversion Agent den Anker, der das Ereignis verursacht
hat, im IntelliScript- und im Beispielbereich hervor. Das ist eine gute Methode,
um die Ursache von Fehlern oder Fehlerereignissen zu finden.
6.
Doppelklicken Sie im Conversion-Agent-Explorer auf die Datei output.xml,
die sich unter dem Knoten Tutorial_2 files/Results befindet. Jetzt sollte
folgende XML angezeigt werden:
44
Erste Schritte mit Conversion Agent, Band 1
4. Einen HL7-Parser definieren
Woran Sie denken sollten
Um ein neues Projekt zu erstellen, führen Sie den Befehl Datei > Neu > Projekt aus.
Daraufhin erscheint ein Assistent, mit dem Sie folgende Optionen festlegen
können:

Parser-Name

Das XSD-Schema für die XML-Ausgabe

Das Beispiel-Quelldokument, zum Beispiel eine Datei oder eine URL

Das Quellformat, zum Beispiel Text oder Binärdaten

Die Delimiter, die die Datenfelder voneinander trennen
Nachdem Sie das Projekt erstellt haben, bearbeiten Sie das IntelliScript und fügen
die Anker hinzu, zum Beispiel Marker- und Content-Anker für einfache
Datenstrukturen oder RepeatingGroup-Anker für wiederholt auftretende
Strukturen.
Um das IntelliScript zu bearbeiten, verwenden Sie die Methode Markieren-EingabeZuweisen-Eingabe. Das heißt, markieren Sie die Stelle, die Sie bearbeiten wollen.
Drücken Sie die Eingabetaste. Weisen Sie den Eigenschaftswert zu und drücken Sie
wieder Eingabe.
Testen Sie den Parser, indem Sie den Befehl IntelliScript > Beispiel markieren
wählen, um die Anker mit einer Farbcodierung zu versehen.
Führen Sie den Parser aus und prüfen Sie die Ereignisse auf Warnungen, Fehler
oder schwerwiegende Fehler. Prüfen Sie die Ergebnisdatei, die die XML-Ausgabe
enthält.
45
Erste Schritte mit Conversion Agent, Band 1
Index
Index Band 1
A
Acrobat
Conversion-Agent-Umwandlungen, 5
Anker
Content, 22
definieren, 29
Marker, 22
RepeatingGroup, 42
Ansicht Binärquelle, 20
Ansichten
Conversion Agent Studio, 18
API
der Conversion Agent Engine, 4
Attribute
XML, 2
Aufgabenansicht, 20
B
Beispielbereich, 21
Beispiel-Quelldokument, 18
C
CMW-Dateien, 18
Content
Anker, 22
Conversion Agent
Überblick, 1
Conversion Agent Engine, 3, 4
Conversion Agent Studio, 3
öffnen, 15
Conversion-Agent-Dienste, 4
Conversion-Agent-Explorer, 19
D
Datenbehälter
Bedeutung, 26
Debuggen
Parser, 45
Delimiter
Tabulator, 22
Dienste
Conversion Agent, 4
Dokumente
Definition, 3
E
Editoren
Conversion Agent Studio, 18
Elemente
XML, 2
Ereignisansicht, 20
Ereignisinformationen, 47
Ereignisprotokoll
interpretieren, 47
Ergebnisdateien, 18
F
Fehler
in der Parser-Konfiguration korrigieren, 28
Fehlerereignisse, 48
Fenster
Conversion Agent Studio, 18
Format
tabulatorbegrenzt, 29
Format Tabulatorbegrenzt, 29
G
gültiges XML, 2
H
Hallo Welt
Conversion-Agent-Tutorial, 15
Hauptelemente
XML, 2
Hilfe
anzeigen, 10
Hilfeansicht, 20
HL7
Conversion-Agent-Umwandlungen, 4
Hintergrund, 35
Nachrichtenstruktur, 36
Parsing-Tutorial, 35
46
Erste Schritte mit Conversion Agent, Band 1
HTML-Dokumente
Conversion-Agent-Umwandlungen, 5
I
Installation
Conversion Agent, 11
IntelliScript
Fehler korrigieren, 28
IntelliScript-Assistent, 19
IntelliScript-Bereich, 20
IntelliScript-Editor, 20
öffnen, 21
Index
Q
Quelldokumente
weitere testen, 31
R
Registrierung
Conversion Agent, 12
RepeatingGroup
Anker, 42
S
Mapper
Definition, 1
Marker
Anker, 22
Schema
XML, 2
Schema-Ansicht, 20
Schemadateien, 18
Schemas
XSD, 40
schwerwiegende Fehler-Ereignisse, 48
Serializer
Definition, 1
Skriptdateien
TGP, 18
Speicheransicht, 20
Startkomponente
festlegen, 30
Subelemente
XML, 2
Systemvoraussetzungen
Conversion Agent, 11
P
T
Parsen
HL7-Tutorial, 35
Parsen gemäß Beispiel, 1, 3
Parser
Definition, 1
in Conversion Agent Studio ausführen, 30
testen und debuggen, 45
Parsing
Anfänger-Tutorial, 15
PDF-Dateien
Conversion-Agent-Umwandlungen, 5
Perspektive
Conversion Agent Studio erstellen, 16
wiederherstellen, 16
Projekte
erstellen, 37
importieren, 16
Tabulator-Delimiter, 22
Testen
Parser, 45
Textdateien
Parsing-Tutorial, 15
TGP-Skriptdateien, 18
Trennzeichen
der sich wiederholenden Gruppe, 44
Tutorial_1
grundlegende Parsing-Techniken, 15
Tutorial_2
einen Parser definieren, 35
Tutorial-Ordner
kopieren, 12
Tutorials
grundlegende Parsing-Techniken, 15
HL7-Parser, 35
K
Komponentenansicht, 19
L
Leerräume
in XML, 2
Lizenz
Conversion Agent, 12
Lösungen
für Übungen zu Erste Schritte, 12
M
47
Erste Schritte mit Conversion Agent, Band 1
Index
V
X
Vokabular
XML, 2
XML
Standards, 3
Tutorial, 3
Überblick, 2
XPath
Anker-Mappings definieren, 26
Conversion-Agent-Erweiterungen, 26
XSD
Referenzinformationen, 40
XSD-Schemas, 40
W
Warnungsereignisse, 48
Webseiten
Conversion-Agent-Umwandlungen, 5
Willkommensseite
in Eclipse anzeigen, 16
wohlgeformtes XML, 2
48
Der SAP-Conversion-Agent
von Itemfield
Erste Schritte mit
Conversion Agent
Band 2: Fortgeschrittene Übungen
Version 4
Rechtlicher Hinweis
Erste Schritte mit Conversion Agent , Band 2: Fortgeschrittene Übungen
Copyright © 2005-2006 Itemfield Inc. Alle Rechte vorbehalten.
Itemfield hat möglicherweise Patente, angemeldete Patente, Marken, Urheberrechte oder sonstige
Rechte an geistigem Eigentum inne, die Inhalte dieses Dokumentes abdecken. Sofern nichts anderes
ausdrücklich in einem schriftlichen Lizenzvertrag mit Itemfield vereinbart wurde, erhalten Sie durch
die Bereitstellung dieses Dokumentes keinerlei Anspruch auf diese Patente, Marken, Urheberrechte
oder auf sonstiges geistiges Eigentum.
Die in diesem Dokument enthaltenen Informationen können jederzeit ohne vorherige Ankündigung
geändert werden. Der Anwender trägt die Verantwortung für die Einhaltung aller anwendbaren
Urheberrechte. Ohne ausdrückliche schriftliche Genehmigung durch Itemfield Inc. darf kein Teil dieses
Dokumentes in irgendeiner Form oder auf irgendeine elektronische oder mechanische Weise zu
irgendeinem Zweck vervielfältigt oder weitergegeben werden.
SAP AG
http://www.sap.com
Angaben zur Veröffentlichung:
Version: 4
Date: September 2006
Erste Schritte mit Conversion Agent, Band 2
Inhalt
Inhalt Band 2
5. Positionsparsen eines PDF-Dokuments .........................................1
Anforderungsanalyse.............................................................................................................................2
Quelldokument ................................................................................................................................ 2
XML-Ausgabe.................................................................................................................................. 4
Die Parsing-Aufgabe ....................................................................................................................... 5
Das Projektanlegen ............................................................................................................................... 6
Die Anker definieren.............................................................................................................................. 8
Näheres über den Suchbereich.....................................................................................................13
Eingebettete, sich wiederholende Gruppen definieren........................................................................14
Grundeigenschaften und erweiterte Eigenschaften ...................................................................... 21
Aktionen verwenden, um Zwischensummen zu berechnen ................................................................ 22
Aktionen ........................................................................................................................................25
Potenzielle Verbesserung: Wie Sie mit Seitenumbrüchen umgehen ............................................25
Woran Sie denken sollten....................................................................................................................25
6. Word- und HTML-Dokumente parsen............................................27
Anforderungsanalyse...........................................................................................................................28
Quelldokument ..............................................................................................................................29
XML-Ausgabe................................................................................................................................ 30
Die Parsing-Aufgabe ..................................................................................................................... 30
Das Projektanlegen .............................................................................................................................32
Eine Variable definieren ......................................................................................................................33
Namen und Adresse parsen ................................................................................................................35
Warum die Ausgabe leere Elemente enthält................................................................................. 37
Die optionale Währungszeile parsen................................................................................................... 37
Die Auftragstabelle parsen ..................................................................................................................39
Warum die Ausgabe keinen HTML-Code enthält.......................................................................... 44
Mit Hilfe von Count Mehrdeutigkeiten ausschließen .....................................................................47
Transformer verwenden, um die Ausgabe zu ändern .........................................................................47
Globale Komponenten...................................................................................................................51
Den Parser mit einem anderen Quelldokument testen........................................................................52
Woran Sie denken sollten....................................................................................................................53
i
Erste Schritte mit Conversion Agent, Band 2
Inhalt
7. Einen Serializer definieren .............................................................55
Voraussetzungen:................................................................................................................................ 55
Anforderungsanalyse...........................................................................................................................55
Das Projekt anlegen ............................................................................................................................ 57
Speicherort des Projektordners bestimmen ..................................................................................58
Den Serializer konfigurieren ................................................................................................................59
Den Serializer rekursiv aufrufen .......................................................................................................... 61
Mehrere Komponenten in einem Projekt definieren ...................................................................... 62
Woran Sie denken sollten....................................................................................................................64
8. Einen Mapper definieren ................................................................65
Anforderungsanalyse...........................................................................................................................65
Das Projekt anlegen ............................................................................................................................ 66
Den Mapper konfigurieren ...................................................................................................................67
Woran Sie denken sollten....................................................................................................................70
9. Conversion Agent Engine ausführen............................................71
Einen Parser als einen Dienst bereitstellen.........................................................................................72
Conversion Agent COM API-Anwendung............................................................................................ 72
Quellcode ...................................................................................................................................... 72
Erläuterung der API-Aufrufe.......................................................................................................... 74
Die COM API-Anwendung ausführen..................................................................................................75
Woran Sie denken sollten....................................................................................................................77
Index Band 2 .......................................................................................78
ii
Erste Schritte mit Conversion Agent, Band 2
5
5. Positionsparsen eines PDF-Dokuments
Positionsparsen eines PDF-Dokuments
Bei vielen Parsing-Anwendungen haben die Quelldokumente ein festes
Seitenlayout. Das gilt beispielsweise für Rechnungen und Kontoauszüge. In
solchen Fällen können Sie einen Parser konfigurieren, der das Format positional
verwendet, um die Datenfelder zu finden.
In diesem Kapitel werden Sie das Positionsparsen anwenden, um ein
Rechnungsformular zu parsen. Sie definieren die Content-Anker aufgrund ihres
Zeichenabstands von den Marker-Ankern.
Neben dem Positionsparsen demonstriert diese Übung noch ein paar weitere
wichtige Conversion-Agent-Funktionen:

Das Quelldokument ist eine Adobe Acrobat PDF-Datei. Der Parser verwendet
einen Dokumentprozessor, um das Dokument vom binären PDF-Format in ein
Textformat umzuwandeln und es weiter bearbeiten zu können.

Die Daten werden in eingebetteten, sich wiederholenden Gruppen organisiert.

Der Parser verwendet Aktionen, um Zwischensummen zu berechnen, die im
Quelldokument nicht vorhanden sind.

Das Dokument enthält eine große Menge irrelevanter Daten, die für das
Parsen nicht benötigt werden. Einige der irrelevanten Daten enthalten
dieselben Referenzpunkt-Strings wie die gewünschten Daten. Diese Übung
führt das Konzept des Suchbereichs ein, das Sie dazu verwenden können, die
Suche nach Ankern einzuschränken und die gewünschten Daten zuverlässig
zu identifizieren.

Um den Parser zu konfigurieren, verwenden Sie sowohl die Grundeigenschaften
der Komponenten als auch die erweiterten Eigenschaften, die ausgeblendet sind,
aber auf Wunsch eingeblendet werden können.
In dieser Übung werden Sie ein komplexes, praxisnahes Parsing-Problem lösen.
Haben Sie etwas Geduld beim Ausführen dieser Übung. Löschen Sie oder machen
Sie Arbeitsschritte rückgängig, wenn Sie einen Fehler machen. Mit etwas Übung
werden Sie Parser wie diesen problemlos erstellen!
1
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
Anforderungsanalyse
Bevor Sie damit beginnen, ein Conversion-Agent-Projekt zu konfigurieren, sollten
Sie das Quelldokument und die gewünschte XML-Ausgabe prüfen, und
analysieren, was der Parser machen soll.
Quelldokument
Um das PDF-Quelldokument anzuzeigen, brauchen Sie den Adobe Reader (auch
bekannt als Adobe Acrobat Reader), Version 4 oder höher. Wenn Sie den Adobe
Reader nicht haben, können Sie ihn unter http://www.adobe.com herunterladen. (Sie
brauchen den Adobe Reader nur, um das Dokument anzuzeigen. Der ConversionAgent hat eine integrierte Komponente für die Verarbeitung von PDFDokumenten und benötigt keine zusätzliche Adobe Software.)
Im Adobe Reader öffnen Sie die Datei, die sich im Conversion-AgentInstallationsordner befindet:
tutorials\Exercises\Files_for_Tutorial_3\Invoice.pdf
Bei diesem Dokument handelt es sich um eine Rechnung, die ein fiktiver Eier- und
Molkereiprodukte-Großhändler namens Orshava Farms an seine Kunden schickt.
Auf der ersten Seite der Rechnung werden folgende Daten angezeigt:

Name, Adresse und Kontonummer des Kunden

Rechnungsdatum

Eine Aufstellung der offenen Beträge

Der fällige Gesamtbetrag
Am Anfang und am Ende der ersten Seite stehen Textbausteine und Werbetext.
2
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
Auf der zweiten Seite sind die Rechnungsposten jedes Käufers einzeln angeführt.
Das Beispieldokument führt zwei Käufer an, von denen jeder mehrere Einkäufe
getätigt hat. Die Seite hat eine eingebettete, sich wiederholende Struktur:

Der Hauptabschnitt wird für jeden Käufer wiederholt.

Innerhalb des Abschnitts für jeden Käufer gibt es eine zweizeilige Struktur für
jeden Einkauf, der ein Leerraum folgt.
Auf der zweiten Seite gibt es oben eine Kopfzeile. Am Seitenende stehen weitere
Textbausteine.
3
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
Diese Struktur ist für viele Rechnungen typisch: eine Aufstellungsseite, der eine
sich wiederholende Struktur für verschiedene Kontonummern, Kreditkarten usw.
folgt. Ein Unternehmen speichert solche Rechnungen unter Umständen als PDFDateien statt auf Papier. Es verwendet die PDF-Rechnungen eventuell für eine
Online-Verrechnung per E-Mail oder über eine Webseite.
Ihre Aufgabe ist es, einen Parsers zu erstellen, der die benötigten Daten abruft,
während er die Textbausteine ignoriert. Da Sie dies (so unsere Annahme) für eine
System-Integrationsanwendung machen, müssen Sie auf sehr hohe Zuverlässigkeit
achten.
XML-Ausgabe
Für den Zweck dieser Übung gehen wir davon aus, dass Sie die Transaktionsdaten
aus der Rechnung abrufen wollen. Sie müssen die Daten in einer XML-Struktur,
die wie folgt aussieht, speichern:
<Invoice account="12345">
<Period_Ending>April 30, 2003</Period_Ending>
<Current_Total>351.01</Current_Total>
4
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
<Balance_Due>457.07</Balance_Due>
<Buyer name="Molly" total="217.64">
<Transaction date="Apr 02" ref="22498">
<Product>large eggs</Product>
<Total>29.07</Total>
</Transaction>
<Transaction date="Apr 08" ref="22536">
<Product>large eggs</Product>
<Total>58.14</Total>
</Transaction>
<!-- Additional transaction elements -->
</Buyer>
<Buyer name="Jack" total="133.37">
<!-- Transaction elements -->
</Buyer>
</Invoice>
Die Struktur enthält mehrere Buyer-Elemente, und jedes Buyer-Element enthält
wiederum mehrere Transaction-Elemente. Jedes Transaction-Element enthält
ausgewählte Daten über eine Transaktion: Datum, Bezugszeichen, Produkt und
Gesamtpreis.
Die Struktur lässt andere Daten über die Transaktion, die wir ignorieren wollen,
weg. Die Struktur lässt beispielsweise den Nachlass, die Menge jedes Produkts
und den Preis pro Einheit weg.
Jedes Buyer-Element enthält das Attribut total, das die Summe der Einkäufe des
Käufers angibt. Die Summe pro Käufer ist in der Rechnung nicht enthalten. Wir
möchten, dass der Conversion Agent sie berechnet.
Die Parsing-Aufgabe
Öffnen Sie die Datei Invoice.pdf im Editor. Sie erhalten in etwa folgende Anzeige:
5
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
Diese Binärdaten zu parsen ist unter Umständen möglich, aber auf jeden Fall sehr
schwierig. Dazu müssten wir das interne PDF-Dateiformat gründlich verstehen
und wir müssten uns sehr bemühen, die Marker- und die Content-Anker eindeutig
zu unterscheiden.
Wenn wir den Textinhalt des Dokuments extrahieren, erscheint das Parsen etwas
einfacher:
Apr 08
22536
large eggs
60 dozen @ 1.02 per dozen
61.20
3.06
58.14
Apr 08
22536
cheddar cheese
30 lbs. @ 1.53 per lb.
45.90
2.30
43.61
Die Transaktionsdaten sind in Spalten angeordnet. Die Position jedes Datenfeldes
ist in Relation zum linken und rechten Rand fix. Das ist ein perfekter Fall für das
Positionsparsen – den Inhalt gemäß seiner Position auf der Seite extrahieren.
Deshalb ist das Format positional für diese Übung geeignet.
Ein weiteres Merkmal ist, dass die Aufzeichnung jeder Transaktion in einem festen
Zeilenmuster erfolgt. Die erste Zeile enthält die Daten, die wir abrufen möchten.
Die zweite Zeile enthält die Menge eines Produkts und den Preis pro Einheit, die
wir nicht abrufen müssen. Die nächste Zeile ist leer. Wir können die sich
wiederholende Zeilenstruktur heranziehen, um die Daten zu parsen.
Ein drittes Merkmal ist, dass der Gruppe von Transaktionen eine Überschrift
vorangeht, wie etwa:
Purchases by: Molly
Die Überschrift enthält den Namen des Käufers, den wir abrufen müssen. Die
Überschrift dient auch als Trennzeichen zwischen Gruppen von Transaktionen.
Das Projektanlegen
Nachdem Ihnen jetzt die Parsing-Anforderungen klar sind, können Sie das
Conversion-Agent-Projekt konfigurieren.
1.
Verwenden Sie den Befehl Datei > Neu > Projekt, um ein Parser-Projekt
namens Tutorial_3 anzulegen.
2.
Legen Sie auf den ersten paar Seiten des Assistenten folgende Optionen fest.
Die Optionen sind jenen, die Sie im vorangehenden Tutorial (siehe Kapitel 4,
Einen HL7-Parser definieren) festgelegt haben, ähnlich.
a. Geben Sie dem Parser den Namen PdfInvoiceParser.
b. Geben Sie der Skriptdatei den Namen Pdf_ScriptFile.
6
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
c. Wenn Sie aufgefordert werden, das Schema anzugeben, suchen Sie nach der
Datei OrshavaInvoice.xsd, die sich im Ordner
tutorials\Exercises\Files_For_Tutorial_3 befindet.
d. Geben Sie an, dass die Beispielquelle eine Datei auf einem lokalen
Computer ist.
e. Suchen Sie nach der Beispielquelle, nämlich Invoice.pdf.
f. Geben Sie an, dass es sich beim Quell-Inhaltstyp um PDF handelt.
3.
Wenn Sie zur Dokumentprozessor-Seite des Assistenten kommen, wählen Sie
den Prozessor PDF to Unicode (UTF-8).
Dieser Prozessor wandelt das binäre PDF-Format in das Textformat um, das
der Parser benötigt. Der Prozessor fügt Leerräume und Zeilenumbrüche in die
Textdatei ein und versucht, das Format der PDF-Datei so genau wie möglich
nachzuvollziehen.
Hinweis: PDF to Unicode (UTF-8) ist eine Beschreibung des Prozessors, die im
Assistenten angezeigt wird. Im IntelliScript können Sie den tatsächlichen
Namen des Prozessors, der PdfToTxt_3_00 lautet, sehen.
4.
Auf der nächsten Seite des Assistenten wählen Sie das Dokumentformat, und
zwar CustomFormat. Diesen Wert werden Sie später ändern, wenn Sie das
IntelliScript bearbeiten.
5.
Auf der letzten Seite klicken Sie auf Fertigstellen.
6.
Nach ein paar Sekunden zeigt der Conversion-Agent-Explorer das Projekt
Tutorial_3 an, und die Skriptdatei wird in einem IntelliScript-Editor geöffnet.
7.
Beachten Sie, dass die Beispielquelle im Beispielbereich im Textformat
angezeigt wird. Das ist die Ausgabe des Dokumentprozessors. Sie werden
später Anker konfigurieren, die den Text verarbeiten.
7
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
Wenn der Adobe Reader auf Ihrem Computer installiert ist, klicken Sie im
Beispielbereich unten auf die Registerkarte Browser. Diese Registerkarte zeigt
das Originaldokument in einem Microsoft Internet Explorer-Fenster an, das
den Adober Reader als Plug-in-Komponente verwendet, um die Datei
anzuzeigen. Die Registerkarte Browser dient nur zur Anzeige. Sie sollten dann
zur Registerkarte Quelle zurückkehren, um die Anker zu konfigurieren.
8.
Nachdem das Projekt und der Parser angelegt wurden, sollten Sie ein paar
Feinabstimmungen vornehmen, indem Sie das IntelliScript bearbeiten.
Erweitern Sie die Eigenschaft format des Parsers und verändern Sie ihren
Wert von CustomFormat auf TextFormat. Das machen Sie deshalb, weil der
Parser die Textform des Dokuments, also die Ausgabe des
Dokumentprozessors, verarbeitet.
Ändern Sie in der Eigenschaft format den Wert delimiters auf Positional.
Das bedeutet, dass der Parser die Struktur der Beispielquelle lernt, indem er
die Zeichen zwischen den Ankern zählt.
Die Anker definieren
Beginnen wir mit dem Parsen gemäß Beispiel:
1.
Suchen Sie am Anfang der Beispielquelle nach dem String ACCOUNT NO:, der
den Beginn des Textes kennzeichnet, den Sie parsen wollen. Definieren Sie
den String als Marker-Anker, indem Sie ihn markieren, mit der rechten
Maustaste anklicken und Marker einfügen wählen
8
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
Der Marker wird automatisch im IntelliScript angezeigt und Sie werden
aufgefordert, die Einstellung für die Eigenschaft search vorzunehmen.
Wählen Sie den Wert TextSearch. Das ist die Standardeinstellung. Bestätigen
Sie unter TextSearch, dass es sich beim text-String, nach dem der Marker–
Anker suchen soll, um ACCOUNT NO: handelt.
Klicken Sie am Ende von TextSearch auf das >>-Symbol, um die erweiterten
Eigenschaften anzuzeigen. Wählen Sie unter Marker die Option Groß/Kleinschreibung beachten. Diese Option bewirkt, dass der Parser nur nach dem
String ACCOUNT NO:, und nicht nach account no:, Account No: oder
irgendeiner anderen Schreibweise sucht. Damit vermeiden Sie Probleme, sollte
eine der anderen Schreibweisen im Dokument auftreten. Tatsächliche taucht
die Schreibweise Account No: in der Kopfzeile der zweiten Seite auf.)
Obwohl es nicht unbedingt notwendig ist, empfehlen wir, dass Sie die Option
Groß-/Kleinschreibung beachten für alle Marker-Anker wählen, die Sie in dieser
Übung definieren.
Hinweis: Weitere Informationen über die erweiterten Eigenschaften finden Sie
im Abschnitt Grundeigenschaften und erweiterte Eigenschaften weiter hinten in
diesem Kapitel.
2.
Markieren Sie in derselben Zeile des Quelldokuments nach dem Marker-Anker
den Eintrag 12345 und klicken Sie ihn mit der rechten Maustaste an. Wählen
Sie im Popup-Menü Content-Abstand einfügen.
Damit fügen Sie einen Content-Anker ein, dessen Eigenschaftswerte für das
Positionsparsen geeignet sind. Die Eigenschaften lauten wie folgt:
opening_marker = OffsetSearch(1)
Das bedeutet, dass der Text 12345 1 Zeichen nach dem Marker-Anker
beginnt.
closing_marker = OffsetSearch(5)
Das bedeutet, dass der Text 12345 5 Zeichen nachdem er beginnt, endet.
9
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
3.
Bearbeiten Sie die Eigenschaft data_holder des Content-Ankers. Stellen Sie
ihren Wert auf /Invoice/@account ein. Das ist der Datenbehälter, in dem der
Content-Anker den Text speichert, den er aus dem Quelldokument abruft.
4.
Es gibt ein kleines Problem bei der Definition des Content-Ankers. Was
passiert, wenn ein Quelldokument eine Kontonummer wie 987654321 enthält,
die länger ist als die Nummer in der Beispielquelle? Gemäß der aktuellen
Definition des closing_marker, ruft der Parser nur die ersten fünf Ziffern ab,
das heißt, er schneidet den Wert auf 98765 ab.
Um dieses potenzielle Problem zu beheben, sollten Sie den closing_marker
dahingehend ändern, dass er nicht nur bis zum fünften Zeichen abruft,
sondern bis zum Ende der Textzeile. Verändern Sie dafür den Wert des
closing_marker von OffsetSearch auf NewlineSearch.
5.
Fahren Sie mit der nächsten Zeile der Beispielquelle fort und definieren Sie
PERIOD ENDING: als Marker-Anker.
6.
Definieren Sie als Content-Anker mit Abstand-Eigenschaften. Ordnen Sie den
Content-Anker dem Datenbehälter /Invoice/*s/Period_Ending zu. Ändern
Sie den closing_marker auf NewlineSearch, um Quelldokumente zu
unterstützen, in denen der Datenstring länger ist als in der Beispielquelle.
10
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
7.
Gemäß der Anforderungsanalyse sind die nächsten Daten, die Sie abrufen
wollen, der aktuelle Rechnungsbetrag. Führen Sie einen Bildlauf ein paar
Zeilen nach unten durch und definieren Sie CURRENT INVOICE als MarkerAnker.
8.
Definieren Sie am Ende derselben Zeile 351.01 als Abstand-Content-Anker.
Ordnen Sie den Content-Anker dem Datenbehälter
/Invoice/*s/Current_Total zu.
Wenn Sie den Content-Anker markieren, nehmen Sie noch ein paar
Leerzeichen links vom String 351.01 in die Markierung mit auf. Beim
Positionsparsen ist das wichtig, weil der Bereich links eventuell noch weitere
Zeichen enthält. Der Inhalt könnte beispielsweise auf 1351.01 lauten.
Wie oben, ändern Sie auch hier den closing_marker auf NewlineSearch, für
den Fall, dass sich die Zahl rechts von der Position in der Beispielquelle
befindet.
9.
Definieren Sie auf dieselbe Weise BALANCE DUE als Marker–Anker und 475.07
als Content-Anker. Ordnen Sie den Content-Anker dem Datenbehälter
/Invoice/*s/Balance_Due zu.
10. Überprüfen Sie das IntelliScript und bestätigen Sie, dass die Reihenfolge der
Marker- und der Content-Anker richtig ist. Es sollte wie folgt aussehen:
11
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
Beachten Sie, dass die genauen Abstände in Ihrer Lösung eventuell von jenen
in der Abbildung abweichen. Die Abstände hängen von der Anzahl der
Leerzeichen ab, die Sie links oder rechts von jedem Anker markiert haben.
11. Überprüfen Sie die Farbcodierung im Beispielbereich. Sie sollte wie folgt
aussehen:
12. Klicken Sie PdfInvoiceParser mit der rechten Maustaste an und definieren Sie
es als Startkomponente.
13. Führen Sie den Parser aus und prüfen Sie die Ergebnisdatei an. Das Ergebnis
sollte wie folgt aussehen:
14. Jetzt sind Sie beinahe soweit, die sich wiederholende Gruppe zu definieren,
die die Buyer-Elemente der XML-Ausgabe erstellt. Danach werden Sie eine
eingebettete, sich wiederholende Gruppe definieren, die die TransactionElemente erstellt.
Die sich wiederholende Gruppe beginnt in der Zeile Purchases by: , die sich
auf Seite 2 der Rechnung befindet. Sie definieren Purchases by: als
Trennzeichen der sich wiederholenden Gruppe.
12
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
Es gibt jedoch einen Haken. Der String Purchases by: scheint auch am Ende
von Seite 1 auf. Damit dies zu keinen Problemen führt, geben Sie an, dass der
Suchbereich für die sich wiederholende Gruppe am Anfang von Seite 2 beginnt.
Definieren Sie dafür den String Page 2 als Marker-Anker. Der Parser geht
davon aus, dass die Anker in der Reihenfolge definiert sind, in der sie im
Dokument aufscheinen. Deshalb sucht er ab dem Ende dieses Marker-Ankers
nach der nächsten sich wiederholenden Gruppe.
Näheres über den Suchbereich
Wie erwähnt, dient der Marker für Page 2 dazu, den Suchbereich für die folgende
sich wiederholende Gruppe (die Sie im Folgenden definieren) festzulegen.
Eigentlich ist es die Aufgabe jedes Marker-Ankers, den Suchbereich für andere
Anker festzulegen. Nehmen wir beispielsweise an, dass sich ein Content-Anker
zwischen zwei Marker-Ankern befindet. Der Conversion Agent findet die MarkerAnker beim ersten Durchlauf durch das Dokument, den man Anfangsphase nennt.
Bei einem zweiten Durchlauf, Hauptphase genannt, sucht der Conversion Agent
nach dem Content zwischen den Marker-Ankern. Beim Ausführen der
vorhergehenden Übungen haben Sie bereits viele Beispiele dafür gesehen, wie das
funktioniert.
Es gibt viele Möglichkeiten, den Suchbereich und die Art, wie der Conversion
Agent nach Ankern sucht, zu verfeinern. Sie können den Conversion Agent zum
Beispiel so konfigurieren, dass er:

in der Anfangs-, Haupt- oder Endphase der Verarbeitung nach bestimmten
Ankern sucht

rückwärts nach Ankern sucht

zulässt, dass Anker einander überlagern
13
Erste Schritte mit Conversion Agent, Band 2

5. Positionsparsen eines PDF-Dokuments
Anker findet, die Suchkriterien, wie etwa einem bestimmten Textstring, einem
Muster (einem regulären Ausdruck) oder einem bestimmten Datentyp
entsprechen.
Den Suchbereich, die Phase und die Kriterien anzupassen ist eine der
leistungsstärksten Funktionen, die der Conversion Agent für das Parsen
komplexer Dokumente bietet. Wenn Sie sich umfassend darüber informieren
möchten, empfehlen wir Ihnen, das Kapitel über Anker im Conversion Agent Studio
Benutzerhandbuch zu lesen.
Eingebettete, sich wiederholende Gruppen definieren
Jetzt müssen Sie einen RepeatingGroup-Anker definieren, der die sich
wiederholende Purchases by: -Struktur parst. Innerhalb dieses Ankers definieren
Sie eine eingebettete RepeatingGroup, die die einzelnen Transaktionen parst.
Wissen Sie noch, wie man eine sich wiederholende Gruppe definiert?
Anweisungen dazu finden Sie in Kapitel 4, Einen HL7-Parser definieren.
1.
Bearbeiten Sie das IntelliScript am Ende der Ankerliste und fügen Sie eine
RepeatingGroup ein.
2.
Definieren Sie die Eigenschaft separator der RepeatingGroup als Marker, der
eine TextSearch für den String Purchases by: durchführt.
Stellen Sie separator_position auf before ein. Das machen Sie, weil sich das
Trennzeichen vor jeder Wiederholung der sich wiederholenden Gruppe
befindet.
Der Conversion Agent hebt die Purchases by: -Strings im Beispielbereich
hervor.
14
Erste Schritte mit Conversion Agent, Band 2
3.
5. Positionsparsen eines PDF-Dokuments
Fügen Sie innerhalb der RepeatingGroup einen Abstand-Content-Anker ein,
der den Käufernamen, Molly, dem Datenbehälter /Invoice/*s/Buyer/@name
zuordnet.
Vergessen Sie nicht, den closing_marker in NewlineSearch zu ändern, für den
Fall, dass der Käufername mehr als fünf Buchstaben enthält. (Wir werden Sie
in Zukunft nicht mehr daran erinnern. Immer, wenn Sie einen AbstandContent-Anker definieren, sollten Sie prüfen, ob er Strings unterstützt, die
eventuell länger sind als die in der Beispielquelle.)
4.
Wählen Sie im Menü IntelliScript > Beispiel markieren. Prüfen Sie, ob beide
Käufernamen, Molly und Jack, hervorgehoben sind. Das bestätigt, dass der
Parser die Wiederholungen der RepeatingGroup richtig identifiziert.
15
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
Wenn Sie möchten, können Sie den Parser auch ausführen. Bestätigen Sie, dass
die Ergebnisdatei zwei Buyer-Elemente enthält.
5.
Suchen Sie nach dem drei-Punkte-Symbol, das innerhalb der RepeatingGroup
eingebettet ist und definieren Sie eine weitere RepeatingGroup.
16
Erste Schritte mit Conversion Agent, Band 2
6.
5. Positionsparsen eines PDF-Dokuments
Was können wir als Trennzeichen für die eingebettete RepeatingGroup
verwenden? Zwischen den Transaktionen scheint es keinen charakteristischen
Text zu geben.
Anstelle eines Texttrennzeichens können wir die Tatsache verwenden, dass
jede Transaktion genau vier Zeilen des Dokuments einnimmt. Wir können die
vier Zeilenumbrüche als Trennzeichen verwenden.
Stellen Sie dafür die separator-Eigenschaft der eingebetteten RepeatingGroup
auf einen Marker ein, der eine NewlineSearch verwendet. Klicken Sie das >>Symbol am Ende des Marker-Ankers an, um seine erweiterten Eigenschaften
anzuzeigen und nehmen Sie die Einstellung count = 4 vor.
Sie können dann das <<-Symbol anklicken, um die erweiterten Eigenschaften
auszublenden.
Vor der ersten Transaktion und nach der letzten Transaktion gibt es kein
Trennzeichen, also sollten Sie die Einstellung separator_position = between
vornehmen.
Übrigens, wenn Sie das ursprüngliche PDF-Dokument sorgfältig prüfen,
werden Sie feststellen, dass jede Transaktion nur drei Zeilen einnimmt. Aber
wir parsen die Ausgabe des Dokumentprozessors. Aus irgendeinem Grund
(der zweifellos mit der Binärstruktur der PDF-Datei zu tun hat), fügt der
Prozessor eine zusätzliche Zeile ein.
17
Erste Schritte mit Conversion Agent, Band 2
7.
5. Positionsparsen eines PDF-Dokuments
Definieren Sie in der ersten Zeile der ersten Transaktion (also Molly's erstem
Einkauf), folgende Abstand-Content-Anker:
Content
Datenbehälter
Apr 02
/Invoice/*s/Buyer/*s/Transaction/@date
22498
/Invoice/*s/Buyer/*s/Transaction/@ref
large eggs
/Invoice/*s/Buyer/*s/Transaction/*s/Product
29.07
/Invoice/*s/Buyer/*s/Transaction/*s/Total
Wenn Sie damit fertig sind, sollte der Beispielbereich folgende Farbcodierung
aufweisen. Die genaue Position der Farbcodierung hängt von der Anzahl der
Leerräume ab, die Sie links und rechts von jedem Feld markiert haben.
Das IntelliScript sollte die vier Content-Anker innerhalb der eingebetteten
RepeatingGroup anzeigen.
18
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
8.
Führen Sie erneut den Befehl IntelliScript > Beispiel markieren aus. Bestätigen
Sie, dass die Spalten Datum, Bezugszeichen, Produkt und Summe in allen
Transaktionen hervorgehoben sind.
9.
Erinnern Sie sich noch, wie wir den Suchbereich der äußeren RepeatingGroup
eingeschränkt haben, indem wir Page 2 als Marker-Anker definiert haben? Es
ist eine gute Idee, auch am Ende der geschachtelten RepeatingGroup einen
Marker zu definieren, um dafür zu sorgen, dass der Conversion Agent nicht zu
weit sucht.
Kehren Sie dafür zur Ankerliste der obersten Ebene zurück (die Ebene, auf der
die äußere RepeatingGroup definiert ist) und definieren Sie einen Teil des
Textbausteins in der Fußzeile von Seite 2 als Marker. Definieren Sie
beispielsweise den String For your convenience:.
19
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
10. Führen Sie den Parser aus. Sie sollten folgende Ausgabe erhalten:
11. Reduzieren Sie die Baumstruktur und bestätigen Sie, dass die zwei BuyerElemente 5 beziehungsweise 3 Transaktionen enthalten. Das ist die Anzahl der
Transaktionen in der Beispielquelle.
Hinweis: Unter Windows XP ab SP2 zeigt der Internet Explorer eventuell eine
gelbe Informationsleiste an, die angibt, dass aktive Inhalte in der Datei
blockiert wurden. In diesem Fall können Sie den Baum nicht mit – und +
zusammenklappen und erweitern. Heben Sie die Blockierung aktiver Inhalte
auf und klappen Sie den Baum dann zusammen.
20
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
Überprüfen Sie wie immer, ob das Ereignisprotokoll irgendwelche Probleme
enthält. Denken Sie daran, dass optionale Fehlerereignisse (und eingebettete
Fehlerereignisse) am Ende einer RepeatingGroup normal sind. Für nähere
Erläuterungen siehe Den Parser testen in Kapitel 4, Einen HL7-Parser definieren.
Grundeigenschaften und erweiterte Eigenschaften
Beim Konfigurieren des Trennzeichens für die eingebettete RepeatingGroup,
haben wir Sie angewiesen, das >>-Symbol anzuklicken, um die erweiterten
Eigenschaften einzublenden. Dabei wird das >>-Symbol zu <<. Klicken Sie auf
das <<-Symbol, um die erweiterten Eigenschaften auszublenden.
Viele Conversion-Agent-Komponenten haben sowohl Grundeigenschaften als
auch erweiterte Eigenschaften. Die Grundeigenschaften brauchen Sie am
häufigsten, also werden sie standardmäßig angezeigt. Die erweiterten
Eigenschaften werden nicht so oft benötigt, also blendet sie der Conversion
Agent aus. Wenn Sie das >>-Symbol anklicken, werden sie grau angezeigt.
Wenn Sie einer erweiterten Eigenschaft einen nicht-standardmäßigen Wert
zuweisen, wird sie wie eine Grundeigenschaft schwarz angezeigt.
Grundeigenschaften und erweiterte Eigenschaften unterscheiden sich nur in
der Anzeige. Die erweiterten Eigenschaften sind nicht schwerer zu verstehen
oder komplizierter anzuwenden. Sie sollten Sie jederzeit bei Bedarf einsetzen.
IntelliScript mit eingeblendeten Grundeigenschaften. Klicken Sie auf >>, um
die erweiterten Eigenschaften anzuzeigen.
21
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
IntelliScript mit eingeblendeten Grund- und erweiterten Eigenschaften. Klicken
Sie auf <<, um die erweiterten Eigenschaften auszublenden.
Aktionen verwenden, um Zwischensummen zu
berechnen
Die Übung ist abgeschlossen, bis auf eine Funktion. Sie müssen für jeden Käufer
die Zwischensumme berechnen, und das Ergebnis in das Attribut total des BuyerElements einfügen. Die gewünschte Ausgabe lautet:
<Buyer name="Molly" total="217.64">
Sie können auf folgende Weise Zwischensummen berechnen:

Bevor Sie die Transaktionen verarbeiten, initialisieren Sie das Attribut total
mit 0.

Nachdem der Parser eine Transaktion verarbeitet hat, fügen Sie total den
Betrag der Transaktion hinzu.
Sie verwenden eine SetValue-Aktion, um die Initialisierung durchzuführen. Sie
verwenden eine CalculateValue-Aktion, um den Betrag hinzuzufügen.
1.
Erweitern Sie das IntelliScript, um die eingebettete RepeatingGroup
anzuzeigen.
2.
Klicken Sie die eingebettete RepeatingGroup mit der rechten Maustaste an, und
wählen Sie Einfügen aus dem Popup-Menü. Auf diese Weise können Sie
oberhalb der RepeatingGroup einen neuen Anker einfügen.
22
Erste Schritte mit Conversion Agent, Band 2
3.
5. Positionsparsen eines PDF-Dokuments
Fügen Sie die SetValue-Aktion ein und legen Sie ihre Eigenschaften wie folgt
fest:
quote = 0.00
data_holder = /Invoice/*s/Buyer/@total
Die SetValue-Aktion weist dem data_holder den quote–Wert zu.
4.
Erweitern Sie jetzt die eingebettete RepeatingGroup. Geben Sie an den drei
Punkten (...) unter dem vierten Content-Anker eine CalculateValue-Aktion
ein.
5.
Legen Sie die Eigenschaften der CalculateValue-Aktion wie folgt fest:
params =
/Invoice/*s/Buyer/@total
/Invoice/*s/Buyer/*s/Transaction/*s/Total
result = /Invoice/*s/Buyer/@total
expression = $1 + $2
Die Eigenschaft params definiert die Parameter. In diesem Fall sind die
Parameter das aktuelle Attribut total des Käufers (das wir mit 0 initialisiert
haben) und das Element Total der aktuellen Transaktion.
Die Eigenschaft expression ist ein JavaScript-Ausdruck, den die Aktion
ausführen soll. $1 und $2 sind die Parameter, die Sie in der Eigenschaft params
definiert haben.
Die Eigenschaft result gibt an, dass wir das Ergebnis des Ausdrucks als
neuen Wert des Attributs total zuweisen sollen.
23
Erste Schritte mit Conversion Agent, Band 2
6.
5. Positionsparsen eines PDF-Dokuments
Führen Sie den Parser aus. In der Ergebnisdatei sollte jedes Buyer-Element ein
total-Attribut haben.
24
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
Aktionen
In dieser Übung haben Sie die Aktionen SetValue und CalculateValue verwendet,
um die Zwischensummen zu berechnen.
Ganz allgemein sind Aktionen Conversion-Agent-Komponenten, die Operationen
mit Daten durchführen. Der Conversion Agent bietet zahlreiche
Aktionskomponenten, die folgende Operationen durchführen:

Werte berechnen

Strings verketten

Eine Bedingung für eine fortlaufende Verarbeitung testen

Einen zweiten Parser ausführen

Eine Datenbank-Abfrage ausführen
Weitere Informationen finden Sie im Kapitel Aktionen im Conversion Agent Studio
Benutzerhandbuch.
Potenzielle Verbesserung: Wie Sie mit Seitenumbrüchen umgehen
Bisher haben wir angenommen, dass die sich wiederholenden Gruppen eine ganz
regelmäßige Struktur aufweisen. Was passiert aber, wenn die Transaktionen sich
über eine weitere Seite erstrecken? Die neue Seite würde eine Kopfzeile aufweisen,
die die sich wiederholende Struktur unterbricht.
Eine Möglichkeit, die Kopfzeilen zu berücksichtigen wäre, das Trennzeichen
zwischen den Transaktionen neu zu definieren. Sie könnten beispielsweise einen
Alternatives-Anker als Trennzeichen verwenden. Auf diese Weise können Sie
mehrere Trennzeichen definieren, die zwischen den Transaktionen auftreten.
Für diese Verbesserung bieten wir Ihnen keine Übung, aber wir ersuchen Sie, mit
diesen Funktionen selbst zu experimentieren.
Woran Sie denken sollten
Um ein Binärformat, wie etwa eine PDF-Datei zu parsen, können Sie einen
Dokumentprozessor verwenden, der die Quelle in Text umwandelt.
Das Positionsparsen ist dann sinnvoll, wenn der Inhalt an einer fixen Position auf
der Seite angeordnet ist, das heißt, in einem bestimmten Abstand von den Rändern
oder von Marker-Ankern.
Wenn Sie Anker definieren, denken Sie an die möglichen Abweichungen, die in
Quelldokumenten auftreten können. Wenn Sie den Inhalt positional definieren,
passen Sie die Abstände an, für den Fall, dass ein Quelldokument längere Daten als
die Beispielquelle enthält.
25
Erste Schritte mit Conversion Agent, Band 2
5. Positionsparsen eines PDF-Dokuments
Der Suchbereich ist der Abschnitt eines Dokuments, an dem der Conversion Agent
nach einem Anker sucht. Marker-Anker dienen dazu, den Suchbereich für andere
Anker zu definieren.
Sich wiederholende Gruppen können eingebettet sein. Sie können diese Funktion
verwenden, um eingebettete, sich wiederholende Strukturen zu parsen.
Zeilenumbrüche sind nützliche Referenzpunkte und Trennzeichen. Sie können einen
Zähler für Zeilenumbrüche festlegen, der angibt, wie viele Zeilen übersprungen
werden sollen.
Im IntelliScript können Sie das >>-Symbol neben einer Komponente anklicken, um
ihre erweiterten Eigenschaften anzuzeigen. Erweiterte Eigenschaften werden seltener
verwendet als Grundeigenschaften, also werden sie ausgeblendet, um die Anzeige
nicht zu überladen.
Sie können Aktionen verwenden, um Operationen mit Daten durchzuführen, wie
etwa Summen zu berechnen.
26
Erste Schritte mit Conversion Agent, Band 2
6
6. Word- und HTML-Dokumente parsen
Word- und HTML-Dokumente parsen
In der Praxis sind viele Dokumente viel lockerer strukturiert als wir es in den
vorhergehenden Kapiteln beschrieben haben. Die Dokumente können Folgendes
enthalten:

Wenige Bezeichnungen und Delimiter, mit deren Hilfe ein Parser Datenfelder
identifizieren kann.

Zeilenumbrüche und flexible Layouts, die ein Positionsparsen schwierig
gestalten.

Schlüsselwörter, die wiederholt vorkommen, sodass es schwer ist, eindeutige
Marker-Anker zu definieren.
Microsoft Word-Dokumente sind ein typisches Beispiel für dieses Phänomen.
Word-Dokumente werden üblicherweise manuell erstellt (obwohl sie auch
programmatisch erzeugt werden können). Die Autoren können die Dokumente auf
der Grundlage einer bestimmten Vorlage erstellen, aber sie können das Layout von
Dokument zu Dokument variieren.
In solchen Fällen können Sie nur die Auszeichnungen oder Muster verwenden, die
vorhanden sind, um diese Dokumente zu parsen. Häufig können Sie zum Beispiel
die Formatierungen verwenden – Absätze, Tabellen, kursiv usw. – um die
Datenfelder zu identifizieren.
Bei einem Microsoft Word-Dokument können Sie die Formatierungen offenlegen,
indem Sie das Dokument als HTML speichern. Ein Parser kann die HTML-Tags
verwenden, die im Grunde nur Formatbezeichnungen sind, um die
Dokumentstruktur zu interpretieren.
In diesem Kapitel werden Sie einen Parser für ein Word-Dokument erstellen. Sie
werden folgende Techniken lernen:

Den WordToHtml-Dokumentprozessor verwenden, der ein Word-Dokument in
ein HTML-Dokument umwandelt.

Die Anfangs- und Ende-Tag-Struktur nutzen, um ein HTML-Dokument zu
parsen.

Anker eindeutig identifizieren, wenn derselbe Text im ganzen Dokument
häufig wiederholt wird

Transformer verwenden, um die Ausgabe der Anker zu ändern.

Variablen verwenden, um die abgerufenen Daten zu speichern, um später
darauf zugreifen zu können.
27
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen

Eine globale Komponente definieren, die Sie einmal konfigurieren und mehrmals
in einem Projekt verwenden.

Einen Parser, neben der Beispielquelle, noch mit anderen Quelldokumenten
testen.
Umfang der Übung
Diese Übung ist die längste und komplizierteste in diesem Buch. Sie ist typisch für
Parsing-Szenarien wie sie in der Praxis vorkommen. Sie werden einen Parser mit
allen Funktionen erstellen, der in einer Produktionsanwendung eingesetzt werden
könnte.
Wir empfehlen, dass Sie das Kapitel zuerst von Anfang bis Ende überfliegen, damit
Sie verstehen, wie der Parser funktionieren soll, und dann die Übung ausführen.
Sie können gerne mit der Parser-Konfiguration experimentieren. Es kann sein, dass
Sie andere oder vielleicht sogar bessere Parsing-Lösungen finden als unsere.
Genau genommen, kennen wir ein paar Methoden, um den Parser weiter zu
verbessern. Es ist beispielsweise möglich, die Anker-Konfiguration zu ändern,
sodass zahlreiche Abweichungen der Quelldokument-Struktur unterstützt werden.
Es ist möglich, das XSD-Schema zu ändern und die Datentypen der Elemente
einzuschränken, um dafür zu sorgen, dass der Parser genau die richtigen Daten
aus einem komplexen Dokument abruft.
Wir haben die meisten dieser Feinheiten weggelassen, damit die Übung nicht zu
umfangreich wird. Wenn Sie mit der Übung fertig sind, können Sie sich
eingehender über die hier beschriebenen Techniken informieren, indem Sie das
Conversion Agent Studio Benutzerhandbuch lesen.
Voraussetzungen
Um diese Übung durchführen zu können, muss Microsoft Word 97 oder höher auf
demselben Computer wie Conversion Agent Studio installiert sein.
Wenn Word auf demselben Computer nicht installiert ist, können Sie das
Quelldokument auf einem anderen Computer öffnen und als HTML speichern.
Dann können Sie das HTML-Dokument auf den Conversion-Agent-Computer
übertragen und parsen. Der Rest der Übung bleibt gleich, abgesehen davon, dass
Sie den WordToHtml-Prozessor nicht einsetzen müssen, weil das Dokument bereits
im HTML-Format vorliegt.
Wir gehen bei dieser Übung davon aus, dass Sie grundlegend mit HTML-Code
vertraut sind. Eine Einführung finden Sie unter http://www.w3.org oder in jedem
Buch über Webseitenerstellung.
Anforderungsanalyse
Bevor Sie damit beginnen, einen Parser zu konfigurieren, ist es immer eine gute
Idee, zu planen, was der Parser tun soll. Untersuchen wir also die
Quelldokumentstruktur, die erforderliche XML-Ausgabe und die Art der ParsingAufgabe.
28
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Quelldokument
Sie können die Beispielquelle in Microsoft Word anzeigen. Das Dokument ist in
folgendem Ordner gespeichert:
tutorials\Exercises\Files_for_tutorial_4\Order.doc
Beim Dokument handelt es sich um ein Bestellformular für ein fiktives
Unternehmen namens The Tennis Book Club. Das Formular enthält:

Den Namen des Käufers

Eine einzeilige Adresse

Eine optionale Zeile, die die Währung, zum Beispiel $ oder £, angibt

Eine Tabelle mit den bestellten Artikeln
Die Artikel in der Tabelle haben kein einheitliches Format. Obwohl die erste
Spaltenüberschrift Books (Bücher) lautet, handelt es sich bei einigen der in dieser
Spalte zulässigen Artikel nicht um Bücher, sondern beispielsweise um
Videokassetten. Es kann sein, dass diese Artikel in einer anderen Schriftart
formatiert sind als die Bücher.
29
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
In einigen Zellen der Tabelle erfolgt ein Zeilenumbruch, das heißt, der Text wird in
einer zweiten Zeile fortgesetzt. Positionsparsen mit der Technik, die Sie im
vorangehenden Kapitel gelernt haben, wäre bei diesen Zellen schwierig.
Die Tabellenzellen enthalten keine Bezeichnungen. Der Parser muss die Zellen
entsprechend ihrer Position in der Tabelle interpretieren.
Das Wort Total erscheint dreimal in der Tabelle. In zwei von diesen Fällen
befindet sich das Wort in einer Spalten- oder Zeilenüberschrift; wir können davon
ausgehen, dass dies in allen ähnlichen Quelldokumenten auch der Fall ist. Im
dritten Fall scheint Total zufällig im Titel der Videokassette auf. Das ist wichtig,
weil wir die Tabellenzeile mit dem Gesamtpreis parsen wollen und einen
eindeutigen Bezeichner für die Zeile benötigen.
Was die Sache zusätzlich kompliziert macht ist, dass die Zeile Currency optional
ist. Bei einigen der Quelldokumente, die wir parsen wollen, fehlt diese Zeile.
XML-Ausgabe
Bei dieser Übung gehen wir davon aus, dass das XML-Ausgabeformat wie folgt
aussehen soll:
<Order>
<To>Becky Handler</To>
<Address>18 Cross Court, Down-the-Line, PA</Address>
<Books>
<Book>
<Title>Topspin Serves Made Easy, by Roland Fasthitter</Title>
<Price>$11.50</Price>
<Quantity>1</Quantity>
<Total>$11.50</Total>
</Book>
<!-- Additional Book elements -->
</Books>
<Total>$46.19</Total>
</Order>
Beachten Sie, dass die Preise und Summen das Währungssymbol ($) enthalten. Im
Quelldokument wird die Währung in der optionalen Währungszeile angegeben,
nicht in der Tabelle.
Die Parsing-Aufgabe
Prozessor-Auswahl
Der Conversion Agent bietet mehrere Dokumentprozessoren, die ein WordDokument in ein für das Parsen geeignetes Format umwandeln können. Dazu
gehören:
30
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
WordToHtml
WordToRtf
WordToTxt
WordToXml
Wir entscheiden uns für den WordToHtml-Prozessor, weil:

Der HTML-Code leicht zu lesen und der Parser somit einfach zu konfigurieren
ist.

Die HTML-Tags eine Reihe von Formatierungsinformationen offenlegen, die
uns dabei helfen, die abzurufenden Daten zu identifizieren.
Der WordToXml- und der WordToRtf-Prozessor wären auch eine gute Wahl, aber ihre
Ausgabe ist weit schwerer zu lesen als die des WordToHtml-Prozessors.
Der WordToTxt-Prozessor erzeugt eine reine Textausgabe. Da diesem Text jegliche
Formatierungsinformationen fehlen, wäre es vermutlich viel schwerer, ihn
zuverlässig zu parsen, als die HTML-Datei.
HTML-Struktur
Der WordToHtml-Prozessor verwendet die Funktion Als Webseite speichern von
Microsoft Word, um die HTML-Datei zu erzeugen. Die HTML-Datei ist äußerst
wortreich; sie kann viele Seiten umfassen, auch wenn das ursprüngliche WordDokument kürzer als eine Seite war. Der Grund dafür ist, dass Word die
kompletten Dokumentmerkmale, einschließlich Formatvorlagen- und
Formatierungsangaben, speichert. Ein Großteil dieser Informationen wirkt sich
nicht auf die HTML-Darstellung in einem Web-Browser aus, aber Word verwendet
diese Informationen, wenn Sie die HTML-Datei später wieder in Word importieren
möchten. Der größte Teil dieses irrelevanten Codes befindet sich im <header>Element des HTML-Dokuments.
Wenn Sie möchten, können Sie das Beispiel-Quelldokument in Word manuell als
Webseite speichern. Die daraus resultierende HTML-Datei können Sie in einem
Browser anzeigen oder Sie können die Datei im Editor öffnen und den HTMLCode überprüfen.
Im Überblick sieht der Code wie folgt aus:
<html>\
<header>
<!-- Very long header storing Word style definitions, etc. -->
</header>
<body>
<h1>The Tennis Book Club<br>Order Form</h1>
<p>Send to:</p>
<p>Becky Handler</p>
<p>18 Cross Court, Down-the-Line, PA</p>
<table>
<tr>
<!-- Table column headers -->
</tr>
<tr>
31
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
<td><i>Topspin Serves Made Easy</i>, by Roland Fasthitter</td>
<td>$11.50</td>
<td>1</td>
<td>$11.50</td>
</tr>
<!-- Additional tr elements containing the other table rows -->
</table>
</body>
</html>
Diese grundlegende HTML-Tag-Struktur werden Sie verwenden, um das
Dokument zu parsen.
Der tatsächliche Code ist wesentlich komplexer als im obigen Überblick. Der
folgende Code ist ein typisches Beispiel, und zwar handelt es sich um das erste
<td>-Element der Topspin Serves-Zeile. Der Code kann auf Ihrem Computer ein
wenig anders aussehen, je nach Ihrer Word-Version und Konfiguration.
<td width=168 valign=top style='width:125.9pt;border:solid windowtext
1.0pt;border-top:none;mso-border-top-alt:solid windowtext .5pt;msoborder-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt'><p
class=MsoBodyText><i style='mso-bidi-font-style:normal'>Topspin Serves
Made Easy</i>, by Roland <span class=SpellE>Fasthitter</span></p></td>
Sobald Sie mit der aus einem Word-Dokument erzeugten HTML-Datei zu arbeiten
beginnen, werden Sie schnell lernen, die wichtigen Struktur-Tags, wie zum
Beispiel das <td>...</td>-Element zu finden. Den irrelevanten Code, wie etwa die
langen Attribute und <span>-Tags, können Sie ignorieren.
Das Projektanlegen
1.
Beginnen Sie mit der Übung, indem Sie ein Projekt namens Tutorial_4
anlegen. Machen Sie im Assistenten Neues Projekt Folgendes:
a. Geben Sie dem Parser den Namen MyHtmlParser.
b. Geben Sie der Skriptdatei den Namen Html_ScriptFile.
c. Wählen Sie das Schema TennisBookClub.xsd, das sich im Ordner
tutorials\Exercises\Files_For_Tutorial_4 befindet.
d. Geben Sie an, dass die Beispielquelle eine Datei auf einem lokalen
Computer ist.
e. Suchen Sie nach der Beispielquelle namens Order.doc.
f. Wählen Sie die Codierung Microsoft Word.
g. Wählen Sie den Dokumentprozessor Microsoft Word To HTML.
32
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
h. Wählen Sie das Format HTML format. Diese Formatkomponente ist mit den
passenden Delimitern und anderen Komponenten für das Parsen von
HTML-Code konfiguriert.
Das daraus resultierende IntelliScript sollte wie folgt aussehen:
2.
Wenn Conversion Agent Studio die Beispielquelle öffnet, kann es sein, dass
eine Microsoft Internet Explorer-Meldung für das Öffnen oder Speichern der
Datei erscheint. Der Grund dafür ist, dass Conversion Agent Studio den
Internet Explorer verwendet, um eine Browser-Ansicht der Datei anzuzeigen.
Das Verhalten hängt von Ihren Internet Explorer-Sicherheitseinstellungen ab.
Sie können bedenkenlos auf Öffnen klicken und fortfahren.
Eine Variable definieren
Erinnern Sie sich noch an die Currency-Zeile, ziemlich weit oben in der
Beispielquelle? Wir müssen das Währungssymbol zwar abrufen, aber wir wollen
es keinem Ausgabeelement oder -attribut zuordnen. Stattdessen wollen wir das
Währungssymbol vorübergehend speichern und den Preisen in der Ausgabe
voranstellen.
Dafür definieren wir einen temporären Datenbehälter, Variable genannt. Sie
können eine Variable genau gleich einsetzen wie einen Element- oder AttributDatenbehälter, aber sie scheint nicht in der XML-Ausgabe auf.
Führen Sie folgende Schritte aus, um die Variable zu definieren:
1.
Markieren Sie am Ende des IntelliScript (auf globaler Ebene, nicht in der
Parser-Komponente eingebettet) die drei Punkte (...) und drücken Sie Eingabe.
33
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
2.
Geben Sie den Variablennamen, varCurrency, ein und drücken Sie Eingabe.
3.
An den drei Punkten rechts vom Gleichheitszeichen (=) drücken Sie Eingabe
und wählen Variable.
Die Variable wird im IntelliScript, in der Schema-Ansicht und in der
Komponentenansicht angezeigt.
Variablendefinition im IntelliScript
Anzeige der Variablen in der Schema-Ansicht
Beachten Sie die Position der Variablen in der Schema-Ansicht, nämlich
eingebettet im Namensraum www.Local-Project.com/Variables. Später
müssen Sie auf die Variable in der Schema-Ansicht zugreifen.
34
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Namen und Adresse parsen
Als Erstes wollen wir die Anker definieren, die den Namen und die Adresse am
Anfang der Beispielquelle parsen. Führen Sie folgende Schritte aus:
1.
Führen Sie im Beispielbereich einen Bildlauf nach dem Header bis zum bodyTag durch (ungefähr 80% nach unten!).
Um den Bildlauf zu beschleunigen, können Sie im Beispielbereich mit der
rechten Maustaste klicken, die Option Suchen wählen und nach dem String
<body suchen (mit einem <-Symbol am Anfang, aber nicht mit dem Endsymbol
>).
2.
Definieren Sie <body als Marker-Anker. Damit überspringt der Parser den
Header komplett (so wie Sie das beim Bildlauf durch das Dokument getan
haben).
Wählen Sie die Eigenschaft match_case für diesen Anker oder für andere
HTML-Tags, die Sie in dieser Übung als Anker definieren, nicht. HTML
unterscheidet nicht zwischen Groß- und Kleinschreibung. Word 2000 und
2002 generiert HTML-Tags in Kleinbuchstaben, aber Word 97 generiert Tags
in Großbuchstaben. Wenn Sie Groß-/Kleinschreibung beachten markieren,
unterstützt der Parser Word 97 nicht.
3.
Führen Sie einen Bildlauf über ein paar Absätze durch, und definieren Sie den
String Send to: als Marker-Anker. Der String gibt den Beginn des Inhalts an,
den Sie abrufen wollen.
Hier ist es in Ordnung, die Option Groß-/Kleinschreibung beachten zu wählen.
Das kann nützlich sein, wenn es darum geht, nur nach der angegebenen
Schreibweise zu suchen.
4.
Jetzt können Sie den ersten Content-Anker definieren. Sie konfigurieren den
Anker so, dass er die Daten zwischen den angegebenen Anfangs- und EndeStrings abruft. Ein auf diese Weise definierter Content-Anker ist einer Marker
Content Marker-Sequenz ähnlich (die Sie auch verwenden können, wenn Sie
möchten).
35
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Klicken Sie dazu den String Becky Handler an und fügen Sie einen ContentAnker ein. Nehmen Sie im IntelliScript folgende Zuweisungen vor:
opening_marker
Geben Sie den String <p ein.
closing_marker
Geben Sie den String </p> ein.
data_holder
Ordnen Sie den Anker /Order/*s/To zu.
Wenn Sie mit diesen Zuweisungen fertig sind, werden <p und </p> im
Beispielbereich als Marker-Anker hervorgehoben. Becky Handler wird als
Content-Anker hervorgehoben.
Beachten Sie, dass nur der String Becky Handler blau hervorgehoben wird.
Der Rest des HTML-Codes zwischen opening_marker und closing_marker,
wie etwa
class=MsoBodyText>
wird nicht hervorgehoben. Der Grund dafür ist, dass das HtmlFormat das
Symbol > als Delimiter erkennt. Es lernt aus der Beispielquelle, dass sich der
gewünschte Inhalt nach dem Delimiter > befindet.
5.
Gehen Sie zum nächsten Absatz der Quelle über und verwenden Sie dieselbe
Methode (opening_marker und closing_marker definieren), um 18 Cross
Court, Down-the-Line, PA dem Datenbehälter /Order/*s/Address
zuzuordnen.
36
Erste Schritte mit Conversion Agent, Band 2
6.
6. Word- und HTML-Dokumente parsen
Führen Sie den Parser aus und bestätigen Sie, dass Sie folgendes Ergebnis
erhalten:
Warum die Ausgabe leere Elemente enthält
Beachten Sie, dass der Parser leere Books- und Total-Elemente einfügt. Der Grund
dafür ist, dass das XSD-Schema Books und Total als erforderliche Elemente
definiert. Der Parser fügt die Elemente ein, um dafür zu sorgen, dass die XMLAusgabe gemäß dem Schema gültig ist (Sie können dieses Verhalten in den
Projekteigenschaften ändern). Die Elemente sind leer, weil wir die Tabelle mit den
Büchern noch nicht geparst haben.
Die optionale Währungszeile parsen
Wenn das Quelldokument eine Currency-Zeile enthält, müssen Sie sie parsen und
das Ergebnis in der Variablen varCurrency speichern, die Sie weiter oben erstellt
haben. Wenn die Currency-Zeile fehlt, soll der Parser dies ignorieren und den Rest
des Dokuments parsen.
Gehen Sie dazu wie folgt vor:

Definieren Sie einen Group-Anker. Zweck dieses Ankers ist es, eine Gruppe
von eingebetteten Ankern zusammenzufassen, und als Einheit zu verarbeiten.

Betten Sie innerhalb der Gruppe Marker- und Content-Anker ein, die die
Währung abrufen.

Wählen Sie die Eigenschaft optional für den Group-Anker. Das bedeutet,
wenn der Group-Anker fehlschlägt (weil der Marker- und/oder Content-Anker
fehlt) soll der Parser weiter ausgeführt werden.
37
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Gehen Sie wie folgt vor:
1.
Fügen Sie nach den Ankern, die Sie bereits definiert haben, einen Group-Anker
ein.
2.
Markieren Sie die drei Punkte, die innerhalb des Group-Ankers eingebettet
sind. Definieren Sie den Text Currency; als Marker-Anker.
3.
Fahren Sie innerhalb des Group-Ankers fort, und definieren Sie $ als Content–
Anker. Ordnen Sie den Anker der VarCurrency-Variablen zu, die Sie weiter
oben definiert haben.
4.
Klicken Sie auf das >>-Symbol, um die erweiterten Eigenschaften von Group
anzuzeigen und wählen Sie die Eigenschaft optional. (Achten Sie darauf, die
Eigenschaft optional von Group zu wählen, und nicht die Eigenschaft
optional des Marker- oder Content-Ankers.)
38
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Die Auftragstabelle parsen
Wie Sie in den vorangehenden Übungen gesehen haben, können Sie die
Auftragstabelle parsen, indem Sie eine RepeatingGroup verwenden. In dieser
Übung werden Sie die RepeatingGroup in einen EnclosedGroup-Anker einbetten.
Der EnclosedGroup-Anker ist für das Parsen von HTML-Code nützlich, weil er die
Anfangs- und Ende-Tag-Struktur erkennt, die für diesen Code typisch ist. Konkret
werden Sie den EnclosedGroup-Anker dazu verwenden, dass er die Tags <tableund </table> erkennt, die eine HTML-Tabelle umgeben.
1.
Markieren Sie die drei Punkte am Ende der Ankersequenz auf der obersten
Ebene (das heißt, die Ebene, auf der der Group-Anker definiert wird, und nicht
die innerhalb des Group-Ankers eingebettete Ebene).
2.
Bearbeiten Sie das IntelliScript und fügen Sie einen EnclosedGroup-Anker ein.
3.
Nehmen Sie unter der Eigenschaft opening der EnclosedGroup folgende
Zuweisung vor: text = <table. Unter der Eigenschaft closing weisen Sie
Folgendes zu: text = </table>. Sie können diese Angaben eintippen oder mit
der Maus aus dem Beispielbereich ziehen.
39
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Im Beispielbereich sollten die Tags <table und </table> im HTML-Code
hervorgehoben sein.
4.
Jetzt fügen Sie innerhalb von EnclosedGroup Anker hinzu. Wenn Sie die
Übungen in den vorangehenden Kapiteln durchgeführt haben, müssten Sie
imstande sein, diese Aufgabe zu lösen. Wir möchten Sie bitten, es zuerst selbst
zu probieren, bevor Sie weiterlesen.
Eine mögliche Lösung lautet: Wir empfehlen, die Anker zu konfigurieren,
indem Sie das IntelliScript bearbeiten, und nicht, indem Sie die Anker in der
Beispielquelle markieren und mit der rechten Maustaste anklicken. Der
HTML-Code der Beispielquelle ist lang und verwirrend, und einige der Anker
haben nicht-standardmäßige Eigenschaften, die Sie nur im IntelliScript
konfigurieren können.
Innerhalb des
EnclosedGroupAnkers hinzufügen
Konfiguration
Erläuterung
Marker
Geht zur ersten Zeile der
Tabelle, die Sie nicht
abrufen müssen.
RepeatingGroup
Beginnt eine sich
wiederholende Gruppe in
der zweiten Zeile der
Tabelle.
Siehe weiter unten, welche
Anker innerhalb der
RepeatingGroup
einzufügen sind.)
40
Erste Schritte mit Conversion Agent, Band 2
Innerhalb des
EnclosedGroupAnkers hinzufügen
6. Word- und HTML-Dokumente parsen
Konfiguration
Marker
Erläuterung
Beendet die sich
wiederholende Gruppe und
geht zur letzten Zeile der
Tabelle.
Für die Zuweisung
count=2, blenden Sie die
erweiterten Eigenschaften
ein (siehe Mit Hilfe von
Count Mehrdeutigkeiten
ausschließen weiter unten).
Marker
Geht zur vierten Zelle in
der letzten Zeile.
Für die Zuweisung
count=3, blenden Sie die
erweiterten Eigenschaften
ein (siehe Mit Hilfe von
Count Mehrdeutigkeiten
ausschließen weiter unten).
Content
Ruft den Inhalt der vierten
Zelle in der letzten Zeile ab.
Die EnclosedGroup sollte jetzt wie folgt aussehen:
5.
Führen Sie den Befehl Beispiel markieren aus. Wenn Sie in der Beispielquelle
einen Bildlauf durchführen, sollten Sie die Farbcodierung für die oben
definierten Anker sehen.
41
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
6.
Führen Sie den Parser aus. Das Ergebnis sollte wie folgt aussehen:
7.
Erweitern Sie jetzt die RepeatingGroup und fügen Sie die folgenden Anker
innerhalb dieser Gruppe ein.
Beachten Sie, dass die vier Content-Anker sehr ähnliche Konfigurationen
aufweisen. Sie können Zeit sparen, indem Sie einen der Content-Anker
kopieren und einfügen, und die Kopien bearbeiten.
Innerhalb des
RepeatingGroupAnkers
hinzufügen
Konfiguration
Erläuterung
Content
Ruft den
Inhalt der
ersten Zelle
einer Zeile ab.
Content
Ruft den
Inhalt der
zweiten Zelle
ab.
Content
Ruft den
Inhalt der
dritten Zelle
ab.
Content
Ruft den
Inhalt der
vierten Zelle
ab.
42
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Wenn Sie damit fertig sind, sollten die EnclosedGroup und die RepeatingGroup
wie folgt aussehen:
8.
Führen Sie den Befehl Beispiel markieren aus und prüfen Sie wieder die
Farbcodierung.
43
Erste Schritte mit Conversion Agent, Band 2
9.
6. Word- und HTML-Dokumente parsen
Führen Sie den Parser aus. Das Ergebnis sollte wie folgt aussehen:
Warum die Ausgabe keinen HTML-Code enthält
Beachten Sie, dass der Parser den HTML-Code aus dem abgerufenen Text entfernt
hat.
Der erste Content-Anker innerhalb der RepeatingGroup ist beispielsweise so
konfiguriert, dass er den gesamten Text zwischen opening_marker (das heißt, <td)
und closing_marker (das heißt, </td>) abruft. Sie haben vielleicht erwartet, dass er
folgenden Text abruft:
width=168 valign=top style='width:125.9pt;border:solid windowtext
1.0pt;border-top:none;mso-border-top-alt:solid windowtext .5pt;msoborder-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt'><p
class=MsoBodyText><i style='mso-bidi-font-style:normal'>Topspin Serves
Made Easy</i>, by Roland <span class=SpellE>Fasthitter</span></p>
Genau genommen entspricht das genau der Farbcodierung im IntelliScript:
44
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Der Content-Anker ruft den gesamten Text, einschließlich HTML-Code, ab. Die
HtmlFormat-Komponente des Parsers ist jedoch mit einer Reihe von
Standardtransformern konfiguriert, die die Ausgabe des Ankers ändern.
Einer der Standardtransformer ist RemoveTags, der den HTML-Code entfernt.
Transformer
Ein Transformer ist eine Komponente, die die Ausgabe eines Ankers ändert.
Transformer werden beispielsweise dazu verwendet, Strings in der Ausgabe
hinzuzufügen oder zu ersetzen. Sie werden Transformer für diesen Zweck in den
nächsten Schritten dieser Übung einsetzen.
Die Formatkomponente eines Parsers wird üblicherweise mit einer Reihe von
Standardtransformern konfiguriert, die der Parser auf die Ausgaben aller Anker
anwendet. Zweck der Standardtransformer ist es, die Ausgabe zu bereinigen.
Die HtmlFormat-Komponente ist mit folgenden Standardtransformern ausgestattet:

RemoveTags – entfernt HTML-Code aus der Ausgabe.

HtmlEntitiesToASCII – wandelt HTML-Entitäten (wie etwa &gt: oder &amp;)
in einfache Text-Symbole um (> oder &).

HtmlProcessor – wandelt mehrfache Leerräume (Leerzeichen, Tabulatoren
oder Zeilenumbrüche) in einfache Leerräume um.

RemoveMarginSpace – löscht vorangestellte und angehängte Leerzeichen.
Weitere Informationen über die Transformer, die Ihnen Conversion Agent zur
Verfügung stellt, finden Sie unter Transformer im Conversion Agent Studio
Benutzerhandbuch.
45
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Warum verwendet der Parser nicht Delimiter, um den HTML-Code zu
entfernen?
Erinnern Sie sich an den Anker Becky Handler, den Sie am Anfang dieser Übung
definiert haben? Wir haben Ihnen erklärt, dass der Anker HTML-Code entfernt,
weil er nur die Daten nach dem Delimiter > abruft. Die Farbcodierung
veranschaulicht dies:
Das funktioniert, weil der Anker Becky Handler mit der Komponente
LearnByExample ausgestattet ist, deren Aufgabe es ist, die Delimiter in der
Beispielquelle zu interpretieren.
Bei den Content-Ankern der RepeatingGroup haben wir die LearnByExampleKomponente absichtlich weggelassen:
Die LearnByExample-Komponente hätte in diesem Fall nicht richtig funktioniert.
Das Problem dabei ist, dass die Anzahl der Delimiter in der Auftragstabelle nicht
konstant ist. In einigen Tabellenzeilen ist der Name eines Buchs kursiv formatiert.
In anderen Zeilen ist der Name nicht kursiv formatiert. In manchen
Quelldokumenten kann die Tabelle andere Formatierungsabweichungen
enthalten. Die Formatierung kann den HTML-Code verändern, einschließlich der
Anzahl und Position der Delimiter.
Deshalb haben wir die Eigenschaft value leer gelassen. Wir haben uns stattdessen
darauf verlassen, dass die Standardtransformer die Ausgabe bereinigen.
46
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Mit Hilfe von Count Mehrdeutigkeiten ausschließen
Wir haben Sie angewiesen, innerhalb der EnclosedGroup die Eigenschaft count
zwei Marker-Ankern zuzuweisen. Das diente dazu, Mehrdeutigkeiten in der
Beispielquelle auszuschließen.
Im >Total<-Anker haben wir count = 2 eingestellt. Damit verhindern wir, dass die
sich wiederholende Gruppe vorzeitig, beim ersten Auftreten des Strings >Total<,
und zwar in der Zeile mit der Spaltenüberschrift, endet. Die Eigenschaft count = 2
bedeutet, dass der Parser nach dem zweiten Auftreten von >Total< suchen soll,
und das ist in der letzten Zeile der Tabelle. Das schließt eine Mehrdeutigkeit aus.
Ein weiterer interessanter Punkt ist, dass wir den Text in Anführungszeichen
gesetzt – >Total< - und nicht einfach nur Total (ohne die Symbole > und <)
geschrieben haben. Damit schließen wir Mehrdeutigkeiten in Bezug auf das Wort
Total aus, das in der Tabellenzeile Total Tennis (video) vorkommt. Hätten wir
das nicht gemacht, würde die sich wiederholende Gruppe fälschlicherweise in der
Zeile Total Tennis (video) enden.
Das zweite Mal haben wir die Eigenschaft count im letzten <td-Referenzpunkt der
EnclosedGroup verwendet, der sich in der letzten Tabellenzeile befindet. Dort
haben wir count = 3 eingestellt, damit der Parser um drei Tabellenzellen
weitergeht. Die übersprungenen Zellen in dieser Zeile enthalten keine Daten, also
müssen wir sie nicht parsen.
Transformer verwenden, um die Ausgabe zu ändern
An dieser Stelle weist die XML-Ausgabe noch zwei kleine Probleme auf:

Einige der Buchtitel sind falsch interpunktiert. Statt
<Title>Topspin Serves Made Easy, by Roland Fasthitter</Title>
lautet die Ausgabe
<Title>Topspin Serves Made Easy , by Roland Fasthitter</Title>
Der Unterschied ist ein zusätzliches Leerzeichen vor dem Komma.

Die Preise und Summen weisen kein Währungssymbol auf:
<Price>11.40</Price>
<Total>46.19</Total>
statt
<Price>$11.40</Price>
<Total>$46.19</Total>
Sie werden für bestimmte Content-Anker Transformer anwenden. Die Transformer
ändern die Ausgabe der Anker und korrigieren diese Probleme.
Das sind zusätzliche Transformer neben den Standardtransformern, die der Parser
auf alle Anker anwendet (siehe Warum die Ausgabe keinen HTML-Code enthält weiter
oben).
47
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
1.
Erweitern Sie im IntelliScript den ersten Content-Anker der RepeatingGroup.
2.
Blenden Sie die erweiterten Eigenschaften des Content-Ankers ein und
erweitern Sie die Eigenschaft transformers.
3.
Betten Sie an den drei Punkten innerhalb der Eigenschaft transformers einen
Replace-Transformer ein
4.
Legen Sie die Eigenschaften des Replace-Transformers wie folgt fest:
find_what="TextSearch(" ,")
replace_with = ","
Mit anderen Worten, der Transformer ersetzt ein Leerzeichen, dem ein
Komma folgt, durch ein Komma.
5.
Sie werden einen AddString-Transformer verwenden, um den Preisen und
Summen das Währungssymbol voranzustellen. Sie könnten für jeden
entsprechenden Content-Anker einen eigenen AddString-Transformer
konfigurieren, aber es gibt eine einfachere Lösung. Sie können einen einzigen
AddString-Transformer als globale Komponente konfigurieren. Die globale
Komponente können Sie dann überall dort einsetzen, wo sie benötigt wird.
Um die globale Komponente zu konfigurieren, markieren Sie die drei Punkte
links vom Gleichheitszeichen auf der obersten Ebene des IntelliScript – die
Ebene, auf der MyHtmlParser und varCurrency definiert werden. Das nennt
man die globale Ebene.
48
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Drücken Sie Eingabe und geben Sie AddCurrencyUnit ein. Das ist der
Bezeichner der globalen Komponente.
6.
Drücken Sie an den zweiten drei Punkten in derselben Zeile (nach dem
Gleichheitszeichen) Eingabe. Fügen Sie einen AddString-Transformer ein.
7.
Markieren Sie die Eigenschaft pre des AddString-Transformers und drücken
Sie die Eingabetaste. Klicken Sie auf der rechten Seite des Textfeldes auf die
Schaltfläche Durchsuchen. Daraufhin wird die Schema-Ansicht angezeigt, in
der Sie einen Datenbehälter auswählen können.
Markieren Sie in der Schema-Ansicht VarCurrency.
Das bedeutet, dass der AddString-Transformer seiner Eingabe den Wert von
VarCurrency (also das Währungssymbol) voranstellen soll.
8.
Jetzt können Sie die AddCurrencyUnit-Komponente an der entsprechenden
Position in MyHtmlParser einfügen.
Blenden Sie beispielsweise die erweiterten Eigenschaften des letzten ContentAnkers in der EnclosedGroup ein (jene, die /Order/*s/Total zugeordnet ist).
Unter der Eigenschaft transformers, markieren Sie die drei Punkte und
drücken Eingabe. In der Dropdown-Liste wird die globale Komponente
AddCurrencyUnit angezeigt, die Sie gerade definiert haben. Markieren Sie die
globale Komponente. Damit wird der Transformer auf den Anker
angewendet.
49
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Das Ergebnis sollte wie folgt aussehen:
Fügen Sie auf dieselbe Weise AddCurrencyUnit in die Eigenschaft
transformers des zweiten und vierten Content-Ankers in der RepeatingGroup
ein (die Price beziehungsweise Total zugeordnet sind).
9.
Führen Sie den Parser aus. Das Ergebnis sollte wie folgt aussehen:
50
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Beachen Sie, dass das Element Title kein zusätzliches Leerzeichen vor dem
Komma enthält. Die Elemente Price und Total enthalten das $-Zeichen. Das
ist auf die von Ihnen definierten Transformer zurückzuführen.
Globale Komponenten
Globale Komponenten sind nützlich, wenn Sie dieselbe
Komponentenkonfiguration in einem Projekt mehrfach benötigen.
Sie können jede Conversion-Agent-Komponente, zum Beispiel einen Transformer,
eine Aktion oder einen Anker, als globale Komponente definieren Der Bezeichner
der globalen Komponente scheint in der Dropdown-Liste an den entsprechenden
Stellen im IntelliScript auf. Die globale Komponente können Sie wie jede andere
Komponente verwenden.
In dieser Übung haben Sie drei globale Komponenten definiert:

Den Parser namens MyHtmlParser, den Sie mit Hilfe des Assistenten definiert
haben.

Die Variable VarCurrency, die Sie am Anfang der Übung definiert haben.

Den Transformer AddCurrencyUnit, den Sie am Ende der Übung hinzugefügt
haben.
51
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Den Parser mit einem anderen Quelldokument testen
Als letzten Schritt wollen wir den Parser mit dem Quelldokument
OrderWithoutCurrency.doc testen. Dieses Dokument ist identisch mit der
Beispielquelle (Order.doc), abgesehen davon, dass ihm die optionale
Währungszeile fehlt.
Dieser Test soll bestätigen, dass der Parser ein Dokument richtig verarbeitet, wenn
die Währungszeile fehlt.
1.
Blenden Sie die erweiterten Eigenschaften von MyHtmlParser ein.
2.
Weisen Sie der Eigenschaft sources_to_extract den Wert LocalFile zu.
Das bedeutet, dass der Parser, anstelle der Beispielquelle, eine Datei auf dem
lokalen Computer verarbeiten soll.
3.
Bearbeiten Sie die Eigenschaft file_name und suchen Sie die Datei
OrderWithoutCurrency.doc.
4.
Blenden Sie die erweiterten Eigenschaften von LocalFile ein, und weisen Sie
pre_processor = WordToHtml zu.
Das bedeutet, dass der Conversion Agent den WordToHtml-Prozessor an
diesem Dokument ausführen soll, bevor es geparst wird.
5.
Führen Sie den Parser aus. Die Ausgabe sollte der obigen Ausgabe
entsprechen, abgesehen davon, dass den Preisen und Summen kein $-Zeichen
vorangestellt ist.
52
Erste Schritte mit Conversion Agent, Band 2
6.
6. Word- und HTML-Dokumente parsen
Wenn Sie fertig sind, können Sie die Eigenschaft sources_to_extract löschen.
Dabei handelt es sich um eine temporäre Einstellung, die Sie nur für das
Testen des Parsers benötigen.
Woran Sie denken sollten
Um ein Microsoft Word-Dokument zu parsen, können Sie einen Dokumentprozessor,
wie WordToHtml verwenden, der das Dokument in ein HTML-Format umwandelt,
das für das Parsen besser geeignet ist.
Um HTML-Code zu parsen, können Sie den EnclosedGroup-Anker oder die
Eigenschaften opening_marker und closing_marker des Content-Ankers
verwenden. Diese Methoden machen sich die typische Anfangs- und Ende-TagStruktur des HTML-Formats zunutze. Wenn Sie ein HTML-Tag als Marker-Anker
definieren, wählen Sie die Eigenschaft match_case lieber nicht, weil HTML nicht
zwischen Groß- und Kleinschreibung unterscheidet.
Um Mehrdeutigkeiten auszuschließen, wenn derselbe Text mehrfach vorkommt,
können Sie die Eigenschaft count eines Marker-Ankers verwenden.
Verwenden Sie Variablen, um abgerufene Daten zu speichern, die Sie in der XMLAusgabe eines Parsers nicht anzeigen wollen. Variablen sind nützlich als Eingabe
für andere Komponenten.
53
Erste Schritte mit Conversion Agent, Band 2
6. Word- und HTML-Dokumente parsen
Verwenden Sie Transformer, um die Ausgabe der Anker zu ändern. Sie können
Standardtransformer auf alle Anker anwenden oder Sie können Transformer auf
bestimmte Anker anwenden.
Um HTML-Tags von der Parsing-Ausgabe auszuschließen, können Sie die Anker
entweder mit Delimitern definieren oder sich darauf verlassen, dass die
Standardtransformer den Code entfernen.
Globale Komponenten sind nützlich, wenn Sie dieselbe Komponentenkonfiguration
mehrmals benötigen.
Um einen Parser mit weiteren Dokumenten zu testen (mit anderen Dokumenten als der
Beispielquelle), weisen Sie die Eigenschaft sources_to_extract zu. Vergessen Sie
nicht, dem Dokument einen Dokumentprozessor zuzuweisen, falls es einen
benötigt.
54
Erste Schritte mit Conversion Agent, Band 2
7
7. Einen Serializer definieren
Einen Serializer definieren
In den vorangehenden Übungen haben Sie Parser definiert, die Dokumente
verschiedener Formate in XML umwandeln. In dieser Übung werden Sie einen
Serializer erstellen. Dieser funktioniert umgekehrt, das heißt, er wandelt XML in
andere Formate um.
Für gewöhnlich ist es einfacher, einen Serializer zu definieren als einen Parser. Der
Grund dafür ist, dass es sich bei der Eingabe um ein komplett strukturiertes,
eindeutiges XML-Dokument handelt.
Der Serializer, den Sie definieren werden, ist sehr einfach. Er enthält nur vier
Serialisierungsanker (das Gegenteil der Anker, die Sie beim Parsen verwenden).
Trotzdem gibt es beim Serializer ein paar interessante Punkte:

Der Serializer ist rekursiv. Das heißt, er ruft sich selbst wiederholt auf, um die
eingebetteten Abschnitte eines XML-Dokuments zu serialisieren.

Die Ausgabe des Serializers ist ein Arbeitsblatt, das Sie in Excel öffnen
können.
Sie werden den Serializer definieren, indem Sie das IntelliScript bearbeiten. Es ist
auch möglich, einen Serializer automatisch zu generieren, indem Sie einen ParsingVorgang einfach umkehren. Weitere Informationen finden Sie im Kapitel Serializer
im Conversion Agent Studio Benutzerhandbuch.
Voraussetzungen:
Die Ausgabe dieser Übung ist eine *.csv (Comma Separated Values) Datei. Sie
können die Ausgabe im Microsoft Editor öffnen, aber am sinnvollsten ist es, sie in
Microsoft Excel anzuzeigen.
Um den Serializer auszuführen, benötigen Sie Excel nicht. Wir empfehlen es nur,
um die Ausgabe anzusehen.
Anforderungsanalyse
Das XML-Eingabedokument ist:
tutorials\Exercises\Files_For_Tutorial_5\FamilyTree.xml
55
Erste Schritte mit Conversion Agent, Band 2
7. Einen Serializer definieren
Das Dokument stellt einen Stammbaum in XML dar. Beachten Sie, dass die
Struktur an sich schon rekursiv ist: jedes Person-Element kann ein ChildrenElement enthalten, das wiederum mehrere Person-Elemente enthält.
<Person>
<Name>Jake Dubrey</Name>
<Age>84</Age>
<Children>
<Person>
<Name>Mitchell Dubrey</Name>
<Age>52</Age>
</Person>
<Person>
<Name>Pamela Dubrey McAllister</Name>
<Age>50</Age>
<Children>
<Person>
<Name>Arnold McAllister</Name>
<Age>26</Age>
</Person>
</Children>
</Person>
</Children>
</Person>
Unser Ziel ist es, Namen und Alter der Person-Elemente als *.csv-Datei mit
folgender Struktur auszugeben:
Jake Dubrey,84
Mitchell Dubrey,52
Pamela Dubrey McAllister,50
Arnold McAllister,26
Excel stellt die Ausgabe in einem Arbeitblatt wie folgt dar:
56
Erste Schritte mit Conversion Agent, Band 2
7. Einen Serializer definieren
Das Projekt anlegen
Um den Serializer zu erstellen, führen Sie folgende Schritte durch:
1.
Wählen Sie im Conversion Agent Studio-Menü Datei > Neu > Projekt.
2.
Markieren Sie im linken Bereich des Fensters Neues Projekt den Eintrag
Conversion Agent Im rechten Bereich wählen Sie Serializer-Projekt.
3.
Legen Sie auf den nachfolgenden Seiten des Assistenten die folgenden
Optionen fest:
a. Geben Sie dem Projekt den Namen Tutorial_5.
b. Geben Sie dem Serializer den Namen FamilyTreeSerializer.
c. Geben Sie der Skriptdatei den Namen Serializer_Script.
4.
Auf der Schema-Seite suchen Sie nach dem Schema FamilyTree.xsd, das sich
im Ordner tutorials\Exercises\Files_For_Tutorial_5 befindet.
Das Schema definiert die Struktur des XML-Eingabedokuments. Wenn Sie mit
XSD nicht vertraut sind, können Sie das Schema in einem XSD-Editor oder im
Microsoft Editor öffnen und untersuchen, wie die rekursive Datenstruktur
definiert wird.
5.
Wenn Sie mit dem Assistenten fertig sind, zeigt der Conversion-AgentExplorer das neue Projekt an. Doppelklicken Sie auf die
Serializer_Script.tgp-Datei, um sie zu bearbeiten.
6.
Im Gegensatz zu einem Parser hat ein Serializer keine Beispielquelle. Sie
können den leeren Beispielbereich des IntelliScript-Editors ausblenden, wenn
Sie möchten.
Wählen Sie dafür den Menübefehl IntelliScript > IntelliScript aus oder klicken
Sie die Schaltfläche nur IntelliScript-Bereich anzeigen in der Symbolleiste an. Um
den Beispielbereich wiederherzustellen, wählen Sie IntelliScript > Beide oder
klicken die Schaltfläche mit der Bezeichnung IntelliScript und Beispielbereich
anzeigen an.
57
Erste Schritte mit Conversion Agent, Band 2
7.
7. Einen Serializer definieren
Um den Serializer zu entwerfen, verwenden Sie das FamilyTree.xmlEingabedokument, dessen Inhalt oben dargestellt ist.
Obwohl es nicht unbedingt erforderlich ist, wäre es eine gute Idee, alle
Dateien, mit denen Sie ein Projekt entwerfen und testen, im Projektordner zu
verwalten, der sich in Ihrem Eclipse-Workspace befindet. Wir empfehlen, die
Datei FamilyTree.xml aus dem Ordner
tutorials\Exercises\Files_For_Tutorial_5
in den Projektordner zu kopieren. Dessen Standardspeicherort ist:
Eigene Dateien\SAP\ConversionAgent\4.0\workspace\Tutorial_5
Speicherort des Projektordners bestimmen
Es kann sein, dass sich Ihr Projektordner aus einem der folgenden Gründe nicht an
seinem standardmäßigen Speicherort befindet:

Sie haben im Assistenten Neues Projekt einen nicht standardmäßigen
Speicherort gewählt.

Eclipse ist bei Ihnen so konfiguriert, dass es einen nicht standardmäßigen
Workspace-Speicherort verwendet.
Sie können den Speicherort des Projektordners bestimmen, indem Sie das Projekt
im Conversion-Agent-Explorer markieren und den Befehl Datei > Eigenschaften
wählen. Alternativ dazu können Sie im IntelliScript-Editor klicken und den Befehl
Projekt > Eigenschaften wählen. Die Registerkarte Info des Eigenschaftenfensters
zeigt den Speicherort an.
Projekteigenschaften
Das Eigenschaftenfenster zeigt viele nützliche Optionen an, wie zum Beispiel die
Eingabe- und Ausgabecodierung, die in Ihren Dokumenten verwendet wird, und
die XML-Validierungsoptionen. Weitere Informationen finden Sie unter
Projekteigenschaften im Conversion Agent Studio Benutzerhandbuch.
58
Erste Schritte mit Conversion Agent, Band 2
7. Einen Serializer definieren
Den Serializer konfigurieren
Jetzt können Sie die Serializer-Eigenschaften konfigurieren und die
Serialisierungsanker hinzufügen. Dazu müssen Sie das IntelliScript bearbeiten.
Eine Methode wie das Markieren und Klicken, die Sie zum Konfigurieren von
Parsern verwendet haben, gibt es hier nicht.
1.
Blenden Sie die erweiterten Eigenschaften des Serializers ein und legen Sie
output_file_extension = .csv fest (mit einem vorangestellten Punkt).
Wenn Sie den Serializer in Conversion Agent Studio ausführen, erhält die
Ausgabedatei dadurch den Namen output.csv. Standardmäßig können *.csvDateien in Microsoft Excel geöffnet werden.
2.
Fügen Sie im Serializer unter der Zeile contains einen ContentSerializerSerialisierungsanker ein, und konfigurieren Sie seine Eigenschaften wie folgt:
data_holder = /Person/*s/Name
closing_str = ","
Das bedeutet, dass der Serialisierungsanker den Inhalt des Datenbehälters
/Person/*s/Name in die Ausgabedatei schreibt. Er hängt den Endestring ","
(ein Komma) an.
3.
Definieren Sie, wie unten dargestellt, einen zweiten ContentSerializerSerialisierungsanker:
59
Erste Schritte mit Conversion Agent, Band 2
7. Einen Serializer definieren
Dieser ContentSerializer schreibt den Datenbehälter /Person/*s/Age in die
Ausgabe. Er hängt einen Wagenrücklauf (ASCII-Code 013) und einen
Zeilenvorschub (ASCII 010) an die Ausgabe an.
Um die ASCII-Codes einzugeben, machen Sie Folgendes:
a. Markieren Sie die Eigenschaft closing_str und drücken Sie Eingabe.
b. Drücken Sie die Tasten Strg+a. Daraufhin erscheint im Textfeld ein kleiner
Punkt.
c. Geben Sie 013 ein.
d. Drücken Sie wieder Strg+a.
e. Geben Sie 010 ein.
f. Drücken Sie die Eingabetaste, um die Eigenschaftszuweisung
abzuschließen.
4.
Führen Sie den Serializer aus. Gehen Sie dazu wie folgt vor:
a. Legen Sie den Serializer als Startkomponente fest.
b. Wählen Sie im Menü den Befehl Ausführen > Ausführen.
c. Suchen Sie an der Eingabeaufforderung nach der Testeingabedatei
FamilyTree.xml.
d. Wenn der Serializer fertig ist, überprüfen Sie die Ereignisansicht nach
Fehlern.
e. Doppelklicken Sie in der Explorer-Ansicht von Conversion Agent unter
Results auf output.csv, um die Ausgabe anzuzeigen.
Vorausgesetzt, dass Excel auf dem Computer installiert ist, zeigt der
Conversion Agent ein Excel-Fenster wie das Folgende an:
60
Erste Schritte mit Conversion Agent, Band 2
7. Einen Serializer definieren
Wenn Excel auf dem Computer nicht installiert ist, können Sie die
Ausgabedatei im Microsoft Editor anzeigen. Alternativ dazu können Sie die
Datei auf einen anderen Computer kopieren, auf dem Excel installiert ist, und
sie dort öffnen.
Den Serializer rekursiv aufrufen
Bisher enthält das Ergebnis nur das Element Person der obersten Ebene. Sie
müssen den Serializer so konfigurieren, dass er tiefer in die XML-Baumstruktur
eindringt und die Person-Elemente der Kinder verarbeitet.
Gehen Sie dazu wie folgt vor:
1.
Fügen Sie einen RepeatingGroupSerializer-Serialisierungsanker ein.
Sie können diesen Serialisierungsanker dazu verwenden, um über eine sich
wiederholende Struktur in der Eingabe zu iterieren und eine sich
wiederholende Struktur in der Ausgabe zu generieren. In diesem Fall iteriert
der RepeatingGroupSerializer über alle Person-Elemente auf einer
bestimmten eingebetteten Ebene.
2.
Betten Sie innerhalb des RepeatingGroupSerializer einen EmbeddedSerializer
ein. Zweck dieses Serialisierungsankers ist es, einen sekundären Serializer
aufzurufen.
61
Erste Schritte mit Conversion Agent, Band 2
3.
7. Einen Serializer definieren
Weisen Sie dem EmbeddedSerializer die unten dargestellten Eigenschaften zu.
Die Eigenschaften haben folgende Bedeutung:
- Die Zuweisung serializer = FamilyTreeSerializer bedeutet, dass der
sekundäre Serializer dem HauptSerializer entspricht. Anders ausgedrückt,
der Serializer ruft sich selbst rekursiv auf.
- Die Eigenschaft schema_connections bedeutet, dass der sekundäre
Serializer /Person/*s/Children/*s/Person so verarbeiten soll, als handle es
sich dabei um ein /Person-Element der obersten Ebene. Auf diese Weise
bewegt sich der Serializer durch die Generationen des Stammbaums.
- Die Eigenschaft optional bedeutet, dass der sekundäre Serializer nicht dazu
führt, dass der HauptSerializer fehlschlägt, wenn ihm die Daten ausgehen.
4.
Führen Sie den Serializer erneut aus. Das Ergebnis sollte wie folgt aussehen:
Mehrere Komponenten in einem Projekt definieren
Beim Ausführen eines sekundären Serializer erhebt sich eine Frage, die wir bisher
noch nicht behandelt haben.
62
Erste Schritte mit Conversion Agent, Band 2
7. Einen Serializer definieren
In allen Übungen dieses Buches enthält jedes Projekt, der Einfachheit halber, nur
einen einzigen Parser, Serializer oder Mapper. We did this for simplicity.
Es ist aber durchaus möglich, dass ein einziges Projekt mehrere Komponenten
enthält, wie etwa:

Mehrere Parser, Serializer oder Mapper

Mehrere (TGP) Skriptdateien

Mehrere XSD-Schemas
Wir haben keine Übung zu diesem Thema für Sie, aber Anweisungen dazu finden
Sie im Conversion Agent Studio Benutzerhandbuch. Die folgenden Absätze bieten eine
kurze Zusammenfassung.
Mehrere Parser und Serializer
Um mehrere Parser, Serializer oder Mapper zu definieren, fügen Sie diese einfach
auf der globalen Ebene des IntelliScript ein. Hier ist ein Beispiel:
Um einen der Parser oder Serializer auszuführen, legen Sie ihn als
Startkomponente fest und verwenden die Befehle des Menüs Ausführen.
Die Startkomponente kann sekundäre Parser, Serializer oder Mapper aufrufen, um
Teile eines Dokuments zu verarbeiten. Das haben Sie in dieser Übung gemacht
(mit dem interessanten Trick, dass Haupt- und sekundärer Serializer identisch
waren – ein rekursiver Aufruf).
Mehrere Skriptdateien
Sie können mehrere Skriptdateien verwenden, um Ihre Arbeit zu organisieren.
Um eine Skriptdatei zu erstellen, klicken Sie den Scripts-Knoten im ConversionAgent-Explorer mit der rechten Maustaste an und wählen Neu > Skript. Um ein
Skript hinzuzufügen, das Sie in einem anderen Projekt erstellt haben, wählen Sie
Datei hinzufügen.
Um eine Skriptdatei zur Bearbeitung zu öffnen, klicken Sie die Datei im
Conversion-Agent-Explorer doppelt an.
Mehrere XSD-Schemas
Um einem Projekt mehrere Schemas hinzuzufügen, klicken Sie den XSD-Knoten im
Conversion-Agent-Explorer mit der rechten Maustaste an und wählen Datei
hinzufügen. Um ein leeres XSD-Schema anzulegen, das Sie in einem beliebigen
Editor bearbeiten können, wählen Sie Neu > XSD.
63
Erste Schritte mit Conversion Agent, Band 2
7. Einen Serializer definieren
Woran Sie denken sollten
Ein Serializer ist das Gegenteil eines Parsers: er wandelt XML in andere Formate
um.
Sie können einen Serializer erstellen, indem Sie ihn aus einem bestehenden Parser
generieren oder das IntelliScript bearbeiten. Ein Serializer enthält
Serialisierungsanker, die den Ankern entsprechen, die Sie in einem Parser
verwenden, aber in der umgekehrten Richtung funktionieren.
In einem IntelliScript-Editor können Sie die Bereiche ein- oder ausblenden, indem Sie
die entsprechenden Befehle im IntelliScript-Menü oder auf der Symbolleiste
wählen.
Wir empfehlen, alle zu einem Projekt gehörenden Dateien im Projektordner zu
speichern, der sich in Ihrem Eclipse-Workspace befindet. Den Speicherort des
Ordners können Sie mit Hilfe des Befehls Datei > Eigenschaften oder Projekt >
Eigenschaften bestimmen.
Ein einzelnes Projekt kann mehrere Parser, Serializer, Mapper, Skriptdateien, XSDDateien usw. enthalten. Die Startkomponente kann sekundäre Serializer, Parser oder
Mapper aufrufen, die im selben Projekt definiert sind und Teile eines Dokuments
verarbeiten. Ein rekursiver Aufruf (eine Komponente, die sich selbst aufruft) ist
möglich.
Sie können einen Serializer entwerfen, der Ausgaben in einem beliebigen Datenformat,
zum Beispiel, Microsoft Excel, erstellt.
64
Erste Schritte mit Conversion Agent, Band 2
8
8. Einen Mapper definieren
Einen Mapper definieren
Bisher haben Sie mit zwei wesentlichen Conversion-Agent-Komponenten
gearbeitet. Mit Parsern haben Sie Dokumente beliebigen Formats in XML
umgewandelt. Mit Serializern haben Sie XML-Dokumente in andere Formate
verwandelt.
In diesem Kapitel werden Sie mit einem Mapper arbeiten, der Umwandlungen von
XML zu XML durchführt. Zweck dieses Arbeitsschrittes ist es, die XML-Struktur
oder das Vokabular der Daten zu ändern.
Das Mapper-Design ist dem von Parsern und Serializern ähnlich. Innerhalb der
Mapper-Hauptkomponente können Sie Mapper-Anker, Map -Aktionen und andere
Komponenten, die Mapping-Operationen ausführen, einbetten.
In dieser Übung wird ein einfacher Mapper präsentiert, der einen
zusammenfassenden XML-Bericht generiert. Neben anderen Funktionen
demonstriert die Übung, wie Sie ein anfangs leeres Projekt konfigurieren, das Sie
mit dem Assistenten Leeres Projekt anlegen. Mit einem leeren Projekt können Sie
zusätzlich zu Mappern auch jede andere Art von Datenumwandlung
konfigurieren.
Anforderungsanalyse
Ziel dieser Übung ist es, eine bestehende XML-Datei heranzuziehen und eine neue
XML-Datei mit einer veränderten Datenstruktur zu generieren. Die Dateien
befinden sich im folgenden Ordner:
tutorials\Exercises\Tutorial_6
XML-Eingabe
Die Eingabe des Mappers ist eine XML-Datei (Input.xml), die Kennnummer und
Namen mehrerer Personen aufzeichnet. Die Eingabe entspricht dem Schema
Input.xsd.
<Persons>
<Person ID="10">Bob</Person>
<Person ID="17">Larissa</Person>
<Person ID="13">Marie</Person>
</Persons>
65
Erste Schritte mit Conversion Agent, Band 2
8. Einen Mapper definieren
XML-Ausgabe
Die erwartete XML-Ausgabe ist ein zusammenfassender Bericht
(ExpectedOutput.xml), der die Namen und Kennnnummern separat auflistet. Die
Ausgabe entspricht dem Schema Output.xsd.
<SummaryData>
<Names>
<Name>Bob</Name>
<Name>Larissa</Name>
<Name>Marie</Name>
</Names>
<IDs>
<ID>10</ID>
<ID>17</ID>
<ID>13</ID>
</IDs>
</SummaryData>
Das Projekt anlegen
Um den Mapper zu erstellen, beginnen Sie mit einem leeren Conversion-AgentProjekt:
1.
Wählen Sie im Conversion Agent Studio-Menü Datei > Neu > Projekt.
2.
Markieren Sie im linken Bereich Conversion Agent. Im rechten Bereich
markieren Sie Leeres Projekt.
3.
Geben Sie dem Projekt im Assistenten den Namen Tutorial_6 und klicken Sie
auf Fertigstellen.
4.
Erweitern Sie das Projekt im Conversion-Agent-Explorer. Beachten Sie, dass es
eine Standard-TGP-Skriptdatei enthält, aber keine XSD-Schemas oder andere
Komponenten.
66
Erste Schritte mit Conversion Agent, Band 2
8. Einen Mapper definieren
5.
Klicken Sie den XSD-Knoten mit der rechten Maustaste an und wählen Sie
Datei hinzufügen. Fügen Sie die Schemas Input.xsd und Output.xsd hinzu. Es
werden beide Schemas benötigt, weil Sie sowohl die Struktur der XMLEingabe als auch der XML-Ausgabe definieren müssen.
6.
Beachten Sie, dass die Schema-Ansicht die Elemente anzeigt, die in beiden
Schemas definiert sind. Sie werden für die Eingabe mit dem Persons-Zweig
der Baumstruktur arbeiten und für die Ausgabe mit dem SummaryData-Zweig.
7.
Wir empfehlen, die Testdokumente Input.xml und ExpectedOutput.xml in den
Projektordner zu kopieren. Standardmäßig ist das folgender Ordner:
Eigene Dateien\SAP\ConversionAgent\4.0\workspace\Tutorial_6
Den Mapper konfigurieren
Um den Mapper zu konfigurieren und die Mapper-Anker einzufügen, führen Sie
folgende Schritte aus:
1.
Öffnen Sie die Skriptdatei, die standardmäßig den Namen Tutorial_6.tgp
trägt, in einem IntelliScript-Editor.
2.
Wenn Sie möchten, können Sie die Befehle im IntelliScript-Menü oder in der
Symbolleiste verwenden, um nur den IntelliScript-Bereich anzuzeigen. Ein
Mapper verwendet keine Beispielquelle, also brauchen Sie den Beispielbereich
nicht.
67
Erste Schritte mit Conversion Agent, Band 2
8. Einen Mapper definieren
3.
Definieren Sie eine globale Komponente namens Mapper1, und bestimmen Sie
sie als Typ Mapper. (Um dieses Thema nochmals nachzulesen, siehe Globale
Komponenten in Kapitel 6, Word- und HTML-Dokumente parsen.)
4.
Weisen Sie dem Mapper die Eigenschaften source und target, wie unten
dargestellt, zu. Die Eigenschaften definieren die Schemazweige, in denen der
Mapper seine Eingabe abruft und seine Ausgabe speichert.
5.
Fügen Sie im Mapper unter der Zeile contains eine RepeatingGroupMappingKomponente ein. Diesen Mapper-Anker verwenden Sie, um über die sich
wiederholenden XML-Strukturen in der Ein- und Ausgabe zu iterieren.
6.
Fügen Sie innerhalb der RepeatingGroupMapping-Komponente zwei MapAktionen ein. Zweck dieser Aktionen ist es, die Daten von der Eingabe in die
Ausgabe zu kopieren.
68
Erste Schritte mit Conversion Agent, Band 2
8. Einen Mapper definieren
Konfigurieren Sie die Eigenschaft source jeder Map-Aktion so, dass sie einen
Datenbehälter aus der Eingabe abruft. Konfigurieren Sie die Eigenschaft
target so, dass sie den entsprechenden Datenbehälter in die Ausgabe schreibt.
7.
Legen Sie den Mapper als Startkomponente fest und führen Sie ihn aus.
Überprüfen Sie die Ereignisansicht nach Fehlern.
8.
Vergleichen Sie die Ergebnisdatei, die den Namen output.xml trägt, mit
ExpectedOutput.xml. Wenn Sie den Mapper richtig konfiguriert haben, sollten
die Dateien identisch sein (abgesehen vielleicht von der <?xml?>Verarbeitungsdeklaration, die von den Optionen in den Projekteigenschaften
abhängt).
69
Erste Schritte mit Conversion Agent, Band 2
8. Einen Mapper definieren
Woran Sie denken sollten
Ein Mapper wandelt ein XML-Quelldokument in ein XML-Ausgabedokument,
entsprechend einem anderen Schema, um.
Sie können einen Mapper erstellen, indem Sie ein leeres Projekt im IntelliScript
bearbeiten. Ein Mapper enthält Mapper-Anker, die den Ankern, die Sie in einem
Parser verwenden, oder den Serialisierungsankern in einem Serializer entsprechen.
Er verwendet Map-Aktionen, um die Daten von der Eingabe in die Ausgabe zu
kopieren.
70
Erste Schritte mit Conversion Agent, Band 2
9
9. Conversion Agent Engine ausführen
Conversion Agent Engine ausführen
Nachdem Sie eine Datenumwandlung erstellt und getestet haben, müssen Sie sie
vom Entwicklungsstadium in das Produktionsstadium übertragen. Dafür sind im
Wesentlichen zwei Schritte notwendig:
1.
Stellen Sie die Datenumwandlung in Conversion Agent Studio als einen
Conversion-Agent-Dienst bereit. Auf diese Weise steht er in ConversionAgent Engine zum Ausführen zur Verfügung.
2.
Starten Sie eine Anwendung, die Conversion Agent Engine aktiviert und den
Dienst ausführt.
In diesem Tutorial führen Sie diesen Vorgang für den HL7-Parser durch, den Sie in
Kapitel 4, unter, Einen HL7-Parser definieren, erstellt haben. Wenn Sie möchten,
können Sie die Übung mit jedem anderen Parser oder Serializer, den Sie
vorbereitet haben, durchführen.
Bei der Anwendung, die Conversion Agent Engine aktiviert, handelt es sich um
ein einfaches Microsoft Visual Basic 6-Proramm, das das Conversion Agent COM
API aufruft. Jenen Conversion-Agent-Anwendern, die Visual Basic eventuell nicht
besitzen, stellen wir sowohl den Quellcode als auch das kompilierte Programm zur
Verfügung.
Als Alternative zur Methode, die Sie in diesem Tutorial lernen werden, können Sie
Conversion Agent-Dienste wie folgt ausführen:

Von der Befehlszeile (siehe Conversion Agent Engine Entwicklerhandbuch)

Indem Sie die Conversion Agent Java-, C- oder C++-APIs verwenden (siehe
Conversion Agent Engine Entwicklerhandbuch)

Indem Sie das Conversion Agent-Prozessmodul für SAP XI verwenden (siehe
Handbuch Conversion Agent bereitstellen und benutzen)

Indem Sie die CGI-Weboberfläche verwenden (siehe Conversion Agent Engine
Entwicklerhandbuch)
71
Erste Schritte mit Conversion Agent, Band 2
9. Conversion Agent Engine ausführen
Einen Parser als einen Dienst bereitstellen
Einen Conversion-Agent-Dienst bereitstellen bedeutet, Conversion Agent Engine
eine Datenumwandlung zur Verfügung zu stellen. Standardmäßig ist der
Speicherort für das Repository:
c:\Programme\SAP\ConversionAgent\ServiceDB
Beachten Sie, dass es keine Beziehung zwsichen Conversion-Agent-Diensten und
Windows-Diensten gibt. Sie können Conversion-Agent-Dienste nicht in der
Windows Systemsteuerung ansehen oder verwalten.
Um eine Datenumwandlung als einen Dienst bereitzustellen, machen Sie
Folgendes:
1.
Markieren Sie das Projekt im Conversion-Agent-Explorer . Wir schlagen vor,
dass Sie das Projekt Tutorial_2 verwenden, das Sie in Kapitel 4, unter Einen
HL7-Parser definieren vorbereitet haben.
2.
Bestätigen Sie, dass die Startkomponente markiert ist und dass die
Datenumwandlung richtig ausgeführt wird.
3.
Wählen Sie im Conversion-Agent-Menü den Befehl Projekt > Bereitstellen.
4.
Im Fenster Dienst bereitstellen werden die Details zum Dienst angezeigt. Sie
können die Informationen, wenn erforderlich, bearbeiten.
5.
Klicken Sie auf die Schaltfläche Bereitstellen.
6.
Blenden Sie im Conversion Agent Studio-Fenster unten links die RepositoryAnsicht ein. Die Ansicht listet den Dienst auf, den Sie bereitgestellt haben,
sowie alle anderen Conversion-Agent-Dienste, die bisher auf dem Computer
bereitgestellt wurden.
Conversion Agent COM API-Anwendung
Um zu demonstrieren, wie ein Conversion Agent-Dienst von einer APIAnwendung aus ausgeführt wird, stellen wir eine Beispielanwendung bereit, die
die Conversion Agent COM-API aufruft. Die Anwendung ist in Microsoft Visual
Basic 6.0 programmiert. Der Quellcode und die kompilierte ausführbare Datei sind
in folgendem Ordner gespeichert:
tutorials\Exercises\CMComApiTutorial
Die Anwendung wird in den folgenden Absätzen beschrieben.
Quellcode
Die Visual Basic-Anwendung zeigt folgendes Formular an:
72
Erste Schritte mit Conversion Agent, Band 2
9. Conversion Agent Engine ausführen
Der Anwender gibt den Pfad des Quelldokuments an, den Pfad des
Ausgabedokuments und den Namen eines Conversion-Agent-Dienstes. Wenn der
Anwender auf die Schaltfläche Ausführen klickt, führt die Anwendung folgenden
Code aus:
Private Sub cmdRun_Click()
Dim objCMEngine As CM_COM3Lib.CMEngine
Dim objCMRequest As CM_COM3Lib.CMRequest
Dim objCMStatus As CM_COM3Lib.CMStatus
Dim strRequest As String
Dim strOutput As String
Dim strStatus As String
'Engine
'Request generation
'Status display
'Request string
'Output string (not used in this sample)
'Status string
'Check for the required input
If txtSource = "" Then
MsgBox "Please enter the path of the source document"
Exit Sub
End If
If txtOutput = "" Then
MsgBox "Please enter the path of the output document"
Exit Sub
End If
If txtService = "" Then
MsgBox "Please enter the name of a deployed service"
Exit Sub
End If
Me.MousePointer = vbHourglass
'Initialize Engine
Set objCMEngine = New CM_COM3Lib.CMEngine
objCMEngine.InitEngine
'Generate a request string
73
Erste Schritte mit Conversion Agent, Band 2
9. Conversion Agent Engine ausführen
Set objCMRequest = New CM_COM3Lib.CMRequest
strRequest = objCMRequest.Generate( _
txtService.Text, _
objCMRequest.FileInput(txtSource.Text), _
objCMRequest.FileOutput(txtOutput.Text), _
"", "", "")
'Execute the request
strStatus = objCMEngine.Exec(strRequest, "", "", strOutput)
'Display the status
Set objCMStatus = New CM_COM3Lib.CMStatus
Call MsgBox( _
"Return code = " & objCMStatus.IsGood(strStatus) & vbCr & _
objCMStatus.GetDescription(strStatus), _
vbOKOnly, "Service Status")
Me.MousePointer = vbDefault
Set objCMEngine = Nothing
Set objCMRequest = Nothing
Set objCMStatus = Nothing
End Sub
Erläuterung der API-Aufrufe
Das Visual Basic-Beispiel verwendet drei Conversion Agent COM API-Objekte:
CMRequest
Generiert einen Anfrage-String, der den Namen des Dienstes, die Eingabe, die
Ausgabe und andere Details über die Operationen angibt, die Conversion
Agent Engine durchführen soll.
CMEngine
Führt die Anfrage aus und generiert die Ausgabe.
CMStatus
Zeigt Informationen über das Ergebnis der Conversion Agent EngineOperation an, wie zum Beispiel einen Rückgabewert und Fehlermeldungen.
Um diese, im Beispiel dargelegten Objekte zu verwenden, gehen Sie wie folgt vor.
Die Vorgehensweise ist bei allen Conversion Agent COM API-Anwendungen
ähnlich.
1.
Definieren Sie die Anfrage-Parameter, wie etwa Speicherort der Eingabe,
Speicherort der Ausgabe und Name des Conversion-Agent-Dienstes.
2.
Verwenden Sie CMRequest, um einen Anfrage-String zu generieren.
3.
Verwenden Sie CMEngine, um die Anfrage auszuführen.
74
Erste Schritte mit Conversion Agent, Band 2
4.
9. Conversion Agent Engine ausführen
Verwenden Sie CMStatus, um zu bestätigen, dass die Anfrage erfolgreich
ausgeführt wurde.
Weitere Informationen
Umfassende Informationen über das COM API finden Sie in der Conversion Agent
COM API-Referenz.
Die COM API-Anwendung ausführen
Vorausgesetzt, dass Sie die Visual Basic 6.0 Laufzeitbibliothek auf Ihrem Computer
haben (was für die meisten Windows-Computer zutrifft), können Sie die Visual
Basic Beispielanwendung ausführen. Wenn es sich um eine
Produktionsanwendung handelte, würden wir sie natürlich in eine Setup-Datei
stellen, die die erforderliche Laufzeitbibliothek enthält.
1.
Führen Sie in Ihrer Arbeitskopie des Ordners Tutorials folgende Datei aus:
Tutorials\Exercises\CMComApiTutorial\CMComApiTutorial.exe
2.
Geben Sie den vollständigen Pfad des Quelldokuments und des
Ausgabedokuments ein. Geben Sie den Namen des Conversion-AgentDienstes ein, den Sie bereitgestellt haben (standardmäßig ist das der Name des
Projekts).
Um beispielsweise den HL7-Beispielparser auszuführen, kopieren Sie das
Quelldokument hl7-obs.txt in das Verzeichnis c:\temp und geben die unten
dargestellten Optionen an:
3.
Klicken Sie auf die Schaltfläche Ausführen. Nach ein paar Sekunden zeigt die
Anwendung eine Statusmeldung an:
75
Erste Schritte mit Conversion Agent, Band 2
9. Conversion Agent Engine ausführen
Der Rückgabewert 1 bedeutet, dass die Ausführung erfolgreich war. Ist
während der Ausführung des Dienstes ein Fehler aufgetreten, zeigt die
Anwendung eine Fehlermeldung an.
4.
Öffnen Sie die Ausgabedatei im Microsoft Editor oder im Internet Explorer.
Die Ausgabe sollte mit der Ausgabe, die Sie beim Ausführen der Anwendung
in Conversion Agent Studio generiert haben, identisch sein.
76
Erste Schritte mit Conversion Agent, Band 2
9. Conversion Agent Engine ausführen
Ist ein Fehler aufgetreten, speichert Conversion Agent Engine ein
Ereignisprotokoll im Ordner für Conversion-Agent-Berichte. Standardmäßig
ist das
c:\Dokumente und Einstellungen\<BENUTZER>\Anwendungsdaten\SAP\
ConversionAgent\4.0\CMReports
wobei <USER> für Ihren Anwendernamen steht. Wie Sie den Speicherort für
Berichte ändern, können Sie im Kapitel Konfigurationseditor im Conversion
Agent Administratorhandbuch nachlesen.
Um ein Protokoll anzuzeigen, ziehen Sie die *.cme-Datei in die Ereignisansicht
von Conversion Agent Studio.
Woran Sie denken sollten
Um einen Parser oder einen Serializer von der Entwicklungs- in die
Produktionsumgebung zu übertragen, können Sie ihn als einen Conversion-AgentDienst bereitstellen. Die Dienste werden im Conversion-Agent-Repository
gespeichert.
Sie können einen Conversion-Agent-Dienst in Conversion Agent Engine über die
Kommandozeile, über eine API-Programmierung, oder über die CGI-Oberfläche
ausführen.
77
Erste Schritte mit Conversion Agent, Band 2
Index
Index Band 2
A
Abstand
Content-Anker, 9
Acrobat
Parsing-Tutorial, 1
Acrobat Reader, 2
Acrobat-Dateien
parsen, 1
Adobe Reader, 2
Aktionen
Summen berechnen, 1
Tutorial, 22
Alternatives
Anker, 25
Anforderungsanalyse
für das Parsen, 2
Anker
Alternatives, 25
Content, 37
EnclosedGroup, 41
Group, 39
positional definieren, 9
SetValue, 23
API
COM-Beispiel, 76
Tutorial, 74
B
Binärdaten
parsen, 6
C
CMComApiTutorial
Conversion Agent Engine ausführen, 74
COM API
Visual Basic-Beispiel, 76
Content
Anker, 37
ContentSerializer
Serialisierungsanker, 61
Conversion Agent COM API
Visual Basic Quellcodebeispiel, 76
Conversion Agent Engine
API-Tutorial, 74
count
Mehrdeutigkeiten ausschließen mit, 49
D
Delimiter
LearnByExample, 48
positional, 1
Dienste
Conversion Agent, 74
Conversion Agent Repository, 75
Dienste bereitstellen
Tutorial, 74
Dokumentprozessoren
Beispiel, 7
für Word-Dokumente, 31
E
Eigenschaften
Projekt, 61
EmbeddedSerializer
Serialisierungsanker, 64
EnclosedGroup
Anker, 41
erweiterte Eigenschaften, 2, 21
Excel
Serializer-Tutorial, 57
F
Format
positional, 1
Formatierung
für das Parsen verwenden, 27
G
globale Komponenten, 50, 53
Group
Anker, 39
Grundeigenschaften, 2, 21
78
Erste Schritte mit Conversion Agent, Band 2
H
HTML
Code aus der Ausgabe entfernen, 46
Hintergrundinformationen, 29
von Word erzeugte, 32
Word-Dokumente umwandeln in, 27
K
Komponenten
globale, 50, 53
L
LearnByExample
Delimiter interpretieren, 48
leere Elemente
in XML-Ausgabe, 38
leeres Projekt
bearbeiten, 69
M
Map
Aktion, 72
Mapper
Definition, 68
erstellen, 69
Tutorial, 68
mehrdeutiger Quelltext
ausschließen, 49
Mehrdeutigkeiten
beseitigen, 28
Microsoft Word
Dokumente parsen, 27
Parsing-Tutorial, 27
O
optionale Eigenschaft
von Group, 39
Ordner
Projekt, 61
P
Parser
mehrere in einem Projekt, 65
PDF
Parsing-Tutorial, 1
PDF to Unicode (UTF-8)
Dokumentprozessor-Beispiel, 7
PDF-Dateien
anzeigen, 2
parsen, 1
Index
PdfToTxt_3_00
Dokumentprozessor-Beispiel, 7
Positionsparen
Tutorial, 1
Projekt
Speicherort bestimmen, 61
Projekteigenschaften
in Conversion Agent Studio, 61
Prozessoren
Dokument, 7
für Word-Dokumente, 31
WordToHtml, 27
Q
Quelldokumente
Parser testen, 54
Quelle
des Mappers, 71
R
Rechnungen
parsen, 2
rekursive Serializer-Aufrufe, 57
RepeatingGroupMapping
Mapper-Anker, 71
RepeatingGroupSerializer
Serialisierungsanker, 63
S
Serialisierungsanker, 57
ContentSerializer, 61
definieren, 61
EmbeddedSerializer, 64
RepeatingGroupSerializer, 63
Serializer
erstellen, 59
mehrere in einem Projekt, 65
Tutorial, 57
SetValue
Anker, 23
sich wiederholende Gruppen
eingebettet, 14
Standardtransformer, 46
Suchbereich, 13
steuern, 2
Summen
berechnen, 22
79
Erste Schritte mit Conversion Agent, Band 2
Index
T
V
testen
Quelldokumente, 54
Textbaustein
ignorieren, 2
Transformer, 47
konfigurieren, 49
Standard, 46
Tutorial_3
Positionsparsen, 1
Tutorial_4
locker strukturierte Dokumente, 27
Tutorial_5
einen Serializer definieren, 57
Tutorial_6
einen Mapper definieren, 68
Tutorials
Conversion Agent Engine API, 74
Dienst in Conversion Agent Engine
ausführen, 74
HTML-Dokument parsen, 27
Positionsparsen von PDFs, 1
Word-Dokument parsen, 27
Variablen
definieren, 34
Visual Basic
Conversion Agent COM API-Beispiel, 76
W
Wiederholende Gruppen
eingebettet, 1
Word
Dokumente parsen, 27
Parsing-Tutorial, 27
WordToHtml
Prozessor, 27, 31
WordToRtf
Prozessor, 31
WordToTxt
Prozessor, 31
Z
Zähler
für Zeilenumbrüche, 17
Zeilenumbruch
als Trennzeichen der RepeatingGroup, 17
suchen bis zum, 10
Ziel
des Mappers, 71
80
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement