<\/p>\n
In unser Ticketsystem haben wir bereits Funktionen integriert, mit denen Sie die Kundenanfragen per Drag and Drop in der Datenbank speichern können. Außerdem haben wir ein Formular hinzugefügt, das alle offenen E-Mails anzeigt und eine einfache Möglichkeit enthält, daraus Tickets zu generieren. Diese wollen wir nun im vorliegenden Teil der Beitragsreihe verarbeiten, und zwar in dafür ausgelegten Formularen. Diese zeigen sowohl eine übersicht aller Tickets – filterbar nach dem Status und anderen Eigenschaften – als auch den Verlauf eines einzelnen Tickets.<\/b><\/p>\nTicketübersicht<\/h2>\n
Im Formular frmTickets <\/b>wollen wir eine übersicht aller Tickets liefern, und zwar nach verschiedenen Kriterien. Die Tickets sollen nach dem Anlagedatum sortiert werden können oder nach dem Kunden. Außerdem benötigen wir natürlich verschiedene Filter, etwa nach dem Kunden oder nach dem Status oder der Priorität.Das Formular soll per Doppelklick auf einen der Einträge die Möglichkeit bieten, das Ticket in der Detailansicht zu öffnen und alle bisher erfolgten Schritte darzustellen.<\/p>\n
Um keine eigene Programmierung etwa für die Sortierung vornehmen zu müssen, nutzen wir zur Anzeige der Tickets einfach ein Unterformular in der Datenblattansicht. Dieses bietet genügend Möglichkeiten zum Sortieren und Filtern der Einträge. Schnelle Filter wollen wir hinzufügen für den Status von Tickets sowie für die Priorität. Außerdem wollen wir eine Schaltfläche zum schnellen Aufheben der Sortierung und des Filters hinzufügen. Schließlich soll ein Ticket natürlich schnell per Doppelklick geöffnet werden können.<\/p>\n
Um den Status und die Priorität eines Tickets erfassen zu können, wollen wir der Tabelle tblTicktes <\/b>zwei neue Felder hinzufügen. Diese sollen als Fremdschlüsselfelder ausgelegt werden und zwei weitere neue Tabellen referenzieren.<\/p>\n
Die erste Tabelle heißt tblStatus <\/b>und soll die verschiedenen Statuswerte erfassen (Status ist übrigens tatsächlich der Plural von Status, daher diese Tabellenbezeichnung). Sie finden den Entwurf dieser Tabelle in Bild 1. Neben dem Primärschlüsselfeld StatusID <\/b>enthält die Tabelle noch das mit einem eindeutigen Index versehene Feld Status<\/b>.<\/p>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2017_01\/pic_1075_001.png\")
<\/p>\n
Bild 1: Entwurf der Tabelle tblStatus<\/span><\/b><\/p>\n Die zweite neue Tabelle heißt tblPrioritaeten <\/b>und ist fast genauso aufgebaut wie die Tabelle tblStatus<\/b>. Sie enthält neben dem Primärschlüsselfeld PrioritaetID <\/b>ebenfalls ein weiteres Feld zum Erfassen der Bezeichnung der Inhalte, in diesem Fall namens Prioritaet<\/b>. Auch dieses Feld haben wir mit einem eindeutigen Index versehen (s. Bild 2).<\/p>\n Bild 2: Entwurf der Tabelle tblPrioritaeten<\/span><\/b><\/p>\n Die beiden Fremdschlüsselfelder der Tabelle tblTickets <\/b>richten wir als Nachschlagefelder ein. Dazu wählen Sie zunächst für das Feld StatusID <\/b>den Datentyp Nachschlage-Assistent <\/b>aus und starten somit den gleichnamigen Assistenten. Wählen Sie hier die Tabelle tblPrioritaeten <\/b>aus, selektieren Sie die beiden Felder StatusID <\/b>und Status<\/b>, legen Sie keine aufsteigende Sortierung für irgendeines der Felder fest und aktivieren Sie die Option Schlüsselspalte ausblenden<\/b>.<\/p>\n Schließlich aktivieren Sie die referenzielle Integrität durch Markieren der Option Datenintegrität aktivieren <\/b>(s. Bild 3).<\/p>\n Bild 3: Letzter Schritt beim Einrichten eines Nachschlagefeldes<\/span><\/b><\/p>\n Die Tabelle tblTickets <\/b>sieht danach im Entwurf wie in Bild 4 aus, sodass wir Status und Priorität bequem per Nachschlagefeld auswählen können. Die Einrichtung von Nachschlagefeldern hat außerdem den praktischen Vorteil, dass Sie später, wenn Sie die Felder dieser Tabelle in den Entwurf von Formularen ziehen, direkt Kombinationfelder für solche Felder erhalten.<\/p>\n Bild 4: Entwurf der soeben erweiterten Tabelle tblTickets<\/span><\/b><\/p>\n Genau davon profitieren wir gleich im nächsten Schritt. Wir erstellen ein neues Formular und speichern es unter dem Namen sfmTickets <\/b>ab. Dieses soll das Unterformular eines weiteren Formulars namens frmTickets <\/b>werden und die Tickets in der Datenblattansicht übersichtlich anzeigen.<\/p>\n Legen Sie als Datenherkunft des Formulars die Tabelle tblTickets <\/b>fest. Ziehen Sie dann aus der Feldliste alle Felder der Tabelle in den Detailbereich des Formularentwurfs (s. Bild 5).<\/p>\n Bild 5: Entwurf des Unterformulars sfmTickets<\/span><\/b><\/p>\n Nun stellen Sie noch die Eigenschaft Standardansicht <\/b>des Formulars <\/b>auf Datenblatt ein und schließen das Formular.<\/p>\n Nun legen Sie das Formular frmTickets <\/b>an und ziehen das Unterformular sfmTickets <\/b>in den Detailbereich des Entwurfs. Stellen Sie die Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>jeweils auf den Wert Beide <\/b>ein.<\/p>\n Für die optische Gestaltung des Hauptformulars legen Sie noch die Eigenschaften Navigationsschaltflächen<\/b>, Datensatzmarkierer<\/b>, Bildlaufleisten <\/b>und Trennlinien <\/b>auf den Wert Nein <\/b>fest.<\/p>\n Nun nutzen wir die beiden Klassen clsFastFilter <\/b>und clsFastFilterControl<\/b>, die wir im Beitrag Schneller Filter <\/b>vorgestellt haben (www.access-im-unternehmen.de\/1072<\/b>). Importieren Sie diese beiden Klassen in die aktuelle Datenbank.<\/p>\n Nun statten Sie das Formular frmTickets <\/b>mit einigen Steuerelementen aus, mit denen der Benutzer die Daten filtern kann. Sie benötigen zwei Schaltlfächen namens cmdNachFeldFiltern <\/b>und cmdNachInhaltFiltern<\/b>, ein Kontrollkästchen namens chkFilterkriterienVer-knuep-fen <\/b>und eine Optionsgruppe mit dem Namen ogrVerknuepfenMit<\/b> (s. Bild 6). Für das Kontrollkästchen stellen Sie als Standardwert False <\/b>ein, für die Optionsgruppe den Wert 1<\/b>. Außerdem stellen Sie für die Optionsgruppe die Eigenschaft Aktiviert <\/b>aus Nein <\/b>ein. Schließlich stellen Sie noch die Eigenschaft Enthält Modul <\/b>des Unterformulars auf den Wert Ja <\/b>ein.<\/p>\n Bild 6: Entwurf des Formulars frmTickets<\/span><\/b><\/p>\n Nun fügen wir den Code zum Initialisieren der Filterfunktionen hinzu. Das Klassenmodul des Formulars frmTickets <\/b>sieht danach wie folgt aus:<\/p>\n Nach dem ersten Test, bei dem wir einen Teil des Feldes Kunde <\/b>markieren und die Schaltlfäche cmdNachInhaltFiltern <\/b>anklicken, stellen wir allerdings fest, dass dies nicht reibungslos funktioniert.<\/p>\n Der Hintergrund ist, dass das Kombinationsfeld KundeID <\/b>eine Datensatzherkunft mit einem berechneten Feld verwendet:<\/p>\n Dies wird durch die Klasse clsFastFilterControl <\/b>nicht abgedeckt. Wir haben probiert, dies so anzupassen, dass auch berechnete Felder aufgelöst werden können, aber dies gelingt nicht, weil es keine Möglichkeit gibt, den berechneten Ausdruck über das Objektmodell zu ermitteln. Dies zeigt im übrigen auch sehr schön, dass auch eine ausgefeilte Lösung nur selten alle möglichen Konstellationen berücksichtigen kann …<\/p>\n Also müssen wir uns einen kleinen Workaround einfallen lassen und die Klasse clsFastFilterControl <\/b>etwas anpassen – und zwar so, dass wir in Fällen wie dem hier vorliegenden selbst Hand anlegen können. In diesem Fall ist das Problem, dass wir den Namen des Feldes der Datensatzherkunft des Kombinationsfeldes ermitteln wollen, dessen Inhalt im Kombinationsfeld angezeigt wird. Dieser lautet aber schlicht Kunde <\/b>und entspricht dem Alias-Namen des berechneten Feldes, das eigentlich den Ausdruck [Nachname] & „, “ & [Vorname] <\/b>enthält.<\/p>\n <\/p>\n An diesen kommen wir aber programmatisch nicht heran (außer, wir würden den SQL-Ausdruck auseinandernehmen – aber dieser kann ja auch beliebig komplex werden, also lassen wir gleich die Finger davon …). Deshalb tragen wir diesen Ausdruck einfach in die Eigenschaft Marke <\/b>(englisch und unter VBA: Tag<\/b>) des Kombinationsfeldes ein (s. Bild 7).<\/p>\n Bild 7: Eintragen des angezeigten Ausdrucks des Kombinationsfeldes in der Eigenschaft Marke<\/span><\/b><\/p>\n Nun müssen wir nur noch den Code der Klasse clsFastFilterControl <\/b>anpassen, damit diese, falls sich ein Wert in der Eigenschaft Tag <\/b>befindet, diesen Wert statt des Feldnamens selbst verwendet. Genau genommen handelt es sich dabei um die Funktion LookupSearchstring<\/b>, die wir um die If…Then…Else<\/b>-Bedingung aus Listing 1 erweitern. Diese prüft schlicht, ob die Tag<\/b>-Eigenschaft einen Wert enthält, und trägt diesen dann statt des Feldnamens in die Variable strFieldCriteria <\/b>ein. Wenn wir dies nun ausprobieren, erhalten wir zum Beispiel nach Markierung des Buchstabens M <\/b>den folgenden SQL-Ausdruck:<\/p>\n Listing 1: Anpassung der Funktion LookupSearchstring<\/span><\/b><\/p>\n Nachdem wir die Filterfunktionen oberhalb des Datenblatts angelegt haben, wollen wir die Schaltflächen mit den Funktionen zum öffnen oder Löschen von Tickets aus dem Datenblatt unter diesem anlegen.<\/p>\n Die beiden Schaltflächen wollen wir optisch etwas ansprechender gestalten und fügen daher zwei neue Icons zur Datenbank hinzu. Dazu markieren Sie eine beliebige leere Stelle im Formularentwurf und wählen dann den Ribbon-Eintrag Entwurf|Steuerelemente|Bild einfügen|Durchsuchen… <\/b>aus.<\/p>\n Fügen Sie die Bilddateien hinzu, sofern Sie eine entsprechende Sammlung von Icons haben (anderenfalls lassen Sie die Icons einfach weg und arbeiten mit einer normalen Beschriftung).<\/p>\n Wir haben zwei Icons namens edit.png <\/b>und delete.png <\/b>hinzugefügt, die dann in der Eigenschaft Bild <\/b>der Schaltflächen als edit <\/b>beziehungsweise delete <\/b>angezeigt werden. Diese wählen wir dort aus. Als Beschriftung fügen Sie die Texte Bearbeiten <\/b>und Löschen<\/b>, als Namen die Werte cmdBearbeiten <\/b>und cmdLoeschen <\/b>hinzu (s. Bild 8).<\/p>\n Bild 8: Schaltflächen zum Bearbeiten und Löschen eines Tickets<\/span><\/b><\/p>\n Damit die Texte auch neben dem Icons erscheinen, stellen Sie die Eigenschaft Anordnung der Bildbeschriftung <\/b>auf Allgemein <\/b>ein. Um den Hintergrund transparent zu gestalten, legen Sie den Wert Transparent <\/b>für die Eigenschaft Hintergrundart <\/b>fest.<\/p>\n Da wir für das Unterformular-Steuerelement die Eigenschaft Vertikaler Anker <\/b>auf Beide <\/b>eingestellt haben, würden die Schaltflächen, die aktuell noch oben verankert sind, beim Vergrößern der Höhe des Formulars hinter dem Unterformular verschwinden. Stellen wir also die Eigenschaft Vertikaler Anker <\/b>der beiden Schaltflächen auf Unten <\/b>ein, damit diese entsprechend nach unten verschoben werden.<\/p>\n Die Schaltfläche cmdLoeschen <\/b>soll das aktuell im Unterformular markierte Ticket löschen. Dazu hinterlegen wir für die Ereigniseigenschaft Beim Klicken <\/b>der Schaltfläche die folgende Prozedur:<\/p>\n Die Prozedur prüft zunächst, ob überhaupt ein Datensatz im Unterformular markiert ist (IsNull(Me!sfmTickets.Form!TicketID)<\/b>). Falls nicht, erscheint eine entsprechende Meldung. Anderenfalls löscht die Prozedur dieses Ticket nach entsprechender Rückfrage (s. Bild 9).<\/p>\n Bild 9: Ticketübersicht in Aktion, hier beim Löschen eines Tickets<\/span><\/b><\/p>\n Die zweite Schaltfläche namens cmdBearbeiten <\/b>soll das Formular frmTicket <\/b>mit den Detailinformationen des Tickets anzeigen. Dazu hinterlegen wir zunächst die folgende Ereignisprozedur:<\/p>\n Diese Prozedur öffnet ein Formular namens frmTicket <\/b>und übergibt als Bedingung einen Ausdruck, der etwa so aussieht:<\/p>\n Bevor wir dieses Formular erstellen, müssen wir uns überlegen, wie dieses aussehen soll und welche Aufgaben damit zu erledigen sind. Da die Aufgaben, die wir mit diesem Formular durchführen wollen, jedoch etwas komplexer sind, erstellen wir zunächst ein Basis-Formular mit den grundlegenden Funktionen. In diesem Fall soll das Formular an die Tabelle tblTickets <\/b>gebunden werden und alle Felder dieser Tabelle anzeigen – mit Ausnahme von MailItemID<\/b>, womit je der Eintrag der zugrunde liegenden E-Mail aus der Tabelle tblMailItems <\/b>referenziert wird.<\/p>\n Die Felder der Tabelle ordnen wir als Textfelder beziehungsweise Kombinationsfelder zunächst wie in Bild 10 an. Dabei soll das Feld Ticketinhalt <\/b>beim Vergrößern des Formulars in die vertikale und horizontale Richtung ebenfalls in beiden Richtungen vergrößert werden, weshalb wir die Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>beide auf den Wert Beide <\/b>einstellen.<\/p>\n Bild 10: Erster Entwurf des Formulars zur Detailansicht eines Tickets<\/span><\/b><\/p>\n Die beiden darüber liegenden Felder sollen nur in die horizontale Richtung gestreckt werden, also erhalten diese nur für die Eigenschaft Horizontaler Anker <\/b>den Wert Beide<\/b>. Die darunter befindlichen Steuerelemente sollen nur nach unten verschoben werden, wenn das Formular nach unten vergrößert wird, also stellen wir die Eigenschaft Vertikaler Anker <\/b>für diese Steuerelemente auf den Wert Unten <\/b>ein.<\/p>\n Die Schaltfläche cmdOK <\/b>führt die folgende Ereignisprozedur aus:<\/p>\n Die Anzeige der Ticketeigenschaften ist allerdings noch längst nicht alles, was dieses Formulars leisten soll. Da jedes Ticket auf Basis einer E-Mail eines Kunden erstellt wurde, wollen wir auch die Möglichkeit haben, die entsprechende E-Mail öffnen zu können. Dazu fügen wir dem Formular eine weitere Schaltfläche hinzu, und zwar links neben dem Steuerelement zur Anzeige des Feldes Ticketinhalt <\/b>(s. Bild 11).<\/p>\n Bild 11: Neue Schaltfläche zum öffnen der Kunden-E-Mail<\/span><\/b><\/p>\n Die Schaltfläche nennen wir cmdAnfrageOeffnen<\/b>. Sie soll die in der Tabelle tblMailItem <\/b>enthaltene und zum aktuellen Ticket gehörende E-Mail im entsprechenden Outlook-Fenster anzeigen.<\/p>\n Diese Schaltfläche löst die folgende Ereignisprozedur aus:<\/p>\n Die Prozedur deklariert eine Variable zum Aufnehmen der EntryID<\/b>, also des eindeutigen Identifizierers für die Outlook-E-Mail, eine Variable für das MAPI-Namespace-Objekt sowie eine Variable für die Mail selbst. Sie ermittelt zunächst die EntryID<\/b> zu der Ausgangsmail zum angezeigten Ticket. Diese finden wir in der Tabelle tblMailItems<\/b>, aus der wir den gesuchten Eintrag über den Primärschlüsselwert ermitteln, der in unserem aktuellen Ticket-Datensatz im Fremdschlüsselfeld MailItemID <\/b>gespeichert ist. Dabei unterstützt uns eine entsprechende DLookup<\/b>-Funktion. Danach füllen wir die Variable objNamespace <\/b>über die Funktion GetMAPI <\/b>und verwenden deren Funktion GetItemFromID<\/b>, um mit der EntryID <\/b>eine Referenz auf die gesuchte E-Mail zu erhalten. Diese speichern wir dann in der Objektvariablen objMailItem<\/b>, deren Methode Display <\/b>wir wiederum nutzen können, um diese E-Mail im Mailfenster von Outlook zu öffnen (s. Bild 12). Dies zeigt die grundlegende Technik für einige der nachfolgend beschriebenen Schritte.<\/p>\n Bild 12: Anzeige der E-Mail zum Ticket<\/span><\/b><\/p>\n Wir haben also nun eine Möglichkeit, Tickets auf Basis von Kunden-E-Mails zu erstellen und können diese in einer übersicht anzeigen. Außerdem haben wir ein Formular erstellt, das die Details zu einem ausgewählten Ticket anzeigt und die Möglichkeit bietet, die Ausgangsmail zu öffnen.<\/p>\n Wie aber geht es nun weiter Was geschieht mit einem Ticket, nachdem es aufgenommen wurde Dazu gibt es je nach Anwendungsfall verschiedene Möglichkeiten. In meinem Fall kommen Anfragen von Kunden, <\/p>\n und vieles mehr.<\/p>\n Die Anfragen der Kunden laufen dann auf verschiedene durchzuführende Aktionen hinaus:<\/p>\n Wir wollen zunächst den ersten Fall technisch abbilden. Dazu ist eine Antwort an den Kunden erforderlich, die gegebenenfalls automatisch aus einer Vorlage formuliert werden kann, gegebenenfalls aber auch noch eine manuelle Ergänzung erfordert.<\/p>\n Für jeden Schritt, also etwa für einen „einfachen Fall“, wollen wir einen Eintrag in einer Tabelle vornehmen, die mit dem Ticket aus der Tabelle tblTickets <\/b>verknüpft ist. In dieser Tabelle, die wir tblAktionen <\/b>nennen werden, wollen wir den Typ der Aktion festlegen. Diese speichern wir wiederum in der Tabelle tblAktionstypen<\/b>, deren Entwurf wie in Bild 13 aussieht.<\/p>\n Bild 13: Tabelle zum Speichern der Aktionstypen<\/span><\/b><\/p>\n Nun stellt sich noch die Frage: Wollen wir etwa einen Fall wie das ändern einer Rechnung, was imgrunde zwei Aktionen anstößt (eine Antwort an den Kunden und eine Mail an die Buchhaltung), in einer Aktion speichern, wofür dann mindestens zwei individuelle Felder nötig wären, oder sollten wir dazu zwei Aktionen anlegen Letzteres ist vermutlich der flexiblere Weg, vor allem, wenn man davon ausgeht, dass eine Aktion auch einmal aus mehr als zwei Basisaktionen bestehen kann.<\/p>\n Damit kommen wir dann auch gleich zur Gestaltung der Tabelle tblAktionen<\/b>. Diese soll auf jeden Fall ein Fremdschlüsselfeld namens TicketID <\/b>enthalten, mit dem wir den entsprechenden Datensatz der Tabelle tblTickets <\/b>referenzieren können.<\/p>\n Außerdem wollen wir damit einen Eintrag der Tabelle tblAktionstypen <\/b>auswählen können, wozu ein weiteres Fremdschlüsselfeld nötig wird (namens AktionstypID<\/b>). Die Tabelle tblAktionstypen <\/b>sollte außerdem zumindest zwei Felder enthalten, mit denen wir Vorlagen für den Betreff und den Inhalt zu versendender Mails an Kunden, Buchhaltung et cetera speichern können.<\/p>\n Da wir ausschließlich über E-Mail kommunizieren wollen, gehört zu jeder Aktion keine oder eine E-Mail – zum Beispiel an den Kunden oder an die Buchhaltung. Dementsprechend kommt für jede Aktion wieder eine neue E-Mail zur Tabelle tblMailItems <\/b>hinzu, die wir ebenfalls von der Tabelle tblAktionen <\/b>aus referenzieren wollen. Das entsprechende Fremdschlüsselfeld heißt MailItemID<\/b>, genau wie in der Tabelle tblTickets<\/b>.<\/p>\n Außerdem sollten wir ein Memofeld zum Eintragen eventuell benötigter Bemerkungen vorhalten. üblicherweise sollten die Aktionen weitgehend standardisiert sein, da zu einem Großteil immer wieder die gleichen Kundenanfragen eingehen.<\/p>\n Daher wird das Memofeld selten zu befüllen sein, da der Aktionstyp bereits einen Hinweis auf die erfolgte Aktion gibt. Dennoch kann es Fälle geben, die sich nicht auf diese Weise bearbeiten lassen und die zusätzliche Bemerkungen erfordern.<\/p>\n Schließlich benötigen wir noch ein Datum plus Uhrzeit, um die Ausführung der Aktion zu dokumentieren – dies erledigen wir in einem Feld namens Aktionsdatum<\/b>.<\/p>\n Wenn allerdings etwa der Eingang einer Kundenmeldung über eine falsch ausgestellte Rechnung zwei Aktionen nach sich zieht, von denen die eine etwa den Aktionstyp „Neuausstellung Rechnung: Mail an Kunde“ und die andere den Aktionstyp „Neuausstellung Rechnung: Mail an Buchhaltung“ enthält, dann brauchen wir noch eine einfache Möglichkeit, um diese beiden Aktionen in einem Rutsch in die Tabelle der Aktionen einzutragen und auszuführen. <\/p>\n Und müsste diese Tabelle dann per m:n-Beziehung mit der Tabelle tblAktionstypen<\/b> verknüpft sein, weil sich jeder der Aktionstypen theoretisch mit jeder Gruppe von Aktionen kombinieren lassen müsste Der erste Gedanke sagt ja, aber wenn jeder Aktionstyp auch etwa eine eigene Mailvorlage mit Betreff und Inhalt vorhält, werden die Datensätze der Tabelle tblAktionstypen <\/b>dann nicht so individuell, dass diese kaum mehreren Aktionsgruppen zugeordnet werden können<\/p>\n Wie auch immer: Es kann ja nicht schaden, hier eine m:n-Beziehung einzurichten statt einer 1:n-Beziehung zwischen den Tabellen tblAktionstypen <\/b>und einer weiteren Tabelle zur Gruppierung von Aktionstypen, die wir – dieser Name kristallisiert sich nun heraus – tblAktionsgruppen <\/b>nennen wollen.<\/p>\n … zwar erst in der nächsten Ausgabe, aber der Beitrag Ticketsystem, Teil IV <\/b>steht Ihnen bereits mit Erscheinen der vorliegenden Ausgabe als Download zur Verfügung: www.access-im-unternehmen.de\/1076<\/b>.<\/p>\n Enthaltene Beispieldateien:<\/p>\n Ticketsystem.accdb<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2017_01\/pic_1075_002.png\")
<\/p>\n![\"Letzter](\"..\/fileadmin\/_temp_\/2017_01\/pic_1075_003.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2017_01\/pic_1075_004.png\")
<\/p>\nUnterformular sfmTickets einrichten<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2017_01\/pic_1075_005.png\")
<\/p>\nFilter für die Ticketübersicht steuern<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2017_01\/pic_1075_006.png\")
<\/p>\nDim <\/span>objFastFilter As <\/span>clsFastFilter\r\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objFastFilter = New<\/span> clsFastFilter\r\n With<\/span> objFastFilter\r\n Set<\/span> .Subform = Me!sfmTickets.Form\r\n Set<\/span> .FastFilterButton = Me!cmdNachFeldFiltern\r\n Set<\/span> .FastFilterContainsButton = Me!cmdNachInhaltFiltern\r\n Set<\/span> .CombineFilterCheckbox = Me!chkFilterkriterienVerknuepfen\r\n Set<\/span> .ANDOrOROptiongroup = Me!ogrVerknuepfenMit\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nSELECT KundeID, [Nachname] & \", \" & [Vorname] AS Kunde FROM tblKunden;<\/pre>\n
![\"Eintragen](\"..\/fileadmin\/_temp_\/2017_01\/pic_1075_007.png\")
<\/p>\nPrivate Function <\/span>LookupSearchstring(cbo As <\/span>ComboBox, strValue As String<\/span>) As String<\/span>\r\n ...\r\n If <\/span>Len<\/span>(cbo.Tag) = 0 Then<\/span>\r\n strFieldCriteria = rst.Fields(i).Name\r\n Else<\/span>\r\n strFieldCriteria = cbo.Tag\r\n End If<\/span>\r\n strSQL = strForeignKey & \" IN (SELECT \" & strBoundColumn & \" FROM \" _\r\n & strBoundTable & \" WHERE \" & strFieldCriteria & \" LIKE ''\" & strValue & \"'')\"\r\n LookupSearchstring = strSQL\r\nEnd Function<\/span><\/pre>\nKundeID IN (SELECT KundeID FROM tblKunden \r\nWHERE Nachname & \", \" & Vorname LIKE ''*M*'')<\/pre>\n
Steuerelemente zum Bearbeiten der Tickets<\/h2>\n
![\"Schaltflächen](\"..\/fileadmin\/_temp_\/2017_01\/pic_1075_008.png\")
<\/p>\nLöschen eines Tickets<\/h2>\n
Private Sub <\/span>cmdLoeschen_Click()\r\n If <\/span>Not<\/span> IsNull(Me!sfmTickets.Form!TicketID) Then<\/span>\r\n If <\/span>MsgBox<\/span>(\"Ticket löschen\", vbYesNo) = vbYes Then<\/span>\r\n Me!sfmTickets.SetFocus\r\n RunCommand acCmdDeleteRecord\r\n End If<\/span>\r\n Else<\/span>\r\n MsgBox<\/span> \"Bitte markieren Sie zunächst den zu löschenden Eintrag.\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Ticketübersicht](\"..\/fileadmin\/_temp_\/2017_01\/pic_1075_009.png\")
<\/p>\nBearbeiten eines Tickets<\/h2>\n
Private Sub <\/span>cmdBearbeiten_Click()\r\n DoCmd.OpenForm \"frmTicket\", WhereCondition:= \"TicketID = \" & Me!sfmTickets.Form!TicketID\r\nEnd Sub<\/span><\/pre>\nTicketID = 123<\/pre>\n
Das Detailformular frmTicket<\/h2>\n
![\"Erster](\"..\/fileadmin\/_temp_\/2017_01\/pic_1075_010.png\")
<\/p>\nPrivate Sub <\/span>cmdOK_Click()\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\nAnzeigen der zugrunde liegenden E-Mail<\/h2>\n
![\"Neue](\"..\/fileadmin\/_temp_\/2017_01\/pic_1075_011.png\")
<\/p>\nPrivate Sub <\/span>cmdAnfrageOeffnen_Click()\r\n Dim <\/span>strEntryID As String<\/span>\r\n Dim <\/span>objNamespace As <\/span>Outlook.NameSpace\r\n Dim <\/span>objMailItem As <\/span>Outlook.MailItem\r\n strEntryID = DLookup(\"EntryID\", \"tblMailItems\", \"MailitemID = \" & Me!MailitemID)\r\n Set<\/span> objNamespace = GetMAPI\r\n Set<\/span> objMailItem = objNamespace.GetItemFromID(strEntryID)\r\n objMailItem.Display\r\nEnd Sub<\/span><\/pre>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2017_01\/pic_1075_012.png\")
<\/p>\nTicket erstellt – was nun<\/h2>\n
Kategorisieren von Anfragen<\/h2>\n
\n
Mögliche Aktionen auf Kundenanfragen<\/h2>\n
\n
Speichern der Aktionstypen in der Tabelle tblAktionen<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2017_01\/pic_1075_013.png\")
<\/p>\nFortsetzung folgt …<\/h2>\n
Downloads zu diesem Beitrag<\/h3>\n