Login class pdo

volgensmij moet het

$query->rowCount() zijn ipv $query->rowCount

Verder, hou er rekening mee dat je in classes geen html wil gebruiken dus geen echo etc. Waarom in je klasse controleren of je wachtwoord en username niet leeg zijn? Je wil dat juist daarvoor checken, zodat je niet onnodig een klasse aanpsreekt.

Verder zal ik de wachtwoordcheck in een aparte methode zetten.

Wat luc zegt.

Zoiezo moeten die echo's eruit. En gebruik de echo's in de pagina's waar nodig. zo leg je je output niet vast, en blijft je class flexibel.

Verder zou ik gebruik maken van de constructor en daar $db als parameter meegeven, zo ben je niet afhankelijk van de globals, en kan je meerdere objecten van de class aanmaken zonder dat die dezelfde $db gebruikt.

EDIT:
Kijk eens naar je query

Ik zou er zelfs een validation class van maken. Zo kan je al je formulieren door die ene class laten controleren (Code hergebruiken!).
Overigens heb ik zelf nooit de user class "zichzelf laten verifiëren". Bij een user class kijk ik zelf altijd naar wat een user allemaal heeft en kan doen. Een user heeft een wachtwoord en kan die veranderen. Een user kan niet zichzelf verifiëren.
Als je altijd op zo'n manier denkt weet je altijd waar je iets kan vinden. Werkt voor mij heel handig.

Zoals hierboven ook al is gezegd echo je in principe nooit iets. Dat zou heel onhandig zijn als je bijvoorbeeld later besluit om je content in twee of meer talen te publiceren. Dan moet je in álle classes dingen gaan zitten veranderen.

Oh, en wat Luc al aangeeft: rowCount is een function en geen property. Je zult er dus () achter moeten zetten.

Laat maar horen als je nog vragen hebt!

Het eerste wat mij opvalt is alweer je query. Je controleert alleen of de gebruiker bestaat, en vervolgens geef je zelf het wachtwoord. Dit is dus niet inloggen, dit is alleen raad een gebruikersnaam in de database. Je controleert niet op het wachtwoord.

Vraag 1 heb je zelf al opgelost, zo zou ik het ook doen. Het was eerder een authentication class dan een user class.

Voor een userclass staat hier een voorbeeld van hoe victor het bedoelde.

Vraag 2 kan je doen door een extra tabel toe te voegen, en iedere foute poging daarin op te slaan, vervolgens te checken wanneer de laatste foute login was, en daarvanuit verder gaan.
Ik zou wel het account blokkeren en niet het ip adres.

Zoals ik al eerder zei, ik zou database in de constructor meegeven. Gewoon een object als input. Dat werkt beter dan met globals werken.

class Authentication {		


        protected $db;


	public function __construct(PDO $db) {
		$this->db = $db;
	}

Hallo,

In je query staat:
"SELECT `password` FROM `Users` WHERE `username`= ? LIMIT 1"

In deze query vraag je het wachtwoord op waar username gelijk is aan de ingevoerde waarde. Ik mis hier AND 'password' = ?.
Je vraag in de query alleen om een username niet om een wachtwoord.

Je kan een propery aan je class meegeven die false wordt als er een fout is opgetreden.
Vervolgens kun je die met een method ophalen in je login script:

class Bla {
	
	protected $valid = true;
	protected $message = 'FOUT!';




	public function getError() {
		if(!$this->valid) {
			return $this->message;
		}
		else {
		   return false;
		}
	}


}




// loginscript :


$bla = new Bla();


echo $bla->getError()

De valid property zet je op false bij een foute login.

Edit:

Ik zie inderdaad dat je wel op wachtwoord controleert, aleen op een andere manier dan hoe ik gewend ben.
Ik vraag de user gegevens op als wachtwoord & username kloppen.

Op jouw manier zal je dus 2 keer een database moeten aanroepen. 1x voor het wachtwoord en erna om de gevens eruit te halen.

Password_verify is trouwens om hashes te controleren die aangemaakt worden met password_hash();

@r8934
In feite maakt dat niet uit, of je nou in de query of buiten de query het wachtwoord controleert. Is alleen extra werk, dus jouw manier is inderdaad wel beter. (Minder load)

Je kunt denk ik beter overal return false meegeven, in plaats van een foutmelding. Zo kun je een aparte class aanmaken voor je foutafhandeling en is dat ook weer gecentraliseerd. Veel makkelijker te onderhouden.

Ik kan zo snel even geen onbeantwoorde vragen eruit halen, dus roep maar als je nog iets wilt weten.

Voor de foutafhandeling zijn meerdere dingen mogelijk.

Je kan met exceptions gaan werken.

Je kan een static class schrijven, of een registry class.

Je kan het ook via sessies doen en een getOnce() methode schrijven, die de sessie erna weer unset als de melding is getoond.

Het ligt er maar net aan wat jij fijn vind.

Het registreren is een mening, en geen echte vraag.
Ik plaats zoiets liever in de controller.
Er zijn ook genoeg mensen die er een aparte class voor schrijven, of het in de user class zetten.

Bedenk dat elk object zijn eigen doel heeft! Simpel voorbeeld:

User.php - Vaak het model dus is eigenlijk alleen maar een container voor alle data (bevat attributen + getters/setters)
UserDao.php - Dit is het data object van de user (bevat alle database acties)
AuthenticationService.php - Dit is het inloggen zelf, waar alle sessies en zooi worden aangemaakt.
AuthenticationController.php - Dit is de pagina die je laat zien op het web met enkele acties

Dit is een ongetest voorbeeld, heel snel geschreven:

<?php
class User {
	
	private $id;
	private $username;
	private $password;
	
	public __construct($username, $password) {
		$this->username = $username;
		$this->password = $password;
	}
	
	public function getUsername() {
		return $this->username;
	}
	
	public function setUsername($username) {
		$this->username = $username;
	}
	
	...
	
}


class UserDao {
	
	public function getUserByUsername($username) {
		// User object maken.
		$user = new User();
		
		try {
			$query = $db->prepare("SELECT * FROM `Users` WHERE `username`= ? LIMIT 1");
			$query->bindParam(1, $username);
			$query->execute();
			
			if($query->rowCount() == 0) {
				return false;
			}
			
			$result = $query->fetchObject();
			
			// Data naar user object plaatsen, kan volgensmij niet rechtstreekt uit de DB omdat het PHP is.
			$user->setUsername($result->username);
		} catch(\PDOException $e) {
			
		}
		
		return $user;
	}
	
	...
	
}


public AuthenticationService {
	
	public function loginUser($username, $password) {
		$dao = new UserDao();
		$user = $dao->getUserByUsername($username);
		
		if ($user->getPassword() === $password) {
			return true;
		} else {
			return false;
		}
	}
	
	...
	
}


public AuthenticationController {
	
	public function loginPage() {
		$service = new AuthenticationService();
		
		if ($service->loginUser('piet', 'eenheellastigwachtwoord')) {
			echo "Gebruiker is wel ingelogd";
		} else {
			echo "Gebruiker is niet ingelogd";
		}
	}
	
	...
	
}
?>

Ik hoop dat dit je een beetje helpt, het zijn veel extra objecten maar ieder object heeft hierin zijn eigen rol die hij vervult.