<\/p>\n
Evernote ist ein sehr praktisches Tool, um Informationen zu sammeln und auf allen möglichen Endgeräten verfügbar zu machen. Schreiben Sie etwa eine Notiz in der Evernote-App auf dem Smartphone, können Sie diese später am Desktop-Rechner weiternutzen. Oder Sie speichern Rechnungen vom heimischen Rechner und können diese, wenn Sie mal etwas umtauschen wollen, wieder auf dem Smartphone abrufen. All dies wird natürlich noch interessanter, wenn Sie auch noch per Access-Datenbank auf die gespeicherten Daten zugreifen oder diese VBA-gesteuert erweitern können.<\/b><\/p>\n
Die Nutzungsmöglichkeiten von Evernote sind wirklich sehr umfangreich. Ich habe beispielsweise einen Scan-Snap-Scanner von Fujitsu auf dem Schreibtisch stehen, in den ich ein oder mehrere Blätter Papier einlege und den Inhalt per Knopfdruck einscanne, in ein PDF-Dokument konvertiere und automatisch in Evernote speichere.<\/p>\n
Evernote klinkt sich auch per Hilfstool in die verfügbaren Internetbrowser ein und bietet eine Schaltfläche an, mit der sich die Inhalte von Webseiten per Mausklick in Evernote speichern lassen. Oder Sie ziehen Dateien aus dem Dateisystem in einen der Evernote-Ordner, um diese überall verfügbar zu machen, wo Sie Evernote nutzen.<\/p>\n
Evernote selbst kommt unter Windows als Anwendung, die links eine Ordnerstruktur anzeigt, in der Mitte die gespeicherten Notizen und rechts den Inhalt der aktuell markierten Notiz (s. Bild 1).<\/p>\n
![\"Einrichten](\"..\/fileadmin\/_temp_\/2016_04\/pic_1051_001.png\")
<\/p>\n
Bild 1: Einrichten des API-Zugriffs<\/span><\/b><\/p>\n In diesem Beispiel sehen Sie einen Ordner mit einigen Ausgaben von Access im Unternehmen, deren Inhalt sich ganz einfach anzeigen und auch durchsuchen lässt (speichern von PDFs nur mit einer bestimmten Version möglich, siehe weiter unten). Wenn Sie mit Evernote arbeiten möchten, benötigen Sie einen entsprechenden Benutzerzugang, den Sie auf www.evernote.com <\/b>anlegen können. Zur Registrierung geben Sie dort E-Mail-Adresse und Kennwort an und klicken auf Kostenlos registrieren<\/b>.<\/p>\n Danach haben Sie die Qual der Wahl: Es gibt nämlich verschiedene Varianten von Evernote, wobei die BASIC<\/b>-Variante kostenlos ist (s. Bild 2). Die folgenden Varianten PLUS<\/b>, PREMIUM <\/b>und BUSINESS <\/b>enthalten jeweils mehr Speicherplatz und Funktionen. Ich selbst nutze die PREMIUM<\/b>-Version, weil es die kleinste Version ist, die das Speichern und Durchsuchen von PDF- und Office-Dokumenten erlaubt. Zum Ausprobieren können Sie allerdings auch erst einmal die BASIC<\/b>-Variante wählen.<\/p>\n Bild 2: Verschiedene Varianten<\/span><\/b><\/p>\n Bezüglich des Speicherplatzes gibt es hier eine Besonderheit: Es gibt keine Begrenzung des eigentlichen Speicherplatzes, sondern nur der Menge der monatlich hochgeladenen Daten.<\/p>\n Nach der Anmeldung können Sie direkt über den Webbrowser mit der Eingabe von Notizen beginnen (s. Bild 3). Hier finden Sie gleich einige Beispielnotizen vor, die gängige Szenarien beschreiben.<\/p>\n Bild 3: Zugriff auf Evernote per Browser<\/span><\/b><\/p>\n Richtig interessant wird es allerdings, wenn Sie sich die Evernote-Software für den Windows-Desktop herunterladen. Den Download finden Sie unter https:\/\/evernote.com\/intl\/de\/download\/<\/b>. Dies lädt eine .exe<\/b>-Datei auf Ihren Rechner, welche die Installationsdateien für Evernote enthält.<\/p>\n Wo ist nun der Unterschied zwischen der Desktop-Version und der Version, die Sie über den Webbrowser von überall aus aufrufen können Zunächst bietet die Desktop-Software naturgemäß eine komfortablere Benutzeroberfläche mit einfacher zu bedienenden Funktionen. Ein weiterer wichtiger Unterschied ist jedoch, dass die Daten nun nicht mehr nur auf dem Webserver von Evernote gespeichert werden, sondern auch lokal auf der Festplatte. Das heißt, dass Sie hier unabhängig von einer Internetverbindung arbeiten können.<\/p>\n Außerdem müssen Sie sich nicht darauf verlassen, dass Evernote Ihre Daten zuverlässig sichert, sondern können selbst für ein Backup sorgen. Dazu sichern Sie einfach die Dateien im Verzeichnis C:\\Users\\ Bild 4: Windows-Verzeichnis mit den Evernote-Dateien<\/span><\/b><\/p>\n Evernote bietet zwar die Möglichkeit an, Notizen in Verzeichnissen zu kategorisieren. Aber es gibt nur maximal zwei Verzeichnisebenen, was dem einen oder anderen etwas schmalbrüstig vorkommen mag. Letztlich kann man sich aber mit dieser Einschränkung anfreunden.<\/p>\n In den Verzeichnissen und Unterverzeichnissen können Sie beliebig viele Notizen anlegen. Zusätzlich können Sie Notizen aber mit Schlagwörtern versehen, was eine wesentlich mächtigere Markierung als die Unterbringung in einem Ordner ist: Die Ordnerstruktur erlaubt schließlich nur die Angabe eines übergeordneten Ordners je Notiz, während Sie jeder Notiz kein, ein oder mehrere Schlagwörter zuordnen können. So lassen sich beispielsweise Artikel zum Thema Access mit dem Schlagwort Access <\/b>versehen, aber gleichzeitig auch mit dem Schlagwort VBA<\/b>. <\/p>\n Bild 5 zeigt ein Beispiel für einige Objekte, die mit verschiedenen Schlagwörtern versehen wurden.<\/p>\n Bild 5: Vergabe mehrerer Schlagwörter für verschiedene gleichzeitig markierte Notizen<\/span><\/b><\/p>\n Im Grunde genommen handelt es sich bei der Struktur unter Evernote noch nicht einmal um zwei vollwertige Ordnerebenen. Die erste Ebene kann nämlich nur Notizbücher enthalten, aber keine Notizen. Stattdessen zeigt ein Ordner der ersten Ebene, ein sogenannter Notizbuchstapel, nur die in untergeordneten Ordnern\/Notizbüchern enthaltenen Notizen an. Einen Notizbuchstapel erstellen Sie, indem Sie ein Notizbuch auf ein anderes Notizbuch ziehen, wobei diese beiden Notizbücher dem neuen Notizbuchstapel untergeordnet werden. Diesen Notizbuchstapel können Sie nun nach Wunsch benennen.<\/p>\n Wer große Mengen an Informationen in einer Datenbank wie der von Evernote speichert, möchte natürlich auch schnell über eine entsprechende Suchfunktion an die gewünschte Information gelangen.<\/p>\n Die Suchfunktion hat sich in meiner Praxis als großartig erwiesen. Sie liefert in Sekundenbruchteilen alle relevanten Notizen. Dabei geben Sie alle benötigten Suchbegriffe in das Suchfenster ein. Als Ergebnis liefert Evernote eine Liste aller Notizen, in denen alle Suchbegiffe vorkommen.<\/p>\n Der Clou ist, dass die Ergebnisliste nach der Eingabe eines jeden Zeichens aktualisiert wird, sodass Sie nicht immer noch auf eine Suchen-Schaltfläche klicken oder die Eingabetaste betätigen müssen (s. Bild 6).<\/p>\n Bild 6: Die Suchfunktion liefert alle Ergebnisse für die mit „Und“ verknüpften Suchbegriffe.<\/span><\/b><\/p>\n Wenn Sie nach einer Phrase suchen möchten, fassen Sie die einzelnen Wörter einfach in Anführungszeichen ein. Außerdem können Sie einige spezielle Suchfunktionen nutzen, indem Sie folgende Operatoren voranstellen:<\/p>\n Weitere Möglichkeiten finden Sie in der Onlinehilfe von Evernote.<\/p>\n Innerhalb von Notizen können Sie Zeilen mit führendem Kontrollkästchen einfügen, was etwa wie in Bild 7 aussieht. Sie können Notizen auch nach solchen Listeneinträgen durchsuchen, wobei es folgende Suchmöglichkeiten gibt:<\/p>\n Bild 7: Anlegen einer Liste von Aufgaben<\/span><\/b><\/p>\n Sie können also mit Evernote auch Ihre zu erledigenden Aufgaben komfortabel verwalten und dabei sichergehen, dass keine nicht erledigte Aufgabe verlorengeht.<\/p>\n Kommen wir zur Schnittstelle zwischen Access und Evernote. Möglicherweise verfügen Sie über Daten, die sich in einer Access-Datenbank befinden und die Sie gern in Evernote importieren möchten, oder Sie wollen die Notizen aus Evernote exportieren und in Ihre Datenbank einlesen.<\/p>\n Evernote kommt mit einer Bibliothek namens Evernote API (enapi) 1.0 Type Library<\/b>. Wir haben eine Weile damit experimentiert, aber letztlich keinen Erfolg gehabt. Die Bibliothek soll auch nur für interne Zwecke des Herstellers gedacht sein und nicht für externe Programmierer. Der zweite Anlauf zielte auf das SDK ab, das aber nicht für COM optimiert ist. Ein Zugriff auf die Daten von Evernote blieb so mühselig bis unmöglich.<\/p>\n Aber in der Not hilft uns der eine oder andere Workaround. <\/p>\n Der erste Workaround ist ein Dateiformat namens .enex<\/b>: Dies ist ein XML-Format, das die Daten eines Notizbuchstapels, eines Notizbuchs oder auch einer einzelnen Notiz aufnimmt.<\/p>\n Probieren wir dies anhand eines kleinen, zu Testzwecken erstellten Notizbuchstapels aus. Dieser enthält zwei Notizbücher namens Notizbuch 2 <\/b>und Notizbuch 2.1<\/b>. Um diese zu einem Notizbuchstapel hinzuzufügen, erstellen Sie die beiden Notizbücher und ziehen dann eines der beiden auf das andere Notizbuch. Evernote erstellt dann ein neues Notizbuchstapel<\/b>-Objekt und fügt die beiden Notizbücher dort ein. Nun legen wir noch in beiden Notizbüchern jeweils eine Notiz an – eine namens Notiz 2 in Notizbuch 2 <\/b>und eine namens Notiz 2.1 in Notizbuch 2.1<\/b>. Außerdem legen wir für beide Notizen noch ein paar Schlagwörter an – Schlagwort 1 <\/b>und Schlagwort 2 <\/b>für Notiz 2 <\/b>und Schlagwort 2 <\/b>und Schlagwort 3 <\/b>für Notiz 2.1<\/b>.<\/p>\n <\/p>\n Die Anordnung sieht nun etwa wie in Bild 8 aus, wo wir nun mit einem Rechtsklick auf den Notizbuchstapel das Kontextmenü öffnen und dort den Eintrag Notizen exportieren… <\/b>auswählen.<\/p>\n Bild 8: Exportieren eines Notizbuchstapels<\/span><\/b><\/p>\n Dies öffnet den Dialog mit dem Titel x Notizen exportieren <\/b>aus Bild 9. Hier behalten Sie die erste Aktion Als ENEX-Datei (.enex) exportieren <\/b>bei und klicken auf die Schaltfläche Exportieren<\/b>.<\/p>\n Bild 9: Dialog mit den Export-Optionen<\/span><\/b><\/p>\n Wenn Sie hinter der Schaltfläche Optionen… <\/b>noch weitere wichtige Optionen erwartet haben, sehen Sie sich getäuscht – hier können Sie lediglich die Option Schlagwörter<\/b> aktivieren oder deaktivieren (s. Bild 10).<\/p>\n Bild 10: Weitere Export-Optionen<\/span><\/b><\/p>\n Im folgenden Schritt legen Sie nun noch fest, wo die Datei gespeichert werden soll. Anschließend können Sie sich diese im Texteditor Ihrer Wahl ansehen. Das Ergebnis finden Sie in Listing 1.<\/p>\n Listing 1: Export zweier Notizen als .enex-Datei<\/span><\/b><\/p>\n Bei der Datei handelt es sich laut Auszeichnung um eine XML-Datei, für die ein bestimmter Dokumenttyp festgelegt wurde (evernote-export2.dtd<\/b>). Der für uns interessante Teil beginnt mit dem Element en-export<\/b>, welches mit dem Attribut export-date <\/b>das Export-Datum mitliefert.<\/p>\n Danach folgen zwei note<\/b>-Elemente mit den Inhalten und Metadaten der beiden Notizen. Da wären der Titel im title<\/b>-Element und der eigentliche Inhalt (content<\/b>).<\/p>\n Danach folgen Metadaten wie das Erstellungs- und das letzte änderungsdatum sowie mit den tag<\/b>-Elementen die Schlagwörter. Unterhalb des Elements note<\/b>-attributes finden wir mit author <\/b>noch den Benutzernamen beziehungsweise die E-Mail-Adresse des Erstellers des Dokuments.<\/p>\n Der eigentliche Inhalt ist als CDATA<\/b>-Element gespeichert. Dieses enthält wiederum ein XML-Dokument, diesmal mit einem Element namens en-note <\/b>und den in div<\/b>-Elementen eingefassten einzelnen Absätzen des Dokuments. Hier haben wir nur einfachste Notizen erstellt, um den Aufbau zu veranschaulichen.<\/p>\n Eines fällt direkt auf: Das Dokument enthält weder Informationen über den Namen des Notizbuchstapels noch über die Notizbücher, in denen die Dokumente enthalten sind. Wenn Sie also einmal Notizen exportieren und wiederherstellen möchten, müssen Sie einzelne Notizbücher exportieren und sich dabei an entsprechender Stelle, etwa in einer Tabelle einer Datenbank, den Namen des exportierten Notizbuchs merken.<\/p>\n Der Rest des Dokuments ist überschaubar und kann, die Kenntnis der VBA-Funktionen für den Zugriff auf XML-Dokumente vorausgesetzt, leicht eingelesen werden. Interessanter wird es natürlich, wie wir später sehen werden, wenn die Notiz neben dem reinen Text auch noch Elemente wie etwa ein PDF-Dokument oder Bilder enthält.<\/p>\n Nun wollen wir Kapital daraus schlagen, dass wir die Daten aus Evernote in einer XML-Datei speichern wollen und die enthaltenen Informationen in einer Access-Datenbank speichern. Dabei beschränken wir uns auf einige beispielhafte Informationen, denn die Daten von Evernote können durchaus mannigfaltig aufgebaut sein. Wir wollen also für jede Notiz einen Datensatz speichern und dazu die Schlagwörter und die enthaltenen Dateien.<\/p>\n Die Tabellen dazu bauen wir wie in Bild 11 auf. Die Tabelle tblEvernote <\/b>ist die Haupttabelle der Datenbank. Sie enthält neben dem Primärschlüsselfeld EvernoteID <\/b>die Felder Titel <\/b>(Text), Inhalt <\/b>(Memo), ErstelltAm <\/b>und AktualisiertAm <\/b>(beide Datum). Die Schlagwörter, die zusammen mit einer Evernote-Notiz angegeben werden können, wollen wir in einer eigenen Tabelle namens tblSchlagwoerter<\/b> speichern. Auf diese Weise brauchen wir jedes Schlagwort nur einmal zu speichern und erhalten keine doppelten Datensätze. Damit sicher keine Dubletten im Feld Schlagwort <\/b>dieser Tabelle landen, legen wir die Eigenschaft Indiziert <\/b>für das Feld Schlagwort <\/b>auf Ja (Ohne Duplikate) <\/b>fest.<\/p>\n Bild 11: Tabellen der Datenbank und ihre Verknüpfungen<\/span><\/b><\/p>\n Wie aber weisen wir die Schlagwörter dem jeweiligen Datensatz der Tabelle tblEvernote <\/b>zu Dies geschieht mithilfe einer Verknüpfungstabelle namens tblEvernoteSchlagwoerter<\/b>, welche eine m:n-Beziehung zwischen den Daten der beiden beteiligten Tabellen herstellt. Damit jede Kombination aus Notiz und Schlagwort nur einmal auftaucht, legen wir für die beiden Felder EvernoteID<\/b> und SchlagwortID <\/b>einen zusammengesetzten eindeutigen Index fest (s. Bild 12).<\/p>\n Bild 12: Eindeutiger Index zur Vermeidung doppelter Kombinationen aus Notiz und Schlagwort<\/span><\/b><\/p>\n Fehlt noch die Tabelle tblResources<\/b>, in der wir die in den Notizen gespeicherten Dateien unterbringen wollen. Diese Tabelle statten wir mit einem Anlage<\/b>-Feld namens Resource <\/b>und einem Feld namens Dateiname <\/b>für den Originalnamen der extrahierten Datei aus. Außerdem legen wir ein Fremdschlüsselfeld namens EvernoteID <\/b>an, mit dem wir die Datensätze der Tabelle tblResourcen <\/b>der jeweiligen Notiz zuweisen. Eine Reihenfolge wollen wir nicht in Form eines separaten Feldes vorgeben, da die Ressourcen in der XML-Datei in der Reihenfolge des Auftretens gespeichert sind und auch in dieser Reihenfolge in der Tabelle tblResources <\/b>landen sollen. Auf diese Weise gibt der Autowert als Primärschüsselwert die Reihenfolge schon vor.<\/p>\n Die Beziehungen zwischen den Tabellen definieren wir mit referenzieller Integrität und Löschweitergabe. Auf diese Weise werden die mit einer Notiz aus der Tabelle tblEvernote <\/b>verknüpften Daten der Tabellen tblResources <\/b>und tblEvernoteSchlagwoerter <\/b>gleich mitgelöscht, wenn Sie einen Datensatz aus tblEvernote <\/b>entfernen.<\/p>\n Die Prozedur Import <\/b>aus Listing 2 erwartet den Namen der .enex<\/b>-Datei als Parameter. Sie erstellt ein neues XML-Dokument und würde in dieses gleich die .enex<\/b>-Datei einlesen – wenn diese nicht eine DTD-Definition enthielt, die beim Einlesen zu einem Fehler führt. Also nutzen wir eine kleine Funktion namens RemoveDTD<\/b>, welche die .enex<\/b>-Datei öffnet, die betroffene Zeile entfernt und die Datei unter dem Namen temp.xml <\/b>wieder speichert, damit die Originaldatei nicht verändert wird. Dann liest die Prozedur die Datei temp.xml <\/b>in das XML-DOMDocument<\/b>-Objekt ein.<\/p>\n Listing 2: Einlesen von Notizen aus einer .enex-Datei<\/span><\/b><\/p>\n Im Falle eines Einlesefehlers endet die Prozedur hier mit der Ausgabe einer Fehlermeldung. Andererseits geht es nun richtig los. Die Prozedur ermittelt alle note<\/b>-Elemente im en-export<\/b>-Element und referenziert diese Auflistung mit der Variablen objNotes<\/b>. Die enthaltenen Elemente durchläuft sie in einer For Each<\/b>-Schleife. Darin liest sie den Inhalt des title<\/b>– und des content<\/b>-Elements in die beiden Variablen strTitel <\/b>und strInhalt <\/b>ein. Die Elemente created <\/b>und updated <\/b>werden erst auf Vorhandensein geprüft, bevor deren Inhalte erst mit der Hilfsfunktion GetDateFromXML <\/b>in eine Datum-Variable überführt und dann mit der Funktion ISODatum <\/b>in eine SQL-taugliche Form gebracht werden.<\/p>\n Die Datenbankaktionen, sprich das Speichern der Datensätze in den vier Tabellen, haben wir komplett in Hilfsfunktionen ausgelagert, damit die Hauptprozedur nicht zu unübersichtlich wird. Die erste heißt NotizSpeichern <\/b>und erhält einen Verweis auf die aktuelle Datenbank und den Inhalt der Variablen strTitel<\/b>, strErstelltAm<\/b>, strAktualisiertAm <\/b>und strInhalt<\/b>, auf dass sie einen neuen Datensatz mit diesen Werten in der Tabelle tblEvernote <\/b>anlegt – garniert mit dem Wunsch, bitte den Primärschlüsselwert des neu angelegten Datensatzes zurückzuliefern.<\/p>\n Den benötigen wir nämlich gleich, wenn wir die mit diesem Datensatz verknüpften Schlagwörter und Ressourcen in den weiteren Tabellen unterbringen wollen.<\/p>\n Mit den Schlagwörtern geht es Schlag auf Schlag weiter: Unterhalb des Elements note <\/b>vermuten wir einige tag<\/b>-Elemente, die wir wieder per selectNodes <\/b>auffinden und mit der Auflistungsvariablen objTags <\/b>referenzieren wollen. Die folgende For Each<\/b>-Schleife durchläuft die gefundenen Elemente und trägt das Schlagwort selbst in die Variable strSchlagwort <\/b>ein. Mit diesem, dem Verweis auf das aktuelle Database<\/b>-Objekt und dem Primärschlüsselwert des frisch angelegten Datensatzes der Tabelle tblEvernote <\/b>geht es dann zur Prozedur SchlagwortSpeichern<\/b>, die einen Datensatz für das Schlagwort in der Tabelle tblSchlagwoerter <\/b>anlegt, sofern dieses dort noch nicht vorhanden ist, und dann einen neuen Datensatz zur Tabelle tblEvernoteSchlagwoerter <\/b>hinzufügt und diesen mit den Primärschlüsselwerten der soeben angelegten Datensätze füllt.<\/p>\n Nachdem diese Aufgabe für alle vorhandenen Schlagwörter erledigt ist, geht es an die Ressourcen. Diese finden Sie, sofern vorhanden, in Form von resource<\/b>-Elementen, die sich wiederum unterhalb des Note<\/b>-Elements befinden. Wie oben schon geübt, landen die gefundenen Elemente in einer Auflistungsvariablen namens objResources<\/b>, die wir dann per For Each<\/b>-Schleife abarbeiten. Für jede Ressource lesen wir dabei den Dateinamen ein, der sich im Element resource-attributes\/file-name <\/b>unterhalb des resource<\/b>-Elements befindet. Das XML-Element objData <\/b>füllen wir mit dem Inhalt des Elements data <\/b>(zu finden unterhalb des resource<\/b>-Elements). Dies ist der Binärcode der zu extrahierenden Datei.<\/p>\n Damit wechseln wir zur Funktion WriteFileFromBytes<\/b>, der wir den Zielpfad der zu erstellenden Datei übergeben sowie den mit der Funktion DecodeBase64 <\/b>behandelten Binärcode aus dem Objekt objData<\/b>. Diese beiden Funktionen erläutern wir ausführlich im Beitrag Dateien aus XML-Dokumenten speichern und lesen <\/b>(www.access-im-unternehmen.de\/1048<\/b>). Das Resultat ist eine auf der Festplatte gespeicherte Datei auf Basis der Binärdaten aus dem data<\/b>-Element des Evernote-Exports.<\/p>\n Damit haben wir es recht leicht, einen neuen Datensatz in der Tabelle tblResources <\/b>anzulegen und das dortige Anlage-Feld mit der gewünschten Datei zu füllen. Diese Arbeit nimmt uns die Prozedur ResourceSpeichern <\/b>ab, der wir dazu den Verweis auf die aktuelle Datenbank, den Dateinamen der zu importierenden Datei sowie den Primärschüsselwert des aktuellen Datensatzes der Tabelle tblEvernote <\/b>übergeben. Warum das nun wieder Weil der neue Datensatz in der Tabelle tblResources <\/b>natürlich ein Fremdschlüsselfeld namens EvernoteID <\/b>enthält, damit die Ressource mit der Notiz verknüpft werden kann.<\/p>\n Das war es auch schon fast – wir löschen nur noch die temporär auf der Festplatte abgelegte Datei und setzen den Vorgang für die übrigen Ressourcen und dann, falls vorhanden, für die weiteren in der .enex<\/b>-Datei enthaltenen Notizen durch.<\/p>\n Die hier nicht beschriebenen Prozeduren NotizSpeichern<\/b>, ResourceSpeichern<\/b>, SchlagwortSpeichern<\/b>, GetDateFromXML<\/b>, RemoveDTD <\/b>und ISODatum <\/b>sehen wir uns in der nächsten Folge dieser Beitragsreihe an. Wer mag, kann sich aber auch schon in der Beispieldatenbank zu diesem Beitrag einen überblick über diese Routinen verschaffen.<\/p>\n Um eine .enex<\/b>-Datei etwa aus dem aktuellen Verzeichnis der Beispieldatenbank zu importieren, verwenden Sie beispielsweise den folgenden Aufruf:<\/p>\n Wenn Sie ein anderes Verzeichnis nutzen, ersetzen Sie den einzigen Parameter der Import<\/b>-Funktion komplett durch den gewünschten Pfad. Ein beispielhaftes Ergebnis für den Import einer einfachen .enex<\/b>-Datei, die keinen eigenen Text enthält, sondern deren Inhalt allein aus einem PDF-Dokument besteht, finden Sie in Bild 13. Alle vier Dateien wurden mit den entsprechenden Daten gefüllt.<\/p>\nVerschiedene Varianten<\/h2>\n
![\"Verschiedene](\"..\/fileadmin\/_temp_\/2016_04\/pic_1051_002.png\")
<\/p>\nWebbrowser-Version<\/h2>\n
![\"Zugriff](\"..\/fileadmin\/_temp_\/2016_04\/pic_1051_003.png\")
<\/p>\nDesktop-Version<\/h2>\n
![\"Windows-Verzeichnis](\"..\/fileadmin\/_temp_\/2016_04\/pic_1051_004.png\")
<\/p>\nStruktur unter Evernote<\/h2>\n
![\"Vergabe](\"..\/fileadmin\/_temp_\/2016_04\/pic_1051_005.png\")
<\/p>\nWer suchet, der findet<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2016_04\/pic_1051_006.png\")
<\/p>\n\n
Aufgaben<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2016_04\/pic_1051_007.png\")
<\/p>\n\n
Access und Evernote<\/h2>\n
Export im XML-Format<\/h2>\n
![\"Exportieren](\"..\/fileadmin\/_temp_\/2016_04\/pic_1051_008.png\")
<\/p>\n![\"Dialog](\"..\/fileadmin\/_temp_\/2016_04\/pic_1051_009.png\")
<\/p>\n![\"Weitere](\"..\/fileadmin\/_temp_\/2016_04\/pic_1051_010.png\")
<\/p>\n<xml version=\"1.0\" encoding=\"UTF-8\">\r\n<!DOCTYPE en-export SYSTEM \"http:\/\/xml.evernote.com\/pub\/evernote-export2.dtd\">\r\n<en-export export-date=\"20160630T190835Z\" application=\"Evernote\/Windows\" version=\"6.x\">\r\n <note>\r\n <title>Notiz 2 in Notizbuch 2<\/title>\r\n <content>\r\n <![CDATA[\r\n <xml version=\"1.0\" encoding=\"UTF-8\">\r\n <!DOCTYPE en-note SYSTEM \"http:\/\/xml.evernote.com\/pub\/enml2.dtd\">\r\n <en-note>\r\n <div>Dies ist der Text von Notiz 2 in Notizbuch 2.<\/div>\r\n <\/en-note>\r\n ]]>\r\n <\/content>\r\n <created>20160630T185708Z<\/created>\r\n <updated>20160630T185720Z<\/updated>\r\n <tag>Schlagwort 1<\/tag>\r\n <tag>Schlagwort 2<\/tag>\r\n <note-attributes>\r\n <author>andre@minhorst.com<\/author>\r\n <\/note-attributes>\r\n <\/note>\r\n <note>\r\n <title>Notiz 2.1 in Notizbuch 2.1<\/title>\r\n <content>\r\n <![CDATA[\r\n <xml version=\"1.0\" encoding=\"UTF-8\">\r\n <!DOCTYPE en-note SYSTEM \"http:\/\/xml.evernote.com\/pub\/enml2.dtd\">\r\n <en-note>\r\n <div>Dies ist der Text von Notiz 2.1.<\/div>\r\n <\/en-note>\r\n ]]>\r\n <\/content>\r\n <created>20160630T190018Z<\/created>\r\n <updated>20160630T190029Z<\/updated>\r\n <tag>Schlagwort 2<\/tag>\r\n <tag>Schlagwort 3<\/tag>\r\n <note-attributes>\r\n <author>andre@minhorst.com<\/author>\r\n <\/note-attributes>\r\n <\/note>\r\n<\/en-export><\/pre>\n
Export ohne Notizbuchstapel- und Notizbuchnamen<\/h2>\n
Notizen in der Datenbank speichern<\/h2>\n
![\"Tabellen](\"..\/fileadmin\/_temp_\/2016_04\/pic_1051_011.png\")
<\/p>\n![\"Eindeutiger](\"..\/fileadmin\/_temp_\/2016_04\/pic_1051_012.png\")
<\/p>\nProzedur zum Speichern einer Evernote-Notiz in der Datenbank<\/h2>\n
Public Sub <\/span>Import(strDatei As String<\/span>)\r\n Dim <\/span>objDocument As <\/span>MSXML2.DOMDocument60\r\n Dim <\/span>objNote As <\/span>MSXML2.IXMLDOMElement, objTag As <\/span>MSXML2.IXMLDOMElement\r\n Dim <\/span>objCreated As <\/span>MSXML2.IXMLDOMElement, objUpdated As <\/span>MSXML2.IXMLDOMElement\r\n Dim <\/span>objResource As <\/span>MSXML2.IXMLDOMElement, objData As <\/span>MSXML2.IXMLDOMElement\r\n Dim <\/span>objTags As <\/span>MSXML2.IXMLDOMSelection, objNotes As <\/span>MSXML2.IXMLDOMSelection\r\n Dim <\/span>objResources As <\/span>MSXML2.IXMLDOMSelection\r\n Dim <\/span>db As <\/span>DAO.Database, lngEvernoteID As Long<\/span>\r\n Dim <\/span>strTitel As String<\/span>, strInhalt As String<\/span>, strDateiname As String<\/span>\r\n Dim <\/span>datErstelltAm As Date<\/span>, datAktualisiertAm As Date<\/span>\r\n Dim <\/span>strErstelltAm As String<\/span>, strAktualisiertAm As String<\/span>, strSchlagwort As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> objDocument = New<\/span> MSXML2.DOMDocument60\r\n RemoveDTD strDatei\r\n objDocument.Load CurrentProject.Path & \"\\temp.xml\"\r\n If <\/span>objDocument.parseError = 0 Then<\/span>\r\n Set<\/span> objNotes = objDocument.selectNodes(\"en-export\/note\")\r\n For Each objNote In objNotes\r\n strTitel = objNote.selectSingleNode(\"title\").nodeTypedValue\r\n strInhalt = objNote.selectSingleNode(\"content\").nodeTypedValue\r\n Set<\/span> objCreated = objNote.selectSingleNode(\"created\")\r\n If <\/span>Not<\/span> objCreated Is Nothing Then<\/span>\r\n datErstelltAm = GetDateFromXML(objCreated.nodeTypedValue)\r\n strErstelltAm = ISODatum(datErstelltAm)\r\n End If<\/span>\r\n Set<\/span> objUpdated = objNote.selectSingleNode(\"updated\")\r\n If <\/span>Not<\/span> objUpdated Is Nothing Then<\/span>\r\n datAktualisiertAm = GetDateFromXML(objUpdated.nodeTypedValue)\r\n strAktualisiertAm = ISODatum(datAktualisiertAm)\r\n End If<\/span>\r\n lngEvernoteID = NotizSpeichern(db, strTitel, strErstelltAm, strAktualisiertAm, strInhalt)\r\n Set<\/span> objTags = objNote.selectNodes(\"tag\")\r\n For Each objTag In objTags\r\n strSchlagwort = objTag.nodeTypedValue\r\n SchlagwortSpeichern db, strSchlagwort, lngEvernoteID\r\n Next<\/span> objTag\r\n Set<\/span> objResources = objNote.selectNodes(\"resource\")\r\n For Each objResource In objResources\r\n strDateiname = objResource.selectSingleNode(\"resource-attributes\/file-name\").nodeTypedValue\r\n Set<\/span> objData = objResource.selectSingleNode(\"data\")\r\n WriteFileFromBytes CurrentProject.Path & \"\\\" _\r\n & strDateiname, DecodeBase64(objData.nodeTypedValue)\r\n ResourceSpeichern db, strDateiname, lngEvernoteID\r\n Kill CurrentProject.Path & \"\\\" & strDateiname\r\n Next<\/span> objResource\r\n Next<\/span> objNote\r\n Else<\/span>\r\n MsgBox<\/span> \"Die Datei ''''\" & strDatei & \"'''' konnte nicht eingelesen werden:\" & vbCrLf<\/span> & \"''''\" _\r\n & objDocument.parseError.reason & \"''''\"\r\n End If<\/span>\r\n Kill CurrentProject.Path & \"\\temp.xml\"\r\nEnd Sub<\/span><\/pre>\nImport starten<\/h2>\n
Import CurrentProject.Path & \"\\<Dateiname>.enex\"<\/pre>\n
![\"Daten](\"..\/fileadmin\/_temp_\/2016_04\/pic_1051_013.png\")
<\/p>\n