Tijden veranderen
Cookie class
Code (php)
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
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
<?php
class Cookie
{
/*
* cookie $id
*/
private $id = false;
/*
* cookie life $time
*/
private $time = false;
/*
* cookie $domain
*/
private $domain = false;
/*
* cookie $path
*/
private $path = false;
/*
* cookie $secure
*/
private $secure = false;
public function __construct($id, $time = 3600, $path = false, $domain = false, $secure = false)
{
$this->id = $id;
$this->time = $time;
$this->path = $path;
$this->domain = $domain;
$this->secure = $secure;
}
public function store()
{
foreach ($this->parameters as $parameter => $validator)
{
setcookie($this->id . "[" . $parameter . "]", $validator->getValue(), time() + $this->time, $this->path, $this->domain, $this->secure, true);
}
}
public function restore()
{
if (isset($_COOKIE[$this->id]))
{
foreach ($_COOKIE[$this->id] as $parameter => $value)
{
$this->{$parameter} = $value;
}
}
}
public function destroy()
{
$this->time = -1;
}
}
class Cookie
{
/*
* cookie $id
*/
private $id = false;
/*
* cookie life $time
*/
private $time = false;
/*
* cookie $domain
*/
private $domain = false;
/*
* cookie $path
*/
private $path = false;
/*
* cookie $secure
*/
private $secure = false;
public function __construct($id, $time = 3600, $path = false, $domain = false, $secure = false)
{
$this->id = $id;
$this->time = $time;
$this->path = $path;
$this->domain = $domain;
$this->secure = $secure;
}
public function store()
{
foreach ($this->parameters as $parameter => $validator)
{
setcookie($this->id . "[" . $parameter . "]", $validator->getValue(), time() + $this->time, $this->path, $this->domain, $this->secure, true);
}
}
public function restore()
{
if (isset($_COOKIE[$this->id]))
{
foreach ($_COOKIE[$this->id] as $parameter => $value)
{
$this->{$parameter} = $value;
}
}
}
public function destroy()
{
$this->time = -1;
}
}
Gewijzigd op 08/07/2012 20:38:34 door Reshad F
Ik vind regel 32-36 raar.
Je gooit in regel 7 tm 27 allerlei dingen op.
Dan ga je op regel 30 nogmaals wat waarde toekennen (false, maar dat waren ze al...)
En op 32 tm 36 kopieer je het nodeloos in $this.
Functie? Kan dus veel korter aangezien dit hetzelfde doet:
Wellicht niet volgens een OOP-opmaak, maar doet precies hetzelfde.
Daarnaast geef je wel hardcoded aan dat het http-only-cookies zijn. Waarom dat dan wel?
restore() is dus gewoon $_COOKIE uitlezen?
En waarom alles in $_COOKIE[123][...] (als $id=123) zetten? En dus niet gewoon direct in $_COOKIE? Er is toch maar 1 user-id met die cookie, als goed is.
Tevens kan je destroy-functie beter. Ik had laatst ook zoiets dat de sessie/cookie niet echt vernietigd werd.
Daar had ik dit voor nodig:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
session_start();
include("functions/saltmaker.php");
include("functions/connect.php");
include("functions/mres.php");
include("functions/sql.php");
if (ini_get("session.use_cookies"))
{
$params = session_get_cookie_params();
setcookie(session_name(), '', time() - 42000,
$params["path"], $params["domain"],
$params["secure"], $params["httponly"]
);
}
setcookie("loginhash", '', time()-10*365*60*60);
session_destroy();
?>
session_start();
include("functions/saltmaker.php");
include("functions/connect.php");
include("functions/mres.php");
include("functions/sql.php");
if (ini_get("session.use_cookies"))
{
$params = session_get_cookie_params();
setcookie(session_name(), '', time() - 42000,
$params["path"], $params["domain"],
$params["secure"], $params["httponly"]
);
}
setcookie("loginhash", '', time()-10*365*60*60);
session_destroy();
?>
Waarom gebruik je het hier niet als datamapper? Een cookie is tenslotte buitenwereld. Flexabiliteit wordt dan veel groter.
ik zal even wat wijzigingen doorvoeren en kijken wat er uit gaat komen!
Reshad, ik heb een paar vragen voor je voordat ik in ga op je script:
Wat is je stappenplan hoe je tot deze code bent gekomen? Ben je meteen begonnen met het schrijven en ben je daarna weer allemaal dingen gaan herschrijven totdat het er wel goed uitzag? Of heb je eerst nagedacht en daarna pas geschreven?
ik heb het echt heel simpel gehouden en hij is wel langer nu maar ik denk dat ik die setters ook in de construct kan plaatsen alleen weet ik niet zeker of het goed is zo.
Code (php)
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
<?php
class Cookie
{
/**
* Cookie name - the name of the cookie.
* @var bool
*/
private $name = false;
/**
* Cookie value
* @var string
*/
private $value = "";
/**
* Cookie life time
* @var DateTime
*/
private $time;
/**
* Cookie domain
* @var bool
*/
private $domain = false;
/**
* Cookie path
* @var bool
*/
private $path = false;
/**
* Cookie secure
* @var bool
*/
private $secure = false;
/**
* Constructor
*/
public function __construct() { }
/**
* Create of Update cookie.
*/
public function create() {
return setcookie($this->name, $this->getValue(), $this->getTime(), $this->getPath(), $this->getDomain(), $this->getSecure(), true);
}
/**
* @return mixed
*/
public function get(){
return $_COOKIE[$this->getName()];
}
/**
* @return bool
*/
public function delete(){
return setcookie($this->name, '', time() - 3600, $this->getPath(), $this->getDomain(), $this->getSecure(), true);
}
/**
* @param $domain
*/
public function setDomain($domain) {
$this->domain = $domain;
}
/**
* @return bool
*/
public function getDomain() {
return $this->domain;
}
/**
* @param $id
*/
public function setName($id) {
$this->name = $id;
}
/**
* @return bool
*/
public function getName() {
return $this->name;
}
/**
* @param $path
*/
public function setPath($path) {
$this->path = $path;
}
/**
* @return bool
*/
public function getPath() {
return $this->path;
}
/**
* @param $secure
*/
public function setSecure($secure) {
$this->secure = $secure;
}
/**
* @return bool
*/
public function getSecure() {
return $this->secure;
}
/**
* @param $time
*/
public function setTime($time) {
// Create a date
$date = new DateTime();
$date->modify($time);
$this->time = $date->getTimestamp();
}
/**
* @return bool|int
*/
public function getTime() {
return $this->time;
}
/**
* @param string $value
*/
public function setValue($value) {
$this->value = $value;
}
/**
* @return string
*/
public function getValue() {
return $this->value;
}
}
?>
class Cookie
{
/**
* Cookie name - the name of the cookie.
* @var bool
*/
private $name = false;
/**
* Cookie value
* @var string
*/
private $value = "";
/**
* Cookie life time
* @var DateTime
*/
private $time;
/**
* Cookie domain
* @var bool
*/
private $domain = false;
/**
* Cookie path
* @var bool
*/
private $path = false;
/**
* Cookie secure
* @var bool
*/
private $secure = false;
/**
* Constructor
*/
public function __construct() { }
/**
* Create of Update cookie.
*/
public function create() {
return setcookie($this->name, $this->getValue(), $this->getTime(), $this->getPath(), $this->getDomain(), $this->getSecure(), true);
}
/**
* @return mixed
*/
public function get(){
return $_COOKIE[$this->getName()];
}
/**
* @return bool
*/
public function delete(){
return setcookie($this->name, '', time() - 3600, $this->getPath(), $this->getDomain(), $this->getSecure(), true);
}
/**
* @param $domain
*/
public function setDomain($domain) {
$this->domain = $domain;
}
/**
* @return bool
*/
public function getDomain() {
return $this->domain;
}
/**
* @param $id
*/
public function setName($id) {
$this->name = $id;
}
/**
* @return bool
*/
public function getName() {
return $this->name;
}
/**
* @param $path
*/
public function setPath($path) {
$this->path = $path;
}
/**
* @return bool
*/
public function getPath() {
return $this->path;
}
/**
* @param $secure
*/
public function setSecure($secure) {
$this->secure = $secure;
}
/**
* @return bool
*/
public function getSecure() {
return $this->secure;
}
/**
* @param $time
*/
public function setTime($time) {
// Create a date
$date = new DateTime();
$date->modify($time);
$this->time = $date->getTimestamp();
}
/**
* @return bool|int
*/
public function getTime() {
return $this->time;
}
/**
* @param string $value
*/
public function setValue($value) {
$this->value = $value;
}
/**
* @return string
*/
public function getValue() {
return $this->value;
}
}
?>
ook heb ik met behulp van datatype de datatypes toegevoegd omdat ik zag dat grote frameworks er ook gebruik van maken.
Gewijzigd op 09/07/2012 10:55:36 door Reshad F
Nu zie je al meteen een paar dingen waarom je altijd eerst moet nadenken over OO en dan pas moet scripten:
- Je hebt je code overnieuw moeten schrijven omdat je er eerste toch niet goed genoeg bleek
- Je hebt niet geprogrammeerd naar een interface, waar je later problemen mee gaat krijgen
- Je hebt nu 1 object die de waarden van een cookie vast houdt en die het aanmaken en verwijderen van de cookie regelt. Dat kan natuurlijk niet, dat zijn 2 verantwoordelijkheden.
- Je hebt nu allemaal properties die nergens geset worden
- Je code is nu nog totaal niet flexibel als je straks wat anders wilt gebruiken.
- moet ik dit eerst in een interface zetten altijd en vervolgens vertellen wat de klasse moet doen?
- hoe splits ik die verantwoordelijkheid van die 2?
- welke properties bedoel je?
Natuurlijk, van fouten leer je, maar de grootste fout waarvan je moet leren is dat je nu meteen bent begonnen met de code zonder enig nadenken. Dat is als een kip zonder kop zomaar wat doen en dat is nooit een succes.
>> moet ik dit eerst in een interface zetten altijd en vervolgens vertellen wat de klasse moet doen?
Je moet altijd boven alles een interface (of abstracte klasse) hebben. Zo kun je later makkelijk en snel controles uitvoeren en heb je heel veel mogelijkheden tot uitbouwen: Je kunt een Session klasse maken met het interface, een Database klasse, een TestKlasse die alleen maar waarden lokaal opslaat voor Unit testen, een File klasse, enz.
>> hoe splits ik die verantwoordelijkheid van die 2?
Nou, laten we eerst maar eens even bedenken wat de 2 verantwoordelijkheden zijn. Vervolgens welke properties en method bij de ene verantwoordelijkheid horen en welke bij de andere. Schrijf dit gewoon eens even uit als:
User
- name
- age
+ constructor(name)
+ setAge(age)
+ getName()
+ getAge()
>> welke properties bedoel je?
Alle properties van de klasse.
Code (php)
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
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
<?php
interface iCookie
{
public function create();
public function get();
public function delete();
public function setDomain();
public function getDomain();
public function setName();
public function getName();
public function setPath();
public function getPath();
public function setSecure();
public function getSecure();
public function setTime();
public function getTime();
public function setValue();
public function getValue();
}
class Cookie implements iCookie
{
// hier de inhoud van klasse Cookie
}
?>
interface iCookie
{
public function create();
public function get();
public function delete();
public function setDomain();
public function getDomain();
public function setName();
public function getName();
public function setPath();
public function getPath();
public function setSecure();
public function getSecure();
public function setTime();
public function getTime();
public function setValue();
public function getValue();
}
class Cookie implements iCookie
{
// hier de inhoud van klasse Cookie
}
?>
heb ik het zo goed?
over het splits gedeelte.. moet delete() in een eigen klasse komen? ( met zijn eigen methods en properties)
Stel je voor dat je 3 verschillende opslag plaatsen hebt:
- Cookie
- Database
- Bestand
En je wilt die 3 overkoepelen met 1 interface die vastlegt welke methods ze sowieso alle 3 moeten hebben, wat ga je dan maken? Hoe gaat je interface dan heten? Welke methods komen daar dan in?
Gewijzigd op 09/07/2012 12:22:09 door Wouter J
Code (php)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
+--------------------+
| Interface |
|--------------------|
| Id |
| Name |
| |
| |
+--------------------+
| Interface |
|--------------------|
| Id |
| Name |
| |
| |
+--------------------+
Tevens heb je nu weer een Entity object, iets wat een ding voorstelt. Probeer nu eens na te denken over een object dat echt alleen maar als doel heeft om dingen op te slaan en te krijgen en dus geen gegevens vasthoudt over wat hij opslaat, alleen maar dat simpele opslaan.
ik zou het als iStorage benoemen i van interface en storage omdat het de interface van storage classes wordt ( cookie, database enz )
Nu heb je dus een set en een get method, wat heb je nog meer met opslaan nodig dat je in alle mogelijke manieren van opslaan gebruikt?
het enige wat ik nog zou kunnen bedenken is de time method en misschien een value method?
Ik doelde meer op de CRUD methods: Create (set), Read (get), Update en Delete. Dat zijn volgens mij de methods die thuis horen in elke storage object.
Tevens raad ik je aan Cookie te hernoemen naar CookieStorage. Aangezien je die alleen hoort te zorgen voor het opslaan van de cookies, de rest van de cookies gaat in een eventuele Cookie object die dus alleen 1 cookie vasthoudt, een Entity dus.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
+-------------------+
| Storage Interface|
|-------------------|
| Create method |
| Read method |
| Update method |
| Delete method |
| |
+-------------------+-------------------+-------------------+
| CookieStorage | DatabaseStorage | FileStorage |
|-------------------|-------------------|-------------------|
| | | |
| | | |
| | | |
| | | |
| | | |
+-------------------+-------------------+-------------------+
| | | |
| Cookie extends | Database extends | File extends |
| CookieStorage | DatabaseStorage | FileStorage |
| | | |
+-------------------+-------------------+-------------------+
| Storage Interface|
|-------------------|
| Create method |
| Read method |
| Update method |
| Delete method |
| |
+-------------------+-------------------+-------------------+
| CookieStorage | DatabaseStorage | FileStorage |
|-------------------|-------------------|-------------------|
| | | |
| | | |
| | | |
| | | |
| | | |
+-------------------+-------------------+-------------------+
| | | |
| Cookie extends | Database extends | File extends |
| CookieStorage | DatabaseStorage | FileStorage |
| | | |
+-------------------+-------------------+-------------------+
Toevoeging op 09/07/2012 14:03:48:
En deze subklassen (CookieStorage, ...) kunnen natuurlijk ook eigen functies hebben. Bij een FileStorage heb je bijv. nog methods nodig die aangeven waar het bestand staat en bij een DatabaseStorage moet je nog ergens een DB verbinding maken. Die horen er ook nog bij. Bij een SessionStorage moet je bijv. nog ergens session_start() plaatsen en ga zo maar door.
Bedenk nu dus welke extra methods de subklassen nog hebben bovenop de verplichte CRUD.
Tevens heb je nu al door hoe makkelijk het is als je eerst nadenkt? Je hebt nu een goed beeld van wat er allemaal gebeurd in je script, waar de verantwoordelijkheden liggen en straks heb je eigenlijk alles al! Je hoeft alleen nog maar de PHP code te schrijven die in de methods hoort, de rest heb je al allemaal uitgedacht!
Toevoeging op 09/07/2012 14:30:54:
Edit:
nog een vraagje Wouter, hoever moet ik nu in de Cookiestorage class gaan? wat moet er wel en wat moet er niet in kwa functionaliteit? zoiets?
nog een vraagje Wouter, hoever moet ik nu in de Cookiestorage class gaan? wat moet er wel en wat moet er niet in kwa functionaliteit? zoiets?
Code (php)
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
<?php
class CookieStorage implements StorageInterface
{
/**
* Cookie name - the name of the cookie.
* @var bool
*/
private $name = false;
/**
* Cookie value
* @var string
*/
private $value = "";
/**
* Cookie life time
* @var DateTime
*/
private $time;
/**
* Cookie domain
* @var bool
*/
private $domain = false;
/**
* Cookie path
* @var bool
*/
private $path = false;
/**
* Cookie secure
* @var bool
*/
private $secure = false;
/**
* constructor
*/
public function __construct() {
}
/**
* Create or Update cookie.
*/
public function set() {
return setcookie(
$this->name,
$this->getValue(),
$this->getTime(),
$this->getPath(),
$this->getDomain(),
$this->getSecure(), true
);
}
public function get() {
return $_COOKIE[$this->getName()];
}
public function update() {
}
public function delete() {
}
/**
* @param $domain
*/
public function setDomain($domain) {
$this->domain = $domain;
}
/**
* @return bool
*/
public function getDomain() {
return $this->domain;
}
/**
* @param $id
*/
public function setName($id) {
$this->name = $id;
}
/**
* @return bool
*/
public function getName() {
return $this->name;
}
/**
* @param $path
*/
public function setPath($path) {
$this->path = $path;
}
/**
* @return bool
*/
public function getPath() {
return $this->path;
}
/**
* @param $secure
*/
public function setSecure($secure) {
$this->secure = $secure;
}
/**
* @return bool
*/
public function getSecure() {
return $this->secure;
}
/**
* @param $time
*/
public function setTime($time) {
$date = new DateTime();
$date->modify($time);
$this->time = $date->getTimestamp();
}
/**
* @return bool|int
*/
public function getTime() {
return $this->time;
}
/**
* @param string $value
*/
public function setValue($value) {
$this->value = $value;
}
/**
* @return string
*/
public function getValue() {
return $this->value;
}
}
?>
class CookieStorage implements StorageInterface
{
/**
* Cookie name - the name of the cookie.
* @var bool
*/
private $name = false;
/**
* Cookie value
* @var string
*/
private $value = "";
/**
* Cookie life time
* @var DateTime
*/
private $time;
/**
* Cookie domain
* @var bool
*/
private $domain = false;
/**
* Cookie path
* @var bool
*/
private $path = false;
/**
* Cookie secure
* @var bool
*/
private $secure = false;
/**
* constructor
*/
public function __construct() {
}
/**
* Create or Update cookie.
*/
public function set() {
return setcookie(
$this->name,
$this->getValue(),
$this->getTime(),
$this->getPath(),
$this->getDomain(),
$this->getSecure(), true
);
}
public function get() {
return $_COOKIE[$this->getName()];
}
public function update() {
}
public function delete() {
}
/**
* @param $domain
*/
public function setDomain($domain) {
$this->domain = $domain;
}
/**
* @return bool
*/
public function getDomain() {
return $this->domain;
}
/**
* @param $id
*/
public function setName($id) {
$this->name = $id;
}
/**
* @return bool
*/
public function getName() {
return $this->name;
}
/**
* @param $path
*/
public function setPath($path) {
$this->path = $path;
}
/**
* @return bool
*/
public function getPath() {
return $this->path;
}
/**
* @param $secure
*/
public function setSecure($secure) {
$this->secure = $secure;
}
/**
* @return bool
*/
public function getSecure() {
return $this->secure;
}
/**
* @param $time
*/
public function setTime($time) {
$date = new DateTime();
$date->modify($time);
$this->time = $date->getTimestamp();
}
/**
* @return bool|int
*/
public function getTime() {
return $this->time;
}
/**
* @param string $value
*/
public function setValue($value) {
$this->value = $value;
}
/**
* @return string
*/
public function getValue() {
return $this->value;
}
}
?>
Gewijzigd op 09/07/2012 14:31:58 door Reshad F