<\/p>\n
Bis Access 2003 unterstützte Access den Entwickler durch eine Benutzerverwaltung inklusive Sicherheitssystem. Neuere Access-Versionen bieten dies nicht mehr. Kein großes Problem: Das Sicherheitssystem war ohnehin nicht besonders effektiv, und die Benutzerverwaltung möchten Sie vielleicht ohnehin selbst gestalten. In diesem Beitrag zeigen wir, wie Sie eine solche Benutzerverwaltung selbst erstellen und einsetzen.<\/b><\/p>\n
Unsere Benutzerverwaltung dient nicht als Ersatz für die bis Access 2003 verfügbare, eingebaute Benutzerverwaltung. Das darin enthaltene Sicherheitssystem werden wir nicht übernehmen. Der Grund ist einfach: Es ist schwierig, ein Sicherheitssystem zu implementieren, wenn die Datenbank-Engine keine Möglichkeiten für die Durchsetzung der dort festgelegten Regeln bietet. Dies ist zwar im SQL Server möglich und auch unter MySQL und anderen Systemen, aber die Jet Engine von Access bietet dies nicht – zumindest nicht offiziell. Intern ist ein Teil des Sicherheitssystems zwar noch vorhanden (das merken Sie, wenn Sie versuchen, Systemtabellen von Access zu verändern), aber es wird von Microsoft offiziell nicht mehr unterstützt. Das Unternehmen verfolgt damit wohl zwei Ziele: erstens die Abkehr vom unzuverlässigen Sicherheitssystem und zweitens die Nutzung von aktiven Datenbankmanagementsystemen mit Ó“echterÓ“ Benutzerverwaltung.<\/p>\n
In diesem Beitrag lassen wir den Sicherheitsaspekt weitgehend außer Acht – zumindest insofern, dass wir den direkten Zugriff auf Tabellen nicht unterbinden. Stattdessen konzentrieren wir uns darauf, Tabellen bereitzustellen, mit denen Sie Benutzer und Benutzergruppen erfassen können. Diese sollen über entsprechende Formulare gefüllt werden. Zusätzlich gibt es noch einen Anmeldedialog, über den der Benutzer sich mit Benutzername und gegebenenfalls einem Kennwort anmeldet. Diese Anmeldedaten der aktuellen Sitzung speichern wir an geeigneter Stelle und erstellen Funktionen, die für den angemeldeten Benutzer freigegebene Features ermitteln.<\/p>\n
Einfache Variante<\/b><\/p>\n
Im einfachsten Fall reicht für die Verwaltung von Benutzern eine Benutzertabelle aus. Sie würden darin lediglich Basisinformationen wie den realen Namen des Benutzers sowie seinen Benutzernamen und gegebenenfalls ein Kennwort speichern. <\/p>\n
Was können Sie mit dieser Variante anfangen Im Prinzip alles, was Sie auch mit einer um Benutzergruppen erweiterten Version erledigen können. Allerdings wird es dann kompliziert, wenn Sie viele Benutzer verwalten und für diese etwa festlegen möchten, welcher Benutzer welche Menübefehle ausführen oder Formulare öffnen darf: Hier kommt es oft vor, dass mehrere Benutzer die gleichen Berechtigungen erhalten sollen, was bei Verwendung von Benutzergruppen deutlich vereinfacht werden kann.<\/p>\n
Wenn Sie die Benutzerverwaltung aber nur für individuelle, benutzerabhängige Aufgaben verwenden möchten, reicht eine einzige Benutzertabelle ohne Benutzerverwaltung völlig aus. Das Paradebeispiel hierfür ist das Protokollieren von Zugriffen auf und änderungen an den Daten einer Datenbank. Dies geschieht immer in Abhängigkeit vom einzelnen Benutzer und erfordert somit nicht die Angabe seiner Benutzergruppe. Die hier verwendete Tabelle sieht beispielsweise wie in Bild 1 aus. Beachten Sie, dass jeder Benutzername nur einmal vorkommen soll. Daher stellen Sie den Wert der Eigenschaft Indiziert <\/b>für das Feld Benutzername <\/b>auf den Wert Ja (Ohne Duplikate) <\/b>ein.<\/p>\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic002_opt.jpeg\")
<\/p>\n
Bild 2: Diese Tabelle speichert unter anderem den angemeldeten Benutzer.<\/span><\/b><\/p>\n Wer Informationen in Abhängigkeit vom aktuell angemeldeten Benutzer speichern möchte, muss zunächst an geeigneter Stelle festhalten, welcher Benutzer gerade angemeldet ist. Dazu sind zwei Voraussetzungen notwendig:<\/p>\n Angemeldeten Benutzer merken<\/b><\/p>\n Die Tabelle zum Speichern des aktuell angemeldeten Benutzers soll eine einfache Optionen-Tabelle sein. Diese heißt tblOptionen <\/b>und enthält die drei Felder OptionID <\/b>(Autowert), Optionsname <\/b>und Optionswert <\/b>(beides Textfelder) und sieht im Entwurf wie in Bild 2 aus.<\/p>\n Bild 1: Entwurf der Tabelle zum Speichern von Benutzern<\/span><\/b><\/p>\n Unabhängig vom Formular, das die Anmeldung des Benutzers beim Anwendungsstart entgegennimmt, schreiben wir nun eine kleine Funktion, welche den Optionswert zu einem bestimmten Optionsnamen in dieser Tabelle speichert.<\/p>\n Dazu öffnen Sie den VBA-Editor (zum Beispiel mit der Tastenkombination Alt + F11<\/b>) und wählen dort den Menübefehl Einfügen|Modul <\/b>aus. Im nun erscheinenden Codefenster fügen Sie die Prozedur aus Listing 1 ein. Die Funktion rufen Sie wie folgt auf:<\/p>\n Listing 1: Mit dieser Funktion speichern Sie Optionen in der Tabelle tblOptionen.<\/p>\n Die Funktion OptionEinstellen <\/b>deklariert und instanziert ein Objekt des Typs Database <\/b>mit einem Verweis auf die aktuelle Datenbank und verwendet dessen Execute<\/b>-Methode, um SQL-Aktualisierungsabfragen aufzurufen. Davon gibt es zwei, von denen eine auf jeden Fall, eine weitere nach Bedarf aufgerufen wird. Die erste aktualisiert alle Datensätze der Tabelle tblOptionen<\/b>, bei denen das Feld Optionsname <\/b>den mit dem Parameter strOptionsname <\/b>übergebenen Wert enthält und stellt für diese Datensätze den Inhalt von Optionswert <\/b>auf den mit strOptionswert <\/b>übergebenen Wert ein.<\/p>\n Die nachfolgende RecordAffected<\/b>-Methode prüft, ob die Anzahl der durch diese Aktionsabfrage betroffenen Datensätze gleich eins ist – dies bedeutet, dass bereits ein Datensatz für die angegebene Option vorhanden war und dieser nun neu eingestellt wurde.<\/p>\n Liefert RecordsAffected<\/b> einen anderen Wert als eins zurück, können zwei Probleme aufgetreten sein:<\/p>\n Erreicht die Prozedur die Zeile hinter der Zeile If db.RecordsAffected > 1 Then<\/b>, ist auf keinen Fall mehr ein Optionsdatensatz mit dem angegebenen Optionsnamen mehr vorhanden, wodurch dieser gleich neu angelegt werden kann – und das erledigt die folgende INSERT INTO<\/b>-Aktionsabfrage.<\/p>\n Formular zur Abfrage des Benutzers<\/b><\/p>\n Für den Moment gehen wir davon aus, das ein Formular zur Verwaltung von Benutzern vorhanden ist und dass bereits einige Benutzerdatensätze in der Tabelle tblBenutzer <\/b>vorliegen (siehe Bild 3).<\/p>\n Bild 3: Die Tabelle tblBenutzer mit einigen Beispieldaten<\/span><\/b><\/p>\n Darauf bauen wir nun ein Formular auf, dass als Anmeldeformular der Anwendung dienen soll. Das Formular soll im Wesentlichen zwei Textfelder zur Eingabe von Benutzername und Kennwort sowie eine Schaltfläche zum Abschließen der Eingabe enthalten. Das erste Textfeld heißt txtBenutzername<\/b>, das zweite txtKennwort<\/b>. Die Schaltfläche zum Abschließen der Eingabe heißt cmdLogin<\/b>, und außerdem benötigen wir noch eine Schaltfläche zum Abbrechen des Logins namens cmdAbbrechen<\/b>. Der Grobentwurf sieht erstmal so wie in Bild 4 aus.<\/p>\n Bild 4: Entwurf des Login-Formulars<\/span><\/b><\/p>\n Das normale Einloggen verläuft wie folgt: Der Benutzer gibt einen Benutzernamen und sein Kennwort ein und klickt auf die Login<\/b>-Schaltfläche. Die dahinter verborgene Ereignisprozedur prüft, ob das Kennwort zum Benutzernamen stimmt, und trägt den neuen aktuellen Benutzer gegebenenfalls in die Optionen-Tabelle ein. Neben dieser Kombination aus gültigem Benutzernamen und passendem Kennwort gibt es jedoch noch weitere Varianten, die das Login<\/b>-Formular berücksichtigen muss:<\/p>\n In beiden Fällen soll der Benutzer eine Nachricht erhalten und erneut mit dem Login-Formular konfrontiert werden. Auch hier gibt es mehrere Möglichkeiten: Beide Textfelder behalten ihren Wert, beide Textfelder werden gelöscht oder der Benutzername wird beibehalten und nur das Kennwortfeld wird gelöscht – das ist der Fall, wenn der Benutzername richtig und das Kennwort falsch ist.<\/p>\n All dies wird zur blassen Theorie, denn wir arbeiten ja mit Access und wollen seine Mittel ausschöpfen. Die Benutzernamen der für die Anwendung registrierten Benutzer sind in der Tabelle tblBenutzer <\/b>gespeichert. Warum sollte man den Benutzer also auf umständliche Weise seinen Benutzernamen eingeben lassen Je nach der Konvention, die für die Zusammenstellung des Benutzernamens gewählt wurde (falls es denn eine gibt), kann es durchaus vorkommen, dass man seinen Benutzernamen einmal vergisst. Also werfen wir das Textfeld txtBenutzername <\/b>raus, bevor wir richtig loslegen, und ersetzen es durch ein Kombinationsfeld namens cboBenutzername<\/b>. Dieses passen wir durch Einstellen der folgenden Eigenschaften an:<\/p>\n Auch das Textfeld txtKennwort <\/b>zur Eingabe des Kennworts passen wir noch so an, dass die Kennworteingabe wie in einer professionellen Anwendung aussieht. Dort erscheinen statt des Kennworts im Klartext bei der Eingabe Platzhalter wie etwa das Sternchen (*). Diese Einstellung nehmen Sie vor, indem Sie die Eigenschaft Eingabeformat <\/b>des Textfelds anklicken, die daraufhin erscheinende Schaltfläche mit den drei Punkten (…) betätigen und im Dialog aus Bild 5 den Eintrag Kennwort <\/b>auswählen.<\/p>\n Bild 5: So sorgen Sie dafür, dass Dritte Kennwörter bei der Eingabe nicht mitlesen können.<\/span><\/b><\/p>\n Login bei Eingabetaste<\/p>\n Wenn der Benutzer auf einem Webformular die Eingabetaste drückt, bewirkt dies üblicherweise das Absenden der im Formular eingetragenen Daten. Dieses im Internet gängige Verhalten kann man auch beim Benutzer einer Datenbankanwendung als bekannt voraussetzen: Wenn dieser schon nicht mit der Maus von Eingabefeld zu Eingabefeld navigiert und die Eingabe mit einem Klick auf die entsprechende Schaltfläche abschließt, erledigt er dies in der Regel mit der Tabulator-Taste und schließt die Eingabe mit der Eingabetaste ab.<\/p>\n Dies soll auch hier der Fall sein. Ungeachtet der beim Abschließen der Anmeldung ausgeführten Codezeilen schauen wir uns erst einmal an, wie wir Access dazu bewegen, beim Klick auf die Eingabetaste das Gleiche zu tun wie beim Betätigen der Login<\/b>-Schaltfläche. Dies verlangt nach Weniger, als Sie wahrscheinlich vermuten: Sie müssen lediglich die Eigenschaft Standard <\/b>der Schaltfläche cmdLogin <\/b>auf den Wert Ja <\/b>einstellen.<\/p>\n Damit definieren Sie diese Schaltfläche als Standardschaltfläche des Formulars, die beim Klick auf die Eingabetaste automatisch ausgelöst wird. Das Gleiche ist übrigens auch für die Abbrechen<\/b>-Schaltfläche möglich: Hier verwenden Sie allerdings die Eigenschaft Abbrechen <\/b>der entsprechenden Schaltfläche, die Sie ebenfalls auf den Wert Ja <\/b>einstellen. In diesem Fall führt das Betätigen der Escape<\/b>-Taste zum Ausführen der für die Abbrechen<\/b>-Schaltfläche hinterlegten Ereignisprozedur.<\/p>\n Beachten Sie aber, dass dies nicht funktioniert, wenn eine andere Schaltfläche bereits den Fokus besitzt, weil der Benutzer diese beispielsweise durch mehrfaches Betätigen der Tabulatortaste aktiviert hat.<\/p>\n Benutzername und Kennwort prüfen<\/b><\/p>\n Damit Sie das Verhalten der Schaltflächen und der damit verbundenen Tasten Enter <\/b>und Escape <\/b>prüfen können, legen Sie nun entsprechende Ereignisprozeduren für die Beim Klicken<\/b>-Ereigniseigenschaften dieser Steuerelemente an.<\/p>\n Am einfachsten gelingt dies mit der Schaltfläche cmdAbbrechen<\/b>: Diese soll bei Betätigung einfach die aktuelle Anwendung beenden, wenn der Benutzer sich nicht einloggen will oder kann. Sicherheitshalber soll die Anwendung den Benutzer noch fragen, ob dieser sicher ist, dass er die Anwendung beenden möchte. Dies sieht wie folgt aus:<\/p>\n Die Prozedur, welche die Benutzereingaben prüfen soll, fällt etwas länger, aber nicht komplizierter aus:<\/p>\n Die Routine verwendet die DLookup<\/b>-Anweisung, um den Wert des Feldes BenutzerID <\/b>für einen Datensatz der Tabelle tblBenutzer <\/b>zu ermitteln, bei dem die Inhalte der Felder Benutzername <\/b>und Kennwort <\/b>mit den Inhalten der Textfelder txtBenutzername <\/b>und txtKennwort <\/b>übereinstimmen.<\/p>\n Wenn DLookup <\/b>keinen passenden Datensatz findet, liefert es den Wert Null <\/b>zurück – und dann tritt die Nz<\/b>-Funktion auf den Plan, die den Wert Null <\/b>durch den im zweiten Parameter angegebenen Wert ersetzt, in diesem Fall die Zahl 0<\/b>. Diese wird schließlich in der Variablen lngCurrentUserID <\/b>gespeichert.<\/p>\n Die nachfolgende If…Then<\/b>-Bedingung prüft genau auf diesen Wert und verzweigt zu einer von zwei Möglichkeiten:<\/p>\n Anzeigen des Loginformulars beim Start<\/b><\/p>\n Der Benutzer soll nach dem Start der Anwendung als Erstes das Loginformular sehen, damit er sich anmelden kann. Außerdem soll er nicht auf irgendein Element der Anwendung zugreifen können, bevor er sich nicht eingeloggt hat und das Loginformular geschlossen ist.<\/p>\n Das gelingt auf zwei Arten:<\/p>\n Für die erste Variante zeigen Sie zunächst die Eigenschaften der aktuellen Datenbank an (unter Access 2003 mit dem Menübefehl Extras|Start<\/b>, unter Access 2007 über die Schaltfläche Access-Optionen <\/b>des Office-Menüs und anschließendes Wechseln in den Bereich Aktuelle Datenbank<\/b>, s. Abb. 6). Dort wählen Sie für die Eigenschaft Formular anzeigen <\/b>das Formular frmLogin <\/b>aus.<\/p>\n Bild 6: Einstellen eines Formulars als Startformular<\/span><\/b><\/p>\n Wenn Sie die Anwendung nun neu starten, erscheint das gewünschte Formular – aber der Benutzer kann ohne Eingabe der Logindaten auf die übrigen Elemente der Anwendung zugreifen und beispielsweise Tabellen öffnen.<\/p>\n Sie müssen das Formular noch als modalen Dialog auslegen und dies geschieht durch die folgenden beiden Schritte:<\/p>\n Bei der zweiten Variante legen Sie zunächst ein neues Makro an und speichern es unter dem Namen AutoExec<\/b>. Durch Verwendung dieses speziellen Namens wird es gleich beim Start der Anwendung ausgelöst – es sei denn, der Benutzer betätigt beim Starten die Umschalttaste. Legen Sie dann wie in Bild 7 eine Aktion namens ÖffnenFormular <\/b>an und legen Sie als Parameter den Formularnamen sowie als Fenstermodus <\/b>den Wert Dialog <\/b>fest. Dies erfüllt die gleiche Funktion wie das Einstellen der beiden Eigenschaften aus der vorherigen Variante.<\/p>\n Feinheiten<\/b><\/p>\n Sie müssen noch einige kleinere Anpassungen vornehmen:<\/p>\n Auch das Verhalten nach Eingabe falscher Benutzerdaten ändern wir noch: Da wir die Benutzernamen per Kombinationsfeld zur Auswahl bereitstellen, ist die Chance, dass der Benutzer einen falschen Namen auswählt, gering. Die Anmeldung wird also üblicherweise an der Eingabe des Kennwort scheitern. Damit der Benutzer nach einer Fehleingabe keine unnötigen Mimiken ausführen muss, legen wie den Fokus direkt auf das Textfeld txtKennwort<\/b>, und zwar mit einer zusätzlichen Zeile in der Ereignisprozedur cmdLogin_Click<\/b>:<\/p>\n Das Formular sieht in der Formularansicht nun wie in Bild 8 aus.<\/p>\n Bild 9: Entwurf der Tabelle tblBenutzergruppen<\/span><\/b><\/p>\n Benutzerverwaltung mit Benutzergruppen<\/b><\/p>\n Bevor wir uns ansehen, was wir mit dem angemeldeten Benutzer anstellen können, werfen wir noch einen Blick auf die Benutzergruppen. Deren Einrichtung ändert nichts am Login-Prozedere, aber wir brauchen diese später, um die Berechtigungen der Benutzer etwa für den Zugriff auf einzelne Elemente von Formularen auch auf Gruppenebene festlegen zu können.<\/p>\n Die Tabelle zum Speichern der Benutzergruppen heißt tblBenutzergruppen <\/b>und enthält nur zwei Felder – BenutzergruppeID <\/b>und Benutzergruppe<\/b>. Letzteres versehen Sie mit einem eindeutigen Index, damit jede Benutzergruppe einen eindeutigen Namen besitzt (siehe Bild 9). Wie stellen wir aber nun die Beziehung zwischen den in der Tabelle tblBenutzer <\/b>gespeicherten Benutzern und der Benutzergruppe aus tblBenutzergruppen <\/b>her Hier gibt es zwei Möglichkeiten, die davon abhängen, ob ein Benutzer nur einer oder mehreren Gruppen angehören darf. Wir wählen gleich die umfassendere Variante, indem wir über eine Verknüpfungstabelle namens tblBenutzerBenutzergruppen <\/b>eine m:n-Beziehung zwischen den beiden Tabellen tblBenutzer <\/b>und tblBenutzergruppen <\/b>herstellen. Den Namen dieser Verknüpfungstabelle können Sie nach eigenem Gusto anpassen – sinnvoll wäre ebenso tblBenutzergruppenzuordnung<\/b>. Nach einer in den meisten Lösungen von Access im Unternehmen verwendeten Konvention wäre die konsequente aber die erstgenannte, bei der dem Präfix tbl <\/b>die beiden Objektarten der zu verknüpfenden Tabellen im Plural aufgeführt werden.<\/p>\n Bild 7: Das AutoExec-Makro öffnet das Formular frmLogin als modalen Dialog.<\/span><\/b><\/p>\n Bild 8: Das fertige Loginformular<\/span><\/b><\/p>\n Die Verknüpfungstabelle besteht aus drei Feldern: einem Primärschlüsselfeld namens ID <\/b>als eindeutigem Index und den beiden Fremdschlüsselfeldern BenutzerID <\/b>und BenutzergruppeID<\/b>. Für diese beiden Felder legen Sie einen zusammengesetzten, eindeutigen Index fest (siehe Bild 10).<\/p>\n Bild 10: Die Verknüpfungstabelle zur Herstellung der m:n-Beziehung zwischen Benutzern und Benutzergruppen<\/span><\/b><\/p>\n Damit für die beiden Felder BenutzerID<\/b> und BenutzergruppeID <\/b>nur solche Werte eingetragen werden können, die den Primärschlüsselfeldern der beiden Tabellen tblBenutzer <\/b>und tblBenutzergruppen<\/b> vorliegen, legen Sie erstens entsprechende Beziehungen zwischen den Tabellen an und aktivieren zweitens die Option Mit referentieller Integrität <\/b>der Beziehungen. All dies geschieht im Beziehungen-Fenster, dass Sie über den Menüeintrag Extras|Beziehungen <\/b>(Access 2003 und älter) beziehungsweise den Ribboneintrag Datenbanktools|Einblenden\/Ausblenden|Beziehungen <\/b>(Access 2007) öffnen. Stellen Sie für beide Beziehungen außerdem die Option Löschweitergabe an verwandte Datensätze <\/b>ein. So gewährleisten Sie, dass beim Löschen etwa eines Benutzers auch die damit verbundenen Datensätze aus der Verknüpfungstabelle gelöscht werden (siehe Bild 11).<\/p>\n Bild 11: Per referentieller Integrität legen wir fest, dass die Tabelle tblBenutzerBenutzergruppen in ihren Fremdschlüsselfeldern nur gültige Werte haben kann.<\/span><\/b><\/p>\n <\/p>\n Verwalten von Benutzern und Benutzergruppen<\/b><\/p>\n Die Access-Versionen 2003 und älter stellten jeweils zwei Dialoge zum Anlegen und zur Zuordnung von Benutzern und Benutzergruppen bereit – einen, mit dem Sie einen Benutzer anlegen oder auswählen und diesem die entsprechenden Benutzergruppen zuweisen können, und umgekehrt. Es ist sicher praktisch, die Zuordnung von Benutzern und Benutzergruppen sowohl aus Sicht der Benutzer als auch aus Sicht der Benutzergruppen verwalten zu können, daher werden wir ebenfalls gleich zwei Formulare für diesen Zweck anlegen. Das erste heißt frmBenutzerBenutzergruppen <\/b>und zeigt die Gruppenzugehörigkeit aus Sicht des Benutzers an. Es enthält die folgenden Steuerelemente (siehe Bild 12):<\/p>\n Bild 12: Entwurf des Formulars zur Verwaltung von Benutzern und Benutzergruppen<\/span><\/b><\/p>\n Auch für dieses Formular stellen Sie wieder die Eigenschaften Navigationsschaltflächen<\/b>, Datensatzmarkierer<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>auf den Wert Nein <\/b>ein.<\/p>\n Auswahl des Benutzers<\/b><\/p>\n Damit die Listenfelder lstAusgewaehlt <\/b>und lstNichtAusgewaehlt <\/b>die Benutzergruppen zu einem Benutzer anzeigen können, muss man zunächst den entsprechenden Benutzer mit dem Kombinationsfeld cboBenutzer <\/b>auswählen können. Dazu legen wir als Datensatzherkunft<\/b> die Abfrage aus Bild 13 fest.<\/p>\n Bild 14: Das Kombinationsfeld cboBenutzer in Aktion<\/span><\/b><\/p>\n Erstellen Sie diese als neue Abfrage und speichern Sie sie unter dem Namen qryFrmBenutzerBenutzergruppenCboBenutzer<\/b>, um das Ziel dieser Abfrage zu verdeutlichen. Stellen Sie dann die Eigenschaft Datensatzherkunft <\/b>des Kombinationsfeldes auf diesen Abfragenamen ein. Der folgende Ausdruck zeigt den Inhalt der drei enthaltenen Felder etwa in der Form aminhorst (André Minhorst) <\/b>im Kombinationsfeld an:<\/p>\n Damit jedoch nur der Inhalt der zweiten Spalte angezeigt und die erste Spalte der Datensatzherkunft ausgeblendet wird, müssen Sie noch die Eigenschaften Spaltenanzahl <\/b>und Spaltenbreiten <\/b>auf 2 <\/b>und 0cm <\/b>einstellen. In der Formularansicht sieht die Anzeige des Kombinationsfeldes nun wie in Bild 14 aus. Nun soll das Kombinationsfeld gleich beim Öffnen des Formulars noch den ersten Eintrag anzeigen. Dazu legen Sie für die Ereigniseigenschaft Beim Laden <\/b>des Formulars die folgende Ereignisprozedur an:<\/p>\n Bild 13: Diese Abfrage liefert die Datensatzherkunft für das Kombinationsfeld cboBenutzer.<\/span><\/b><\/p>\n Anschließend wenden wir uns den beiden Listenfeldern zu, welche die zum ausgewählten Benutzer gehörenden Benutzergruppen anzeigen sollen.<\/p>\n Anzeige der zugeteilten Benutzergruppen<\/b><\/p>\n Das erste Listenfeld namens lstAusgewaehlt <\/b>soll alle Benutzergruppen anzeigen, die dem aktuell im Kombinationsfeld cboBenutzer <\/b>ausgewählten Benutzer zugewiesen sind. Das zweite enthält die übrigen Benutzergruppen. Damit wir für die folgenden änderungen einige Testdaten haben, legen Sie zunächst ein paar Benutzergruppen an und weisen einige davon den vorhandenen Testbenutzern zu. Letzteres geschieht, indem Sie in die Tabelle tblBenutzerBenutzergruppen <\/b>Kombinationen der vorhanden Werte der Felder BenutzerID <\/b>und BenutzergruppeID <\/b>der beiden Tabellen tblBenutzer <\/b>und tblBenutzergruppen <\/b>eintragen. Dies sieht dann wie in Bild 15 aus.<\/p>\n Bild 15: Zuweisen von Benutzergruppen zu Benutzern in der Tabelle tblBenutzerBenutzergruppen<\/span><\/b><\/p>\n Damit können wir uns an die Datensatzherkünfte der beiden Listenfelder heranwagen. Das Listenfeld soll alle Datensätze der Tabelle tblBenutzergruppen <\/b>anzeigen, die über die Tabelle tblBenutzerBenutzergruppen<\/b> dem im Kombinationsfeld ausgewählten Benutzer zugewiesen sind. Das Listenfeld soll die BenutzerID <\/b>als gebundene, ausgeblendete Spalte und das Feld Benutzer <\/b>als anzuzeigenden Wert enthalten. Dazu stellen Sie die Eigenschaften Spaltenanzahl <\/b>und Spaltenbreiten <\/b>wie schon oben beim Kombinationsfeld cboBenutzer <\/b>auf die Werte 2 <\/b>und 0cm <\/b>ein.<\/p>\n Da die anzuzeigenden Daten nach der Auswahl eines neuen Benutzers in cboBenutzer <\/b>jeweils aktualisiert werden müssen, gehört die Zuweisung der entsprechenden SQL-Auswahlabfrage in eine VBA-Prozedur, die durch die Ereigniseigenschaft Nach Aktualisierung <\/b>des Kombinationsfeld-Steuerelements ausgelöst wird. Dort können wir dann auslesen, welcher Benutzer gerade im Kombinationsfeld ausgewählt ist, und eine entsprechende Datensatzherkunft für das Listenfeld lstAusgewaehlt <\/b>zusammenstellen (s. Listing 2).<\/p>\n Listing 2: Füllen eines Listenfelds mit verknüpften Benutzergruppen<\/p>\n Als Basisabfrage dient die in Bild 16 dargestellte Abfrage qryFrmBenutzerBenutzergruppenLstAusgewaehlt<\/b>. Für das Feld BenutzerID<\/b>, das nicht zur Ergebnismenge der Abfrage gehört, wurde ein Parameter namens prmBenutzerID <\/b>festgelegt. Die folgende Prozedur erstellt zunächst eine Objektvariable namens db <\/b>mit einem Verweis auf das aktuelle Database<\/b>-Objekt. Diese liefert einen Verweis auf die soeben erstellte Abfrage. Nach der Ermittlung der BenutzerID <\/b>des im Kombinationsfeld cboBenutzer <\/b>ausgewählten Benutzers erzeugt die Prozedur ein Parameter<\/b>-Objekt zum Füllen des Parameters prmBenutzerID <\/b>der gespeicherten Abfrage.<\/p>\n Bild 16: Diese Abfrage dient als Basis für das Füllen des Listenfelds lstAusgewaehlt.<\/span><\/b><\/p>\n Die folgende Anweisung weist diesem Parameter den Wert von lngBenutzerID <\/b>zu, dann erzeugt die Prozedur ein Recordset<\/b>-Objekt auf Basis der Abfrage mit dem angegebenen Parameterwert und weist dieses dem Listenfeld als Recordset <\/b>zu. Das ist aber doch keine Ereignisprozedur Nein, ist es nicht: Es ist eine einfache Prozedur, deren Aufruf Sie erst noch in eine Ereignisprozedur einfügen müssen – genau genommen sogar in mehrere. Das ist auch der Sinn, warum wir diese Funktion in eine eigene Prozedur gepackt haben: Das Füllen des Listenfeldes lstAusgewaehlt <\/b>soll von mehreren Stellen aus geschehen, und zwar gleich beim Öffnen des Formulars nach dem automatischen Auswählen des ersten Eintrags des Kombinationsfelds cboBenutzer <\/b>und außerdem durch die Ereignisprozedur, die durch das Ereignis Nach Aktualisieren <\/b>des gleichen Kombinationfeldes ausgelöst wird. Die beiden Prozeduren sehen nun so aus:<\/p>\n Im gleichen Zuge soll auch noch das zweite Listenfeld mit Daten gefüllt werden. Dazu benötigen wir eine Abfrage, die alle Datensätze der Tabelle tblBenutzergruppen <\/b>liefert, die nicht in der Datensatzherkunft des Listenfeldes lstAusgewaehlt <\/b>enthalten sind – also alle, die übrig bleiben. Die Definition dieser Abfrage können Einsteiger im ersten Moment sicher nicht herleiten, daher eine ausführliche Erläuterung. Die Basis der Abfrage besteht ja bereits: Es handelt sich um die Abfrage, welche alle im linken Listenfeld angezeigten Einträge liefert. Wir gehen dies nun in vier Schritten an:<\/p>\n Bild 17: Mit dieser Einstellung zeigt die Abfrage alle Datensätze der Tabelle tblBenutzergruppen an.<\/span><\/b><\/p>\n Bild 18 zeigt die Abfrage in der Entwurfsansicht. Die Prozedur zum Öffnen eines Recordsets auf Basis dieser Abfrage und zum Zuweisen dieser Abfrage zum Listenfeld lstNichtAusgewaehlt <\/b>heißt lstNichtAusgewaehltFuellen <\/b>und sieht bis auf Details wie die Prozedur lstAusgewaehltFuellen <\/b>aus. Sie finden diese Prozedur ebenfalls im Klassenmodul des Formulars frmBenutzerBenutzergruppen<\/b>. Nachdem wir nun nicht nur eines, sondern zwei Listenfelder füllen müssen, müssen wir natürlich auch unsere Ereignisprozeduren ändern, die beim Laden des Formulars und beim Auswählen eines neuen Benutzers aus dem Kombinationsfeldes ausgelöst werden. Diese sehen nun so aus:<\/p>\n Bild 18: Datensatzherkunft des Listenfeldes zur Anzeige aller nicht ausgewählter Benutzergruppen eines Benutzers<\/span><\/b><\/p>\n Benutzergruppen zuweisen<\/b><\/p>\n Das Zuweisen der Benutzergruppen erfolgt entweder durch einen Doppelklick auf einen der Einträge im Listenfeld lstNichtAusgewaehlt <\/b>oder durch Auswählen eines der Einträge und anschließendes Betätigen der Schaltfläche cmdEinzelnAuswaehlen <\/b>zum Hinzufügen einer einzelnen Benutzergruppe. Zum Hinzufügen aller Benutzergruppen gleichzeitig soll ein Klick auf die Schaltfläche cmdAlleAuswaehlen <\/b>dienen.<\/p>\n Die durch einen Doppelklick auf einen Eintrag des Listenfelds lstNichtAusgewaehlt <\/b>ausgelöste Prozedur ruft eine weitere Prozedur namens EinzelnAuswaehlen <\/b>auf. Diese bezieht ihre Daseinsberechtigung wiederum daher, dass die enthaltene Funktion von mehreren Stellen aus aufgerufen werden soll:<\/p>\n Diese Prozedur sieht wie in Listing 3 aus und deklariert zunächst ein Database<\/b>-Objekt sowie zwei Long<\/b>-Variablen. Bevor sie richtig loslegt, prüft sie, ob der Benutzer überhaupt einen Eintrag im Listenfeld markiert hat. Dabei ist die Eigenschaft Count <\/b>der Auflistung der markierten Einträge, ItemsSelected<\/b>, hilfreich.<\/p>\n Listing 3: Hinzufügen einer Benutzergruppe zum aktuellen Benutzer<\/p>\n Weist diese Eigenschaft den Wert 1 <\/b>auf, dann ist ein Listenfeldeintrag markiert und der Inhalt der If…Then<\/b>-Bedingung wird ausgeführt. Die Variable db <\/b>wird mit einem Verweis auf das aktuelle Database<\/b>-Objekt gefüllt und die beiden Long<\/b>-Variablen lngBenutzerID <\/b>und lngBenutzergruppeID <\/b>erhalten die Primärschlüsselwerte des betroffenen Benutzers (aus cboBenutzer<\/b>) und der hinzuzufügenden Benutzergruppe (aus lstNichtAusgewaehlt<\/b>) als Wert.<\/p>\n Schließlich fügt eine INSERT INTO<\/b>-Aktionsabfrage einen neuen Datensatz zur Tabelle tblBenutzerBenutzergruppen <\/b>hinzu, der die Werte aus lngBenutzerID <\/b>und lngBenutzergruppeID <\/b>für die Felder BenutzerID <\/b>und BenutzergruppeID <\/b>erhält.<\/p>\n Zu guter Letzt müssen die beiden Listenfelder noch aktualisiert werden, damit der Benutzer auch etwas vom just angelegten Datensatz in der Tabelle tblBenutzerBenutzergruppe <\/b>mitbekommt – und dies erledigen die bereits bekannten Prozeduren lstAusgewaehltFuellen <\/b>und lstNichtAusgewaehltFuellen<\/b>. Die Prozedur EinzelnAuswaehlen <\/b>wird auch aufgerufen, wenn der Benutzer auf die Schaltfläche cmdEinzelnAuswaehlen <\/b>klickt:<\/p>\n Wenn ein Benutzer mit allen möglichen Berechtigungen ausgestattet werden soll, können Sie diesem natürlich auch gleich alle Benutzergruppen zuweisen. Den Start macht ein Klick auf die Schaltfläche cmdAlleAuswaehlen<\/b>, was diese Ereignisprozedur auslöst:<\/p>\n Die einzige Anweisung dieser Prozedur ruft eine weitere Prozedur namens AlleAuswaehlen <\/b>auf. Deren Inhalt hätten wir zwar auch gleich in die Ereignisprozedur cmdAlleAuswaehlen_Click <\/b>schreiben können, aber wir wollten an dieser Stelle konsequent alle Funktionen zum Aus- und Abwählen der Benutzergruppen eines Benutzers in eigene Prozeduren auslagern. Die Prozedur AlleAuswaehlen <\/b>finden Sie in Listing 4.<\/p>\n Listing 4: Diese Prozedur weist einem Benutzer alle verfügbaren Benutzergruppen zu.<\/p>\n Sie hält sich nicht damit auf, zu prüfen, welche Benutzergruppen dem aktuellen Benutzer bereits zugewiesen sind und welche nicht, sondern entfernt schlicht alle zugewiesenen Benutzergruppen und fügt dann alle hinzu. Dazu liest die Prozedur ebenfalls zunächst die ID des aktuell im Kombinationsfeld ausgewählten Benutzers aus und speichert diese in einer Long<\/b>-Variablen. Danach löscht eine DELETE<\/b>-Aktionsabfrage alle Datensätze der Tabelle tblBenutzerBenutzergruppen<\/b>, deren Feld BenutzerID <\/b>die ID des aktuellen Benutzers enthält. Eine INSERT INTO<\/b>-Abfrage fügt dann für jeden Datensatz der Tabelle tblBenutzergruppen <\/b>einen neuen Datensatz zur Tabelle tblBenutzerBenutzergruppen <\/b>hinzu, wobei das Feld BenutzerID <\/b>jeweils mit der ID aus der Variablen lngBenutzerID <\/b>und das Feld BenutzergruppeID <\/b>mit dem entsprechenden Datensatz der Tabelle tblBenutzergruppen <\/b>gefüllt wird. Auch hier findet zum Abschluss die Aktualisierung der beiden Listenfelder statt.<\/p>\n Benutzergruppen entfernen<\/b><\/p>\n Das Entfernen einer einzelnen oder aller aktuell ausgewählten Benutzergruppen eines Benutzers geht noch einfacher. Eine einzelne Benutzergruppe entfernt beispielsweise ein Doppelklick auf einen Eintrag des Listenfelds lstAusgewaehlt <\/b>oder das Auswählen eines Eintrags und ein anschließender Klick auf die Schaltfläche cmdEinzelnAbwaehlen<\/b>. Die entsprechenden Ereignisprozeduren sehen so aus:<\/p>\n Beide rufen die Prozedur EinzelnAbwaehlen <\/b>auf, die Sie in Listing 5 finden. Die Prozedur arbeitet ähnlich wie die Prozedur EinzelnAuswaehlen<\/b>, fügt aber keinen Datensatz zur Tabelle tblBenutzerBenutzergruppen <\/b>hinzu, sondern entfernt stattdessen einen Eintrag. Die dazu notwendige DELETE<\/b>-Aktionsabfrage sucht sich dabei den Datensatz heraus, dessen Felder BenutzerID <\/b>und BenutzergruppeID <\/b>genau die in den beiden Long<\/b>-Variablen gespeicherten Werte aufweisen, und löscht diesen. Fehlt noch das Abwählen aller dem aktuellen Benutzer zugewiesenen Benutzergruppen, was durch einen Klick auf die Schaltfläche cmdAlleAbwaehlen <\/b>geschieht:<\/p>\n Listing 7: Diese Prozedur öffnet das Formular zum Anlegen eines neuen Benutzers und aktualisiert anschließend das Kombinationsfeld zur Anzeige des aktuellen Benutzers.<\/p>\n Listing 5: Diese Prozedur löscht den aktuell markierten Eintrag des Listenfeldes lstAusgewaehlt.<\/p>\n Die hier aufgerufene Prozedur AlleAbwaehlen <\/b>hat leichtes Spiel: Sie braucht einfach nur mit einer entsprechenden DELETE<\/b>-Anweisung alle Einträge der Tabelle tblBenutzerBenutzergruppen<\/b> zu löschen, deren Feld BenutzerID<\/b> den im Kombinationsfeld cboBenutzer<\/b> ausgewählten Wert aufweist (s. Listing 6).<\/p>\n Listing 6: Löschen aller einem Benutzer zugeordneten Benutzergruppen<\/p>\n Benutzer hinzufügen und bearbeiten<\/b><\/p>\n Für die Bearbeitung der in der Tabelle tblBenutzer <\/b>gespeicherten Datensätze legen wir ein Formular namens frmBenutzerDetail <\/b>an. Dieses besitzt die Tabelle tblBenutzer <\/b>als Datenherkunft <\/b>und soll in der Formularansicht einfach alle in dieser Tabelle enthaltenen Felder anzeigen – mit Ausnahme des Primärschlüsselfeldes BenutzerID<\/b>, weil dies für den Benutzer völlig uninteressant ist.<\/p>\n Stellen Sie die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>auf Nein <\/b>und die Eigenschaft Zentriert anzeigen <\/b>auf Ja <\/b>ein.<\/p>\n Für das Feld Kennwort <\/b>legen Sie als Eingabeformat <\/b>den Eintrag Kennwort <\/b>fest (siehe Bild 19). Schließlich stellen Sie die Eigenschaften Mit Systemfeldmenü <\/b>und Schließen-Schaltfläche <\/b>auf den Wert Nein <\/b>und MinMax-Schaltflächen <\/b>auf Keine <\/b>ein. So stellen Sie sicher, dass der Benutzer das Formular nur über die nun zu erstellenden Schaltflächen verlassen kann.<\/p>\n Bild 19: Das Formular frmBenutzerDetail zeigt die Eigenschaften eines Benutzers an.<\/span><\/b><\/p>\n Diese beiden Schaltflächen sollen cmdOK <\/b>und cmdAbbrechen<\/b> heißen. Die Schaltfläche cmdAbbrechen <\/b>soll beim Anklicken schlicht die folgende Ereignisprozedur auslösen:<\/p>\n Dadurch werden die änderungen verworfen und das Formular wird geschlossen. Die Prozedur der OK<\/b>-Schaltfläche sieht schon komplizierter aus:<\/p>\n Was ist DefaultEditing<\/b> und wofür brauchen wir verschiedene Aktionen beim Schließen DefaultEditing <\/b>ist eine verborgene Eigenschaft (das heißt, sie wird nicht mehr offiziell unterstützt, ist aber aus Kompatibilitätsgründen noch vorhanden). Sie liefert einen Zahlenwert zurück, der festlegt, in welchem Modus das Formular geöffnet wurde. Ist der Wert 1<\/b>, wurde das Formular mit einem neuen, leeren Datensatz geöffnet, beim Wert 2 <\/b>wird ein bestehender Wert angezeigt. In beiden Fällen ist das Bearbeiten möglich. Für unseren Fall ist das wichtig, weil wir das Formular von zwei Stellen aus für die beiden unterschiedlichen Bearbeitungsmodi aufrufen – und damit landen wir wieder beim Formular frmBenutzerBenutzergruppen<\/b>.<\/p>\n Dieses enthält ja, wie auch in Bild 19 gut zu erkennen, zwei Schaltflächen hinter dem Kombinationsfeld cboBenutzer<\/b>. Wenn Sie auf die Schaltfläche mit den drei Punkten (…) klicken, soll das Formular frmBenutzerDetail <\/b>erscheinen und den aktuell im Kombinationsfeld ausgewählten Benutzer zum Bearbeiten anzeigen. Das ist schnell erledigt, und zwar mit der ersten Anweisung der Prozedur, die durch die Ereigniseigenschaft Beim Klicken <\/b>dieser Schaltfläche ausgelöst wird:<\/p>\n Die Verwendung des Parameters acFormEdit <\/b>führt dazu, dass das Formular frmBenutzerDetail <\/b>beim Öffnen den mit dem Parameter WhereCondition <\/b>angegebenen Datensatz zum Bearbeiten anzeigt und dass seine Eigenschaft DefaultEditing <\/b>den Wert 2 <\/b>annimmt.<\/p>\n Der Parameter WindowMode <\/b>sorgt mit dem Wert acDialog <\/b>überdies dafür, dass Access das Formular frmBenutzerDetail <\/b>als modalen Dialog öffnet – das stellt erstens sicher, dass der Benutzer nicht auf andere Elemente der Benutzeroberfläche zugreifen kann, und zweitens wird der aufrufende Code, hier die DoCmd<\/b>-Anweisung, unterbrochen, bis das Formular geschlossen oder unsichtbar gemacht wird. In diesem Fall ist das hilfreich, weil wir so nach dem Schließen des Formulars frmBenutzerDetails <\/b>noch eine Anweisung zum Aktualisieren des Inhalts des Kombinationsfeldes loslassen können – dadurch werden eventuelle änderungen an den Benutzereigenschaften, die im Kombinationsfeld angezeigt werden, gleich in der neuen Fassung dargestellt.<\/p>\n Neuen Benutzer anlegen<\/b><\/p>\n Das Formular frmBenutzerDetail <\/b>soll auch dann geöffnet werden, wenn der Benutzer auf die Schaltfläche cmdNeu <\/b>des Formulars frmBenutzerBenutzergruppen <\/b>klickt. Beim Anlegen eines neuen Benutzers soll dieser gleich im Kombinationsfeld ausgewählt werden – wozu sollte man sonst einen neuen Benutzer anlegen Schauen wir uns also die Ereignisprozedur an, die durch das Ereignis Beim Klicken <\/b>der Schaltfläche cmdNeu <\/b>ausgelöst wird (s. Listing 7). Diese Prozedur öffnet zunächst das Formular, und zwar diesmal mit dem Wert acFormAdd <\/b>für den Parameter DataMode<\/b>. Dies führt dazu, dass das Formular einen neuen, leeren Datensatz anzeigt und der Wert der Eigenschaft DefaultEditing <\/b>auf 1 <\/b>eingestellt wird. Durch das Öffnen als modaler Dialog wird die Prozedur nun unterbrochen, bis der Benutzer eine der beiden Schaltflächen cmdOK <\/b>oder cmdAbbrechen <\/b>des Formulars frmBenutzerDetail <\/b>betätigt. Die Abbrechen<\/b>-Schaltfläche schließt das Formular einfach. Die folgende Anweisung der aufrufenden Prozedur prüft nun mit der benutzerdefinierten Funktion IstFormularGeoeffnet<\/b>, ob das Formular frmBenutzerDetail<\/b> noch geöffnet ist. Das ist hier nicht der Fall, also werden die in der If…Then<\/b>-Bedingung enthaltenen Anweisungen diesmal nicht ausgeführt.<\/p>\n Anders verhält es sich, wenn der Benutzer tatsächlich einen neuen Benutzer angelegt und auf die OK<\/b>-Schaltfläche von frmBenutzerDetail <\/b>geklickt hat. Dann liefert die Funktion IstFormularGeoeffnet<\/b>, die Sie übrigens im Modul mdlTools <\/b>der Beispieldatenbank finden, den Wert True <\/b>zurück und die If…Then<\/b>-Bedingung führt die enthaltenen Anweisungen aus. Dabei greift sie zunächst auf das noch geöffnete Formular frmBenutzerDetail <\/b>zu und liest den Wert des Primärschlüsselfeldes BenutzerID<\/b>, das zwar nicht im Formular angezeigt wird, aber dennoch vorhanden ist, in die Long<\/b>-Variable lngBenutzerID <\/b>ein. Nachdem dies geschehen ist, haben wir alle benötigten Informationen und können das Formular, das ja nur unsichtbar gemacht wurde, endgültig schließen. Das ist wichtig, denn wir wollen im Folgenden das Kombinationsfeld, das die Benutzer anzeigt, dazu bringen, den neuen Benutzer auszuwählen. Hierfür sind zwei Schritte nötig:<\/p>\n Wofür aber nun mussten wir die BenutzerID <\/b>in einer Variablen speichern und das Formular frmBenutzerDetail <\/b>vorher schließen Ganz einfach: Die Datensatzherkunft des Kombinationsfeldes kann den neuen Benutzer nur dann aufnehmen, wenn dieser auch in der zugrunde liegenden Tabelle tblBenutzer<\/b> gespeichert ist. Und dies geschieht zum Beispiel dann, wenn man das Formular, mit dem der Benutzer angelegt wurde, schließt. Schließlich müssen wir noch dafür sorgen, dass die Listenfelder mit den Benutzergruppen im neuen Benutzerdatensatz entsprechend aktualisiert werden, und rufen dafür die beiden Prozeduren lstAusgewaehltFuellen <\/b>und lstNichtAusgewaehltFuellen <\/b>auf.<\/p>\n Berechtigungen verwalten<\/b><\/p>\n Wenden wir uns nun einem wichtigen Thema dieser Lösung zu: den Berechtigungen.<\/p>\n Hier gibt es mehrere Entscheidungen, die Sie vor der Programmierung und der Erstellung des Datenmodells treffen müssen:<\/p>\n Diese Themen schauen wir uns in den folgenden Abschnitten an.<\/p>\n Benutzer und Benutzergruppen<\/b><\/p>\n Die Einteilung in Benutzergruppen haben wir ja vorgenommen, damit man Standardsätze von Berechtigungen festlegen und diese einem Benutzer über die Benutzergruppe zuweisen kann. Die einfachste Methode ist, tatsächlich nur Berechtigungen auf Benutzergruppenebene zu vergeben und nicht auf Benutzerebene. Außerdem deckt diese Regelung auch Sonderfälle ab, in denen ein einziger Benutzer ein spezielles Recht erhalten soll. Sie müssen dann nur eine neue Gruppe mit den entsprechenden Berechtigungen anlegen, der Sie nur den fraglichen Benutzer zuweisen.<\/p>\n Dies setzt natürlich voraus, dass ein Benutzer auch mehr als einer Gruppe zugeteilt werden kann, was durch die bisherige Fassung der Beispieldatenbank aber möglich ist.<\/p>\n Unabhängig davon, ob Sie Berechtigungen auf Benutzer- und\/oder Benutzergruppenebene vergeben, sollten Sie festlegen, dass ein Benutzer, der in mehreren Benutzergruppen vertreten ist, immer die höchste der ihm zugewiesenen Berechtigungen erhält. Wir gehen in den folgenden Schritten davon aus, dass nur Berechtigungen für Benutzergruppen vergeben werden.<\/p>\n Globale oder objektbezogene Berechtigungen<\/b><\/p>\n Unter Access 2003 und älter konnten Sie für jeden einzelnen Benutzer und auch für die Benutzergruppen die Berechtigungen für jedes Element der Datenbank festlegen, also zum Beispiel für die einzelnen Tabellen, Abfragen, Formulare, Berichte und auch für allgemeine Belange wie etwa der Verwaltung der Datenbank. Dies ist eine Variante. Alternativ legen Sie einfach eine Berechtigungsstufe für eine bestimmte Benutzergruppe fest. Diese wird etwa beim Öffnen von Formularen oder beim Ausführen von Funktionen abgefragt und führt dazu, dass das Öffnen des Formulars oder das Ausführen der Funktion erlaubt wird oder auch nicht. Dies soll die Variante sein, die wir weiter unten beschreiben.<\/p>\n Abhängige oder unabhängige Berechtigungen<\/b><\/p>\n Ein Beispiel für aufeinander aufbauende Berechtigungen ist folgendes:<\/p>\n Die einzelnen Berechtigungen können Sie natürlich auch einzeln behandeln:<\/p>\n Die erste Variante hat scheinbar einen Vorteil: Sie brauchen nur einen einzigen Wert zu speichern, welcher der jeweiligen Berechtigung entspricht (zum Beispiel die Zahlenwerte 1 <\/b>bis 4<\/b>). Im Datenmodell bedeutet dies, dass wir beispielsweise nur eine Eigenschaft für die entsprechende Benutzergruppe anlegen müssen. Bei der zweiten Variante müssten Sie schon mehrere Eigenschaften für das Festlegen der verschiedenen Berechtigungen speichern, denn eine Benutzergruppe kann ja beispielsweise nur lesende und löschende Rechte besitzen.<\/p>\n Aber auch dies lässt sich in einer einzigen Eigenschaft unterbringen: Dazu brauchen Sie die Berechtigungen lediglich mit Zweierpotenzen zu versehen (0, 1, 2, 4, 8, 16), die Sie durch Addieren als eine Zahl speichern können, aus der sich anschließend auch problemlos die Berechtigungen wiederherstellen lassen. Natürlich können Sie die Berechtigungen auch als Datensätze in einer Tabelle speichern und diese einer Benutzergruppe über eine m:n-Beziehung zuweisen, wie dies auch bei den Benutzern geschieht. Die Tabelle mit den Berechtigungen könnte dann etwa wie in Bild 20 aussehen.<\/p>\n Bild 20: Tabelle mit verschiedenen Berechtigungen<\/span><\/b><\/p>\n Für das Zuweisen legen Sie noch eine Verknüpfungstabelle an, die folgende drei Felder besitzt:<\/p>\n\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic001_opt.jpeg\")
<\/p>\nPublic Function OptionEinstellen(strOptionsname As String, strOptionswert As String) As Boolean\r\n Dim db As DAO.Database\r\n Set db = CurrentDb\r\n db.Execute "UPDATE tblOptionen SET Optionswert = ''''" & strOptionswert _\r\n & "'''' WHERE Optionsname = ''''" & strOptionsname & "''''", dbFailOnError\r\n If db.RecordsAffected = 1 Then\r\n OptionEinstellen = True\r\n Exit Function\r\n Else\r\n If db.RecordsAffected > 1 Then\r\n db.Execute "DELETE FROM tblOptionen WHERE Optionsname = ''''" _\r\n & strOptionsname & "''''", dbFailOnError\r\n End If\r\n db.Execute "INSERT INTO tblOptionen(Optionsname, Optionswert) VALUES(''''" & strOptionsname _\r\n & "'''', ''''" & strOptionswert & "'''')", dbFailOnError\r\n If db.RecordsAffected = 1 Then\r\n OptionEinstellen = True\r\n Exit Function\r\n End If\r\n End If\r\nEnd Function\r\nOptionEinstellen "CurrentUserID", 1<\/pre>\n\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic003_opt.jpeg\")
<\/p>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic004_opt.jpeg\")
<\/p>\n\n
\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic005_opt.jpeg\")
<\/p>\nPrivate Sub cmdAbbrechen_Click()\r\n If MsgBox("Dies beendet die Anwendung.\r\n Fortsetzen", vbYesNo + vbExclamation,\r\n "Anwendung beenden") = vbYes Then\r\n DoCmd.Quit\r\nEnd If\r\nEnd Sub<\/pre>\nPrivate Sub cmdLogin_Click()\r\nDim lngBenutzerID As Long\r\nlngBenutzerID = Nz(DLookup("BenutzerID", _\r\n"tblBenutzer", "Benutzername = ''''" _\r\n& Me!cboBenutzername _\r\n& "'''' AND Kennwort = ''''" _\r\n& Me!txtKennwort & "''''"), 0)\r\nIf lngBenutzerID = 0 Then\r\n MsgBox "Benutzername und\/oder " _\r\n & "Kennwort sind falsch."\r\nElse\r\n MsgBox "Anmeldung erfolgreich!"\r\n OptionEinstellen "CurrentUserID", _\r\n CStr(lngBenutzerID)\r\n DoCmd.Close acForm, Me.Name\r\nEnd If\r\nEnd Sub<\/pre>\n\n
\n
![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic006_opt.jpeg\")
<\/p>\n\n
\n
[...]\r\nIf lngBenutzerID = 0 Then\r\nMsgBox "Benutzername und\/oder Kennwort sind falsch."\r\nMe!txtKennwort.SetFocus\r\nElse\r\n[...]<\/pre>\n
![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic007_opt.jpeg\")
<\/p>\n![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic009_opt.jpeg\")
<\/p>\n![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic008_opt.jpeg\")
<\/p>\n![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic010_opt.jpeg\")
<\/p>\n![\"pic011.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic011_opt.jpeg\")
<\/p>\n![\"pic012.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic012_opt.jpeg\")
<\/p>\n\n
![\"pic015.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic015_opt.jpeg\")
<\/p>\nBenutzer: [Benutzername] & " (" & [Vorname] & " " & [Nachname] & ")"<\/pre>\n![\"pic014.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic014_opt.jpeg\")
<\/p>\nPrivate Sub Form_Load()\r\n Me!cboBenutzer = Me!cboBenutzer.ItemData(0)\r\n End Sub<\/pre>\n
![\"pic013.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic013_opt.jpeg\")
<\/p>\nPrivate Sub lstAusgewaehltFuellen()\r\n Dim db As DAO.Database\r\n Dim qdf As DAO.QueryDef\r\n Dim prm As DAO.Parameter\r\n Dim rst As DAO.Recordset\r\n Dim lngBenutzerID As Long\r\n Set db = CurrentDb\r\n Set qdf = db.QueryDefs("qryFrmBenutzerBenutzergruppenLstAusgewaehlt")\r\n lngBenutzerID = Nz(Me!cboBenutzer, 0)\r\n Set prm = qdf.Parameters("prmBenutzerID")\r\n prm.Value = lngBenutzerID\r\n Set rst = qdf.OpenRecordset\r\n If Not rst.EOF Then\r\n rst.MoveLast\r\n End If\r\n Set Me!lstAusgewaehlt.Recordset = rst\r\n End Sub<\/pre>\n![\"pic016.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic016_opt.jpeg\")
<\/p>\nPrivate Sub Form_Load()\r\n Me!cboBenutzer = Me!cboBenutzer.ItemData(0)\r\n Call lstAusgewaehltFuellen\r\n End Sub\r\nPrivate Sub cboBenutzer_AfterUpdate()\r\n Call lstAusgewaehltFuellen\r\n End Sub<\/pre>\n
\n
![\"pic018.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic018_opt.jpeg\")
<\/p>\n![\"pic017.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic017_opt.jpeg\")
<\/p>\nPrivate Sub Form_Load()\r\n Me!cboBenutzer = Me!cboBenutzer.ItemData(0)\r\n Call lstAusgewaehltFuellen\r\n Call lstNichtAusgewaehltFuellen\r\n End Sub\r\nPrivate Sub cboBenutzer_AfterUpdate()\r\n Call lstAusgewaehltFuellen\r\n Call lstNichtAusgewaehltFuellen\r\n End Sub<\/pre>\n
Private Sub lstNichtAusgewaehlt_DblClick(Cancel _\r\n As Integer)\r\n Call EinzelnAuswaehlen\r\n End Sub<\/pre>\n
Private Sub EinzelnAuswaehlen()\r\n Dim db As DAO.Database\r\n Dim lngBenutzerID As Long\r\n Dim lngBenutzergruppeID As Long\r\n If Me!lstNichtAusgewaehlt.ItemsSelected.Count = 1 Then\r\n Set db = CurrentDb\r\n lngBenutzerID = Nz(Me!cboBenutzer, 0)\r\n lngBenutzergruppeID = Me!lstNichtAusgewaehlt\r\n db.Execute "INSERT INTO tblBenutzerBenutzergruppen(BenutzerID, BenutzergruppeID) VALUES(" _\r\n & lngBenutzerID & ", " & lngBenutzergruppeID & ")", dbFailOnError\r\n Call lstAusgewaehltFuellen\r\n Call lstNichtAusgewaehltFuellen\r\n End If\r\n End Sub<\/pre>\nPrivate Sub cmdEinzelnAuswaehlen_Click()\r\n Call EinzelnAuswaehlen\r\n End Sub<\/pre>\n
Private Sub cmdAlleAuswaehlen_Click()\r\n Call AlleAuswaehlen\r\n End Sub<\/pre>\n
Private Sub AlleAuswaehlen()\r\nDim db As DAO.Database\r\nDim lngBenutzerID As Long\r\nSet db = CurrentDb\r\nlngBenutzerID = Nz(Me!cboBenutzer, 0)\r\ndb.Execute "DELETE FROM tblBenutzerBenutzergruppen WHERE BenutzerID = " _\r\n& lngBenutzerID, dbFailOnError\r\ndb.Execute "INSERT INTO tblBenutzerBenutzergruppen SELECT " & lngBenutzerID _\r\n& " AS BenutzerID, BenutzergruppeID FROM tblBenutzergruppen", dbFailOnError\r\nCall lstAusgewaehltFuellen\r\nCall lstNichtAusgewaehltFuellen\r\nEnd Sub<\/pre>\n
Private Sub cmdEinzelnAbwaehlen_Click()\r\n Call EinzelnAbwaehlen\r\n End Sub\r\nPrivate Sub lstAusgewaehlt_DblClick(Cancel As Integer)\r\n Call EinzelnAbwaehlen\r\n End Sub<\/pre>\n
Private Sub EinzelnAbwaehlen()\r\n Dim db As DAO.Database\r\n Dim lngBenutzerID As Long\r\n Dim lngBenutzergruppeID As Long\r\n If Me!lstAusgewaehlt.ItemsSelected.Count = 1 Then\r\n Set db = CurrentDb\r\n lngBenutzerID = Nz(Me!cboBenutzer, 0)\r\n lngBenutzergruppeID = Me!lstAusgewaehlt\r\n db.Execute "DELETE FROM tblBenutzerBenutzergruppen WHERE BenutzerID = " & lngBenutzerID _\r\n & " AND BenutzergruppeID = " & lngBenutzergruppeID, dbFailOnError\r\n Call lstAusgewaehltFuellen\r\n Call lstNichtAusgewaehltFuellen\r\n End If\r\n End Sub\r\nPrivate Sub cmdAlleAbwaehlen_Click()\r\n Call AlleAbwaehlen\r\n End Sub<\/pre>\n
Private Sub AlleAbwaehlen()\r\nDim db As DAO.Database\r\nDim lngBenutzerID As Long\r\nSet db = CurrentDb\r\nlngBenutzerID = Nz(Me!cboBenutzer, 0)\r\ndb.Execute "DELETE FROM tblBenutzerBenutzergruppen WHERE BenutzerID = " & lngBenutzerID, _\r\ndbFailOnError\r\nCall lstAusgewaehltFuellen\r\nCall lstNichtAusgewaehltFuellen\r\nEnd Sub<\/pre>\n
![\"pic019.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic019_opt.jpeg\")
<\/p>\nPrivate Sub cmdAbbrechen_Click()\r\n Me.Undo\r\n DoCmd.Close acForm, Me.Name\r\n End Sub<\/pre>\n
Private Sub cmdOK_Click()\r\n Select Case Me.DefaultEditing\r\n Case 1 ''''Neu\r\n Me.Visible = False\r\n Case 2 ''''Bearbeiten\r\n DoCmd.Close acForm, Me.Name\r\n End Select\r\n End Sub<\/pre>\n
Private Sub cmdBearbeiten_Click()\r\n DoCmd.OpenForm "frmBenutzerDetail", _\r\n WindowMOde:=acDialog, _\r\n DataMode:=acFormEdit, _\r\n WhereCondition:="BenutzerID = " _\r\n & Me!cboBenutzer\r\n Me!cboBenutzer.Requery\r\n End Sub<\/pre>\n
Private Sub cmdNeu_Click()\r\n Dim lngBenutzerID As Long\r\n DoCmd.OpenForm "frmBenutzerDetail", WindowMOde:=acDialog, DataMode:=acFormAdd\r\n If IstFormularGeoeffnet("frmBenutzerDetail") Then\r\n lngBenutzerID = Forms!frmBenutzerDetail!BenutzerID\r\n DoCmd.Close acForm, "frmBenutzerDetail"\r\n Me!cboBenutzer = lngBenutzerID\r\n Me!cboBenutzer.Requery\r\n Call lstAusgewaehltFuellen\r\n Call lstNichtAusgewaehltFuellen\r\n End If\r\n End Sub<\/pre>\n\n
\n
\n
\n
![\"pic020.png\"](\"..\/fileadmin\/_temp_\/2009_05\/Benutzerverwaltung-web-images\/pic020_opt.jpeg\")
<\/p>\n\n