Klassenaufbau Rechte- / Gruppensystem

splasch · 16.07.2009

Ich hab eine verständnis Frage bezüglich Beziehungen zwischen klassen. Ein User kann ja in mehren Gruppen sein (1/n).
Wie kann ich mir das nun bei den Klassen vorstellen wird dort einfach ein Objekt der User klasse in die Klasse Gruppe übernohmen oder wie folgt die Beziehungs zuweisung.

Muß für jede Gruppe ein weiteres user Objekt übergeben werden oder wird nur 1 user objekt für alle seine gruppen erstellt.
So ein Rechte System ohne OO aufzubauen ist relative einfach aber in OO steh ich da vollkommen an.

Hat villeicht jemand von euch ein vollständiges Klassen diagram über ein Benutzer rechte system. Wo auch die eigenschaften und methoden eingetragen sind.Sowie die Abstracten klassen.

Bzw ein Beispiel Code für die n Seite wie ihr dort mehre Objekt an die andere Klasse übergebt.

Mfg Splasch

ZackBag · 16.07.2009

AW: Klassenaufbau Rechte- / Gruppensystem

splasch schrieb:
So ein Rechte System ohne OO aufzubauen ist relative einfach aber in OO steh ich da vollkommen an.

Vertippt?

Gruß
ZackBag

splasch · 16.07.2009

AW: Klassenaufbau Rechte- / Gruppensystem

OO ist die Abkürzung für Objekt Orentiert und OOP steht für Objekt Orentierte Programmierung.

Mfg Splasch

Thyras · 16.07.2009

AW: Klassenaufbau Rechte- / Gruppensystem

Oha ne Benutzerrechteverwaltung, sehr komplexes Thema - ein Fass ohne Boden.

Den ultimativen Lösungsweg gibt's da nicht, hängt wirklich vom Umfang und der kompletten Struktur des Systems ab. Soll's zu den Gruppen noch Rollen geben, gibt es zusätzlich Einzelbenutzerrechte zu den Gruppenrechten etc.

Nur ein vereinfachter möglicher Anfang, so als kleiner Denkanstoß...

PHP:

class User {
    //some code
}

class Gruppe {
    private $users = array();
    
    function addUser(User $user) {
        if(in_array($user, $this->users, true)) {
            return;
        }
        $this->users[] = $user;
    }
}

$user = new User();

$gruppe1 = new Gruppe();
$gruppe1->addUser($user);

$gruppe2 = new Gruppe();
$gruppe2->addUser($user);

Viel Erfolg!

splasch · 16.07.2009

AW: Klassenaufbau Rechte- / Gruppensystem

Thyras schrieb:
Oha ne Benutzerrechteverwaltung, sehr komplexes Thema - ein Fass ohne Boden.

Den ultimativen Lösungsweg gibt's da nicht, hängt wirklich vom Umfang und der kompletten Struktur des Systems ab. Soll's zu den Gruppen noch Rollen geben, gibt es zusätzlich Einzelbenutzerrechte zu den Gruppenrechten etc.

Danke für das Code Beispiel das hilft schon viel weiter.
Daraus läst sich erkennen das auf der n Seite die Objekte in einen Array abgelegt werden.

Da dieses Thema in der OO auch für mich noch relative neu ist soll es einfach werden. Daher ohne Rollen statt dessen übernehmen die Gruppen eine Rollen ähnliche funktion.
Die User werden keine eigene Rechte bekommen sondern nur Gruppen rechte das vereinfacht das ganze. Allerdings soll es möglich sein das 1 User mehre Gruppen bekommen kann so das nicht immer gleich eine neue Gruppe erstellt werden muß.

Mfg Splasch

Duddle · 16.07.2009

AW: Klassenaufbau Rechte- / Gruppensystem

