<\/p>\n
Im ersten Teil der Beitragsreihe haben wir uns darum gekümmert, die E-Mails mit Kundenanfragen zu erfassen und diese in einem Formular in neue Tickets umzuwandeln. Außerdem haben wir in diesem Zuge auch gleich die Kundendaten erfasst. Nun schauen wir uns an, wie wir die Tickets bearbeiten, Antworten an die Kunden senden und deren Antworten automatisch zum Ticket hinzufügen. Außerdem stehen noch einige Feinheiten an, die uns die Arbeit mit den Tickets erleichtern sollen. Schließlich sollen die Tickets auf einfachste Weise von Outlook in unsere Anwendung gelangen.<\/b><\/p>\nBin ich im richtigen Frontend<\/h2>\n
Bevor wir zu den eigentlichen Funktionen der Ticketverwaltung übergehen, wollen wir noch eine Sache sicherstellen, die mir beim Vorbereiten der Anwendung für den zweiten Teil dieser Beitragsreihe kurz Kopfzerbrechen bereitet hat. In der vorherigen Ausgabe von Access im Unternehmen haben wir im Beitrag Benutzerdefinierte Outlook-Eigenschaften <\/b>(www.access-im-unternehmen.de\/1030<\/b>) erfahren, wie wir in Outlook benutzerdefinierte Eigenschaften speichern können.<\/p>\n
Genau genommen war das eine Vorarbeit für die Ticketverwaltung, denn wir wollen dort in Outlook speichern, in welche Datenbank die Kundenanfragen, die dort als E-Mail eingehen, gespeichert werden sollen. Dabei handelt es sich natürlich um unser Ticketsystem.<\/p>\n
Wenn wir dort den Pfad zur entsprechenden Datenbankdatei speichern, soll Outlook eingehende Kundenanfragen als E-Mails in dieser Datenbank speichern. Das gelingt genau so lange, bis die Datenbank nicht mehr am angegebenen Speicherort vorgebunden werden kann.<\/p>\n
Es kann aber auch der Fall eintreten, dass Sie – aus welchen Gründen auch immer – die Datenbank mit dem Ticketsystem nicht von einem Verzeichnis in ein anders verschieben, sondern es lediglich kopieren. Bei mir war dies der Fall, weil ich die Datenbank von dem Ordner, in dem die Daten für den ersten Teil der Beitragsreihe lagen, in den Ordner mit den Daten für den zweiten Teil kopiert habe. Dadurch lag die Zieldatenbank für die neu eingehenden Kundenanfragen zwar nun in einem neuen Verzeichnis, gleichzeitig aber auch noch im alten Verzeichnis!<\/p>\n
Hätte ich die Datenbank einfach verschoben und somit aus dem alten Ordner entfernt, wäre dies beim öffnen von Outlook durch den dann ausgelösten VBA-Code aufgefallen und ich hätte einfach den Pfad zum neuen Speicherort eingeben müssen.<\/p>\n
Nun habe ich aber fleißig neue Kundenanfragen in den dafür angelegten Outlook-Ordner kopiert, in der Hoffnung, diese würden so auch automatisch in der Access-Datenbank im Ordner für den zweiten der Beitragsreihe gespeichert. Dort geschah aber gar nichts – keine neuen Einträge!<\/p>\n
Damit Sie eine Möglichkeit haben, zu erkennen, dass etwas falsch läuft, fügen wir also nun zunächst etwas Code zum Access-Ticketsystem hinzu, der prüft, ob die aktuell geöffnete Access-Datenbankdatei auch diejenige ist, die in Outlook für die entsprechende Eigenschaft hinterlegt ist.<\/p>\n
Dazu können wir auch von Access aus die im Beitrag Benutzerdefinierte Outlook-Eigenschaften <\/b>formulierten VBA-Routinen nutzen – mit Ausnahme einer einzigen Routine, die wir noch anpassen müssen.<\/p>\n
Die Routinen EigenschaftEinlesen<\/b>, EigenschaftSetzen <\/b>und OpenFilename <\/b>können Sie aus der Beispieldatenbank zu Benutzerdefinierte Outlook-Eigenschaften <\/b>entnehmen und in das Ticketsystem einpflegen.<\/p>\n
Die weitere Routine DatenbankpfadHolen <\/b>überführen wir in eine parameterlose Routine namens Datenbankpfad-InOutlookAktualisieren<\/b> (s. Listing 1). Diese deklariert zunächst einige Variablen und legt deren Werte fest, zum Beispiel für die Variablen strElement <\/b>(Wert: Ticketsystem<\/b>) und strName <\/b>(Datenbankpfad<\/b>).<\/p>\n Listing 1: Aktualisieren des Datenbankpfades in Outlook<\/span><\/b><\/p>\n Außerdem haben wir den Code dieser Methode etwas angepasst. Sie soll nun nicht mehr prüfen, ob die benutzerdefinierte Eigenschaft Datenbankpfad <\/b>einen Wert enthält und ob dieser dem Pfad einer vorhandenen Datenbankdatei entspricht, um gegebenenfalls den Benutzer aufzufordern, den passenden Pfad per Datei öffnen<\/b>-Dialog anzugeben.<\/p>\n Das ist nicht nötig, denn wir befinden uns ja gerade in der gewünschten Datenbank-Datei. Also müssen wir nur noch prüfen: Ist in der Eigenschaft Datenbankpfad <\/b>überhaupt ein Pfad gespeichert und entspricht dieser dem Datenbankpfad der aktuell geöffneten Datei Falls nicht, soll die Eigenschaft einfach auf die aktuelle Datenbank eingestellt werden.<\/p>\n Die Routine liest über die Funktion EigenschaftEinlesen <\/b>den aktuell in der Eigenschaft Datenbankpfad <\/b>des StorageItem<\/b>-Elements namens Ticketsystem <\/b>gespeicherten Wert in die Variable strDatenbankpfad <\/b>ein. Sie prüft, ob strDatenbankpfad<\/b> überhaupt einen Wert enthält. Falls ja, prüft sie, ob der Wert einem gültigen Dateipfad entspricht. Falls ja, wird die Variable bolVorhanden <\/b>auf True <\/b>eingestellt. Ist bolVorhanden<\/b> danach False<\/b>, stellt die Prozedur den Wert der Variablen strDatenbankpfad <\/b>auf den Pfad zur aktuellen Datenbankdatei ein und ruft dann die Funktion EigenschaftSetzen <\/b>auf, um den Wert der Eigenschaft Datenbankpfad <\/b>auf den Namen der aktuellen Datenbankdatei einzustellen – nicht ohne den Benutzer zuvor über diese Aktion zu informieren.<\/p>\n War bereits ein Datenbankpfad gespeichert, vergleicht die Prozedur diesen mit dem Pfad zur aktuellen Datenbankdatei. Sind die beiden Zeichenketten nicht gleich, erscheint ebenfalls eine Meldung und der Pfad der aktuellen Datenbankdatei landet in der benutzerdefinierten Eigenschaft Datenbankpfad <\/b>von Outlook.<\/p>\n Bevor wir uns nun weiter um die Verarbeitung der Tickets in Access kümmern, wollen wir noch eine Möglichkeit schaffen, neue Kundenanfragen, die im Ticketsystem verarbeitet werden sollen, dort hinein zu kopieren.<\/p>\n Dies soll auf der Outlook-Seite ganz einfach geschehen: Der Benutzer soll die infrage kommenden Mails von Kunden einfach per Drag and Drop in einen Ordner namens Ticketsystem <\/b>ziehen (s. Bild 1).<\/p>\n Bild 1: Verschieben einer Anfrage in den Ordner Ticketsystem<\/span><\/b><\/p>\n Wenn die E-Mails dann im Zielordner gelandet sind, sollen sie vor allem mit dem Zusatz [Ticket xxx] <\/b>ausgestattet sein. Damit können wir zwei Dinge erkennen: Erstens, dass der Mechanismus, der durch das Hineinziehen einer Mail in diesen Ordner ausgelöst werden soll, funktioniert hat.<\/p>\n Zweitens soll der Platzhalter xxx <\/b>den Wert des Primärschlüsselfeldes enthalten, unter dem die Mail als neuer Datensatz in der Tabelle tblMailItems <\/b>angelegt wurde (s. Bild 2).<\/p>\n Bild 2: In den Ordner Ticketsystem verschobene Anfragen<\/span><\/b><\/p>\n Damit kommen wir zu dem Mechanismus selbst. Dieser soll ausgelöst werden, wenn wir eine E-Mail in den Ordner Ticketsystem <\/b>von Outlook ziehen.<\/p>\n Diesen initialisieren wir in einer Prozedur namens Application_Startup_Ticketverwaltung <\/b>(s. Listing 2). Diese wird nicht automatisch mit Outlook gestartet. Allerdings löst Outlook beim Start automatisch eine Prozedur aus, die wir Application_Startup <\/b>nennen und die sich in der Klasse ThisOutlookSession <\/b>des VBA-Projekts von Outlook befindet.<\/p>\n Listing 2: Starten des Mechanismus zum automatischen übertragen von E-Mails, die in einen bestimmten Ordner verschoben werden<\/span><\/b><\/p>\n Sollten Sie diese noch nicht verwenden, tragen Sie nur den Aufruf der Prozedur Application_Startup_Ticketverwaltung <\/b>dort ein. Anderenfalls fügen Sie diesen Aufruf einfach an die bereits vorhandenen Anweisungen an:<\/p>\n Die Prozedur Application_Startup_Ticketverwaltung <\/b>deklariert Variablen zum Speichern von Verweisen auf die Ticketsystem-Datenbank und ein Recordset für den Zugriff auf die Optionentabelle, ein Folder<\/b>-Objekt für den Zugriff auf den Ziel-Ordner in Outlook sowie eine Variable zum Speichern von Objekten des Typs clsFolderArchiv<\/b>.<\/p>\n Da wir hier innerhalb des Outlook-VBA-Projekts auf Elemente der DAO-Bibliothek zugreifen, fügen wir dem VBA-Projekt noch einen Verweis auf diese Objektbibliothek hinzu – plus einen Verweis auf die Access-Bibliothek, falls wir mal eine Funktion wie Nz() <\/b>oder DLookup() <\/b>benötigen (s. Bild 3).<\/p>\n Bild 3: Verweis auf die DAO-Bibliothek, zusätzlich auch noch auf die Access-Bibliothek<\/span><\/b><\/p>\n Die Prozedur verwendet dann zunächst die Funktion DatenbankpfadHolen<\/b>, die wir bereits im Beitrag Benutzerdefinierte Outlook-Eigenschaften <\/b>beschrieben haben. Diese Funktion liefert den Pfad zur Datenbank Ticketsyste.accdb <\/b>zurück, der in der dafür angelegten benutzerdefinierten Eigenschaft gespeichert ist. Diese Vorgehensweise verwenden wir, damit wir diesen Pfad nicht fest im Code verdrahten müssen – etwa in Form einer Konstanten -, sondern ihn auch einmal dynamisch ändern können, wenn sich der Speicherort des Ticketsystems ändert. Dann öffnen wir mit der OpenDatabase<\/b>-Methode die soeben ermittelte Datenbankdatei und speichern einen Verweis darauf in der Database<\/b>-Variablen db<\/b>.<\/p>\n Als Nächstes greifen wir über die OpenRecordset<\/b>-Methode auf die Tabelle tblOptionen <\/b>dieser Datenbank zu und speichern den Verweis darauf in der Recordset<\/b>-Variablen rst<\/b>.<\/p>\n Die Prozedur könnte auch mehrere Ordner als Zielordner definieren, daher verwenden wir eine Collection, um für jeden Zielordner ein Objekt der Klasse clsFolderArchiv <\/b>zu speichern. Diese deklarieren wir wir folgt im Kopf des Moduls ThisOutlookSession<\/b>:<\/p>\n <\/p>\n Da wir wie gesagt auch mehrere Ordner nutzen könnten, durchlaufen wir die Datensätze der Tabelle tblOptionen <\/b>in einer Do While<\/b>-Schleife. Im ersten Schritt erstellen wir eine neue Instanz der Klasse clsFolderArchiv<\/b>.<\/p>\n Dieser weisen wir einige Informationen zu, die wir dem aktuellen Datensatz der Tabelle tblOptionen <\/b>entnehmen. Der erste ist der Zielordner. Den Pfad zu diesem Ordner, in unserer Beispielkonstellation \\\\Outlook\\Posteingang\\Ticketsystem<\/b>, lesen wir aus dem Feld Verzeichnis <\/b>ein.<\/p>\n Dann verwenden wir die Hilfsfunktion GetFolderByPath<\/b>, um ein Folder<\/b>-Objekt zu diesem Verzeichnis zu ermitteln und das Ergebnis in der Variablen objFolder <\/b>zu speichern.<\/p>\n Die Funktion GetFolderByPath <\/b>erwartet den Pfad als String. Sie durchläuft alle Ordner, auch rekursiv, bis sie den entsprechenden Outlook-Folder gefunden hat. Dieser landet dann in der Variablen objFolder<\/b>.<\/p>\n Diese Funktion haben wir, neben einigen anderen Funktionen für den Zugriff auf die Outlook-Objekte, schon in mehreren Ausgaben genutzt. In der nächsten Ausgabe finden Sie im Beitrag Outlook-Ordner im Griff <\/b>(www.access-im-unternehmen.de\/1043<\/b>) eine Erläuterung dieser Funktion sowie einige weiterführende Informationen zu Outlook-Ordnern.<\/p>\n Es kann sein, dass die Funktion GetFolderByPath <\/b>kein Ergebnis zurückliefert. Das ist genau dann der Fall, wenn es kein Folder<\/b>-Objekt mit dem angegebenen Pfad gibt.<\/p>\n Deshalb prüfen wir mit der folgenden If…Then<\/b>-Bedingung, ob objFolder <\/b>den Wert Nothing <\/b>liefert, also dass es leer ist. Ist das der Fall, folgt eine entsprechende Meldung und die PickFolder<\/b>-Methode zeigt einen Dialog an, mit dem der Benutzer den gewünschten Zielordner auswählen kann (s. Bild 4).<\/p>\n Bild 4: Auswählen eines neuen Zielordners für die Kundenanfragen<\/span><\/b><\/p>\n Der auf diese Weise der Variablen objFolder <\/b>zugewiesene Outlook-Folder liefert mit der Eigenschaft FolderPath <\/b>seine Pfadangabe, die wir mit der nächsten Anweisung per UPDATE<\/b>-Abfrage in der Tabelle tblOptionen <\/b>speichern.<\/p>\n Nun können wir die Eigenschaft Folder <\/b>der Klasse clsFolderArchiv <\/b>auf dieses Objekt einstellen. Auf wesentlich einfachere Weise füllen wir nun die Eigenschaften AnlagenSpeichern<\/b>, NeuEinlesen <\/b>und Groesse<\/b>, denen wir einfach die Werte der entsprechenden Felder des Recordsets rst <\/b>zuweisen – und die Eigenschaft Database <\/b>erhält einen Verweis auf das Objekt db<\/b>, also die aktuelle referenzierte Datenbank.<\/p>\n Das so gefüllte Objekt objFolderArchiv <\/b>fügen wir dann per Add<\/b>-Methode zum Collection<\/b>-Objekt colFolders <\/b>hinzu, damit es nach Beenden der Prozedur und somit dem Verfallen der Gültigkeit der Objektvariablen nicht in den ewigen Jagdgründen landet. Auf die gleiche Weise werden, sollten auch Unterordner dieses Ordners als Ziel für das Verschieben von Kundenanfragen infrage kommen, auch noch alle Ordner unterhalb des angegebenen Ordners referenziert und in der Collection colFolders <\/b>gespeichert – und natürlich deren Unterordner und so weiter. Dafür muss jedoch das Feld Rekursiv <\/b>der Tabelle tblOptionen <\/b>den Wert True <\/b>aufweisen.<\/p>\n Die Klasse clsFolderArchiv <\/b>haben wir weitgehend aus der gleichnamigen Klasse des Beitrags Outlook-Mails nach Empfang archivieren <\/b>(www.access-im-unternehmen.de\/1007<\/b>) übernommen. Es gibt ein paar kleinere Unterschiede.<\/p>\n So verfügt unsere Tabelle tblMailItems<\/b> in der Ticketsystem-Datenbank über ein eindeutiges Feld namens EntryID<\/b>, sodass eine E-Mail nur einmalig in der Tabelle gespeichert werden kann und eine Fehlermeldung angezeigt wird, wenn der Benutzer die gleiche Mail zwei Mal in einen der Outlook-Ordner der Ticketverwaltung zieht.<\/p>\n Die übrigen Vorgänge sind mit den in diesem Beitrag beschriebenen Abläufen identisch: Beim Hineinziehen einer E-Mail in einen Outlook-Ordner, den wir mit einem Objekt der Klasse clsFolderArchiv <\/b>referenziert haben, löst dies ein Ereignis aus, das den Inhalt der E-Mail in die Tabelle tblMailItems <\/b>der Zieldatenbank schreibt.<\/p>\n Das Formular frmOffeneMails <\/b>soll alle Mails anzeigen, die in den entsprechenden Outlook-Ordner gezogen und so automatisch in der Tabelle tblMailItems <\/b>gespeichert wurden (s. Bild 5). Dazu nutzt das Formular das Listenfeld lstOffeneMails<\/b> links oben.<\/p>\n Bild 5: Das Formular frmOffeneMails in der Entwurfsansicht<\/span><\/b><\/p>\n Die Datensatzherkunft des Listenfeldes sieht wie in Bild 6 aus. Sie verwendet die Tabelle tblMailItems <\/b>und die Tabelle tblTickets <\/b>als Datenquelle. Die Tabelle tblTickets <\/b>ist über das Fremdschlüsselfeld MailItemID <\/b>mit der Tabelle tblTickets <\/b>verknüpft.<\/p>\n Bild 6: Datensatzherkunft für das Listenfeld lstOffeneMails<\/span><\/b><\/p>\n Ohne weitere Maßnahmen würde die Abfrage also alle Datensätze der beiden Tabellen liefern, für die eine Verknüpfung vorliegt. Wir wollen aber ja gerade die Datensätze der Tabelle tblMailItems <\/b>anzeigen, die noch nicht in Form eines Tickets in die Datenbank aufgenommen wurden. Also führen wir zwei Schritte durch: Als Erstes klicken Sie doppelt auf den Beziehungspfeil, sodass sich die Verknüpfungseigenschaften öffnen. Hier wählen Sie die Option Beinhaltet ALLE Datensätze aus “tblMailItems“ und nur die Datensätze aus “tblTickets“, bei denen die Inhalte der verknüpften Felder beider Tabellen gleich sind. <\/b>aus.<\/p>\n Damit zeigt die Abfrage nun auch solche Datensätze der Tabelle tblMail-Items <\/b>an, die noch nicht mit einem Datensatz der Tabelle tblTickets <\/b>verknüpft sind. Wir wollen aber ausschließlich die Datensätze, die noch nicht mit dieser Tabelle verknüpft sind, liefern.<\/p>\n Das ist ohne viel Aufwand umzusetzen: Wir müssen einfach nur ein Kriterium festlegen, das nur diejenigen Datensätze zulässt, für die das Feld TicketID <\/b>den Wert Null <\/b>enthält.<\/p>\n Das Listenfeld soll das Feld MailItemID <\/b>als gebundene Spalte verwenden und die Felder Absender <\/b>und Betreff <\/b>anzeigen, also ziehen wir diese neben TicketID <\/b>in das Entwurfsraster der Abfrage.<\/p>\n Damit das Listenfeld die Felder so anzeigt, stellen wir die Eigenschaft Spaltenanzahl <\/b>auf 3 <\/b>und Spaltenbreiten <\/b>auf 0;5cm <\/b>ein. So wird die gebundene Spalte mit dem Feld MailItemID <\/b>ausgeblendet, das Feld Absender <\/b>nimmt fünf Zentimeter ein und das Feld Betreff <\/b>den Rest der Breite des Listenfeldes. Das Feld TicketID <\/b>wird gar nicht berücksichtigt, Sie könnten es daher im Abfrageentwurf auch durch Entfernen des Hakens in der Zeile Anzeigen <\/b>aus dem Ergebnis entfernen.<\/p>\n Das Formular frmOffeneMails <\/b>selbst enthält einige Steuer-elemente, die an Felder der Tabelle tblMailItems <\/b>gebunden sind. Daher stellen wir für die Eigenschaft Datenherkunft <\/b>des Formulars natürlich den Wert tblMailItems <\/b>ein.<\/p>\n Das Formular frmOffeneMails <\/b>soll natürlich nur geöffnet werden, wenn es neue Mails in der Tabelle tblMailItem <\/b>gibt, die noch keinem Ticket zugeordnet wurden. Dies muss etwa beim Starten der Anwendung geprüft werden – zum Beispiel in einer Prozedur, die durch das automatisch beim Start ausgeführte Makro namens AutoExec <\/b>aufgerufen wird – oder durch ein als Startformular angegebenes Formular. Da meine Beispieldatenbanken ohnehin immer ein Startformular mit der Angabe des Beitrags und der Ausgabe haben, zu welcher die Beispieldatenbank gehört, nutzen wir diese Möglichkeit.<\/p>\n Das Formular frmIntro <\/b>erhält also in der Prozedur, die durch das Anklicken des OK<\/b>-Symbols unten rechts ausgelöst wird, folgende Anweisungen (s. Bild 7):<\/p>\n Bild 7: Startformular der Anwendung<\/span><\/b><\/p>\n Interessant ist die letzte Anweisung, welche die Prozedur Start <\/b>aufruft. Diese sieht wie folgt aus:<\/p>\n Sie prüft also, ob die Abfrage qryOffeneMails <\/b>mehr als 0 <\/b>Datensätze zurückliefert, und öffnet nur in diesem Fall das Formular frmOffeneMails<\/b>. Den Aufbau dieser Abfrage haben Sie ja weiter oben bereits kennen gelernt.<\/p>\n Beim Laden des Formulars sollen einige Steuerelemente initialisiert werden. Zum Beispiel soll das Listenfeld lstOffeneMails <\/b>direkt den ersten Datensatz markieren. Und das Formular selbst soll natürlich die Daten zu diesem ersten Datensatz anzeigen.<\/p>\n Schließlich soll auch das Kombinationsfeld cboKundeID<\/b>, das zur Auswahl des passenden Kunden zu diesem Ticket dient, den ersten Eintrag anzeigen. Welcher das ist, klären wir gleich im Anschluss.<\/p>\n Damit die Steuerelemente initialisiert werden, fügen wir der Ereignisprozedur, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird, den Aufruf der Prozedur SteuerelementeInitialisieren <\/b>hinzu:<\/p>\n Diese Prozedur sieht dann wie folgt aus und landet ebenfalls im Klassenmodul zum Formular frmOffeneMails<\/b>:<\/p>\n Die erste Anweisung stellt den Wert des Listenfeldes lstOffeneMails <\/b>auf den Wert des ersten Eintrags ein, der mit der Eigenschaft ItemData(0)<\/b> ermittelt wird.<\/p>\n Die zweite ruft die Methode FindFirst <\/b>des Recordset<\/b>-Objekts des Formulars auf und übergibt ihr als Kriterium einen Ausdruck wie MailItemID = xxx<\/b>, wobei xxx <\/b>für den Wert der gebundenen Spalte des Listenfeldes lstOffene-Mails <\/b>dient.<\/p>\n Zum Anlegen eines neuen Tickets wählt der Benutzer zunächst die gewünschte E-Mail aus dem Listenfeld lstOffeneMails <\/b>aus, sofern er nicht die beim öffnen des Formulars ausgewählte erste E-Mail der Liste bearbeiten möchte. Dies löst das Ereignis Nach Aktualisierung <\/b>des Listenfeldes und somit die folgende Ereignisprozedur aus:<\/p>\n Dies sorgt dafür, dass die Daten des ausgewählten Eintrags auch in den Steuerelementen des Formulars abgebildet werden.<\/p>\n Nun wird der Benutzer Teile des Inhalts der E-Mail in das Feld Inhalt <\/b>übertragen, indem er diese markiert. Das automatische Kopieren erledigt die im Beitrag Markierung automatisch kopieren <\/b>(www.access-im-unternehmen.de\/1027<\/b>) beschriebene Technik.<\/p>\n Dafür sorgen die beiden Ereignisprozeduren aus Listing 3. ähnliche Prozeduren liegen auch für das Textfeld txtHTMLBody <\/b>vor, damit Sie auch diese Inhalte einfach in das Textfeld txtInhalt <\/b>überführen können.<\/p>\n Listing 3: Prozeduren, die für ein automatisches übertragen markierter Inhalte des Textfeldes txtBody in das Textfeld txtInhalt sorgen<\/span><\/b><\/p>\n Eine weitere wichtige Eigenschaft für das Anlegen eines neuen Tickets ist die Zuordnung zu einem Kunden aus der Tabelle tblKunden<\/b>.<\/p>\n Wenn Sie beginnen, das Ticketsystem zu nutzen, befinden sich aber erst einmal keine Datensätze in der Tabelle tblKunden<\/b>. Also werden Sie die ersten Kunden erst einmal anlegen müssen, bevor irgendwann eine Anfrage eines Kunden kommt, der bereits in der Tabelle tblKunden <\/b>gespeichert ist.<\/p>\n Um einen neuen Kundendatensatz anzulegen, gibt es kein offensichtliches Steuerelement im Formular frmOffeneMails<\/b>. Das ist allerdings Absicht, denn dazu haben wir einen Eintrag im Kombinationsfeld cboKundeID <\/b>mit dem Text Bild 8: Das Formular frmOffeneMails mit dem Eintrag zum Anlegen neuer Kunden<\/span><\/b><\/p>\n Damit das Kombinationsfeld nicht nur diesen, sondern auch noch den Eintrag Dabei handelt es sich um eine UNION<\/b>-Abfrage, die wie folgt aussieht:<\/p>\n Die UNION<\/b>-Abfrage fügt also drei einzelne Abfragen zu einer einzigen zusammen. Die erste steuert lediglich den informativen Eintrag Der zweite Teil der UNION<\/b>-Abfrage liefert den Text Schließlich folgt der dritte Teil, der Daten aus der Tabelle tblKunden <\/b>beisteuert – und zwar jeweils den Wert des Feldes KundeID <\/b>sowie ein neues berechnetes Feld namens Kunde, das aus dem Feld Nachname<\/b>, einem Komma und dem Feld Vorname<\/b> des Kunden zusammengesetzt ist – also etwa in der Form Minhorst, André<\/b>.<\/p>\n Wenn der Benutzer einen neuen Eintrag für dieses Kombinationsfeld auswählt, löst er damit das Ereignis Nach Aktualisierung <\/b>aus. Dafür hinterlegen wir die Prozedur aus Listing 4. Diese prüft lediglich, ob das Kombinationsfeld den Wert -1 <\/b>aufweist.<\/p>\n Listing 4: Die Ereignisprozedur Nach Aktualisierung des Kombinationsfeldes cboKundeID<\/span><\/b><\/p>\n Ist dies der Fall, soll ein neuer Kunde angelegt werden – und dazu verwenden wir das Formular frmKundeDetail<\/b>, das wir im ersten Teil der Beitragreihe namens Ticketsystem mit Access, Teil 1 <\/b>(www.access-im-unternehmen.de\/1033<\/b>) bereits vorgestellt haben. Dazu öffnen wir das Formular mit der Methode DoCmd.OpenForm <\/b>und stellen den Datenmodus auf acFormAdd <\/b>ein.<\/p>\n Außerdem soll das Formular als modaler Dialog geöffnet werden, weshalb wir für den Parameter WindowMode <\/b>den Wert acDialog <\/b>übergeben. Schließlich soll die E-Mail-Adresse für diesen Kunden bereits aufgrund der mit der E-Mail gelieferten Absenderadresse vorbelegt werden. Daher übergeben wir diesen Wert mit dem Parameter OpenArgs<\/b>.<\/p>\n Der Code der aufrufenden Prozedur cboKundeID_After-Update <\/b>wird erst fortgesetzt, wenn das Formular geschlossen oder ausgeblendet wird.<\/p>\n Die Prozedur prüft dann, ob das Formular noch geöffnet ist, und liest den Primärschlüsselwert des neu angelegten Kundendatensatzes in die Variable lngKundeID <\/b>ein. Dann schließt sie das Formular frmKundeDetails<\/b>.<\/p>\n Damit der neue Kunde gleich im Kombinationsfeld cbo-KundeID <\/b>erscheint, aktualisiert die Prozedur seine Datensatzherkunft mit der Requery<\/b>-Methode. Das Kombinationsfeld soll den neu zur Tabelle tblKunden <\/b>hinzugefügten Datensatz direkt auswählen, was wir durch einfache Zuweisung des Primärschlüsselwertes aus lngKundeID <\/b>erledigen.<\/p>\n Sobald der Benutzer nun noch eine Bezeichnung für das Ticket eingegeben hat, kann er mit einem Klick auf die Schaltfläche Anlegen <\/b>einen neuen Ticket-Datensatz in der Tabelle tblTickets <\/b>anlegen. Dies löst die Prozedur aus Listing 5 aus. Die Prozedur prüft, ob das Kombinationsfeld cboKundeID <\/b>einen Wert größer als 0 <\/b>enthält, also nicht etwa der Eintrag Public Function <\/span>DatenbankpfadInOutlookAktualisieren()\r\n Dim <\/span>strDatenbankpfad As String<\/span>\r\n Dim <\/span>bolVorhanden As Boolean<\/span>\r\n Dim <\/span>strElement As String<\/span>\r\n Dim <\/span>strName As String<\/span>\r\n strElement = \"Ticketsystem\"\r\n strName = \"Datenbankpfad\"\r\n strDatenbankpfad = EigenschaftEinlesen(strElement, strName)\r\n If <\/span>Not<\/span> Len<\/span>(strDatenbankpfad) = 0 Then<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(Dir(strDatenbankpfad)) = 0 Then<\/span>\r\n bolVorhanden = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> bolVorhanden Then<\/span>\r\n strDatenbankpfad = CurrentDb.Name\r\n MsgBox<\/span> \"Der Datenbankpfad für die Ticketverwaltung in Outlook ist noch nicht gesetzt. Dies wird nun erledigt.\", _\r\n vbOKOnly + vbExclamation\r\n EigenschaftSetzen strElement, strName, strDatenbankpfad\r\n Else<\/span>\r\n If <\/span>Not<\/span> (strDatenbankpfad = CurrentDb.Name) Then<\/span>\r\n MsgBox<\/span> \"Der Datenbankpfad in Outlook ist nicht auf die aktuelle Datenbankdatei gesetzt, sondern auf:\" _\r\n & vbCrLf<\/span> & vbCrLf<\/span> & strDatenbankpfad & vbCrLf<\/span> & vbCrLf<\/span> _\r\n & \"Er wird nun auf die aktuelle Datenbank eingestellt.\"\r\n strDatenbankpfad = CurrentDb.Name\r\n EigenschaftSetzen strElement, strName, strDatenbankpfad\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nMails von Outlook halbautomatisch in die Datenbank einlesen<\/h2>\n
![\"Verschieben](\"..\/fileadmin\/_temp_\/2016_03\/pic_1041_001.png\")
<\/p>\n![\"In](\"..\/fileadmin\/_temp_\/2016_03\/pic_1041_002.png\")
<\/p>\nMechanismus zum übertragen der Kundenanfragen in Outlook<\/h2>\n
Public Sub <\/span>Application_Startup_Ticketverwaltung()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>objFolder As <\/span>Outlook.Folder\r\n Dim <\/span>objFolderArchiv As <\/span>clsFolderArchiv\r\n Dim <\/span>strTicketsystemDatenbank As String<\/span>\r\n On Error GoTo<\/span> Application_Startup_Err\r\n strTicketsystemDatenbank = DatenbankpfadHolen(\"Ticketsystem\", \"Datenbankpfad\")\r\n Set<\/span> db = DBEngine.OpenDatabase(strTicketsystemDatenbank, , True<\/span>)\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblOptionen\", dbOpenDynaset)\r\n Set<\/span> colFolders = New<\/span> Collection\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Set<\/span> objFolderArchiv = New<\/span> clsFolderArchiv\r\n With<\/span> objFolderArchiv\r\n Set<\/span> objFolder = GetFolderByPath(rst!Verzeichnis)\r\n If <\/span>objFolder Is Nothing Then<\/span>\r\n MsgBox<\/span> \"Der in der Export-Datenbank ''\" & strTicketsystemDatenbank & \"'' angegebene Outlook-Ordner ''\" _\r\n & rst!Verzeichnis & \"'' ist nicht in Outlook vorhanden. Wählen Sie diesen nun erneut aus.\"\r\n Set<\/span> objFolder = Outlook.GetNamespace(\"MAPI\").PickFolder\r\n db.Execute \"UPDATE tblOptionen SET Verzeichnis = ''\" & objFolder.FolderPath & \"''\", dbFailOnError\r\n End If<\/span>\r\n Set<\/span> .Folder = objFolder\r\n .AnlagenSpeichern = rst!AnlagenSpeichern\r\n Set<\/span> .Database = db\r\n .NeuEinlesen = rst!NeuEinlesen\r\n .Groesse = Nz(rst!Groesse)\r\n End With<\/span>\r\n colFolders.Add objFolderArchiv\r\n If <\/span>rst!Rekursiv Then<\/span>\r\n UnterordnerInstanzieren objFolder, db, Nz(rst!Groesse), rst!NeuEinlesen, rst!AnlagenSpeichern, colFolders\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>Application_Startup()\r\n ...\r\n Application_Startup_Ticketverwaltung\r\nEnd Sub<\/span><\/pre>\n![\"Verweis](\"..\/fileadmin\/_temp_\/2016_03\/pic_1041_003.png\")
<\/p>\nDim <\/span>colFolders As <\/span>Collection<\/pre>\n![\"Auswählen](\"..\/fileadmin\/_temp_\/2016_03\/pic_1041_004.png\")
<\/p>\nFunktionsweise des Formulars frmOffeneMails<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2016_03\/pic_1041_006.png\")
<\/p>\n![\"Datensatzherkunft](\"..\/fileadmin\/_temp_\/2016_03\/pic_1041_005.png\")
<\/p>\nDatenherkunft des Formulars<\/h2>\n
öffnen des Formulars<\/h2>\n
![\"Startformular](\"..\/fileadmin\/_temp_\/2016_03\/pic_1041_007.png\")
<\/p>\nPrivate Sub <\/span>cmdGo_Click()\r\n DoCmd.Close acForm, Me.Name\r\n Start\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>Start()\r\n If <\/span>DCount(\"MailItemID\", \"qryOffeneMails\") > 0 Then<\/span>\r\n DoCmd.OpenForm \"frmOffeneMails\"\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nBeim Laden des Formulars<\/h2>\n
Private Sub <\/span>Form_Load()\r\n SteuerelementeInitialisieren\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>SteuerelementeInitialisieren()\r\n Me!lstOffeneMails = Me!lstOffeneMails.ItemData(0)\r\n Me.Recordset.FindFirst \"MailItemID = \" _\r\n & Me!lstOffeneMails\r\n Me!cboKundeID = Me!cboKundeID.ItemData(0)\r\nEnd Sub<\/span><\/pre>\nNeues Ticket anlegen<\/h2>\n
Private Sub <\/span>lstOffeneMails_AfterUpdate()\r\n Me.Recordset.FindFirst \"MailItemID = \" _\r\n & Me!lstOffeneMails\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtBody_KeyUp(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>strTemp As String<\/span>\r\n If <\/span>Shift = 1 And KeyCode = 16 And Me!txtBody.SelLength > 0 Then<\/span>\r\n strTemp = Mid<\/span>(Me!txtBody, Me!txtBody.SelStart + 1, Me!txtBody.SelLength)\r\n If <\/span>Not<\/span> Len<\/span>(Me!txtInhalt) = 0 Then<\/span>\r\n Me!txtInhalt = Me!txtInhalt & vbCrLf<\/span>\r\n End If<\/span>\r\n Me!txtInhalt = Me!txtInhalt & strTemp\r\n End If<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtBody_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Dim <\/span>strTemp As String<\/span>\r\n strTemp = Mid<\/span>(Me!txtBody, Me!txtBody.SelStart + 1, Me!txtBody.SelLength)\r\n If <\/span>Not<\/span> Len<\/span>(Me!txtInhalt) = 0 Then<\/span>\r\n Me!txtInhalt = Me!txtInhalt & vbCrLf<\/span>\r\n End If<\/span>\r\n Me!txtInhalt = Me!txtInhalt & strTemp\r\nEnd Sub<\/span><\/pre>\nKunde an der E-Mail-Adresse erkennen<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2016_03\/pic_1041_008.png\")
<\/p>\nSELECT 0 AS KundeID, ''<Auswählen>'' AS Kunde FROM tblKunden \r\nUNION SELECT -1 AS KundeID, ''<Neuer Kunde>'' AS Kunde \r\nFROM tblKunden UNION SELECT tblKunden.KundeID, [Nachname] & \", \" & \r\n[Vorname] AS Kunde FROM tblKunden ORDER BY Kunde;<\/pre>\n
Private Sub <\/span>cboKundeID_AfterUpdate()\r\n Dim <\/span>lngKundeID As Long<\/span>\r\n If <\/span>Me!cboKundeID = -1 Then<\/span>\r\n DoCmd.OpenForm \"frmKundeDetail\", DataMode:=acFormAdd, WindowMode:=acDialog, _\r\n OpenArgs:=Me!Absender\r\n If <\/span>IstFormularGeoeffnet(\"frmKundeDetail\") Then<\/span>\r\n lngKundeID = Forms!frmKundeDetail!KundeID\r\n DoCmd.Close acForm, \"frmKundeDetail\"\r\n Me!cboKundeID.Requery\r\n Me!cboKundeID = lngKundeID\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nTicket anlegen<\/h2>\n
Private Sub <\/span>cmdAnlegen_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n If <\/span>Me!cboKundeID > 0 Then<\/span>\r\n If <\/span>Len<\/span>(Nz(Me!txtBezeichnung)) = 0 Then<\/span>\r\n MsgBox<\/span> \"Bitte geben Sie eine Bezeichnung ein.\"\r\n Me!txtBezeichnung.SetFocus\r\n Exit Sub<\/span>\r\n Else<\/span>\r\n If <\/span>