Sinnvolle User & Rechteverwaltung

[MiLa]

Alles schön und gut, aber es geht mir immernoch darum das so zu machen, wie in meinem letzten Post beschrieben...

Können die "Profis" nicht mal was zu sagen?! Nehmt das als Hilferuf von mir...

Tim...?! HILFEEE !

 

[js-mueller]

Muss ja nicht unbedingt eine komplette zahl sein oder?
Du kannst ne zahl machen die du immer durch # trennst. So hast du die rechte abgeschottet.
Dein Skript muss sich nur merken welches recht an welcher Stelle steht. Und mit dem Wissen kann man doch ganz leicht die stelle rausnehmen bit operatoren ansetzen und dann wieder an die gewünschte stelle setzen.
Ich hoffe ich hab mich verständlich ausgedrückt. Ich versuchs mal in nem beispiel

1001#110001#00110#11001 // das mit explode trennen.
0 = mdl1, 1 = mdl2, 2 = mdl3 // Das aus einer mysql spalte auslesen, wo sich das skript merkt welcher bereich zu welchem modul gehört
110001 // Modul 1 rauspicken

110001 & 001000 // Bitoperatoren

// Am schluss mit ner for schleife die rechte für das modul wieder an die richtige stelle rücken.

Das war mein bescheidener Lösungsvorschlag, vieleicht kann ja wirklich einer von den Profis das verbessern oder was komplett neues in den Raum werfen.

 

[Fabian H]

Hm, du könntest versuchen, einen Varchar mit lauter Nullen und Einsen zu machen (Varchar deshalb, weil ja eine Null an erster Stellen liegen könnte)

Sagen wir, jedes Modul hätte vier Stellen in dem String. Die Reihenfolge ist natürlich fest.
Der String könnte dann z.B. so aussehen:

01000100101011011100
\  /\  /\  /\  /\  /
 \/  \/  \/  \/  \/
  |   |   |  |   |
  |   |   |  |  usw...
  |   |   | Modul 4
  |   |  Modul 3
  |  Rechte für Modul 2
Rechte für Modul 1

Logischerweise steht eine Null für "verboten" und eine Eins für "erlaubt".
Die Reihenfolge, was die Null und Einsen in einen Block darstellen muss natürlich auch fest sein.

Frage:
Wieso willst du das nicht auf mehrere Zeilen verteilen?
Wäre doch wesentlich übersichtlicher so!

//Edit: Da war wohl jemand schneller

 

[MiLa]

Joa, den Gedanken hatte ich in Ansätzen auch schon...

Bisher sind hier ja ganz nette Lösungsmöglichkeiten erschienen, aber für mich persönlich noch nicht das wahre

Vieleicht kann man es ja aber auch mit irgendeiner Summe lösen?!

Irgendwo war das meiner Meinung nach doch so,
dass man die Summe von mehreren zahlen angeben konnte und damit Eindeutige Rechte anzugeben, könnt sein, dass das bei Adminmod für Half-Life war
Weiss nicht so genau...

Aber vieleicht hat ja jmd. anderes noch nen Vorschlag in meien Richtung... *hoff*

 

[MiLa]

Überlege mal, ich habe 2000 User in einer Community,
und diese haben unterschiedliche Zugriffsrechte auf 30 Module...

...sind das nicht ein paar überflüssige Datensätze(60000), die ich mit etwas Rechnerei und Überlegungen vereinfachen kann ?!

Also ichw erde mir nochmal etwas Gedanken dazu machen, wie ich das nun lösen werd...
Das gefällt mir irgendwie ganz gut, muss mal sehn...

01000100101011011100
\  /\  /\  /\  /\  /
 \/  \/  \/  \/  \/
  |   |   |  |   |
  |   |   |  |  usw...
  |   |   | Modul 4
  |   |  Modul 3
  |  Rechte für Modul 2
Rechte für Modul 1

*überleg*

 

[Fabian H]

MySQL ist nicht umsonst verdammt schnell!

Aber Datenabnkleistung hin oder her: Jo, du hast recht, wenn man es auf einen String verkürzt, ist das ganze wohl effektiver.


//Edit:

*überleg*

Hm, so schwer ist das (zumindest in meiner Theorie ) gar nicht.

Nehmen wir an,die Module haben eine interne Nummer. Diese ist von 1 bis meinetwegen 30 durchnummeriert. Es gibt keine Lücken (also: 5, 6, 7, 9, 10)

Zugreiffen ist dann schonmal einfach:

//module23.php:
$iModuleId = 12;

$sRighrs = getRights($iModuleId);

[...]

function getRights( $a_iModuleId )
{
    //Hier kriegst du von irgendwo den langen eins-null String her:
    $sRightData = "1011010100101010101111010101010110110";

    return substr($sRightData, ($a_iModuleId - 1) * 4, 4);
}

Du kannst auch das -1 weglassen, wenn deine Modul-Ids bei null anfangen.

