<\/p>\n
Viele Access-Benutzer dürften, wenn Sie schon das Office-Paket auf dem Rechner haben, auch Outlook nutzen – zumindest, um E-Mails zum empfangen, zu senden und zu bearbeiten. Vielen fehlt dabei die Möglichkeit einer stärkeren Interaktion zwischen Access und Outlook, beispielsweise bei Verwendung einer Kundenverwaltung. Eine pfiffige Möglichkeit wäre es, beim Anzeigen einer E-Mail von einem bestimmten Kunden direkt den Kundendatensatz in der Kundenverwaltung zu öffnen. Dies sollte dann auch noch auf möglichst einfache Art und Weise geschehen, beispielsweise per Tastenkombination. Wie das gelingt, zeigt der vorliegende Beitrag.<\/b><\/p>\n
In einem anderen Beitrag mit dem Titel Outlook-Mails per Tastenkombination verschieben <\/b>(www.access-im-unternehmen.de\/1290<\/b>) haben wir bereits gezeigt, wie Sie Aktionen für die aktuell markierte E-Mail per Tastenkombination ausführen können. <\/p>\n
Im vorliegenden Beitrag wollen wir die Verbindung zwischen der dort beschriebenen reinen Outlook-Technik und Access herstellen. Dazu wollen wir, wenn der Benutzer eine bestimmte Tastenkombination für die aktuell angezeigte E-Mail betätigt, die folgenden Schritte ausführen:<\/p>\n
Ob die Kunden-Datenbank bereits geöffnet ist oder nicht bringt noch eine wichtige Unterscheidung mit sich: Wenn sie noch nicht geöffnet ist, haben wir es etwas einfacher. Wir brauchen die Datenbank dann nämlich einfach nur zu öffnen, was relativ einfach ist, und dabei die entsprechende E-Mail-Adresse zu übergeben. Wenn die Access-Anwendung bereits geöffnet ist, wird es etwas komplizierter, denn dann müssen wir per VBA zunächst die Access-Anwendung referenzieren und diese dann so fernsteuern, dass sie den gewünschten Kunden anzeigt.<\/p>\n
Wir wollen jedoch mit dem Aufruf beginnen.<\/p>\n
Die Grundlagen zu diesem Schritt haben wir ausführlich in dem eingangs erwähnten Beitrag beschrieben. Dabei haben wir eine VBA-Prozedur erstellt, welche die aktuelle E-Mail ermittelt und dann etwas damit erledigt.<\/p>\n
Einige der dort verwendeten Techniken übernehmen wir für die nachfolgend vorgestellte Prozedur namens ShowCustomerInAccess<\/b>, die Sie in Listing 1 finden (die nachfolgend beschriebenen Routinen geben Sie in einem neuen Standardmodul des VBA-Projekts von Outlook ein, das Sie von Outlook aus mit der Tastenkombination Alt + F11 <\/b>öffnen). Diese Prozedur schreibt den Pfad zur Kundenverwaltungs-Datenbank in die Variable strDatabase <\/b>und referenziert den aktuell im Outlook-Explorer-Bereich angezeigten Ordner mit der Variablen objCurrentFolder<\/b>.<\/p>\n Listing 1: Prozedur zum Anzeigen eines Kunden in Access<\/span><\/b><\/p>\n Heißt dieser Ordner Posteingang<\/b>, wird der Rest der Prozedur ausgeführt. Wenn Sie nicht die deutschsprachige Outlook-Version verwenden, heißt der Ordner möglicherweise anders, in diesem Fall müssen Sie den Code entsprechend anpassen. Die Prozedur erfasst mit der Variablen objSelection <\/b>die aktuelle Auswahl in diesem Ordner. Wenn die mit Count <\/b>ermittelte Anzahl der markierten Elemente nicht 1 <\/b>lautet, erscheint eine entsprechende Meldung und die Prozedur wird beendet.<\/p>\n Anderenfalls prüft die Prozedur, ob es sich um ein Element des Typs MailItem <\/b>handelt. Ist das der Fall, weist die Prozedur das markierte Objekt der Variablen objMailItem <\/b>zu. Danach liest es die E-Mail-Adresse des Absenders aus der Eigenschaft SenderEmailAddress <\/b>aus und schreibt sie in die Variable strMail<\/b>.<\/p>\n Anschließend versucht die Prozedur, mit der Funktion GetDatabase <\/b>auf eine laufende Instanz der Datenbank aus strDatabase <\/b>zugreifen. Liefert diese kein Objekt zurück, bleibt objAccess <\/b>leer. Die Prozedur durchläuft dann den If<\/b>-Teil der Bedingung.<\/p>\n Hier erstellt sie mit OpenDatabase <\/b>einen Verweis auf das Database<\/b>-Objekt der Datenbank und referenziert dieses mit der Variablen db<\/b>. Damit ruft sie die Funktion CustomerExists <\/b>auf, die prüft, ob die Datenbank einen Kunden mit der angegebenen E-Mail-Adresse enthält. Falls ja, ruft die Prozedur eine weitere Routine namens OpenDatabaseInAccess <\/b>auf, welche die Kundenverwaltung öffnen und die E-Mail-Adresse des gesuchten Kunden als Parameter übergeben soll.<\/p>\n Liefert CustomerExists <\/b>den Wert False <\/b>zurück, zeigt die Prozedur eine Meldung an, dass kein Kunde mit der angegebenen E-Mail-Adresse gefunden werden konnte.<\/p>\n Es gibt noch den Fall, dass die Funktion GetDatabase <\/b>einen Verweis auf eine Access-Anwendung zurückgeliefert hat. Diese wird im Else<\/b>-Zweig der entsprechenden Bedingung behandelt. Dieser Teil ruft die Prozedur ShowCustomer <\/b>auf und übergibt dieser einen Verweis auf die gefundene Access-Instanz und die E-Mail-Adresse des gesuchten Kunden.<\/p>\n Die hier aufgerufenen Funktionen und Prozeduren beschreiben wir in den folgenden Abschnitten.<\/p>\n Die erste Funktion, die wir benötigen, heißt GetDatabase<\/b>. Sie erwartet den Pfad der zu holenden Datenbank als Parameter und liefert eine Objektvariable des Typs Access.Application <\/b>zurück (siehe Listing 2).<\/p>\n Listing 2: Funktion zum Holen eines Access.Application-Objekts<\/span><\/b><\/p>\n Die Funktion ruft eine weitere Funktion namens IsDatabaseOpen <\/b>auf, der ebenfalls der Pfad zu der betroffenen Datenbank übergeben wird. Diese Funktion, die wir im Anschluss beschreiben, prüft, ob die mit strDatabase <\/b>angegebene Datenbank geöffnet ist. Ist das der Fall, verwendet die Funktoin GetDatabase <\/b>die VBA-Funktion GetObject <\/b>mit Angabe des Datenbankpfades, um einen Verweis auf das entsprechende Access.Application<\/b>-Objekt zu holen. Der Inhalt der Variablen objAccess <\/b>wird dann als Funktionswert der Funktion GetDatabase <\/b>an die aufrufende Funktion zurückgegeben. Dabei kann objAccess <\/b>an dieser Stelle auch leer sein, also den Wert Nothing <\/b>enthalten.<\/p>\n <\/p>\n Die Funktion IsDatabaseOpen <\/b>erwartet mit dem Parameter strPath <\/b>die Angabe der zu untersuchenden Datenbankdatei (siehe Listing 3). Der Ansatz ist, die beim Öffnen einer Datenbankdatei von Access erstellte Datei mit der Endung .laccdb <\/b>zu untersuchen. Diese wird immer im gleichen Verzeichnis wie die .accdb<\/b>-Datei erstellt. Außerdem ist diese Datei, wenn die Datenbank noch geöffnet ist, schreibgeschützt und kann nicht gelöscht werden. Manchmal kommt es vor, dass die Access-Datenbank geschlossen wird und die .laccdb<\/b>-Datei noch vorhanden ist. Dann kann diese aber problemlos gelöscht werden, was wir in der Funktion ausnutzen.<\/p>\n Listing 3: Funktion zum Prüfen, ob eine Datenbank geöffnet ist<\/span><\/b><\/p>\n Die Prozedur ermittelt zunächst den Pfad zu der gegebenenfalls vorhandenen .laccdb<\/b>-Datei, indem es für den mit strPath <\/b>angegebenen Pfad die Zeichenkette .accdb <\/b>durch .laccdb <\/b>ersetzt.<\/p>\n Dann prüft die Prozedur, ob die Dir<\/b>-Funktion für den Pfad zur .laccdb<\/b>-Datei eine Zeichenkette mit einer Länge von mehr als 0 Zeichen zurückliefert. Dir <\/b>liefert, soweit vorhanden, den Dateinamen. Wenn die .laccdb<\/b>-Datei vorhanden ist, liefert Dir <\/b>für den Pfad zu dieser Datei eine Zeichenkette mit mehr als 0 Zeichen.<\/p>\n Ist die .laccdb<\/b>-Datei vorhanden, müssen wir nun noch prüfen, ob es sich dabei um ein Überbleibsel einer zuvor geöffneten Datenbank handelt oder um eine aktive .laccdb<\/b>-Datei. Eine aktive .laccdb<\/b>-Datei kann nicht gelöscht werden, also versuchen wir, diese zu löschen. Da das Löschen mit der Kill<\/b>-Anweisung einen Fehler auslöst, wenn die Datei nicht gelöscht werden kann, deaktivieren wir die eingebaute Fehlerbehandlung zuvor mit der Anweisung On Error Resume Next<\/b>. Nach dem Aufruf der Kill<\/b>-Anweisung prüfen wir, ob dadurch ein Fehler ausgelöst wurde. In diesem Fall liefert Err.Number <\/b>einen Wert ungleich 0<\/b>. Das bedeutet: Wenn die Datenbank geöffnet ist, kann die .laccdb<\/b>-Datei nicht gelöscht werden und Err.Number <\/b>ist ungleich 0<\/b>. In diesem Fall stellt die Funktion den Wert der Variablen bolIsDatabaseOpen <\/b>auf True <\/b>ein.<\/p>\n Nach dieser Prüfung gibt die Funktion den Wert aus bolIsDatabaseOpen <\/b>als Funktionswert zurück.<\/p>\n Die Funktion CustomerExists <\/b>erwartet einen Verweis auf das Database<\/b>-Objekt der Kundendatenbank sowie die Angabe der zu untersuchenden E-Mail-Adresse als Parameter. Sie liefert einen Boolean<\/b>-Wert zurück, der angibt, ob ein Kunde mit der angegebenen E-Mail-Adresse gefunden werden konnte (siehe Listing 4).<\/p>\n Listing 4: Funktion zum Prüfen, ob ein Kunde mit der angegebenen E-Mail-Adresse existiert<\/span><\/b><\/p>\n Die Funktion erstellt ein Recordset<\/b>-Objekt auf Basis einer SELECT<\/b>-Abfrage, die alle Kunden abfragt, deren Feld EMail <\/b>mit dem Wert des Parameters strEMail <\/b>übereinstimmt. Danach prüft sie, ob das Recordset nicht leer ist. In diesem Fall gibt die Funktion den Wert True <\/b>zurück.<\/p>\n Wenn der Kunde mit der angegebenen E-Mail-Adresse gefunden werden konnte und die Datenbank-Anwendung noch nicht geöffnet ist, wollen wir die Datenbank öffnen und den gewünschten Kundendatensatz in einem Formular namens frmKunden <\/b>anzeigen.<\/p>\n Die dazu aufgerufene Prozedur heißt OpenDatabaseInAccess<\/b>. Sie erwartet den Pfad zu der zu öffnenden Datenbank sowie die E-Mail-Adresse des anzuzeigenden Kunden als Parameter (siehe Listing 5).<\/p>\n Listing 5: Prozedur zum Öffnen einer Access-Instanz mit der Kundendatenbank<\/span><\/b><\/p>\n Die Prozedur verwendet die Shell<\/b>-Funktion, um den Aufruf von Access per Kommandozeilen-Befehl durchzuführen. Die Shell<\/b>-Funktion erwartet als ersten Parameter den auszuführenden Befehl und als zweiten die Angabe, wie das zu öffnende Fenster anzuzeigen ist.<\/p>\n Der auszuführende Befehl setzt sich aus drei Bestandteilen zusammen:<\/p>\n Der Befehl öffnet eine Access-Instanz mit der angegebenen Datenbank und übergibt die E-Mail-Adresse mit dem Parameter \/cmd<\/b>.<\/p>\n Unsere Kundendatenbank müssen wir noch vorbereiten, damit diese nach diesem Aufruf und der Übergabe der E-Mail-Adresse als Command<\/b>-Parameter den gewünschten Kunden anzeigt. Die Datenbank haben wir so einfach wie möglich gehalten. Sie enthält eine Tabelle namens tblKunden <\/b>sowie ein Formular namens frmKunden<\/b>. Die Magie jedoch verbirgt sich in einem AutoExec<\/b>-Makro sowie in der dadurch aufgerufenen VBA-Funktion.<\/p>\n Das AutoExec<\/b>-Makro sieht wie in Bild 1 aus. Es enthält lediglich eine Makroaktion, nämlich AusführenCode. Der Funktionsname lautet =Start()<\/b>.<\/p>\n Bild 1: Das AutoExec-Makro der Kundenverwaltung<\/span><\/b><\/p>\n Diese Funktion programmieren wir wie in Listing 6. Die Funktion Command <\/b>liefert die Zeichenkette, die beim Aufruf von Access mit dem Parameter \/cmd <\/b>übergeben wurde. In der If…Then<\/b>-Bedingung prüft die Funktion, ob Command <\/b>eine Zeichenkette mit einer Länge größer als 0 <\/b>enthält. Falls ja, schreibt sie den Inhalt in die Variable strMail<\/b>. Diese Variable wird in der folgenden DoCmd.OpenForm<\/b>-Methode als Vergleichswert des für den Parameter WhereCondition <\/b>übergebenen Ausdrucks verwendet.<\/p>\n Listing 6: Funktion zum Öffnen des Kunden-Formulars für die übergebene E-Mail-Adresse<\/span><\/b><\/p>\n Das Formular frmKunden <\/b>sollte damit so geöffnet werden, dass es nur Datensätze anzeigt, deren Wert im Feld EMail <\/b>den mit dem \/cmd<\/b>-Parameter übergebenen Wert entspricht.<\/p>\n Die so geöffnete Access-Anwendung lädt also direkt die gewünschte Datenbank und öffnet das Formular frmKunden für den Kunden, der die Absenderadresse aus der aktuell in Outlook selektierten E-Mail enthält.<\/p>\n Sollte die Prozedur ShowCustomer-In-Access <\/b>von weiter oben eine Access-Instanz mit der Kundendatenbank gefunden haben und die dortige Variable objAccess <\/b>nicht leer sein, wird im Else<\/b>-Zweig der entsprechenden Bedingung die Prozedur ShowCustomer <\/b>aufgerufen. Diese erwartet als Parameter die Objektvariable objAccess <\/b>mit einem Verweis auf die gefundene Access-Instanz sowie die E-Mail-Adresse des zu öffnenden Kunden aus der E-Mail (siehe Listing 7).<\/p>\n Listing 7: Funktion zum Anzeigen eines Kunden in einer bereits geöffneten Kunden-Datenbank<\/span><\/b><\/p>\n Die Prozedur nutzt die Eigenschaft hWndAccessApp <\/b>der Access-Instanz aus objAccess<\/b>, um das Fenster-Handle auf die Access-Instanz zu bestimmen und in der Variablen lngHwnd <\/b>zu speichern. Dann referenziert es das mit CurrentDb <\/b>ermittelte Database<\/b>-Objekt dieser Datenbank mit der Variablen db<\/b>. Die weiter oben bereits beschriebene Funktion CustomerExists <\/b>kommt hier zu einem weiteren Aufruf. Wir prüfen also zunächst, ob die Datenbank überhaupt einen Kunden enthält, für den die angegebene E-Mail-Adresse hinterlegt wurde.<\/p>\n Liegt ein entsprechender Kunde vor, schließen wir zur Sicherheit das eventuell noch geöffnete Formular frmKunden. Da dies einen Fehler auslöst, wenn das Formular gar nicht geöffnet ist, deaktivieren wir die eingebaute Fehlerbehandlung zuvor mit On Error Resume Next <\/b>und aktivieren diese anschließend wieder mit On Error Goto 0<\/b>.<\/p>\n Danach öffnen wir das Kunden-Formular mit der DoCmd.OpenForm<\/b>-Methode und übergeben den Namen des zu öffnenden Formulars sowie eine Bedingung für den Parameter WhereCondition<\/b>. Diese Bedingung soll alle Datensätze liefern, deren Feld EMail <\/b>die mit strEMail <\/b>gelieferte E-Mail-Adresse enthält.<\/p>\n Schließlich holen wir das bereits geöffnete Access-Fenster noch mit der API-Funktion SetForegroundWindow <\/b>nach vorn. Dazu übergeben wir diesem das Fenster-Handle aus lngHwnd<\/b>, das wir zuvor ermittelt haben. Dies ist nötig, da wir die Aktion ja von Outlook aus initiieren und das Access-Fenster gegebenenfalls zu diesem Zeitpunkt hinter einem oder mehreren Fenstern versteckt sein könnte.<\/p>\n Die API-Funktion SetForegroundWindow <\/b>deklarieren wir oben in dem Standardmodul des Outlook-VBA-Projekts, in dem sich auch die übrigen hier vorgestellten Prozeduren und Funktionen befinden:<\/p>\n Bleibt noch die Möglichkeit, dass kein passender Datensatz in der Tabelle tblKunden <\/b>gefunden wurde.<\/p>\n In diesem Fall gibt auch diese Prozedur eine Meldung mit den Hinweis aus, dass kein Kunde mit der gesuchten E-Mail-Adresse existiert.<\/p>\n Im Beitrag Outlook-Mails per Tastenkombination verschieben <\/b>(www.access-im-unternehmen.de\/1290<\/b>) haben wir bereits ausführlich erläutert, wie Sie VBA-Prozeduren per Tastenkombination auswählen können – daher hier nur die gekürzte Fassung, um den Aufruf der Kundendatenbank für den Kunden der aktuellen E-Mail zu realisieren.<\/p>\n Dazu fügen Sie der Quick Access Toolbar des Ribbons ein neues Element hinzu:<\/p>\n Wie kommen Sie nun zu der Tastenkombination Wie diese lautet, richtet sich nach der Position der neuen Schaltfläche in der Quick Access Toolbar. Wenn sich diese beispielsweise an der dritten Position befindet, können Sie die Tastenkombination Alt + 3 <\/b>verwenden, um den Befehl aufzurufen.<\/p>\n Wenn gerade eine E-Mail markiert ist, sollte dies nun den passenden Kundendatensatz in der Kundenverwaltung anzeigen. Diese wird dazu entweder geöffnet (wenn Sie geschlossen ist) oder eine vorhandene Instanz wird zur Anzeige der Kundendaten genutzt.<\/p>\n Die hier vorgestellte Lösung bietet eine extreme Vereinfachung zur Anzeige eines Kunden in der Datenbank, der Ihnen eine E-Mail geschrieben hat. Sie brauchen einfach nur die E-Mail zu markieren und eine Tastenkombination wie Alt + 3 <\/b>zu betätigen. Sollte die Kundendatenbank einen Kunden enthalten, für den die Absenderadresse der E-Mail festgelegt ist, wird dieser im Kunden-Formular angezeigt.<\/p>\n Auch diese Lösung lässt sich noch erweitern. So kann es beispielsweise sein, dass der Kunde in der E-Mail eine andere E-Mail-Adresse verwendet als in der Kundendatenbank angegeben ist. Für solche Fälle könnten Sie die Kundendatenbank so anpassen, dass mehrere E-Mail-Adressen je Kunde angelegt werden können, die dann von der hier vorgestellten Lösung ausgelesen werden.<\/p>\n Oder Sie hinterlegen eine Funktion, mit der ein neuer Kunde zu der ausgewählten E-Mail angelegt wird – vielleicht wird ja aus der E-Mail-Anfrage ein Kunde!<\/p>\n Enthaltene Beispieldateien:<\/p>\n Kundenverwaltung.accdb<\/p>\n mdlMailsVerschieben.bas<\/p>\nPublic Sub <\/span>ShowCustomerInAccess()\r\n Dim <\/span>objMailItem As <\/span>MailItem\r\n Dim <\/span>objExplorer As <\/span>Explorer\r\n Dim <\/span>objSelection As <\/span>Selection\r\n Dim <\/span>objCurrentFolder As <\/span>Folder\r\n Dim <\/span>objNamespace As <\/span>NameSpace\r\n Dim <\/span>objAccess As <\/span>Access.Application\r\n Dim <\/span>strMail As String<\/span>\r\n Dim <\/span>strDatabase As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n strDatabase = \"C:\\...\\Kundenverwaltung.accdb\"\r\n Set<\/span> objExplorer = Application.ActiveExplorer\r\n Set<\/span> objCurrentFolder = objExplorer.CurrentFolder\r\n If <\/span>objCurrentFolder.Name = \"Posteingang\" Then<\/span>\r\n Set<\/span> objSelection = objExplorer.Selection\r\n Set<\/span> objNamespace = Application.GetNamespace(\"MAPI\")\r\n If <\/span>Not<\/span> objSelection.count = 1 Then<\/span>\r\n MsgBox<\/span> (\"Bitte selektieren Sie genau eine E-Mail.\")\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Select Case TypeName(objSelection.Item(1))\r\n Case <\/span>\"MailItem\"\r\n Set<\/span> objMailItem = objSelection.Item(1)\r\n strMail = objMailItem.SenderEmailAddress\r\n Set<\/span> objAccess = GetDatabase(strDatabase)\r\n If <\/span>objAccess Is Nothing Then<\/span>\r\n Set<\/span> db = OpenDatabase(strDatabase)\r\n If <\/span>CustomerExists(db, strMail) Then<\/span>\r\n OpenDatabaseInAccess strDatabase, strMail\r\n Else<\/span>\r\n MsgBox<\/span> \"Es existiert kein Kunde mit der E-Mail-Adresse ''\" _\r\n & strMail & \"''\"\r\n End If<\/span>\r\n Set<\/span> db = Nothing\r\n Else<\/span>\r\n ShowCustomer objAccess, strMail\r\n End If<\/span>\r\n End Select<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDatenbank holen mit GetDatabase<\/h2>\n
Public Function <\/span>GetDatabase(strDatabase As String<\/span>) As <\/span>Access.Application\r\n Dim <\/span>objAccess As <\/span>Access.Application\r\n If <\/span>IsDatabaseOpen(strDatabase) Then<\/span>\r\n Set<\/span> objAccess = GetObject(strDatabase)\r\n End If<\/span>\r\n Set<\/span> GetDatabase = objAccess\r\nEnd Function<\/span><\/pre>\nAuf geöffnete Datenbank prüfen mit IsDatabaseOpen<\/h2>\n
Public Function <\/span>IsDatabaseOpen(strPath As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>strLACCDB As String<\/span>\r\n Dim <\/span>bolIsDatabaseOpen As Boolean<\/span>\r\n strLACCDB = Replace<\/span>(strPath, \".accdb\", \".laccdb\")\r\n If <\/span>Not<\/span> Len<\/span>(Dir(strLACCDB)) = 0 Then<\/span>\r\n On Error Resume Next<\/span>\r\n Kill strLACCDB\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n bolIsDatabaseOpen = True<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n End If<\/span>\r\n IsDatabaseOpen = bolIsDatabaseOpen\r\nEnd Function<\/span><\/pre>\nPrüfen der E-Mail-Adresse mit CustomerExists<\/h2>\n
Public Function <\/span>CustomerExists(db As <\/span>DAO.Database, strEMail As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblKunden WHERE EMail = ''\" & strEMail & \"''\", dbOpenDynaset)\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n CustomerExists = True<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nÖffnen der Kundendatenbank mit OpenDatabaseInAccess<\/h2>\n
Public Sub <\/span>OpenDatabaseInAccess(strDatabase As String<\/span>, strCommand As String<\/span>)\r\n Shell \"MSAccess.exe \" & strDatabase & \" \/cmd \" & strCommand, vbNormalFocus\r\nEnd Sub<\/span><\/pre>\n\n
Kundendatenbank für das Verarbeiten der E-Mail-Adresse vorbereiten<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2021_02\/pic_1291_001.png\")
<\/p>\nPublic Function <\/span>Start()\r\n Dim <\/span>strMail As String<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(Command) = 0 Then<\/span>\r\n strMail = Command\r\n DoCmd.OpenForm \"frmKunden\", WhereCondition:=\"EMail = ''\" & strMail & \"''\"\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nKunde in geöffneter Datenbank anzeigen mit ShowCustomer<\/h2>\n
Public Sub <\/span>ShowCustomer(objAccess As <\/span>Access.Application, strEMail As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngHwnd As Long<\/span>\r\n With<\/span> objAccess\r\n lngHwnd = .hWndAccessApp\r\n Set<\/span> db = .CurrentDb\r\n If <\/span>CustomerExists(db, strEMail) Then<\/span>\r\n On Error Resume Next<\/span>\r\n .DoCmd.Close acForm, \"frmKunden\"\r\n On Error GoTo<\/span> 0\r\n .DoCmd.OpenForm \"frmKunden\", WhereCondition:=\"EMail=''\" & strEMail & \"''\"\r\n SetForegroundWindow lngHwnd\r\n Else<\/span>\r\n MsgBox<\/span> \"Es existiert kein Kunde mit der E-Mail-Adresse ''\" & strEMail & \"''\"\r\n End If<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nDeclare Function SetForegroundWindow Lib \"user32.dll\" (ByVal hwnd As Long<\/span>) As Long<\/span><\/pre>\nFunktion in Outlook per Tastenkombination verfügbar machen<\/h2>\n
\n
Zusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h2>\n