Session + Login klasse

Overzicht Reageren

Sponsored by: Vacatures door Monsterboard

Tom Swinkels

Tom Swinkels

26/02/2012 22:36:38
Quote Anchor link
Beste Phpers,

Ik ben pas begonnen met OOP en probeer nu een login + session systeem te maken.
De bedoeling is dat een gebruiker in kan loggen er dan een cookie gemaakt word met als inhoud een hash.
Deze hash word ook opgeslagen in de database en ook word het user object opgeslagen in de database.
Verder wil in de cookie ook weer opslaan in een session met session_set_save_handler()

Nu was mijn vraag aan jullie ben ik goed op weg? Wat zijn mijn verbeter punten tot nu toe? Waar moet ik rekening mee houden? Wat moet ik anders doen?

LoginAction.class.php
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
<?php
/**
 * LoginAction klasse
 *
 * @author Tom Swinkels
 * @version v1.0 last edit on 26-02-2012
 */

class LoginAction
{
    private $_userMapper;
    private $_sessionMapper;

    public function __construct(UserMapper $userMapper, $sessionMapper)
    {

        $this->_userMapper = $userMapper;
        $this->_sessionMapper = $sessionMapper;
    }

    public function execute(Request $request)
    {

        $errors = array();
        if(isset($request->postData['submit']))
        {

            /** Form are submit **/
            $user = $this->_userMapper->login($request->postData['user_name'], $request->postData['user_password']);
            if($user != null)
            {

                /** Make new session **/
                $session = new Session('user', $user);
                $this->_sessionMapper->save($session);
                $this->_sessionMapper->saveCookie($session);

                /** Redirect user to an page **/
                //header("location:" . SITE_PATH);

                return $user;
            }

            else
            {
                $errors[] = 'Login gegevens kloppen niet';

                return $errors[0];
            }
        }
    }
}

?>


Session.class.php

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<?php
/**
 * Session klasse
 *
 * @author Tom Swinkels
 * @version v1.0 last edit on 26-02-2012
 */

class Session
{
    private $_name;
    private $_data;
    private $_timestamp;
    private $_hash;

    public function __construct($name, $data)
    {

        $this->generateHash();

        $this->_name = $name;
        $this->_data = $data;
        $this->_timestamp = time();
    }

    public function generateHash()
    {

        $this->_hash = hash("sha512", time() . uniqid() . session_id());
    }

    public function getData()
    {

        return array('name'         => $this->_name,
                     'hash'         => $this->_hash,
                     'data'         => $this->_data,
                     'timestamp'    => $this->_timestamp);
    }
}

?>


SessionMapper.class.php

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
<?php
/**
 * SessionMapper klasse
 *
 * @author Tom Swinkels
 * @version v1.0 last edit on 26-02-2012
 */

class SessionMapper
{
    private $_db;
    private $_cookieData;

    const COOKIE_NAME = 'SESSION_ID';

    public function __construct(PDO $db, array $cookieData)
    {

        $this->_db = $db;
        $this->_cookieData = $cookieData;
    }

    public function getSession($name)
    {

        $resultWebs = $this->_db->prepare("SELECT
                                                 webs_id,
                                                 webs_name,
                                                 webs_data
                                           FROM
                                                 web_session
                                           WHERE
                                                 webs_hash = ?
                                           AND
                                                 webs_name = ?
                                          "
);

        $resultWebs->execute(array($this->getSessionId(),
                                   $name));
        $listWebs = $resultWebs->fetch(PDO::FETCH_ASSOC);

        $session = new Session($name, unserialize($listWebs['webs_data']));
        return $session;
    }

    public function getSessionId()
    {

        return $this->_cookieData[self::COOKIE_NAME];
    }

    public function save(Session $session)
    {

        /** Get the session data **/
        $dataArray = $session->getData();

        $resultUsrs = $this->_db->prepare("INSERT INTO
                                                      web_session
                                           SET
                                                      webs_date_add = NOW(),
                                                      webs_name = ?,
                                                      webs_hash = ?,
                                                      webs_data = ?,
                                                      webs_timestamp = ?
                                          "
);
        $resultUsrs->execute(array($dataArray['name'],
                                   $dataArray['hash'],
                                   serialize($dataArray['data']),
                                   $dataArray['timestamp']));
    }

