public function __construct($host, $username, $password, $database) {
$this->host = $host;
$this->username= $username;
$this->password= $password;
$this->database= $database;
$this->connect();
}
private function connect() {
mysql_connect($this->host, $this->username, $this->password);
mysql_select_db($this->database);
}
public function loginnow() {
$result = mysql_query("SELECT gebruikerid FROM gebruikers WHERE gebruikersnaam='" . mysql_real_escape_string($_POST['gebruikersnaam']) . "' AND wachtwoord='" . mysql_real_escape_string($_POST['wachtwoord']) . "'");
- De connect functie kun je gewoon bij de construct functie zetten.
- Require kan je -vind ik- beter in het begin doen, dus voor de if
- Het OOP programmeren kan je misschien wel, maar je moet ook OOP kunnen denken. Dat betekend dat je moet leren denken in objecten. Elk object is een class.
Als je bijv. een tabel wilt maken heb je een table object, een tr object en een td object:
> Table
> Row
> Cell
Deze objecten hebben weer eigenschappen. In een Cel staat de content, in een Rij staan cellen en in een Tabel staan rijen. Deze eigenschappen zijn de properties:
> Table
- rows
> Row
- cells
> Cell
- content
Nu heb je alleen nog een gedrag/verandering toe te voegen aan de objecten. Een Cel kan content toevoegen en hij kan zichzelf tonen, een Rij kan cellen toevoegen en hij kan ook zichzelf tonen en een Tabel kan rijen toevoegen en zichzelf ook tonen. Dit zijn de methoden:
> Table
- rows
append()
write()
> Row
- cells
append()
getRows()
> Cells
- content
append()
getCells()
Nu heb je de basis van een tabel. Dit is Object geörienteerd denken en zeker nodig bij het maken van OOP.
Probeer na dit verhaal zelf eens te bedenken welke classes, properties en methodes je nodig hebt voor een login.
- Database zou je eigenlijk in een aparte database handler moeten stoppen.
- Zelfde geld voor sessie
- Variabelen protected, uitbreidingen moet mogelijk blijven
- POST variabelen niet direct in de klasse aanroepen, google eens op een request handler, of maak er variabelen in je methode van.
Maar goed, het concept is al niet goed, en ik quote maar even een bericht van jelmer:
Jelmer rrrr op 28/12/2010 10:17:59
Heel heel heel strict genomen zou je inloggen en gebruikers moeten scheiden. Je hebt gebruikers, en je hebt een set classen die inloggen mogelijk maken. Die classen regelen dan het opslaan van de combinatie gebruiker – wachtwoord, (of gebruiker + openid, daarom zijn ze losgetrokken van de User class, zodat je verschillende manieren van inloggen kan maken) en die classen regelen het onthouden van de identiteit van iemand na het inloggen.
User_Store
- create($nickname, $email)
- get($id)
User
- id()
// regelt het onthouden van iemands identiteit (in bijv. $_SESSION)
Authentication
- __construct(User_Store $users)
// roept $method->login($arguments) aan, en onthoudt het user-id dat die teruggeeft
- login(AuthenticationMethod $method, array $arguments)
- isLoggedIn()
// geeft $users->get($currentUserId) terug.
- currentUser()
PasswordIdentification extends AuthenticationMethod
// koppelt een gebruiker aan een wachtwoord
- register(User $user, $password)
// geeft user-id terug indien gelukt
- login(array $arguments)
OpenIDIdentification extends AuthentictionMethod
- register(User $user, $openid)
// geeft user-id terug indien gelukt
- login(array $arguments)
Maar in veel gevallen is dat misschien wat teveel, en dan zou ik zeggen dat je User_Store::create een extra argument, $password, meegeeft, en een extra method, User_Store::login($username, $password) die dan net zo werkt als User_Store::get($id), en dat je zelf de sessies e.d. afhandelt in een simpele class.
Je moet leren denken in objecten. Wat heb je bij een inlog systeem? Een user object en een object die ervoor zorgt dat die user ingelogd wordt.
In deze objecten/classes zitten weer eigenschappen/properties. Dit zijn voor de user bijv. naam, wachtwoord, ... Daarnaast heeft deze user class ook nog gedragsveranderingen/methoden. Je kan bijv. de naam wijzigen, rank wijzigen, ect.
Een user class zou er dus bijv. zo uit kunnen zien:
> User
- name
- rank
- pass
changeName()
changeRank()
changePass()
ConnectDB en ConnectUser klinken als werkwoorden en doen dan ook meer denken aan iets wat je in een functie zou afhandelen.
Classes zijn er om objecten mee te maken. Een object is een "ding". Het lijkt dan ook logisch om classes te maken met een naam die een zelfstandig naamwoord is.
Het is een simplificatie ... op drie lijntjes krijg je het niet helemaal uitgelegd.
Connect is iets wat je als object kan doen. Je hebt in jou geval dus een class Database en een class User. Deze heeft dan de functies/methodes connect.