Wenn ein Nutzer mehrere Gruppen haben kann und eine Gruppe mehrere Nutzer haben kann, dann ist das eine n:m-Beziehung. In Datenbanken wird sowas über eine Zwischentabelle gemacht, die dann zu den anliegenden Tabellen jeweils eine 1:m-Beziehung hat. Beispiel:

Nutzer:
1 | jochen | dortmund
7 | bernd | oslo

Gruppe:
3 | politiker
4 | menschen

Zuordnung:
1 | 3
1 | 4
7 | 4

Dann ist Jochen ein Poltiker und Mensch, Bernd ein Mensch (es ist übrigens reiner Zufall, dass ich diese beiden Gruppen unterscheide).

Es gibt da afaik auch kein Entwurfs-Muster, dass sich irgendwie mit n:m-Beziehungen beschäftigt, was du ja offenbar für deinen Zweck suchst. Insofern kannst du es im Entwurf so lassen, in der Datenhaltung solltest du aber dich ganz scharf an oben erwähnter Hilfstabelle orientieren.

Duddle

splasch · 16.07.2009

AW: Klassenaufbau Rechte- / Gruppensystem

@duddle

Datenbank mässig ist mir das klar und auch die n/m Beziehung existiert. Mir geht hier um den Klassenaufbau. So das ich später nur mehr die Daten von der Datenbank in die Klasse laden brauch. In der Db wird einen n/m Beziehung über eine weitere Tabelle aufgelöst so das daraus 2 weitere 1/n Beziehungen enstehen daher sind mindesten 3 Tabellen für eine n/m Beziehung notwendig.

Ob das beim Klassen Modell nun mit einer 1/n Beziehung ausreichend ist weiß ich nicht denke aber schon da eh nur 1 User Objekt werend der laufzeit exsistieren kann.

Mfg Splasch

splasch · 21.07.2009

AW: Klassenaufbau Rechte- / Gruppensystem

Hier mal meine ersten Versuche.

Klasse User

PHP:

<?php
/**
* User
* @version 1
* @author Splasch
* Benutzer Verwaltung
**/ 

if (0 > version_compare(PHP_VERSION, '5'))
{
	die('Dieses File wurde generiert für PHP 5');
}

class User
{
    protected $user_id = 0;       # Benutzer Nummer
	protected $user_name = '';    # Benutzer Name
	protected $user_mail = '';    # E-Mail Adresse	
	protected $gruppen = array(); # Gruppen des User

/**
* User Profil Eigenschaften füllen
* @param $profil array
* @return null
*/
public function __construct($profil)
{
	if(is_array($profil))
	{
	 $this->user_id=$profil['id'];
	 $this->user_name=$profil['name'];
	 $this->user_mail=$profil['mail'];
	}
	return false; 
}
/**
* Neue Gruppe den User hinzufügen
* @param $gruppe Objekt 
* @param $name String
* @return void
*/
public function addGruppe(Gruppe $gruppe,$name)
{
	if(is_object($this->gruppen[$name]))
	{echo "schon drin.";
     return;
    }
	$this->gruppen[$name]=$gruppe;		

}
/**
* Gibt das Angeforderte Gruppen Objekt zurück
* @param $index String
* @return gruppen Objekt
*/
public function getGruppen($index)
{
	return $this->gruppen[$index];	
}

} /* end of class User */

?>

Klasse Gruppe

PHP:

<?php
/**
* Gruppe mit Rechten
* @version 1
* @author Splasch
* Benutzer Verwaltung
**/ 

if (0 > version_compare(PHP_VERSION, '5'))
{
	die('Dieses File wurde generiert für PHP 5');
}

