Hoe een userId ophalen?

Het gaat er nu nog even om welke manier je zou gebruiken voor het UserId? De eerste manier, door setUser() methode aan te maken spreekt mij het meeste aan.

Kun je hier eens antwoord op geven:

Kris Peeters op 17/12/2012 11:48:17

Toon eens wat er buiten de class gebeurt.

Iets als

<?php
$mijn_transaction = new Transaction();
$mijn_user = new User();

$mijn_object = new Mijn_class() // geen idee waar die class over gaat
$mijn_object->create( $mijn_transaction , $mijn_user );
// en hier verwacht je dus die id te kennen.
?>

Ik begrijp niet echt wat je nu precies wilt

Natuurlijk kan ik dat :)

                            $transactionMapper = new TransactionMapper( $db );
                            $transaction = new Transaction();
                            $transaction->setCredit( '-1' );
                            $transaction->setDescription( 'SMS verstuurd' );
                            $transactionMapper->create( $transaction, $user ); 

User is het user object die heeft ook het id.

Ja dat ziet er goed uit toch? Wat is dan het probleem? Wat is je relatie tussen User en Transaction?

Edit: ah sorry je vraag staat bovenin ergens. Ik ben ook wel benieuwd hoe je dit leuk kan oplossen

Sorry voor al die opties. Die TransactionMapper doet object-relational mapping?

En als ik het goed begrijp is de vraag hoe je de relaties implementeert:
1. Hij mapt de foreign key en doet verder niets. Dit lijkt me "zoals het nu is".
2. Hij doet "ijverige instantiatie" (eager instantiation) van de gereleateerde objecten. Dit is zoals ik beschrijf bij "de Transaction een referentie naar de user meegeven".
3. Het object doet "luie instatiatie" (lazy instatiation) van het gerelateerde object. Dit is het geval in alle overige opties die ik beschreef.

Manier 1 heeft tot gevolg dat de code die iets met de objecten doet zelf aan de slag moet met de relatie.

                            $transactionMapper = new TransactionMapper( $db );
                            $transaction = new Transaction();
                            $transaction->setCredit( '-1' );
                            $transaction->setDescription( 'SMS verstuurd' );
                            $transaction->setUserId($user->getId());
                            $transactionMapper->create( $transaction ); 

Als je $user->getId() op diverse plaatsen moet schrijven is dat natuurlijk niet optimaal ("Don't repeat yourself").

Manier 2 heeft tot gevolg dat je, als je een Transaction object maakt die gerelateerd is aan een user, je ook altijd een User object moet maken. Als je die toch altijd nodig gaat hebben is dat de meest efficiente optie.

Heb je het gerelateerde object soms wel en soms niet nodig dan is is manier 3 de beste keus.

Zowel bij manier 2 als manier 3 krijg je:

                            $transactionMapper = new TransactionMapper( $db );
                            $transaction = new Transaction();
                            $transaction->setCredit( '-1' );
                            $transaction->setDescription( 'SMS verstuurd' );
                            $transaction->setUser($user);
                            $transactionMapper->create( $transaction ); 

Bij manier 2 slaat de transaction een referentie naar de User op en moet de TransactionMappers create functie de user opvragen, dan de id van de user opvragen en die in de $data array stoppen. Bij manier 3 doet de functie setUser van de Transaction dat en zet hem in userId:

    function setUser($user) {
        $this->userId = $user ? $user->getId() : null;
    }

De TransactionMappers create functie hoeft dan alleen maar de gegevens uit de Transacion in de $data array stoppen en hoeft verder niet te weten hoe het zit met de relatie met de user.

En wat betreft die verschillende opties die ik beschreef voor manier 3: als je geen duidelijk voordeel ziet dan doe je toch gewoon "The simpelest thing that could possibly work"?

@henk, bedankt voor je antwoord.

Ik had dit topic vooral aangemaakt voor bij het ophalen van de transacties, ik zie dat jij nu ook al aan setUser het user object meegeeft, bij het create van een transactie. Is dit ook de meest voorkomende manier?

Als je met getters en setters werkt is volgens mij de meest voorkomende manier om ook de relatie tussen twee objecten te regelen met setters en getters die die het gerelateerde object als argument resp return value hebben. In dit geval setUser($user) en getUser(). En als je die setter en getter toch al hebt, waarom zou je dan nog de user als parameter aan create meegeven?

Maar er is ook een hele andere stijl, ActiveRecord. Ik heb daar in Kohana een voorbeeld van gezien waarbij er met __set en __get werdt gewerkt. ActiveRecord is geloof ik vrij populair met PHP. Daardoor weet ik niet wat nu in algemene zin de meest voorkomende manier is.