<\/p>\n
In den Beiträgen „Benutzerverwaltung mit verschlüsselten Kennwörtern“ und „Berechtigungen per HTML verwalten“ haben wir die Voraussetzungen für eine Benutzerverwaltung geschaffen. Im vorliegenden Beitrag bauen wir darauf auf und legen ein Anmeldeformular an, mit dem der Benutzer sich an der Anwendung anmelden kann. Außerdem stellen wir die Funktion vor, mit der wir aus den Tabellen zur Verwaltung der Berechtigungen aufgrund des Benutzernamens die Berechtigung an einer bestimmten Tabelle ermitteln.<\/b><\/p>\n
In den Beiträgen Benutzerverwaltung mit verschlüsselten Kennwörtern <\/b>(www.access-im-unternehmen.de\/1190<\/b>) und Berechtigungen per HTML verwalten <\/b>(www.access-im-unternehmen.de\/1191<\/b>) haben wir das Datenmodell und die Formulare zur Verwaltung unseres Berechtigungssystems vorbereitet.<\/p>\n
Daraus ist das Datenmodell aus Bild 1 entstanden, auf dem dieser Beitrag aufbaut. Für die Anmeldung an der Anwendung benötigen wir lediglich die Tabelle tblBenutzer<\/b>. Wir erstellen dazu ein Formular, mit dem der Benutzer seinen Benutzernamen sowie das Kennwort eingeben kann und das dann prüft, ob die Daten mit den gespeicherten Daten übereinstimmen. Falls nicht, kann der Benutzer sich bei Bedarf ein neues Kennwort zusenden lassen beziehungsweise dieses ändern. Im zweiten Teil verwenden Sie die Daten der aktuellen Anmeldung dann dazu, um die Berechtigung für diesen Benutzer an einer bestimmten Tabelle zu ermitteln. Dazu definieren wir eine passende VBA-Funktion. Hier kommen dann alle Tabellen der Berechtigungsverwaltung zum Einsatz.<\/p>\n
![\"Datenmodell](\"..\/fileadmin\/_temp_\/2019_03\/pic_1192_001.png\")
<\/p>\n
Bild 1: Datenmodell der Berechtigungsverwaltung<\/span><\/b><\/p>\n Im ersten Teil programmieren wir das Anmeldeformular. Das sollte normalerweise schnell zu erledigen sein, aber in der Tat kann man ein solches Formular beliebig kompliziert gestalten. In unserem Fall wollen wir damit starten, zwei Textfelder zur Eingabe von Benutzername und Kennwort bereitzustellen sowie eine Schaltfläche zum Bestätigen der Eingabe und eine zum Beenden der Anmeldung, die dann auch die Anwendung schließt. Der Entwurf sieht also im ersten Anlauf etwa wie in Bild 2 aus.<\/p>\n Bild 2: Entwurf des Anmeldeformulars<\/span><\/b><\/p>\n Das Formular enthält nun neben dem Bezeichnungsfeld mit dem Text Anmeldung <\/b>die folgenden Steuer-elemente:<\/p>\n Für das Textfeld txtKennwort<\/b> legen wir das Eingabeformat Kennwort <\/b>fest. Dazu klicken Sie rechts in der Eigenschaft Eingabeformat <\/b>für dieses Textfeld auf die Schaltfläche mit den drei Punkten (…<\/b>). Es erscheint der Dialog Eingabeformat-Assistent<\/b>, wo Sie das Eingabeformat Kennwort auswählen (siehe Bild 3).<\/p>\n Bild 3: Einstellen des Eingabeformats<\/span><\/b><\/p>\n Anschließend wird die Eingabe des Textes im Textfeld txtKennwort <\/b>durch Sternchen maskiert (siehe Bild 4). An dieser Stelle legen wir für die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Bildlaufleisten <\/b>und Trennlinien <\/b>den Wert Nein <\/b>und für Automatisch zentrieren <\/b>den Wert Ja <\/b>fest, damit die entsprechenden Elemente nicht mehr erscheinen beziehungsweise das Anmeldeformular in der Mitte des Access-Fensters angezeigt wird.<\/p>\n Bild 4: Verbergen der Kennworteingabe<\/span><\/b><\/p>\n Wenn der Benutzer auf die Schaltfläche cmdAnmelden <\/b>klickt, soll eine Prozedur prüfen, ob Benutzername und Kennwort zusammengehören. Diese gestalten wir erst einmal so einfach wie möglich. Die Ereignisprozedur soll erst einmal prüfen, ob Benutzername und Kennwort zusammenpassen und in diesem Fall ein Meldungsfenster mit dem Ergebnis anzeigen. Das Gleiche soll geschehen, wenn die Kombination aus Benutzername und Kennwort nicht in der Tabelle tblBenutzer <\/b>gespeichert ist:<\/p>\n Die Funktion AnmeldungPruefen <\/b>finden Sie in Listing 1. Die Funktion berücksichtigt, dass wir die Kennwörter nicht im Klartext im Feld Kennwort <\/b>der Tabelle tblBenutzer <\/b>speichern, sondern in verschlüsselter Form. Sie nimmt die zu untersuchende Kombination von Benutzername und Kennwort in Form der beiden Parameter strBenutzername <\/b>und strKennwort <\/b>entgegen. Dann erstellt sie eine neue Instanz der Klasse clsCrypt<\/b>, die unter anderem eine Methode zum Verschlüsseln mit dem SHA1<\/b>-Algorithmus bereitstellt. Diese Methode verschlüsselt dann das Kennwort aus strKennwort<\/b>. Das Ergebnis landet in der Variablen strVerschluesselt<\/b>.<\/p>\n Listing 1: Funktion zum Prüfen einer Anmeldung<\/span><\/b><\/p>\n Damit können wir dann über den Aufruf einer DLookup<\/b>-Funktion prüfen, ob die Kombination aus Benutzername und SHA1<\/b>-verschlüsseltem Kennwort in der Tabelle tblBenutzer <\/b>vorkommt. Ist dies der Fall, liefert die Funktion AnmeldungPruefen <\/b>den Wert True <\/b>zurück, anderenfalls den Wert False<\/b>.<\/p>\n Was soll nach der Anmeldung geschehen Als Erstes sollte der Anmeldedialog geschlossen werden. Dann speichern wir den Benutzernamen des angemeldeten Benutzers in irgendeiner Form. Aber welche ist die geeignete Form – eine öffentliche Variable Nein, denn wir wollen später im Beitrag Zugriffsrechte mit Datenmakros<\/b> (www.access-im-unternehmen.de\/1193<\/b>) auch auf diese Information zugreifen.<\/p>\n Das ist dort am einfachsten möglich über eine in der TempVars<\/b>-Auflistung gespeicherte Variable.<\/p>\n Also ersetzen wir die MsgBox<\/b>-Anweisung in der Prozedur cmdAnmelden_Click <\/b>durch die folgenden beiden Zeilen:<\/p>\n Danach können wir wie folgt auf den Wert der temporären Variablen zugreifen:<\/p>\n Wenn die Anmeldung fehlschlägt, soll die temporäre Variable übrigens wieder geleert werden:<\/p>\n Wenn der Benutzer nicht die richtigen Daten eingibt, erscheint aktuell jeweils die Meldung mit dem Text Anmeldung nicht erfolgreich<\/b>. Hier könnten wir nun beispielsweise prüfen, ob ein Benutzer mehrfach versucht, sich mit dem gleichen Benutzernamen anzumelden und dabei immer wieder das falsche Kennwort eingibt.<\/p>\n Ist das der Fall, könnte man verschiedene Aktionen durchführen – beispielsweise die Zeit zwischen den möglichen Anmeldeversuchen schrittweise vergrößern, um zu verhindern, dass jemand automatisiert versucht, das Kennwort für den Benutzernamen zu ermitteln.<\/p>\n Hier wird es schon interessant, denn diese Informationen müssen wir ebenfalls speichern, um beim nächsten Anmeldeversuch wieder darauf zugreifen zu können. Zunächst legen wir fest, wieviel Zeit zwischen zwei Anmeldeversuchen verstreichen soll.<\/p>\n Wir beginnen ganz entspannt und legen fest, dass zwischen den ersten und dem zweiten Versuch eine Sekunde verstreichen soll. Das merkt der Benutzer gar nicht, da die Eingabe des Kennworts ja mindestens eine Sekunde dauern sollte.<\/p>\n Von nun an verdoppeln wir die Zeit mit jedem Versuch. Nach dem zweiten Versuch muss er also zwei Sekunden warten, nach dem dritten Versuch vier Sekunden und so weiter. So wächst die Wartezeit zwischen zwei Anmeldeversuchen schnell an.<\/p>\n Welche Informationen müssen wir dazu speichern Wir benötigen den Benutzernamen, denn die Anmeldungen sollen nur für Versuche mit dem gleichen Benutzernamen gezählt werden. Dann benötigen wir die Anzahl der Versuche seit der letzten erfolgreichen Anmeldung und den Zeitpunkt des letzten erfolglosen Versuchs.<\/p>\n Diese Informationen können wir am besten direkt in der Benutzertabelle speichern, da diese ja ohnehin bereits für jeden Benutzer einen Datensatz enthält. Also fügen wir die folgenden Felder wie in Bild 5 hinzu:<\/p>\n Bild 5: Neue Felder in der Tabelle tblBenutzer<\/span><\/b><\/p>\n Die Daten dieser drei Felder ändern wir bei jedem fehlgeschlagenen und auch bei jedem erfolgreichen Anmeldeversuch. Bei einem erfolgreichen Anmeldeversuch tragen wir Datum und Zeit dieses Versuchs in das Feld LetzteErfolgreicheAnmeldung <\/b>ein und stellen den Wert des Feldes AnzahlFehlgeschlageneAnmeldungen <\/b>auf 0 <\/b>ein.<\/p>\n Bei einem gescheiterten Anmeldeversuch stellen wir das Feld LetzteFehlgeschlageneAnmeldung <\/b>auf das aktuelle Datum plus Uhrzeit ein und erhöhen den Wert des Feldes AnzahlFehlgeschlageneAnmeldungen <\/b>um 1<\/b>.<\/p>\n Auf diese Weise können wir allerdings nur Anmeldeversuche behandeln, für die ein gültiger Benutzername angegeben wurde. Wenn kein Benutzername angegeben wurde, können wir auch keine Informationen über die letzte Anmeldung des Benutzers in der Tabelle tblBenutzer <\/b>speichern. Wie gehen wir dann vor Ignorieren wir Anmeldeversuche ohne gültigen Benutzernamen, weil der Benutzer – auch wenn er böse Absichten hat – ohne Kenntnis eines gültigen Benutzernamens noch weiter von einer erfolgreichen Anmeldung entfernt ist als mit Benutzername Oder sollten wir auch hier eine zeitliche Barriere einführen Wir wollen es einfach halten und ignorieren Anmeldungen ohne gültigen Benutzernamen einfach.<\/p>\n Die Funktion AnmeldungPruefen <\/b>ändern wir wie in Listing 2. Wir haben statt der DLookup<\/b>-Funktion direkt den Zugriff auf den Datensatz der Tabelle tblBenutzer <\/b>mit dem passenden Benutzernamen als Recordset implementiert. Das heißt, dass wir nach dem Ermitteln des verschlüsselten Kennworts ein Recordset öffnen, das den Datensatz der Tabelle tblBenutzer <\/b>mit dem Benutzernamen aus dem Parameter strBenutzername <\/b>enthält. Ist dieses Recordset leer, hat der Benutzer einen ungültigen Benutzernamen eingegeben und die Funktion soll den Wert False <\/b>zurückliefern. Ist das Recordset nicht leer, hat der Benutzer zumindest einen gültigen Benutzernamen angegeben.<\/p>\n <\/p>\n Listing 2: Funktion zum Prüfen einer Anmeldung, erweiterte Fassung<\/span><\/b><\/p>\n Dann prüfen wir in einer If…Then<\/b>-Bedingung, ob das verschlüsselte Kennwort aus strVerschluesselt <\/b>mit der im Feld Kennwort <\/b>gespeicherten, verschlüsselten Version des Kennworts für diesen Benutzer übereinstimmt. In diesem Fall versetzen wir das Recordset mit der Edit<\/b>-Methode in den Verarbeitungsmodus und stellen zwei Felder auf neue Werte ein. Das Feld LetzteErfolgreicheAnmeldung <\/b>erhält mit der Funktion Now <\/b>das aktuelle Datum plus Uhrzeit, das Feld AnzahlFehlgeschlageneAnmeldungen <\/b>stellen wir auf den Wert 0 <\/b>ein. Danach speichern wir den aktualisierten Datensatz mit der Update<\/b>-Methode und geben den Wert True <\/b>als Funktionswert zurück.<\/p>\n Stimmt das verschlüsselte Kennwort nicht mit dem Wert aus dem Feld Kennwort <\/b>überein, bearbeiten wir den aktuellen Datensatz ebenfalls. Hier legen wir den Wert des Feldes LetzteFehlgeschlageneAnmeldung <\/b>auf das Ergebnis der Funktion Now <\/b>fest und erhöhen den Wert des Feldes AnzahlFehlgeschlageneAnmeldungen <\/b>auf den vorherigen Wert plus 1<\/b>. Falls das Feld vorher noch leer war, erhält das Feld den Wert 1<\/b>. In diesem Fall geben wir den Wert False <\/b>als Funktionsergebnis zurück.<\/p>\n Der entsprechende Datensatz sieht nach drei fehlgeschlagenen Anmeldungen und ohne erfolgreiche Anmeldung beispielsweise wie in Bild 6 aus.<\/p>\n Bild 6: Speichern fehlgeschlagener Anmeldungen<\/span><\/b><\/p>\n Nun müssen wir noch dafür sorgen, dass das Formular frmAnmeldung <\/b>beim Versuch, sich unter einem Benutzernamen anzumelden, für den es seit der letzten erfolgreichen Anmeldung einen oder mehrere fehlgeschlagene Anmeldungen gab, eine zeitliche Sperre einrichtet und den Benutzer auch darüber informiert.<\/p>\n Was wir dafür zweifelsohne benötigen, ist die Ereignisprozedur Bei Zeitgeber <\/b>sowie ein entsprechendes Intervall für die Eigenschaft Zeitgeberintervall<\/b>, das angibt, nach welchem Zeitraum das Ereignis Bei Zeitgeber <\/b>das nächste Mal ausgelöst werden soll. Die Eigenschaft Zeitgeberintervall <\/b>statten wir mit dem Zeitraum über eine Sekunde aus, was dem Wert 1.000 <\/b>(in Millisekunden) entspricht.<\/p>\n Wie genau soll die Anzeige der Zeitverzögerung nach mehreren fehlgeschlagenen Anmeldeversuchen mit gültigem Benutzernamen, aber mit falschem Kennwort erfolgen Wir müssen als Erstes prüfen, ob das Textfeld txtBenutzername <\/b>überhaupt einen gültigen Benutzernamen anzeigt.<\/p>\n Nur dann können wir aus der Tabelle tblBenutzer <\/b>die Werte der Felder LetzteFehlgeschlageneAnmeldung<\/b> und AnzahlFehlgeschlageneAnmeldungen<\/b> für diesen Benutzer ermitteln. Danach können wir prüfen, wie lange nach dem letzten Anmeldeversuch ein erneuter Versuch noch unterbunden werden soll.<\/p>\n Dann ermitteln wir, bis zu welchem Zeitpunkt ausgehend von der letzten fehlgeschlagenen Anmeldung und der Anzahl der fehlgeschlagenen Anmeldungen eine weitere Anmeldung unter diesem Benutzernamen unterbunden werden soll.<\/p>\n Theoretisch müssten wir also immer wieder auf die Daten der Tabelle tblBenutzer <\/b>zugreifen – wenn wir das in der Ereignisprozedur Form_Timer <\/b>erledigen, sogar jede Sekunde. Das ist sicher ein wenig übertrieben.<\/p>\n Wie aber können wir die Anzahl der Zugriffe verringern – vor allem, weil wir ja die Daten zum Zeitpunkt der letzten gescheiterten Anmeldung und die Anzahl der gescheiterten Anmeldungen seit der letzten erfolgreichen Anmeldung bei jedem Aufruf von Form_Timer <\/b>benötigen<\/p>\n Ein Ansatz ist, das Recordset immer dann neu zu laden, wenn der Benutzer einen neuen Benutzernamen in das Formular frmAnmeldung <\/b>eingegeben hat. Das könnten wir so erledigen, dass wir einmalig beim Öffnen des Formulars alle Benutzernamen in eine Collection oder ein ähnliches Objekt einlesen und dann bei der Eingabe eines Benutzernamens in das Textfeld txtBenutzername <\/b>prüfen, ob der Benutzername in der Tabelle tblBenutzer <\/b>enthalten ist.<\/p>\n Eine mögliche Collection-Art für diesen Zweck ist das Dictionary<\/b>-Objekt. In diesem können wir den Namen des Benutzers als Schlüssel speichern und auch schnell prüfen, ob es einen Eintrag mit dem gesuchten Benutzernamen gibt. Um das Dictionary<\/b>-Objekt mit Early Binding nutzen und damit auf IntelliSense zugreifen zu können, fügen Sie einen Verweis auf die Bibliothek Microsoft Scripting Runtime <\/b>wie in Bild 7 zum VBA-Projekt der Anwendung hinzu.<\/p>\n Bild 7: Verweis auf die Bibliothek Microsoft Scripting Runtime<\/span><\/b><\/p>\n Für unseren Einsatzzweck benötigen wir drei Variablen, die wir im Kopf des Klassenmoduls des Formulars frmAnmeldung <\/b>anlegen:<\/p>\n Die erste soll das Recordset mit dem Datensatz der Tabelle tblBenutzer <\/b>aufnehmen, wenn der Benutzer einen gültigen Benutzernamen in das Textfeld txtBenutzername <\/b>eingegeben hat. Den Benutzernamen speichern wir nach der Eingabe in der Variablen strBenutzername<\/b>. Und das Dictionary<\/b>-Objekt, das alle Benutzernamen der Tabelle tblBenutzer <\/b>aufnehmen soll, nennen wir dicBenutzer<\/b>.<\/p>\n Wenn das Formular frmAnmeldung <\/b>geöffnet wird, wollen wir alle Benutzernamen aus der Tabelle tblBenutzer <\/b>in das Dictionary dicBenutzer <\/b>schreiben. Das erledigen wir in der Ereignisprozedur, die durch das Ereignis Beim Laden <\/b>ausgelöst wird. Dazu instanzieren wir zunächst das Objekt dicBenutzer <\/b>als neues Dictionary<\/b>-Objekt. Der Database<\/b>-Variablen db <\/b>weisen wir die aktuelle Datenbank zu, dem Recordset<\/b>-Objekt rst <\/b>alle Datensätze der Tabelle tblBenutzer <\/b>– allerdings benötigen wir davon nur den Inhalt des Feldes Benutzername<\/b>. In einer Do While<\/b>-Schleife über alle Datensätze durchlaufen wir dann das Recordset rst <\/b>und weisen den Inhalt des Feldes Benutzername <\/b>für alle Datensätze mit der Add<\/b>-Methode als neuen Eintrag zum Dictionary<\/b>-Objekt hinzu.<\/p>\n Dabei geben wir den Benutzernamen sowohl als Schlüssel als auch als Wert des neuen Eintrags an. Wichtig ist hier, dass wir nicht nur rst!Benutzername <\/b>angeben, sondern rst!Benutzername.Value <\/b>– sonst fügt die Prozedur nicht den Wert, sondern den Verweis auf das Feld des Recordsets zum Dictionary<\/b>-Objekt hinzu. Und das würde dann direkt beim zweiten Durchlauf der Do While<\/b>-Schleife zum Fehler führen, weil der Verweis ja schon im ersten Durchlauf hinzugefügt wurde und der Schlüssel eindeutig sein muss:<\/p>\n Nun wollen wir immer dann, wenn der Benutzername sich ändert, prüfen, ob der Benutzer gerade einen gültigen Benutzernamen eingegeben hat. Das erledigen wir in der Ereignisprozedur, die durch das Ereignis Beim Ändern <\/b>des Textfeldes txtBenutzername <\/b>ausgelöst wird. Diese sieht wie in Listing 3 aus und überträgt zunächst den aktuell eingegebenen Wert im Textfeld txtBenutzer <\/b>in die Variable strBenutzer<\/b>. Dann prüft sie, ob das Dictionary<\/b>-Objekt dicBenutzer <\/b>einen Eintrag enthält, dessen Schlüssel den Wert aus strBenutzer <\/b>aufweist. Ist das der Fall, füllt die Prozedur die Recordset<\/b>-Variable rstBenutzer <\/b>mit dem Eintrag der Tabelle tblBenutzer<\/b>, dessen Benutzername mit dem Wert aus strBenutzername <\/b>übereinstimmt. Da wir die Recordset<\/b>-Variable im allgemeinen Teil des Klassenmoduls deklariert haben, können wir nun von allen Prozeduren des Klassenmoduls aus darauf zugreifen.<\/p>\n Listing 3: Ereignisprozedur Bei Änderung des Textfeldes txtBenutzername<\/span><\/b><\/p>\n Damit kommen wir zu der Ereignisprozedur, die durch das Ereignis Bei Zeitgeber <\/b>des Formulars ausgelöst werden soll und mit dem wir prüfen wollen, ob die Anmeldung für den in txtBenutzername<\/b> angegebenen Benutzer unterbunden werden muss, weil zu viele fehlgeschlagene Anmeldungen vorliegen. Die Prozedur finden Sie in Listing 4. Sie stellt zunächst die Eigenschaft Painting <\/b>des Formulars auf den Wert False<\/b>, um unnötiges Flackern des Formulars zu verhindern.<\/p>\n Listing 4: Ereignisprozedur Bei Zeitgeber<\/span><\/b><\/p>\n Dann prüft sie, ob rstBenutzer <\/b>überhaupt schon gefüllt wurde, was ja erst geschieht, wenn der Benutzer einen gültigen Benutzernamen in das Textfeld txtBenutzername <\/b>eingegeben hat. Ist das nicht der Fall, wird die Prozedur gleich wieder verlassen. Anderenfalls prüft die Prozedur, ob das Recordset einen Datensatz enthält. Das ist wiederum der Fall, wenn txtBenutzername <\/b>einen gültigen Benutzernamen enthält. Ist auch das nicht der Fall, sollen die eventuell zuvor deaktivierten Steuer-elemente lblNaechsteAnmeldung<\/b>, txtKennwort <\/b>und cmdAnmelden <\/b>wieder aktiviert werden.<\/p>\n Das Bezeichnungsfeld lblNaechsteAnmeldung<\/b> hatten wir noch gar nicht erwähnt – wir fügen es wie in Bild 8 im Formular frmAnmeldung <\/b>ein. Es dient der Ausgabe der Zeit bis zum nächsten Anmeldeversuch mit diesem Benutzernamen. Es soll nur eingeblendet werden, wenn ein gültiger Benutzername eingegeben wurde und der Benutzer so oft falsche Kennwörter eingegeben hat, dass die Eingabe bis zum nächsten Versuch gesperrt wird.<\/p>\n Bild 8: Anmeldedialog mit Hinweistext im Entwurf<\/span><\/b><\/p>\n Das geschieht nur, wenn die If…Then<\/b>-Bedingung das Ergebnis wahr liefert. In diesem Fall ermittelt die Prozedur für die Variable lngSekunden <\/b>die Anzahl der Sekunden, die bis zum nächsten Anmeldeversuch verstreichen müssen. Dazu verwenden wir zwei verschachtelte DateDiff<\/b>– und DateAdd<\/b>-Funktionen. Die innere DateAdd<\/b>-Funktion soll dem Wert des Feldes LetzteFehlgeschlageneAnmeldung <\/b>eine Anzahl von Sekunden hinzufügen, welche der Menge der fehlgeschlagenen Anmeldungen entspricht. Diese ermitteln wir über eine Potenz, deren Basis der Wert 2 <\/b>und deren Exponent der Anzahl der fehlgeschlagenen Anmeldungen aus dem Feld AnzahlFehlgeschlageneAnmeldungen <\/b>entspricht.<\/p>\n Die äußere DateDiff<\/b>-Funktion ermittelt die Differenz der Sekunden zwischen dem aktuellen Datum und dem Datum beziehungsweise Uhrzeit, an dem der nächste Anmeldeversuch möglich ist. Ist der Wert aus lngSekunden <\/b>größer 0<\/b>, ist eine Wartezeit vorhanden und der Benutzer muss die ermittelte Anzahl Sekunden bis zum nächsten Anmeldeversuch warten. Deshalb blenden wir das Bezeichnungsfeld lblNaechsteAnmeldung <\/b>ein und stellen die Beschriftung über die Eigenschaft Caption <\/b>auf einen Text wie in Bild 9 ein. Außerdem werden, wie ebenfalls in der Abbildung zu erkennen, die Steuer-elemente txtKennwort <\/b>und cmdAnmelden <\/b>deaktiviert.<\/p>\n Bild 9: Anmeldedialog mit Hinweistext<\/span><\/b><\/p>\n Das Steuer-element cmdAbbrechen <\/b>bleibt aktiviert, damit der Benutzer die Anmeldung abbrechen und somit auch die Anwendung beenden kann. Das Textfeld txtBenutzername <\/b>bleibt aktiviert, damit der Benutzer einen anderen Benutzernamen eingeben kann.<\/p>\n Wenn lngSekunden <\/b>kleiner oder gleich 0 <\/b>ist, kann der Benutzer gleich den nächsten Anmeldeversuch starten. Dazu blenden wir das Bezeichnungsfeld lblNaechsteAnmeldung <\/b>wieder aus und aktivieren die beiden Steuer-elemente cmdAnmelden <\/b>und txtKennwort <\/b>wieder (siehe Bild 10). Am Ende der Prozedur stellen wir die Eigenschaft Painting <\/b>wieder auf den Wert True <\/b>ein, damit die vorgenommenen Änderungen am Formular sichtbar werden.<\/p>\n Bild 10: Anmeldedialog, bereits zur Anmeldung<\/span><\/b><\/p>\n Wir benötigen noch eine Funktion, mit der wir herausfinden, ob ein bestimmter Benutzer Zugriff auf eine bestimmte Tabelle hat – und mit welchen Berechtigungen er auf die Tabelle zugreift. Dazu ziehen wir das Datenmodell von weiter oben heran und stellen eine Abfrage zusammen, die alle relevanten Tabellen enthält. Diese Abfrage speichern wir unter dem Namen qryBenutzerBerechtigungen<\/b>. Sie sieht im Entwurf wie in Bild 11 aus.<\/p>\n Bild 11: Entwurf der Abfrage qryBenutzerBerechtigungen zum Ermitteln der Berechtigungen eines Benutzers an einer Tabelle<\/span><\/b><\/p>\n Wechseln wir in die Datenblattansicht, erhalten wir ein Ergebnis wie in Bild 12. Wir werden allerdings nie mit der Datenblattansicht arbeiten, sondern eine Funktion erstellen, der wir die wichtigen Informationen wie den Benutzer und die Tabelle übergeben und die uns dann die Berechtigungen für den Benutzer an der Tabelle zurückliefert.<\/p>\n Bild 12: Datenblattansicht der Abfrage qryBenutzerBerechtigungen<\/span><\/b><\/p>\n Diese Funktion heißt BenutzerBerechtigungen<\/b> und Sie finden diese in Listing 5. Die Funktion erwartet den Primärschlüsselwert für den Benutzer sowie den Namen der zu untersuchenden Tabelle als Parameter. Sie liefert einen Integer<\/b>-Wert zurück, der die Berechtigungen für den angegebenen Benutzer an dieser Tabelle repräsentiert.<\/p>\nAnmeldeformular programmieren<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2019_03\/pic_1192_002.png\")
<\/p>\n\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2019_03\/pic_1192_003.png\")
<\/p>\n![\"Verbergen](\"..\/fileadmin\/_temp_\/2019_03\/pic_1192_004.png\")
<\/p>\nPrüfen von Benutzername und Kennwort<\/h2>\n
Private Sub <\/span>cmdAnmelden_Click()\r\n If AnmeldungPruefen(Me!txtBenutzername, _\r\n Me!txtKennwort) = True<\/span> Then\r\n MsgBox<\/span> \"Anmeldung erfolgreich.\"\r\n Else<\/span>\r\n MsgBox<\/span> \"Anmeldung nicht erfolgreich.\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>AnmeldungPruefen(strBenutzername As String<\/span>, strKennwort As String<\/span>)\r\n Dim <\/span>objCrypt As <\/span>clsCrypt\r\n Dim <\/span>strVerschluesselt As String<\/span>\r\n Set<\/span> objCrypt = New<\/span> clsCrypt\r\n strVerschluesselt = objCrypt.GetSHA1(strKennwort)\r\n If Not<\/span> IsNull(DLookup(\"BenutzerID\", \"tblBenutzer\", \"Benutzername = ''\" & strBenutzername & \"'' AND Kennwort = ''\" _\r\n & strVerschluesselt & \"''\")) Then\r\n AnmeldungPruefen = True<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nNach der Anmeldung<\/h2>\n
If <\/span>AnmeldungPruefen(Me!txtBenutzername, Me!txtKennwort) = True<\/span> Then<\/span>\r\n TempVars.Add \"Benutzername\", Me!txtBenutzername.Value\r\n DoCmd.Close acForm, Me.Name\r\nElse<\/span><\/pre>\nDebug.Print<\/span> TempVars!Benutzername\r\nPeter Gross<\/pre>\nTempVars.Remove \"Benutzername\"<\/pre>\n
Bei nicht erfolgreicher Anmeldung<\/h2>\n
![\"Neue](\"..\/fileadmin\/_temp_\/2019_03\/pic_1192_005.png\")
<\/p>\n\n
Integration der Wartezeit in den Anmeldedialog<\/h2>\n
Public Function <\/span>AnmeldungPruefen(strBenutzername As String<\/span>, strKennwort As String<\/span>)\r\n Dim <\/span>objCrypt As <\/span>clsCrypt\r\n Dim <\/span>strVerschluesselt As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> objCrypt = New<\/span> clsCrypt\r\n strVerschluesselt = objCrypt.GetSHA1(strKennwort)\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblBenutzer WHERE Benutzername = ''\" & strBenutzername & \"''\", dbOpenDynaset)\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n If <\/span>strVerschluesselt = rst!Kennwort Then<\/span>\r\n rst.Edit\r\n rst!LetzteErfolgreicheAnmeldung = Now\r\n rst!AnzahlFehlgeschlageneAnmeldungen = 0\r\n rst.Update\r\n AnmeldungPruefen = True<\/span>\r\n Else<\/span>\r\n rst.Edit\r\n rst!LetzteFehlgeschlageneAnmeldung = Now\r\n rst!AnzahlFehlgeschlageneAnmeldungen = Nz(rst!AnzahlFehlgeschlageneAnmeldungen, 0) + 1\r\n rst.Update\r\n AnmeldungPruefen = False<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n AnmeldungPruefen = False<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Speichern](\"..\/fileadmin\/_temp_\/2019_03\/pic_1192_006.png\")
<\/p>\nZeitverzögerung beim Anmelden<\/h2>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2019_03\/pic_1192_007.png\")
<\/p>\nDim <\/span>rstBenutzer As <\/span>DAO.Recordset\r\nDim <\/span>strBenutzername As String<\/span>\r\nDim <\/span>dicBenutzer As <\/span>Dictionary<\/pre>\nDictionary beim Laden mit Benutzernamen füllen<\/h2>\n
Private Sub <\/span>Form_Load()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> dicBenutzer = New<\/span> Dictionary\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT Benutzername FROM tblBenutzer\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n dicBenutzer.Add rst!Benutzername.Value, rst!Benutzername.Value\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtBenutzername_Change()\r\n Dim <\/span>strBenutzername As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n strBenutzername = Me!txtBenutzername.Text\r\n If <\/span>dicBenutzer.Exists(strBenutzername) Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rstBenutzer = db.OpenRecordset(\"SELECT * FROM tblBenutzer WHERE Benutzername = ''\" & strBenutzername _\r\n & \"''\", dbOpenDynaset)\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDas Zeitgeber-Ereignis<\/h2>\n
Private Sub <\/span>Form_Timer()\r\n Dim <\/span>lngSekunden As Long<\/span>\r\n Me.Painting = False<\/span>\r\n If <\/span>Not<\/span> rstBenutzer Is Nothing Then<\/span>\r\n If <\/span>Not<\/span> rstBenutzer.EOF Then<\/span>\r\n lngSekunden = DateDiff(\"s\", Now, DateAdd(\"s\", 2 ^ Nz(rstBenutzer!AnzahlFehlgeschlageneAnmeldungen, 0), _\r\n Nz(rstBenutzer!LetzteFehlgeschlageneAnmeldung, Date)))\r\n If <\/span>lngSekunden > 0 Then<\/span>\r\n With<\/span> Me!lblNaechsteAnmeldung\r\n .Visible = True<\/span>\r\n .Caption = \"Nächste Anmeldung in \" & lngSekunden & \" Sekunden möglich.\"\r\n End With<\/span>\r\n Me!txtKennwort.Enabled = False<\/span>\r\n Me!cmdAnmelden.Enabled = False<\/span>\r\n Else<\/span>\r\n Me!lblNaechsteAnmeldung.Visible = False<\/span>\r\n Me!txtKennwort.Enabled = True<\/span>\r\n Me!cmdAnmelden.Enabled = True<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n Me!lblNaechsteAnmeldung.Visible = False<\/span>\r\n Me!txtKennwort.Enabled = True<\/span>\r\n Me!cmdAnmelden.Enabled = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Me.Painting = True<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Anmeldedialog](\"..\/fileadmin\/_temp_\/2019_03\/pic_1192_008.png\")
<\/p>\n![\"Anmeldedialog](\"..\/fileadmin\/_temp_\/2019_03\/pic_1192_009.png\")
<\/p>\n![\"Anmeldedialog,](\"..\/fileadmin\/_temp_\/2019_03\/pic_1192_010.png\")
<\/p>\nErmitteln, ob ein Benutzer Zugriff auf eine Tabelle hat<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2019_03\/pic_1192_011.png\")
<\/p>\n![\"Datenblattansicht](\"..\/fileadmin\/_temp_\/2019_03\/pic_1192_012.png\")
<\/p>\nPublic Function <\/span>BenutzerBerechtigungen(lngBenutzerID As Long<\/span>, strTabelle As String<\/span>) As Integer<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>intBerechtigungTemp As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM qryBenutzerBerechtigungen WHERE BenutzerID = \" & lngBenutzerID _\r\n & \" AND Tabelle = ''\" & strTabelle & \"''\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n intBerechtigungTemp = intBerechtigungTemp + rst!BerechtigungID\r\n rst.Move