    public function saveCookie(Session $session)
    {

        /** Get the session data **/
        $dataArray = $session->getData();

        setcookie(self::COOKIE_NAME, $dataArray['hash'], strtotime("+20 years"));
    }
}

?>
 
PHP hulp

PHP hulp

28/09/2022 15:12:42
 
Wouter J

Wouter J

26/02/2012 22:55:33
Quote Anchor link
Ik zou niet $sessionMapper/Session gebruiken in de login klasse. De klasse Login hoeft niet te weten waar hij het opslaat, als hij het maar ergens kan opslaan. Of dat nu in een sessie, cookie, xml file, ini file, db, enz. is maakt hem niks uit.
Je zou een interface Storage class kunnen maken die bijv. SessionStorage of XmlStorage implend en dan zou je in de constructor van de Logic klasse kunnen kijken of het instance is van de Storage class. Iets als:
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
<?php
interface Storage
{
  public function set( $key, $value );
  public function get( $key );
}


class SessionStorage implements Storage
{
  public function __construct()
  {

    if( headers_sent() )
      throw new LogicException('Cannot use session storage, because headers alreay sent');
    session_start();
  }


  public function set( $key, $value )
  {

    $_SESSION[$key] = $value;
  }


  public function get( $key )
  {

    if( !isset($_SESSION[$key]) )
      throw new LogicException('The session '.$key.' is not set');
    return $_SESSION[$key];
  }
}


class Login
{
  protected $storage;

  public function __construct( Storage $storage )
  {

    $this->storage = $storage;
  }


  public function execute( User $user )
  {

    $this->storage->set($user->getID(), $user->getHash());
  }
}

?>

Eventueel kun je hiervoor zelfs een service container gebruiken, meer informatie.

Bij OO programmeren moet je altijd zorgen dat een klasse niet iets beslist waar hij niks over te zeggen heeft. In dit geval heeft de Login classe betrekken op het inloggen en niet op waar het inloggen wordt opgeslagen. Daar zijn de Storage klassen weer verantwoordelijkheid. Een klasse moet eigenlijk maar 1 verantwoordelijkheid hebben, bijv. het onthouden van User informatie, het opslaan van data, enz.
Een datamapper is altijd verantwoordelijk voor het overbrengen van data tussen de db en het object, zonder dat deze 2 van elkaar weten.

Het is ook verstandig om PHPDoc comments voor elke functie te zetten, dan wordt het een stuk beter. Ik heb het script nu nog maar een beetje globaal doorgekeken, omdat het een beetje onoverzichtelijk is als je dat voor je neus krijgt geworpen.
Gewijzigd op 26/02/2012 22:59:23 door Wouter J
 
Tom Swinkels

Tom Swinkels

26/02/2012 23:17:02
Quote Anchor link
Ik gebruik de klasse session ook niet, de sessionMapper gebruikt enkel de session klasse om alles op te halen.
Ik snap nog niet helemaal wat je met die interface storage wil zeggen.
Verder vind ik comments niet zo belangrijk ik vind het belangrijker dat de code netjes is en de benaming.
 
Wouter J

Wouter J

26/02/2012 23:39:02
Quote Anchor link
Maar in de Login klasse verplicht je wel dat het een session moet zijn, zie bijv. Regel 28-30. Dit is niet dynamisch en veel te strak voor OOP. Je moet zorgen dat die Login klasse iets opslaat zonder te weten waarin.

Om dat voor elkaar te krijgen moet ik zorgen dat ik storage klassen maak die op zijn minst een set en get method hebben en ik moet zorgen dat de klasse die ik in de constructor als storage inlaad wel iets is van storage.
Dit doe ik met de interface, meer over interfaces: http://phptuts.nl/view/45/12/
 
Tom Swinkels

Tom Swinkels

26/02/2012 23:45:54
Quote Anchor link
Ik schrijf de login klasse toch ook? En ik wil dat er met een session ingelogd moet worden? Ik heb mijn session klasse wel zo gemaakt dat als ik andere sessions op wil slaan dat wel gaat. Maar voor de loginAction klasse hoef ik toch geen opties te maken voor andere manieren om in te loggen?
 
