Erste Schritte mit ContentMaster - SAP...Erste Schritte mit ContentMaster, Band 1 1. Einführung in ContentMaster 3 XML wird üblicherweise in einem Buch oder auf einem Computerbildschirm

Der SAP-Conversion-Agentvon Itemfield (ContentMaster)

Erste Schritte mitContentMaster

Version 4.0

Dieses Produkt wurde in SAP-Conversion-Agent von Itemfield umbenannt. KünftigeAusgaben dieses Handbuchs werden den neuen Namen enthalten, der ContentMasterersetzt.



Band 1: Einleitende Übungen

Version 4.0


Rechtlicher Hinweis

Erste Schritte mit ContentMaster, Band 1: Einleitende Übungen

Copyright © 2005-2006 Itemfield Inc. Alle Rechte vorbehalten.

Itemfield hat möglicherweise Patente, angemeldete Patente, Marken, Urheberrechte oder sonstigeRechte an geistigem Eigentum inne, die Inhalte dieses Dokumentes abdecken. Sofern nichts anderesausdrücklich in einem schriftlichen Lizenzvertrag mit Itemfield vereinbart wurde, erhalten Sie durchdie Bereitstellung dieses Dokumentes keinerlei Anspruch auf diese Patente, Marken, Urheberrechteoder auf sonstiges geistiges Eigentum.

Die in diesem Dokument enthaltenen Informationen können jederzeit ohne vorherige Ankündigunggeändert werden. Der Anwender trägt die Verantwortung für die Einhaltung aller anwendbarenUrheberrechte. Ohne ausdrückliche schriftliche Genehmigung durch Itemfield Inc. darf kein Teil diesesDokumentes in irgendeiner Form oder auf irgendeine elektronische oder mechanische Weise zuirgendeinem Zweck vervielfältigt oder weitergegeben werden.

SAP AGhttp://www.sap.com

Angaben zur Veröffentlichung:

Version: 4.0Date: Januar 2006

Erste Schritte mit ContentMaster, Band 1 Inhalt

i

Inhalt Band 1

1. Einführung in ContentMaster ..........................................................1Einführung in XML ................................................................................................................................. 1Wie der ContentMaster funktioniert ....................................................................................................... 3

ContentMaster Studio......................................................................................................................3ContentMaster Engine..................................................................................................................... 3

ContentMaster in Integrationsanwendungen einsetzen ........................................................................ 4HL7-Integration................................................................................................................................ 4PDF-Formulare verarbeiten............................................................................................................. 4HTML-Seiten in XML umwandeln....................................................................................................5

Wie Sie mit diesem Buch arbeiten......................................................................................................... 5Aufbau der einzelnen Kapitel .......................................................................................................... 5Kurzreferenz für ContentMaster-Konzepte und -Funktionen........................................................... 5

Weitere ContentMaster-Dokumentation ................................................................................................ 8

2. Installation ........................................................................................9Systemvoraussetzungen ....................................................................................................................... 9ContentMaster installieren..................................................................................................................... 9Ordner für Tutorials und Workspace ................................................................................................... 10

Übungen und Lösungen ................................................................................................................10

3. Grundlegende Parsing-Techniken ................................................12ContentMaster Studio öffnen...............................................................................................................12Das Projekt Tutorial_1 importieren ...................................................................................................... 14Ein kurzer Blick auf das ContentMaster Studio-Fenster ...................................................................... 16Die Struktur eines Quelldokuments definieren ....................................................................................18

Fehler in der Parser-Konfiguration korrigieren .............................................................................. 26Techniken zum Definieren von Ankern .........................................................................................27Das Format Tabulatorbegrenzt .....................................................................................................27

Den Parser ausführen .........................................................................................................................28Den Parser mit weiteren Quelldokumenten ausführen..................................................................29

Woran Sie denken sollten....................................................................................................................30Was kommt als Nächstes?..................................................................................................................31


ii

4. Einen HL7-Parser definieren..........................................................32Anforderungsanalyse...........................................................................................................................32

HL7-Hintergrund............................................................................................................................ 32Eingabestruktur für HL7-Nachrichten............................................................................................ 33XML-Ausgabestruktur....................................................................................................................33

Ein Projekt erstellen.............................................................................................................................34XSD-Schemas im ContentMaster verwenden...............................................................................37

Die Anker definieren............................................................................................................................ 38Das IntelliScript bearbeiten..................................................................................................................42Den Parser testen................................................................................................................................ 42Woran Sie denken sollten....................................................................................................................46

Index Band 1 .......................................................................................47

Erste Schritte mit ContentMaster, Band 1 1. Einführung in ContentMaster

1

Einführung in ContentMaster

ContentMaster ist ein Datenumwandlungssystem. Mit dem ContentMaster könnenSie eine leistungsstarke Schnittstelle zwischen beliebigen Datenformaten undXML-basierten Systemen erstellen.

Um eine ContentMaster-Datenumwandlung zu konfigurieren, verwenden Sie einVerfahren, das man Parsen gemäß Beispiel nennt. Bei diesem Verfahren zeigen SieContentMaster, wie Daten in XML konvertiert werden, indem Sie einfach einBeispiel in einer visuellen Editorumgebung markieren. Für die Konvertierungbrauchen Sie nichts zu programmieren. Sie können sogar eine komplizierteUmwandlung in nur wenigen Stunden oder Tagen konfigurieren, und ersparensich wochen- oder monatelanges Programmieren.

Der ContentMaster kann strukturierte, halbstrukturierte oder unstrukturierteDaten verarbeiten. Sie können den ContentMaster so konfigurieren, dass er Text,binäre Daten, Nachrichten-Formate, HTML-Seiten, PDF-Dokumente,Textverarbeitungsdateien und jedes beliebige andere Format verarbeiten kann.

Der ContentMaster kann die Daten parsen und in jedes Standard- oderbenutzerdefinierte XML-Vokabular umwandeln. In der umgekehrten Richtungkann der ContentMaster XML-Daten serialisieren, indem er den Inhalt in andereFormate umwandelt. Die ContentMaster-Komponenten, die diese Umwandlungendurchführen, nennt man Parser bzw. Serialisierer. Eine weitere Komponente, derMapper, kombiniert diese beiden Funktionen und führt Umwandlungen von XMLnach XML durch.

Dieses Buch liefert Ihnen eine praktische Einführung in den ContentMaster.Während Sie es lesen, werden Sie mehrere Übungen durchführen, die Ihnenzeigen, wie Sie den ContentMaster verwenden, um Ihre eigenenDatenumwandlungen zu konfigurieren und auszuführen.

Einführung in XML

XML (Extensible Markup Language) ist der De-Facto-Standard für denplattformübergreifenden Informationsaustausch. Für ContentMaster-Anwender,denen XML neu ist, bieten wir hier eine kurze Einführung. Wenn Sie mit XMLbereits vertraut sind, können Sie diesen Abschnitt überspringen.

Dies ist ein Beispiel für ein kleines XML-Dokument:

1


2

<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 dengrundlegenden Regeln der XML-Syntax entspricht. Es weist eine Baumstruktur aufund 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 istbeispielsweise ein Attribut des Elements Company und id ist ein Attribut desElements Product.

Um die hierarchische Beziehung zwischen den Elementen zu veranschaulichen,bezeichnen wir sie auch als Haupt- und Subelemente. Das Element Products istbeispielsweise das Subelement von Company und das Hauptelement von Product.

Das individuelle System der Elemente und Attribute nennt man ein XML-Vokabular. Dieses Vokabular kann für jede Anwendung individuell angepasstwerden. Für unser Beispiel haben wir ein Vokabular erstellt, das etwa für einHandelsadressbuch geeignet ist.

Das Vokabular kann in einer Syntax-Spezifikation, die man Schema nennt,formuliert werden. Das Schema kann beispielsweise angeben, dass Company undName erforderliche Elemente sind, dass die anderen Elemente optional sind, unddass 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 Zeileneingerückt, um zu zeigen, wie die Elemente eingebettet sind. Die Einrückung unddie Leerräume sind keine wesentlichen Bestandteile der XML-Syntax. Wir hättengenauso gut einen langen, fortlaufenden String wie den folgenden schreibenkö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">stainlesssteel</Product></Products></Company>

Der fortlaufende String entspricht exakt der eingerückten Version. Genaugenommen, speichert ein Computer die XML-Daten in einem String wie diesem.


3

XML wird üblicherweise in einem Buch oder auf einem Computerbildschirm inder eingerückten Version dargestellt, weil diese viel leichter zu verstehen ist.

Weitere Informationen

Informationen über XML finden Sie in vielen Büchern, Artikeln oder aufWebseiten. Ein ausgezeichnetes Tutorial finden Sie unter http://www.w3schools.com.Abschriften des XML-Standards finden Sie unter http://www.w3.org.

Wie der ContentMaster funktioniert

Das ContentMaster-System besteht aus zwei Hauptkomponenten:

ContentMaster StudioDie Entwicklungs- und Konfigurationsumgebung des ContentMaster.

ContentMaster EngineDie Datenumwandlungs-Engine.

ContentMaster Studio

ContentMaster Studio ist eine visuelle Editorumgebung, in der SieDatenumwandlungen, wie Parser, Serialisierer und Mapper, entwickeln undkonfigurieren können.

Sie verwenden ContentMaster Studio, um ContentMaster zu beizubringen, wieDaten eines bestimmten Typs verarbeitet werden sollen. Wenn Sie einen Parsererstellen, können Sie durch Markieren-und-Anklicken die Datenfelder in einemBeispiel-Quelldokument bestimmen, und definieren, wie ContentMaster die Felder inXML umwandeln soll. Diesen Vorgang nennt man Parsen gemäß Beispiel.

Beachten Sie bitte, dass wir den Begriff Dokument (wie etwa in Beispiel-Quelldokument) im weitest möglichen Sinne verwenden. Ein Dokument kann Textoder binäre Daten enthalten und von beliebiger Größe sein. Es kann an einembeliebigen Ort gespeichert oder aufgerufen werden – in einer Datei, einem Buffer,einem Stream, einer URL, einer Datenbank, einem Nachrichtensystem.

ContentMaster Engine

ContentMaster Engine ist eine leistungsstarke Datenumwandlungs-Engine. Sieverfügt über keine Benutzerschnittstelle. Sie arbeitet ausschließlich im Hintergrundund führt die Datenumwandlungen aus, die Sie vorher in ContentMaster Studiodefiniert haben.

Um eine Datenumwandlung vom ContentMaster Studio in die ContentMasterEngine zu verschieben, müssen Sie die Umwandlung als einen ContentMaster-Dienst verfügbar machen.

Eine Integrationsanwendung kann auf verschiedene Arten Anfragen anContentMaster Engine übergeben, zum Beispiel, indem das ContentMaster API

http://www.w3schools.com/

http://www.w3.org/


4

aufgerufen wird oder durch eine Übertragung an eine CGI-Schnittstelle. EineAnfrage gibt die Daten an, die umgewandelt werden sollen und denContentMaster-Dienst, der die Umwandlung durchführt. ContentMaster Engineführt die Anfrage aus und gibt die Ausgabe an die aufrufende Anwendungzurück.

ContentMaster in Integrationsanwendungeneinsetzen

Die folgenden Absätze zeigen ein paar typische Beispiele dafür, wieContentMaster-Datenumwandlungen in System-Integrationsanwendungeneingesetzt werden.

Wenn Sie die Übungen in diesem Buch ausführen, gewinnen Sie an Erfahrung, wieContentMaster für diese Arten von Datenumwandlungen eingesetzt wird. ImKapitel Einen HL7-Parser definieren wird beispielsweise erläutert, wie SieContentMaster einsetzen, um HL7-Meldungen zu parsen. In den KapitelnPositionsparsen eines PDF-Dokuments und Word- und HTML-Dokumente parsenwerden Parser beschrieben, die verschiedene Arten von unstrukturiertenDokumenten verarbeiten.

HL7-Integration

HL7 ist das standardmäßige Nachrichtenprotokoll des Gesundheitswesens. HL7-Meldungen haben eine flexible Struktur, die optionale und wiederholt auftretendeDatenfelder unterstützt. Diese Felder werden durch eine Hierarchie vonBegrenzungszeichen getrennt.

In einer typischen Anwendung verwendet eine große GesundheitsorganisationContentMaster, um die Nachrichten, die zu und von ihren HL7-basiertenInformationssystemen übertragen werden, umzuwandeln. ContentMaster ist sokonfiguriert, dass alle Arten von HL7-Nachrichten verarbeitet werden.

PDF-Formulare verarbeiten

Das Adobe Acrobat (PDF) Dateiformat ist zum Standard für den Austauschformatierter Dokumente geworden. Mit Hilfe dieses Formats können vollständigformatierte Dokumente – einschließlich ihres ursprünglichen Layouts, derSchriftarten, Grafiken usw. – auf einer Vielzahl unterstützter Plattformen angezeigtwerden. Bei Informationsverarbeitungsanwendungen ist das PDF-Format jedochweit weniger nützlich als bei visuellen Anwendungen. Der Grund dafür ist, dassAnwendungen nicht auf die unstrukturierten, binären PDF-Dateien zugreifen undsie analysieren können.

Der ContentMaster löst dieses Problem, indem er die Umwandlung von PDF-Dokumenten in XML-Dateien ermöglicht. Der ContentMaster kann beispielsweiseRechnungen, die Lieferanten im PDF-Format schicken, in XML umwandeln, um siein einer Datenbank zu speichern.


5

HTML-Seiten in XML umwandeln

Informationen in HTML-Dokumenten werden üblicherweise in unstrukturierterund nicht standardisierter Form dargestellt. Zweck eines HTML-Dokuments ist dievisuelle Darstellung und nicht die Informationsverarbeitung.

Der ContentMaster bietet viele Funktionen, um die Informationen in einem HTML-Dokument anzusteuern, zu finden und zu speichern. Mit Hilfe des ContentMasterkönnen Sie Informationen von HTML in strukturiertes XML umwandeln, sodassSoftware-Anwendungen auf diese Informationen zugreifen können. Händler, dieIhre Waren im Internet anbieten, können beispielsweise die Informationen in XMLumwandeln, sodass sie die Informationen mit einer Verrechnungsstelle oderanderen Händlern teilen können.

Wie Sie mit diesem Buch arbeiten

Dieses Buch ist ein Tutorial für den ContentMaster. Während des Lesens werdenSie mehrere Übungen durchführen, anhand derer Sie lernen, wie Sie denContentMaster für Datenumwandlungen in der Praxis anwenden.

Nachdem Sie die Übungen durchgeführt haben, sind Sie mit den ContentMaster-Abläufen vertraut und können den ContentMaster für Ihre eigenenDatenumwandlungen einsetzen.

Aufbau der einzelnen Kapitel

In den meisten Kapiteln dieses Buches finden Sie Übungen, durch die Sie lernen,wie Sie Datenumwandlungen erstellen, die Parser, Serialisierer oder Mapperverwenden. Wir empfehlen, dass alle Anwender die ersten zwei Übungenausführen—Grundlegende Parsing-Techniken und Einen HL7-Parser definieren. Siekönnen dann die weiteren Übungen der Reihe nach ausführen oder Sie können dieKapitel überfliegen und sich nur mit jenen näher befassen, die Sie brauchen.

Im letzten Kapitel, ContentMaster Engine ausführen, wird erläutert, wie Sie eineDatenumwandlung als einen ContentMaster-Dienst verfügbar machen, und wasSie machen müssen, damit ContentMaster Engine den Dienst ausführt. In diesemKapitel erfahren Sie auch, wie Sie ein ContentMaster-Projekt vomEntwicklungsstadium in das Produktionsstadium transferieren.

Kurzreferenz für ContentMaster-Konzepte und -Funktionen

In der folgenden Tabelle sind die ContentMaster-Konzepte und –Funktionenzusammengefasst, die in jedem Kapitel vorgestellt und erklärt werden.


6

Konzept Spezielle Funktion oderKomponente

Kapitel

Systemvoraussetzungen 2. Installation

Installationsvorgang 2. Installation

Installation

Registrierung 2. Installation

IntelliScript anzeigen 3. Grundlegende Parsing-Techniken

IntelliScript bearbeiten 4. Einen HL7-Parser definieren

Mehrere Skriptdateien 7. Einen Serialisierer definieren

Farbcodierung für Anker 3. Grundlegende Parsing-Techniken

Grundlegende und erweiterteEigenschaften

5. Positionsparsen eines PDF-Dokuments

MitContentMasterStudio arbeiten

Globale Komponenten 6. Word- und HTML-Dokumente parsen

Importieren 3. Grundlegende Parsing-Techniken

Erstellen 4. Einen HL7-Parser definieren

Mit mehreren Parsern oderSerialisierern

7. Einen Serialisierer definieren

Projekteigenschaften 7. Einen Serialisierer definieren

Projekte

Speicherort des Projektordnersbestimmen


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 Beispielquelletesten

4. Einen HL7-Parser definieren

Anhand zusätzlicherQuelldokumente testen

3. Grundlegende Parsing-Techniken6. Word- und HTML-Dokumente parsen

Dokumentprozessoren 5. Positionsparsen eines PDF-Dokuments6. Word- und HTML-Dokumente parsen

Parser

Die einen zweiten Parseraufrufen


Text 3. Grundlegende Parsing-Techniken

Tabulatorbegrenzt 3. Grundlegende Parsing-Techniken

HL7 4. Einen HL7-Parser definieren

Formate

Positional 5. Positionsparsen eines PDF-Dokuments


7


Kapitel

PDF 5. Positionsparsen eines PDF-Dokuments

Microsoft Word 6. Word- und HTML-Dokumente parsen

HTML 6. Word- und HTML-Dokumente parsen

Die ein XSD-Schemaverwenden

3. Grundlegende Parsing-Techniken

Die einem Projekt ein Schemahinzufügen


Schemas erstellen undbearbeiten


Die mehrere Schemasverwenden

8. Einen Mapper definieren

Datenbehälter

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 positionalenAbständen


Content mit öffnenden undschließ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

EingebetteteRepeatingGroup


Anker

Zeilenumbrüche alsReferenzpunkte undTrennzeichen


Standardtransformatoren 6. Word- und HTML-Dokumente parsen

AddString 6. Word- und HTML-Dokumente parsen

Transformatoren

Replace 6. Word- und HTML-Dokumente parsen

SetValue 5. Positionsparsen eines PDF-Dokuments

CalculateValue 5. Positionsparsen eines PDF-Dokuments

Aktionen

Map 8. Einen Mapper definieren

Serialisierer und Erstellen 7. Einen Serialisierer definieren


8


Kapitel

ContentSerializer 7. Einen Serialisierer definieren

RepeatingGroupSerializer


EmbeddedSerializer 7. Einen Serialisierer definieren

Serialisierungsanker

Die einen zweiten Serialisiereraufrufen


Erstellen 8. Einen Mapper definierenMapper undMappinganker

RepeatingGroupMapping 8. Einen Mapper definieren

Farbcodierung verwenden 4. Einen HL7-Parser definieren

Ereignisse anzeigen 3. Grundlegende Parsing-Techniken

Ereignisse interpretieren 4. Einen HL7-Parser definieren

Techniken zum Testen undDebuggen


Testen

Auszuführenden Parser oderSerialisierer auswählen


Bereitstellen einesContentMaster-Dienstes

9. ContentMaster Engine ausführenIn ContentMasterEngine ausführen

API 9. ContentMaster Engine ausführen

Weitere ContentMaster-Dokumentation

Die komplette ContentMaster-Dokumentation steht im Online-Hilfeformat zurVerfügung. Sie können die vollständige Hilfe über den Ordner SAP ContentMasterim Startmenü oder über das Hilfemenü in ContentMaster Studio aufrufen.

Erste Schritte mit ContentMaster, Band 1 2. Installation

9

Installation

Bevor Sie mit diesem Buch fortfahren, sollten Sie die ContentMaster-Softwareinstallieren (falls Sie das nicht schon getan haben).

Weitere Informationen über die Systemvoraussetzungen, die Installation und dieRegistrierung finden Sie im ContentMaster Administratorhandbuch. In den folgendenAbsä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 denContentMaster auf einem Computer installieren, der die folgenden minimalenVoraussetzungen 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

ContentMaster installieren

Um den ContentMaster zu installieren, klicken Sie die Setup-Datei doppelt an undbefolgen dann die Anweisungen auf dem Bildschirm. Achten Sie darauf,mindestens folgende Komponenten zu installieren:

EngineDie ContentMaster Engine-Komponente, die für alle Übungen in diesem Buchbenötigt wird.

Entwicklungsumgebung EclipseDie ContentMaster Studio für Eclipse Entwicklungs- undKonfigurationsumgebung, die für alle Übungen in diesem Buch benötigt wird.

DokumentprozessorenOptionale Komponenten, die für die Tutorials in Kapitel 5 und 6 benötigtwerden.

2


10

Standard-Installationsordner

Standardmäßig wird ContentMaster in folgendem Ordner installiert:

c:\Programme\SAP\ContentMaster

Das Setup-Programm fordert Sie auf, den Ordner zu wechseln, wenn Sie möchten.

Registrierung und Lizenzierung

