<\/p>\n
Im Beitrag „Berechtigungen für Access-Objekte per SQL Server I: Tabellen“ haben wir ein Datenmodell entwickelt für die Verwaltung der Berechtigungen verschiedener Benutzergruppen auf die Formulare, Berichte und Steuer-elemente einer Access-Anwendung – gesteuert über die jeweilige Anmeldung an der SQL Server-Datenbank. Im zweiten Teil dieser Beitragsreihe verknüpfen wir die Access-Anwendung mit diesen Tabellen und erstellen die Formulare, die zur Bearbeitung der für die Berechtigungsverwaltung notwendigen Tabellen erforderlich sind.<\/b><\/p>\n
Für die im ersten Teil dieser Beitragsreihe namens Berechtigungen für Access-Objekte per SQL Server I: Tabellen<\/b>, die Sie unter www.access-im-unternehmen.de\/1159 <\/b>finden, benötigen wir prinzipiell zwei verschiedene Datenbanken: eine, mit der wir die Objektberechtigungen verwalten und eine, welche die Berechtigungen umsetzt. Die Formulare, mit denen wir die Objekte, Benutzergruppen und Berechtigungen einander zuordnen wollen, müssen nicht unbedingt in der eigentlichen Anwendung stecken. Andererseits kann es auch nicht schaden, damit gleich auszuprobieren, ob die Berechtigungen funktionieren – denn diese sollen weder durch Mitglieder der Gruppe Bestellannahme <\/b>noch der Gruppe Management <\/b>verwendet werden, sondern nur von den Administratoren. Wir werden also noch eine dritte Gruppe namens Berechtigungsadministratoren <\/b>zu Windows hinzufügen, die wir dann auch in den SQL Server übernehmen. Das erledigen Sie in der Eingabeaufforderung wie folgt:<\/p>\n Im SQL Server Management Studio fügen wir diese Anmeldung wie folgt hinzu (Details siehe Beitrag SQL Server: Sicherheit und Benutzerverwaltung<\/b>, www.access-im-unternehmen.de\/1154<\/b>) – Auf den folgenden Seiten zeigen wir Ihnen, wie Sie erstens die Verknüpfung zu den relevanten Tabellen herstellen – also zu den Tabellen, die wir im ersten Teil entworfen haben -, und dann die Formulare programmieren, die zur Verwaltung der Berechtigungen erforderlich sind.<\/p>\n Als Erstes benötigen wir eine Verknüpfung von einer Access-Datenbank zu den im ersten Teil der Beitragsreihe erstellten Tabellen. Dazu bemühen wir einfache ODBC-Verknüpfungen. Diese legen wir mit einem Tool an, dass wir bereits im Beitrag SQL Server-Tools <\/b>vorgestellt haben (http:\/\/www.access-im-unternehmen.de\/1061<\/b>). Genaugenommen können wir die dort erstellte Datenbank auch als Grundlage für unsere Datenbank zur Verwaltung der Berechtigungen nutzen, denn sie enthält einige praktische Werkzeuge, die wir noch brauchen.<\/p>\n Das beginnt mit dem Formular frmVerbindungszeichenfolgen<\/b> aus Bild 1, mit dem wir uns gleich eine passende Verbindungszeichenfolge zusammenstellen.<\/p>\n Bild 1: Einrichten der Verbindungszeichenfolge<\/span><\/b><\/p>\n Nachdem wir dies erledigt haben, können wir gleich das Formular frmTabellenVerknuepfen <\/b>öffnen, mit der wir die soeben angelegte Verbindung auswählen. Es erscheinen alle Tabellen der Datenbank Suedsturm_SQL<\/b>, von denen wir die Tabellen tblBenutzergruppen<\/b>, tblBerechtigungsstufen<\/b>, tblObjekte<\/b>, tblObjekteBenutzergruppenBerechtigungsen <\/b>und tblObjekttypen <\/b>auswählen – bei gedrückter Umschalttaste (siehe Bild 2). Diese Tabellen erscheinen kurz darauf im Navigationsbereich der Datenbank.<\/p>\n Bild 2: Hinzufügen der Verknüpfungen<\/span><\/b><\/p>\n Aus Performance-Gesichtspunkten wäre es günstiger, über Abfragen und gespeicherte Prozeduren auf die Tabellen der SQL Server-Datenbank zuzugreifen. Allerdings werden wir nicht so viele Objekte, Benutzer oder Berechtigungen anlegen, dass die Performance bei Nutzung von ODBC-Verknüpfungen in die Knie geht – und wir werden auch nicht mit vielen Benutzern gleichzeitig auf diese Daten zugreifen. Also ist die einfache Variante akzeptabel. Wenn wir später die Berechtigungen beim Anzeigen des Ribbons oder beim öffnen von Formularen und Berichten abfragen, werden wir auf die performantere Variante zurückgreifen.<\/p>\n Im ersten Teil dieser Beitragsreihe haben wir die Tabellen vorgestellt, mit denen wir die Objekte, die Berechtigungsstufen, die Berechtigungen und die Objekttypen speichern wollen. Nun kann es bei einer umfangreichen Datenbank relativ aufwendig werden, alle Objekte wie Formulare und Berichte sowie die enthaltenen Steuer-elemente in die Tabelle tblObjekte <\/b>zu schreiben, um dann über die anderen Tabellen die Berechtigungen zuzuordnen.<\/p>\n Also programmieren wir uns eine Prozedur, mit der wir die Formulare und Berichte sowie die enthaltenen Steuer-elemente in die Tabelle tblObjekte <\/b>schreiben können.<\/p>\n Diese heißt ObjekteSchreiben <\/b>und erwartet einen optionalen Parameter, mit dem Sie den Namen eines oder mehrerer Formulare angeben können, die nicht von der Prozedur berücksichtigt werden sollen, die also nicht samt Steuerelementen in die Tabelle tblObjekte <\/b>geschrieben werden sollen. Der Aufruf der Prozedur sieht also so aus, wenn alle Formulare berücksichtigt werden sollen:<\/p>\n Wenn Sie die Prozedur, wie wir es später tun werden, von einem Formular wie frmObjektberechtigungen <\/b>aus aufrufen werden, können Sie dieses auf folgende Weise ausschließen:<\/p>\n Wenn Sie mehr als ein Formular ausschließen wollen, geben Sie die Namen der Formulare einfach in einer durch Kommata getrennten Liste an:<\/p>\n Die Prozedur ObjekteSchreiben <\/b>finden Sie in Listing 1. Damit Sie kein, ein oder mehrere Formulare von der Verarbeitung ausschließen können, verwenden wir ein ParamArray <\/b>als Parameter. In einer For…Next<\/b>-Schleife durchläuft die Prozedur alle Formulare der aktuellen Anwendung. Dabei ermitteln wir die Anzahl der zu durchlaufenden Formulare über die Count<\/b>-Eigenschaft der Auflistung CurrentProject.AllForms<\/b>.<\/p>\n Listing 1: Prozedur zum Einlesen der Formulare und Steuer-elemente in die Tabelle tblObjekte<\/span><\/b><\/p>\n Danach erfassen wir den Namen des ersten Formulars und speichern diesen in der Variablen strForm<\/b>. Die Boolean<\/b>-Variable bolNicht <\/b>stellen wir auf den Wert False <\/b>ein, da wir in der folgenden Schleife alle Elemente des per Parameter übergebenen ParamArrays durchlaufen und prüfen, ob das in strForm <\/b>gespeicherte Formular einem der auszuschließenden Formulare entspricht. Dies erledigen wir in einer weiteren For…Next<\/b>-Schleife, diesmal mit der Laufvariablen j<\/b>.<\/p>\n In dieser Schleife durchlaufen wir alle Elemente des ParamArrays und referenzieren diese über den mit j <\/b>ermittelten Indexwert. Stimmen strForm <\/b>und das aktuelle Element aus strNicht(j) <\/b>überein, stellen wir bolNicht <\/b>auf True <\/b>ein und verlassen die Schleife. Erhalten wir dabei den Wert True <\/b>für die Variable bolNicht<\/b>, dann wird der Inhalt der folgenden If…Then<\/b>-Bedingung nicht ausgeführt, denn das aktuelle Formular samt Steuerelementen soll nicht eingelesen werden.<\/p>\n Anderenfalls beginnt hier jedoch der Einlesevorgang. Dabei öffnen wir das Formular aus strForm <\/b>in der Entwurfsansicht und referenzieren es mit der Objektvariablen objForm<\/b>. Danach deaktivieren wir die eingebaute Fehlerbehandlung, da es sein kann, dass beim Versuch, das aktuelle Formular als neuen Datensatz in die Tabelle tblObjekte <\/b>zu schreiben, ein Fehler wegen einer Schlüsselverletzung ausgelöst wird.<\/p>\n Dies kommt vor, wenn Sie beispielsweise neue Formulare oder Steuer-elemente hinzugefügt haben und diese Elemente erneut einlesen. Wir haben der Prozedur keine überprüfung hinzugefügt, mit der wir das Vorhandensein eines Formulars oder Steuerelements prüfen, sondern lassen es auf den Fehler ankommen, den wir dann ignorieren. Die INSERT INTO<\/b>-Anweisung schreibt den Namen des Formulars in das Feld Bezeichnung <\/b>eines neuen Datensatzes der Tabelle tblObjekte<\/b>.<\/p>\n Außerdem trägt es dort den Wert 1 <\/b>für Formular in das Feld ObjekttypID <\/b>ein. Die zweite INSERT INTO<\/b>-Anweisung trägt einen zweiten Datensatz für dieses Formular ein, wobei allerdings das Feld Bezeichnung <\/b>mit dem Wert Form <\/b>und das Feld Uebergeordnet <\/b>mit dem Namen des Formulars gefüllt wird. Wozu wir das benötigen, erfahren Sie weiter unten.<\/p>\n Danach durchlaufen wir in einer For Each<\/b>-Schleife alle in dem mit frm <\/b>referenzierten Formulare enthaltenen Steuer-elemente. Dabei prüfen wir zunächst, ob es sich nicht um ein Bezeichnungsfeld handelt – diese sollen hier nicht berücksichtigt werden. Ist das aktuelle Steuerelement kein Bezeichnungsfeld, schreiben wir zunächst den Namen des aktuellen Steuerelements in die Variable strControl<\/b>.<\/p>\n Danach fügen wir, wiederum bei deaktivierter Fehlerbehandlung, einen neuen Datensatz für das aktuelle Steuer-element in die Tabelle tblObjekte <\/b>ein. Diesmal landet der Name des Steuerelements im Feld Bezeichnung<\/b>. Der Name des übergeordneten Formulars landet im Feld Uebergeordnet<\/b>. Für den Objekttyp landet der Wert 4 <\/b>für Steuer-element im Feld ObjekttypID<\/b>. Außerdem speichern wir noch den Steuerelementtyp aus der Eigenschaft ControlType<\/b>, und zwar im Feld Steuer-ele-ment-typ-ID<\/b>.<\/p>\n Danach aktivieren wir die Fehlerbehandlung wieder und öffnen ein Recordset, das alle Elemente der Tabelle tblObjekte <\/b>enthält, deren Feld Uebergeordnet <\/b>dem Namen des aktuell untersuchten Formulars entspricht und die im Feld ObjekttypID <\/b>den Wert 4 <\/b>aufweisen – mit Ausnahme der Datensätze, die im Feld Bezeichnung <\/b>den Wert Form <\/b>enthalten.<\/p>\n Das Recordset enthält also jeweils einen Datensatz für alle Steuer-elemente des aktuellen Formulars. Damit durchlaufen wir dann in einer Do While<\/b>-Schleife alle Datensätze dieses Recordsets. Wir leeren die Objektvariable ctl <\/b>und versuchen dann, bei deaktivierter Fehlerbehandlung das Steuer-element mit dem Namen aus dem Feld Bezeichnung <\/b>im Formular zu referenzieren.<\/p>\n <\/p>\n Entspricht ctl <\/b>danach dem Objekt Nothing<\/b>, ist also leer, ist das Steuer-element zwar noch in der Tabelle tblObjekte <\/b>gespeichert, aber nicht mehr im angegebenen Formulare vorhanden – vermutlich hat der Entwickler es in der Zwischenzeit gelöscht. In diesem Fall können wir auch den dazu gehörenden Datensatz aus der Tabelle tblObjekte <\/b>löschen.<\/p>\n Danach schließen wir schließlich noch das aktuell untersuchte Formular und durchlaufen die Schleife für die weiteren Formulare, bis wir alle Formular durchlaufen haben.<\/p>\n Eine weitere Prozedur, die wir mit der letzten Anweisung der zuvor beschriebenen Prozedur aufrufen, heißt FormularePruefen<\/b> (siehe Listing 2). Sie untersucht alle Einträge der Tabelle tblObjekte<\/b>, die den Wert 1 <\/b>im Feld Objekttyp-ID <\/b>aufweisen dahingehend, ob die angegebenen Formular noch in der Datenbank vorhanden sind. Ist dies nicht der Fall, werden die Formulare-Einträge auch aus der Tabelle tblObjekte <\/b>gelöscht – inklusive der Steuerelement-Einträge für diese Formulare.<\/p>\n Listing 2: Prozedur zum Prüfen und gegebenenfalls Löschen von Einträgen für Formulare aus der Tabelle tblObjekte<\/span><\/b><\/p>\n Wenn Sie die Prozedur ObjekteSchreiben <\/b>einmal aufgerufen haben, etwa für die Beispieldatenbank zu diesem Beitrag, finden Sie Daten wie die aus Bild 3 in der Tabelle tblObjekte<\/b>.<\/p>\n Bild 3: Daten über die mit Berechtigungen zu versehenden Objekte<\/span><\/b><\/p>\n Das Formular zum Verwalten der Berechtigungen heißt frmBerechtigungen<\/b>. Im linken Teil beherbergt es ein Listenfeld mit allen Formularen, die wir aus Einträgen der Tabelle tblObjekte<\/b> ermitteln, für die das Feld ObjektID <\/b>den Wert 1 <\/b>enthält. Den Entwurf dieses Formulars finden Sie in Bild 4.<\/p>\n Bild 4: Entwurf des Formulars frmBerechtigungen<\/span><\/b><\/p>\n Damit das Listenfeld namens lstFormulare <\/b>die gewünschten Daten anzeigt, weisen wir diesem die folgende Abfrage als Datensatzherkunft zu:<\/p>\n Nach einem Wechsel in die Formularansicht liefert das bereits die Ansicht aus Bild 5.<\/p>\n Bild 5: Das Listenfeld lstFormulare mit den Daten der Tabelle tblObjekte<\/span><\/b><\/p>\n Als Nächstes wollen wir die Steuer-elemente zu dem jeweils im Listenfeld lstFormulare <\/b>markierten Formular im zweiten Listenfeld lstSteuerelemente <\/b>anzeigen. Da beim öffnen noch kein Element des ersten Listenfeldes markiert ist, wollen wir einfach alle Elemente der Tabelle tblObjekte <\/b>im zweiten Listenfeld anzeigen. Dazu fügen wir der Eigenschaft Datensatzherkunft <\/b>des Listenfeldes lstElemente <\/b>die folgende SQL-Abfrage hinzu:<\/p>\n Sobald der Benutzer jedoch einen Eintrag des Listenfeldes lstFormulare<\/b> markiert, sollen nur noch die Elemente dieses Formulars im zweiten Listenfeld lstElemente<\/b> angezeigt werden. Deshalb hinterlegen wir für die Ereignis-eigenschaft Nach Aktualisierung <\/b>eine Ereignisprozedur, die das Listenfeld lstElemente <\/b>so filtert, dass nur noch die zum gewählten Formular gehörenden Elemente angezeigt werden – und so, dass die Bezeichnungsfelder nicht mit angezeigt werden:<\/p>\n Die Ansicht im Formular frmBerechtigungen <\/b>sieht dann nach der Auswahl eines der Formulare im linken Listenfeld wie in Bild 6 aus.<\/p>\n Bild 6: Elemente eines Formulars<\/span><\/b><\/p>\n Hier taucht nun neben den Steuerelementen des markierten Formulars auch der Eintrag Form <\/b>auf. Damit wollen wir eine einheitliche Möglichkeit schaffen, nicht nur die Berechtigungen für die Steuer-elemente zu definieren, sondern auch für das Formular selbst.<\/p>\n Ganz rechts im Formular haben wir zwei weitere Listenfelder vorgesehen. Das obere soll die Benutzergruppen anzeigen, die unter Windows eingerichtet sind und die wir temporär in der Tabelle tblBenutzergruppen <\/b>speichern.<\/p>\n Dazu müssen wir diese allerdings erst einmal ermitteln.<\/p>\n Die Benutzergruppen lesen wir mithilfe einer gespeicherten Prozedur ein, die wir entweder direkt im SQL Server Management Studio anlegen oder die wir im Formular frmSQLBefehle<\/b> eingeben und ausführen (siehe Bild 7).<\/p>\n Bild 7: Erstellen einer gespeicherten Prozedur zum Ermitteln von Benutzergruppen<\/span><\/b><\/p>\n Die gespeicherte Prozedur enthält dabei genau eine Anweisung. Diese ermittelt per SELECT <\/b>alle Einträge der Katalogsicht sys.database_principals<\/b>, deren Feld type <\/b>den Wert G <\/b>aufweist, und schreibt diese mittels INSERT INTO<\/b>-Anweisung in die Tabelle tblBenutzergruppen<\/b>:<\/p>\n Die Katalogsicht sys.database_principals <\/b>liefert dabei Elemente wie SQL-Benutzer, Windows-Benutzer, Windows-Benutzergruppen und so weiter. Der Wert G <\/b>für das Feld type <\/b>schränkt die Rückgabewerte dabei auf die Windows-Benutzergruppen ein.<\/p>\n Danach führen wir die gespeicherte Prozedur noch aus, damit die Benutzergruppen auch in die Tabelle tblBenutzergruppen <\/b>eingetragen werden. Das erledigen wir mit der folgenden Anweisung, die wir entweder in einer neuen Abfrage im SQL Server Management Studio ausführen oder wieder im Formular frmSQLBefehle <\/b>in der aktuellen Datenbank:<\/p>\n Danach finden wir in der Tabelle tblBenutzergruppen <\/b>die Einträge etwa wie in Bild 8 vor.<\/p>\n Bild 8: Tabelle der Benutzergruppen<\/span><\/b><\/p>\n Um das Listenfeld rechts oben mit den Daten der Tabelle tblBenutzergruppen <\/b>zu füllen, stellen wir seine Eigenschaft Datensatzherkunft auf die entsprechende Tabelle ein, also tblBenutzergruppen<\/b>. Damit das Listenfeld nur die Bezeichnung der Benutzergruppe anzeigt und nicht die Primärschlüsselwerte aus dem Feld BenutzergruppeID<\/b>, legen wir außerdem für die Eigenschaft Spaltenanzahl <\/b>den Wert 2 <\/b>und für Spaltenbreiten <\/b>den Wert 0cm <\/b>fest.<\/p>\n Wenn wir nun das Formular frmBerechtigungen <\/b>öffnen, zeigt das Listenfeld lstBenutzergruppen<\/b> die Einträge der Tabelle tblBenutzergruppen <\/b>an (siehe Bild 9).<\/p>\n Bild 9: Benutzergruppen im Listenfeld des Formulars frmBerechtigungen<\/span><\/b><\/p>\n Damit kommen wir der Fertigstellung dieses Formulars näher. Wir sollen nun dafür sorgen, dass das vierte Listenfeld rechts unten verschiedene Berechtigungen für das jeweilige Objekt anzeigt, die dann markiert werden, wenn diese Berechtigung gesetzt ist. Die Berechtigungen speichern wir in der Tabelle tblObjekteBenutzergruppenBerechtigungen<\/b>. Im Listenfeld lstBerechtigungsstufen <\/b>zeigen wir die Datensätze der Tabelle tblBerechtigungsstufen <\/b>an. Diese Tabelle enthält ja lediglich die drei Datensätze aus Bild 10. Wie aber wollen wir nun für eines der Formulare oder die darin enthaltenen Steuer-elemente Berechtigungsstufen festlegen und im Listenfeld lstBerechtigungsstufen <\/b>anzeigen<\/p>\n Bild 10: Tabelle der Berechtigungsstufen<\/span><\/b><\/p>\n Das erledigen wir, indem wir die Werte der Tabelle tblObjekteBenutzergruppenBerechtigungen <\/b>abhängig von den aktuell in den drei Listenfeldern lstFormulare<\/b>, lst-Elemente <\/b>und lstBenutzergruppen <\/b>markierten Einträgen den passenden Eintrag im Listenfeld lstBerechtigungsstufen <\/b>markieren.<\/p>\n Dabei wollen wir zunächst dafür sorgen, dass beim Auswählen eines Eintrags für die Listenfelder lstElemente <\/b>und lstBenutzergruppen <\/b>eine Prozedur aufgerufen wird, die prüft, welche Berechtigung für diese Kombination aus Benutzergruppe und Element vorliegt. Daher hinterlegen wir für diese beiden Listenfelder die folgenden Ereignisprozeduren, die jeweils durch das Ereignis Nach Aktualisierung <\/b>ausgelöst werden:<\/p>\n Die dadurch aufgerufene Prozedur namens Be-rech-ti-gung–Anzeigen <\/b>finden Sie in Listing 3.<\/p>\n Listing 3: Prozedur zum Aktualisieren der Anzeige der Berechtigungen für die Kombination aus Element und Benutzergruppe<\/span><\/b><\/p>\n Die Prozedur durchläuft zunächst alle Elemente des Listenfeldes lstBerechtigungsstufen <\/b>und stellt den Selektiert-Status auf nicht selektiert ein. Die dazu verwendete Schleife durchläuft dabei die Elemente mit dem Index von 0 <\/b>bis zur Anzahl der Einträge minus eins.<\/p>\n Dann folgt eine For Each<\/b>-Schleife über alle im Listenfeld lstElemente <\/b>selektierten Elemente, die wir mit der Auflistung ItemsSelected <\/b>referenzieren. Das jeweilige Element speichern wir in der Variablen varElement<\/b>. Für dieses Element ermitteln wir zunächst den Wert der ersten Spalte beziehungsweise den Primärschlüsselwert und speichern diesen in der Variablen lngElementID<\/b>.<\/p>\n In einer zweiten For Each<\/b>-Schleife durchlaufen wir alle Elemente des Listenfeldes lstBenutzergruppen<\/b>. Den Primärschlüsselwert des aktuellen Elements referenzieren wir dabei mit der Variablen lngBenutzergruppeID<\/b>.<\/p>\n Nun wird es interessant, denn wir müssen uns auch noch ansehen, unter welchen Bedingungen wir eine der Berechtigungsstufen für die Kombination aus Element und Benutzergruppe als aktiv betrachten wollen. Wenn wir nur ein Element und eine Benutzergruppe markiert haben, ist die Frage leicht zu beantworten, denn es gibt nur einen Wert für die Berechtigungsstufe.<\/p>\n Wenn wir jedoch beispielsweise zwei Elemente markiert haben und eine Benutzergruppe und für das erste Element ist die Berechtigungsstufe Keine <\/b>festgelegt und für das zweite Element die Berechtigungsstufe Alle<\/b>, welche Berechtigungsstufe zeigen wir dann an Damit der Benutzer direkt erkennt, dass es keine eindeutige Berechtigungsstufe gibt, wollen wir hier einfach alle aktiven Berechtigungsstufen für die gewählten Elemente markieren.<\/p>\n Das erledigen wir, indem wir für jede Kombination aus Element und Benutzergruppe die Berechtigungsstufe mit DLookup <\/b>ermitteln und das Ergebnis (entweder 1<\/b>, 2 <\/b>oder 3<\/b>) in der Variablen lngBerechtigungsstufeID <\/b>speichern). Dann legen wir das Element des Listenfeldes lstBerechtigungsstufen <\/b>als markiert fest, dessen Index den Wert aus lngBerechtigungsstufeID <\/b>minus eins aufweist (der Index ist 0-basiert, unsere Werte für lngBerechtigungsstufe <\/b>jedoch 1-basiert).<\/p>\n Damit haben wir die Berechtigung eingestellt und können über die beiden For Each<\/b>-Schleifen über die beiden Listenfelder die übrigen Kombinationen aus Element und Benutzergruppe abarbeiten.<\/p>\n In der DLookup<\/b>-Funktion ist noch ein wichtiges Detail versteckt: Wir führen für das Ergebnis nämlich noch die Nz<\/b>-Funktion aus. Diese liefert den Wert des ersten Parameters, hier der DLookup<\/b>-Funktion, zurück, wenn dieser nicht Null ist. Liefert DLookup <\/b>den Wert Null<\/b>, gibt die Nz<\/b>-Funktion den als zweiten Parameter angegebenen Wert zurück, den wir hier als 3 <\/b>eingestellt haben.<\/p>\n Die Berechtigungsstufe 3 <\/b>entspricht dem Wert Alle<\/b>. Kombinationen aus Element und Benutzergruppe, für die kein Wert in der Tabelle tblObjekteBenutzergruppenBerechtigungen <\/b>festgelegt ist, erhalten also die Berechtigungsstufe Alle<\/b>.<\/p>\n Damit kommen wir zu der Prozedur, die durch das Anklicken eines Eintrags des Listenfeldes lstBerechtigungsstufen <\/b>ausgelöst wird, genau genommen durch das Ereignis Nach Aktualisierung<\/b> (siehe Listing 4).<\/p>\nnet.exe LOCALGROUP \/ADD Berechtigungsadministratoren<\/pre>\n
USE [master]\r\nGO\r\nCREATE LOGIN [<Server>\\Berechtigungsadministratoren] FROM WINDOWS WITH DEFAULT_DATABASE=[Suedsturm_SQL]\r\nGO\r\nUSE [Suedsturm_SQL]\r\nGO\r\nCREATE USER [<Server>\\Berechtigungsadministratoren] FOR LOGIN [<Server>\\Berechtigungsadministratoren]\r\nGO\r\nALTER ROLE [db_datareader] ADD MEMBER [<Server>\\Berechtigungsadministratoren]\r\nGO\r\nALTER ROLE [db_datawriter] ADD MEMBER [<Server>\\Berechtigungsadministratoren]\r\nGO<\/pre>\n
Verknüpfung herstellen<\/h2>\n
![\"Einrichten](\"..\/fileadmin\/_temp_\/2019_02\/pic_1180_001.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2019_02\/pic_1180_002.png\")
<\/p>\nWarum ODBC-Verknüpfungen<\/h2>\n
Tabellen füllen<\/h2>\n
ObjekteSchreiben<\/pre>\n
ObjekteSchreiben \"frmObjektberechtigungen\"<\/pre>\n
ObjekteSchreiben \"frmObjektberechtigungen\", \"frmArtikel\", ...<\/pre>\n
Public Sub <\/span>ObjekteSchreiben(ParamArray strNicht() As Variant<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database, frm As <\/span>Form, strForm As String<\/span>\r\n Dim <\/span>i As Integer<\/span>, j As Integer<\/span>, ctl As <\/span>Control\r\n Dim <\/span>bolNicht As Boolean<\/span>, strControl As String<\/span>, rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n For i = 0 To CurrentProject.AllForms.Count - 1\r\n strForm = CurrentProject.AllForms(i).Name\r\n bolNicht = False<\/span>\r\n For j = LBound<\/span>(strNicht) To UBound<\/span>(strNicht)\r\n If <\/span>strForm = strNicht(j) Then<\/span>\r\n bolNicht = True<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> j\r\n If <\/span>Not<\/span> bolNicht Then<\/span>\r\n DoCmd.OpenForm strForm, acDesign\r\n Set<\/span> frm = Forms(strForm)\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblObjekte(Bezeichnung, ObjekttypID) VALUES(''''\" & strForm & \"'''', 1)\", dbFailOnError\r\n db.Execute \"INSERT INTO tblObjekte(Bezeichnung, Uebergeordnet, ObjekttypID) VALUES(''''Form'''', ''''\" _\r\n & strForm & \"'''', 4)\", dbFailOnError\r\n For Each ctl In frm.Controls\r\n If <\/span>Not<\/span> ctl.ControlType = 100 Then<\/span>\r\n strControl = ctl.Name\r\n db.Execute \"INSERT INTO tblObjekte(Bezeichnung, Uebergeordnet, ObjekttypID, SteuerelementtypID) \" _\r\n & \"VALUES(''''\" & strControl & \"'''', ''''\" & strForm & \"'''', 4, \" & ctl.ControlType & \")\", dbFailOnError\r\n End If<\/span>\r\n Next<\/span> ctl\r\n On Error GoTo<\/span> 0\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblObjekte WHERE Uebergeordnet = ''''\" & strForm _\r\n & \"'''' AND ObjekttypID = 4 AND NOT Bezeichnung = ''''Form''''\", dbOpenDynaset, dbSeeChanges)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Set<\/span> ctl = Nothing\r\n On Error Resume Next<\/span>\r\n Set<\/span> ctl = frm.Controls(rst!Bezeichnung)\r\n Debug.Print<\/span> Err.Number, Err.Description\r\n On Error GoTo<\/span> 0\r\n If <\/span>ctl Is Nothing Then<\/span>\r\n db.Execute \"DELETE FROM tblObjekte WHERE ObjektID = \" & rst!ObjektID, dbFailOnError Or dbSeeChanges\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n DoCmd.Close acForm, strForm\r\n End If<\/span>\r\n Next<\/span> i\r\n FormularePruefen\r\nEnd Sub<\/span><\/pre>\nAuf gelöschte Formulare prüfen<\/h2>\n
Public Sub <\/span>FormularePruefen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>bolBehalten As Boolean<\/span>\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblObjekte WHERE ObjekttypID = 1\", dbOpenDynaset, dbSeeChanges)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n bolBehalten = False<\/span>\r\n For i = 0 To CurrentProject.AllForms.Count - 1\r\n If <\/span>CurrentProject.AllForms(i).Name = rst!Bezeichnung Then<\/span>\r\n bolBehalten = True<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\n If <\/span>bolBehalten = False<\/span> Then<\/span>\r\n db.Execute \"DELETE FROM tblObjekte WHERE Uebergeordnet = ''''\" & rst!Bezeichnung _\r\n & \"''''\", dbFailOnError Or dbSeeChanges\r\n db.Execute \"DELETE FROM tblObjekte WHERE ObjektID = \" & rst!ObjektID, dbFailOnError Or dbSeeChanges\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Daten](\"..\/fileadmin\/_temp_\/2019_02\/pic_1180_003.png\")
<\/p>\nFormular zum Verwalten der Berechtigungen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2019_02\/pic_1180_004.png\")
<\/p>\nSELECT DISTINCT tblObjekte.Bezeichnung FROM tblObjekte WHERE ObjekttypID = 1 ORDER BY tblObjekte.Bezeichnung;<\/pre>\n
![\"Das](\"..\/fileadmin\/_temp_\/2019_02\/pic_1180_005.png\")
<\/p>\nSteuer-elemente im Listenfeld anzeigen<\/h2>\n
SELECT tblObjekte.ObjektID, [Bezeichnung] & \" (\" & [Uebergeordnet] & \")\" AS ElementObjekt, tblObjekte.Bezeichnung FROM tblObjekte;<\/pre>\n
Private Sub <\/span>lstFormulare_AfterUpdate()\r\n Dim <\/span>strObjekte As String<\/span>\r\n Dim <\/span>var As Variant<\/span>\r\n For Each var In Me!lstFormulare.ItemsSelected\r\n strObjekte = strObjekte & \", ''''\" _\r\n & Me!lstFormulare.ItemData(var) & \"''''\"\r\n Next<\/span> var\r\n If <\/span>Len<\/span>(strObjekte) > 0 Then<\/span>\r\n strObjekte = Mid<\/span>(strObjekte, 3)\r\n End If<\/span>\r\n Me!lstElemente.RowSource = \"SELECT ObjektID, Bezeichnung FROM tblObjekte WHERE Uebergeordnet IN (\" & strObjekte & \")\"\r\nEnd Sub<\/span><\/pre>\n![\"Elemente](\"..\/fileadmin\/_temp_\/2019_02\/pic_1180_006.png\")
<\/p>\nDas Form-Element<\/h2>\n
Listenfeld der Benutzergruppen<\/h2>\n
Benutzergruppen einlesen<\/h2>\n
![\"Erstellen](\"..\/fileadmin\/_temp_\/2019_02\/pic_1180_007.png\")
<\/p>\nCREATE PROC [dbo].[spBenutzergruppenAktualisieren]\r\nAS\r\nSET NOCOUNT ON;\r\nINSERT INTO dbo.tblBenutzergruppen(Bezeichnung)\r\nSELECT name FROM sys.database_principals WHERE type = ''''G'''';<\/pre>\n
Exec dbo.spBenutzergruppenAktualisieren<\/pre>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2019_02\/pic_1180_008.png\")
<\/p>\nListenfeld lstBenutzergruppen füllen<\/h2>\n
![\"Benutzergruppen](\"..\/fileadmin\/_temp_\/2019_02\/pic_1180_009.png\")
<\/p>\nBerechtigungen setzen<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2019_02\/pic_1180_010.png\")
<\/p>\nPrivate Sub <\/span>lstBenutzergruppen_AfterUpdate()\r\n BerechtigungenAnzeigen\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>lstElemente_AfterUpdate()\r\n BerechtigungenAnzeigen\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>BerechtigungenAnzeigen()\r\n Dim <\/span>varElement As Variant<\/span>\r\n Dim <\/span>lngElementID As Long<\/span>\r\n Dim <\/span>varBenutzergruppe As Variant<\/span>\r\n Dim <\/span>lngBenutzergruppeID As Long<\/span>\r\n Dim <\/span>lngBerechtigungsstufeID As Long<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n For i = 0 To Me!lstBerechtigungsstufen.ListCount - 1\r\n Me!lstBerechtigungsstufen.Selected(i) = False<\/span>\r\n Next<\/span> i\r\n For Each varElement In Me!lstElemente.ItemsSelected\r\n lngElementID = Me!lstElemente.ItemData(varElement)\r\n For Each varBenutzergruppe In Me!lstBenutzergruppen.ItemsSelected\r\n lngBenutzergruppeID = Me!lstBenutzergruppen.ItemData(varBenutzergruppe)\r\n lngBerechtigungsstufeID = Nz(DLookup(\"BerechtigungsstufeID\", \"tblObjekteBenutzergruppenBerechtigungen\", _\r\n \"ObjektID = \" & lngElementID & \" AND BenutzergruppeID = \" & lngBenutzergruppeID), 3)\r\n Me!lstBerechtigungsstufen.Selected(lngBerechtigungsstufeID - 1) = True<\/span>\r\n Next<\/span> varBenutzergruppe\r\n Next<\/span> varElement\r\nEnd Sub<\/span><\/pre>\nBerechtigungen setzen<\/h2>\n
Private Sub <\/span>lstBerechtigungsstufen_AfterUpdate()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngBerechtigungsstufeID As Long<\/span>\r\n Dim <\/span>lngObjektID As Long<\/span>\r\n Dim <\/span>lngBenutzergruppeID As Long<\/span>\r\n Dim <\/span>varElement As Variant<\/span>\r\n Dim <\/span>varBenutzergruppe As Variant<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n If <\/span>Me!lstElemente.ItemsSelected.Count = 0 Then<\/span>\r\n MsgBox<\/span> \"Wählen Sie mindestens ein Element aus.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n If <\/span>Me!lstBenutzergruppen.ItemsSelected.Count = 0 Then<\/span>\r\n MsgBox<\/span> \"Wählen Sie mindestens eine Benutzergruppe aus.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n lngBerechtigungsstufeID = Me!lstBerechtigungsstufen.ListIndex + 1\r\n For i = 0 To Me!lstBerechtigungsstufen.ListCount - 1\r\n Me!lstBerechtigungsstufen.Selected(i) = False<\/span>\r\n