Wouter J

Wouter J

26/02/2012 23:49:20
Quote Anchor link
Via OO principes wel. OO moet je nooit schrijven voor 1 project, maar voor hergebruik. Straks op een andere site wil je weer dit login systeem gebruiken, maar dan loop je tegen een probleem aan van sessies en dan wil je het veranderen naar bijv. een xml file. Doormiddel van OO hoort dit snel gedaan te zijn, door een nieuwe klasse te schrijven en deze te veranderen met de oude. Het hoort niet zo te zijn dat je andere klassen helemaal moet gaan herschrijven.
 
Tom Swinkels

Tom Swinkels

26/02/2012 23:56:24
Quote Anchor link
Ok, daar geef ik je wel gelijk in. Alleen de vraag is hoevaak komt het voor bij een login klasse? Ik heb het nog nooit anders gedaan als met een session?
Dit neem ik in iedergeval mee in mijn hoofd en kijk of dat ik dat ook zo ga doorvoeren of dat het nog even te lastig word.

Zijn er nog andere dingen die jij anders zou doen?
 
Wouter J

Wouter J

27/02/2012 00:04:53
Quote Anchor link
In dit geval is het inderdaad niet echt nodig, maar wel goed om aan te passen aangezien het wel echt een onderdeel is van OOP.

Wat andere globale puntjes:
- Een sessionmapper die een cookie opslaat zie ik ook nog niet helemaal zitten. Een cookiemapper zou een cookie moeten opslaan.
- Ik ben benieuwd wat de login method in de usermapper doet, alles wat te maken heeft met het inloggen hoort in de Login klasse thuis.
- Een getData method mag wel, maar het is mooier om allemaal aparte getters te maken.
- Foutafhandeling zou ik met exceptions doen, dat is het meest gebruikelijke in OO. Meer info: http://phptuts.nl/view/35/7/
 
Tom Swinkels

Tom Swinkels

27/02/2012 00:14:39
Quote Anchor link
Bedankt voor je reactie hier heb ik zeker iets aan.
Verder zeg je dat je liever aparte getters hebt.
Wil je dit dan op de manier doen door allemaal losse methodes of via de __get() function? Ik zie dat de __get() bijna nooit gebruikt word.

Bijvoorbeeld zoals ik bij de user klasse doe:

Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
<?php
/**
 * User klasse
 *
 * @author Tom Swinkels
 * @version v1.0 last edit on 09-02-2012
 */

class User
{
    private $_name;
    private $_password;
    private $_email;
    private $_firstName;
    private $_middleName;
    private $_lastName;
    private $_dateBirth;
    private $_adres;
    private $_houseNr;
    private $_zipcode;
    private $_town;
    private $_phoneNr;
    private $_mobileNr;

    public function __construct()
    {

    }

    public function setName($name)
    {

        $this->_name = $name;
    }

    public function setPassword($password)
    {

        $this->_password = $password;
    }

    public function setEmail($email)
    {

        $this->_email = $email;
    }

    public function setFirstName($firstname)
    {

        $this->_firstName = $firstname;
    }

    public function setMiddleName($middlename)
    {

        $this->_middleName = $middlename;
    }

    public function setLastName($lastname)
    {

        $this->_lastName = $lastname;
    }

    public function setDateBirth($datebirth)
    {

        $this->_dateBirth = $datebirth;
    }

    public function setAdres($adres)
    {

        $this->_adres = $adres;
    }

    public function setHouseNr($housenr)
    {

        $this->_houseNr = $housenr;
    }

    public function setZipcode($zipcode)
    {

        $this->_zipcode = $zipcode;
    }

    public function setTown($town)
    {

        $this->_town = $town;
    }

    public function setPhoneNr($phonenr)
    {

        $this->_phoneNr = $phonenr;
    }

    public function setMobileNr($mobilenr)
    {

        $this->_mobileNr = $mobilenr;
    }