class Gruppe
{
	protected $re_name = array();   # Beschreibungs Name des Zugriffs | Seitenkennung (id) für den Zugriff
	protected $gruppenName;         # Name der Gruppe
/**
* Ladet Gruppen Rechte
* @param $rename Array
* @param $gruppe String
* @return null
*/	
public function __construct($rename,$gruppe)
{
	$this->re_name=$rename;	
	$this->gruppenName=$gruppe;
}
/**
* Gibt den Gruppenname wieder
* @param  null
* @return String
*/
public function getName()
{
	return $this->gruppenName;
}
/**
* Gibt den Rechte Namen wieder
* @param null
* @return array
*/
public function getRechte()
{
	return $this->re_name;
}	

}
?>

Hier noch ein kleiner Test durchgang für die 2 Klassen

PHP:

<?php
/**
* TEST
* @version 1
* @author Splasch
* Benutzer Verwaltung
**/ 


include('gruppe.php');
include('user.php');


#test Dumy Gruppe erstellen 
$rename = array("News erstellen"=>"news",
                "Wartung" => "on_off"
                );
                
$admin = new Gruppe($rename,"admin");
# 2 Gruppe
$rename = array("Spieler sperren"=>"blockuser",
                "Gruppen erstellen" => "newgroup"
                );

$support = new Gruppe($rename,"support");

#User Dumy Profil
$profil = array("name"=>"Nubon",
                "id"=>"4",
                "mail"=>"nubon@ttt.de"
               );

$user = new User($profil);
$user->addGruppe($admin,"admin"); # Die Gruppe admin den User hinzufügen

# Test Doppel belegung abfangen 
$user->addGruppe($support,"support"); # Weitere Gruppe support den User hinzufügen
$user->addGruppe($support,"support"); # Doppel belegung

echo"<br>Test Objekt Array Zugriff User<br>";
echo $user->getGruppen('admin')->getName();  #Gruppen Namen der Gruppe admin ausgeben
var_dump($user->getGruppen('admin')->getRechte()); #Gruppen Rechte der Gruppe admin ausgeben
?>

Die 1/n Beziehung zwischen den 2 Klassen funktioniert mal soweit.Meine überlegung ist nun ob es sinvoll ist eine Abstrace Klasse zu erstellen die für die Erstellung der Gruppen Objekte zuständig ist.Da es ja mehre Gruppen geben kann. Die später mal aus der Db ins Objelt geladen werden.

Was Mein ihr dazu.

Mfg Splasch

lostboi · 22.07.2009

AW: Klassenaufbau Rechte- / Gruppensystem

Eine Frage zur Haltung der Daten bzw. dem Management habe ich. Bisher hast Du "nur" über den eigentlichen Programmcode gesprochen.
Wie willst Du denn den Zugriff auf die DB realisieren? Willst Du Dir eine eigene DB Klasse schreiben bzw. in den einzelnen Klassen (user, gruppe, etc.) die entsprechenden SQLs mit einbauen? Oder gehst Du über ein ORM Framework (Doctrine o.a.) an die Datenbank?

Letzteres hätte den Vorteil, das Du konsequent bei OOP bleibst und Dich nicht mehr großartig mit SQL beschäftigen musst. Und auch das handling der Abhängigkeiten zwischen den Tabellen wird hier vom ORM-Framework übernommen. (MySQL als MyISAM kann das ja nicht selber)

Wollte das nur mal als Anstoß geben, falls Du Dir in die Richtung noch keine Gedanken gemacht hast

splasch · 22.07.2009

AW: Klassenaufbau Rechte- / Gruppensystem

lostboi schrieb:
Eine Frage zur Haltung der Daten bzw. dem Management habe ich. Bisher hast Du "nur" über den eigentlichen Programmcode gesprochen.
Wie willst Du denn den Zugriff auf die DB realisieren? Willst Du Dir eine eigene DB Klasse schreiben bzw. in den einzelnen Klassen (user, gruppe, etc.) die entsprechenden SQLs mit einbauen? Oder gehst Du über ein ORM Framework (Doctrine o.a.) an die Datenbank?