Je nachdem, welche Version von ContentMaster Sie verwenden, werden Sie beimSetup eventuell aufgefordert, die Software zu registrieren und eine Lizenz zuinstallieren. Folgen Sie den Anweisungen auf dem Bildschirm, um dieRegistrierung durchzuführen. Ausführliche Informationen dazu finden Sie in imContentMaster Administratorhandbuch.

Ordner für Tutorials und Workspace

Für die Übungen in diesem Buch benötigen Sie die Tutorial-Dateien, die sich imOrdner tutorials Ihres ContentMaster Programmordners befinden.Standardmäßig ist der Speicherort:

c:\Programme\SAP\ContentMaster\tutorials

Beim Ausführen der Übungen werden Sie einen Teil des Inhalts dieses Ordners inden ContentMaster Studio Workspace-Ordner importieren oder kopieren. DerStandardspeicherort für Workspace ist:

Eigene Dateien\SAP\ContentMaster\4.0\workspace

Sie sollten mit den Kopien im Ordner Workspace arbeiten. Wir empfehlen, dieOriginaldateien im Ordner Tutorials nicht zu ändern, für den Fall, dass Sie sienochmals benötigen.

Übungen und Lösungen

Der Ordner tutorials enthält zwei Unterordner:

tutorialsExercisesSolutions to Exercises

Der Ordner Exercises enthält die Dateien, die Sie für die Übungen brauchen. Indiesem ganzen Buch beziehen wir uns auf Dateien in diesem Ordner.

Beim Ausführen der Übungen werden Sie ContentMaster-Projekte mit Namen wieTutorial_1, Tutorial_2 usw. erstellen. Die Projekte werden in IhremContentMaster Studio Workspace-Ordner gespeichet.


11

Der Ordner Solutions to Exercises enthält die von uns vorgeschlagenenLösungen für die Übungen. Die Lösungen sind Projekte mit Namen wieTutorialSol_1 usw. Sie können die Projekte in Ihren Workspace importieren undunsere Lösungen mit Ihren vergleichen. Beachten Sie, dass es in vielen Fällen mehrals eine richtige Lösung gibt.

Erste Schritte mit ContentMaster, Band 1 3. Grundlegende Parsing-Techniken

12

Grundlegende Parsing-Techniken

Damit Sie gleich damit beginnen können den ContentMaster einzusetzen, stellenwir Ihnen ein teilweise konfiguriertes Projekt zur Verfügung, das einen einfachenParser enthält. Das Projekt heißt Tutorial_1.

Sie arbeiten in ContentMaster Studio und werden die Konfiguration bearbeitenund fertig stellen. Dann verwenden Sie den Parser, um ein paarBeispieltextdokumente in XML umzuwandeln.

Hauptzweck dieser Übung ist es:

Das Parsen gemäß Beispiel mit ContentMaster zu demonstrieren

Zu lernen, wie man einen Parser definiert und einsetzt

Dabei werden Sie ein paar wichtige ContentMaster Studio-Funktionen einsetzen,wie etwa:

Ein Projekt importieren und öffnen

Ein XSD-Schema verwenden, das die Struktur des XML-Ausgabedokumentsdefiniert

Die Struktur des Quelldokuments mit Hilfe von 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

ContentMaster Studio öffnen

Um ContentMaster Studio für Eclipse zu öffnen, machen Sie Folgendes:

1. Klicken Sie im Start-Menü auf Programme > SAP ContentMaster >ContentMaster Studio für Eclipse.

2. Zeigen Sie in ContentMaster Studio die Perspektive Erstellen an. DiePerspektive ist eine Gruppe von Fenstern, Menüs und Symbolleisten, mitdenen Sie ContentMaster-Projekte in Eclipse bearbeiten können.

Wählen Sie dafür den Menübefehl Fenster > Perspektive öffnen > Andere >ContentMaster Studio erstellen.

3


13

3. Wahlweise können Sie den Befehl Fenster > Perspektive wiederherstellenausführen. Das ist eine gute Idee, wenn Sie vorher in ContentMaster Studiogearbeitet und die Fenster verschoben oder in der Größe verändert haben. Mitdiesem Befehl werden alle Fenster in ihrer Standardgröße und –Positionwiederhergestellt.

4. Wahlweise können Sie den Befehl Hilfe > Willkommen ausführen und dieContentMaster Studio Willkommensseite auswählen. Diese Seite enthälteinleitende Anweisungen darüber, wie Sie ContentMaster Studio verwenden.

Die Willkommensseite schließen Sie, indem Sie das X auf der rechten Seite derRegisterkarte Editor anklicken.


14

Das Projekt Tutorial_1 importieren

Das teilweise konfigurierte Projekt wird mit der ContentMaster-Softwaremitgeliefert, aber Sie können es in ContentMaster 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 derEingabeaufforderung wählen Sie die Option, mit der Sie ein bestehendesContentMaster-Projekt in den Workspace importieren.

2. Klicken Sie auf die Schaltfläche Weiter, und suchen Sie nach folgender Datei(ersetzen Sie die Angaben mit Ihrem Pfad zum ContentMasterInstallationsordner):

c:\Programme\SAP\ContentMaster\tutorials\Exercises\Tutorial_1\Tutorial_1.cmw

3. Auf den verbleibenden Seiten des Import-Assistenten können Sie dieStandardeinstellungen übernehmen. Klicken Sie auf Fertigstellen, um denImport abzuschließen.


15

Der importierte Tutorial_1-Ordner sollte sich im Eclipse Workspace-Ordnerbefinden:

Eigene Dateien\SAP\ContentMaster\4.0\workspace\Tutorial_1

4. Im oberen rechten Bereich des Eclipse-Fensters zeigt der ContentMaster-Explorer die Tutorial_1-Dateien an, die Sie importiert haben.

Die einzelnen Ordner und Dateien werden im Folgenden kurz beschrieben:

ExamplesDieser Ordner enthält ein Beispiel-Quelldokument, bei dem es sich um einBeispiel-Eingabedokument handelt, mit dem Sie den Parser konfigurieren.

ScriptsEine TGP-Skriptdatei, in der die Parser-Konfiguration gespeichert wird.

XSDEine XSD-Schemadatei, die die XML-Struktur definiert, die der Parsererstellt.

ResultsDieser Ordner ist vorübergehend leer. Wenn Sie den Parser konfigurierenund ausführen, speichert der ContentMaster seine Ausgabe in diesemOrdner.

Beachten Sie bitte, dass es sich bei den meisten dieser Ordner um virtuelleOrdner handelt. Sie werden dazu verwendet, die angezeigten Dateien zukategorisieren, aber sie bestehen nicht wirklich auf Ihrer Festplatte. Nur beimOrdner Results handelt es sich um physisches Verzeichnis auf IhrerFestplatte, aber er ist noch nicht vorhanden, weil Sie noch keine Ausgabeerzeugt haben.

Wenn Sie sich den Ordner Tutorial_1 im Windows Explorer ansehen, werdenSie ein paar weitere Dateien entdecken, die im ContentMaster-Explorer nichtangezeigt werden, wie zum Beispiel:

Tutorial_1.cmwDas ist die Hauptprojektdatei, die die Konfigurationseigenschaften für dasProjekt enthält .


16

.projectDas ist eine Datei, die von der Eclipse-Entwicklungsumgebung erzeugtwird. Es handelt sich dabei nicht um eine ContentMaster-Datei, aber Siebenötigen Sie, um das ContentMaster-Projekt in Eclipse zu öffnen.

Ein kurzer Blick auf das ContentMaster Studio-Fenster

In ContentMaster Studio werden mehrere Fenster angezeigt. Es gibt dabei zweiArten von Fenstern, Ansichten und Editoren. Eine Ansicht dient dazu, Daten zueinem Projekt anzuzeigen oder bestimmte Operationen auszuführen. In einemEditor können Sie die Konfiguration eines Projekts frei bearbeiten.

In den folgenden Absätzen werden die einzelnen Ansichten und Editorenbeschrieben, wobei wir links oben beginnen und gegen den Uhrzeigersinnvorgehen.

Oben linksContentMaster-Explorer-Ansicht

Zeigt die Projekte und Dateien im ContentMaster Studio-Workspace an.Durch einen Rechtsklick oder Doppelklick in dieser Ansicht können Sie einemProjekt bestehende Dateien hinzufügen, neue Dateien anlegen oder Dateienzum Bearbeiten öffnen.


17

Unten links

In der unteren linken Ecke des ContentMaster-Fensters werden zwei gestapelteAnsichten angezeigt. Sie können zwischen den Ansichten wechseln, indem Sie aufdie jeweilige Registerkarte klicken.

KomponentenansichtZeigt die Hauptkomponenten an, die in einem Projekt definiert sind, wie zumBeispiel Parser, Serialisierer, Mapper, Transformatoren und Variablen. Durcheinen Rechtsklick oder einen Doppelklick können Sie eine Komponente zumBearbeiten öffnen.

Ansicht IntelliScript-AssistentMit Hilfe dieser Ansicht können Sie bestimmte Komponenten in derIntelliScript-Konfiguration einer Datenumwandlung konfigurieren. Einenähere Erläuterung dazu finden Sie in der Beschreibung des IntelliScript-Editors weiter unten.

Unten rechts

Unten rechts werden mehrere Ansichten angezeigt, die Sie auswählen, indem Siedie entsprechende Registerkarte anklicken.

AufgabenansichtZeigt Syntaxfehler in einer Datenumwandlung oder in einem Schema an. Siekönnen diese Ansicht auch dafür verwenden, Aufgaben aufzuzeichnen, dieSie ausführen müssen (eine Aufgabenliste).

HilfeansichtZeigt einen Hilfetext an, während Sie in einem IntelliScript-Editor. Wenn Sieim Editor ein Element markieren, erfolgt in der Hilfeansicht automatisch einBildlauf zum entsprechenden Thema.

Hinweis: Sie können die ContentMaster-Hilfe auch über das Hilfe-Menü inContentMaster Studio oder über den Ordner SAP ContentMaster im Start-Menü aufrufen. Damit können Sie, im Gegensatz zur Anzeige eines einzelnenThemas in der Hilfeansicht, die gesamte ContentMaster-Dokumentationeinsehen.

EreignisansichtZeigt Ereignisse an, die auftreten, während Sie eine Datenumwandlungausführen. Die Ereignisse dienen dazu, zu bestätigen, dass eine Umwandlungkorrekt abläuft oder um Probleme zu diagnostizieren.

Ansicht BinärquelleZeigt den Binärcode des Beispiel-Quelldokuments an. Das ist nützlich, wennSie eine binäre Eingabe parsen oder wenn Sonderzeichen, wieZeilenumbrüche und Tabulatoren, angezeigt werden sollen.

Schema-AnsichtZeigt die mit einem Projekt verbundenen XSD-Schemata an. Die Schemasdefinieren die XML-Strukturen, die eine Datenumwandlung verarbeiten kann.


18

SpeicheransichtZeigt die ContentMaster-Dienste an, die für die Ausführung in ContentMasterEngine verfügbar gemacht werden.

Oben rechts

Oben rechts zeigt ContentMaster Studio Editor-Fenster an. Sie können mehrereEditoren öffnen, und dann zwischen ihnen wechseln, indem Sie die jeweiligeRegisterkarte anklicken.

IntelliScript-EditorWird verwendet, um eine Datenumwandlung zu konfigurieren. Hier werdenSie überwiegend arbeiten, wenn Sie die Übungen in diesem Buch ausführen.

Der linke Bereich des IntelliScript-Editors ist der IntelliScript-Bereich. Hierdefinieren Sie eine Datenumwandlung. Der IntelliScript-Bereich weist eineBaumstruktur auf, die die Reihenfolge der ContentMaster-Komponentendefiniert, die die Umwandlung durchführen.

Der rechte Bereich ist der Beispielbereich. Er zeigt das Beispiel-Quelldokumenteines Parsers an. In diesem Bereich können Sie einen Parser durch Markieren-und-Anklicken konfigurieren.

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 ContentMaster-Explorer die Dateien Tutorial_1 files undklicken Sie die Datei Tutorial_11.tgp doppelt an. Die Datei wird in einemIntelliScript-Editor geöffnet.


19

2. Der IntelliScript-Editor zeigt eine Parser-Komponente namens MyFirstParseran. Erweitern Sie den IntelliScript-Baum und überprüfen Sie die Parser-Eigenschaften. Sie enthalten die folgenden Werte, die wir für Sie konfigurierthaben:

example_sourceDas Beispiel-Quelldokument, das Sie verwenden, um den Parser zukonfigurieren. Wir haben eine Datei namens File1.txt als Beispielquellegewählt. Die Datei ist im Projektordner gespeichert.

formatWir haben für die Beispielquelle das Format TextFormat und TabDelimitedfestgelegt. Das bedeutet, dass die Textfelder durch Tabulatoren voneinander getrennt sind.

3. Die Beispielquelle, File1.txt , sollte im rechten Bereich des Editors angezeigtwerden. Wenn nicht, klicken Sie MyFirstParser im linken Bereich mit derrechten Maustaste an, und wählen Sie die Option zum Öffnen derBeispielquelle.

Hinweis: Sie können zwischen der Anzeige des linken und rechten Bereichsumschalten. Öffnen Sie dazu das IntelliScript-Menü und wählen SieIntelliScript, Beispiel oder Beide. Es gibt auch Symbolleisten-Schaltflächen fürdiese Optionen.

4. Überprüfen Sie die Beispielquelle etwas näher. Sie enthält zwei Arten vonInformationen.

Die Einträge auf der linken Seite, wie etwa First Name:, Last Name: und Id:,sind Marker-Anker, die den Speicherort der Datenfelder angeben. Die Einträgeauf der rechten Seite, wie etwa Ron, Lehrer und 547329876, sind Content-Anker,also die Werte der Datenfelder. Die Marker- und Content-Anker sind durchTabulatoren getrennt, die man Tabulator-Begrenzungszeichen nennt.


20

"First Name:" ist ein Marker-Anker. "Ron" ist ein Content-Anker. Die Ankersind durch Tabulator-Begrenzungszeichen getrennt.

Um Ihnen die Arbeit zu erleichtern, haben wir den Parser bereits mit dengrundlegenden Eigenschaften, wie etwa dem Format TabDelimitedkonfiguriert. Sie müssen die Konfiguration jetzt noch abschließen, indem Siedie Anker definieren. Im Folgenden werden Sie den Parser so konfigurieren,dass er nach jedem Marker-Anker sucht und die Daten vom nachfolgendenContent-Anker abruft. Der Parser fügt die Daten dann in die XML-Strukturein.

Im Laufe dieses Buches lernen Sie noch viele andere Arten von Ankern undBegrenzungszeichen kennen. Anker sind jene Stellen, an denen sich der Parserin ein Quelldokument einklinkt und eine Operation ausführt.Begrenzungszeichen sind Zeichen, die die einzelnen Anker trennen. Mit demContentMaster können Sie Anker und Begrenzungszeichen auf vieleverschiedene Arten definieren.

5. Jetzt können Sie mit dem Parsen gemäß Beispiel beginnen. Ziehen Sie imBeispielbereich mit der Maus über den Text First Name:, den ersten Marker-Anker.

6. Klicken Sie den gerade markierten Text mit der rechten Maustaste an undwählen Sie Marker einfügen aus dem Popup-Menü.


21

7. Im vorigen Arbeitsschritt haben Sie einen Marker-Anker in das IntelliScripteingefügt. Sie werden jetzt aufgefordet, die erste Eigenschaft, die eine Eingabeerfordert, nämlich search, anzugeben. Mit dieser Eigenschaft können Sie dieArt der Suche festlegen. Die Standardeinstellung ist TextSearch. Da dies diegewünschte Einstellung ist, drücken Sie einfach Eingabe.

8. Sie werden jetzt aufgefordert, die nächste Eigenschaft, die eine Eingabeerfordert, nämlich den text des Ankers, nach dem der Parser sucht,anzugeben. Standardmäßig ist das der Text, den Sie in der Beispielquellemarkiert haben. Drücken Sie also wieder Eingabe.

Hinweis: In den hier dargestellten Abbildungen ist die gewählte Eigenschaftweiß, und der Hintergrund ist grau. Auf Ihrem Bildschirm kann es sein, dassder Hintergrund weiß ist. Sie können diese Darstellung ändern, indem Sie denBefehl Fenster > Einstellungen wählen. Auf der ContentMaster-Seite desEinstellungsfensters aktivieren oder deaktivieren Sie die Option FokussierteInstanz hervorheben.


22

9. Im IntelliScript zeigt ContentMaster Studio den neuen Marker-Anker als Teilder MyFirstParser-Definition an. In der Beispielquelle hebt ContentMasterStudio den Marker gelb hervor.

Hinweis: Falls die Farbcodierung nicht sofort angezeigt wird, rufen Sie dasIntelliScript-Menü auf und prüfen Sie, ob die Option Beispiel automatischlernen markiert ist.

10. Jetzt können Sie den ersten Content-Anker erstellen. Markieren Sie in derBeispielquelle das Wort Ron. Klicken Sie den markierten Text mit der rechtenMaustaste 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 werdenaufgefordert, die erste Eigenschaft, die eine Eingabe erfordert, nämlich value,anzugeben. Mit Hilfe dieser Eigenschaft können Sie festlegen, wie das Parsingdurchgeführt wird.

Die Standardeinstellung ist LearnByExample, die bewirkt, dass der Parser denInhalt aufgrund der Begrenzungszeichen, die ihn in der Beispielquelleumgeben, findet. Da dies die gewünschte Einstellung ist, drücken Sie Eingabe.


23

12. Sie können die Standardwerte der nächsten Eigenschaften (example,opening_marker und closing-marker) annehmen oder sie überspringen, indemSie mit der Maus an eine anderen Stelle klicken.

13. Ihre nächste Aufgabe ist es, anzugeben, wo der Content-Anker die Daten, dieer aus dem Quelldokument extrahiert, speichern soll.

Der Ausgabe-Speicherort wird Datenbehälter genannt. Das ist ein allgemeinerBegriff, der "ein XML-Element, ein XML-Attribut oder eine Variable" bedeutet.In dieser Übung verwenden Sie Datenbehälter, bei denen es sich um Elementeoder Attribute handelt. In einer späteren Übung werden Sie Variablenverwenden.

Um den Datenbehälter zu definieren, markieren Sie die Eigenschaftdata_holder und klicken sie doppelt an oder drücken Eingabe. Daraufhinwird eine Schema-Ansicht geöffnet, die die XML-Elemente und –Attributeanzeigt, die im XSD-Schema des Projekts definiert sind (Person.xsd).

Erweitern Sie den no target namespace-Knoten, und markieren Sie dasElement First. Das bedeutet, dass der Content -Anker seine Ausgabe in einemXML-Element namens First, wie im Folgenden dargestellt, speichern soll:

<First>Ron</First>

Genauer gesagt, ist das Element First innerhalb von Name eingebettet, daswiederum innerhalb von Person eingebettet ist. Die vom Parser erzeugteAusgabe-Struktur sieht wie folgt aus:

<Person><Name>

<First>Ron</First></Name>

</Person>


24

Einen Datenbehälter wählen