    public function getData()
    {

        return array('name'         => $this->_name,
                     'password'     => $this->_password,
                     'email'        => $this->_email,
                     'firstName'    => $this->_firstName,
                     'middleName'   => $this->_middleName,
                     'lastName'     => $this->_lastName,
                     'dateBirth'    => $this->_dateBirth,
                     'adres'        => $this->_adres,
                     'houseNr'      => $this->_houseNr,
                     'zipcode'      => $this->_zipcode,
                     'town'         => $this->_town,
                     'phoneNr'      => $this->_phoneNr,
                     'mobileNr'     => $this->_mobileNr);
    }
}

?>
 
Wouter J

Wouter J

27/02/2012 11:41:40
Quote Anchor link
Als je vanuit een C objective scripttaal kijkt zou je het moeten doen op de manier die jij hierboven geeft. Maar als je zoveel functies gebruikt dan wil ik nog wel eens de magic __get method gebruiken. Het is dan wel zo dat je goed moet controleren of de property die je op vraagt wel een property is die je mag ophalen (niet alles moet read access hebben).
 
Mark Kazemier

Mark Kazemier

27/02/2012 14:02:55
Quote Anchor link
Ik ben het niet helemaal eens met Wouter J op twee vlakken:
- Het gebruik van een storage interface
- Het gebruik van PHPDoc

Ik zal ze hieronder beide even toelichten:

== Storage interface ==

Tijdens het programmeren kan je altijd zoveel abstraheren als je zelf wil. Je moet alleen wel bedenken voor jezelf wanneer het genoeg is. Hier kom je goed achter als je Test Driven Development (TDD) gaat toepassen. Ik denk in dit geval dat een storage interface een stap te ver is.

Als ik inlog wil ik altijd dat mijn data persistent blijft over verschillende requests. Dit is waar een session voor is. Ik zou dan ook altijd een session gebruiken voor het inloggen. De manier waarop de session opgeslagen moet worden zou ik vervolgens abstraheren zoals hier ook al gebeurd doormiddel van de SessionMapper. Je zou verschillende mappers kunnen maken voor de verschillende storage methoden die je kan toepassen.

Overigens denk ik dat het voor een deel ook gewoon is wat je zelf prettig vind werken. Iedereen zou de abstracties iets anders en verder / minder ver doorvoeren.

== PHPDoc ==

Ik heb nog nooit een nuttig gebruik gezien van PHPDoc. Sterker nog, ik heb er vaker last van gehad dan daadwerkelijk baat. Het belangrijkste bij het programmeren is duidelijke naamgeving van methoden, variabelen en klassen. Op het moment dat je naamgeving gebruikt die voor zich wijst en de intentie van de code beschrijft, heb je geen commentaar meer nodig om te achterhalen hoe iets werkt.

Sterker nog het commentaar wordt dubbelop en vertelt eigenlijk hetgene wat de naam van een methode ook al zegt. Dit is een gevaarlijke situatie, want terwijl er verder ontwikkelt wordt aan een systeem, zal wellicht de werking van de methode veranderen. Er wordt echter zelden meer gekeken naar de PHPDoc die erboven staat, wat deze outdated en daardoor juist heel erg verwarrend maakt.

Voor mensen die willen weten hoe deze code tot stand is gekomen zie ook dit topic:
https://webdevils.nl/forum/serverside/348-tip-s-voor-mijn-class/

== Opmerkingen over laatste reactie Tom ==

Ik zou zelf alles opdelen in losse get en set methoden zover je die nodig hebt. Pas hier echter wel mee op, want als je vervolgens niets doet in de get en set kan dit het risico veroorzaken dat je dingen buiten de user klasse gaat doen die je er eigenlijk in zou moeten doen.

Verder zou ik als je een klasse hebt met zoveel properties kijken of je de klasse niet verder zou moeten opsplitsen. Bijv. in een aantal data objecten. In jou voorbeeld zou ik zelf bijv. voor een Adres klasse gaan die de adres informatie bijhoudt. Je kan er dan ook direct voor zorgen dat je het adres alleen in zijn geheel kan vervangen. Het enige moment waarop een adres zou wijzigen is namelijk op het moment dat iemand verhuist en dan wil je sowieso alles vervangen en niet alleen de postcode. Dat kan je op die manier afdwingen.
Gewijzigd op 27/02/2012 14:08:03 door Mark Kazemier
 
