Ontwerpen usermanagement

Over databases heb ik geen verstand, over de OO kant wel.

Probeer wat meer te programmeren/denken naar een interface*. De objecten die je nu hebt zijn allemaal objecten via programmeren naar een implementatie. Dat is niet verstandig.
Zo heb je nu bijv. de Session implementatie, maar wil je straks liever een File implementatie van het opslaan van de gebruiker of een cookie implementatie. Het is dus beter om deze terug te leiden naar 1 interface: Storage. Deze bevat de basis, vervolgens heb je de SessionStorage klasse die voor de implementatie zorgt.

Ditzelfde moet je doen voor bijv. de Log klasse. Nu heb je een database log, straks een logfile, vervolgens een email log. Daarom moet je 1 interface Log hebben die voor de basis zorgt en verschillende subklassen die voor de implementatie zorgen. Een leuk voorbeeld van log kun je hier vinden: Een logging class in OO - Jelmer.

Tevens zal ik eens kijken naar het STRATEGY pattern. Hiermee regel je wat de gebruiker mag en kan. Even snel wat gemaakt in plain text (hoort natuurlijk in een UML diagram)

             +---------------------+                +-------------------------+
             |    <<interface>>    |                |          User           |
             |  RemoveUserStrategy |                +-------------------------+
             +---------------------+                | ...                     |
             | removeUser()        |--------------> | removeUserStrategy      |
             +---------------------+                +-------------------------+
                  ^           ^                     | ...                     |
                 /             \                    | addRemoveUserStrategy() |
                /               \                   +-------------------------+
+------------------+        +----------------+
| CannotRemoveUser |        | CanRemoveUser  |
+------------------+        +----------------+
| removeUser() {   |        | removeUser() { |
|     // exception |        |  // removeUser |
| }                |        | }              | 
+------------------+        +----------------+

Kort gezegd heb je de klassen op object niveau door, alleen moet je nu nog gaan nadenken over de objecten op implementatie (of eigenlijk juist niet op implementatie) niveau. Je moet nu gaan nadenken over de structuur van je applicatie en hoe je die zo flexibel mogelijk maakt.

* Met interface doel ik hier niet per se op een interface zoals we die in PHP kennen. Maar ik bedoel een superklasse, het kan dus ook een abstracte klasse zijn.

Dat is inderdaad wel een leuke denkwijze. Inderdaad een beetje kijken wanneer het interessant is gebruik te maken van een interface / abstracte klasse / beide.

Bedankt, hiermee kan ik zeker wat. Misschien nog een toevoeging, is het interessant om de 'log' klasse te gaan verwerven met een Exception klasse? Dan kan een exception bv. een bepaalde log-methode worden meegegeven.

Nee, misschien wel zo maken dat de ExceptionHandler klasse een HEEFT_EEN relatie heeft met de Log klasse. Dat je in de ExceptionHandler kan doen:
<?php
class ExceptionHandler
{
protected $log; // log klasse

// ...

public function handle(\Exception $exception)
{
$message = sprintf('%s(%i) [%d] %s',
$exception->getFile(),
$exception->getLine(),
date('c'),
$exception->getMessage()
);
$log->log($message, $exception->getCode());
}
}
?>

Hierbij vang je dus een exception op. Vervolgens laat je die afhandelen door de ExceptionHandler. De code van de Exception is vervolgens het niveau van de log, zoals je in dat voorbeeldje van Jelmer kan zien.

En je moet eigenlijk altijd naar een interface/abstracte klasse programmeren, dat is het meest flexibel. Als je ook nog methods hebt die in elke subklasse gelijk zijn (of zouden zijn, altijd verder denken dan wat je nu hebt) dan maak je geen interface maar een abstracte klasse.

In dit geval moet je nog $log dan toch ergens meegeven in een constructor?

Ja, mooi via DI. Nog mooier zou het zijn als je een service container zou werken. Dan heb je iets als:
<?php
$container = new Container();

