<\/p>\n
Eine parallele Haltung von Terminen in Outlook und einer weiteren Anwendung wie etwa einer Access-Applikation sollte man eigentlich vermeiden. Wenn Sie sich jedoch entscheiden, Ihren Tagesablauf mit Access zu planen, kann eine Integration von Outlook dennoch lohnend sein: Immerhin können Sie mit Outlook Termine von Kunden oder Mitarbeitern empfangen, um diese dann in Ihr Access-System zur Tagesplanung einzulesen. Wie dies gelingt, erfahren Sie in diesem Beitrag.<\/b><\/p>\n
Wenn Sie Outlook-Termine in eine Access-Datenbank importieren, erfolgt dies normalerweise eins zu eins: Ein Termin entspricht dann einem Eintrag in einer entsprechenden Tabelle.<\/p>\n
Dabei spielen Anfangs- und Endzeit keine Rolle, sie werden einfach in die Tabelle eingetragen. Dies erschwert leider die Darstellung etwa in einer Tagesübersicht: Dies ist nicht so einfach tabellarisch möglich, da ein Termin ja auch einmal von 11:05 bis 11:37 Uhr angesetzt sein kann.<\/p>\n
Um dies in einem Formular darzustellen, müssen Sie schon erheblich tricksen, da dieses ja nur eine zeilenweise Darstellung erlaubt. Eine Einteilung in ein bestimmtes Zeitraster etwa in 15-Minuten-Schritten wäre hier also eine willkommene Erleichterung.<\/p>\n
Erfahrungsgemäß reicht dies für die meisten in Outlook angelegten Termine auch aus – eine höhere Genauigkeit als eine Viertelstunde für einen Termin und seine Dauer ist wohl eher selten.<\/p>\n
Ausgehend davon – und unter Berücksichtigung der Tatsache, dass die Termine auch einmal nebeneinander in einer Wochenübersicht dargestellt werden sollen – speichern wir jeden Termin in 15-Minuten-Häppchen. Dazu verwenden wir die Tabelle tblTermine<\/b>, die wie in Bild 1 aufgebaut ist.<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2012_02\/OutlooktermineImportieren-web-images\/pic001.png\")
<\/p>\n
Bild 1: Tabelle zum Speichern von Terminen<\/span><\/b><\/p>\n Der Import der Outlook-Termine soll also wie folgt verlaufen:<\/p>\n Damit wären die Felder Termindatum<\/b>, Terminzeit<\/b>, Bezeichnung <\/b>und Beschreibung <\/b>erläutert. AngelegtAm <\/b>wird mit der aktuellen Zeit versehen. AufgabeID <\/b>ist ein Feld, das wir für die Weiterverwendung der hier vorgestellten Teillösung im Beitrag Tagesabläufe verwalten <\/b>benötigen. Bleibt noch das Feld KategorieID<\/b>: Dieses soll die Zuordnung eines Termins zu einer Kategorie ermöglichen (beispielsweise Kundengespräch<\/b>, Programmierung <\/b>oder Auswärtstermin<\/b>). Was hat das mit Outlook zu tun Nun: Auch mit Outlook können Sie Termine kategorisieren und diese beispielsweise mit einer Farbe versehen.<\/p>\n Diese Kategorie soll beim Einlesen der Termine erkannt und durch einen entsprechenden Wert im Feld KategorieID <\/b>gekennzeichnet werden. Dieses Feld ist wiederum ein Fremdschlüsselfeld, mit dem Sie Einträge der Tabelle tblKategorien <\/b>auswählen können (diese enthält die drei Felder KategorieID<\/b>, Kategorie <\/b>und Outlookkategorie<\/b>).<\/p>\n Vor und nach dem Import<\/b><\/p>\n Ein typischer Outlook-Termin für den Import sieht wie in Bild 3 aus.<\/p>\n Bild 3: Der Outlook-Termin nach dem Import<\/span><\/b><\/p>\n Bild 2: Ausgangspunkt: Ein Outlook-Termin<\/span><\/b><\/p>\n Termine und Terminserien<\/b><\/p>\n In Outlook definieren Sie einzelne Termine oder auch Terminserien, die beispielsweise täglich oder wöchentlich zum angegebenen Zeitpunkt wiederholt werden. Die hier beschriebene Lösung importiert alle Termine so, als ob es einzelne Termine wären, und nimmt dabei keine Rücksicht darauf, ob ein Termin ein Einzeltermin oder Teil einer Terminserie ist.<\/p>\n Terminänderungen in Outlook<\/b><\/p>\n Nun kommt es beizeiten vor, dass ein mit einem Kunden oder Mitarbeiter vereinbarter Termin verschoben oder anderweitig geändert wird.<\/p>\n In diesem Falle soll natürlich beim nächsten Import der Outlook-Termine ein entsprechendes Update der Termine vorgenommen werden, die durch diesen Outlook-Termin in der Access-Anwendung angelegt wurden.<\/p>\n Hier wird es nun ein wenig kniffelig: Wir müssen entweder in Access ein eindeutiges Merkmal des Outlook-Termins ablegen, um die aktuellen Daten des Termins mit den in Access gespeicherten Daten abzugleichen oder aber den Outlook-Termin mit einem entsprechenden Merkmal versehen.<\/p>\n Outlook-Termine verfügen mit der EntryID<\/b> über eine eindeutige Eigenschaft, die normalerweise ihren Wert nicht ändern sollte.<\/p>\n Also legen wir in der Tabelle tblTermine <\/b>noch ein weiteres Feld namens OutlookID <\/b>an, das die EntryID <\/b>des Outlook-Termins speichert. Wenn ein Termin in Outlook geändert wurde, der bereits in der Datenbank gespeichert ist, soll Folgendes geschehen: Access liest die Daten des Termins ein, prüft, ob bereits Termine mit der EntryID <\/b>vorliegen und ob sich die festgelegten Zeiten unterscheiden.<\/p>\n Falls ja, soll der vorhandene Outlook-Termin gelöscht und die neue Version in die Datenbank geschrieben werden.<\/p>\n Umgang mit vorhandenen Terminen<\/b><\/p>\n Die hier vorgestellte Variante, Termine in einer Tabelle zu pflegen, unterscheidet sich in einem wichtigen Punkt von Outlook: Die Tabelle soll nur einen Termin für einen Zeitraum gleichzeitig aufnehmen können (sollten später mehrere Mitarbeiter die Anwendung nutzen, kann natürlich jeder Termin einmal pro Mitarbeiter vergeben werden).<\/p>\n Das bedeutet für den Import jedoch, dass wir eine Vorgehensweise für den Fall definieren müssen, dass ein Outlook-Termin zeitlich mit einem bereits vorhandenen Termin zusammenfällt.<\/p>\n Also legen wir fest, dass Outlook-Termine hier Priorität haben. Bereits vorhandene Termine sollen in eine temporäre Tabelle verschoben werden, von der aus der Benutzer diese Termine entweder an eine andere Stelle verschiebt oder diese löscht. Die Tabelle, in die solche Termine verschoben werden, heißt tblTermine_Temp <\/b>und ist genau so aufgebaut wie die Tabelle tblTermine<\/b>.<\/p>\n Termine importieren<\/b><\/p>\n Das Importieren der Termine wird durch einen einzigen Prozeduraufruf gestartet. Die Prozedur heißt OutlooktermineEinlesen<\/b> und erwartet zwei Parameter:<\/p>\n Wenn Sie die Prozedur beispielsweise nur für den aktuellen Tag aufrufen möchten, gelingt dies mit folgender Anweisung:<\/p>\n Die Prozedur selbst finden Sie in Listing 1<\/a><\/span>. Im Folgenden beschreiben wir diese Prozedur, gehen jedoch immer wieder auch auf weitere Routinen ein, die von dieser Prozedur aus aufgerufen werden.<\/p>\n Listing 1: Prozedur zum Einlesen von Outlook-Terminen mit Abgleich bestehender Einträge<\/p>\n Die Prozedur füllt zunächst eine Variable namens db <\/b>mit dem Typ Database <\/b>mit einem Verweis auf die aktuelle Datenbank. Diese Variable wird später an weitere Prozeduren übergeben.<\/p>\n Danach erzeugt sie eine neue Outlook-Instanz beziehungsweise referenziert eine gegebenenfalls bereits geöffnete Instanz und speichert einen Verweis darauf in der Variablen objOutlook<\/b>.<\/p>\n Damit Sie die Objekte der Outlook-Bibliothek überhaupt verwenden können, fügen Sie dem VBA-Projekt über den Verweise<\/b>-Dialog (VBA-Editor, Menüpunkt Extras|Verweise<\/b>) einen Verweis auf die Bibliothek Microsoft Outlook x.0 Object Library <\/b>hinzu.<\/p>\n Filter zusammenstellen<\/b><\/p>\n Die beiden Parameter datStart <\/b>und datEnde <\/b>der Prozedur legen den Zeitraum der zu importierenden Outlook-Termine fest. Wenn Sie auf Outlook-Termine zugreifen, können Sie entweder direkt alle Termine durchlaufen oder aber die Termine vorher nach bestimmten Kriterien filtern.<\/p>\n Dies erledigen wir in der Funktion FilterZusammenstellen<\/b>, die einen Filterausdruck auf Basis der übermittelten Daten zusammenstellt (s. Listing 2<\/a><\/span>).<\/p>\n Listing 2: Zusammenstellen des Outlook-Filters<\/p>\n Der Filter liefert in der aktuellen Version alle Termine, deren Start oder Ende in den angegebenen Zeitraum fällt. Für den aktuellen Tag können Sie den Filter wie folgt im Direktfenster ausgeben:<\/p>\n Wenn Sie die Termine anders filtern möchten, also etwa so, dass nur Termine verwendet werden, deren Beginn nicht vor dem ersten Tag und deren Ende nicht hinter dem letzten Tag liegt, müssen Sie die Funktion FilterZusammenstellen <\/b>entsprechend umformulieren.<\/p>\n <\/p>\n Termine holen<\/b><\/p>\n Wenn die Filterbedingung zusammengestellt ist, können Sie damit gleich die entsprechenden Termine ermitteln. Dies erledigt die Funktion TermineHolen<\/b> (s. Listing 3<\/a><\/span>). Die Funktion erwartet zwei Parameter:<\/p>\n Listing 3: Terminaufzählung holen<\/p>\n Die Funktion erstellt ein MAPI-Namespace-Objekt und ermittelt über dessen Funktion GetDefaultFolder <\/b>den Ordner, der alle Termine enthält (olFolderCalendar<\/b>).<\/p>\n Mit GetDefaultFolder <\/b>wird der Standardkalender zurückgegeben! Sollten Sie Termine von anderen Kalendern einlesen wollen, schalten Sie eine Funktion dazwischen, mit der Sie den gewünschten Ordner auswählen können. Diese sieht beispielsweise wie in Listing 4<\/a><\/span> aus.<\/p>\n Listing 4: Kalender-Ordner auswählen<\/p>\n Der Aufruf dieser Funktion mit dem MAPI-Namespace-Objekt öffnet den Dialog aus Bild 4. Wenn der Benutzer einen Ordner auswählt, der nicht standardmäßig AppointmentItem<\/b>-Objekte enthält, erscheint eine entsprechende Meldung.<\/p>\n Bild 4: Dialog zum Auswählen von Outlook-Ordnern<\/span><\/b><\/p>\n Ein Verweis auf das entsprechende Folder<\/b>-Objekt wird nur zurückgegeben, wenn es sich um einen Kalender-Ordner handelt. Berücksichtigen Sie dies durch eine entsprechende Prüfung in der aufrufenden Prozedur.<\/p>\n Sobald die GetDefaultFolder<\/b>-Funktion (oder Ihre eigene Funktion zur Auswahl des Ordners) ein Folder<\/b>-Objekt zurückgeliefert hat, erstellt die Funktion TermineHolen <\/b>ein Items<\/b>-Objekt, das die Items<\/b>-Auflistung des Folder<\/b>-Objekts referenziert. Die darin enthaltenen Termine werden zunächst mit der Sort<\/b>-Methode nach dem Wert der Eigenschaft Start <\/b>des jeweiligen Item<\/b>-Objekts sortiert, also nach der Startzeit. Die Eigenschaft IncludeRecurrences <\/b>gibt an, ob Terminserien berücksichtigt werden sollen – dies ist hier der Fall.<\/p>\n Schließlich verwendet die Restrict<\/b>-Methode den in strFilter <\/b>gespeicherten Filterausdruck, um die Termine nach dem angegebenen Zeitraum zu filtern. Das Ergebnis ist eine neue Items<\/b>-Auflistung, die schließlich als Rückgabewert der Funktion dient.<\/p>\n Temporäre Termine löschen<\/b><\/p>\n Die Tabelle tblTermine_Temp <\/b>speichert verschobene Termine, also Termine, die bereits vorhanden sind und von neu importierten Outlook-Terminen überschrieben werden.<\/p>\n Diese Tabelle sollte gleich nach dem Einlesen der Outlook-Termine vom Benutzer bearbeitet werden, um verschobene Termine an anderer Stelle beziehungsweise mit anderer Zeitangabe in die Tabelle tblTermine <\/b>einzufügen beziehungsweise zu löschen. Ist dies nicht geschehen, erledigt die Prozedur OutlooktermineEinlesen <\/b>dies mit einer entsprechenden DELETE<\/b>-Anweisung.<\/p>\n Termine durchlaufen und speichern<\/b><\/p>\n Danach durchläuft die Prozedur OutlooktermineEinlesen <\/b>alle Elemente der mit objItems <\/b>referenzierten Items<\/b>-Auflistung und referenziert das jeweils aktuelle Element mit der Objektvariablen objItem<\/b>. Sie prüft zunächst, ob es sich bei dem Element überhaupt um ein Element des Typs Appointment <\/b>handelt. Falls ja, wird der Verweis auf dieses Objekt der Variablen objAppointmentItem <\/b>zugewiesen, das den dafür vorgesehenen Datentyp aufweist.<\/p>\n Es folgt noch die Prüfung, ob es sich nicht um ein abgesagtes Terminelement handelt. Falls nicht, beginnt das Einlesen des Termins. Dies geschieht zunächst durch das Speichern wichtiger Informationen wie dem Datum, der Startzeit, der Endzeit und des eindeutigen Merkmals EntryID <\/b>in den Variablen datDatum<\/b>, datStartzeit<\/b>, datEndzeit <\/b>und strOutlookID<\/b>.<\/p>\n Die EntryID <\/b>wird in einer String<\/b>-Variablen gespeichert, weil es sich dabei um eine GUID wie beispielsweise 00000000809CC08917748749AC450D4276BE7B0C0410A001<\/b> handelt. Start- und Endzeit werden nicht direkt aus den jeweiligen Eigenschaften ermittelt, sondern mithilfe der Funktion ZeitpunktErmitteln<\/b>.<\/p>\n Die Funktion aus Listing 5<\/a><\/span> hat folgende Aufgabe: Die 15 Minuten langen Bestandteile der importierten Outlook-Termine werden jeweils unter Angabe der Startzeit gespeichert. datStartzeit <\/b>und datEndzeit <\/b>sollen nun die Zeiten enthalten, an denen das erste und das letzte 15-Minuten-Element beginnt. Wenn der Termin von 12:00 bis 13:00 Uhr dauert, sind das also vier Elemente, die um 12:00, 12:15, 12:30 und 12:45 Uhr beginnen. Über diese in der Tabelle tblTimeplanZeiten <\/b>gespeicherten Einträge soll dann später eine Schleife laufen, um die einzelnen Elemente anzulegen.<\/p>\n Listing 5: Ermitteln der Startzeit von Teilterminen<\/p>\n Was geschieht, wenn der Termin mal nicht zur vollen Viertelstunde beginnt oder endet Dann soll die Funktion ZeitpunktErmitteln <\/b>dies ausgleichen, indem sie den Startzeitpunkt auf die vorherige Viertelstunde und den Endzeitpunkt auf die folgende Viertelstunde verlegt.<\/p>\n Aus einem Termin, der von 12:37 bis 13:05 Uhr dauert, wird also ein Termin von 12:30 bis 13:15 Uhr. Dabei werden die genauen Zeitpunkte per Domänenfunktion aus der Tabelle tblTimeplanZeiten <\/b>ermittelt.<\/p>\n Die erste Zeit wird dabei mit DMax <\/b>ermittelt, um den größten Eintrag zu erwischen, der kleiner oder gleich der Startzeit ist (bei 12:07 also etwa 12:00 Uhr). Die Ermittlung der letzten Zeit erfolgt mit der DMin<\/b>-Funktion, um die erste volle Viertelstunde zu erhalten, die größer oder gleich der Endzeit ist. Damit erhalten wir aber auch nur die Viertelstunde, die den Zeitraum beendet, aber wir benötigen die letzte Viertelstunde, bevor der Zeitraum endet. Also ziehen wir noch den Wert 1\/96 von diesem Wert ab.<\/p>\n Prüfen, ob Termin schon vorhanden ist<\/b><\/p>\n Bevor ein Outlook-Termin in die Tabelle tblTermine<\/b> übernommen werden kann, fehlt noch die Prüfung, ob dieser nicht bereits vorhanden ist.<\/p>\n Davon abhängig können zwei Dinge geschehen:<\/p>\n Die Prüffunktion heißt TerminVorhanden <\/b>und erwartet folgende Parameter (s. Listing 6<\/a><\/span>):<\/p>\n Listing 6: Prüfen, ob ein Termin bereits vorhanden ist<\/p>\n Im ersten Schritt prüft die Funktion grundsätzlich, ob der Termin bereits einmal in der Datenbank angelegt wurde. Dazu reicht es, das Feld OutlookID <\/b>aller Datensätze der Tabelle tblTermine <\/b>auf den Wert der Eigenschaft EntryID <\/b>des zu untersuchenden Outlook-Termins zu prüfen. Wenn kein entsprechender Eintrag gefunden wird, wurde der Termin noch nicht importiert und kann einfach angelegt werden. Konnte jedoch mindestens ein Datensatz gefunden werden, liest die Funktion die Startzeiten des ersten und letzten Elements dieses Termins in die beiden Variablen datOutlookStartzeit <\/b>und datOutlookEndzeit <\/b>ein.<\/p>\n Beide werden mit den per Parameter übergebenen Werten des anzulegenden Termins verglichen. Ist das Ergebnis gleich, ist der Termin vorhanden und wurde seit dem Anlegen in der Tabelle tblTermine <\/b>nicht mehr in Outlook verändert – es ist keine weitere Aktion nötig.<\/p>\n Anderenfalls sollen die entsprechenden Terminelemente entsprechend der neuen Start- und Endzeit erneut angelegt werden. Dazu löscht die Funktion TerminVorhanden <\/b>zunächst die vorhandenen Einträge in der Tabelle tblTermine<\/b>.<\/p>\n Anlegen des Termins<\/b><\/p>\n\n
![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2012_02\/OutlooktermineImportieren-web-images\/pic007.png\")
<\/p>\n![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2012_02\/OutlooktermineImportieren-web-images\/pic006.png\")
<\/p>\n\n
OutlooktermineEinlesen Date, Date<\/pre>\n
Public Sub OutlooktermineEinlesen(datStart As Date, datEnde As Date)\r\n Dim db As dao.Database\r\n Dim objOutlook As Outlook.Application\r\n Dim objItems As Outlook.Items\r\n Dim strFilter As String\r\n Dim datDatum As Date\r\n Dim objAppointment As Outlook.AppointmentItem\r\n Dim objItem As Object\r\n Dim datStartzeit As Date\r\n Dim datEndzeit As Date\r\n Dim strOutlookID As String\r\n Set db = CurrentDb\r\n strFilter = FilterZusammenstellen(datStart, datEnde)\r\n Set objOutlook = New Outlook.Application\r\n Set objItems = TermineHolen(objoutlook, strFilter)\r\n db.Execute "DELETE FROM tblTermine_Temp", dbFailOnError\r\n For Each objItem In objItems\r\n If TypeName(objItem) = "AppointmentItem" Then\r\n Set objAppointment = objItem\r\n With objAppointment\r\n Select Case .MeetingStatus\r\n Case olMeeting, olMeetingReceived, olNonMeeting\r\n datDatum = CDate(Int(.Start))\r\n datStartzeit = ZeitpunktErmitteln(.Start, True)\r\n datEndzeit = ZeitpunktErmitteln(.End, False)\r\n strOutlookID = .EntryID\r\n If Not TerminVorhanden(db, strOutlookID, datDatum, datStartzeit, datEndzeit) Then\r\n TerminAnlegen db, objAppointment, datDatum, datStartzeit, datEndzeit, _\r\n strOutlookID\r\n End If\r\n End Select\r\n End With\r\n End If\r\n Next objItem\r\n If Not IsNull(DLookup("TerminID", "tblTermine_Temp")) Then\r\n MsgBox "Es wurden Termine verschoben."\r\n End If\r\n Set objoutlook = Nothing\r\nEnd Sub<\/pre>\nPublic Function FilterZusammenstellen(datStart As Date, datEnde As Date) As String\r\n Dim strStart As String\r\n Dim strEnde As String\r\n Dim strFilterTemp As String\r\n strStart = Format(datStart, "ddddd")\r\n strEnde = Format(datEnde, "ddddd")\r\n strFilterTemp = "[Start] <= " & Chr(34) & strEnde & " 23:59" & Chr(34)\r\n strFilterTemp = strFilterTemp & " AND [End] > " & Chr(34) & strStart & " 00:00" & Chr(34)\r\n FilterZusammenstellen = strFilterTemp\r\nEnd Function<\/pre>\n
Filterzusammenstellen(Date,Date)\r\n[Start] <= "02.03.2012 23:59" AND [End] > "02.03.2012 00:00"<\/pre>\n
\n
Public Function TermineHolen(objOutlook As Outlook.Application, strFilter As String) As Outlook.Items\r\n Dim objMAPI As Outlook.NameSpace\r\n Dim objCalendar As Outlook.Folder\r\n Dim objItems As Outlook.Items\r\n Set objMAPI = objOutlook.GetNamespace("MAPI")\r\n Set objCalendar = objMAPI.GetDefaultFolder(olFolderCalendar)\r\n Set objItems = objCalendar.Items\r\n objItems.Sort "[Start]", False\r\n objItems.IncludeRecurrences = True\r\n Set TermineHolen = objItems.Restrict(strFilter)\r\nEnd Function<\/pre>\nPublic Function GetAppointmentFolder(objMAPI As Outlook.NameSpace) As Outlook.Folder\r\n Dim objFolder As Outlook.Folder\r\n Set objFolder = objMAPI.PickFolder\r\n If Not objFolder.DefaultItemType = olAppointmentItem Then\r\n MsgBox "Dies ist kein Kalender-Ordner."\r\n Else\r\n Set GetAppointmentFolder = objFolder\r\n End If\r\nEnd Function<\/pre>\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2012_02\/OutlooktermineImportieren-web-images\/pic002.png\")
<\/p>\nPublic Function ZeitpunktErmitteln(dat As Date, bolVorher As Boolean) As Date\r\n Dim datTemp As Date\r\n datTemp = CDate(dat) - Int(dat)\r\n If bolVorher Then\r\n ZeitpunktErmitteln = DMax("TimeplanZeit", "tblTimeplanZeiten", "TimeplanZeit <= " & ISODatum(datTemp))\r\n Else\r\n ZeitpunktErmitteln = DMin("TimeplanZeit", "tblTimeplanZeiten", "TimeplanZeit >= " & ISODatum(datTemp)) - 1 \/ 96\r\n End If\r\nEnd Function<\/pre>\n\n
\n
Public Function TerminVorhanden(db As dao.Database, strOutlookID As String, datDatum As Date, _\r\n datStartzeit As Date, datEndzeit As Date) As Boolean\r\n Dim bolVorhanden As Boolean\r\n Dim datOutlookStartzeit As Date\r\n Dim datOutlookEndzeit As Date\r\n bolVorhanden = False\r\n If Not IsNull(DLookup("TerminID", "tblTermine", "OutlookID = ''" & strOutlookID & "''")) Then\r\n datOutlookStartzeit = DMin("Termindatum & '' '' & Terminzeit", "tblTermine", "OutlookID = ''" & strOutlookID & "''")\r\n datOutlookEndzeit = DMax("Termindatum & '' '' & Terminzeit", "tblTermine", "OutlookID = ''" & strOutlookID & "''")\r\n If datOutlookStartzeit = CDbl(datDatum + datStartzeit) And datOutlookEndzeit = CDbl(datDatum + datEndzeit) Then\r\n bolVorhanden = True\r\n Else\r\n db.Execute "DELETE FROM tblTermine WHERE OutlookID = ''" & strOutlookID & "''", dbFailOnError\r\n End If\r\nEnd If\r\nTerminVorhanden = bolVorhanden\r\nEnd Function<\/pre>\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2012_02\/OutlooktermineImportieren-web-images\/pic003.png\")
<\/p>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2012_02\/OutlooktermineImportieren-web-images\/pic004.png\")
<\/p>\n![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2012_02\/OutlooktermineImportieren-web-images\/pic005.png\")
<\/p>\n