Naja, und ne Routine zum Speichern sollte auch nicht allzu schwer sein.

Das wäre mal meine Idee

hth

 

[MiLa]

Joa, ich geh das heut kurz vorm einschlafen nochmal durch und kritzel mir die Struktur auf, vieleicht wird daraus ja was einigermaaßen gescheites...

Also, soviel dazu...
ich mach mich nu Bettfertig und geb mir mal ne schöpferische Pause

Aber wenn jemand noch etwas produktives dazu beizutragen hat,
morgen ist auch noch ein Tag!

 

[MiLa]

OK, ich habe jetzt die Methode von Fabian in einem kleinen Testscript übernommen und ein bisschen rummodifiziert
Das ganze sieht nurn so aus...

<?PHP
/*
$modul			- gibt die ID des Moduls an
getrights() 	- holt Rechte für dieses Modul
check()			- überprüft die Rechte des Users

0	- nichts
1 	- lesen
2 	- schreiben
4 	- ändern
16	- löschen
*/
$modul=1;

if(check(getrights($modul),1))
{
	echo"Du darfst lesen<br>";	
}
else
{
	echo"Du darfst nicht lesen<br>";	
}
if(check(getrights($modul),2))
{
	echo"Du darfst schreiben<br>";	
}
else
{
	echo"Du darfst nicht schreiben<br>";	
}
if(check(getrights($modul),4))
{
	echo"Du darfst ändern<br>";	
}
else
{
	echo"Du darfst nicht ändern<br>";	
}
if(check(getrights($modul),16))
{
	echo"Du darfst löschen<br>";	
}
else
{
	echo"Du darfst nicht löschen<br>";	
}
function check($user,$check)
{
    if(($user & $check)==$check)
    {
        return true;
    }
    else
    {
        return false;
    }
}
function getrights($modul_id)
{
    $rights = "111101110000";
    return substr($rights, $modul_id  * 4, 4);
}
?>

Mein größter wunsch, um das ganze nun noch zu perfektionieren, ist es das irgendwie so hinzubiegen, dass die Module keine durchgehende Reihenfolge mehr haben müssen, sondern das irgendwie anders gelöst wird.
Es sollte weiterhin alles von einem Wert ausgehen nur sollte es auch Sprünge in den Modulnummern geben können...

Überlegung:
Man könnte vor die jeweiligen "Blöcke" im $rights String einen Indexwert setzen, nur gibt sich dann ein Problem, wenn wir in den zweistelligen Bereich kommen

Jemand ne Idee?

 

[Fabian H]

Also:
Ich denke mal, dass du hier die Nummeron 1, 2, 4, 16, usw. nicht mehr brauchst, du kannst beliebige Nummern nehmen.

Mein Vorschlag wäre folgender:
Du lässt die Modul-Ids, machst aber eine Funktion, mit der man mehrere Werten auf einmal auslesen kann.
Zusätzlich kannst du auch gleich Konstanten für die Privilegien festlegen (Modul-Ids fangen bei eins an):

define("PR_READ", 0);
define("PR_WRITE", 1);
define("PR_CHANGE", 2);
define("PR_DELETE", 3);

function getRights( $a_mRights, $a_iModuleId )
{
    // Hier irgendwo dein eins-null String herbekommen
    $sPrivileges = "0100101011011010110101";

    if (!is_array($a_mRights)) {
        $aRights = array( $a_mRights );
    } else {
        $aRights = $a_mRights;
    }

    $sModuledata = substr($sPrivileges, $a_iModuleId - 1, 4);
    $aRetArray   = array();

    foreach( $aRights as $iOneRight) {
        if ($sModuleData{$iOneRight} == "1") {
            $aRetArray[$iOneRight] = "Y";
        } else {
            $aRetArray[$iOneRight] = "N";
        }
    }

    return $aRetArray;
}

// Modul 4:
$iModuleId = 4;
$aModuleRights = GetRights( array( PR_READ, PR_WRITE, PR_DELETE),
                                    $iModuleId );

if (in_array("Y", $aModuleRights)) {
    if ($aModuleRights[PR_WRITE] == "Y") {
        echo "Schreibrechte";
    } elseif ($aModuleRights[PR_DELETE]) {
        echo "Du darfst löschen";
    }  //Und so weiter;
} else {
    echo "Keine Rechte!";
}

Sorry für die schlechte Einrückung, aber bei mir geht grad Copy und Paste net, sprich ich kann den Code nich in einem Editor vorschreiben

hth

 

[MiLa]

Hm, bist du dir sicher, dass das Script so funktioniert?

Ich habs bei mir ausprobiert und habe permanent keine Rechte...

Ich seh im Endeffekt auch keinen Vorteil bei dir, der Unterschied ist eigendlich auch minimal...
Nur dass du die Funktion einmal aufrufst und das über Arrays machst und ich die Funktion einfach mehrmals aufrufe.

Oder sehe ich da was falsch?!