$container->set('log.class', 'FileLog');
$container->set('log.config', array('logs/exceptions.log'));
$container->set('log', function($c) {
$reflection = new \ReflectionClass($c->get('log.class'));

if (!$reflection->isSubclassOf('Log')) {
throw new InvalidArgumentException('log.class does not implement the Log interface');
}

return $reflection->newInstanceArgs($c->get('log.config'));
});

$container->set('exceptionHandler.class', 'ExceptionHandler');
$container->set('exceptionHandler.config', array($container->get('log')));
$container->set('exceptionHandler', function($c) {
$reflection = new \ReflectionClass($c->get('log.class'));

if (!$reflection->isSubclassOf('Handler')) {
throw new InvalidArgumentException('exceptionHandler.class does not implement the Handler interface');
}

return $reflection->newInstanceArgs($c->get('exceptionHandler.config'));
});

$exceptionHandler = $container->get('exceptionHandler');

try {
$foo = new Foo();

$foo->setBar('12'); // gooit met exceptions
} catch (\Exception $e) {
$exceptionHandler->handle($e);
}
?>

Bedankt wouter!

Alleen, wat is precies de bedoeling van 'reflection'? Overigens, wat is het voordeel van zo'n container?

Het voordeel van zo'n container is dat je alle taken gescheiden houdt. Als je nu bijv. de exceptions niet wilt loggen, maar in de DB wilt zetten dan hoef je alleen op regel 4 'FileLog' te veranderen in 'DbLog'. Dan zal de rest gewoon doorwerken.
Of als je de locatie van het bestand wilt veranderen hoef je alleen regel 5 te veranderen.

Zo maak je je code beter aanpasbaar.

De [php]ReflectionClass[/php] is een ingebouwde PHP klasse. Deze zorgt ervoor dat je klassen kunt aanmaken. In dit geval gebruik ik hem omdat je argumenten wilt meegeven aan de constructor (welk bestand, welke logger). Daarom maak ik een ReflectionClass aan met als argument de naam van de klasse (al eerder gedefinieerd) en vervolgens gebruik ik newInstanceArgs, welke de klasse aanmaakt met de argumenten die je opgeeft (in dit geval de array die ook al eerder is aangemaakt).

[edit]Ik heb de code even bewerkt, waardoor je ook meteen het voordeel ziet van werken met interfaces. De reflectionclass gebruik ik nu ook om te controleren of ze wel een subklasse zijn van de Log of Handler interfaces.[/edit]

Bedankt voor de verhelderende uitleg! Echter maak ik hierbij (misschien onterecht) wat kanttekeningen. Als ik het principe min of meer begrijp, is dit erg gericht op de flexibiliteit van een applicatie evenals de herbruikbaarheid van (delen) van de applicatie.

Ik begrijp dat het handig is dat je simpelweg door op lijn 4 wat aan te passen dat dit erg eenvoudig werkt. Langs de andere kant, het is weer extra code, extra objecten, ... (extra werkruimte, opslag) Weegt deze flexibiliteit op den duur nog op tegen de performantie? Daar heb ik eerlijk gezegd mijn twijfels bij. Verder bedenk ik dan ook, als je dit toepast, dan dien je eigenlijk al een hele denkpiste af te leggen eer je werkelijk doet wat je wilt doen. Dan vraag ik me af, is het niet eenvoudiger om simpel DI te gebruiken (m.a.w. via contructoren/setters doorgeven wat nodig is)?

Ik denk eerlijk gezegd dat je dit niet -hoeft- te gebruiken, maar dat het wel kan. Komt het eigenlijk er niet op neer dat je voor jezelf een bepaald niveau van flexibiliteit vastlegt, en hier naar streeft?

Weegt deze flexibiliteit op den duur nog op tegen de performantie?

Nee. Dat is echt micro-optimalisatie, als je kijkt naar websites die gemaakt zijn met een framework dan zijn er zo'n 100 objecten nodig voor een pagina aanroep. Dit is dus echt geen verschil.

