<\/p>\n
Es gibt verschiedene Möglichkeiten, auf Basis des aktuell angemeldeten Benutzers sicherzustellen, dass dieser nur die für ihn vorgesehenen Aktionen mit Daten durchführen darf – beispielsweise durch eine Prüfung in den Ereignisprozeduren, die durch Ereignisse wie „Vor Aktualisierung“ ausgelöst werden. Noch praktischer wäre es allerdings, wenn diese Prüfung nicht in jedem Formular programmiert werden müsste, sondern anwendungsweit verfügbar wäre – also auch dann, wenn der Benutzer es schafft, ohne Formulare auf die Tabellen mit den Daten zuzugreifen. Das gelingt mit Datenmakros. Wie genau, zeigt der vorliegende Beitrag.<\/b><\/p>\nGrundlage für unsere Beispielanwendung<\/h2>\n
Wenn wir Datenmakros für Tabellen programmieren wollen, die dafür sorgen, dass Benutzer abhängig von ihrer Benutzergruppe und den für diese vergebenen Berechtigungen auf den verschiedenen Tabellen Daten an den Tabellen ändern können, benötigen wir einige Tabellen, in denen wir die Berechtigungen speichern. In unserem Fall haben wir 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>) bereits einiges an Vorarbeit geleistet. Dort haben wir nämlich sowohl die Tabellen definiert, mit denen wir die Benutzer, Benutzergruppen, Tabellen und Berechtigungen sowie die Zuordnung der Berechtigungen zu den Kombinationen aus Benutzergruppen und Tabellen verwalten.<\/p>\nErmitteln des aktuellen Benutzers<\/h2>\n
Um die Berechtigungen für den Zugriff auf eine Tabelle zu ermitteln, benötigen wir die Benutzerdaten. Darüber ermitteln wir die Benutzergruppe und schließlich die Berechtigung an der angegebenen Tabelle. Die Benutzerdaten haben wir im Beitrag Benutzer und Berechtigungen ermitteln <\/b>(www.access-im-unternehmen.de\/1192<\/b>) nach der Anmeldung in einer temporären Variablen gespeichert. Das hilft in einem Datenmakro leider nicht weiter, denn von dort aus können wir nicht auf temporäre Variablen zugreifen. Also müssen wir die Prozedur im Formular frmAnmeldungen<\/b>, welche die Benutzerdaten nach der Prüfung der Kombination aus Benutzername und Kennwort in temporären Variablen gespeichert hat, zunächst so ändern, dass die BenutzerID <\/b>und der Benutzername in einer Tabelle landen – die in diesem Fall tblOptionen <\/b>heißen soll. Die Prozedur cmdAnmelden_Click<\/b> ändern wir dazu wie in Listing 1. Die Prozedur trägt zunächst den Benutzernamen aus dem Textfeld txtBenutzername <\/b>in die Variable strBenutzername <\/b>ein. Dann prüft sie mit der Funktion AnmeldungPruefen<\/b>, ob die Anmeldedaten korrekt sind. Ist dies der Fall, ermittelt sie per DLookup <\/b>den Wert des Feldes BenutzerID <\/b>für den angegebenen Benutzernamen und speichert diesen in der Variablen lngBenutzerID<\/b>.<\/p>\n Listing 1: Prozedur zum Speichern der Daten nach der Anmeldung in der Tabelle tblOptionen<\/span><\/b><\/p>\n Damit versucht sie, die beiden Felder Benutzername <\/b>und BenutzerID <\/b>in der Tabelle tblOptionen <\/b>durch den Aufruf einer UPDATE<\/b>-Anweisung auf die neuen Werte zu aktualisieren. Ob das gelungen ist, zeigt die Eigenschaft RecordsAffected <\/b>im Anschluss. Liefert sie den Wert 0<\/b>, wurde kein Datensatz geändert, was nur bedeuten kann, dass noch kein Datensatz vorhanden ist. In diesem Fall ruft die Prozedur eine INSERT INTO<\/b>-Anweisung auf und fügt einen neuen Datensatz mit den gewünschten Werten zur Tabelle tblOptionen <\/b>hinzu.<\/p>\n Sollte die Funktion AnmeldungPruefen <\/b>den Wert False <\/b>zurückgeliefert haben, füllt die Prozedur auf die gleiche Art das Feld BenutzerID <\/b>mit dem Wert 0 <\/b>und Benutzername <\/b>mit einer leeren Zeichenkette.<\/p>\n Wenn wir etwa das Ändern der Daten eines Datensatzes unterbinden wollen, können wir das durch ein ganz einfaches Datenmakro erledigen. Wir schauen uns das am Beispiel der Tabelle tblKunden <\/b>an, für die wir Änderungen zunächst komplett verhindern wollen. Dazu legen wir ein Datenmakro an, indem wir bei in der Datenblattansicht geöffneter Tabelle den Ribbon-Eintrag Tabelle|Vorabereignisse|Vor Änderung <\/b>anklicken (siehe Bild 1).<\/p>\n Bild 1: Anlegen eines Datenmakros per Ribbon-Befehl<\/span><\/b><\/p>\n Das öffnet den Makro-Editor für dieses Makro, dem wir nur eine einzige Makro-Aktion hinzufügen (siehe Bild 2). Diese enthält den Befehl AuslösenFehler <\/b>mit der Nummer 1 <\/b>und dem Text Ändern nicht möglich <\/b>als Fehlerbeschreibung.<\/p>\n Bild 2: Einfaches Makro zum Unterbinden von Änderungen<\/span><\/b><\/p>\n Wenn Sie nun den Makro-Editor schließen und versuchen, einen der Datensätze der Tabelle tblKunden <\/b>zu ändern, erhalten Sie beim Speichern die Meldung aus Bild 3. Ein ähnliches Datenmakro können Sie für das Ereignis Vor Löschung <\/b>anlegen – in diesem Fall mit einer entsprechenden Fehlermeldung wie Löschen nicht möglich<\/b>. Wenn Sie nun versuchen, einen der Datensätze zu löschen, wird das ebenfalls nicht gelingen.<\/p>\n Bild 3: Meldung beim Versuch, einen Datensatz zu ändern<\/span><\/b><\/p>\n Was aber geschieht, wenn wir einen neuen Datensatz anlegen möchten Dann erscheint die gleiche Meldung wie beim Versuch, den Datensatz zu ändern. Hier müssen wir also noch differenzieren. Das erledigen wir im Datenmakro für das Ereignis Vor Änderung<\/b>, indem wir eine Wenn<\/b>-Bedingung hinzufügen, für die wir die Bedingung IstNull([Alt].[KundeID]) <\/b>festlegen (siehe Bild 4). Alt <\/b>enthält ein Recordset mit den Daten des Datensatzes vor dem Ändern. Bei einem vorhandenen Datensatz liefert KundeID <\/b>den zwangsläufig vorhandenen Primärschlüsselwert, beim Anlegen eines neuen Datensatzes ist [Alt].[KundeID] <\/b>leer, als NULL<\/b>.<\/p>\n Bild 4: Unterscheidung von neuen und vorhandenen Datensätzen beim Ändern<\/span><\/b><\/p>\n Wenn dies der Fall ist, soll das Makro die Meldung Anlegen nicht möglich <\/b>ausgeben, sonst Ändern nicht möglich<\/b> (siehe Bild 5).<\/p>\n Bild 5: Meldung beim Versuch, einen neuen Datensatz anzulegen<\/span><\/b><\/p>\n Damit kommen wir zu dem Punkt, wo wir die Meldungen nur in Abhängigkeit von den Berechtigungen des Benutzers an der jeweiligen Tabelle anzeigen wollen.<\/p>\n <\/p>\n Wenn also etwa ein Benutzer angemeldet ist, der Daten der Tabelle tblKunden <\/b>anlegen und ändern, diese aber nicht löschen darf, soll nur das Löschen von Datensätzen unterbunden werden.<\/p>\n Da wir nun die Daten des aktuellen Benutzers in einer Tabelle namens tblOptionen <\/b>speichern und diese auch den Wert des Primärschlüsselfeldes des angemeldeten Benutzers enthält, können wir eine Abfrage erstellen, welche diese Daten der Tabelle tblOptionen <\/b>nutzt. Dazu fügen wir dieser Abfrage, die wir unter dem Namen qryTabellenberechtigungen <\/b>speichern wollen, die Tabellen aus Bild 6 hinzu.<\/p>\n Bild 6: Abfrage zum Ermitteln der Berechtigungen <\/span><\/b><\/p>\n Hier sehen Sie auch, dass wir nur zwei Felder zum Entwurfsraster hinzufügen, nämlich Tabelle <\/b>und BerechtigungID<\/b>. Das reicht aus, um zu ermitteln, ob der aktuelle Benutzer eine bestimmte Berechtigung für eine Tabelle hat. Den aktuellen Benutzer ermitteln wir ja bereits über die Tabelle tblOptionen<\/b>, daher müssen wir die Daten der Abfrage nur noch nach dem Namen der zu untersuchenden Tabelle und der zu berücksichtigenden Berechtigung filtern.<\/p>\n Denn wir wollen ja nicht alle Berechtigungen des Benutzers an einer Tabelle ermitteln, sondern nur prüfen, ob der Benutzer über eine bestimmte Berechtigung verfügt. Im Datenmakro Vor Löschung <\/b>etwa wollen wir nur wissen, ob der aktuell angemeldete Benutzer etwa für die Tabelle tblKunden <\/b>über das Löschen<\/b>-Recht verfügt, also das Recht mit dem Wert 8<\/b>. Die Berechtigungen für den aktuellen Benutzer liefert die Abfrage etwa wie in Bild 7. Wenn wir die Abfrage nun nach der Tabelle tblKunden <\/b>und der BerechtigungID <\/b>mit dem Wert 8 <\/b>filtern, erhalten wir nur noch einen Datensatz – oder eben keinen, falls diese Berechtigung für den Kunden nicht festgelegt wurde.<\/p>\n Bild 7: Berechtigungen für den aktuellen Benutzer<\/span><\/b><\/p>\n Das Datenmakro Vor Löschung <\/b>der Tabelle tblKunden<\/b> soll nun prüfen, ob es einen Datensatz in der Abfrage qryTabellenberechtigungen<\/b> gibt, der die Bedingung aus Bild 8 erfüllt. Dazu fügen wir die Makroaktion Datensatz nachschlagen in <\/b>hinzu und geben die Abfrage qryTabellenberechtigungen <\/b>als Datenquelle an. Als Bedingung geben wir den folgenden Ausdruck an:<\/p>\n Bild 8: Datenmakro für das Prüfen der Löschen-Berechtigung<\/span><\/b><\/p>\n Nun muss man wissen, dass man der Makroaktion Datensatz nachschlagen in <\/b>weitere Makroaktionen unterordnen kann, die nur dann ausgeführt werden, wenn die Datensatzgruppe mindestens einen Datensatz enthält. Das machen wir uns hier zunutze, indem wir für diesen Fall die Makroaktion StoppMakro <\/b>einfügen. Das sorgt dafür, dass das Makro an dieser Stelle beendet wird – also genau dann, wenn die gewünschte Berechtigung für die angegebene Tabelle vorhanden ist.<\/p>\n Ist kein Datensatz vorhanden, wird StoppMakro <\/b>nicht ausgeführt und das Datenmakro läuft hinter der Aktion Datensatz nachschlagen in <\/b>einfach weiter. In diesem Fall wird dann die AuslösenFehler<\/b>-Aktion ausgeführt, welche die Meldung Löschen nicht möglich <\/b>anzeigt. Und durch den Aufruf der AuslösenFehler<\/b>-Makroaktion wird die das Makro auslösende Aktion, in diesem Fall also das Löschen des Datensatzes, nicht mehr abgeschlossen.<\/p>\n Sie können dies nun ausprobieren, indem Sie sich einmal als ein Benutzer anmelden, der über mindestens eine Gruppe die Berechtigung zum Löschen von Daten in der Tabelle tblKunden <\/b>besitzt und dann einen Datensatz aus der Tabelle tblKunden <\/b>löschen. Dies sollte problemlos möglich sein – mit der Ausnahme von Datensätzen, für die bereits ein verknüpfter Datensatz in der Tabelle tblBestellungen <\/b>vorliegt. Dieser wird in der Beispieldatenbank aufgrund der referenziellen Integrität nicht gelöscht. Wenn Sie sich dann als ein anderer Benutzer anmelden, der kein Löschen-Recht an dieser Tabelle besitzt oder einfach dem aktuellen Benutzer das Löschen-Recht entziehen, sollte beim Versuch, einen Datensatz aus der Tabelle tblKunden <\/b>zu löschen, eine entsprechende Meldung erscheinen.<\/p>\n Auf die gleiche Weise kümmern wir uns nun um die Berechtigungen zum Anlegen oder Ändern von Daten in der Tabelle tblKunden<\/b>. Das Makro sieht wie in Bild 9 aus. Hier verwenden wir die bereits weiter oben vorgestellte Wenn…Sonst<\/b>-Bedingung weiter, mit der wir geprüft haben, ob der Benutzer gerade einen vorhandenen oder einen neuen Datensatz ändern möchte.<\/p>\n Bild 9: Datenmakro für das Prüfen der Ändern- und Anlegen-Berechtigung<\/span><\/b><\/p>\n Im ersten Teil der Bedingung schlagen wir den Datensatz der Abfrage qryTabellenberechtigungen <\/b>nach, der die Tabelle tblKunden <\/b>im Feld Tabelle <\/b>und den Wert 2 <\/b>im Feld BerechtigungID <\/b>aufweist. Ist ein solcher Datensatz vorhanden, wird das Makro abgebrochen und der Datensatz kann angelegt werden. Falls nicht, wird die AuslösenFehler<\/b>-Aktion aufgerufen.<\/p>\n Im zweiten Teil geschieht der gleiche Ablauf, nur dass dieser ausgelöst wird, wenn der Benutzer einen bestehenden Datensatz ändern möchte. Dementsprechend prüfen wir mit der Abfrage qryTabellenberechtigungen<\/b>, ob es einen Datensatz gibt, der im Feld Tabelle <\/b>den Wert tblKunden <\/b>und im Feld BerechtigungID <\/b>den Wert 4 <\/b>enthält.<\/p>\n Wenn wir diese Makroaktion für alle Tabellen der Datenbank anwenden wollen, haben wir je nach der Anzahl der Tabellen eine umfangreiche Aufgabe vor uns. Wir können zwar den Inhalt eines Makros mit Copy and Paste von einer Tabelle zur nächsten übertragen, aber zusätzlich müssen wir auch noch in jedem Makro den Namen der Tabelle in der Bedingung für die Makroaktion Datensatz nachschlagen in <\/b>anpassen.<\/p>\n Wie also können wir dies vereinfachen Zum Glück kennen wir ein paar Tricks, zum Beispiel die Methode LoadFromText<\/b>, die ein Objekt aus einer Textdatei erzeugt. Das geht seit einigen Access-Versionen auch für Objekte mit der Konstanten acTableDataMacro <\/b>als ersten Parameter. Und wir wissen, dass die Datenmakros schlicht und einfach XML-Dokumente sind. Wenn wir also unsere beiden bereits programmierten Datenmakros für die Tabelle tblKunden <\/b>nehmen und diese per VBA so ändern, dass sie sich nicht mehr auf die Tabelle tblKunden<\/b>, sondern auf die Tabelle tblArtikel <\/b>und nicht mehr auf das Primärschlüsselfeld KundeID<\/b>, sondern ArtikelID <\/b>beziehen, brauchen wir das XML-Dokument nur noch als Textdatei zu speichern und diese Textdatei mit der LoadFromText<\/b>-Methode für eine andere Tabelle, hier tblArtikel<\/b>, zur Datenbank hinzuzufügen. Der Aufruf der LoadFromText<\/b>-Methode würde dann etwa so aussehen:<\/p>\n Dies haben wir in der Prozedur aus Listing 2 realisiert. Die Prozedur erwartet zwei Parameter, nämlich den Namen der anzupassenden Tabelle sowie den Namen des Primärschlüsselfeldes der Tabelle. Der folgende Aufruf fügt beispielsweise die nötigen Datenmakros zur Tabelle tblArtikel <\/b>hinzu:<\/p>\n Listing 2: Prozedur zum Hinzufügen der Datenmakros zu einer Tabelle <\/span><\/b><\/p>\n Den ersten Parameter benötigt die Prozedur gleich an mehreren Stellen. Zunächst einmal wird dieser in der Bedingung der Makroaktion Datensatz nachschlagen in <\/b>benötigt. Außerdem benötigen wir diesen, um die Datenmakros mit der LoadFromText<\/b>-Anweisung zur richtigen Tabelle hinzuzufügen. Den zweiten Parameter benötigen wir für die Wenn<\/b>-Makroaktion im Datenmakro Vor Änderung <\/b>an der Stelle, wo wir prüfen, ob das Primärschlüsselfeld des zu ändernden beziehungsweise anzulegenden Datensatzes leer ist.<\/p>\n Den Tabellennamen und den Primärschlüsselnamen fügen wir beim Zusammensetzen des XML-Codes für die Datenmakros direkt in dem XML-Code ein. Am Ende erhalten wir so in der Variablen strMakro <\/b>den Code für das komplette Datenmakro. Dieser ist im Listing aus Platzgründen gekürzt.<\/p>\n Der interessante Teil der Prozedur folgt nach dem Zusammensetzen des XML-Codes. Hier stellt die Prozedur zunächst einen Dateinamen für die zunächst zu erstellende Textdatei zusammen. Die Datei soll den Namen der Tabelle und die Endung .txt <\/b>erhalten und im Verzeichnis der aktuellen Datenbank gespeichert werden. Dann löscht die Prozedur eine eventuell vorhandene Datei gleichen Namens und erstellt die Datei dann mit der Open<\/b>-Anweisung neu, um mit der Print<\/b>-Anweisung den Inhalt der String<\/b>-Variablen strMakro <\/b>in die Datei zu schreiben. Diese wird dann mit der Close<\/b>-Anweisung geschlossen. Schließlich liest die LoadFromText<\/b>-Anweisung die Datei unter dem Typ acTableDataMacro <\/b>für die mit dem zweiten Parameter angegebene Tabelle ein.<\/p>\n Wenn Sie dies für alle in der Datenbank enthaltenen Tabellen erledigen wollen, können Sie eine Prozedur programmieren, die alle TableDef<\/b>-Objekte durchläuft und die Prozedur DatenmakrosZuTabelleHinzufuegen <\/b>für jede Tabelle einmal aufruft. Diese Prozedur könnte vereinfacht wie folgt aussehen:<\/p>\n Vereinfacht deshalb, weil wir hier davon ausgehen, dass das erste Feld einer Tabelle auch das Primärschlüsselfeld dieser Tabelle ist. Es gibt zuverlässigere Methoden, den Namen des Primärschlüsselfeldes zu ermitteln, aber für die meisten Tabellen funktioniert diese Prozedur. Wenn Sie diese Prozedur aufrufen, erhalten alle Tabellen die Datenmakros Vor Änderung <\/b>und Vor Löschung <\/b>mit angepassten Tabellen- und Primärschlüsselnamen.<\/p>\n Dieser Beitrag zeigt, wie Sie das Anlegen, Ändern und Löschen von Datensätzen über Datenmakros entsprechend der angegebenen Berechtigungen einschränken können.<\/p>\n Um das System abzurunden, das die Beiträge dieser Ausgabe erläutern, müssen wir noch einen Weg finden, die Tabellen vor dem Zugriff der Benutzer zu schützen. Darum kümmern wir uns in der nächsten Ausgabe von Access im Unternehmen unter dem Titel Tabellen vor unerlaubtem Zugriff schützen <\/b>(www.access-im-unternehmen.de\/1196<\/b>).<\/p>\n Enthaltene Beispieldateien:<\/p>\n ZugriffsrechteMitDatenmakros.accdb<\/p>\nPrivate Sub <\/span>cmdAnmelden_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strBenutzername As String<\/span>\r\n Dim <\/span>lngBenutzerID As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n strBenutzername = Nz(Me!txtBenutzername, \"\")\r\n If <\/span>AnmeldungPruefen(strBenutzername, Nz(Me!txtKennwort, \"\")) = True<\/span> Then<\/span>\r\n lngBenutzerID = DLookup(\"BenutzerID\", \"tblBenutzer\", \"Benutzername = ''\" & strBenutzername & \"''\")\r\n db.Execute \"UPDATE tblOptionen SET Benutzername = ''\" & strBenutzername & \"'', BenutzerID = \" & lngBenutzerID, _\r\n dbFailOnError\r\n If <\/span>db.RecordsAffected = 0 Then<\/span>\r\n db.Execute \"INSERT INTO tblOptionen(Benutzername, BenutzerID) VALUES(''\" & strBenutzername & \"'', \" _\r\n & lngBenutzerID & \")\", dbFailOnError\r\n End If<\/span>\r\n DoCmd.Close acForm, Me.Name\r\n Else<\/span>\r\n MsgBox<\/span> \"Anmeldung nicht erfolgreich.\"\r\n db.Execute \"INSERT INTO tblOptionen(Benutzername, BenutzerID) VALUES(\"\", 0)\", dbFailOnError\r\n If <\/span>db.RecordsAffected = 0 Then<\/span>\r\n db.Execute \"UPDATE tblOptionen SET Benutzername = '''' AND BenutzerID = 0\", dbFailOnError\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nÄndern per Datenmakro unterbinden<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2019_03\/pic_1193_002.png\")
<\/p>\n![\"Einfaches](\"..\/fileadmin\/_temp_\/2019_03\/pic_1193_001.png\")
<\/p>\n![\"Meldung](\"..\/fileadmin\/_temp_\/2019_03\/pic_1193_003.png\")
<\/p>\n![\"Unterscheidung](\"..\/fileadmin\/_temp_\/2019_03\/pic_1193_004.png\")
<\/p>\n![\"Meldung](\"..\/fileadmin\/_temp_\/2019_03\/pic_1193_005.png\")
<\/p>\nAnmeldung prüfen<\/h2>\n
Abfrage zum Ermitteln der Berechtigung<\/h2>\n
![\"Abfrage](\"..\/fileadmin\/_temp_\/2019_03\/pic_1193_006.png\")
<\/p>\n![\"Berechtigungen](\"..\/fileadmin\/_temp_\/2019_03\/pic_1193_007.png\")
<\/p>\nDatenmakro zum Prüfen der Berechtigung vor dem Löschen<\/h2>\n
![\"Datenmakro](\"..\/fileadmin\/_temp_\/2019_03\/pic_1193_008.png\")
<\/p>\n[Tabelle]=''tblKunden'' Und [BerechtigungID]=8<\/pre>\n
Löschen testen<\/h2>\n
Ändern und Anlegen mit Berechtigungen versehen<\/h2>\n
![\"Datenmakro](\"..\/fileadmin\/_temp_\/2019_03\/pic_1193_009.png\")
<\/p>\nAnlegen der Makroaktionen für weitere Tabellen<\/h2>\n
LoadFromText acTableDataMacro, \"tblArtikel\", \"c:\tblArtikel.txt\"<\/pre>\n
Public Sub <\/span>DatenmakrosZuTabelleHinzufuegen(strTabelle As String<\/span>, strPK As String<\/span>)\r\n Dim <\/span>strMakro As String<\/span>\r\n Dim <\/span>strDateiname As String<\/span>\r\n strMakro = strMakro & \"<xml version=\"\"1.0\"\" encoding=\"\"UTF-16\"\" standalone=\"\"no\"\">\" & vbCrLf<\/span>\r\n strMakro = strMakro & \"<DataMacros xmlns=\"\"...\"\">\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <DataMacro Event=\"\"BeforeChange\"\">\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Statements>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <ConditionalBlock>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <If>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Condition>IsNull([Old].[\" & strPK & \"])<\/Condition>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Statements>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <LookUpRecord>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Data Alias=\"\"dsTabellenberechtigungen\"\">\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Reference>qryTabellenberechtigungen<\/Reference>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <WhereCondition>[Tabelle]=''\" & strTabelle & \"'' And [BerechtigungID]=2 <\/WhereCondition>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <\/Data>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Statements>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Action Name=\"\"StopMacro\"\"\/>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <\/Statements>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <\/LookUpRecord>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Action Name=\"\"RaiseError\"\">\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Argument Name=\"\"Number\"\">2<\/Argument>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Argument Name=\"\"Description\"\">Anlegen nicht möglich.<\/Argument>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <\/Action>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <\/Statements>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <\/If>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Else>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Statements>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <LookUpRecord>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Data Alias=\"\"dsTabellenberechtigungen\"\">\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Reference>qryTabellenberechtigungen<\/Reference>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <WhereCondition>[Tabelle]=''\" & strTabelle _\r\n & \"'' And [BerechtigungID]=4<\/WhereCondition>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <\/Data>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Statements>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \" <Action Name=\"\"StopMacro\"\"\/>\" & vbCrLf<\/span>\r\n ...\r\n strMakro = strMakro & \" <\/DataMacro>\" & vbCrLf<\/span>\r\n strMakro = strMakro & \"<\/DataMacros>\" & vbCrLf<\/span>\r\n strDateiname = CurrentProject.Path & \"\" & strTabelle & \".txt\"\r\n On Error Resume Next<\/span>\r\n Kill strDateiname\r\n On Error GoTo<\/span> 0\r\n Open strDateiname For Append As <\/span>#1\r\n Print #1, strMakro\r\n Close #1\r\n LoadFromText acTableDataMacro, strTabelle, strDateiname\r\nEnd Sub<\/span><\/pre>\nDatenmakrosZuTabelleHinzufuegen \"tblArtikel\", \"ArtikelID\"<\/pre>\n
Public Sub <\/span>DatenmakrosZuAllenTabellen()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>strPK As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n For Each tdf In db.TableDefs\r\n If <\/span>Not<\/span> Left<\/span>(tdf.Name, 4) = \"MSys\" Then<\/span>\r\n strPK = tdf.Fields(0).Name\r\n DatenmakrosZuTabelleHinzufuegen tdf.Name, strPK\r\n End If<\/span>\r\n Next<\/span> tdf\r\nEnd Sub<\/span><\/pre>\nZusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h3>\n