Tom Swinkels

Tom Swinkels

27/02/2012 21:50:31
Quote Anchor link
Bedankt voor de reacties hier heb ik zeker iets aan!
Een adres klasse gaat er ook zeker komen.

Verder maak ik liever gebruik van losse get's en set's i.v.m de magic methode.

Verder een login hoort bij de userMapper omdat hij de gegevens dan de user ophaalt, eigenlijk zou de naam van die methode moeten zijn getUserByNameAndPassword().
 
Wouter J

Wouter J

29/02/2012 11:08:35
Quote Anchor link
Omdat Tom graag wilt dat ik mijn mening vertel over de reactie van Mark:

Quote:
Overigens denk ik dat het voor een deel ook gewoon is wat je zelf prettig vind werken. Iedereen zou de abstracties iets anders en verder / minder ver doorvoeren.

Dit ben ik met je eens. De Storage Interface is misschien een stapje te ver voor alleen een inlog systeem. Maar als ik een hele site ga maken in OOP is het handig dat ik al van dit soort verschillende storage objecten heb en er zo eentje bij kan bouwen.

Quote:
Het belangrijkste bij het programmeren is duidelijke naamgeving van methoden, variabelen en klassen.

Dit is inderdaad het belangrijkste. Maar gebruik jij dan type prefixen in namen? Zodat je kan zien wat er gereturned word en welk type een parameter moet zijn? Voor dat soort dingen is de PHPdoc heel handig. Je hebt snel overzicht wat er in moet en wat je terug krijgt.
Bij getter en setters zou ik geen PHPdoc gebruiken, dat weet je zo wel. Maar bij de wat uitgebreidere methods is het altijd handig om een kort overzicht te zien.
Verder vind ik de " Er wordt echter zelden meer gekeken naar de PHPDoc die erboven staat, wat deze outdated en daardoor juist heel erg verwarrend maakt." mening een beetje vreemd. Hoe weet je dat er zelden naar de PHPdoc wordt gekeken? Als ik iets verander verander ik namelijk ook meteen de PHPdoc erboven. Ik denk dat het vooral aan de persoon ligt of dit wel of niet wordt gedaan, maar als je PHPdoc gebruikt moet je het ook goed gebruiken...
 
Mark Kazemier

Mark Kazemier

29/02/2012 13:20:52
Quote Anchor link
Interessant, een discussie :)

Quote:
Dit ben ik met je eens. De Storage Interface is misschien een stapje te ver voor alleen een inlog systeem. Maar als ik een hele site ga maken in OOP is het handig dat ik al van dit soort verschillende storage objecten heb en er zo eentje bij kan bouwen.

Hangt er geheel vanaf hoe je alles opgebouwd hebt. Ik gebruik zelf het domain model pattern. Waarbij ik repositories gebruik waaruit je de domein modellen kan opvragen en in kan toevoegen. De repository bepaalt zelf vervolgens doormiddel van een ORM hoe en waar de object opgeslagen worden en waar ze vandaan komen. Zo heb ik ook nooit meer te maken met de relationele structuur van de database. Daarnaast is mijn domein model op die manier volledig losgekoppeld van de infrastructuur. Het domein model weet niet eens dat het opgeslagen kan worden.

Quote:
zien.
Verder vind ik de " Er wordt echter zelden meer gekeken naar de PHPDoc die erboven staat, wat deze outdated en daardoor juist heel erg verwarrend maakt." mening een beetje vreemd.

Dat is geen mening, maar gewoon wat ik in de praktijk tegen kom als ik code van andere moet aanpassen of moet samenwerken met andere. Het schrijven van PHPDoc kost tijd en vaak is die tijd er niet. Zeker niet als er een set met bugs gefixt moeten worden. De fixes en features worden snel toegevoegd en de PHPDoc blijft staan. Helaas is niet iedereen zo netjes daarmee dus.

Daarnaast heb ik nog nooit een methode gezien waarbij de naam goed was en PHPDoc nog enige toegevoegde waarde kon hebben. Natuurlijk zijn er wel methoden waar PHPDoc kan helpen, maar meestal zijn er dan één van de volgende dingen mis:

