<\/p>\n
André Minhorst, Duisburg<\/b><\/p>\n
Wenn Sie eine Anwendung nicht gerade für sich selbst oder Ihren Schreibtischnachbarn (sofern Sie einen haben) erstellt haben, sondern für örtlich weiter entfernte Personen, wird das Beheben von Fehlern schnell zur Qual: Es besteht dann aus einer Mischung aus Telefonaten und per E-Mail verschickten Screenshots mit Fehlermeldungen – und das auch nur, wenn der jeweilige Anwender ausreichend versiert ist. Zumindest für Laufzeitfehler können Sie hier einiges an Zeit und Mühe einsparen – durch die richtige Automatisierung.<\/b><\/p>\n
Wenn Sie gelegentlich selbst entwickelte Anwendungen verteilen und keine Lust haben, die Fehlermeldungen jeder Kopie der Anwendung separat aufzunehmen und telefonisch oder auf ähnlich zeitraubende Art mit dem Benutzer abzuhandeln, müssen Sie diesen Vorgang so weit wie möglich automatisieren. Damit sparen Sie nicht nur sich selbst, sondern auch dem Benutzer Aufwand und ärger – vor allem wenn dieser einfach nur mit Ihrer Anwendung arbeiten möchte und gar nichts mit dem Erstellen von Screenshots von Fehlermeldungen und ähnlichen Tätigkeiten zu tun haben möchte.<\/p>\n
Das grundlegende Handwerkszeug dazu haben Sie möglicherweise bereits vor der Lektüre dieses Beitrags kennen gelernt: Es steckt in den Beiträgen Mails versenden ohne Outlook (4\/2004), Fehlerdokumentation (5\/2004) und Mail abrufen mit Access und POP3 in der aktuellen Ausgabe von Access im Unternehmen.<\/p>\n
Im vorliegenden Beitrag erfahren Sie, wie Sie das Know-how dieser drei Beiträge verbinden und eine Lösung erstellen, die dem Anwender und dem Entwickler möglichst wenig Aufwand bei der Abhandlung auftretender Fehler bereitet.<\/p>\n
Damit Sie einen Eindruck von der Funktionsweise der Fehlerverwaltung gewinnen, spielen wir einfach ein kleines Beispiel durch. Damit Sie alle nachfolgend beschriebenen Schritte nachvollziehen können, finden Sie auf der beiliegenden CD vier Beispieldatenbanken zu diesem Beitrag: Die eigentliche Fehlerverwaltung verbirgt sich hinter dem Dateinamen FehlerverwaltungXX.mdb und die Anwendung, die den Fehler auslöst, heißt Fehlerverwaltung_ClientXX.mdb (wobei „XX“ durch „97“ für Access 97 und „00“ für Access 2000 und höher ersetzt wird.<\/p>\n
Beginnen wir mit der fehlerhaften Datenbank: Diese enthält ein Formular namens frmBeispielfehler mit der Schaltfläche Fehler erzeugen (siehe Bild 1).<\/p>\n
![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Bild 1: Fehler per Mausklick<\/span><\/b><\/p>\n Quellcode 1<\/b><\/p>\n <\/b><\/p>\n Bild 2: Das Meldungsfenster der Fehlerbehandlung<\/span><\/b><\/p>\n Ein Klick auf diese Schaltfläche bewirkt den Aufruf der folgenden Ereignisprozedur: <\/p>\n Die dort aufgerufene Funktion FehlerhafteFunktion dividiert 1 durch 0 und löst damit einen Fehler aus. Damit hier kein Laufzeitfehler mit einer von Access generierten Fehlermeldung auftritt, fängt die Prozedur den Fehler ab (s. Quellcode 1).<\/p>\n Was dann passiert, schauen wir uns zunächst einmal an und kümmern uns im Anschluss um die dahinter stehenden Techniken.<\/p>\n Nach dem Auslösen des Fehlers durch einen Klick auf die Schaltfläche Fehler erzeugen erscheint das Formular aus Bild 2. Das Formular informiert den Benutzer darüber, dass ein Fehler aufgetreten ist und um welchen Fehler es sich handelt.<\/p>\n Es bietet die Möglichkeit, eine E-Mail an den Hersteller der Software zu senden, und zeigt in einem separaten Fenster alle Informationen an, die mit dieser E-Mail versendet werden.<\/p>\n Der Benutzer der Software kann zusätzlich einen Text mit weiteren Hinweisen zum Auftreten des Fehlers eingeben – beispielsweise mit den Schritten, die zum Fehler führten.<\/p>\n Damit der Hersteller den Kunden, bei dem der Fehler aufgetreten ist, identifizieren kann, muss dieser seine Kundennummer eingeben – schließlich soll er mit einer überarbeiteten Version der Software für sein Verständnis belohnt werden.<\/p>\n Schließlich legt der Benutzer noch fest, ob sich zwischen seinem Rechner und dem Internet eine Firewall befindet, die gegebenenfalls das Versenden der E-Mail über Port 110 verhindern könnte.<\/p>\n Wenn das nicht der Fall ist, muss er nur noch auf die Schaltfläche Fehlermeldung senden klicken, um die entsprechende Mail direkt via SMTP zu versenden.<\/p>\n Sollte eine Firewall im Spiel sein, kann die Mail auch über den Standard-E-Mail-Client des Benutzers versendet werden. Dieser wird von der Anwendung automatisch aufgerufen und mit den entsprechenden Daten gefüllt. Unter Outlook 2003 sieht die zu verschickende E-Mail wie in Bild 3 aus.<\/p>\n <\/b><\/p>\n Bild 3: Fehlerversand per Outlook<\/span><\/b><\/p>\n An diesem Punkt tritt die eigentliche Fehlerverarbeitung in Aktion. Damit ist die Beispieldatenbank FehlerverwaltungXX.mdb gemeint. Mit ihr holt der Entwickler die Fehlermeldungen per POP3 vom Mailserver ab.<\/p>\n <\/b><\/p>\n Bild 4: Das Hauptformular der Fehlerverwaltung<\/span><\/b><\/p>\n Das Formular mit dem Titel Fehlermeldungen ist die Steuerzentrale für die Verwaltung der Fehlermeldungen. Interessant ist dort vor allem die Schaltfläche Fehlermeldungen abrufen (siehe Bild 4).<\/p>\n Mit einem Klick auf diese setzen Sie einen Prozess in Gang, der die auf dem E-Mail-Server vorliegende E-Mail mit der Fehlermeldung herunterlädt und ihren Inhalt in der Datenbank speichert.<\/p>\n Die Fehlermeldungen werden dann in einem Listenfeld angezeigt, von wo der Entwickler die einzelnen Meldungen in der Detailansicht anzeigen kann. Die Detailansicht (siehe Bild 5) bietet die Möglichkeit, einem Fehler eine Priorität zuzuordnen, den Fehler als behoben zu markieren und Informationen zur Fehlerbehebung einzutragen.<\/p>\n <\/b><\/p>\n Bild 5: Detailansicht einer Fehlermeldung<\/span><\/b><\/p>\n Quellcode 2<\/b><\/p>\n Die nachfolgenden Schritte beschreiben, wie Sie den Fehlerverwaltungs-Client in eigene Anwendungen integrieren.<\/p>\n Der erste Schritt besteht im Import der Objekte, die für die Verarbeitung eines Fehlers erforderlich sind. Dazu öffnen Sie die Zieldatenbank (in diesem Fall eine Kopie der Nordwind-Datenbank) und importieren die gewünschten Objekte:<\/p>\n Nachdem das Handwerkszeug beisammen ist, legen Sie eine Fehlerbehandlung an. Für Beispielzwecke nehmen wir uns das Formular Lieferanten vor. Der hinter der Schaltfläche Artikel hinzufügen stehende Code enthält bereits eine rudimentäre Fehlerbehandlung.<\/p>\n <\/p>\n Eine Fehlerbehandlung sollten Sie prinzipiell für alle Prozeduren einer Anwendung anlegen – Fehler treten immerhin meistens dort auf, wo man sie nicht erwartet. Und wenn Sie diese lückenlos erfassen und melden können, bestehen gute Chancen, eine Anwendung mit der Zeit fast vollständig von Fehlern zu befreien. „Fast vollständig“ deshalb, weil man nie alle Fehler ausschließen kann. <\/p>\n Ersetzen Sie diese durch Ihre eigene Fehlerbehandlung und fügen Sie Zeilennummern hinzu.<\/p>\n <\/b><\/p>\n Bild 6: Anlegen von Fehlerbehandlung und Nummerierung per Mausklick<\/span><\/b><\/p>\n Quellcode 3<\/b><\/p>\n Die Prozedur sieht anschließend wie in Quellcode 2 aus.<\/p>\n Am schnellsten fügen Sie einer Prozedur die Fehlerbehandlung und Zeilennummerierung über die Funktionen der Menüleiste VBAExtensions hinzu, die wir im Beitrag Erweitern der VBA-Entwicklungsumgebung in Ausgabe 5\/2004 von Access im Unternehmen vorgestellt haben. Damit kostet Sie der ganze Vorgang genau zwei Mausklicks (siehe Bild 6). Achtung: Verwenden Sie die neue Version der .dll-Datei, die Sie auf der beiliegenden CD finden! <\/p>\n Damit die E-Mails mit den Fehlermeldungen an die gewünschte Adresse gesendet werden, passen Sie einige Zeilen Code an.<\/p>\n Die anzupassenden Anweisungen befinden sich in der Prozedur cmdFehlermeldungSenden des Klassenmoduls des Formulars frmFehlerbehandlung (s. Quellcode 3).<\/p>\n Die Prozedur setzt den Text der E-Mail zusammen, übermittelt die E-Mail-Daten an das SMTP-Objekt und stößt das Versenden der E-Mail an. Dort ersetzen Sie die folgenden Platzhalter durch die entsprechenden Werte (Platzhalter sind im Quellcode fett gesetzt):<\/p>\n Quellcode 4<\/b><\/p>\n Damit die E-Mail mit der Fehlermeldung Informationen über die Anwendung und ihre Version enthält, ändern Sie zwei Zeilen in der Prozedur Fehlerbehandlung im Modul mdlError. Die zu ändernden Zeilen sind in Quellcode 4 fett gedruckt.<\/p>\n Nun müssen Sie nur noch einen Fehler provozieren, um die Funktionalität zu testen. Im Beispielformular Lieferanten können Sie das folgendermaßen tun: Legen Sie einen neuen leeren Datensatz an. Klicken Sie dann auf die Schaltfläche Artikel hinzufügen. Wenn nun die Meldung aus Bild 7 erscheint, haben Sie alles richtig gemacht.<\/p>\n <\/b><\/p>\n Bild 7: Fehlermeldung in der Nordwinddatenbank<\/span><\/b><\/p>\n Die Fehlerverwaltung enthält neben den eingangs beschriebenen noch einige weitere Funktionen.<\/p>\n Bevor Sie die Fehlerverwaltung verwenden können, müssen Sie noch die Daten des E-Mail-Kontos anpassen, von dem die E-Mails mit den Fehlermeldungen abgeholt werden sollen.<\/p>\n <\/b><\/p>\n Bild 8: Anpassen der E-Mail-Einstellungen<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 9: Sortieren nach verschiedenen Kriterien<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 10: Leeres Formular zur manuellen Eingabe von Fehlern<\/span><\/b><\/p>\n Dazu öffnen Sie einfach die Datenbank FehlerverwaltungXX.mdb und klicken im Dialog Fehlermeldungen auf die Schaltfläche E-Mail-Einstellungen.<\/p>\n Dort können Sie mehrere Konten anlegen, für die Sie jeweils den Benutzernamen, das Kennwort und den POP3-Server angeben. Für das aktuell zu verwendende Konto setzen Sie ein Häkchen in das Kontrollkästchen Standard (siehe Bild 8).<\/p>\n Die Liste der Fehlermeldungen im Dialog Fehlermeldungen kann nach drei beliebig zu kombinierenden Kriterien auf- oder absteigend sortiert werden. Dabei dienen drei Kombinationsfelder zur Auswahl der Kriterien und drei entsprechende Optionsgruppen zum Festlegen der Sortierreihenfolge (siehe Bild 9).<\/p>\n Wenn doch mal ein Fehler durch das feine Netz von Fehlerbehandlungsroutinen schlüpft, weil es sich beispielsweise nicht um einen Laufzeitfehler, sondern etwa um einen logischen Fehler handelt, können Sie diesen manuell eingeben. Mit einem Mausklick auf die Schaltfläche Neu öffnen Sie ein leeres Formular zur Eingabe der Fehlerinformationen (siehe Bild 10).<\/p>\n Das Formular zur Bearbeitung der Detailansicht eines Fehlers enthält zwei unscheinbare Schaltflächen, die weitere Dialoge öffnen. Der erste befindet sich neben dem Textfeld zur Eingabe der Anwendung und öffnet den Dialog Anwendungen (siehe Bild 11).<\/p>\n <\/b><\/p>\n Bild 11: Auswahl der Anwendung mit Schaltfläche für die Detailansicht<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 12: Verwalten von Anwendungen<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 13: Anwendungsnamen mit Versionsangabe<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 14: Formular zum Verwalten von Kunden<\/span><\/b><\/p>\n Der Dialog zeigt den Namen der ausgewählten Anwendung an und bietet die Möglichkeit, zu der aktuellen Anwendung unterschiedliche Versionsstände einzugeben (siehe Bild 12). Diese erscheinen in der übersichtsliste der Fehlermeldungen in Kombination mit dem Anwendungsnamen (siehe Bild 13).<\/p>\n Das Formular zur Verwaltung von Kunden (siehe Bild 14) öffnen Sie ebenfalls vom Dialog Fehlermeldungen Detailansicht aus. Dieses Formular wie auch die Verwaltung der Kunden selbst ist recht einfach gehalten.<\/p>\n Wenn einer der Fehler in der Liste behoben wurde, können Sie das der Anwendung in der Detailansicht des jeweiligen Fehlers durch Betätigen der Schaltfläche Fehler behoben mitteilen. Wenn das Textfeld mit der Bezeichnung Fehlerbehebung bis dahin noch keinen Inhalt hat, fordert die Anwendung Sie dazu auf, einen entsprechenden Text einzugeben.<\/p>\n Die Erläuterung der Funktionen der Fehlerbehandlung und ihrer Integration in eigene Anwendungen schien dem Autor wichtiger als die dahinter stehende Technik; außerdem werden die meisten hier verwendeten Prozeduren in den drei in Kapitel 1 genannten Beiträgen erläutert.<\/p>\n Daher beschränken wir uns an dieser Stelle auf einige wenige technische Hintergründe.<\/p>\n Die Haupttabelle der Anwendung namens tblFehlermeldungen enthält die Detailinformationen zu den Fehlermeldungen. Alle anderen sind mehr oder weniger direkt mit dieser Tabelle verknüpft (siehe Bild 15).<\/p>\n Die beiden Tabellen tblKunden und tblPrioritaeten haben jeweils eine 1:n-Beziehung mit der Tabelle tblFehlermeldungen. <\/p>\n Die Tabelle tblAnwendungen ist über die Tabelle tblVersionen mit der Tabelle tblFehlermeldungen verknüpft. Die Tabelle tblVersionen ist dabei die Verknüpfungstabelle in einer m:n-Beziehung.<\/p>\n <\/b><\/p>\n Bild 15: Datenmodell der Fehlerverwaltung<\/span><\/b><\/p>\n Quellcode 5<\/b><\/p>\n Auf diese Weise kann die Fehlerverwaltung mehrere Versionen einer Anwendung enthalten.<\/p>\n Der Fehlerverwaltungs-Client ist die Anwendung, die Fehlermeldungen verschickt. Technisch interessant ist die Verwendung der Klasse clsSMTP, die ja bereits im Beitrag Mails versenden ohne Outlook in Ausgabe 4\/2004 von Access im Unternehmen vorgestellt wurde.<\/p>\n Der Aufruf erfolgt in der Ereignisprozedur, die durch einen Klick auf die Schaltfläche Fehlermeldung senden des Formulars Fehlerbehandlung ausgelöst wird (s. Quellcode 3).<\/p>\n Die Prozedur überprüft zunächst, ob das Textfeld zur Angabe der Kundennummer einen numerischen Wert enthält (im Quellcode aus Platzgründen ausgespart). Ist das nicht der Fall, fordert die Prozedur den Anwender zur Eingabe einer Kundennummer auf.<\/p>\n Anderenfalls fährt die Prozedur fort und setzt aus dem Inhalt des großen Textfelds mit den Fehlerinformationen, des Textfelds mit der manuellen Fehlerbeschreibung des Kunden und des Textfelds mit der Kundennummer den Text der E-Mail zusammen.<\/p>\n Dann erfolgt die überprüfung, ob der Benutzer die Option Firewall lässt Zugriff auf Port 110 (SMTP) zu aktiviert hat oder nicht. Sollte ein Unternehmen eine Firewall installiert haben, die den Port 100 sperrt, kann die Fehlermeldung nicht direkt von der Access-Anwendung aus per SMTP versendet werden. Statt dessen verwendet die Anwendung den Standard-E-Mail-Client auf dem aktuellen Rechner. Ist Port 110 frei, instanziiert die Prozedur ein Objekt der Klasse clsSMTP. Anschließend übergibt sie die für den Mailversand benötigten Werte an die entsprechenden Eigenschaften des SMTP-Objekts und ruft schließlich dessen Methode Send auf.<\/p>\n Ist der direkte Versand via SMTP nicht möglich, setzt die Prozedur über die API-Funktion ShellExecute eine mailto:-Anweisung ab und übergibt dabei direkt die entsprechenden Werte für die Parameter Subject und Body.<\/p>\n Quellcode 6<\/b><\/p>\n Quellcode 7<\/b><\/p>\n Auf Seiten der Fehlerverwaltung sorgt die Funktion ExtractMessage für das Lesen der Detailinformationen aus der Mail (s. Quellcode 5).<\/p>\n Die Funktion liest die Informationen zu der Fehlermeldung aus der Mail aus. Dazu durchsucht sie den Inhalt der Mail nach den entsprechenden Schlüsselwörtern wie From, To oder Date für die E-Mail-relevanten Informationen und Schlüsselwörter wie Modul, Routine, Fehlernummer, Zeile und so weiter für die fehlerspezifischen Informationen. Dieser Suchvorgang erfolgt in einer eigenen Funktion, die für jede Eigenschaft der Fehlermeldung einmal mit dem jeweiligen Schlüsselwort als Argument aufgerufen wird.<\/p>\n Diese Funktion heißt GetHeader und ermittelt nach dem Finden des jeweiligen Schlüsselworts den dahinter angegebenen Ausdruck bis zum nächsten Semikolon (;).<\/p>\n Eventuell enthaltene Zeilenumbrüche ersetzt die Funktion durch Leerzeichen und gibt dann den gefundenen Wert für das Schlüsselwort an die aufrufende Funktion zurück (s. Quellcode 6).<\/p>\n Die Funktion GetMailDate ermittelt aus dem Sendedatum einer Mail, das in einem besonderen Format vorliegt, ein von Access lesbares Datumsformat (s. Quellcode 7).<\/p>\n Die hier vorgestellte Fehlerverwaltung bietet die grundlegenden Techniken zum „Einsammeln“ von Fehlermeldungen, die von möglicherweise weit entfernt eingesetzten Anwendungen stammen. Damit sparen Sie sowohl dem Benutzer als auch sich selbst aufwändige Kommunikation. Zudem liegen so alle Fehlermeldungen an einem Ort vor und Sie können diese nach Priorität oder Eingangsdatum abarbeiten.<\/p>\n Wie so viele Musterlösungen bietet auch diese eine Menge Erweiterungsmöglichkeiten:<\/p>\n Wenn Sie eine Anwendung nicht gerade für sich selbst oder Ihren Schreibtischnachbarn (sofern Sie einen haben) erstellt haben, sondern für örtlich weiter entfernte Personen, wird das Beheben von Feh-lern schnell zur Qual: Es besteht dann aus einer Mischung aus Telefonaten und per E-Mail verschickten Screenshots mit Fehlermeldungen – und das auch nur, wenn der jeweilige Anwender ausreichend versiert ist. Zumindest für Laufzeitfehler können Sie hier einiges an Zeit und Mühe einsparen – durch die richtige Automatisierung.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662004,66062004,44000028,44000025],"tags":[],"class_list":["post-55000244","post","type-post","status-publish","format-standard","hentry","category-662004","category-66062004","category-Ergonomie_und_Benutzeroberflaeche","category-VBA_und_Programmiertechniken"],"yoast_head":"\nPublic Function FehlerhafteFunktion() As Long\r\n On Error GoTo FehlerhafteFunktion_Err\r\n FehlerhafteFunktion = 1 \/ 0\r\n ''Fehlerbehandlung\r\nFehlerhafteFunktion_Exit:\r\n ''Restarbeiten\r\n Exit Function\r\nFehlerhafteFunktion_Err:\r\n Call Fehlerbehandlung(\"mdlBeispielfehler \", _ \"FehlerhafteFunktion\", Erl, \"Bemerkungen: .\/.\")\r\n GoTo FehlerhafteFunktion_Exit\r\nEnd Function<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic002.png\")
<\/p>\nPrivate Sub cmdFehlerErzeugen_Click()\r\n FehlerhafteFunktion\r\nEnd Sub<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic003.png\")
<\/p>\nVerarbeitung der Fehlermeldung<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic004.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic005.png\")
<\/p>\nPrivate Sub ArtikelHinzufügen_Click()\r\n50 On Error GoTo ArtikelHinzufügen_Click_Err\r\n60 Dim strDocName As String\r\n70 strDocName = \"Artikel\"\r\n80 DoCmd.OpenForm strDocName, , , , acAdd, , _ Me!LieferantenNr\r\n90 DoCmd.Close acForm, \"Artikelliste\"\r\n100 Forms![Artikel]!Artikelname.SetFocus\r\n110 ''Fehlerbehandlung\r\n120 ArtikelHinzufügen_Click_Exit:\r\n130 ''Restarbeiten\r\n140 Exit Sub\r\n150 ArtikelHinzufügen_Click_Err:\r\n160 Call Fehlerbehandlung(\"Form_Lieferanten \", _ \"ArtikelHinzufügen_Click\", Erl, _ \"Bemerkungen: .\/.\")\r\n170 GoTo ArtikelHinzufügen_Click_Exit\r\nEnd Sub<\/pre>\n
Import der benötigten Objekte<\/h2>\n
Einbau der Fehlerbehandlung<\/h2>\n
Praxis-Tipp<\/h3>\n
![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic006.png\")
<\/p>\nPrivate Sub cmdFehlermeldungSenden_Click()\r\n Dim objSMTP As clsSMTP\r\n Dim strFehlermeldung As String\r\n ''Validierung aus Platzgründen ausgespart\r\n strFehlermeldung = Me!txtMailtext\r\n strFehlermeldung = strFehlermeldung & _ \"KundenBeschreibung: \" & Me!txtBeschreibung _ & \";\" & vbCrLf\r\n strFehlermeldung = strFehlermeldung _ & \"Kundennummer: \" & Me!txtKundennummer & \";\"\r\n If Me.ctlFirewall = True Then\r\n Set objSMTP = New clsSMTP\r\n With objSMTP\r\n .MailFrom = \"<E-Mail Absender>\"\r\n .MailTo = \"<E-Mail Empfänger>\"\r\n .Port = 25\r\n .SenderEMail = \"<E-Mail Absender>\"\r\n .Sendername = \"<Name Absender>\"\r\n .SMTPServer = \"<SMTP-Server>\"\r\n .Subject = \"Fehlermeldung\"\r\n .Plaintext = strFehlermeldung\r\n .Send\r\n End With\r\n Else\r\n Call ShellExecute(0&, \"Open\", \"mailto:\" _ + \"<E-Mail Empfänger>\" + \"Subject=\" + _ \"Fehlermeldung\" + \"&Body=\" + _ Replace(strFehlermeldung, vbCrLf, _ \"%0a%0d\"), \"\", \"\", 1)\r\n End If\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/pre>\n
Praxis-Tipp<\/h3>\n
E-Mail-Daten anpassen<\/h2>\n
Public Sub Fehlerbehandlung(strModul As String, strRoutine As String, _ lngZeile As Long, Optional strBemerkungen As String)\r\n Dim strBeschreibung As String\r\n Dim strFehler As String\r\n Dim strInfo As String\r\n Dim strAnwendungsname As String\r\n Dim strVersion As String\r\n strFehler = Err.Description\r\n strAnwendungsname = \"<Anwendungsname>\"\r\n strVersion = \"<Anwendungsversion>\"\r\n strInfo = strInfo & \"Anwendung: \" & strAnwendungsname & \";\" & vbCrLf\r\n strInfo = strInfo & \"Version: \" & strVersion & \";\" & vbCrLf\r\n strInfo = strInfo & \"Datum: \" & Now & \";\" & vbCrLf\r\n strInfo = strInfo & \"Datenbankpfad: \" & CurrentDb.Name & \";\" & vbCrLf\r\n strInfo = strInfo & \"Modul: \" & strModul & \";\" & vbCrLf\r\n strInfo = strInfo & \"Routine: \" & strRoutine & \";\" & vbCrLf\r\n strInfo = strInfo & \"Benutzer: \" & CurrentUser() & \";\" & vbCrLf\r\n strInfo = strInfo & \"Fehlernummer: \" & Err.Number & \";\" & vbCrLf\r\n strInfo = strInfo & \"Fehlerbeschreibung: \" & Err.Description & \";\" & vbCrLf\r\n strInfo = strInfo & \"Zeile: \" & lngZeile & \";\" & vbCrLf\r\n strInfo = strInfo & \"Bemerkungen: \" & strBemerkungen & \";\" & vbCrLf\r\n DoCmd.OpenForm \"frmFehlerbehandlung\", WindowMode:=acDialog, OpenArgs:=strInfo\r\nEnd Sub<\/pre>\n
Anwendungsdaten anpassen<\/h2>\n
Anstoßen der Fehlerbehandlung<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic007.png\")
<\/p>\nEinstellen des POP3-Servers<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic008.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic009.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic010.png\")
<\/p>\nSortieren der Fehlermeldungen<\/h2>\n
Manuelles Anlegen von Fehlermeldungen<\/h2>\n
Anwendungen verwalten<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic011.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic012.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic013.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic014.png\")
<\/p>\nKunden verwalten<\/h2>\n
Fehler behoben<\/h2>\n
Datenmodell<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{CF3DC94F-DCA5-4D7B-8991-60B5B5AC878C}\/pic015.png\")
<\/p>\nPublic Function ExtractMessage() As Boolean\r\n On Error GoTo ExtractMessage_Err\r\n Dim intPosStart As Integer\r\n Dim intPosEnd As Integer\r\n If Len(mMessage) = 0 Then\r\n ExtractMessage = False\r\n Exit Function\r\n End If\r\n mMessageFrom = GetHeader(\"From:\")\r\n '' Weitere Werte ermitteln für To, Subject, ...\r\n mDateSent = CDate(GetMaildate(GetHeader(\"Date:\")))\r\n mDateReceived = Now\r\n ExtractMessage = True\r\nExtractMessage_Exit:\r\n Exit Function\r\nExtractMessage_Err:\r\n ExtractMessage = False\r\n Call Fehlerbehandlung(\"clsMessage \", \"ExtractMessage\", Erl, \"Bemerkungen: .\/.\")\r\n GoTo ExtractMessage_Exit\r\nEnd Function<\/pre>\n
Details zum Fehlerverwaltungs-Client<\/h2>\n
Private Function GetHeader(strHeader As String)\r\n Dim intPosStart As Integer\r\n Dim intPosEnd As Integer\r\n Dim intLenHeader As Integer\r\n Dim intPosInit As Integer\r\n Dim strEnd As String\r\n Dim i As Integer\r\n intLenHeader = Len(strHeader) + 1\r\n intPosInit = 1\r\n strEnd = \";\"\r\n intPosStart = InStr(intPosInit, mMessage, strHeader)\r\n intPosEnd = InStr(intPosStart + 1, mMessage, strEnd)\r\n GetHeader = Trim(Replace(Mid(mMessage, intPosStart _ + intLenHeader, intPosEnd - intPosStart - _ intLenHeader), Chr(10), \" \"))\r\nEnd Function<\/pre>\n
Private Function GetMaildate(strMaildate As String) _ As Date\r\n Dim Part() As String\r\n Const Months = _ \"JanFebMarAprMayJunJulAugSepOctNovDec\"\r\n Part = Split(strMaildate, \" \")\r\n GetMaildate = DateSerial(Part(3), 1 + (InStr(Months, _ Part(2)) - 1) \\ 3, Part(1)) + CDate(Part(4))\r\nEnd Function<\/pre>\n
Details zur Fehlerverwaltung<\/h2>\n