Probleme mit der Navigation wegen Rechtesystem

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Probleme mit der Navigation wegen Rechtesystem

    Hallo zusammen,

    ich arbeite gerade an einer Navigation, deren Links von einer Datenbank ausgelesen werden, und dann über das Rechtesystem "ausgewertet" wird, ob der Link angezeigt werden soll, oder nicht (Das Rechtesystem steckt noch in Kinderschuhen).

    Die Datenbank ist folgendermaßen aufgebaut:

    id | aktiv | kategorie_id | name | url | stelle | rechte

    (nur id für die db | ob der link überhaupt angezeigt werden soll oder nicht | zu welcher "Überordnung" der Link gehört | wird für den Link angezeigt | dreimal dürft ihr raten | an wievielter stelle der Link stehen soll | wer den Link sehen darf)

    Das Rechtesystem ist mit einem gestaffeltem Zahlensystem aufgebaut:

    0: Nicht angemeldet
    25: Normaler User, nur die normalen Rechte
    50: Moderatoren
    75: Entwickler
    100: Admin

    (wie gesagt, steckt noch in den Kinderschuhen)

    Das Auslesesystem für doie Anzeige:

    Quellcode

    1. $ergebnis = $mysqli->query("SELECT id, aktiv, name, url, rechte FROM navigation_kategorie ORDER BY stelle");
    3. echo "<ul>\n";
    4. while ($result = $ergebnis->fetch_object())
    5. {
    6. if (((($result->rechte <= "24")&&($user->rechte >= "25"))||(($result->rechte <= "24")&&(!isset($user)))||(($result->rechte >= "24")&&($user->rechte >= "25")))&&($result->aktiv == "1")) {
    7. $navi_kate_id = $result->id;
    8. $abfrage = $mysqli->query("SELECT id, aktiv, login, name, url, rechte FROM navigation_links WHERE kategorie_id = '$navi_kate_id' ORDER BY stelle");
    10. echo "<li>";
    11. echo "<a href=\"".$result->url."\">";
    12. echo bbcode($result->name);
    13. if (($result->id == "4")&&($_SESSION['eingeloggt'] == TRUE))
    14. {
    15. echo " [".$user->username."]";
    16. }
    17. echo "</a>\n";
    18. echo "<ul>\n";
    19. while ($row = $abfrage->fetch_object())
    20. {
    21. if (((($row->rechte <= "24")&&($user->rechte >= "25"))||(($row->rechte <= "24")&&(!isset($user)))||(($row->rechte >= "25")&&($user->rechte >= "25")))&&($row->aktiv == "1"))
    22. {
    23. echo "<li><a href=\"".$row->url."\">";
    24. echo bbcode($row->name."</a></li>\n");
    25. }
    26. }
    27. echo "</ul>";
    28. echo "</li>\n";
    29. }
    30. }
    31. echo "</ul>\n";
    Alles anzeigen


    Jetzt habe ich das Problem, dass drei Links nur angezeigt werden sollen, wenn man nicht eingeloggt ist ("Login", "Registrieren", "Passwort vergessen"). Doch da ich mit dem Rechtesystem bei den drei Links bei Rechte 0 eingetragen habe, werden diese auch angezeigt, wenn man eingeloggt ist.

    Wie kann man das am schlauesten lösen, was meint ich?

    Danke schonmal

    Fipsi

  • Wenst mich fragst ist das zahlen System Müll. Ist von Anfänger enstanden um nee abgrenzen zu bewerkstelligen. Am ende ist das unübersichtlich und nicht wirklich mehr Kontrollierbar.

    Wenn du ein Rechtesystem haben willst dann schau dir mal ACL an (Access Controll List)
    Ein Beispiel dafür hab ich vor langen in OOP geschrieben. (Jeder hat mal Angefangen auch ich )

    Hier meine Anfänge einer Acl:
    (siehe letzen Beitrag von mir)
    php2all.de/thread-651-rechtesystem.html

    Dort findest du ein Anfänger Beispiel einer Acl

    Du hast die möglichkeit über ein Array zu Arbeiten oder wie im Beispiel über die Datenbank
    In dem Beispiel kann ein User mehren Gruppen angehören. Also können die Rechte leicht gändert und weiter vergeben werden.
    Zb kann ein User dann der Gruppe Moderator sowie auch der Gruppe Entwickler angehören.
    Es gibt kein Limit für die Anzahl der Gruppen die man angehören kann.

    Jede Gruppe hat ihre eigenen Rechte. Überschneidende Rechte werden gefiltert und das höhere Recht immer zu gewiessen
    Wenn nun die Gruppe Moderator das recht zum lesen hat. Und die Gruppe Entwickler das Recht zu schreiben auf bestimmten Seiten.
    Der User nun beiden Gruppen angehört kann er lesen sowol auch schreiben.

    So kannst du auch eine Gruppe festlegen für User die nicht angemeldet sind (Also nicht eingelogt) Und rechte vergeben was diese User sehen dürfen und machen können.

    Im Letzten Teil wird dann das Recht geprüft.

    Quellcode

    1. <?
    2. $access = new Access();
    3. if(!$access->zugang($user,"log")) // log ist der Rechtename
    4. {
    5. die('Zugriff auf die Seite Verweigert');
    6. }
    7. echo "Zugang Erlaubt";




    Mfg Splasch

    Dieser Beitrag wurde bereits 7 mal editiert, zuletzt von splasch ()

  • Fipsi schrieb:

    ok, ich fürchte, dannw erde ich vorerst noch n "kleines" Problem damit haben, da ich mit OOP noch nich zurecht komme, arbeite aber immernoch daran das endlich zu ändern.

    Danke dir schonmal für deine Hilfe, hatte aber gehofft, das ginge auch ohne OOP


    Es geht ohne OOP
    Eine Acl kannst du ohne OO auch umsetzen das war ja nur ein Beispiel und hat nix mit der Technick zu tun. Am einfachsten für dich wird es sein mit Array Listen zur Arbeiten.

    Ob du nun die Liste in der Datenbank oder als Array in einer Datei abbildest bleibt dir überlassen. Wenn du die Rechte nicht umbeding Online verwalten willst würd ich auf jeden Fall die Array variante vorziehen.

    Hier mal ein Beispiel wie so einen Acl Liste ausehen kann.

    Quellcode

    1. <?
    2. return array(
    4. 'roles' => array
    5. (
    6. 'author' => 'guest',
    7. 'user' => 'guest',
    8. 'admin' => 'user'
    9. ),
    11. 'resources' => array
    12. (
    13. 'index' => NULL, // Startseite
    14. 'galerie' => NULL, // Galerie
    15. 'login' => NULL, // Authorizierung Prüfung
    16. 'newadmin' => NULL, // Admin Tool
    17. 'about' => NULL, // About Edit
    19. ),
    21. 'rules' => array
    22. (
    23. 'allow' => array
    24. (
    25. // Gast Acount nicht eingelogt
    26. 'guest0' => array(
    27. 'role' => 'guest',
    28. 'resource' => array('login',
    29. ),
    30. 'privilege' => array('index','login','logout')
    31. ),
    33. // Admin Rechte
    34. 'admin99' => array(
    35. 'role' => 'admin',
    36. 'resource' => array('newadmin',
    37. ),
    38. 'privilege' => array('index','create')
    39. ),
    41. // Backend Startseite (Admin Rechte)
    42. 'admin0' => array(
    43. 'role' => 'admin',
    44. 'resource' => array('index'),
    45. 'privilege' => array('index')
    46. ),
    48. // Galerie Verwaltung (Admin Rechte der Seite Galerie Verwaltung)
    49. 'admin1' => array(
    50. 'role' => 'admin',
    51. 'resource' => array('galerie'),
    52. 'privilege' => array('index','add_picture','add_images',
    53. 'del_picture','del_images','add_album',
    54. 'save_album','album_photo','save_photoalbum',
    55. 'del_album','del_alben','sort_album','sort_alben',
    56. 'sort_picture','multiadd_picture','nophoto_album',
    57. )
    58. ),
    60. // Backend About
    61. 'admin2' => array(
    62. 'role' => 'admin',
    63. 'resource' => array('about'),
    64. 'privilege' => array('index','save_about')
    65. ),
    66. )
    Alles anzeigen


    Mach dich mal mit der Therio und technick vertraut bevor du sagt das kann man nicht umsetzen.
    Natürlich kann man hier nicht erwarten das man fertige Scripte bekommt dafür gibst nee Scriptbörse.

    Siehe auch: ACL erleuterung de.wikipedia.org/wiki/Access_Control_List

    Mfg Splasch

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von splasch ()

  • hm... also eigentlich habe ich vor, dass die Rechteverwaltung "mobil" bleibt, also denke ich, dass eine Onlineverwaltung (sprich Datenbank) wahrscheinlich geschickter wäre.

    Ich hab mir dein gerade gezeigtes Beispiel mal ein paarmal durchgelesen und bissl genauer angeschaut und cih msus sagen, ich bin ein bisschen verwirrt:

    - Wie wird einem User sein Recht dann zugeordnet?
    - Muss ich also für jede Seite so n eigenes Rechtesystem basteln?
    - Bzw. muss ich jede Seite da eintragen und einstellen?

  • Fipsi schrieb:

    hm... also eigentlich habe ich vor, dass die Rechteverwaltung "mobil" bleibt, also denke ich, dass eine Onlineverwaltung (sprich Datenbank) wahrscheinlich geschickter wäre.

    Ich hab mir dein gerade gezeigtes Beispiel mal ein paarmal durchgelesen und bissl genauer angeschaut und cih msus sagen, ich bin ein bisschen verwirrt:

    - Wie wird einem User sein Recht dann zugeordnet?
    - Muss ich also für jede Seite so n eigenes Rechtesystem basteln?
    - Bzw. muss ich jede Seite da eintragen und einstellen?


    Am einfachsten ist es über Rollen du kennst das vielleicht von einer Forum Rechte Verwaltung.

    Dem User wird beim Login eine Rolle zu gewiesen. Für die Rolle selbst kannst du einen beliebigen Namen vergeben am besten einen ausagekräftigen.
    Zb. Moderator, Admin, User und so weiter

    Jede Rolle hat dann die zugewissen Rechte laut Liste.

    Muss ich also für jede Seite so n eigenes Rechtesystem basteln?


    Nein das Array oder die Datenbank abbildung speichert die Rechte für alle Seiten.

    Bzw. muss ich jede Seite da eintragen und einstellen

    Ja so kannst du nix vergessen oder übersehen. Seiten wo keine Rechte vergeben wurden sind generell gesperrt und nicht erreichbar.

    dass die Rechteverwaltung "mobil" bleibt, also denke ich, dass eine Onlineverwaltung (sprich Datenbank) wahrscheinlich geschickter wäre

    Es ist natürlich auch möglich das Array online zu bearbeiten und wieder zu Speichern.
    Siehe dazu php befehle wie: file_put_contents und var_export()

    Mfg Splasch

  • Ich bin gerade am überlegen, wie es am sinnvollsten is, so eine struktur mit Datenbank aufzubauen.

    Würde das gehen, wenn jedes mal wenn eine Seite aufgerufen wird, wird die Datenbank abgefragt, darf er diese Seite überhaupt sehen. Und jedes mal wird auch gleichzeitig überprüft, ob die aktuelle Rolle auch noch wirklich aktuell ist?
    Und wie wäre das dann mit der Navigation gehen...?^^

    P.S.: ich weiß, ich bin anstrengend, sry, aber ich bin noch im lernstadion :D

  • Fipsi schrieb:

    Ich bin gerade am überlegen, wie es am sinnvollsten is, so eine struktur mit Datenbank aufzubauen.

    Würde das gehen, wenn jedes mal wenn eine Seite aufgerufen wird, wird die Datenbank abgefragt, darf er diese Seite überhaupt sehen. Und jedes mal wird auch gleichzeitig überprüft, ob die aktuelle Rolle auch noch wirklich aktuell ist?
    Und wie wäre das dann mit der Navigation gehen...?^^

    P.S.: ich weiß, ich bin anstrengend, sry, aber ich bin noch im lernstadion :D


    Zur Datenbank Aufbau kannst du das fertige Er Diagram aus meinen OO Beispiel übernehmen wenn du willst. siehe php2all.de/thread-651-rechtesystem.html
    (Bild Anhang)

    Würde das gehen, wenn jedes mal wenn eine Seite aufgerufen wird, wird die Datenbank abgefragt, darf er diese Seite überhaupt sehen. Und jedes mal wird auch gleichzeitig überprüft, ob die aktuelle Rolle auch noch wirklich aktuell ist?


    Die Rolle ändert sich normal nicht während der ganzen Sitizung. Wenn deine Scripte Zentral aufgebaut sind reicht es aus einmal die Konfiguration zu laden.
    Wenn du unötige Datenbank zugriffe sparen willst. Kanst du auch das Array aus der Datenbank in die Session laden. So brauchst du nicht bei jeden Klick erneut die Datenbank abfragen.

    Bei Änderungen sollte du allerdings nicht vergessen das Session array auch zu aktualisieren.

    Siehe dazu auch mein OOP Test Ausgabe Beispiel laden der Datenbank informationen.

    Quellcode

    1. ?>
    2. #Laden der Berechtigungen
    3. $sql="SELECT
    4. grup_id,grup_name,re_name,re_bez
    5. FROM
    6. admin_gruppen,admin_rechte,gruppen,rechte
    7. WHERE
    8. f_userid='1' AND
    9. grup_id=admin_gruppen.f_grupid AND
    10. admin_gruppen.f_grupid=admin_rechte.f_grupid AND
    11. rechte.re_id = admin_rechte.f_reid
    12. ORDER by grup_name";
    14. $obj= new Dbpdo();
    15. $stmt =Dbpdo::get_db()->query($sql);
    16. $gruppe="";
    17. while ($data = $stmt->fetch(PDO::FETCH_OBJ))
    18. {
    19. if($gruppe=="" || $gruppe == $data->grup_name)
    20. {
    21. $rechte[$data->re_name]=$data->re_bez;
    22. $gruppe=$data->grup_name;
    23. echo $gruppe."";
    24. }
    25. else
    26. {
    27. # Alle Rechte der Gruppe laden
    28. $grupobj= new Gruppe($rechte,$gruppe); # Gruppe erstellen
    29. unset($rechte);
    30. $user->addGruppe($grupobj,$gruppe); # Gruppe den User zuweisen
    31. # Weiter Gruppen daten einlesen
    32. $rechte[$data->re_name]=$data->re_bez;
    33. $gruppe=$data->grup_name;
    34. echo "else:".$gruppe."";
    35. }
    36. }
    Alles anzeigen


    Und wie wäre das dann mit der Navigation gehen...?^^


    Wenn du das Rechtesystem etwas genauer betrachtest wirst du feststellen das es in der Liste privilege und resource gibt
    resource gibt die ganze Seite an auf die Zugriffen werden soll .
    privilege gibt die einzelne Elemente an auf dieser Seite auf die zugegriffen werden darf.

    Das kann nun alles sein angefangen von deiner Navigation bis hin zu Formular einträgen oder anderen Aktionen auf der Seite.
    Siehe dir dazu die Seite Galerie im Beispiel an hier noch mal der ausschnitt davon.

    Hier darf die Rolle Admin auf die Aktionen unter privilege gelistet sind zugreiffen. ('del_picture','del_images','add_album',
    'save_album','album_photo','save_photoalbum' und so weiter)

    Quellcode

    1. // Galerie Verwaltung (Admin Rechte der Seite Galerie Verwaltung)
    2. 'admin1' => array(
    3. 'role' => 'admin',
    4. 'resource' => array('galerie'),
    5. 'privilege' => array('index','add_picture','add_images',
    6. 'del_picture','del_images','add_album',
    7. 'save_album','album_photo','save_photoalbum',
    8. 'del_album','del_alben','sort_album','sort_alben',
    9. 'sort_picture','multiadd_picture','nophoto_album',


    Mfg Splasch

    Ps ich hab dir das Er Diagram der Datenbank hier nochmal im Anhang eingespielt.
    Bilder

    • Diagram_admin.png

      24,73 kB, 718×437, 240 mal angesehen

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von splasch ()

  • splasch schrieb:

    Fipsi schrieb:

    Ich bin gerade am überlegen, wie es am sinnvollsten is, so eine struktur mit Datenbank aufzubauen.

    Würde das gehen, wenn jedes mal wenn eine Seite aufgerufen wird, wird die Datenbank abgefragt, darf er diese Seite überhaupt sehen. Und jedes mal wird auch gleichzeitig überprüft, ob die aktuelle Rolle auch noch wirklich aktuell ist?
    Und wie wäre das dann mit der Navigation gehen...?^^

    P.S.: ich weiß, ich bin anstrengend, sry, aber ich bin noch im lernstadion :D


    Zur Datenbank Aufbau kannst du das fertige Er Diagram aus meinen OO Beispiel übernehmen wenn du willst. siehe php2all.de/thread-651-rechtesystem.html
    (Bild Anhang)


    Wenn ich das richtig sehe, dann gibts da ja eig. nur nen "normalen user" und nen "admin User"?

    splasch schrieb:

    Würde das gehen, wenn jedes mal wenn eine Seite aufgerufen wird, wird die Datenbank abgefragt, darf er diese Seite überhaupt sehen. Und jedes mal wird auch gleichzeitig überprüft, ob die aktuelle Rolle auch noch wirklich aktuell ist?


    Die Rolle ändert sich normal nicht während der ganzen Sitizung. Wenn deine Scripte Zentral aufgebaut sind reicht es aus einmal die Konfiguration zu laden.
    Wenn du unötige Datenbank zugriffe sparen willst. Kanst du auch das Array aus der Datenbank in die Session laden. So brauchst du nicht bei jeden Klick erneut die Datenbank abfragen.

    Bei Änderungen sollte du allerdings nicht vergessen das Session array auch zu aktualisieren.

    Siehe dazu auch mein OOP Test Ausgabe Beispiel laden der Datenbank informationen.


    Deswegen meinte ich, bei jedem Seitenladen die Datenbank erneut abrufen. Ich habe das z.Z., ich habe nur zwei Session: $_SESSION['eingeloggt'] und $_SESSION['id'], wenn $_SESSION['eingeloggt'] == TRUE wird bei jedem Seitenabruf alle user-daten mit der id $_SESSION['id'] erneut von der Datenbank abgerufen.

    splasch schrieb:

    Quellcode

    1. ?>
    2. #Laden der Berechtigungen
    3. $sql="SELECT
    4. grup_id,grup_name,re_name,re_bez
    5. FROM
    6. admin_gruppen,admin_rechte,gruppen,rechte
    7. WHERE
    8. f_userid='1' AND
    9. grup_id=admin_gruppen.f_grupid AND
    10. admin_gruppen.f_grupid=admin_rechte.f_grupid AND
    11. rechte.re_id = admin_rechte.f_reid
    12. ORDER by grup_name";
    14. $obj= new Dbpdo();
    15. $stmt =Dbpdo::get_db()->query($sql);
    16. $gruppe="";
    17. while ($data = $stmt->fetch(PDO::FETCH_OBJ))
    18. {
    19. if($gruppe=="" || $gruppe == $data->grup_name)
    20. {
    21. $rechte[$data->re_name]=$data->re_bez;
    22. $gruppe=$data->grup_name;
    23. echo $gruppe."";
    24. }
    25. else
    26. {
    27. # Alle Rechte der Gruppe laden
    28. $grupobj= new Gruppe($rechte,$gruppe); # Gruppe erstellen
    29. unset($rechte);
    30. $user->addGruppe($grupobj,$gruppe); # Gruppe den User zuweisen
    31. # Weiter Gruppen daten einlesen
    32. $rechte[$data->re_name]=$data->re_bez;
    33. $gruppe=$data->grup_name;
    34. echo "else:".$gruppe."";
    35. }
    36. }
    Alles anzeigen


    Also das funktioniert ja jez nur mit deinem anderem Code-teilen, weil des is ja n Teil aus dem OOP-teil, oder? (ich sag doch, mich mag OOP nich :D)

    splasch schrieb:

    Und wie wäre das dann mit der Navigation gehen...?^^


    Wenn du das Rechtesystem etwas genauer betrachtest wirst du feststellen das es in der Liste privilege und resource gibt
    resource gibt die ganze Seite an auf die Zugriffen werden soll .
    privilege gibt die einzelne Elemente an auf dieser Seite auf die zugegriffen werden darf.

    Das kann nun alles sein angefangen von deiner Navigation bis hin zu Formular einträgen oder anderen Aktionen auf der Seite.
    Siehe dir dazu die Seite Galerie im Beispiel an hier noch mal der ausschnitt davon.

    Hier darf die Rolle Admin auf die Aktionen unter privilege gelistet sind zugreiffen.


    Kann ich dazu auch ne Datenbank-tabelle machen und in der alles speichern? bzw. wie würde sowas dann ausschauen.

    Und was ich mit deinem Code auch noch nicht begriffen habe:

    Wie werden die Rechte dann eigentlich genau zugeordnet, bzw. wie heißen die Rechte?

  • Wenn ich das richtig sehe, dann gibts da ja eig. nur nen "normalen user" und nen "admin User"?


    Nein das Diagram ist für alle Rollen vollständig. Damals war es für Gruppen gedacht ist aber im grunde fast das selbe nur das es bei Gruppen mehre geben kann bei Rollen spricht man immer nur von einer pro user
    Wie die Tabellen namen benannt sind ist egal wobei die von mir damals nicht sehr passend bennant wurden. Entscheident ist die Userid das ist der User welche rolle du ihm dann zu weißt bleibt dir überlassen möglich sind endlos viele verschiedene Rollen. (admin, user,moderator und und)

    Also das funktioniert ja jez nur mit deinem anderem Code-teilen, weil des is ja n Teil aus dem OOP-teil, oder? (ich sag doch, mich mag OOP nich )


    Hier ging es mir in erste Linie um den Sql Befehl damit du sieht wie du die Daten abfragen kannst. Und die Sql Abfrage kannst du in deinen Script dann entsprechend auswerten ohne das du OO verwenden musst.
    Im Beispiel wird PDO verwendet für die Datenbank abfrage würd ich dir übrings auch empfehlen.
    siehe dazu : php.net/manual/de/book.pdo.php
    php.net/manual/de/pdo.prepare.php

    Kann ich dazu auch ne Datenbank-tabelle machen und in der alles speichern? bzw. wie würde sowas dann ausschauen.

    Und was ich mit deinem Code auch noch nicht begriffen habe:

    Wie werden die Rechte dann eigentlich genau zugeordnet, bzw. wie heißen die Rechte?


    Darin wird bereits alles gespeichert in dem Beispiel. Die rechte selbst sind den Rollen zugeordnet. Zur leichteren verständnis siehe dir dazu das Array an.
    Alle Rollen die User Besitzen und deren Rechte

    Mfg Splasch

  • Puh, langsam übersteigt das alles mein Verständnis, und ich krieg langsam Kopfweh davon...

    Ich glaube, ich nehm das jetzt einfach mal alles raus, kopier das in meinen Code, und versuch das dann zu verstehen.

    Nett wäre es nur auch zu wissen, wie die Rechte dann auch "zugeteilt" werden. Also ich mein jetzt, was mus sin die Datenbank eingetragen werden, damit er weiß, auf welches Recht er dem user zugestehen muss?

  • Fipsi schrieb:

    Puh, langsam übersteigt das alles mein Verständnis, und ich krieg langsam Kopfweh davon...

    Ich glaube, ich nehm das jetzt einfach mal alles raus, kopier das in meinen Code, und versuch das dann zu verstehen.

    Nett wäre es nur auch zu wissen, wie die Rechte dann auch "zugeteilt" werden. Also ich mein jetzt, was mus sin die Datenbank eingetragen werden, damit er weiß, auf welches Recht er dem user zugestehen muss?


    Vereinfacht gesagt brauchst du nur den Rollen Rechte zuweisen. Und die Rolle weißt du dann einfach den User x zu

  • so, also ich hab jetzt mal die kompletten Code's eingepackt, datenbank erstellt, und die letzte datei, die unter dem Link angegeben ist, nochmal in eine extra datei gepackt und ne funktion dazu gebastelt.

    Ich habe jetzt allerdings ein kleines Problem:

    Der sagt immer: Catchable fatal error: Argument 1 passed to User::addGruppe() must be an instance of Gruppe, null given, called in F:\Webserver\xampp\htdocs\data\templates\function\rechte\use.php on line 64 and defined in F:\Webserver\xampp\htdocs\data\templates\function\rechte\user.php on line 34
    (betrifft diese zeile: public function addGruppe(Gruppe $gruppe,$name))

    Die Datenbanken sind noch leer, da ich noch nicht so recht weiß, wie ich sie befüllen muss.

    Und wie genau muss ich das dann gleich ncchmal mit den Seiten machen? Die in eine Datenbank eintragen, und wie dann sagen, die rolle hat welches Recht?

  • Langsam hab ich den dreh raus, glaub ich:
    Gruppen und rechte gemacht, und diese Usern zugewiesen.
    jetzt muss ich eine Datenbank anlegen, in der alle seiten stehen, und welche rechte in ihn "herrschen".
    Jetzt habe ich glaube ich zumindest, das ganze begriffen.
    Wenn ich nochmal Probleme hab, melde ich mich nochmal

  • So, jetzt werd ich wohl erstmal nen Arschtritt kassieren, wegen dreifachpost, aber sonst könnte es überlesen werden.

    Also die Code's hab eich teilweise ein bisschen angepasst, so dass sie jetzt so ausschauen:

    user.php

    Quellcode

    1. class User extends Absgruppen
    2. {
    3. protected $user_id = 0;
    4. # Benutzer Nummer
    5. protected $user_name = '';
    6. # Benutzer Name protected
    8. /**
    9. * User Profil Eigenschaften füllen
    10. * @param $profil array
    11. * @return null */
    12. public function __construct($profil)
    13. {
    14. if(is_array($profil))
    15. {
    16. $this->user_id=$profil['id'];
    17. $this->user_name=$profil['name'];
    18. }
    19. return false;
    20. }
    22. /**
    23. * Neue Gruppe den User hinzufügen
    24. * @param $gruppe Objekt
    25. * @param $name String
    26. * @return void
    27. */
    28. public function addGruppe(Gruppe $gruppe,$name)
    29. {
    30. $this->setGruppe($gruppe,$name);
    31. }
    33. /**
    34. * Gibt das Angeforderte Gruppen Objekt zurück
    35. * @param $index String
    36. * @return gruppen Objekt
    37. */
    38. public function getGruppen($index)
    39. {
    40. return $this->gibGruppe($index);
    41. }
    43. /** * Gibt die Namen Aller Gruppen zurück
    44. * @param
    45. * @return array
    46. */
    47. public function getGrupNames()
    48. {
    49. return $this->gibGrupNames();
    50. }
    51. }
    Alles anzeigen


    absgruppen.php

    Quellcode

    1. abstract class Absgruppen
    2. {
    3. private $gruppen = array();
    4. # Gruppen Objekte private
    5. public $allName = array();
    6. # Namen aller Instanzierten Gruppen
    8. /**
    9. * Neue Gruppe den User hinzufügen
    10. * @param $gruppe Objekt
    11. * @param $name String
    12. * @return void
    13. */
    14. abstract public function addGruppe(Gruppe $gruppe,$name);
    15. /**
    16. * Neues Objekt der Gruppe in Array Speichern und den Gruppen Namen
    17. * @param $gruppe Objekt
    18. * @param $name String
    19. * @return void
    20. * Nur hinzufügen wenn das Objekt noch nicht vorhanden ist */
    22. function setGruppe(Gruppe $gruppe,$name)
    23. {
    24. if(is_object($this->gruppen[$name]))
    25. {
    26. #echo "Gruppe <b>".$name."</b> schon drin.";
    27. return;
    28. }
    29. $this->gruppen[$name]=$gruppe;
    30. $this->allName[]=$name;
    31. }
    33. /**
    34. * Gibt das Angeforderte Gruppen Objekt zurück
    35. * @param $index String
    36. * @return gruppen Objekt
    37. */
    38. function gibGruppe($index)
    39. {
    40. return $this->gruppen[$index];
    41. }
    43. /**
    44. * Gibt die Namen Aller Gruppen zurück
    45. * @param
    46. * @return array
    47. */
    48. function gibGrupNames()
    49. {
    50. return $this->allName;
    51. }
    52. }
    Alles anzeigen


    access.php

    Quellcode

    1. class Access
    2. {
    3. /**
    4. *
    5. * @param
    6. * @return null
    7. */
    9. public function __construct()
    10. {
    12. }
    14. /**
    15. * Pürfen ob der Zugriff zur Seite Erlaubt ist
    16. * @param $user Objekt
    17. * @param $seite String
    18. * @return bolean
    19. */
    20. public function zugang(User $user5,$seite)
    21. {
    22. # Session Prüfen
    23. if (!$this->checkSession())
    24. {
    25. return false;
    26. }
    27. foreach ($user->getGrupNames() as $gruppe)
    28. {
    29. if (array_key_exists($seite,$user5->getGruppen($gruppe)->getRechte()))
    30. {
    31. return true;
    32. }
    33. #echo "nicht enthalten in: ".$gruppe.ž;
    34. }
    35. return false;
    36. }
    38. /**
    39. * SESSION Prüfen
    40. * @return bolean
    41. */
    42. protected function checkSession()
    43. {
    44. if ((($_SESSION['eingeloggt'] == TRUE)&&($_SESSION['ip_adress'] != $_SERVER['REMOTE_ADDR'])||$_SESSION['eingeloggt'] != TRUE)&&(isset($_SESSION['id'])))
    45. {
    46. return false;
    47. }
    48. else
    49. {
    50. # Session Prüfung bestanden
    51. return true;
    52. }
    53. }
    54. //ende checkSession
    56. /**
    57. * Gibt alle Rechte aus allen Gruppen zurück
    58. * Führt die Rechte zusammen und Filtert doppelte Werte
    59. * @param
    60. * @return array
    61. */
    62. public function alleRechte(User $user)
    63. {
    64. $rechte=array();
    65. foreach ($user->getGrupNames() as $gruppe)
    66. {
    67. foreach ($user->getGruppen($gruppe)->getRechte() as $key=>$inhalt)
    68. {
    69. if(!array_key_exists($key,$rechte))
    70. {
    71. $rechte[$key]=$inhalt;
    72. }
    73. }
    74. }
    75. asort($rechte);
    76. return $rechte;
    77. }
    78. }
    Alles anzeigen


    dbpdo.php

    Quellcode

    1. class Dbpdo
    2. {
    3. private $uid = "f";
    4. #Benutzename
    5. private $pw = "";
    6. #Password
    7. private $serv = "";
    8. #Datenbank Server
    9. private $dbname = "";
    10. #Datenbank Name
    11. protected static $db_obj = null;
    12. #Datenbank Objekt PDO
    13. public $error;
    14. #Fehler Varibale
    16. /**
    17. * Klassen aufruf PDO verbindung aufbauen
    18. */
    19. public function __construct()
    20. {
    21. $db="mysql:dbname=".$this->dbname.";host=".$this->serv;
    22. #mysql:dbname=Datenbankname;host=localhost
    23. try
    24. {
    25. self::$db_obj = new PDO($db, $this->uid, $this->pw, array
    26. (
    27. PDO::ATTR_PERSISTENT => false,
    28. PDO::ATTR_ERRMODE => PDO::ERRMODE_WARNING
    29. #PDO::ERRMODE_EXCEPTION
    30. #PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true
    31. )
    32. );
    33. }
    34. catch (PDOException $e)
    35. {
    36. $this->error='Fehler beim Öffnen der Datenbank: ' . $e->getMessage();
    37. echo $this->error;
    38. #Fehler ausgabe
    39. }
    40. }
    42. /**
    43. * Eine Instanz des PDO Objektes übergeben
    44. * @return Objekt $db_obj
    45. */
    46. public static function get_db()
    47. {
    48. if(is_null(self::$db_obj))
    49. {
    50. self::$db_obj = new Dbpdo();
    51. }
    52. return self::$db_obj;
    53. }
    54. }
    Alles anzeigen


    gruppe.php

    Quellcode

    1. class Gruppe
    2. {
    3. protected $re_name = array();
    4. # Beschreibungs Name des Zugriffs | Seitenkennung(id) für den Zugriff
    5. protected $gruppenName;
    6. # Name der Gruppe
    8. /**
    9. * Ladet Gruppen Rechte
    10. * @param $rename Array
    11. * @param $gruppe String
    12. * @return null
    13. */
    14. public function __construct($rename,$gruppe)
    15. {
    16. $this->re_name=$rename;
    17. $this->gruppenName=$gruppe;
    18. }
    20. /**
    21. * Gibt den Gruppenname wieder
    22. * @param null
    23. * @return String
    24. */
    25. public function getName()
    26. {
    27. return $this->gruppenName;
    28. }
    30. /**
    31. * Gibt den Rechte Namen wieder
    32. * @param null
    33. * @return array
    34. */
    35. public function getRechte()
    36. {
    37. return $this->re_name;
    38. }
    39. }
    Alles anzeigen


    use.php

    Quellcode

    1. require_once("dbpdo.php");
    2. require_once("gruppe.php");
    3. require_once("absgruppen.php");
    4. require_once("user.php");
    5. require_once("access.php");
    7. if ($_SESSION['eingeloggt'] == TRUE)
    8. {
    9. $profil = array("name"=>$user->username,
    10. "id"=>$_SESSION['id']);
    11. $user5 = new User($profil);
    12. }
    13. else
    14. {
    15. $profil = array("name"=>"guest",
    16. "id"=>"0");
    17. $user5 = new User($profil);
    18. }
    20. #Laden der Berechtigungen
    21. $sql="SELECT grup_id,grup_name,re_name,re_bez FROM admin_gruppen,admin_rechte,gruppen,rechte WHERE f_userid='1' AND grup_id=admin_gruppen.f_grupid AND admin_gruppen.f_grupid=admin_rechte.f_grupid AND rechte.re_id = admin_rechte.f_reid ORDER by grup_name";
    22. $obj= new Dbpdo();
    23. $stmt =Dbpdo::get_db()->query($sql);
    24. $gruppe="";
    25. while ($data = $stmt->fetch(PDO::FETCH_OBJ))
    26. {
    27. if($gruppe=="" || $gruppe == $data->grup_name)
    28. {
    30. $rechte[$data->re_name]=$data->re_name;
    31. $gruppe=$data->grup_name;
    32. #echo $gruppe."";
    33. }
    34. else
    35. {
    36. # Alle Rechte der Gruppe laden
    37. $grupobj= new Gruppe($rechte,$gruppe);
    38. #Gruppe erstellen
    39. unset($rechte);
    40. $user5->addGruppe($grupobj,$gruppe);
    41. # Gruppe den User zuweisen
    42. # Weiter Gruppen daten einlesen
    43. $rechte[$data->re_name]=$data->re_name;
    44. $gruppe=$data->grup_name;
    45. #echo "else:".$gruppe."";
    46. }
    47. }
    49. #Letzte Gruppe erstellen falls vorhanden
    50. if (is_array($rechte))
    51. {
    52. $grupobj= new Gruppe($rechte,$gruppe);
    53. # Gruppe erstellen
    54. $user5->addGruppe($grupobj,$gruppe);
    55. # Gruppe den User zuweisen
    56. #echo "last:".$gruppe."";
    57. }
    60. #echo $user5->getGruppen('Super Admininstrator')->getName()."";
    62. $access = new Access();
    64. function zugang_check_seite($access, $user5, $seite, $seiten_inhalt)
    65. {
    66. if(!$access->zugang($user5,$seite))
    67. {
    68. $seiten_inhalt = "<br />Failure<br />";
    69. }
    71. return;
    72. }
    Alles anzeigen


    Und das steht in der Datei, die angezeigt wird:

    zugang_check_seite($access, $user5, "index_lesen", $seiten_inhalt)

    Ich habe jetzt ein Problem:

    Wenn ich nicht eingeloggt bin, erhalte ich problemlos das Recht zum lesen und kann die Seite auch sehen.
    Bin ich allerdings eingeloggt, erhalt eich zwar auch das Recht, steht zumindest genauso in print_r($user5) drin, allerdings wird mir dann der Teil ohne Zugriffsrecht angezeigt.

    Das steht in print_r($user5):

    User Object ( [user_id:protected] => 1 [user_name:protected] => Fipsi [gruppen:Absgruppen:private] => Array ( [Absoluter Administrator] => Gruppe Object ( [re_name:protected] => Array ( [index_edit] => index_edit [index_lesen] => index_lesen ) [gruppenName:protected] => Absoluter Administrator ) ) [allName] => Array ( [0] => Absoluter Administrator ) )

    Danke schonmal :)

  • Hi,
    Dbpdo construct solltest du private machen
    methoden solltest du englisch machen.

    zwischen den methoden herrscht ein ziemlich chaos.. warum ruft getgruppe die gibgruppe auf?
    Kann es sein, dass die parent nicht geläufig ist?
    In der Klasse User musst du wahrscheinlich nur den Konstruktor überschreiben.

    use.php und zugang_check_seite sind nur Beispiele, oder?
    Ich verstehe nicht warum du auf nicht objektorientieren Code zurückgreifen möchtest.
    Sämtliche Datenbankzugriffe gehören in das Model.

    Ansonsten: Wo ist das Problem beim Gast Benutzer? Allein durch den Session check muss doch false returned werden?
    Ansonsten hast du da ein paar falsche Bedingungen - der Test sieht sehr kompliziert aus

    Quellcode

    1. if ($_SESSION['eingeloggt'] != TRUE || !$_SESSION['id'] || $_SESSION['ip_adress'] != $_SERVER['REMOTE_ADDR']) {
    2. return false;
    3. }

  • Torben Brodt schrieb:

    Dbpdo construct solltest du private machen


    Wenn ich das contruct auf private macht gibt er mir n error aus wegen "$obj= new Dbpdo(); " in use.php

    Torben Brodt schrieb:

    zwischen den methoden herrscht ein ziemlich chaos.. warum ruft getgruppe die gibgruppe auf?
    Kann es sein, dass die parent nicht geläufig ist?


    Ich habe mich acuh schon drüber gewundert, aber der Code ist von splash, und da ich mich in OOP noch nich sonderlich auskenn wollt ich da nicht drin rumwursteln.

    Torben Brodt schrieb:

    use.php und zugang_check_seite sind nur Beispiele, oder?
    Ich verstehe nicht warum du auf nicht objektorientieren Code zurückgreifen möchtest.
    Sämtliche Datenbankzugriffe gehören in das Model.


    Wie, sind nur Beispiele? die use.php wird überall mcih eingebunden, und über zugang_check_seite überprüf ich dann, ob etwas angezeigt wird, oder nicht.
    Und was meinst du mit "Sämtliche Datenbankzugriffe gehören in das Model."? Soll ich die SQL-Abfrage also in n Object mit einbauen? Wenn ja, in welches?

    Torben Brodt schrieb:

    Ansonsten: Wo ist das Problem beim Gast Benutzer? Allein durch den Session check muss doch false returned werden?
    Ansonsten hast du da ein paar falsche Bedingungen - der Test sieht sehr kompliziert aus

    Quellcode

    1. if ($_SESSION['eingeloggt'] != TRUE || !$_SESSION['id'] || $_SESSION['ip_adress'] != $_SERVER['REMOTE_ADDR']) {
    2. return false;
    3. }


    Ich hab gerade die Bedingung selber abgeändert, da ich Fehler in der Klammersetzung entdeckt habe (access.php Zeile 44) auf "((($_SESSION['eingeloggt'] == TRUE)&&($_SESSION['ip_adress'] != $_SERVER['REMOTE_ADDR']))||(($_SESSION['eingeloggt'] != TRUE)&&(isset($_SESSION['id']))))", was jetzt eigentlich richtig sein sollte, und dann das true mti false ausgetauscht. Jetzt wird zwar die Seite, die angezeigt werden soll eingeloggt angezeigt, aber dafür nicht mehr, wenn man ausgeloggt ist.

    Edit: letztes Problem gerade gelöst:
    Ich habe die in der $_SESSION gespeicherte IP-Adresse verschlüsselt, die $_SERVER['REMOTE_ADDR'] war abe rnoch unverschlüsselt. *facepalm*

    Ich check das Problem nicht 8|

    Edit: weitere Problemlösungen:

    In der SQL-Abfrage ist für die Userid schon ein fester wert (1) vorgegeben, dieser wurde jettz auf $profil_id ($profil_id = $profil['id']) abgeändert.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von Fipsi ()

  • $obj = new Dbpdo solltest du auch nicht machen, stattdessen
    $obj = Dbpdo::get_db();

    Und was meinst du mit "Sämtliche Datenbankzugriffe gehören in das Model."? Soll ich die SQL-Abfrage also in n Object mit einbauen? Wenn ja, in welches?

    Den ganzen use.php kannst du in

    Quellcode

    1. class Access {
    2. ...
    3. public statuc function check_seite() {
    4. HIEREIN
    5. }


    machen

    und an der entsprechenden Stelle nur noch Access:check_seite() aufrufen.

  • Torben Brodt schrieb:

    $obj = new Dbpdo solltest du auch nicht machen, stattdessen
    $obj = Dbpdo::get_db();


    =>

    Quellcode

    1. $obj= new Dbpdo();
    2. $stmt =Dbpdo::get_db()->query($sql);


    Hab ich doch?? Wenn ich die erste Zeile streich geht nix.

    Quellcode

    1. class Access {
    2. ...
    3. public statuc function check_seite() {
    4. HIEREIN
    5. }


    machen

    und an der entsprechenden Stelle nur noch Access:check_seite() aufrufen.



    Stimmt, psar ich mir ne menge Variablenübergabe... mach ich gleich :)

    Edit: damit wären wir wieder beim Thema, ich bin zu blöd für OOP: letzteres krieg ich wieder mal nich auf die reihe, aber da es auch so geht, wie ichs jez hab, lass ichs so

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Fipsi ()

  • Fipsi schrieb:

    get_db()

    Fipsi schrieb:

    Torben Brodt schrieb:

    $obj = new Dbpdo solltest du auch nicht machen, stattdessen
    $obj = Dbpdo::get_db();


    =>

    Quellcode

    1. $obj= new Dbpdo();
    2. $stmt =Dbpdo::get_db()->query($sql);


    Hab ich doch?? Wenn ich die erste Zeile streich geht nix.

    Quellcode

    1. class Access {
    2. ...
    3. public statuc function check_seite() {
    4. HIEREIN
    5. }


    machen

    und an der entsprechenden Stelle nur noch Access:check_seite() aufrufen.



    Stimmt, psar ich mir ne menge Variablenübergabe... mach ich gleich :)

    Edit: damit wären wir wieder beim Thema, ich bin zu blöd für OOP: letzteres krieg ich wieder mal nich auf die reihe, aber da es auch so geht, wie ichs jez hab, lass ichs so

    Fipsi
    Du musst die Datenbank Klasse Statisch aufrufen. Und dir zu erst eine Instantz davon holen.

    Statt:

    Quellcode

    1. $obj= new Dbpdo();

    Schreibst du:

    Quellcode

    1. $db = Dbpdo::get_db();
    2. $db->query($sql);



    Hier hast du nee kleine Erweiterung von der Db Klasse wenn du was veränderst an den Klassen sollte du auch verstehen was du da machst.

    Quellcode

    1. <?php
    2. /**
    3. * Datenbank Klasse
    4. * @version 1.1
    5. * @author Splasch
    6. * Filename: dbpdo.php
    7. * Verbindung über die PDO herstellen
    8. **/
    10. class Dbpdo
    11. {
    12. private $uid = dbuid; # Benutzename
    13. private $pw = dbPw; # Password
    14. private $serv = dbServ; # Datenbank Server
    15. private $dbname= dbname; # Datenbank Name
    17. protected static $db_obj = null; # Datenbank Objekt PDO
    18. public $error; # Fehler Varibale
    19. private $anfragen; # Sql Anfragen zählen
    21. /**
    22. * Klassen aufruf PDO verbindung aufbauen
    23. *
    24. */
    25. private function __construct()
    26. {
    27. $db="mysql:dbname=".$this->dbname.";host=".$this->serv; #mysql:dbname=Datenbankname;host=localhost
    28. try
    29. {
    30. self::$db_obj = new PDO($db, $this->uid, $this->pw,array
    31. (
    32. PDO::ATTR_PERSISTENT => false,
    33. PDO::ATTR_ERRMODE => PDO::ERRMODE_WARNING #PDO::ERRMODE_EXCEPTION
    34. #PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true
    35. )
    36. );
    37. }
    38. catch (PDOException $e)
    39. {
    40. $this->error='Fehler beim Öffnen der Datenbank: ' . $e->getMessage();
    41. echo $this->error; #Fehler ausgabe
    42. }
    44. }
    46. /**
    47. * Eine Instanz des PDO Objektes übergeben
    48. * @return Objekt $db_obj
    49. */
    50. public static function get_db()
    51. {
    52. if(is_null(self::$db_obj))
    53. {
    54. self::$db_obj = new Dbpdo();
    55. }
    56. return self::$db_obj;
    57. }
    59. /**
    60. * exec
    61. * Auch exec Anfragen mit zählen
    62. * @param sql (string)
    63. **/
    64. public function exec($sql)
    65. {
    66. $this->anfragen ++;
    67. return parent::exec($sql); // Funktion der Eltern Klasse zurückgeben
    68. }
    70. /**
    71. * execute
    72. * Auch execute Anfragen mit zählen
    73. * Nach prepare
    74. * @param params (array)
    75. **/
    76. public function execute($params = array())
    77. {
    78. $this->anfragen ++;
    79. return parent::execute($params);
    80. }
    82. /**
    83. * get_anfragen
    84. * Gesamt Sql anfragen zurück geben
    85. **/
    86. public function get_anfragen()
    87. {
    88. return $this->anfragen;
    89. }
    91. } // Ende Klasse
    92. ?>
    Alles anzeigen


    Noch ein Tip zu den Klassen von mir verwende __autoload() damit ersparst du dir das ganze manuele Nachladen der Klassen

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von splasch ()