- De methode heeft naam die niet goed beschrijft wat de methode doet
- De methode doet meer dan één ding en zou opgesplitst moeten worden

Ik heb de afgelopen vijf jaar geen PHPDoc of Javadoc of Doxygen geschreven en het ook geen moment gemist. En de mensen die bij mij in het team zaten heb ook nog nooit horen klagen dat ze misten. Ook niet voor het opgeven van typen. Ik gebruik namelijk voor klassen altijd typehinting en bij primitieve typen geven de parameter namen en methode namen al duidelijk aan wat er voor type verwacht wordt. Voor Java en C++ is dit verder helemaal zinloos, want bij die talen geef je gewoon in je methode interface al de typen aan.

Zie ook mijn artikel Commentaar wanneer is het nuttig? over deze kwestie. Veel mensen noemen commentaar (en dus ook PHPDoc) in hun code ten onrechte documentatie. Maar commentaar en documentatie zijn twee compleet verschillende dingen. Documentatie ben ik wel een heel groot voorstander van.
Gewijzigd op 29/02/2012 13:21:51 door Mark Kazemier
 
Tom Swinkels

Tom Swinkels

02/03/2012 19:48:48
Quote Anchor link
Ik heb weer aan update gedaan, de cookie word nu opgeslagen en werkt.

Moet ik nu om te bepalen wie er ingelogd is de functie getSession oproepen? Hoe kan ik deze functie beter beveiligen en waar zouden jullie op beveilingen enkel IP?
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
<?php
/**
 * SessionMapper klasse
 *
 * @author Tom Swinkels
 * @version v1.0 last edit on 27-02-2012
 */

class SessionMapper
{
    private $_db;

    const COOKIE_NAME = 'SESSION_ID';

    public function __construct(PDO $db)
    {

        $this->_db = $db;
    }

    public function getSession($name, $request)
    {

        $resultWebs = $this->_db->prepare("SELECT
                                                 webs_id,
                                                 webs_name,
                                                 webs_data
                                           FROM
                                                 web_session
                                           WHERE
                                                 webs_hash = ?
                                           AND
                                                 webs_name = ?
                                          "
);

        $resultWebs->execute(array($this->getSessionId($request),
                                   $name));
        $listWebs = $resultWebs->fetch(PDO::FETCH_ASSOC);

        $session = new Session($name, unserialize($listWebs['webs_data']));
        return $session;
    }

    public function getSessionId(Request $request)
    {

        return $request->getCookie[self::COOKIE_NAME];
    }

    public function save(Session $session)
    {

        $resultUsrs = $this->_db->prepare("INSERT INTO
                                                      web_session
                                           SET
                                                      webs_date_add = NOW(),
                                                      webs_name = ?,
                                                      webs_hash = ?,
                                                      webs_data = ?,
                                                      webs_timestamp = ?
                                          "
);
        $resultUsrs->execute(array($session->getName(),
                                   $session->getHash(),
                                   serialize($session->getData()),
                                   $session->getTimestamp()));

        $this->saveCookie($session->getHash());
    }

    private function saveCookie($hash)
    {

        setcookie(self::COOKIE_NAME, $hash, strtotime("+20 years"));
    }
}

?>


Moet het ophalen van iemand die is ingelogd op de volgende manier?
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
5
6
$logindata = $sessionMapper->getSession('user', $request);
//Check login?
if($logindata->data)
{
    echo 'Ingelogd als ' . $logindata->data->name;
}


Verder krijg ik een error als er een gebruiker naar de pagina gaat waar nog geen session voor gemaakt is, hoe kan ik dat oplossen?
Code (php)
PHP script in nieuw venster Selecteer het PHP script
1
2
3
4
public function getSessionId(Request $request)
{
    return $request->getCookie[self::COOKIE_NAME];
}
 



Overzicht Reageren

 
 

Om de gebruiksvriendelijkheid van onze website en diensten te optimaliseren maken wij gebruik van cookies. Deze cookies gebruiken wij voor functionaliteiten, analytische gegevens en marketing doeleinden. U vindt meer informatie in onze privacy statement.