Verder bedenk ik dan ook, als je dit toepast, dan dien je eigenlijk al een hele denkpiste af te leggen eer je werkelijk doet wat je wilt doen. Dan vraag ik me af, is het niet eenvoudiger om simpel DI te gebruiken (m.a.w. via contructoren/setters doorgeven wat nodig is)?

En dat is nou net het verschil tussen Flat scripten en OO scripten. In OO moet je voordat je begint met scripten eerst alles al hebben uitgedacht. Pas als je alles hebt uitgedacht en hebt uitgetekend in UML diagrammen begin je met de code en je zult zien dat je dan maar heel kort of te programmeren, omdat je alles al hebt uitgedacht.
Bij Flat PHP begin je gewoon ergens en zie je wel waar het schip strand. En dat is dus niet de manier hoe programmeren werkt, volgens OO mensen.

Ik denk eerlijk gezegd dat je dit niet -hoeft- te gebruiken, maar dat het wel kan. Komt het eigenlijk er niet op neer dat je voor jezelf een bepaald niveau van flexibiliteit vastlegt, en hier naar streeft?

OO is eigenlijk alleen maar kijken tot welk level je wilt. Wil je gaan tot een BlogPost klasse, of ga je ook een extra Author klasse erbij maken? Dat zijn vragen die je je zelf moet stellen.
Maar ik heb geleerd uit ervaring dat je beter teveel klassen kan hebben dan te weinig. Hoe beter je alles opsplitst hoe flexibeler het wordt en dat is nou net OO. OO is niet zo zeer het denken in objecten, OO is het flexibel maken van je code.

Ik heb (eindelijk) de tijd gevonden om dit topic nog eens geheel door te lezen.

Eerst en vooral ben ik het geheel eens met je reactie Wouter. Waar ik met mijn vorige post op doelde heb jij in jouw post kort en kracht gezegd: "OO is eigenlijk alleen maar kijken tot welk level je wilt."

De 'strategy pattern' begrijp ik geheel. Zonder de term te kennen heb ik dit in het verleden al toegepast. Niet in PHP maar in Java, maar goed dat maakt niets uit. Alleen ik zie niet in waarvoor jij dit zou gebruiken i.v.m. de gebruikerspermissies.

Misschien heeft er iemand wat aan, ik bekeek het artikel 'Strategy Design Pattern' en een filmpje in een of andere tutorialreeks: 'Strategy Pattern'

Misschien moet ik voor de zekerheid even kort toelichten welke 'mogelijkheden' ik zeker en vast wil gaan inbouwen. In eerste instantie wil ik een onderscheid kunnen maken tussen: bezoeker, 'geregistreerde zonder rechten', 'geregistreerde met rechten' Hiermee wil ik simpelweg bereiken, sommige pagina's kunnen door iedereen bekeken/gebruikt worden, anderen door ingelogde gebruikers en dan is er nog de admin sectie.

Als je er even mijn ERD bijhaalt en daar Groups aan toevoegt is dit makkelijk te verkrijgen. In de 'permissions table' een veld met die refereert naar de 'group table'. group 1 is bv. 'geregistreerde zonder rechten' en groep twee is logischerwijs 'geregistreerde met rechten'. Later zou ik dan willen uitbreiden met meer specifieke rechten, bv. een gebruiker mag een (andere) gebruiker verwijderen, bewerken, toevoegen, ... Dit zowel op 'group' niveau als op één specifieke gebruiker.

Ik zie echter niet in hoe ik dit op jouw manier / een andere efficiënte manier dit perfect kan bekomen. Op database niveau is dit geen enkel probleem:

Een gebruiker moet een record hebben in 'permissions' en optioneel is er een link naar een 'group'.

Ik hoop dat mijn vraag min of meer duidelijk is. Ik wil alvast iedereen bedanken, en in het bijzonder natuurlijk Wouter :-).