Letzteres hätte den Vorteil, das Du konsequent bei OOP bleibst und Dich nicht mehr großartig mit SQL beschäftigen musst. Und auch das handling der Abhängigkeiten zwischen den Tabellen wird hier vom ORM-Framework übernommen. (MySQL als MyISAM kann das ja nicht selber)

Wollte das nur mal als Anstoß geben, falls Du Dir in die Richtung noch keine Gedanken gemacht hast

Hi
Der Zugriff erfolgt über PDO die Login Daten zur Db werden dabei als Konstate in eine Config Datei Definiert und die Verbindung wird über eine klasse mit Singelton dann zuverfügung gestellt.

Beispiel für den Aufruf einer Db verbindung:
$stmt =Dbpdo::get_db()->query($sql);

Mfg Splasch

lostboi · 22.07.2009

AW: Klassenaufbau Rechte- / Gruppensystem

OK, das beantwortet meine Frage!

Wobei Du dabei ja immer noch die "arbeit" hast die SQLs vollständig selber schreiben zu müssen und für die Sicherheit auf DB Ebene musst Du auch selber sorgen.
Aber es ist wie so oft bei diesen Geschichten zum einen Geschmackssache und zum anderen auch immer eine Frage ob ein Framework an der Stelle nicht für zu viel Overhead sorgt. Zumal durch ein ORM-Framework ggf. die Anwendung langsamer werden könnte. Was in deinem Fall wahrscheinlich nicht merkbar sein wird, es sei denn, Du entwickelst eine Hochverfügbarkeitsanwendung, die extremen Performacevorgaben unterliegt.

Grüße!
LostBoi

splasch · 25.07.2009

AW: Klassenaufbau Rechte- / Gruppensystem

Ich hab mal weiteres eine Abstrace Ableitung erstellt. Ist die Überlegung so in Ordnung oder hättet ihr andere Sachen auch noch mit reingenohmen bwz andere Ableitung erstellt.

Abstrace Klasse Absgruppe

PHP:

<?php
/**
* Abstrace Gruppen 
* @version 1
* @author Splasch
* @Filename: absgruppen.php
* Benutzer Verwaltung
**/ 

if (0 > version_compare(PHP_VERSION, '5'))
{
	die('Dieses File wurde generiert für PHP 5');
}

abstract class Absgruppen
{
	protected $gruppen = array(); # Gruppen des User
	
/**
* Neue Gruppe den User hinzufügen
* @param $gruppe Objekt 
* @param $name String
* @return void
*/	
abstract public function addGruppe(Gruppe $gruppe,$name);	
	
}
?>

Klasse User

PHP:

<?php
/**
* User
* @version 1
* @author Splasch
* @Filename: user.php
* Benutzer Verwaltung
**/ 

if (0 > version_compare(PHP_VERSION, '5'))
{
	die('Dieses File wurde generiert für PHP 5');
}

class User extends Absgruppen 
{
	protected $user_id = 0;       # Benutzer Nummer
	protected $user_name = '';    # Benutzer Name
	protected $user_mail = '';    # E-Mail Adresse	
	
/**
* User Profil Eigenschaften füllen
* @param $profil array
* @return null
*/
public function __construct($profil)
{
	if(is_array($profil))
	{
		$this->user_id=$profil['id'];
	 $this->user_name=$profil['name'];
	 $this->user_mail=$profil['mail'];
	}
	return false; 
}
/**
* Neue Gruppe den User hinzufügen
* @param $gruppe Objekt 
* @param $name String
* @return void
*/
public function addGruppe(Gruppe $gruppe,$name)
{
	if(is_object($this->gruppen[$name]))
	{echo "schon drin.";
  return;
 }
	$this->gruppen[$name]=$gruppe;		

}
/**
* Gibt das Angeforderte Gruppen Objekt zurück
* @param $index String
* @return gruppen Objekt
*/
public function getGruppen($index)
{
	return $this->gruppen[$index];	
}

} /* end of class User */

?>

Mfg Splasch