Ik zit er aan te denken om nog eens wat in PHP te gaan doen. Als basis wil ik eerst en vooral een degelijk 'usermangement system' opzetten. Dit in een object gericht concept.
Omdat hierbij zowel het databaseontwerp als het implementeren van de code zelf belangrijk zijn, zou ik deze graag beiden bespreken.
De database zou ik als volgt willen inrichten:
Misschien kort even het schema toelichten:
In de database wordt over elke gebruiker wat basisgegevens bijgehouden. Er kunnen eventueel een aantal opmerkingen gemaakt worden over een gebruiker. (bv. zijn specifieke functie op de website). Verder is er verplicht een koppeling met de permissies tabel. Uiteraard, behoord een 'permissie-entry' altijd aan 1 specifieke gebruiker. (kleine opmerking hieronder) Verder worden alle belangrijke zaken die een gebruiker uitvoert gelogd. Tot slot is er nog een tabel met sessies in (Ik ben van plan een eigen session handler te programmeren die via de database werkt.) Elke sessie verwijst naar 1 gebruiker.
[opmerking permissies]
Ik overweeg dit nog wat aan te passen, namelijk een toevoeging: groups. Elke gebruiker krijgt dan een group en een group krijgt op zijn beurt een aantal permissies.
In PHP zou ik dan volgende klassen bekomen:
Session, User, Log, Note. Wat deze doen, lijkt mij vanzelfsprekend. Indien dat niet het geval zou zijn, wil ik dit gerust even toelichten.
Ik denk echter dat dat niet de bedoeling van Wouter was. Wat ikzelf nu van plan ben is in de 'Storage' klasse een aantal basis methoden zou gaan schrijven. Bijvoorbeeld om kunnen te schrijven naar een bestand en opslaan in de database. Ik zou dus SessionStorage laten extenden van Storage en e.v.t. de SessionHandlerInterface implementeren. Graag jullie meningen!
Ik hou erg van al die 'magic' interfaces in PHP, maar ik begrijp dat je dat niet wilt.
Het was ook niet mijn eerste bedoeling. Mijn bedoeling was dat je een Storage interface ging maken die voorschrijft welke methods er verplicht moeten zijn. Vervolgens laat je alle Storage klassen deze implementeren:
<?php
interface StorageInterface
{
public function set($id, $value);
public function get($id);
}
class SessionStorage implements StorageInterface
{
public function __construct($session_id = null)
{
session_start($session_id);
}
public function set($id, $value)
{
$_SESSION[$id] = $value;
}
public function get($id)
{
if (!isset($_SESSION[$id])) {
throw new \InvalidArgumentException('Session '.$id.' has not been set');
}
return $_SESSION[$id];
}
}
class FileStorage implements StorageInterface
{
protected $file;
public function __construct($fileName)
{
if (file_exists($fileName)) {
$this->file = fopen($fileName, 'a');
} else {
throw new \InvalidArgumentException('File '.$fileName.' is not found in '.getcwd());
}
}
public function set($id, $value)
{
fwrite($this->file, "\n[$id] ".$value);
}
public function get($id)
{
while ($line = fgets($this->file)) {
if (preg_match('/^\['.$id.'\]/', $line)) {
return end(explode('] ', $line);
}
}
throw new \InvalidArgumentException('Key '.$id.' has not been set');
}
}
class YmlFileStorage extends FileStorage
{
// ...
}
?>
@Erwin
Het is maar net welke insteek je hebt. Op jouw manier bepaal jij als ontwikkelaar hoe de afnemers van jouw app de rechten moeten uitdelen. Op mijn manier laat je die keuze aan hen over.
En natuurlijk moet je dan gaan doornormaliseren, waardoor je queries complexer worden, maar dat is dan gewoon de keuze die je maakt, en dat is pesoonlijk ;-)
Ger, uiteraard is het een keuze en aangezien het eigenlijk ergens ander over gaat zal ik er na deze post ook geen woorden meer aan vuil maken.
Het enige wat ik wil zeggen is dat de 'persoonlijke' rechten al mogelijk zijn mits je groepen van 1 persoon toelaat. Dat je met zo'n model dus als ontwikkelaar de gebruiker beperkt ben ik het niet mee eens. Je doet het alleen op een, wat mij betreft, transparantere manier. In de GUI kan je namelijk nog precies hetzelfde als wat jij kan.
@Wouter
Alweer erg bedankt voor je duidelijk antwoord. Ik apprecieer dit ten zeerste. Uiteraard ook de reacties van de andere mensen in dit topic.
Ik denk dat dit inderdaad een goede structuur geeft. Bij SessionStorage ben ik dan ook wel van plan de interface die eigenlijk voor PHP 5.4 bedoeld is te gaan gebruiken.
@Ger & Erwin
Reacties hierover zijn natuurlijk wél gewenst. Als er geen discussie is, dan kan je er ook niets van leren.
Het model van Ger vind ik erg mooi, maar dan weer net iets te ver gaan. Voor ingewikkelde queries heb ik geen angst, maar de vraag is natuurlijk: is het noodzakelijk? En dan denk ik in dit geval van niet.
Mijn plan is dus een user tabel, een group table en tot slot een permissions table. In eerste instantie vond ik dit geen prettig idee. Ik wil niet dat de eindgebruiker verplicht is een groep te maken voor 1 specifieke gebruiker. Maar, ik heb er eens verder over nagedacht. Ik kan dit probleem in de GUI inderdaad netjes oplossen (eigenlijk wat Erwin ook al aangeeft).
Nogmaals bedankt voor alle jullie reacties!
Ik ga nu nog wat inspiratie op doen voor mijn database klasse. Dan kan het echte werk beginnen. Moest er iemand nog leuke voorbeeldjes hebben van een database klasse die werkt met PDO, altijd welkom!
Ik vind die Propel er erg leuk uitzien en zelfs werken. Alleen vind ik dat persoonlijk te vergaand. Veel extra code om het, naar mijn mening, jezelf makkelijk te maken. Iets wat ik persoonlijk niet altijd nodig vind. Daarom ga ik toch eerder gaan voor een eenvoudige database klasse die een paar standaard zaken voor mij afhandelt. (zoals bv. de error reporting)
Alleen de naam van die klasse waar je naar link schrikt mij al af. Ik zou je misschien door dit laten inspireren, maar zeker niet gebruiken. Singleton, het idee alleen al... ;)
