Hi hier ben ik weer, ik ga zo snel mogelijk het boek dat ik nu heb uitlezen, en dan het boek over OOP dat hier geadviseerd wordt lezen, en natuurlijk toepassen.
Ondertussen heb ik met mijn beperkte kennis van OOP al een deeltje van het script afgewerkt. Namelijk het deel om in te loggen.
Dit is de index.php, dit is het formulier en de verwerking van het formulier. ik heb de overige HTML tags er weer uit gestript.
PHP:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| <?php
if (isset($_POST['submit']))
{
require_once("classes/user.php");
$user = new user;
$user->setUserName($_POST['username']);
$user->setPassword($_POST['password']);
if (count($user->getErrordata()) == 0)
{
$user->loginUser();
}
echo $user->getErrorData();
}
?>
<form method="post" action="<?php echo $_SERVER["PHP_SELF"]; ?>">
<input class="input" type="text" placeholder="username" name="username" value="" />
<input class="input" type="password" placeholder="password" name="password" />
<input type="submit" name="submit" value="Login"><br>
</form>
|
Dit is de user class: (Het is de bedoeling dat hier het login zelf gebeurt, en uit loggen, deze class is dus goed in het autentificeren van gebruikers).
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
| <?php
class user
{
private $firstname;
private $lastname;
private $email;
private $username;
private $password;
private $passwordDatabase;
private $passwordCrypt;
private $pepperDatabase;
private $error;
private $salt;
private $safe;
function __construct()
{
$this->error = array();
$this->salt = 'R4185u4488J388n';
$this->safe = 'test.php';
}
public function setUserName($username)
{
if (empty($username))
{
array_push($this->error, 'userNameEmpty');
}
elseif (strpos($username, ' ') !== false)
{
array_push($this->error, 'userNameSpaces');
}
elseif (strlen($username) < 3 and strlen($username) > 10)
{
array_push($this->error, 'userNameLength');
}
else
{
$this->username = $username;
}
}
public function setPassword($password)
{
if (empty($password))
{
array_push($this->error, 'passwordEmpty');
}
elseif (strpos($password, ' ') !== false)
{
array_push($this->error, 'passwordSpaces');
}
elseif (strlen($password) < 8)
{
array_push($this->error, 'passwordLength');
}
else
{
$this->password = $password;
}
}
public function getUsername()
{
return $this->username;
}
public function getErrorData()
{
return $this->error;
}
public function loginUser()
{
require("database.php");
$database = new database;
$database->setUsername($this->username);
$this->passwordDatabase = $database->getPassworDatabase();
$this->pepperDatabase = $database->getPepperDatabase();
if ($this->checkPassword())
{
$database->setUserDataDatabase();
$this->firstname = $database->getFirstname();
$this->lastname = $database->getLastname();
$this->email = $database->getEmail();
$this->startSession();
$this->makeSession();
header('location: ' . $this->safe. '');
}
}
private function checkPassword()
{
$this->passwordCrypt = crypt($this->password, '$5$' . $this->salt . $this->pepperDatabase);
if (trim($this->passwordDatabase) == trim($this->passwordCrypt) )
{
return true;
}
else
{
array_push($error, 'passwordWrong');
}
}
private function startSession()
{
if (!isset($_SESSION))
{
session_start();
}
}
private function makeSession()
{
$_SESSION['username'] = $this->username;
$_SESSION['firstname'] = $this->firstname;
$_SESSION['lastname'] = $this->lastname;
$_SESSION['email'] = $this->email;
}
}
?>
|
De code in de contstruct ga ik nog vervangen door constanten die in een apart configuratie bestand zijn opgenomen.
En de database class:
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
| <?php
class database
{
private $passworDatabase;
private $username;
public function __construct()
{
require_once("config.php");
}
public function setUsername($username)
{
$this->username = $username;
}
public function getPassworDatabase()
{
$connection = DataBaseConnection::getInstance();
$sql = "SELECT password FROM users WHERE username=?";
$q = $connection->getPDO()->prepare($sql);
$q->execute(array($this->username));
$row = $q->fetch();
return $row['password'];
}
public function getPepperDatabase()
{
$connection = DataBaseConnection::getInstance();
$sql = "SELECT pepper FROM users WHERE username=?";
$q = $connection->getPDO()->prepare($sql);
$q->execute(array($this->username));
$row = $q->fetch();
return $row['pepper'];
}
public function setUserDataDatabase()
{
$connection = DataBaseConnection::getInstance();
$sql = "SELECT firstname, lastname, email FROM users WHERE username=?";
$q = $connection->getPDO()->prepare($sql);
$q->execute(array($this->username));
$row = $q->fetch();
echo '<pre>';
var_dump($row);
echo '</pre>';
$this->firstname = $row['firstname'];
$this->lastname = $row['lastname'];
$this->email = $row['email'];
}
public function getFirstname()
{
return $this->firstname;
}
public function getLastname()
{
return $this->lastname;
}
public function getEmail()
{
return $this->email;
}
}
|
Deze class doet dus alle afhandelingen met de database, en dat is ook alles.
Ik heb nog enkele vragen die mij verwarren, in de user class moet ik (tijdelijk) verschillende paswoorden opslaan. Per tijdelijk passwoord heb ik nu een property aangemaakt.
Ik heb de functies die van buitenaf benaderd worden een public scoop meegegeven, en de gene die ik enkel in de class zelf gebruikt private. Is dit de normale gang van zaken?
Ik ga nu de links over de database connecties lezen, want nu maak ik elke keer opnieuw een verbinding, maar ik wilde klein beginnen.
De error afhandeling ga ik ook nog maken, maar eclipse vond het leuk om de user class leeg te maken.
, dus dan heb ik dat maar eerst opnieuw herschreven. (Ondertussen back-up ik de code regelmatig)
P.s. in de quickstart stond iets, dat GoT geen code nakijk forum was, maar omdat ik toch nog met enkele vragen zit, heb ik de code voor de duidelijkheid hier in dit topic gepost,
Ik hoop dat ik ondertussen in objecten begin te denken, maar ik ga zo snel mogelijk dat boek kopen en lezen.
EDIT: zoals gezegd heb ik naar Singleton pattern gekeken, en de code daarop aangepast.
En dan de config.php:
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
| <?php
<?php
class DataBaseConnection {
static private $instance = NULL;
private $PDO;
private function __construct() {
$this->PDO= new PDO('mysql:host=localhost;dbname=login', 'root', 'h4crUDru');
}
static public function getInstance() {
if (self::$instance == NULL) self::$instance = new self;
return self::$instance;
}
public function __clone()
{
trigger_error('Clone is not allowed.', E_USER_ERROR);
}
public function getPDO(){
return $this->PDO;
}
}
?>
|
LEDfan wijzigde deze reactie 17-07-2012 12:12 (27%)
)
). Dan zou er zo uit kunnen zien:
Heb dat stuk even weggehaald. Idealiter heb je gelijk, maar in een versimpelde vorm zou je ervoor kunnen kiezen om je SQL statements in je business layer te zetten. En aangezien we hier te maken hebben met een TS die een simpele vorm van OOP probeert te implementeren...:
Iets duidelijker zou waarschijnlijk wel zijn om te zeggen dat het een absolute URL moet zijn.