14. Wenn Sie die Schaltfläche OK anklicken, wird der Eigenschaft data_holderder Wert /Person/*s/Name/*s/First zugewiesen. In der XML-Terminologienennt man das XPath-Ausdruck. Es handelt sich dabei um eine Darstellung derXML-Struktur, die wir oben beschrieben haben.

(Eigentlich lautet der standardmäßige XPath-Ausdruck /Person/Name/First.Die *s-Symbole sind ContentMaster-Erweiterungen der XPath-Syntax, die Sieignorieren können.)

ContentMaster Studio hebt die Content-Anker in der Beispielquelle hervor.Marker- und Content-Anker haben eine andere Farbe, damit Sie sie leichterunterscheiden können.


25

15. Wählen Sie den Befehle Datei > Speichern oder klicken Sie auf die SchaltflächeSpeichern in der Symbolleiste. Damit wird Ihre Bearbeitung im Projektordnergespeichert.

16. Bisher haben Sie den Parser angewiesen, nach einem First Name:-Marker zusuchen, den Inhalt des nachfolgenden Feldes Ron abzurufen und den Inhalt imElement First des XSD-Schemas zu speichern.

Sie sollten jetzt mit dem Quelldokument fortfahren und die anderen Marker-und Content-Anker auf dieselbe Weise definieren. In der folgenden Tabellesind die Anker aufgelistet, die Sie definieren müssen.

Anker Ankertyp Datenbehälter

Last Name: Marker

Lehrer Content /Person/*s/Name/*s/Last

Id: Marker

547329876 Content /Person/*s/Id

Age: Marker

27 Content /Person/*s/Age

Gender: Marker

M Content /Person/@gender

Achten Sie darauf, die Anker in der oben angegebenen Reihenfolge zudefinieren, denn das ist die Reihenfolge im Quelldokument. Das ist wichtig,weil Sie die richtige Beziehung zwischen jedem Marker und seinemzugehörigen Inhalt herstellen müssen. Wenn Sie die Reihenfolge nichteinhalten, kann es sein, dass der ContentMaster den Text nicht findet.


26

Wenn Sie damit fertig sind, sollte das ContentMaster Studio-Fenster wie in derfolgenden Abbildung aussehen. Es kann natürlich sein, dass Sie dieBaumstruktur erweitern oder reduzieren müssen, um die abgebildeten Zeilenanzuzeigen.

17. Speichern Sie das Projekt wieder.

Fehler in der Parser-Konfiguration korrigieren

Beim Definieren der Anker kann es gelegentlich vorkommen, dass Sie einen Fehlermachen, wie etwa, dass Sie den falschen Text markieren oder einem Anker diefalschen 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 irgendeineandere Komponente, die Sie in die Konfiguration eingefügt haben) und dieTaste Entf drücken.

Im IntelliScript-Bereich können Sie den Anker mit der rechten Maustasteanklicken. Klicken Sie dann im Popup-Menü auf Löschen.

Sobald Sie mehr Erfahrung mit dem IntelliScript-Bereich haben, können Sie nochfolgende Techniken anwenden:

Wenn Sie einen Anker in der falschen Reihenfolge erstellt haben, können Sieihn im IntelliScript an die richtige Stelle ziehen.

Wenn Sie vergessen, einen Anker zu definieren, klicken Sie den Anker, vordem der ausgelassene Anker platziert werden soll, mit der rechten Maustastean und wählen Sie Einfügen.


27

Im IntelliScript können Sie Komponenten, wie zum Beispiel Anker, kopierenund einfügen.

Sie können die Eigenschaftswerte im IntelliScript bearbeiten.

Techniken zum Definieren von Ankern

In den oben beschriebenen Schritten wurden Sie angewiesen, einen Anker zumarkieren, ihn mit der rechten Maustaste anzuklicken und den Befehl Markereinfügen oder Content einfügen zu wählen. Damit fügen Sie einen Anker in dasIntelliScript 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 derBeispielquelle in einen Datenbehälter in der Schema-Ansicht ziehen. Damitfügen Sie einen Content-Anker in das IntelliScript ein, dem bereits dieEigenschaft data_holder zugewiesen ist.

Sie können Anker definieren, indem Sie die Angaben in den IntelliScript-Bereich eintippen, ohne die Beispielquelle zu verwenden.

Sie können die Eigenschaften von Marker- und Content-Ankern in der AnsichtIntelliScript-Assistent bearbeiten.

Wir möchten Sie dazu ermutigen, mit diesen Funktionen zu experimentieren.Weitere Informationen finden Sie im Buch ContentMaster Studio in Eclipse.

Das Format Tabulatorbegrenzt

Sie erinnern sich vielleicht, dass MyFirstParser mit dem Format TabDelimiteddefiniert wurde. Die Begrenzungszeichen definieren, wie der Parser dieBeispielquelle interpretiert. In diesem Fall schließt der Parser daraus, dass dieMarker- und Content-Anker durch Tabultoren getrennt sind.

In den Anweisungen empfehlen wir, dass Sie die Marker einschließlich derDoppelpunkte markieren, wie zum Beispiel:

First Name:

Weil das Format Tabulatorbegrenzt gewählt wurde, ist der Doppelpunkt in diesemParser eigentlich nicht von Bedeutung. Wenn Sie First Name (ohne denDoppelpunkt) markieren, findet der Parser den Marker und den nachfolgendenTabulator noch immer und er liest den Inhalt richtig. Andere Zeichen, wie denDoppelpunkt, ignoriert er einfach.

Aufgrund des Formats Tabulatorbegrenzt können Sie auch einen kurzen Content-Anker wie Ron wählen, ohne sich um die Feldgröße Gedanken machen zu müssen.In einem anderen Quelldokument hat eine Person vielleicht einen langenVornamen, wie etwa Rumpelstiltskin . Standardmäßig liest eintabulatorbegrenzter Parser den gesamten String nach dem Tabulator bis zumZeilenumbruch (es sei denn, die Zeile enthält noch einen weiteren Anker oderTabulator).


28

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 mitder rechten Maustaste an. Wählen Sie die Option Als Startkomponentefestlegen.

Das bedeutet, dass ContentMaster MyFirstParser aktiviert, wenn Sie dasProjekt ausführen.

2. Im Menü wählen Sie Ausführen > MyFirstParser ausführen.

3. Nach einigen Sekunden zeigt ContentMaster Studio die Ereignisansicht an.Die Ereignisse umfassen beispielsweise alle Marker- und Content-Anker, dieder Parser in der Beispielquelle gefunden hat.

Sie können die Ereignisansicht dazu verwenden, eventuelle Fehler, diewährend der Ausführung aufgetreten sind, zu prüfen. Wenn Sie dieAnweisungen sorgfältig befolgt haben, sollte die Ausführung fehlerfreierfolgen.

4. Jetzt können Sie die Ausgabe, die der Parser erzeugt hat, überprüfen.Erweitern Sie im ContentMaster-Explorer den Tutorial_1 files/Results-Knoten und klicken Sie die Datei output.xml doppelt an.

ContentMaster Studio zeigt die XML-Datei in einem Internet Explorer-Fensteran. Prüfen Sie die Ausgabe sorgfältig und bestätigen Sie, dass die Ergebnisserichtig sind. Sind die Ergebnisse nicht richtig, überprüfen Sie die von Ihnenerstellte Parser-Konfiguration, korrigieren Sie eventuelle Fehler und versuchenSie es erneut.


29

Wenn Sie Windows XP SP2 oder höher verwenden, zeigt der Internet Explorereventuell eine Warnung an, die auf aktive Inhalte in der XML-Ergebnisdateihinweist. 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 (derMenübefehl Projekt > Eigenschaften). Sie können dieses Problem imAugenblick 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 >>. Damitwerden die erweiterten Eigenschaften der Komponente angezeigt.

Das Symbol >> verändert sich in <<. Sie können die erweiterten Eigenschaftenschließen, indem Sie das Symbol << anklicken.

Die erweiterten Eigenschaften anzeigen

2. Markieren Sie die Eigenschaft sources_to_extract und klicken Sie sie doppeltan oder drücken Sie Eingabe. Wählen Sie aus der Dropdown-Liste LocalFile.


30

3. Erweitern Sie den LocalFile-Knoten des IntelliScripts und weisen Sie dieEigenschaft file_name zu. ContentMaster Studio zeigt das Dialogfeld Öffnenan, in dem Sie nach der Datei suchen können.

Sie können eine der Test-Dateien verwenden, die wir mitgeliefert haben. Siebefinden sich im Ordner

tutorials\Exercises\Tutorial_1\Additional source files

Wählen Sei beispielsweise die Datei File2.txt mit folgendem Inhalt:

First Name: DanLast Name: SmithId: 45209875Age: 13Gender: M

4. Führen Sie den Parser erneut aus. Sie sollten dieselbe XML-Struktur erhaltenwie oben dargestellt, die die Daten enthält, die der Parser in der Testdateigefunden hat.

Woran Sie denken sollten

Ein ContentMaster-Projekt enthält die Parser-Konfiguration und das XSD-Schema.Üblicherweise enthält es auch das Beispiel-Quelldokument, dem der Parser dieDokumentstruktur entnimmt und andere Dateien, wie die Parsing-Ausgabe.


31

Der ContentMaster-Explorer zeigt die Projekte an, die in Ihrem ContentMasterStudio-Workspace vorhanden sind. Um ein bestehendes Projekt in den Workspacezu kopieren, verwenden Sie den Befehl Datei > Importieren.

Um eine Datenumwandlung zur Bearbeitung im IntelliScript-Editor zu öffnen,klicken Sie ihre TGP-Skriptdatei im ContentMaster-Explorer doppelt an. ImIntelliScript können Sie Komponenten, wie zum Beispiel Anker, hinzufügen. DieAnker definieren Positionen im Quelldokument, die der Parser sucht undverarbeitet. Marker-Anker bezeichnen die Datenfelder und Content-Ankerextrahieren 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ügenSie den Anker in das IntelliScript ein, wo Sie seine Eigenschaften festlegen können.Sie sollten beispielsweise den Datenbehälter festlegen – ein XML-Element oderAttribut – in dem ein Content-Anker seine Ausgabe speichert.

Verwenden Sie die Farbcodierung, um die Ankerdefinitionen zu überprüfen.

Die Begrenzungszeichen definieren die Beziehung zwischen den Ankern. DasFormat tabulatorbegrenzt bedeutet, dass die Anker durch Tabulatoren getrennt sind.

Um einen Parser zu testen, legen Sie ihn als Startkomponente fest. Verwenden Siedann den Befehl Ausführen im ContentMaster Studio-Menü. Um die Ergebnisdateianzuzeigen, doppelklicken Sie im ContentMaster-Explorer auf den Dateinamen.

Was kommt als Nächstes?

Glückwunsch! Sie haben Ihren ersten ContentMaster-Parser konfiguriert undausgeführt.

Die für das Parsen verwendeten Quelldokumente hatten natürlich eine sehreinfache Struktur. Die Dokumente enthielten ein paar Referenzpunkte, wobeijedem ein Tabulator und ein Inhalt folgte.

Darüberhinaus hatten alle Dokumente genau dieselben Referenzpunkte inderselben Reihenfolge. Das hat das Parsen sehr erleichtert, weil Sie die möglichenAbweichungen innerhalb der Quelldokumente nicht berücksichtigen mussten.

Wenn Sie Parser in der Praxis einsetzen, gibt es nur wenige Quelldokumente miteiner derart einfachen, starren Struktur. In den folgenden Kapiteln werden Sielernen, wie Sie komplexe und flexible Dokumentstrukturen mit Hilfe einerVielzahl von Parsing-Techniken parsen. Alle diese Techniken basieren jedoch aufden einfachen Schritten, die Sie in diesem Kapitel gelernt haben.

Erste Schritte mit ContentMaster, Band 1 4. Einen HL7-Parser definieren

32

Einen HL7-Parser definieren

In diesem Kapitel werden Sie eine HL7-Nachricht parsen. HL7 ist einStandardnachrichtenformat, das für medizinische Informationssysteme verwendetwird. Charakteristisch für seine Struktur ist eine Hierarchie vonBegrenzungszeichen und sich wiederholenden Elementen. Wenn Sie einmal dieTechniken gelernt haben, mit denen man diese Funktionen verarbeitet, sind Sieimstande eine Vielzahl von Dokumenten, wie sie in der Praxis verwendet werden,zu parsen.

Wie schon im vorhergehenden Kapitel, stellen wir Ihnen ein komplettkonfiguriertes XML-Schema zur Verfügung. Den Parser müssen Sie jedoch selbstkonfigurieren. Sie werden folgende Techniken lernen:

Ein Projekt erstellen

Einen Parser erstellen

Ein Dokument selektiv parsen, das heißt, ausgewählte Daten abrufen und denRest ignorieren

Eine sich wiederholende Gruppe definieren

Begrenzungszeichen verwenden, um die Quelldokument-Struktur zudefinieren

Einen Parser testen und debuggen

Anforderungsanalyse

Bevor Sie mit der Übung beginnen, wollen wir die Eingabe- undAusgabeanforderungen des Projekts analysieren. Beim Entwerfen des Parsersverwenden Sie diese Informationen, die die Konfiguration bestimmen.

HL7-Hintergrund

HL7 ist ein Standardnachrichten- und Transaktionsprotokoll für dasGesundheitswesen. Es wird weltweit in Krankenhäusern und medizinischenInformationssystemen eingesetzt.

Genauere Informationen über HL7 finden Sie auf der Health Level 7 Webseite,unter http://www.hl7.de.

4

http://www.hl7.de/


33

Eingabestruktur für HL7-Nachrichten

Die folgenden Zeilen zeigen eine typische HL7-Nachricht, die Sie alsQuelldokument für das Parsen verwenden werden.

MSH|^~\&|LAB||CDB||||ORU^R01|K172|PPID|||PATID1234^5^M11||Jones^William||19610613|MOBR||||80004^ElectrolytesOBX|1|ST|84295^Na||150|mmol/l|136-148|Above high normal|||Final resultsOBX|2|ST|84132^K+||4.5|mmol/l|3.5-5|Normal|||Final resultsOBX|3|ST|82435^Cl||102|mmol/l|94-105|Normal|||Final resultsOBX|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 einevordefinierte Hierarchie von Feldern und Subfeldern, die durch die Zeichen, diedem MSH-Bezeichner unmittelbar folgen, begrenzt werden (|^~\&).

Der Patientenname (Jones^William) folgt beispielsweise der PID-Bezeichnung undfünf | Begrenzungszeichen. Nach- und Vorname (Jones und William) sind durchein ^-Begrenzungszeichen getrennt.

Dieser Nachrichtentyp wird durch in Feld im MSH-Segment festgelegt. Im obenangegebenen Beispiel ist die Nachricht vom Typ ORU und Untertyp R01, das heißt,es ist eine unangeforderte Übermittlung eines Befundes. Das OBR-Segment gibt dieArt der Untersuchung an und das OBX-Segment listet die Untersuchungsergebnisseauf.

In diesem Kapitel werden Sie einen Parser konfigurieren, der ORU-Nachrichten, wiedas oben angeführte Beispiel, verarbeitet. Zu den Hauptpunkten bei derParserdefinition gehört, wie die Begrenzungszeichen definiert und wie die sichwiederholende OBX-Gruppe verarbeitet wird.

XML-Ausgabestruktur

Zweck dieser Übung ist es, einen Parser zu erstellen, der die obige HL7-Nachrichtin 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>


34

<value>...</value><range>...</range><comment>...</comment><status>...</status>

</Result><Result num="...">

<type>...</type><value>...</value><range>...</range><comment>...</comment><status>...</status>

</Result>

</Message>

Das XML hat Elemente, die viele – aber nicht alle – der Daten der HL7-Beispielnachricht speichern können. Das ist akzeptabel. In dieser Übung werdenSie einen Parser erstellen, der die Daten des Quelldokuments selektiv verarbeitet,das heißt, er ruft die benötigten Informationen ab und ignoriert den Rest. DieXML-Struktur enthält die Elemente, die für den Abruf benötigt werden.

Beachten Sie das sich wiederholende Element Result. Dieses Element speichertDaten aus dem sich wiederholenden OBX-Segment der HL7-Nachricht.

Ein Projekt erstellen

Als Erstes wollen wir ein Projekt erstellen, in dem ContentMaster Studio IhreArbeit speichern kann.

1. Klicken Sie im ContentMaster Studio-Menü auf Datei > Neu > Projekt.Daraufhin wird ein Assistent gestartet, in dem Sie den Projekttyp wählenkönnen.

2. Wählen Sie im linken Bereich ein ContentMaster-Projekt. Im rechten Bereichwählen Sie den Eintrag Parser-Projekt.


35

3. Auf der nächsten Seite des Assistenten geben Sie einen Projektnamen, wieetwa Tutorial_2 ein. ContentMaster erstellt einen Ordner und eine *.cmwKonfigurationsdatei mit diesem Namen.

4. Auf der nächsten Seite des Assistenten tragen Sie einen Namen für die Parser-Komponente 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, dieder 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-Strukturdefiniert, in der der Parser seine Ausgabe speichert. Wir haben ein Schema fürSie bereitgestellt. Der Speicherort im ContentMaster Installationsordner lautet:

tutorials\Exercises\Files_For_Tutorial_2\HL7_tutorial.xsd

Suchen Sie nach dieser Datei und klicken Sie auf Öffnen. ContentMasterStudio kopiert das Schema in den Projektordner.


36

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 Siealso Datei.

8. Auf der nächsten Seite werden Sie aufgefordert, nach der Beispielquelle zusuchen. Der Speicherort ist:

tutorials\Exercises\Files_For_Tutorial_2\hl7-obs.txt

ContentMaster Studio kopiert die Datei in den Projektordner.

9. Auf der nächsten Seite wählen Sie die Codierung des Quelldokuments. Indieser Übung ist die Codierung ASCII, was ohnehin die Standardeinstellungist.

10. Die Dokumentpräprozessor-Seite können Sie überspringen. Für dieses Projektbrauchen Sie keinen Dokumentpräprozessor.

11. Wählen Sie das Format des Quelldokuments. Bei diesem Projekt ist dasFormat HL7.

Das bedeutet, dass der Parser davon ausgehen soll, dass die Nachrichtenfelderdurch die HL7-Begrenzungshierarchie getrennt sind:

newline|Other symbols such as ^ and tab


37

Der Parser lernt beispielsweise, dass ein bestimmter Content-Anker drei | -Begrenzungszeichen nach einem Referenzpunkt beginnt und beim vierten |-Begrenzungszeichen endet.

12. Überprüfen Sie die Zusammenfassung auf der letzten Seite und klicken Sie aufFertigstellen.

13. Der ContentMaster erstellt das neue Projekt. Er zeigt das Projekt imContentMaster-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 undformat entsprechend Ihren Angaben zugewiesen wurden.

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 ContentMaster verwenden

Für ContentMaster Datenumwandlungen sind XSD-Schemas erforderlich, die dieStruktur der XML-Dokumente definieren. Jedes ContentMaster Parser-,Serialisierer- oder Mapper-Projekt benötigt mindestens ein Schema.

Für das Ausführen der Tutorial-Übungen in diesem Buch, stellen wir Ihnen diebenötigten Schemas zur Verfügung. Für Ihre eigenen Anwendungen haben Sievielleicht bereits Schemas oder Sie müssen neue Schemas erstellen.

XSD lernenEine ausgezeichnete Einführung in die XSD-Schemasyntax finden Sie im Tutorialauf der W3Schools-Webseite, http://www.w3schools.com. Maßgebliche

http://www.w3schools.com/


38

Referenzinformtionen finden Sie im XML-Schemastandard unterhttp://www.w3.org.

Schemas bearbeiten

Sie können die Schemas, die Sie mit ContentMaster verwenden, mit jedembeliebigen XSD-Editor erstellen und bearbeiten. Weitere Informationen finden Sieim Kapitel Datenbehälter im ContentMaster Studio Benutzerhandbuch.

Sie können den ContentMaster-Explorer so konfigurieren, dass er ein Schema imXSD-Editor Ihrer Wahl öffnet. Anweisungen dazu finden Sie unter ContentMasterStudio-Einstellungen im Buch ContentMaster Studio in Eclipse.

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 imQuelldokument angeben, und Content-Anker, die die Feldwerteidentifizieren.

Beginnen wir mit den sich nicht wiederholenden Teilen des Dokuments,nämlich den ersten drei Zeilen. Die praktischsten Referenzpunkte sind dieSegmentbezeichnungen MSH, PID und OBR. Diese Bezeichnungen geben Teiledes Dokuments an, die eine wohlgeformte Struktur haben.

Innerhalb jedes Segments müssen Sie die abzurufenden Datenfelderbestimmen. Das sind die Content-Anker. Für jeden Referenzpunkt gibt esmehrere Content-Anker.

Außerdem müssen Sie die Datenbehälter für jeden Content-Anker definieren.Die Datenbehälter sind Elemente oder Attribute in der XML-Ausgabe, dieoben abgebildet ist.

Wenn Sie die HL7-Nachricht und die XML-Struktur, die erzeugt werden soll,untersuchen, werden Sie wahrscheinlich herausfinden, welcheNachrichtenfelder als Anker definiert werden müssen, und Sie können dieFelder ihren entsprechenden Datenbehältern zuordnen. Um Ihnen Zeit zuersparen, haben wir das für Sie erledigt. Die Ergebnisse sind in der folgendenTabelle dargestellt:


MSH Marker

ORU Content /Message/@type

K172 Content /Message/@id

PID Marker

PATID1234^5^M11 Content /Message/*s/Patient/@id

http://www.w3.org/


39


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

Beachten Sie das @-Symbol in einigen der XPath-Ausdrücke, wie etwa/Message/@type. Das Symbol bedeutet, dass type ein Attribut und keinElement 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 fertigsind, sollte der IntelliScript-Editor wie in der folgenden Abbildung aussehen.

2. Jetzt müssen Sie dem Parser beibringen, wie er die OBX-Zeilen imQuelldokument verarbeiten soll. Es gibt mehrere OBX-Zeilen, die alle dasselbeFormat haben. Der Parser soll für jede OBX-Zeile, die er findet, eine Ausgabeerstellen.

Dafür definieren Sie einen Anker namens RepeatingGroup. Der Anker teiltdem ContentMaster mit, dass er nach einem wiederholten Segment suchensoll. Innerhalb der RepeatingGroup werden Sie mehrere Content-Ankereinbetten, die dem Parser mitteilen, wie er jede Wiederholung des Segmentsparsen soll.

Suchen Sie im IntelliScript-Bereich nach dem letzten von Ihnen definiertenAnker (Electrolytes). Unmittelbar unterhalb des Ankers ist ein leerer Knotenmit drei Punkten (...). Das ist die Stelle, an der Sie den neuen Ankerdefinieren.


40

Definieren Sie die RepeatingGroup am ...-Symbol in der Ankerliste

Markieren Sie die drei Punkte und drücken Sie die Eingabe-Taste. Daraufhinerscheint eine Dropdown-Liste, in der die Namen der verfügbaren Ankerangezeigt werden.

Wählen Sie in der Liste den RepeatingGroup-Anker. Alternativ dazu könnenSie den Text RepeatingGroup in das Feld eintippen. Nachdem Sie die erstenpaar Buchstaben eingeben, vervollständigt ContentMaster Studio die Eingabeautomatisch.

Drücken Sie nochmals die Eingabetaste, um den neuen Eintrag zuübernehmen.

3. Jetzt müssen Sie die RepeatingGroup konfigurieren, damit sie die sichwiederholenden Segmente identifizieren kann. Dazu weisen Sie dieEigenschaft separator zu. Sie geben an, dass die Segmente durch einenReferenzpunkt von einander getrennt sind, nämlich dem Text OBX .


41

Erweitern Sie im IntelliScript-Bereich die RepeatingGroup. Suchen Sie nach derZeile, die die Eigenschaft separator definiert.

Standardmäßig ist der Wert separator leer, was durch ein ...-Symbolangezeigt wird. Markieren Sie das ...-Symbol, drücken Sie Eingabe undändern Sie den Wert auf Marker. Drücken Sie nochmals Eingabe, um denneuen Wert zu übernehmen. Der Wert Marker bedeutet, dass die sichwiederholenden Elemente durch einen Marker-Anker getrennt sind.

Erweitern Sie die Marker-Eigenschaft und suchen Sie nach ihrer text-Eigenschaft. Markieren Sie den Wert (standardmäßig "") und drücken SieEingabe. Tippen Sie den Wert OBX ein und drücken Sie wieder Eingabe. Dasbedeutet, dass das Trennzeichen der Marker-Anker OBX ist.

ContentMaster Studio hebt im Beispielbereich alle OBX-Anker hervor, wasdarauf 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-Ankerinnerhalb der RepeatingGroup einbetten.

Sie sollten die Anker nur in der ersten OBX-Zeile definieren. Weil die Anker ineiner RepeatingGroup eingebettet sind, weiß der Parser, dass er in weiterenOBX-Zeilen nach denselben Ankern suchen soll.

Definieren Sie die Content-Anker wie folgt:


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 highnormal

Content /Message/*s/Result/*s/comment

Final results Content /Message/*s/Result/*s/status


42

Anker in einer RepeatingGroup einbetten

Wenn Sie fertig sind, sollten die Auszeichnungen im Beispielbereich wie folgtaussehen:

Das IntelliScript bearbeiten

Die oben beschriebene Vorgehensweise ist die übliche Methode zum Bearbeitendes 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 auchdoppelklicken, 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ürgibt es verschiedene Methoden:

Sie können die Farbcodierung in der Beispielquelle anzeigen. Damit wird diegrundlegende Anker-Konfiguration getestet.


43

Sie können den Parser ausführen, bestätigen, dass die Ereignisse fehlerfreisind und die XML-Ausgabe anzeigen. Damit wird die Parser-Operation an derBeispielquelle getestet.

Sie können den Parser mit weiteren Quelldokumenten ausführen Damit wirdbestätigt, dass der Parser beliebige Abweichungen in der Quellstruktur, dieeventuell in den Dokumenten auftreten, verarbeiten kann

In dieser Übung werden Sie die ersten zwei Methoden verwenden, um den Parserzu testen. Mit der dritten Testmethode befassen wir uns hier nicht. Sie ist aber ganzeinfach auszuführen (siehe Den Parser mit weiteren Quelldokumenten ausführen inKapitel 3, Grundlegende Parsing-Techniken).

1. Wählen Sie im Menü IntelliScript > Beispiel markieren. Alternativ dazukönnen Sie die Schaltfläche auf der rechten Seite der Symbolleiste, mit derBezeichnung Gesamtes Beispiel entsprechend des aktuellen Skripts markieren,anklicken.

Beachten Sie, dass die Farbcodierung auf die gesamte Beispielquelle erweitertwird. Zuvor wurden nur die Anker, die Sie in der ersten Zeile der sichwiederholenden Gruppe definiert haben, hervorgehoben. Beim Ausführen desBefehls Beispiel markieren hat der ContentMaster den Parser ausgeführt unddie Anker in den anderen Zeilen gefunden.

Bestätigen Sie, dass die Markierung Ihren Erwartungen entspricht. Prüfen Siebeispielsweise, ob der Testwert, -bereich und –kommentar in jeder OBX-Zeilerichtig identifiziert wurden.

Wenn die Markierung nicht stimmt (oder nicht vorhanden ist), ist in derParser-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 derKonfiguration absichtlich einen Fehler machen.

Erinnern Sie sich an die Option für HL7-Begrenzungszeichen, die Sie imAssistenten „Neuer Parser“ (siehe Ein Projekt erstellen weiter oben ) definierthaben? Geben wir dieser Option nun einen anderen Wert:

a. Speichern Sie Ihre Arbeit (falls Sie während dieses Experiments einenschwerwiegenden Fehler machen).

b. Bearbeiten Sie die Eigenschaft delimiters (sie befindet sich unterParser/format).


44

c. Ändern Sie den Wert von HL7 auf Positional. Dies bedeutet, dass sich dieContent-Anker an festen Positionen (Anzahl von Zeichen) hinter denMarkern befinden.

d. Führen Sie den Befehl „Beispiel markieren“ erneut aus. Die Anker werdennicht richtig identifiziert. In der zweiten OBX-Zeile etwa wird derKommentar als rmal|||Final resu statt als Normal angegeben. DiesesProblem entsteht, weil der Parser annimmt, dass sich die Anker an einerfesten 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 Siestattdessen auf Bearbeiten > Rückgängig, um die vorherige Konfigurationwiederherzustellen.)

f. Speichern Sie Ihre Arbeit erneut.

3. Jetzt können Sie den Parser ausführen. Klicken Sie die Parser-Komponentemit 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 keineFehler enthält.

Wenn Sie den Ereignisbaum durchsuchen, werden Sie ein Ereignis finden, dasmit einem -Symbol versehen ist, das für einen optionalen Fehler steht. DasEreignis befindet sich in der Baumstruktur unter Execution/RepeatingGroupund trägt die Bezeichnung Separator before 5. Das heißt, dass RepeatingGroupeine fünfte Wiederholung des OBX-Trennzeichens nicht finden konnte. Das istdas erwartete Ergebnis, denn die Beispielquelle enthält nur vierWiederholungen. Der Fehler wird optional genannt, weil es erlaubt ist, dassdas Trennzeichen am Ende der Wiederholungen fehlt.

Innerhalb des optionalen Fehlerereignisses ist ein -Symbol eingebettet, dasfür einen Fehler steht. Das Ereignis bedeutet, dass ContentMaster den Marker-Anker nicht gefunden hat, der das OBX-Trennzeichen definiert. Da der Fehlerin einen optionalen Fehler eingebettet ist, besteht kein Grund zur Sorge.

Im Allgemeinen sollten Sie einem Fehlerereignis aber Beachtung schenkenund seiner Ursache auf den Grund gehen. Ein Fehler weist häufig auf einProblem im Parser hin.


45

Neben Fehlerereignissen sollten Sie (Warnung)-Ereignissen und(schwerwiegender Fehler)-Ereignissen Beachtung schenken. Warnungen sindweniger schwerwiegend als Fehler. Schwerwiegende Fehler sind amgravierendsten; sie brechen die Datenumwandlung ab.

5. Versuchen Sie im rechten Bereich der Ereignisansicht eines der Marker- oderContent-Ereignisse doppelt anzuklicken.

Daraufhin hebt der ContentMaster den Anker, der das Ereignis verursacht hat,im IntelliScript- und im Beispielbereich hervor. Das ist eine gute Methode, umdie Ursache von Fehlern oder Fehlerereignissen zu finden.

6. Doppelklicken Sie im ContentMaster-Explorer auf die Datei output.xml, diesich unter dem Knoten Tutorial_2 files/Results befindet. Jetzt solltefolgende XML angezeigt werden:


46


Um ein neues Projekt zu erstellen, führen Sie den Befehl Datei > Neu > Projekt aus.Daraufhin erscheint ein Assistent, mit dem Sie folgende Optionen festlegenkö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 Begrenzungszeichen, die die Datenfelder trennen

Nachdem Sie das Projekt erstellt haben, bearbeiten Sie das IntelliScript und fügendie Anker hinzu, zum Beispiel Marker- und Content-Anker für einfacheDatenstrukturen oder RepeatingGroup-Anker für wiederholt auftretendeStrukturen.

Um das IntelliScript zu bearbeiten, verwenden Sie die Methode Markieren-Eingabe-Zuweisen-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 Siewieder Eingabe.

Testen Sie den Parser, indem Sie den Befehl IntelliScript > Beispiel markierenwählen, um die Anker mit einer Farbcodierung zu versehen.

Führen Sie den Parser aus und prüfen Sie die Ereignisse auf Warnungen, Fehleroder schwerwiegende Fehler. Prüfen Sie die Ergebnisdatei, die die XML-Ausgabeenthält.

Erste Schritte mit ContentMaster, Band 1 Index

47

Index Band 1

A

AcrobatContentMaster-Umwandlungen, 4

AnkerContent, 19definieren, 27Marker, 19RepeatingGroup, 39

Ansicht Binärquelle, 17Ansichten

ContentMaster Studio, 16API

der ContentMaster Engine, 4Attribute

XML, 2Aufgabenansicht, 17

B

BegrenzungszeichenTabulator, 19

Beispielbereich, 18Beispiel-Quelldokument, 15

C

CMW-Dateien, 15Content

Anker, 19ContentMaster

Überblick, 1ContentMaster Engine, 3ContentMaster Studio, 3

öffnen, 12ContentMaster-Dienste, 3ContentMaster-Explorer, 16

D

DatenbehälterBedeutung, 23

DebuggenParser , 42

DiensteContentMaster, 3

DokumenteDefinition, 3

E

EditorenContentMaster Studio, 16

ElementeXML, 2

Ereignisansicht, 17Ereignisinformationen, 44Ereignisprotokoll

interpretieren, 44Ergebnisdateien, 15

F

Fehlerin der Parser-Konfiguration korrigieren, 26

Fehlerereignisse, 44, 45Fenster

ContentMaster Studio, 16Format

Tabulatorbegrenzt, 27Format Tabulatorbegrenzt, 27Funktionen

ContentMaster -Tutorial, 5

G

gültiges XML, 2

H

Hallo WeltContentMaster-Tutorial, 12

HauptelementeXML, 2

Hilfeanzeigen, 8

Hilfeansicht, 17


48

HL7ContentMaster-Umwandlungen, 4Hintergrund, 32Nachrichtenstruktur , 33Parsing-Tutorial, 32

HTML-DokumenteContentMaster-Umwandlungen, 5

I

InstallationContentMaster, 9

IntelliScriptFehler korrigieren, 26

IntelliScript-Assistent, 17IntelliScript-Bereich, 18IntelliScript-Editor, 18

öffnen, 18

K

KomponentenContentMaster-Tutorial, 5

Komponentenansicht, 17Kurzreferenz

ContentMaster -Tutorials, 5

L

Leerräumein XML, 2

LizenzContentMaster, 10

Lösungenfür Übungen zu Erste Schritte, 10

M

MapperDefinition, 1

MarkerAnker, 19

P

ParsenHL7-Tutorial, 32

Parsen gemäß Beispiel, 1, 3Parser

Definition, 1in ContentMaster Studio ausführen, 28testen und debuggen, 42

ParsingAnfänger-Tutorial, 12

PDF-DateienContentMaster-Umwandlungen, 4

PerspektiveContentMaster Studio erstellen, 12

wiederherstellen, 13Projekte

erstellen, 34importieren, 14

Q

Quelldokumenteweitere testen, 29

R

RegistrierungContentMaster, 10

RepeatingGroupAnker, 39

S

SchemaXML, 2

Schema-Ansicht, 17Schemadateien, 15Schemas

XSD, 37schwerwiegende Fehler-Ereignisse, 45Serialisierer

Definition, 1Skriptdateien

TGP, 15Speicheransicht, 18Startkomponente

festlegen, 28Subelemente

XML, 2Systemvoraussetzungen

ContentMaster, 9

T

Tabulator-Begrenzungszeichen, 19Testen

Parser, 42Textdateien

Parsing-Tutorial, 12TGP-Skriptdateien, 15Trennzeichen

der sich wiederholenden Gruppe, 41Tutorial_1

grundlegende Parsing-Techniken, 12Tutorial_2

einen Parser definieren, 32Tutorial-Ordner

kopieren, 10Tutorials

grundlegende Parsing-Techniken, 12HL7-Parser , 32


49

V

VokabularXML, 2

W

Warnungsereignisse, 45Webseiten

ContentMaster-Umwandlungen, 5Willkommensseite

in Eclipse anzeigen, 13wohlgeformtes XML, 2

X

XMLStandards, 3Tutorial, 3Überblick, 1

XPathAnker-Mappings definieren, 24ContentMaster-Erweiterungen, 24

XSDReferenzinformationen, 38

XSD-Schemas, 37



Band 2: FortgeschritteneÜbungen

Version 4.0


Rechtlicher Hinweis

Erste Schritte mit ContentMaster, Band 2: Fortgeschrittene Übungen

Copyright © 2005-2006 Itemfield Inc. Alle Rechte vorbehalten.

Itemfield hat möglicherweise Patente, angemeldete Patente, Marken, Urheberrechte oder sonstigeRechte an geistigem Eigentum inne, die Inhalte dieses Dokumentes abdecken. Sofern nichts anderesausdrücklich in einem schriftlichen Lizenzvertrag mit Itemfield vereinbart wurde, erhalten Sie durchdie Bereitstellung dieses Dokumentes keinerlei Anspruch auf diese Patente, Marken, Urheberrechteoder auf sonstiges geistiges Eigentum.

Die in diesem Dokument enthaltenen Informationen können jederzeit ohne vorherige Ankündigunggeändert werden. Der Anwender trägt die Verantwortung für die Einhaltung aller anwendbarenUrheberrechte. Ohne ausdrückliche schriftliche Genehmigung durch Itemfield Inc. darf kein Teil diesesDokumentes in irgendeiner Form oder auf irgendeine elektronische oder mechanische Weise zuirgendeinem Zweck vervielfältigt oder weitergegeben werden.

SAP AGhttp://www.sap.com

Angaben zur Veröffentlichung:

Version: 4.0Date: Januar 2006


i

Inhalt Band 2

5. Positionsparsen eines PDF-Dokuments .........................................1Anforderungsanalyse.............................................................................................................................2

Quelldokument ................................................................................................................................ 2XML-Ausgabe.................................................................................................................................. 4Die Parsing-Aufgabe ....................................................................................................................... 5

Das Projektanlegen ............................................................................................................................... 6Die Anker definieren.............................................................................................................................. 8

Näheres über den Suchbereich.....................................................................................................13Eingebettete, sich wiederholende Gruppen definieren........................................................................14

Grundeigenschaften und erweiterte Eigenschaften ...................................................................... 21Aktionen verwenden, um Zwischensummen zu berechnen ................................................................ 22

Aktionen ........................................................................................................................................25Potenzielle Verbesserung: Wie Sie mit Seitenumbrüchen umgehen ............................................25

Woran Sie denken sollten....................................................................................................................25

6. Word- und HTML-Dokumente parsen............................................27Anforderungsanalyse...........................................................................................................................28

Quelldokument ..............................................................................................................................29XML-Ausgabe................................................................................................................................ 30Die Parsing-Aufgabe ..................................................................................................................... 30

Das Projektanlegen .............................................................................................................................32Eine Variable definieren ......................................................................................................................33Namen und Adresse parsen ................................................................................................................35

Warum die Ausgabe leere Elemente enthält................................................................................. 37Die optionale Währungszeile parsen................................................................................................... 37Die Auftragstabelle parsen ..................................................................................................................39

Warum die Ausgabe keinen HTML-Code enthält.......................................................................... 44Mit Hilfe von Count Mehrdeutigkeiten ausschließen .....................................................................47

Transformatoren verwenden, um die Ausgabe zu ändern ..................................................................47Globale Komponenten...................................................................................................................51

Den Parser mit einem anderen Quelldokument testen........................................................................52Woran Sie denken sollten....................................................................................................................53


ii

7. Einen Serialisierer definieren ........................................................55Voraussetzungen:................................................................................................................................ 55Anforderungsanalyse...........................................................................................................................55Das Projekt anlegen ............................................................................................................................ 57

Speicherort des Projektordners bestimmen ..................................................................................58Den Serialisierer konfigurieren ............................................................................................................59Den Serialisierer rekursiv aufrufen ...................................................................................................... 61

Mehrere Komponenten in einem Projekt definieren ...................................................................... 62Woran Sie denken sollten....................................................................................................................64

8. Einen Mapper definieren ................................................................65Anforderungsanalyse...........................................................................................................................65Das Projekt anlegen ............................................................................................................................ 66Den Mapper konfigurieren ...................................................................................................................67Woran Sie denken sollten....................................................................................................................70

9. ContentMaster Engine ausführen .................................................71Einen Parser als einen Dienst bereitstellen.........................................................................................71ContentMaster COM API-Anwendung.................................................................................................72

Quellcode ...................................................................................................................................... 72Erläuterung der API-Aufrufe.......................................................................................................... 74

Die COM API-Anwendung ausführen..................................................................................................75Woran Sie denken sollten....................................................................................................................77

Index Band 2 .......................................................................................78

Erste Schritte mit ContentMaster, Band 2 5. Positionsparsen eines PDF-Dokuments

1

Positionsparsen eines PDF-Dokuments

Bei vielen Parsing-Anwendungen haben die Quelldokumente ein festesSeitenlayout. Das gilt beispielsweise für Rechnungen und Kontoauszüge. Insolchen Fällen können Sie einen Parser konfigurieren, der das Format positionalverwendet, um die Datenfelder zu finden.

In diesem Kapitel werden Sie das Positionsparsen anwenden, um einRechnungsformular zu parsen. Sie definieren die Content-Anker aufgrund ihresZeichenabstands von den Referenzpunkten.

Neben dem Positionsparsen demonstriert diese Übung noch ein paar weiterewichtige ContentMaster-Funktionen:

Das Quelldokument ist eine Adobe Acrobat PDF-Datei. Der Parser verwendeteinen Dokumentprozessor, um das Dokument vom binären PDF-Format in einTextformat 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 imQuelldokument nicht vorhanden sind.

Das Dokument enthält eine große Menge irrelevanter Daten, die für dasParsen nicht benötigt werden. Einige der irrelevanten Daten enthaltendieselben Referenzpunkt-Strings wie die gewünschten Daten. Diese Übungführt das Konzept des Suchbereichs ein, das Sie dazu verwenden können, dieSuche nach Ankern einzuschränken und die gewünschten Daten zuverlässigzu identifizieren.

Um den Parser zu konfigurieren, verwenden Sie sowohl die Grundeigenschaftender 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 machenSie Arbeitsschritte rückgängig, wenn Sie einen Fehler machen. Mit etwas Übungwerden Sie Parser wie diesen problemlos erstellen!

5


2

Anforderungsanalyse

Bevor Sie damit beginnen, ein ContentMaster-Projekt zu konfigurieren, sollten Siedas 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 (auchbekannt als Adobe Acrobat Reader), Version 4 oder höher. Wenn Sie den AdobeReader nicht haben, können Sie ihn unter http://www.adobe.com herunterladen. (Siebrauchen den Adobe Reader nur, um das Dokument anzuzeigen. DerContentMaster hat eine integrierte Komponente für die Verarbeitung von PDF-Dokumenten und benötigt keine zusätzliche Adobe Software.)

Im Adobe Reader öffnen Sie die Datei, die sich im ContentMaster-Installationsordner befindet:

tutorials\Exercises\Files_for_Tutorial_3\Invoice.pdf

Bei diesem Dokument handelt es sich um eine Rechnung, die ein fiktiver Eier- undMolkereiprodukte-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.

http://www.adobe.com/


3

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äufegetä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ürjeden Einkauf, der ein Leerraum folgt.

Auf der zweiten Seite gibt es oben eine Kopfzeile. Am Seitenende stehen weitereTextbausteine.


4

Diese Struktur ist für viele Rechnungen typisch: eine Aufstellungsseite, der einesich wiederholende Struktur für verschiedene Kontonummern, Kreditkarten usw.folgt. Ein Unternehmen speichert solche Rechnungen unter Umständen als PDF-Dateien statt auf Papier. Es verwendet die PDF-Rechnungen eventuell für eineOnline-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 eineSystem-Integrationsanwendung machen, müssen Sie auf sehr hohe Zuverlässigkeitachten.

XML-Ausgabe

Für den Zweck dieser Übung gehen wir davon aus, dass Sie die Transaktionsdatenaus 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>


5

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

</Buyer><Buyer name="Jack" total="133.37">

</Buyer>

</Invoice>

Die Struktur enthält mehrere Buyer-Elemente, und jedes Buyer-Element enthältwiederum mehrere Transaction-Elemente. Jedes Transaction-Element enthältausgewählte Daten über eine Transaktion: Datum, Bezugszeichen, Produkt undGesamtpreis.

Die Struktur lässt andere Daten über die Transaktion, die wir ignorieren wollen,weg. Die Struktur lässt beispielsweise den Nachlass, die Menge jedes Produktsund den Preis pro Einheit weg.

Jedes Buyer-Element enthält das Attribut total, das die Summe der Einkäufe desKäufers angibt. Die Summe pro Käufer ist in der Rechnung nicht enthalten. Wirmöchten, dass der ContentMaster sie berechnet.

Die Parsing-Aufgabe

Öffnen Sie die Datei Invoice.pdf im Editor. Sie erhalten in etwa folgende Anzeige:


6

Diese Binärdaten zu parsen ist unter Umständen möglich, aber auf jeden Fall sehrschwierig. Dazu müssten wir das interne PDF-Dateiformat gründlich verstehenund wir müssten uns sehr bemühen, Referenzpunkte und Inhalt eindeutig zuunterscheiden.

Wenn wir den Textinhalt des Dokuments extrahieren, erscheint das Parsen etwaseinfacher:

Apr 08 22536 large eggs 61.20 3.06 58.1460 dozen @ 1.02 per dozen

Apr 08 22536 cheddar cheese 45.90 2.30 43.6130 lbs. @ 1.53 per lb.

Die Transaktionsdaten sind in Spalten angeordnet. Die Position jedes Datenfeldesist in Relation zum linken und rechten Rand fix. Das ist ein perfekter Fall für dasPositionsparsen – 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 festenZeilenmuster 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, diewir nicht abrufen müssen. Die nächste Zeile ist leer. Wir können die sichwiederholende Zeilenstruktur heranziehen, um die Daten zu parsen.

Ein drittes Merkmal ist, dass der Gruppe von Transaktionen eine Überschriftvorangeht, 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 dasContentMaster-Projekt konfigurieren.

1. Verwenden Sie den Befehl Datei > Neu > Projekt, um ein Parser-Projektnamens 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.


7

c. Wenn Sie aufgefordert werden, das Schema anzugeben, suchen Sie nach derDatei OrshavaInvoice.xsd , die sich im Ordnertutorials\Exercises\Files_For_Tutorial_3 befindet.

d. Geben Sie an, dass die Beispielquelle eine Datei auf einem lokalenComputer 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 Sieden Prozessor PDF to Unicode (UTF-8).

Dieser Prozessor wandelt das binäre PDF-Format in das Textformat um, dasder Parser benötigt. Der Prozessor fügt Leerräume und Zeilenumbrüche in dieTextdatei ein und versucht, das Format der PDF-Datei so genau wie möglichnachzuvollziehen.

Hinweis: PDF to Unicode (UTF-8) ist eine Beschreibung des Prozessors, die imAssistenten angezeigt wird. Im IntelliScript können Sie den tatsächlichenNamen des Prozessors, der PdfToTxt_3_00 lautet, sehen.

4. Auf der nächsten Seite des Assistenten wählen Sie das Dokumentformat, undzwar CustomFormat. Diesen Wert werden Sie später ändern, wenn Sie dasIntelliScript bearbeiten.

5. Auf der letzten Seite klicken Sie auf Fertigstellen.

6. Nach ein paar Sekunden zeigt der ContentMaster-Explorer das ProjektTutorial_3 an, und die Skriptdatei wird in einem IntelliScript-Editor geöffnet.

7. Beachten Sie, dass die Beispielquelle im Beispielbereich im Textformatangezeigt wird. Das ist die Ausgabe des Dokumentprozessors. Sie werdenspäter Anker konfigurieren, die den Text verarbeiten.


8

Wenn der Adobe Reader auf Ihrem Computer installiert ist, klicken Sie imBeispielbereich unten auf die Registerkarte Browser. Diese Registerkarte zeigtdas Originaldokument in einem Microsoft Internet Explorer-Fenster an, dasden Adober Reader als Plug-in-Komponente verwendet, um die Dateianzuzeigen. Die Registerkarte Browser dient nur zur Anzeige. Sie sollten dannzur Registerkarte Quelle zurückkehren, um die Anker zu konfigurieren.

8. Nachdem das Projekt und der Parser angelegt wurden, sollten Sie ein paarFeinabstimmungen vornehmen, indem Sie das IntelliScript bearbeiten.

Erweitern Sie die Eigenschaft format des Parsers und verändern Sie ihrenWert von CustomFormat auf TextFormat. Das machen Sie deshalb, weil derParser die Textform des Dokuments, also die Ausgabe desDokumentprozessors, verarbeitet.

Ändern Sie in der Eigenschaft format den Wert delimiters auf Positional.Das bedeutet, dass der Parser die Struktur der Beispielquelle lernt, indem erdie 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:, derden Beginn des Textes kennzeichnet, den Sie parsen wollen. Definieren Sieden String als Marker-Anker, indem Sie ihn markieren, mit der rechtenMaustaste anklicken und Marker einfügen wählen


9

Der Referenzpunkt wird automatisch im IntelliScript angezeigt und Siewerden aufgefordert, die Einstellung für die Eigenschaft searchvorzunehmen. Wählen Sie den Wert TextSearch. Das ist dieStandardeinstellung. 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 erweitertenEigenschaften anzuzeigen. Wählen Sie unter Marker die Option Groß-/Kleinschreibung beachten. Diese Option bewirkt, dass der Parser nur nach demString ACCOUNT NO:, und nicht nach account no:, Account No: oderirgendeiner anderen Schreibweise sucht. Damit vermeiden Sie Probleme, sollteeine der anderen Schreibweisen im Dokument auftreten. Tatsächliche tauchtdie Schreibweise Account No: in der Kopfzeile der zweiten Seite auf.)

Obwohl es nicht unbedingt notwendig ist, empfehlen wir, dass Sie die OptionGroß-/Kleinschreibung beachten für alle Marker-Anker wählen, die Sie in dieserÜbung definieren.

Hinweis: Weitere Informationen über die erweiterten Eigenschaften finden Sieim Abschnitt Grundeigenschaften und erweiterte Eigenschaften weiter hinten indiesem Kapitel.

2. Markieren Sie in derselben Zeile des Quelldokuments nach dem Marker-Ankerden Eintrag 12345 und klicken Sie ihn mit der rechten Maustaste an. WählenSie im Popup-Menü Content-Abstand einfügen.

Damit fügen Sie einen Content-Anker ein, dessen Eigenschaftswerte für dasPositionsparsen geeignet sind. Die Eigenschaften lauten wie folgt:

opening_marker = OffsetSearch(1)Das bedeutet, dass der Text 12345 1 Zeichen nach dem Marker-Ankerbeginnt.

closing_marker = OffsetSearch(5)Das bedeutet, dass der Text 12345 5 Zeichen nachdem er beginnt, endet.


10

3. Bearbeiten Sie die Eigenschaft data_holder des Content-Ankers. Stellen Sieihren Wert auf /Invoice/@account ein. Das ist der Datenbehälter, in dem derContent-Anker den Text speichert, den er aus dem Quelldokument abruft.

4. Es gibt ein kleines Problem bei der Definition des Content-Ankers. Waspassiert, wenn ein Quelldokument eine Kontonummer wie 987654321 enthält,die länger ist als die Nummer in der Beispielquelle? Gemäß der aktuellenDefinition 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_markerdahingehend ändern, dass er nicht nur bis zum fünften Zeichen abruft,sondern bis zum Ende der Textzeile. Verändern Sie dafür den Wert desclosing_marker von OffsetSearch auf NewlineSearch.

5. Fahren Sie mit der nächsten Zeile der Beispielquelle fort und definieren SiePERIOD ENDING: als Marker-Anker.

6. Definieren Sie als Content-Anker mit Abstand-Eigenschaften. Ordnen Sie denContent-Anker dem Datenbehälter /Invoice/*s/Period_Ending zu. ÄndernSie den closing_marker auf NewlineSearch, um Quelldokumente zuunterstützen, in denen der Datenstring länger ist als in der Beispielquelle.


11

7. Gemäß der Anforderungsanalyse sind die nächsten Daten, die Sie abrufenwollen, der aktuelle Rechnungsbetrag. Führen Sie einen Bildlauf ein paarZeilen nach unten durch und definieren Sie CURRENT INVOICE als Marker-Anker.

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 paarLeerzeichen links vom String 351.01 in die Markierung mit auf. BeimPositionsparsen ist das wichtig, weil der Bereich links eventuell noch weitereZeichen enthält. Der Inhalt könnte beispielsweise auf 1351.01 lauten.

Wie oben, ändern Sie auch hier den closing_marker auf NewlineSearch, fürden Fall, dass sich die Zahl rechts von der Position in der Beispielquellebefindet.

9. Definieren Sie auf dieselbe Weise BALANCE DUE als Marker–Anker und 475.07als 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 derMarker- und Abstand-Content-Anker richtig ist. Es sollte wie folgt aussehen:


12

Beachten Sie, dass die genauen Abstände in Ihrer Lösung eventuell von jenenin der Abbildung abweichen. Die Abstände hängen von der Anzahl derLeerzeichen ab, die Sie links oder rechts von jedem Anker markiert haben.

11. Überprüfen Sie die Farbcodierung im Beispielbereich. Sie sollte wie folgtaussehen:

12. Klicken Sie PdfInvoiceParser mit der rechten Maustaste an und definieren Siees als Startkomponente.

13. Führen Sie den Parser aus und prüfen Sie die Ergebnisdatei an. Das Ergebnissollte 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 eineeingebettete, sich wiederholende Gruppe definieren, die die Transaction-Elemente erstellt.

Die sich wiederholende Gruppe beginnt in der Zeile Purchases by: , die sichauf Seite 2 der Rechnung befindet. Sie definieren Purchases by: alsTrennzeichen der sich wiederholenden Gruppe.


13

Es gibt jedoch einen Haken. Der String Purchases by: scheint auch am Endevon Seite 1 auf. Damit dies zu keinen Problemen führt, geben Sie an, dass derSuchbereich 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 gehtdavon aus, dass die Anker in der Reihenfolge definiert sind, in der sie imDokument aufscheinen. Deshalb sucht er ab dem Ende dieses Marker-Ankersnach der nächsten sich wiederholenden Gruppe.

Näheres über den Suchbereich

Wie erwähnt, dient der Page 2-Marker dazu, den Suchbereich für die folgende sichwiederholende Gruppe (die Sie im Folgenden definieren) festzulegen.

Eigentlich ist es die Aufgabe jedes Marker-Ankers, den Suchbereich für andereAnker festzulegen. Nehmen wir beispielsweise an, dass sich ein Content-Ankerzwischen zwei Marker-Ankern befindet. Der ContentMaster findet die Marker-Anker beim ersten Durchlauf durch das Dokument, den man Anfangsphase nennt.Bei einem zweiten Durchlauf, Hauptphase genannt, sucht der ContentMaster nachdem 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 ContentMasternach Ankern sucht, zu verfeinern. Sie können den ContentMaster zum Beispiel sokonfigurieren, dass er:

in der Anfangs-, Haupt- oder Endphase der Verarbeitung nach bestimmtenAnkern sucht

rückwärts nach Ankern sucht

zulässt, dass Anker einander überlagern

Anker findet, die Suchkriterien, wie etwa einem bestimmten Textstring, einemMuster (einem regulären Ausdruck) oder einem bestimmten Datentypentsprechen.


14

Den Suchbereich, die Phase und die Kriterien anzupassen ist eine derleistungsstärksten Funktionen, die der ContentMaster für das Parsen komplexerDokumente bietet. Wenn Sie sich umfassend darüber informieren möchten,empfehlen wir Ihnen, das Kapitel über Anker im ContentMaster StudioBenutzerhandbuch zu lesen.

Eingebettete, sich wiederholende Gruppen definieren

Jetzt müssen Sie einen RepeatingGroup-Anker definieren, der die sichwiederholende Purchases by: -Struktur parst. Innerhalb dieses Ankers definierenSie 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 eineRepeatingGroup ein.

2. Definieren Sie die Eigenschaft separator der RepeatingGroup als Marker, dereine TextSearch für den String Purchases by: durchführt.

Stellen Sie separator_position auf before ein. Das machen Sie, weil sich dasTrennzeichen vor jeder Wiederholung der sich wiederholenden Gruppebefindet.

Der ContentMaster hebt die Purchases by: -Strings im Beispielbereich hervor.


15

3. Fügen Sie innerhalb der RepeatingGroup einen Abstand-Content-Anker ein,der den Käufernamen, Molly, dem Datenbehälter /Invoice/*s/Buyer/@namezuordnet.

Vergessen Sie nicht, den closing_marker in NewlineSearch zu ändern, für denFall, dass der Käufername mehr als fünf Buchstaben enthält. (Wir werden Siein Zukunft nicht mehr daran erinnern. Immer, wenn Sie einen Abstand-Content-Anker definieren, sollten Sie prüfen, ob er Strings unterstützt, dieeventuell länger sind als die in der Beispielquelle.)

4. Wählen Sie im Menü IntelliScript > Beispiel markieren. Prüfen Sie, ob beideKäufernamen, Molly und Jack, hervorgehoben sind. Das bestätigt, dass derParser die Wiederholungen der RepeatingGroup richtig identifiziert.


16

Wenn Sie möchten, können Sie den Parser auch ausführen. Bestätigen Sie, dassdie Ergebnisdatei zwei Buyer-Elemente enthält.

5. Suchen Sie nach dem drei-Punkte-Symbol, das innerhalb der RepeatingGroupeingebettet ist und definieren Sie eine weitere RepeatingGroup.


17

6. Was können wir als Trennzeichen für die eingebettete RepeatingGroupverwenden? Zwischen den Transaktionen scheint es keinen charakteristischenText zu geben.

Anstelle eines Texttrennzeichens können wir die Tatsache verwenden, dassjede Transaktion genau vier Zeilen des Dokuments einnimmt. Wir können dievier Zeilenumbrüche als Trennzeichen verwenden.

Stellen Sie dafür die separator-Eigenschaft der eingebetteten RepeatingGroupauf einen Marker ein, der eine NewlineSearch verwendet. Klicken Sie das >>-Symbol am Ende des Marker-Ankers an, um seine erweiterten Eigenschaftenanzuzeigen und nehmen Sie die Einstellung count = 4 vor.

Sie können dann das <<-Symbol anklicken, um die erweiterten Eigenschaftenauszublenden.

Vor der ersten Transaktion und nach der letzten Transaktion gibt es keinTrennzeichen, also sollten Sie die Einstellung separator_position = betweenvornehmen.

Übrigens, wenn Sie das ursprüngliche PDF-Dokument sorgfältig prüfen,werden Sie feststellen, dass jede Transaktion nur drei Zeilen einnimmt. Aberwir parsen die Ausgabe des Dokumentprozessors. Aus irgendeinem Grund(der zweifellos mit der Binärstruktur der PDF-Datei zu tun hat), fügt derProzessor eine zusätzliche Zeile ein.


18

7. Definieren Sie in der ersten Zeile der ersten Transaktion (also Molly's erstemEinkauf), 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 Farbcodierungaufweisen. Die genaue Position der Farbcodierung hängt von der Anzahl derLeerräume ab, die Sie links und rechts von jedem Feld markiert haben.

Das IntelliScript sollte die vier Content-Anker innerhalb der eingebettetenRepeatingGroup anzeigen.


19

8. Führen Sie erneut den Befehl IntelliScript > Beispiel markieren aus. BestätigenSie, dass die Spalten Datum, Bezugszeichen, Produkt und Summe in allenTransaktionen hervorgehoben sind.

9. Erinnern Sie sich noch, wie wir den Suchbereich der äußeren RepeatingGroupeingeschränkt haben, indem wir Page 2 als Marker-Anker definiert haben? Esist eine gute Idee, auch am Ende der geschachtelten RepeatingGroup einenMarker zu definieren, um dafür zu sorgen, dass der ContentMaster nicht zuweit sucht.

Kehren Sie dafür zur Ankerliste der obersten Ebene zurück (die Ebene, auf derdie äußere RepeatingGroup definiert ist) und definieren Sie einen Teil desTextbausteins in der Fußzeile von Seite 2 als Marker. Definieren Siebeispielsweise den String For your convenience:.


20

10. Führen Sie den Parser aus. Sie sollten folgende Ausgabe erhalten:

11. Reduzieren Sie die Baumstruktur und bestätigen Sie, dass die zwei Buyer-Elemente 5 beziehungsweise 3 Transaktionen enthalten. Das ist die Anzahl derTransaktionen in der Beispielquelle.

Hinweis: Unter Windows XP ab SP2 zeigt der Internet Explorer eventuell einegelbe Informationsleiste an, die angibt, dass aktive Inhalte in der Dateiblockiert wurden. In diesem Fall können Sie den Baum nicht mit – und +zusammenklappen und erweitern. Heben Sie die Blockierung aktiver Inhalteauf und klappen Sie den Baum dann zusammen.


21

Überprüfen Sie wie immer, ob das Ereignisprotokoll irgendwelche Problemeenthält. Denken Sie daran, dass optionale Fehlerereignisse (und eingebettete

Fehlerereignisse) am Ende einer RepeatingGroup normal sind. Für nähereErlä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 erweitertenEigenschaften einzublenden. Dabei wird das >>-Symbol zu <<. Klicken Sie aufdas <<-Symbol, um die erweiterten Eigenschaften auszublenden.

Viele ContentMaster-Komponenten haben sowohl Grundeigenschaften als aucherweiterte Eigenschaften. Die Grundeigenschaften brauchen Sie am häufigsten,also werden sie standardmäßig angezeigt. Die erweiterten Eigenschaftenwerden nicht so oft benötigt, also blendet sie der ContentMaster aus. Wenn Siedas >>-Symbol anklicken, werden sie grau angezeigt.

Wenn Sie einer erweiterten Eigenschaft einen nicht-standardmäßigen Wertzuweisen, wird sie wie eine Grundeigenschaft schwarz angezeigt.

Grundeigenschaften und erweiterte Eigenschaften unterscheiden sich nur inder Anzeige. Die erweiterten Eigenschaften sind nicht schwerer zu verstehenoder komplizierter anzuwenden. Sie sollten Sie jederzeit bei Bedarf einsetzen.

IntelliScript mit eingeblendeten Grundeigenschaften. Klicken Sie auf >>, umdie erweiterten Eigenschaften anzuzeigen.


22

IntelliScript mit eingeblendeten Grund- und erweiterten Eigenschaften. KlickenSie auf <<, um die erweiterten Eigenschaften auszublenden.

Aktionen verwenden, um Zwischensummen zuberechnen

Die Übung ist abgeschlossen, bis auf eine Funktion. Sie müssen für jeden Käuferdie Zwischensumme berechnen, und das Ergebnis in das Attribut total des Buyer-Elements 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 totalmit 0.

Nachdem der Parser eine Transaktion verarbeitet hat, fügen Sie total denBetrag der Transaktion hinzu.

Sie verwenden eine SetValue-Aktion, um die Initialisierung durchzuführen. Sieverwenden eine CalculateValue-Aktion, um den Betrag hinzuzufügen.

1. Erweitern Sie das IntelliScript, um die eingebettete RepeatingGroupanzuzeigen.

2. Klicken Sie die eingebettete RepeatingGroup mit der rechten Maustaste an, undwählen Sie Einfügen aus dem Popup-Menü. Auf diese Weise können Sieoberhalb der RepeatingGroup einen neuen Anker einfügen.


23

3. Fügen Sie die SetValue-Aktion ein und legen Sie ihre Eigenschaften wie folgtfest:

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 dreiPunkten (...) unter dem vierten Content-Anker eine CalculateValue-Aktionein.

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 paramsdefiniert die Parameter. In diesem Fall sind dieParameter das aktuelle Attribut total des Käufers (das wir mit 0 initialisierthaben) und das Element Total der aktuellen Transaktion.

Die Eigenschaft expression ist ein JavaScript-Ausdruck, den die Aktionausführen soll. $1 und $2 sind die Parameter, die Sie in der Eigenschaft paramsdefiniert haben.

Die Eigenschaft result gibt an, dass wir das Ergebnis des Ausdrucks alsneuen Wert des Attributs total zuweisen sollen.


24

6. Führen Sie den Parser aus. In der Ergebnisdatei sollte jedes Buyer-Element eintotal-Attribut haben.


25

Aktionen

In dieser Übung haben Sie die Aktionen SetValue und CalculateValue verwendet,um die Zwischensummen zu berechnen.

Ganz allgemein sind Aktionen ContentMaster-Komponenten, die Operationen mitDaten durchführen. Der ContentMaster bietet zahlreiche Aktionskomponenten, diefolgende 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 ContentMaster StudioBenutzerhandbuch.

Potenzielle Verbesserung: Wie Sie mit Seitenumbrüchen umgehen

Bisher haben wir angenommen, dass die sich wiederholenden Gruppen eine ganzregelmäß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 Trennzeichenzwischen den Transaktionen neu zu definieren. Sie könnten beispielsweise einenAlternatives-Anker als Trennzeichen verwenden. Auf diese Weise können Siemehrere Trennzeichen definieren, die zwischen den Transaktionen auftreten.

Für diese Verbesserung bieten wir Ihnen keine Übung, aber wir ersuchen Sie, mitdiesen Funktionen selbst zu experimentieren.


Um ein Binärformat, wie etwa eine PDF-Datei zu parsen, können Sie einenDokumentprozessor verwenden, der die Quelle in Text umwandelt.

Das Positionsparsen ist dann sinnvoll, wenn der Inhalt an einer fixen Position aufder Seite angeordnet ist, das heißt, in einem bestimmten Abstand von den Rändernoder von Referenzpunkten.

Wenn Sie Anker definieren, denken Sie an die möglichen Abweichungen, die inQuelldokumenten 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 alsdie Beispielquelle enthält.


26

Der Suchbereich ist der Abschnitt eines Dokuments, an dem der ContentMasternach einem Anker sucht. Referenzpunkte dienen dazu, den Suchbereich für andereAnker zu definieren.

Sich wiederholende Gruppen können eingebettet sein. Sie können diese Funktionverwenden, um eingebettete, sich wiederholende Strukturen zu parsen.

Zeilenumbrüche sind nützliche Referenzpunkte und Trennzeichen. Sie können einenZähler für Zeilenumbrüche festlegen, der angibt, wie viele Zeilen übersprungenwerden sollen.

Im IntelliScript können Sie das >>-Symbol neben einer Komponente anklicken, umihre erweiterten Eigenschaften anzuzeigen. Erweiterte Eigenschaften werden seltenerverwendet als Grundeigenschaften, also werden sie ausgeblendet, um die Anzeigenicht zu überladen.

Sie können Aktionen verwenden, um Operationen mit Daten durchzuführen, wieetwa Summen zu berechnen.

Erste Schritte mit ContentMaster, Band 2 6. Word- und HTML-Dokumente parsen

27

Word- und HTML-Dokumente parsen

In der Praxis sind viele Dokumente viel lockerer strukturiert als wir es in denvorhergehenden Kapiteln beschrieben haben. Die Dokumente können Folgendesenthalten:

Wenige Bezeichnungen und Begrenzungszeichen, mit deren Hilfe ein ParserDatenfelder identifizieren kann.

Zeilenumbrüche und flexible Layouts, die ein Positionsparsen schwieriggestalten.

Schlüsselwörter, die wiederholt vorkommen, sodass es schwer ist, eindeutigeReferenzpunkte zu definieren.

Microsoft Word-Dokumente sind ein typisches Beispiel für dieses Phänomen.Word-Dokumente werden üblicherweise manuell erstellt (obwohl sie auchprogrammatisch erzeugt werden können). Die Autoren können die Dokumente aufder Grundlage einer bestimmten Vorlage erstellen, aber sie können das Layout vonDokument zu Dokument variieren.

In solchen Fällen können Sie nur die Auszeichnungen oder Muster verwenden, dievorhanden sind, um diese Dokumente zu parsen. Häufig können Sie zum Beispieldie Formatierungen verwenden – Absätze, Tabellen, kursiv usw. – um dieDatenfelder 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-Tagsverwenden, die im Grunde nur Formatbezeichnungen sind, um dieDokumentstruktur zu interpretieren.

In diesem Kapitel werden Sie einen Parser für ein Word-Dokument erstellen. Siewerden folgende Techniken lernen:

Den WordToHtml-Dokumentprozessor verwenden, der ein Word-Dokument inein HTML-Dokument umwandelt.

Die Anfangs- und Ende-Tag-Struktur nutzen, um ein HTML-Dokument zuparsen.

Anker eindeutig identifizieren, wenn derselbe Text im ganzen Dokumenthäufig wiederholt wird

Transformatoren verwenden, um die Ausgabe der Anker zu ändern.

Variablen verwenden, um die abgerufenen Daten zu speichern, um späterdarauf zugreifen zu können.

6


28

Eine globale Komponente definieren, die Sie einmal konfigurieren und mehrmalsin einem Projekt verwenden.

Einen Parser, neben der Beispielquelle, noch mit anderen Quelldokumententesten.

Umfang der ÜbungDiese Übung ist die längste und komplizierteste in diesem Buch. Sie ist typisch fürParsing-Szenarien wie sie in der Praxis vorkommen. Sie werden einen Parser mitallen Funktionen erstellen, der in einer Produktionsanwendung eingesetzt werdenkönnte.

Wir empfehlen, dass Sie das Kapitel zuerst von Anfang bis Ende überfliegen, damitSie verstehen, wie der Parser funktionieren soll, und dann die Übung ausführen.Sie können gerne mit der Parser-Konfiguration experimentieren. Es kann sein, dassSie andere oder vielleicht sogar bessere Parsing-Lösungen finden als unsere.

Genau genommen, kennen wir ein paar Methoden, um den Parser weiter zuverbessern. 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 Elementeeinzuschränken, um dafür zu sorgen, dass der Parser genau die richtigen Datenaus einem komplexen Dokument abruft.

Wir haben die meisten dieser Feinheiten weggelassen, damit die Übung nicht zuumfangreich wird. Wenn Sie mit der Übung fertig sind, können Sie sicheingehender über die hier beschriebenen Techniken informieren, indem Sie dasContentMaster Studio Benutzerhandbuch lesen.

Voraussetzungen

Um diese Übung durchführen zu können, muss Microsoft Word 97 oder höher aufdemselben Computer wie ContentMaster Studio installiert sein.

Wenn Word auf demselben Computer nicht installiert ist, können Sie dasQuelldokument auf einem anderen Computer öffnen und als HTML speichern.Dann können Sie das HTML-Dokument auf den ContentMaster-Computerübertragen und parsen. Der Rest der Übung bleibt gleich, abgesehen davon, dassSie den WordToHtml-Prozessor nicht einsetzen müssen, weil das Dokument bereitsim HTML-Format vorliegt.

Wir gehen bei dieser Übung davon aus, dass Sie grundlegend mit HTML-Codevertraut sind. Eine Einführung finden Sie unter http://www.w3.org oder in jedemBuch über Webseitenerstellung.

Anforderungsanalyse

Bevor Sie damit beginnen, einen Parser zu konfigurieren, ist es immer eine guteIdee, zu planen, was der Parser tun soll. Untersuchen wir also dieQuelldokumentstruktur, die erforderliche XML-Ausgabe und die Art der Parsing-Aufgabe.

http://www.w3.org/


29

Quelldokument

Sie können die Beispielquelle in Microsoft Word anzeigen. Das Dokument ist infolgendem Ordner gespeichert:

tutorials\Exercises\Files_for_tutorial_4\Order.doc

Beim Dokument handelt es sich um ein Bestellformular für ein fiktivesUnternehmen 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 ersteSpaltenüberschrift Books (Bücher) lautet, handelt es sich bei einigen der in dieserSpalte zulässigen Artikel nicht um Bücher, sondern beispielsweise umVideokassetten. Es kann sein, dass diese Artikel in einer anderen Schriftartformatiert sind als die Bücher.


30

In einigen Zellen der Tabelle erfolgt ein Zeilenumbruch, das heißt, der Text wird ineiner zweiten Zeile fortgesetzt. Positionsparsen mit der Technik, die Sie imvorangehenden Kapitel gelernt haben, wäre bei diesen Zellen schwierig.

Die Tabellenzellen enthalten keine Bezeichnungen. Der Parser muss die Zellenentsprechend ihrer Position in der Tabelle interpretieren.

Das Wort Total erscheint dreimal in der Tabelle. In zwei von diesen Fällenbefindet sich das Wort in einer Spalten- oder Zeilenüberschrift; wir können davonausgehen, dass dies in allen ähnlichen Quelldokumenten auch der Fall ist. Imdritten Fall scheint Total zufällig im Titel der Videokassette auf. Das ist wichtig,weil wir die Tabellenzeile mit dem Gesamtpreis parsen wollen und eineneindeutigen Bezeichner für die Zeile benötigen.

Was die Sache zusätzlich kompliziert macht ist, dass die Zeile Currency optionalist. 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 folgtaussehen 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>

</Books><Total>$46.19</Total>

</Order>

Beachten Sie, dass die Preise und Summen das Währungssymbol ($) enthalten. ImQuelldokument wird die Währung in der optionalen Währungszeile angegeben,nicht in der Tabelle.

Die Parsing-Aufgabe

Prozessor-AuswahlDer ContentMaster bietet mehrere Dokumentprozessoren, die ein Word-Dokument in ein für das Parsen geeignetes Format umwandeln können. Dazugehören:


31

WordToHtmlWordToRtfWordToTxtWordToXml

Wir entscheiden uns für den WordToHtml-Prozessor, weil:

Der HTML-Code leicht zu lesen und der Parser somit einfach zu konfigurierenist.

Die HTML-Tags eine Reihe von Formatierungsinformationen offenlegen, dieuns dabei helfen, die abzurufenden Daten zu identifizieren.

Der WordToXml- und der WordToRtf-Prozessor wären auch eine gute Wahl, aber ihreAusgabe ist weit schwerer zu lesen als die des WordToHtml-Prozessors.

Der WordToTxt-Prozessor erzeugt eine reine Textausgabe. Da diesem Text jeglicheFormatierungsinformationen fehlen, wäre es vermutlich viel schwerer, ihnzuverlässig zu parsen, als die HTML-Datei.

HTML-StrukturDer WordToHtml-Prozessor verwendet die Funktion Als Webseite speichern vonMicrosoft Word, um die HTML-Datei zu erzeugen. Die HTML-Datei ist äußerstwortreich; sie kann viele Seiten umfassen, auch wenn das ursprüngliche Word-Dokument kürzer als eine Seite war. Der Grund dafür ist, dass Word diekompletten Dokumentmerkmale, einschließlich Formatvorlagen- undFormatierungsangaben, speichert. Ein Großteil dieser Informationen wirkt sichnicht auf die HTML-Darstellung in einem Web-Browser aus, aber Word verwendetdiese Informationen, wenn Sie die HTML-Datei später wieder in Word importierenmö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 alsWebseite speichern. Die daraus resultierende HTML-Datei können Sie in einemBrowser anzeigen oder Sie können die Datei im Editor öffnen und den HTML-Code überprüfen.

Im Überblick sieht der Code wie folgt aus:

<html>\<header>

</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>

</tr><tr>


32

<td><i>Topspin Serves Made Easy</i>, by Roland Fasthitter</td><td>$11.50</td><td>1</td><td>$11.50</td>

</tr>

</table></body>

</html>

Diese grundlegende HTML-Tag-Struktur werden Sie verwenden, um dasDokument zu parsen.

Der tatsächliche Code ist wesentlich komplexer als im obigen Überblick. Derfolgende 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 einwenig anders aussehen, je nach Ihrer Word-Version und Konfiguration.

<td width=168 valign=top style='width:125.9pt;border:solid windowtext1.0pt;border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt'><pclass=MsoBodyText><i style='mso-bidi-font-style:normal'>Topspin ServesMade Easy</i>, by Roland <span class=SpellE>Fasthitter</span></p></td>

Sobald Sie mit der aus einem Word-Dokument erzeugten HTML-Datei zu arbeitenbeginnen, werden Sie schnell lernen, die wichtigen Struktur-Tags, wie zumBeispiel das <td>...</td>-Element zu finden. Den irrelevanten Code, wie etwa dielangen Attribute und <span>-Tags, können Sie ignorieren.

Das Projektanlegen

1. Beginnen Sie mit der Übung, indem Sie ein Projekt namens Tutorial_4anlegen. 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.


33

h. Wählen Sie das Format HTML format. Diese Formatkomponente ist mit denpassenden Begrenzungszeichen und anderen Komponenten für das Parsenvon HTML-Code konfiguriert.

Das daraus resultierende IntelliScript sollte wie folgt aussehen:

2. Wenn ContentMaster Studio die Beispielquelle öffnet, kann es sein, dass eineMicrosoft Internet Explorer-Meldung für das Öffnen oder Speichern der Dateierscheint. Der Grund dafür ist, dass ContentMaster Studio den InternetExplorer verwendet, um eine Browser-Ansicht der Datei anzuzeigen. DasVerhalten 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 derBeispielquelle? Wir müssen das Währungssymbol zwar abrufen, aber wir wollenes keinem Ausgabeelement oder -attribut zuordnen. Stattdessen wollen wir dasWährungssymbol vorübergehend speichern und den Preisen in der Ausgabevoranstellen.

Dafür definieren wir einen temporären Datenbehälter, Variable genannt. Siekönnen eine Variable genau gleich einsetzen wie einen Element- oder Attribut-Datenbehä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 derParser-Komponente eingebettet) die drei Punkte (...) und drücken Sie Eingabe.


34

2. Geben Sie den Variablennamen, varCurrency, ein und drücken Sie Eingabe.

3. An den drei Punkten rechts vom Gleichheitszeichen (=) drücken Sie Eingabeund wählen Variable .

Die Variable wird im IntelliScript, in der Schema-Ansicht und in derKomponentenansicht angezeigt.

Variablendefinition im IntelliScript

Anzeige der Variablen in der Komponentenansicht

Anzeige der Variablen in der Schema-Ansicht

Beachten Sie die Position der Variablen in der Schema-Ansicht, nämlicheingebettet im Namensraum www.ContentMaster.com/CM/Variables. Spätermüssen Sie auf die Variable in der Schema-Ansicht zugreifen.


35

Namen und Adresse parsen

Als Erstes wollen wir die Anker definieren, die den Namen und die Adresse amAnfang der Beispielquelle parsen. Führen Sie folgende Schritte aus:

1. Führen Sie im Beispielbereich einen Bildlauf nach dem Header bis zum body-Tag durch (ungefähr 80% nach unten!).

Um den Bildlauf zu beschleunigen, können Sie im Beispielbereich mit derrechten 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 denHeader komplett (so wie Sie das beim Bildlauf durch das Dokument getanhaben).

Wählen Sie die Eigenschaft match_case für diesen Anker oder für andereHTML-Tags, die Sie in dieser Übung als Anker definieren, nicht. HTMLunterscheidet nicht zwischen Groß- und Kleinschreibung. Word 2000 und2002 generiert HTML-Tags in Kleinbuchstaben, aber Word 97 generiert Tagsin 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 denString 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 angegebenenSchreibweise zu suchen.

4. Jetzt können Sie den ersten Content-Anker definieren. Sie konfigurieren denAnker so, dass er die Daten zwischen den angegebenen Anfangs- und Ende-Strings abruft. Ein auf diese Weise definierter Content-Anker ist einer MarkerContent Marker-Sequenz ähnlich (die Sie auch verwenden können, wenn Siemöchten).


36

Klicken Sie dazu den String Becky Handler an und fügen Sie einen Content-Anker ein. Nehmen Sie im IntelliScript folgende Zuweisungen vor:

opening_markerGeben Sie den String <p ein.

closing_markerGeben Sie den String </p> ein.

data_holderOrdnen Sie den Anker /Order/*s/To zu.

Wenn Sie mit diesen Zuweisungen fertig sind, werden <p und </p> imBeispielbereich als Marker-Anker hervorgehoben. Becky Handler wird alsContent-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 dasSymbol > als Begrenzungszeichen erkennt. Es lernt aus der Beispielquelle, dasssich der gewünschte Inhalt nach dem >-Begrenzungszeichen befindet.

5. Gehen Sie zum nächsten Absatz der Quelle über und verwenden Sie dieselbeMethode (opening_marker und closing_marker definieren), um 18 CrossCourt, Down-the-Line, PA dem Datenbehälter /Order/*s/Addresszuzuordnen.


37

6. Führen Sie den Parser aus und bestätigen Sie, dass Sie folgendes Ergebniserhalten:

Warum die Ausgabe leere Elemente enthält

Beachten Sie, dass der Parser leere Books- und Total-Elemente einfügt. Der Grunddafür ist, dass das XSD-Schema Books und Total als erforderliche Elementedefiniert. Der Parser fügt die Elemente ein, um dafür zu sorgen, dass die XML-Ausgabe gemäß dem Schema gültig ist (Sie können dieses Verhalten in denProjekteigenschaften ändern). Die Elemente sind leer, weil wir die Tabelle mit denBüchern noch nicht geparst haben.

Die optionale Währungszeile parsen

Wenn das Quelldokument eine Currency-Zeile enthält, müssen Sie sie parsen unddas Ergebnis in der Variablen varCurrency speichern, die Sie weiter oben erstellthaben. Wenn die Currency-Zeile fehlt, soll der Parser dies ignorieren und den Restdes Dokuments parsen.

Gehen Sie dazu wie folgt vor:

Definieren Sie einen Group-Anker. Zweck dieses Ankers ist es, eine Gruppevon eingebetteten Ankern zusammenzufassen, und als Einheit zu verarbeiten.

Betten Sie innerhalb der Gruppe Marker- und Content-Anker ein, die dieWä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-Ankerfehlt) soll der Parser weiter ausgeführt werden.


38

Gehen Sie wie folgt vor:

1. Fügen Sie nach den Ankern, die Sie bereits definiert haben, einen Group-Ankerein.

2. Markieren Sie die drei Punkte, die innerhalb des Group-Ankers eingebettetsind. 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 weiteroben definiert haben.

4. Klicken Sie auf das >>-Symbol, um die erweiterten Eigenschaften von Groupanzuzeigen und wählen Sie die Eigenschaft optional. (Achten Sie darauf, dieEigenschaft optional von Group zu wählen, und nicht die Eigenschaftoptional des Marker- oder Content-Ankers.)


39

Die Auftragstabelle parsen

Wie Sie in den vorangehenden Übungen gesehen haben, können Sie dieAuftragstabelle 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 dieAnfangs- und Ende-Tag-Struktur erkennt, die für diesen Code typisch ist. Konkretwerden Sie den EnclosedGroup-Anker dazu verwenden, dass er die Tags <table-und </table> erkennt, die eine HTML-Tabelle umgeben.

1. Markieren Sie die drei Punkte am Ende der Ankersequenz auf der oberstenEbene (das heißt, die Ebene, auf der der Group-Anker definiert wird, und nichtdie 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 folgendeZuweisung vor: text = <table. Unter der Eigenschaft closing weisen SieFolgendes zu: text = </table>. Sie können diese Angaben eintippen oder mitder Maus aus dem Beispielbereich ziehen.


40

Im Beispielbereich sollten die Tags <table und </table> im HTML-Codehervorgehoben sein.

4. Jetzt fügen Sie innerhalb von EnclosedGroup Anker hinzu. Wenn Sie dieÜbungen in den vorangehenden Kapiteln durchgeführt haben, müssten Sieimstande sein, diese Aufgabe zu lösen. Wir möchten Sie bitten, es zuerst selbstzu 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 derBeispielquelle markieren und mit der rechten Maustaste anklicken. DerHTML-Code der Beispielquelle ist lang und verwirrend, und einige der Ankerhaben nicht-standardmäßige Eigenschaften, die Sie nur im IntelliScriptkonfigurieren können.

Innerhalb desEnclosedGroup-Ankers hinzufügen

Konfiguration Erläuterung

Marker Geht zur ersten Zeile derTabelle, die Sie nichtabrufen müssen.

RepeatingGroup Beginnt eine sichwiederholende Gruppe inder zweiten Zeile derTabelle.Siehe weiter unten, welcheAnker innerhalb derRepeatingGroupeinzufügen sind.)


41

Innerhalb desEnclosedGroup-Ankers hinzufügen


Marker Beendet die sichwiederholende Gruppe undgeht zur letzten Zeile derTabelle.Für die Zuweisungcount=2, blenden Sie dieerweiterten Eigenschaftenein (siehe Mit Hilfe vonCount Mehrdeutigkeitenausschließen weiter unten).

Marker Geht zur vierten Zelle inder letzten Zeile.Für die Zuweisungcount=3, blenden Sie dieerweiterten Eigenschaftenein (siehe Mit Hilfe vonCount Mehrdeutigkeitenausschließen weiter unten).

Content Ruft den Inhalt der viertenZelle 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 Beispielquelleeinen Bildlauf durchführen, sollten Sie die Farbcodierung für die obendefinierten Anker sehen.


42

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 Ankerinnerhalb dieser Gruppe ein.

Beachten Sie, dass die vier Content-Anker sehr ähnliche Konfigurationenaufweisen. Sie können Zeit sparen, indem Sie einen der Content-Ankerkopieren und einfügen, und die Kopien bearbeiten.

Innerhalb desRepeatingGroup-Ankershinzufügen


Content Ruft denInhalt derersten Zelleeiner Zeile ab.

Content Ruft denInhalt derzweiten Zelleab.

Content Ruft denInhalt derdritten Zelleab.

Content Ruft denInhalt dervierten Zelleab.


43

Wenn Sie damit fertig sind, sollten die EnclosedGroup und die RepeatingGroupwie folgt aussehen:

8. Führen Sie den Befehl Beispiel markieren aus und prüfen Sie wieder dieFarbcodierung.


44


Warum die Ausgabe keinen HTML-Code enthält

Beachten Sie, dass der Parser den HTML-Code aus dem abgerufenen Text entfernthat.

Der erste Content-Anker innerhalb der RepeatingGroup ist beispielsweise sokonfiguriert, 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 erfolgenden Text abruft:

width=168 valign=top style='width:125.9pt;border:solid windowtext1.0pt;border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt'><pclass=MsoBodyText><i style='mso-bidi-font-style:normal'>Topspin ServesMade Easy</i>, by Roland <span class=SpellE>Fasthitter</span></p>

Genau genommen entspricht das genau der Farbcodierung im IntelliScript:


45

Der Content-Anker ruft den gesamten Text, einschließlich HTML-Code, ab. DieHtmlFormat-Komponente des Parsers ist jedoch mit einer Reihe vonStandardtransformatoren konfiguriert, die die Ausgabe des Ankers ändern.

Einer der Standardtransformatoren ist RemoveTags , der den HTML-Code entfernt.

TransformatorenEin Transformator ist eine Komponente, die die Ausgabe eines Ankers ändert.Transformatoren werden beispielsweise dazu verwendet, Strings in der Ausgabehinzuzufügen oder zu ersetzen. Sie werden Transformatoren für diesen Zweck inden nächsten Schritten dieser Übung einsetzen.

Die Formatkomponente eines Parsers wird üblicherweise mit einer Reihe vonStandardtransformatoren konfiguriert, die der Parser auf die Ausgaben aller Ankeranwendet. Zweck der Standardtransformatoren ist es, die Ausgabe zu bereinigen.

Die HtmlFormat-Komponente ist mit folgenden Standardtransformatorenausgestattet:

RemoveTags – entfernt HTML-Code aus der Ausgabe.

HtmlEntitiesToASCII – wandelt HTML-Entitäten (wie etwa &gt: oder &)in einfache Text-Symbole um (> oder &).

HtmlProcessor – wandelt mehrfache Leerräume (Leerzeichen, Tabulatorenoder Zeilenumbrüche) in einfache Leerräume um.

RemoveMarginSpace – löscht vorangestellte und angehängte Leerzeichen.

Weitere Informationen über die Transformatoren, die Ihnen der ContentMaster zurVerfügung stellt, finden Sie unter Transformatoren im ContentMaster StudioBenutzerhandbuch.


46

Warum verwendet der Parser nicht Begrenzungszeichen, um den HTML-Codezu entfernen?

Erinnern Sie sich an den Becky Handler-Anker, den Sie am Anfang dieser Übungdefiniert haben? Wir haben Ihnen erklärt, dass der Anker HTML-Code entfernt,weil er nur die Daten nach dem >-Begrenzungszeichen abruft. Die Farbcodierungveranschaulicht dies:

Das funktioniert, weil der Becky Handler-Anker mit der LearnByExample-Komponente ausgestattet ist, deren Aufgabe es ist, die Begrenzungszeichen in derBeispielquelle zu interpretieren.

Bei den Content-Ankern der RepeatingGroup haben wir die LearnByExample-Komponente absichtlich weggelassen:

Die LearnByExample-Komponente hätte in diesem Fall nicht richtig funktioniert.Das Problem dabei ist, dass die Anzahl der Begrenzungszeichen in derAuftragstabelle nicht konstant ist. In einigen Tabellenzeilen ist der Name einesBuchs kursiv formatiert. In anderen Zeilen ist der Name nicht kursiv formatiert. Inmanchen Quelldokumenten kann die Tabelle andere Formatierungsabweichungenenthalten. Die Formatierung kann den HTML-Code verändern, einschließlich derAnzahl und Position der Begrenzungszeichen.

Deshalb haben wir die Eigenschaft value leer gelassen. Wir haben uns stattdessendarauf verlassen, dass die Standardtransformatoren die Ausgabe bereinigen.


47

Mit Hilfe von Count Mehrdeutigkeiten ausschließen

Wir haben Sie angewiesen, innerhalb der EnclosedGroup die Eigenschaft countzwei Marker-Ankern zuzuweisen. Das diente dazu, Mehrdeutigkeiten in derBeispielquelle auszuschließen.

Im >Total<-Anker haben wir count = 2 eingestellt. Damit verhindern wir, dass diesich wiederholende Gruppe vorzeitig, beim ersten Auftreten des Strings >Total<,und zwar in der Zeile mit der Spaltenüberschrift, endet. Die Eigenschaft count = 2bedeutet, 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ührungszeichengesetzt – >Total< - und nicht einfach nur Total (ohne die Symbole > und <)geschrieben haben. Damit schließen wir Mehrdeutigkeiten in Bezug auf das WortTotal aus, das in der Tabellenzeile Total Tennis (video) vorkommt. Hätten wirdas nicht gemacht, würde die sich wiederholende Gruppe fälschlicherweise in derZeile Total Tennis (video) enden.

Das zweite Mal haben wir die Eigenschaft count im letzten <td-Referenzpunkt derEnclosedGroup verwendet, der sich in der letzten Tabellenzeile befindet. Dorthaben wir count = 3 eingestellt, damit der Parser um drei Tabellenzellenweitergeht. Die übersprungenen Zellen in dieser Zeile enthalten keine Daten, alsomüssen wir sie nicht parsen.

Transformatoren 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 Transformatoren anwenden. DieTransformatoren ändern die Ausgabe der Anker und korrigieren diese Probleme.


48

Das sind zusätzliche Transformatoren, neben den Standardtransformatoren, dieder Parser auf alle Anker anwendet (siehe Warum die Ausgabe keinen HTML-Codeenthält weiter oben).

1. Erweitern Sie im IntelliScript den ersten Content-Anker der RepeatingGroup.

2. Blenden Sie die erweiterten Eigenschaften des Content-Ankers ein underweitern Sie die Eigenschaft transformers.

3. Betten Sie an den drei Punkten innerhalb der Eigenschaft transformers einenReplace-Transformator ein

4. Legen Sie die Eigenschaften des Replace-Transformators wie folgt fest:

find_what="TextSearch(" ,")

replace_with = ","

Mit anderen Worten, der Transformator ersetzt ein Leerzeichen, dem einKomma folgt, durch ein Komma.

5. Sie werden einen AddString-Transformator verwenden, um den Preisen undSummen das Währungssymbol voranzustellen. Sie könnten für jedenentsprechenden Content-Anker einen eigenen AddString-Transformatorkonfigurieren, aber es gibt eine einfachere Lösung. Sie können einen einzigenAddString-Transformator als globale Komponente konfigurieren. Die globaleKomponente können Sie dann überall dort einsetzen, wo sie benötigt wird.

Um die globale Komponente zu konfigurieren, markieren Sie die drei Punktelinks vom Gleichheitszeichen auf der obersten Ebene des IntelliScript – dieEbene, auf der MyHtmlParser und varCurrency definiert werden. Das nenntman die globale Ebene.


49

Drücken Sie Eingabe und geben Sie AddCurrencyUnit ein. Das ist derBezeichner der globalen Komponente.

6. Drücken Sie an den zweiten drei Punkten in derselben Zeile (nach demGleichheitszeichen) Eingabe. Fügen Sie einen AddString-Transformator ein.

7. Markieren Sie die Eigenschaft pre des AddString-Transformators und drückenSie Eingabe. Klicken Sie auf der rechten Seite des Textfeldes auf dieSchaltfläche Durchsuchen. Daraufhin wird die Schema-Ansicht angezeigt, inder Sie einen Datenbehälter auswählen können.

Markieren Sie in der Schema-Ansicht VarCurrency.

Das bedeutet, dass der AddString-Transformator seiner Eingabe den Wert vonVarCurrency (also das Währungssymbol) voranstellen soll.

8. Jetzt können Sie die AddCurrencyUnit-Komponente an der entsprechendenPosition in MyHtmlParser einfügen.

Blenden Sie beispielsweise die erweiterten Eigenschaften des letzten Content-Ankers in der EnclosedGroup ein (jene, die /Order/*s/Total zugeordnet ist).Unter der Eigenschaft transformers, markieren Sie die drei Punkte unddrücken Eingabe. In der Dropdown-Liste wird die globale KomponenteAddCurrencyUnit angezeigt, die Sie gerade definiert haben. Markieren Sie dieglobale Komponente. Damit wird der Transformator auf den Ankerangewendet.


50

Das Ergebnis sollte wie folgt aussehen:

Fügen Sie auf dieselbe Weise AddCurrencyUnit in die Eigenschafttransformers des zweiten und vierten Content-Ankers in der RepeatingGroupein (die Price beziehungsweise Total zugeordnet sind).



51

Beachen Sie, dass das Element Title kein zusätzliches Leerzeichen vor demKomma enthält. Die Elemente Price und Total enthalten das $-Zeichen. Dasist auf die von Ihnen definierten Transformatoren zurückzuführen.

Globale Komponenten

Globale Komponenten sind nützlich, wenn Sie dieselbeKomponentenkonfiguration in einem Projekt mehrfach benötigen.

Sie können jede ContentMaster-Komponente, zum Beispiel einen Transformator,eine Aktion oder einen Anker, als globale Komponente definieren Der Bezeichnerder globalen Komponente scheint in der Dropdown-Liste an den entsprechendenStellen im IntelliScript auf. Die globale Komponente können Sie wie jede andereKomponente verwenden.

In dieser Übung haben Sie drei globale Komponenten definiert:

Den Parser namens MyHtmlParser, den Sie mit Hilfe des Assistenten definierthaben.

Die Variable VarCurrency, die Sie am Anfang der Übung definiert haben.

Den Transformator AddCurrencyUnit , den Sie am Ende der Übunghinzugefügt haben.


52

Den Parser mit einem anderen Quelldokument testen

Als letzten Schritt wollen wir den Parser mit dem QuelldokumentOrderWithoutCurrency.doc testen. Dieses Dokument ist identisch mit derBeispielquelle (Order.doc), abgesehen davon, dass ihm die optionaleWährungszeile fehlt.

Dieser Test soll bestätigen, dass der Parser ein Dokument richtig verarbeitet, wenndie 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 demlokalen Computer verarbeiten soll.

3. Bearbeiten Sie die Eigenschaft file_name und suchen Sie die DateiOrderWithoutCurrency.doc.

4. Blenden Sie die erweiterten Eigenschaften von LocalFile ein, und weisen Siepre_processor = WordToHtml zu.

Das bedeutet, dass der ContentMaster den WordToHtml-Prozessor an diesemDokument ausführen soll, bevor es geparst wird.

5. Führen Sie den Parser aus. Die Ausgabe sollte der obigen Ausgabeentsprechen, abgesehen davon, dass den Preisen und Summen kein $-Zeichenvorangestellt ist.


53

6. 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 dasTesten des Parsers benötigen.


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 dieEigenschaften opening_marker und closing_marker des Content-Ankersverwenden. Diese Methoden machen sich die typische Anfangs- und Ende-Tag-Struktur des HTML-Formats zunutze. Wenn Sie ein HTML-Tag als Marker-Ankerdefinieren, wählen Sie die Eigenschaft match_case lieber nicht, weil HTML nichtzwischen 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 XML-Ausgabe eines Parsers nicht anzeigen wollen. Variablen sind nützlich als Eingabefür andere Komponenten.


54

Verwenden Sie Transformatoren, um die Ausgabe der Anker zu ändern. Sie könnenStandardtransformatoren auf alle Anker anwenden oder Sie könnenTransformatoren auf bestimmte Anker anwenden.

Um HTML-Tags von der Parsing-Ausgabe auszuschließen, können Sie die Ankerentweder mit Begrenzungszeichen definieren oder sich darauf verlassen, dass dieStandardtransformatoren den Code entfernen.

Globale Komponenten sind nützlich, wenn Sie dieselbe Komponentenkonfigurationmehrmals benötigen.

Um einen Parser mit weiteren Dokumenten zu testen (mit anderen Dokumenten als derBeispielquelle), weisen Sie die Eigenschaft sources_to_extract zu. Vergessen Sienicht, dem Dokument einen Dokumentprozessor zuzuweisen, falls es einenbenötigt.

Erste Schritte mit ContentMaster, Band 2 7. Einen Serialisierer definieren

55

Einen Serialisierer definieren

In den vorangehenden Übungen haben Sie Parser definiert, die Dokumenteverschiedener Formate in XML umwandeln. In dieser Übung werden Sie einenSerialisierer erstellen. Dieser funktioniert umgekehrt, das heißt, er wandelt XML inandere Formate um.

Für gewöhnlich ist es einfacher, einen Serialisierer 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 Serialisierer, den Sie definieren werden, ist sehr einfach. Er enthält nur vierSerialisierungsanker (das Gegenteil der Anker, die Sie beim Parsen verwenden).Trotzdem gibt es beim Serialisierer ein paar interessante Punkte:

Der Serialisierer ist rekursiv. Das heißt, er ruft sich selbst wiederholt auf, umdie eingebetteten Abschnitte eines XML-Dokuments zu serialisieren.

Die Ausgabe des Serialisierers ist ein Arbeitsblatt, das Sie in Excel öffnenkönnen.

Sie werden den Serialisierer definieren, indem Sie das IntelliScript bearbeiten. Esist auch möglich, einen Serialisierer automatisch zu generieren, indem Sie einenParsing-Vorgang einfach umkehren. Weitere Informationen finden Sie im KapitelSerialisierer im ContentMaster Studio Benutzerhandbuch.

Voraussetzungen:

Die Ausgabe dieser Übung ist eine *.csv (Comma Separated Values) Datei. Siekönnen die Ausgabe im Microsoft Editor öffnen, aber am sinnvollsten ist es, sie inMicrosoft Excel anzuzeigen.

Um den Serialisierer 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

7


56

Das Dokument stellt einen Stammbaum in XML dar. Beachten Sie, dass dieStruktur an sich schon rekursiv ist: jedes Person-Element kann ein Children-Element 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 mitfolgender Struktur auszugeben:

Jake Dubrey,84Mitchell Dubrey,52Pamela Dubrey McAllister,50Arnold McAllister,26

Excel stellt die Ausgabe in einem Arbeitblatt wie folgt dar:


57

Das Projekt anlegen

Um den Serialisierer zu erstellen, führen Sie folgende Schritte durch:

1. Wählen Sie im ContentMaster Studio-Menü Datei > Neu > Projekt.

2. Markieren Sie im linken Bereich des Fensters Neues Projekt den EintragContentMaster Im rechten Bereich wählen Sie Serialisierer-Projekt.

3. Legen Sie auf den nachfolgenden Seiten des Assistenten die folgendenOptionen fest:

a. Geben Sie dem Projekt den Namen Tutorial_5 .b. Geben Sie dem Serialisierer 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 sichim Ordner tutorials\Exercises\Files_For_Tutorial_5 befindet.

Das Schema definiert die Struktur des XML-Eingabedokuments. Wenn Sie mitXSD nicht vertraut sind, können Sie das Schema in einem XSD-Editor oder imMicrosoft Editor öffnen und untersuchen, wie die rekursive Datenstrukturdefiniert wird.

5. Wenn Sie mit dem Assistenten fertig sind, zeigt der ContentMaster-Explorerdas neue Projekt an. Doppelklicken Sie auf die Serializer_Script.tgp-Datei,um sie zu bearbeiten.

6. Im Gegensatz zu einem Parser, hat ein Serialisierer keine Beispielquelle. Siekönnen den leeren Beispielbereich des IntelliScript-Editors ausblenden, wennSie möchten.

Wählen Sie dafür den Menübefehl IntelliScript > IntelliScript aus oder klickenSie die Schaltfläche nur IntelliScript-Bereich anzeigen in der Symbolleiste an. Umden Beispielbereich wiederherzustellen, wählen Sie IntelliScript > Beide oderklicken die Schaltfläche mit der Bezeichnung IntelliScript und Beispielbereichanzeigen an.


58

7. Um den Serialisierer zu entwerfen, verwenden Sie das FamilyTree.xml-Eingabedokument, dessen Inhalt oben dargestellt ist.

Obwohl es nicht unbedingt erforderlich ist, wäre es eine gute Idee, alleDateien, mit denen Sie ein Projekt entwerfen und testen, im Projektordner zuverwalten, der sich in Ihrem Eclipse-Workspace befindet. Wir empfehlen, dieDatei FamilyTree.xml aus dem Ordner

tutorials\Exercises\Files_For_Tutorial_5

in den Projektordner zu kopieren. Dessen Standardspeicherort ist:


Speicherort des Projektordners bestimmen

Es kann sein, dass sich Ihr Projektordner aus einem der folgenden Gründe nicht anseinem standardmäßigen Speicherort befindet:

Sie haben im Assistenten Neues Projekt einen nicht standardmäßigenSpeicherort gewählt.

Eclipse ist bei Ihnen so konfiguriert, dass es einen nicht standardmäßigenWorkspace-Speicherort verwendet.

Sie können den Speicherort des Projektordners bestimmen, indem Sie das Projektim ContentMaster-Explorer markieren und den Befehl Datei > Eigenschaftenwählen. Alternativ dazu können Sie im IntelliScript-Editor klicken und den BefehlProjekt > Eigenschaften wählen. Die Registerkarte Info des Eigenschaftenfensterszeigt den Speicherort an.

ProjekteigenschaftenDas Eigenschaftenfenster zeigt viele nützliche Optionen an, wie zum Beispiel dieEingabe- und Ausgabecodierung, die in Ihren Dokumenten verwendet wird, unddie XML-Validierungsoptionen. Weitere Informationen finden Sie unterProjekteigenschaften im ContentMaster Studio Benutzerhandbuch.


59

Den Serialisierer konfigurieren

Jetzt können Sie die Serialisierer-Eigenschaften konfigurieren und dieSerialisierungsanker hinzufügen. Dazu müssen Sie das IntelliScript bearbeiten.Eine Methode wie das Markieren-und-Klicken, die Sie zum Konfigurieren vonParsern verwendet haben, gibt es hier nicht.

1. Blenden Sie die erweiterten Eigenschaften des Serialisierers ein und legen Sieoutput_file_extension = .csv fest (mit einem vorangestellten Punkt).

Wenn Sie den Serialisierer in ContentMaster Studio ausführen, erhält dieAusgabedatei dadurch den Namen output.csv. Standardmäßig können *.csv-Dateien in Microsoft Excel geöffnet werden.

2. Fügen Sie im Serialisierer unter der Zeile contains einen ContentSerializer-Serialisierungsanker 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 ContentSerializer-Serialisierungsanker:


60

Dieser ContentSerializer schreibt den Datenbehälter /Person/*s/Age in dieAusgabe. Er hängt einen Wagenrücklauf (ASCII-Code 013) und einenZeilenvorschub (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 Serialisierer aus. Gehen Sie dazu wie folgt vor:

a. Legen Sie den Serialisierer 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 Serialisierer fertig ist, überprüfen Sie die Ereignisansicht nach

Fehlern.e. Doppelklicken Sie in der ContentMaster Explorer-Ansicht unter Results auf

output.csv, um die Ausgabe anzuzeigen.

Vorausgesetzt, dass Excel auf dem Computer installiert ist, zeigt derContentMaster ein Excel-Fenster wie das Folgende an:


61

Wenn Excel auf dem Computer nicht installiert ist, können Sie dieAusgabedatei im Microsoft Editor anzeigen. Alternativ dazu können Sie dieDatei auf einen anderen Computer kopieren, auf dem Excel installiert ist, undsie dort öffnen.

Den Serialisierer rekursiv aufrufen

Bisher enthält das Ergebnis nur das Element Person der obersten Ebene. Siemüssen den Serialisierer so konfigurieren, dass er tiefer in die XML-Baumstruktureindringt 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 sichwiederholende Struktur in der Eingabe zu iterieren und eine sichwiederholende Struktur in der Ausgabe zu generieren. In diesem Fall iteriertder RepeatingGroupSerializer über alle Person-Elemente auf einerbestimmten eingebetteten Ebene.

2. Betten Sie innerhalb des RepeatingGroupSerializer einen EmbeddedSerializerein. Zweck dieses Serialisierungsankers ist es, einen sekundären Serialisiereraufzurufen.


62

3. Weisen Sie dem EmbeddedSerializer die unten dargestellten Eigenschaften zu.

Die Eigenschaften haben folgende Bedeutung:

- Die Zuweisung serializer = FamilyTreeSerializer bedeutet, dass dersekundäre Serialisierer dem Hauptserialisierer entspricht. Andersausgedrückt, der Serialisierer ruft sich selbst rekursiv auf.

- Die Eigenschaft schema_connections bedeutet, dass der sekundäreSerialisierer /Person/*s/Children/*s/Person so verarbeiten soll, als handlees sich dabei um ein /Person-Element der obersten Ebene. Auf diese Weisebewegt sich der Serialisierer durch die Generationen des Stammbaums.

- Die Eigenschaft optional bedeutet, dass der sekundäre Serialisierer nichtdazu führt, dass der Hauptserialisierer fehlschlägt, wenn ihm die Datenausgehen.

4. Führen Sie den Serialisierer erneut aus. Das Ergebnis sollte wie folgt aussehen:

Mehrere Komponenten in einem Projekt definieren

Beim Ausführen eines sekundären Serialisierers erhebt sich eine Frage, die wirbisher noch nicht behandelt haben.


63

In allen Übungen dieses Buches enthält jedes Projekt, der Einfachheit halber, nureinen einzigen Parser, Serialisierer oder Mapper. We did this for simplicity.

Es ist aber durchaus möglich, dass ein einziges Projekt mehrere Komponentenenthält, wie etwa:

Mehrere Parser, Serialisierer oder Mapper

Mehrere (TGP) Skriptdateien

Mehrere XSD-Schemas

Wir haben keine Übung zu diesem Thema für Sie, aber Anweisungen dazu findenSie im ContentMaster Studio Benutzerhandbuch. Die folgenden Absätze bieten einekurze Zusammenfassung.

Mehrere Parser und SerialisiererUm mehrere Parser, Serialisierer oder Mapper zu definieren, fügen Sie dieseeinfach auf der globalen Ebene des IntelliScript ein. Hier ist ein Beispiel:

Um einen der Parser oder Serialisierer auszuführen, legen Sie ihn alsStartkomponente fest und verwenden die Befehle des Menüs Ausführen.

Die Startkomponente kann sekundäre Parser, Serialisierer 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 Serialisierer identischwaren – 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 imContentMaster-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 imContentMaster-Explorer doppelt an.

Mehrere XSD-Schemas

Um einem Projekt mehrere Schemas hinzuzufügen, klicken Sie den XSD-Knoten imContentMaster-Explorer mit der rechten Maustaste an und wählen Dateihinzufügen. Um ein leeres XSD-Schema anzulegen, das Sie in einem beliebigenEditor bearbeiten können, wählen Sie Neu > XSD.


64


Ein Serialisierer ist das Gegenteil eines Parsers: er wandelt XML in andere Formateum.

Sie können einen Serialisierer erstellen, indem Sie ihn aus einem bestehenden Parsergenerieren oder das IntelliScript bearbeiten. Ein Serialisierer enthältSerialisierungsanker, die den Ankern entsprechen, die Sie in einem Parserverwenden, aber in der umgekehrten Richtung funktionieren.

In einem IntelliScript-Editor können Sie die Bereiche ein- oder ausblenden, indem Siedie entsprechenden Befehle im IntelliScript-Menü oder auf der Symbolleistewählen.

Wir empfehlen, alle zu einem Projekt gehörenden Dateien im Projektordner zuspeichern, der sich in Ihrem Eclipse-Workspace befindet. Den Speicherort desOrdners können Sie mit Hilfe des Befehls Datei > Eigenschaften oder Projekt >Eigenschaften bestimmen.

Ein einzelnes Projekt kann mehrere Parser, Serialisierer, Mapper, Skriptdateien,XSD-Dateien usw. enthalten. Die Startkomponente kann sekundäre Serialisierer,Parser oder Mapper aufrufen, die im selben Projekt definiert sind und Teile einesDokuments verarbeiten. Ein rekursiver Aufruf (eine Komponente, die sich selbstaufruft) ist möglich.

Sie können einen Serialisierer entwerfen, der Ausgaben in einem beliebigenDatenformat, zum Beispiel, Microsoft Excel, erstellt.

Erste Schritte mit ContentMaster, Band 2 8. Einen Mapper definieren

65

Einen Mapper definieren

Bisher haben Sie mit zwei wesentlichen ContentMaster-Komponenten gearbeitet.Mit Parsern haben Sie Dokumente beliebigen Formats in XML umgewandelt. MitSerialisierern haben Sie XML-Dokumente in andere Formate verwandelt.

In diesem Kapitel werden Sie mit einem Mapper arbeiten, der Umwandlungen vonXML zu XML durchführt. Zweck dieses Arbeitsschrittes ist es, die XML-Strukturoder das Vokabular der Daten zu ändern.

Das Mapper-Design ist dem von Parsern und Serialisierern ähnlich. Innerhalb derMapper-Hauptkomponente können Sie Mappinganker, Map-Aktionen und andereKomponenten, die Mapping-Operationen ausführen, einbetten.

In dieser Übung wird ein einfacher Mapper präsentiert, der einenzusammenfassenden XML-Bericht generiert. Neben anderen Funktionendemonstriert die Übung, wie Sie ein anfangs leeres Projekt konfigurieren, das Siemit dem Assistenten Leeres Projekt anlegen. Mit einem leeren Projekt können Siezusätzlich zu Mappern auch jede andere Art von Datenumwandlungkonfigurieren.

Anforderungsanalyse

Ziel dieser Übung ist es, eine bestehende XML-Datei heranzuziehen und eine neueXML-Datei mit einer veränderten Datenstruktur zu generieren. Die Dateienbefinden sich im folgenden Ordner:

tutorials\Exercises\Tutorial_6

XML-EingabeDie Eingabe des Mappers ist eine XML-Datei (Input.xml), die Kennnummer undNamen mehrerer Personen aufzeichnet. Die Eingabe entspricht dem SchemaInput.xsd.

<Persons><Person ID="10">Bob</Person><Person ID="17">Larissa</Person><Person ID="13">Marie</Person>

</Persons>

8


66

XML-Ausgabe

Die erwartete XML-Ausgabe ist ein zusammenfassender Bericht(ExpectedOutput.xml), der die Namen und Kennnnummern separat auflistet. DieAusgabe 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 ContentMaster-Projekt:

1. Wählen Sie im ContentMaster Studio-Menü Datei > Neu > Projekt.

2. Markieren Sie im linken Bereich ContentMaster. Im rechten Bereich markierenSie Leeres Projekt.

3. Geben Sie dem Projekt im Assistenten den Namen Tutorial_6 und klicken Sieauf Fertigstellen.

4. Erweitern Sie das Projekt im ContentMaster-Explorer. Beachten Sie, dass eseine Standard-TGP-Skriptdatei enthält, aber keine XSD-Schemas oder andereKomponenten.


67

5. Klicken Sie den XSD-Knoten mit der rechten Maustaste an und wählen SieDatei hinzufügen. Fügen Sie die Schemas Input.xsd und Output.xsd hinzu. Eswerden beide Schemas benötigt, weil Sie sowohl die Struktur der XML-Eingabe als auch der XML-Ausgabe definieren müssen.

6. Beachten Sie, dass die Schema-Ansicht die Elemente anzeigt, die in beidenSchemas definiert sind. Sie werden für die Eingabe mit dem Persons-Zweigder Baumstruktur arbeiten und für die Ausgabe mit dem SummaryData-Zweig.

7. Wir empfehlen, die Testdokumente Input.xml und ExpectedOutput.xml in denProjektordner zu kopieren. Standardmäßig ist das folgender Ordner:


Den Mapper konfigurieren

Um den Mapper zu konfigurieren und die Mappinganker einzufügen, führen Siefolgende Schritte aus:

1. Öffnen Sie die Skriptdatei, die standardmäßig den Namen Tutorial_6.tgpträgt, in einem IntelliScript-Editor.

2. Wenn Sie möchten, können Sie die Befehle im IntelliScript-Menü oder in derSymbolleiste verwenden, um nur den IntelliScript-Bereich anzuzeigen. EinMapper verwendet keine Beispielquelle, also brauchen Sie den Beispielbereichnicht.


68

3. Definieren Sie eine globale Komponente namens Mapper1, und bestimmen Siesie als Typ Mapper. (Um dieses Thema nochmals nachzulesen, siehe GlobaleKomponenten in Kapitel 6, Word- und HTML-Dokumente parsen.)

4. Weisen Sie dem Mapper die Eigenschaften source und target, wie untendargestellt, zu. Die Eigenschaften definieren die Schemazweige, in denen derMapper seine Eingabe abruft und seine Ausgabe speichert.

5. Fügen Sie im Mapper unter der Zeile contains eine RepeatingGroupMapping-Komponente ein. Diesen Mappinganker verwenden Sie, um über die sichwiederholenden XML-Strukturen in der Ein- und Ausgabe zu iterieren.

6. Fügen Sie innerhalb der RepeatingGroupMapping-Komponente zwei Map-Aktionen ein. Zweck dieser Aktionen ist es, die Daten von der Eingabe in dieAusgabe zu kopieren.


69

Konfigurieren Sie die Eigenschaft source jeder Map-Aktion so, dass sie einenDatenbehälter aus der Eingabe abruft. Konfigurieren Sie die Eigenschafttarget 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, mitExpectedOutput.xml. Wenn Sie den Mapper richtig konfiguriert haben, solltendie Dateien identisch sein (abgesehen vielleicht von der <?xml?>-Verarbeitungsdeklaration, die von den Optionen in den Projekteigenschaftenabhängt).

Erste Schritte mit ContentMaster, Band 2 8. Einen Mapper defin ieren

70


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 IntelliScriptbearbeiten. Ein Mapper enthält Mappinganker, die den Ankern, die Sie in einemParser verwenden, oder den Serialisierungsankern in einem Serialisierer,entsprechen. Er verwendet Map-Aktionen, um die Daten von der Eingabe in dieAusgabe zu kopieren.

Erste Schritte mit ContentMaster, Band 2 9. ContentMaster Engine ausführen

71

ContentMaster Engine ausführen

Nachdem Sie eine Datenumwandlung erstellt und getestet haben, müssen Sie sievom Entwicklungsstadium in das Produktionsstadium übertragen. Dafür sind imWesentlichen zwei Schritte notwendig:

1. Stellen Sie die Datenumwandlung in ContentMaster Studio als einenContentMaster-Dienst bereit. Auf diese Weise steht er in ContentMasterEngine zum Ausführen zur Verfügung.

2. Starten Sie eine Anwendung, die ContentMaster Engine aktiviert und denDienst ausführt.

In diesem Tutorial führen Sie diesen Vorgang für den HL7-Parser durch, den Sie inKapitel 4, unter, Einen HL7-Parser definieren, erstellt haben. Wenn Sie möchten,können Sie die Übung mit jedem anderen Parser oder Serialisierer, den Sievorbereitet haben, durchführen.

Bei der Anwendung, die ContentMaster Engine aktiviert, handelt es sich um eineinfaches Microsoft Visual Basic 6-Proramm, das das ContentMaster COM APIaufruft. Jenen ContentMaster-Anwendern, die Visual Basic eventuell nichtbesitzen, stellen wir sowohl den Quellcode als auch das kompilierte Programm zurVerfügung.

Alternativ zur Methode, die Sie in diesem Tutorial lernen werden, können SieContentMaster-Dienste von der Kommandozeile aus ausführen, indem Sie dasContentMaster Java API oder die CGI Weboberfläche verwenden. WeitereInformationen finden Sie im ContentMaster Engine Entwicklerhandbuch.

Einen Parser als einen Dienst bereitstellen

Einen ContentMaster-Dienst bereitstellen bedeutet, ContentMaster Engine eineDatenumwandlung zur Verfügung zu stellen. Standardmäßig ist der Speicherortfür das Repository:

c:\Programme\SAP\ContentMaster\ServiceDB

Beachten Sie, dass es keine Beziehung zwsichen ContentMaster-Diensten undWindows-Diensten gibt. Sie können ContentMaster-Dienste nicht in der WindowsSystemsteuerung ansehen oder verwalten.

Um eine Datenumwandlung als einen Dienst bereitzustellen, machen SieFolgendes:

9


72

1. Markieren Sie das Projekt im ContentMaster-Explorer . Wir schlagen vor, dassSie 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 dieDatenumwandlung richtig ausgeführt wird.

3. Wählen Sie im ContentMaster-Menü den Befehl Projekt > Bereitstellen.

4. Im Fenster Dienst bereitstellen werden die Details zum Dienst angezeigt. Siekönnen die Informationen, wenn erforderlich, bearbeiten.

5. Klicken Sie auf die Schaltfläche Bereitstellen.

6. Blenden Sie im ContentMaster Studio-Fenster unten links die Repository-Ansicht ein. Die Ansicht listet den Dienst auf, den Sie bereitgestellt haben,sowie alle anderen ContentMaster-Dienste, die bisher auf dem Computerbereitgestellt wurden.

ContentMaster COM API-Anwendung

Sie können in ContentMaster Engine einen Dienst auf eine der folgenden Artenausführen:

Durch Eingabe von Befehlen in der ContentMaster-Kommandozeile.

Durch Programmieren einer Anwendung, die das ContentMaster COM APIaufruft.

Durch Programmieren einer Anwendung, die das ContentMaster Java APIaufruft.

Durch Senden an die ContentMaster CGI-Oberfläche.

Zur Veranschaulichung stellen wir Ihnen eine Beispielanwendung zur Verfügung,die die zweite Methode verwendet. Die Anwendung ist in Microsoft Visual Basic6.0 programmiert und sie ruft das ContentMaster COM API auf. Der Quellcodeund 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:


73

Der Anwender gibt den Pfad des Quelldokuments an, den Pfad desAusgabedokuments und den Namen eines ContentMaster-Dienstes. Wenn derAnwender auf die Schaltfläche Ausführen klickt, führt die Anwendung folgendenCode aus:

Private Sub cmdRun_Click()

Dim objCMEngine As CM_COM3Lib.CMEngine 'ContentMaster EngineDim objCMRequest As CM_COM3Lib.CMRequest 'Request generationDim objCMStatus As CM_COM3Lib.CMStatus 'Status display

Dim strRequest As String 'Request stringDim strOutput As String 'Output string (not used in this sample)Dim strStatus As String 'Status string

'Check for the required inputIf txtSource = "" Then

MsgBox "Please enter the path of the source document"Exit Sub

End If

If txtOutput = "" ThenMsgBox "Please enter the path of the output document"Exit Sub

End If

If txtService = "" ThenMsgBox "Please enter the name of a deployed " & _

"ContentMaster service"Exit Sub

End If

Me.MousePointer = vbHourglass

'Initialize ContentMaster EngineSet objCMEngine = New CM_COM3Lib.CMEngineobjCMEngine.InitEngine


74

'Generate a request stringSet objCMRequest = New CM_COM3Lib.CMRequeststrRequest = objCMRequest.Generate( _

txtService.Text, _objCMRequest.FileInput(txtSource.Text), _objCMRequest.FileOutput(txtOutput.Text), _"", "", "")

'Execute the requeststrStatus = objCMEngine.Exec(strRequest, "", "", strOutput)

'Display the statusSet objCMStatus = New CM_COM3Lib.CMStatusCall MsgBox( _

"Return code = " & objCMStatus.IsGood(strStatus) & vbCr & _objCMStatus.GetDescription(strStatus), _vbOKOnly, "ContentMaster Status")

Me.MousePointer = vbDefault

Set objCMEngine = NothingSet objCMRequest = NothingSet objCMStatus = Nothing

End Sub

Erläuterung der API-Aufrufe

Das Visual Basic-Beispiel verwendet drei ContentMaster COM API-Objekte:

CMRequestGeneriert einen Anfrage-String, der den Namen des Dienstes, die Eingabe, dieAusgabe und andere Details über die Operationen angibt, die ContentMasterEngine durchführen soll.

CMEngineFührt die Anfrage aus und generiert die Ausgabe.

CMStatusZeigt Informationen über das Ergebnis der ContentMaster Engine-Operationan, 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 ContentMaster COM API-Anwendungen ähnlich.

1. Definieren Sie die Anfrage-Parameter, wie etwa Speicherort der Eingabe,Speicherort der Ausgabe und Name des ContentMaster-Dienstes.

2. Verwenden Sie CMRequest , um einen Anfrage-String zu generieren.

3. Verwenden Sie CMEngine , um die Anfrage auszuführen.


75

4. Verwenden Sie CMStatus , um zu bestätigen, dass die Anfrage erfolgreichausgeführt wurde.

Weitere InformationenUmfassende Informationen über das COM API finden Sie in der ContentMasterCOM API-Referenz.

Die COM API-Anwendung ausführen

Vorausgesetzt, dass Sie die Visual Basic 6.0 Laufzeitbibliothek auf Ihrem Computerhaben (was für die meisten Windows-Computer zutrifft), können Sie die VisualBasic Beispielanwendung ausführen. Wenn es sich um eineProduktionsanwendung handelte, würden wir sie natürlich in eine Setup-Dateistellen, 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 desAusgabedokuments ein. Geben Sie den Namen des ContentMaster-Dienstesein, den Sie bereitgestellt haben (standardmäßig ist das der Name desProjekts).

Um beispielsweise den HL7-Beispielparser auszuführen, kopieren Sie dasQuelldokument hl7-obs.txt in das Verzeichnis c:\temp und geben die untendargestellten Optionen an:

3. Klicken Sie auf die Schaltfläche Ausführen. Nach ein paar Sekunden zeigt dieAnwendung eine Statusmeldung an:


76

Der Rückgabewert 1 bedeutet, dass die Ausführung erfolgreich war. Istwährend der Ausführung des Dienstes ein Fehler aufgetreten, zeigt dieAnwendung 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 Anwendungin ContentMaster Studio generiert haben, identisch sein.


77

Ist ein Fehler aufgetreten, speichert ContentMaster Engine einEreignisprotokoll im Ordner für ContentMaster-Berichte. Standardmäßig istdas

c:\Dokumente und Einstellungen\<BENUTZER>\Anwendungsdaten\SAP\ContentMaster\4.0\CMReports

wobei <USER> für Ihren Anwendernamen steht. Wie Sie den Speicherort fürBerichte ändern, können Sie im Kapitel Konfigurationseditor im ContentMasterAdministratorhandbuch nachlesen.

Um ein Protokoll anzuzeigen, ziehen Sie die *.cme-Datei in die Ereignisansichtvon ContentMaster Studio.


Um einen Parser oder einen Serialisierer von der Entwicklungs- in dieProduktionsumgebung zu übertragen, können Sie ihn als einen ContentMaster-Dienst bereitstellen. Die Dienste werden im ContentMaster-Repository gespeichert.

Sie können einen ContentMaster-Dienst in ContentMaster Engine über dieKommandozeile, über eine API-Programmierung, oder über die CGI-Oberflächeausführen.


78

Index Band 2

A

AbstandContent-Anker, 9

AcrobatParsing-Tutorial, 1

Acrobat Reader, 2Acrobat-Dateien

parsen, 1Adobe Reader, 2Aktionen

Summen berechnen, 1Tutorial, 22

AlternativesAnker, 25

Anforderungsanalysefür das Parsen, 2

AnkerAlternatives, 25Content, 35EnclosedGroup, 39Group, 37positional definieren, 8SetValue, 23

APICOM-Beispiel, 72Tutorial, 71

B

BegrenzungszeichenLearnByExample, 46positional, 1

Binärdatenparsen, 6

C

CMComApiTutorialContentMaster Engine ausführen, 71

COM APIVisual Basic-Beispiel, 72

ContentAnker, 35

ContentMaster COM APIVisual Basic Quellcodebeispiel, 72

ContentMaster Engineaktivieren, 72API-Tutorial, 71

ContentSerializerSerialisierungsanker, 59

countMehrdeutigkeiten ausschließen mit, 47

D

DiensteContentMaster, 71ContentMaster Repository, 71

Dienste bereitstellenTutorial, 71

DokumentprozessorenBeispiel, 7für Word-Dokumente, 30

E

EigenschaftenProjekt, 58

EmbeddedSerializerSerialisierungsanker, 61

EnclosedGroupAnker, 39

erweiterte Eigenschaften, 1, 21Excel

Serialisierer-Tutorial, 55

F

Formatpositional, 1

Formatierungfür das Parsen verwenden, 27

G

globale Komponenten, 48, 51Group

Anker, 37Grundeigenschaften, 1, 21


79

H

HTMLCode aus der Ausgabe entfernen, 44Hintergrundinformationen, 28von Word erzeugte, 31Word-Dokumente umwandeln in, 27

K

Komponentenglobale, 48, 51

L

LearnByExampleBegrenzungszeichen interpretieren, 46

leere Elementein XML-Ausgabe, 37

leeres Projektbearbeiten, 66

M

MapAktion, 68

MapperDefinition , 65erstellen, 66Tutorial, 65

mehrdeutiger Quelltextausschließen, 47

Mehrdeutigkeitenbeseitigen, 27

Microsoft WordDokumente parsen, 27Parsing-Tutorial, 27

O

optionale Eigenschaftvon Group, 37

OrdnerProjekt, 58

P

Parsermehrere in einem Projekt, 62

PDFParsing-Tutorial, 1

PDF to Unicode (UTF-8)Dokumentprozessor-Beispiel, 7

PDF-Dateienanzeigen, 2parsen, 1

PdfToTxt_3_00Dokumentprozessor-Beispiel, 7

PositionsparenTutorial, 1

ProjektSpeicherort bestimmen, 58

Projekteigenschaftenin ContentMaster Studio, 58

ProzessorenDokument, 7für Word-Dokumente, 30WordToHtml, 27

Q

QuelldokumenteParser testen, 52

Quelledes Mappers, 68

R

Rechnungenparsen, 2

rekursive Serialisiereraufrufe, 55RepeatingGroupMapping

Mappinganker, 68RepeatingGroupSerializer

Serialisierungsanker, 61

S

Serialisierererstellen, 57mehrere in einem Projekt, 62Tutorial, 55

Serialisierungsanker, 55ContentSerializer, 59definieren, 59EmbeddedSerializer, 61RepeatingGroupSerializer, 61

SetValueAnker, 23

sich wiederholende Gruppeneingebettet, 14

Standardtransformatoren, 44Suchbereich, 13

steuern, 1Summen

berechnen, 22

T

testenQuelldokumente, 52

Textbausteinignorieren, 1


80

Transformatoren, 45konfigurieren, 47Standard, 44

Tutorial_3Positionsparsen, 1

Tutorial_4locker strukturierte Dokumente, 27

Tutorial_5einen Serialisierer definieren, 55

Tutorial_6einen Mapper definieren, 65

TutorialsContentMaster Engine API, 71Dienst in ContentMaster Engine

ausführen, 71HTML-Dokument parsen, 27Positionsparsen von PDFs, 1Word-Dokument parsen, 27

V

Variablendefinieren, 33

Visual BasicContentMaster COM API-Beispiel, 72

W

Wiederholende Gruppeneingebettet, 1

WordDokumente parsen, 27Parsing-Tutorial, 27

WordToHtmlProzessor, 27, 30

WordToRtfProzessor, 30

WordToTxtProzessor, 30

Z

Zählerfür Zeilenumbrüche, 17

Zeilenumbruchals Trennzeichen der RepeatingGroup, 17suchen bis zum, 10

Zieldes Mappers, 68

Documents

Erste Schritte mit ContentMaster - SAP...Erste Schritte mit ContentMaster, Band 1 1. Einführung in ContentMaster 3 XML wird üblicherweise in einem Buch oder auf einem Computerbildschirm