Verbesserungsvorschläge zu Login-Klasse

CookieBuster · 4. Oktober 2009

Hi Leute,

Ich habe eine Loginklasse geschrieben welche ich auch anwenden möchte. Ich persönlich bin irgentwie noch nicht so ganz damit zufrieden, fragt mich aber nicht warum, bisher nur so ein Gefühl. Die Frage wäre ob hier jemand Vorschläge hätte.

Interessant wäre:
- Performaceverbesserungen
- DB-Entlastung
- Codeverschönerungen (Naja, natürlich subjektiv zu sehen)
- Sonstiges

Lasst einfach alles raus

Ich hänge den Code zustälich noch als .zip an, falls jemand es direkt bei sich testen möchte. Kommentierung sollte zum schnell und einfach verstehen ausreichen, denke ich.
Ich habe eine TestIndex gleich dabei.

Die Tabellen:

Code:

-- --------------------------------------------------------

--
-- Tabellenstruktur für Tabelle `failed_logins`
--

CREATE TABLE IF NOT EXISTS `failed_logins` (
  `ip` varchar(64) collate utf8_unicode_ci NOT NULL,
  `time` timestamp NOT NULL default CURRENT_TIMESTAMP
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

-- --------------------------------------------------------

--
-- Tabellenstruktur für Tabelle `user`
--

CREATE TABLE IF NOT EXISTS `user` (
  `id` int(11) NOT NULL auto_increment,
  `nickname` varchar(32) collate utf8_unicode_ci NOT NULL,
  `password` varchar(32) collate utf8_unicode_ci NOT NULL,
  `rights` binary(10) NOT NULL,
  `is_admin` binary(1) NOT NULL default '0',
  `salt` varchar(16) collate utf8_unicode_ci NOT NULL,
  `cookie_hash` varchar(32) collate utf8_unicode_ci NOT NULL,
  PRIMARY KEY  (`id`),
  KEY `nickname` (`nickname`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=5 ;

Die Index, nur zum Zeigen wie's funktioniert:

PHP:

<?php
/**
 * Configuration
 */
$Config = array();

/* MySQL Table Prefix: */
$Config['TablePrefix']           = '';   			 // Tabellen Prefix, wenn keiner Vorhanden ist einfach leer lassen

/* Debug? */
$Config['Debug']        = 1;            	 // 1 = true, 0 = false;
$Config['Notices']      = 1;            	 // show notices. 1 = true, 0 = false

/* MySQL Connection Settings: */
$Config['DBHost']      = 'localhost';       // DB-Host
$Config['DBUser']      = '';            // DB-Username
$Config['DBPass']      = '';       // DB-Passwort
$Config['DBName']        = '';           // Datenbank
$Config['MySQLForm']   = 'mysqli';			 // Welche MySQLFunktionen benutzen?

/* Templates: */
$Config['TemplateDir']      = 'tpl/';            // Template Verzeichnis

/* Cookies: */
$Config['CookieName']  = 'login_';          // Cookie Name
$Config['CookieTimeout'] = 60*60*24*10;     // Wie lange gelten Cookies in Sekunden
$Config['CookieSeperator']    = '|.|?|.|';  // Seperator when build string of pw and username to save in only 1 cookie
$Config['CookiePath']       = '/';               // Path, in which the cookie is available no need to change this

/* Anti-Brutoforcing: */
$Config['LoginRetrys']       = 3;                 // Max. Login Versuche in Zeitspanne: $Config['LoginTimeout'];
$Config['LoginTimeout']      = 3600;              // In dieser Zeitspanne darf der User max $Config['LoginRetrys'] login versuche machen, in Sekunden

/* Admin */
$Config['AdminPage']    = 'admin.php';       // Admindatei


require_once "Login.class.php";

ob_start();

$Login = new Login($Config);

// Session starten
session_start();

// Sicherstellen das die SID durch den Server vergeben wurde
// um einen möglichen Session Fixation Angriff unwirksam zu machen
if (!isset( $_SESSION['server_SID'] )) {
	// Möglichen Session Inhalt löschen
	session_unset();
	// Ganz sicher gehen das alle Inhalte der Session gelöscht sind
	$_SESSION = array();
	// Session zerstören
	session_destroy();
	// Session neu starten
	session_start();
	// Neue Server-generierte Session ID vergeben
	session_regenerate_id();
	// Status festhalten
	$_SESSION['server_SID'] = TRUE;
}
if(isset($_GET['logout']) && $_GET['logout'] == "true") {
	$Login->Logout();
}

if(isset($_POST['Submit'])) {
	if($Login->LoginUser($_POST['UName'], $_POST['UPass'], TRUE)) {
		echo "Erfolgreich eingeloggt!";
	} else {
		echo "Einloggen fehlgeschlagen!";
	}
}
$Form = <<<Bump
<form action="" method="POST">
	Name: <input type="text" name="UName" value="Robusta"/><br />
	Pass: <input type="text" name="UPass" value="pass" /><br />
	<input type="submit" value="Abschicken" name="Submit" />
</form><br /><br />
Bump;
echo $Form;

if($Login->LoginCheck()) {
	echo "Du bist eingeloggt";
} else {
	echo "Du bist NICHT eingeloggt";
}

echo "<pre>";
print_r($_POST);
print_r($_SESSION);
print_r($_COOKIE);

ob_end_flush();


?>

Die Klasse selbst:

PHP:

<?php
/**
 * @lastchange 04.10.2009
 * @author CookieBuster (c) 2009
 * @mail <cookies91@gmx.de>
 * Diese Klasse ist OpenSource, jeder kann sie verwenden und nach seinen Vorstellungen verändern.
 * Verbesserungsvorschläge, Lob und Kritik per Mail verschicken ;)
 */
class Login {
	/**
	 * Wichtige Klassenvariablen
	 */
	public  $UserId         = 0;             // Die Id des Nutzers
	public  $Username       = "";            // Name des aktuellen Users
	public  $Password       = "";            // verschlüsseltes Passwort des Users
	private $IsAdmin        = FALSE;         // Ist der User Admin?
	private $Salt           = "";            // Salt des Users
	private $Config         = array();       // Globales Konfigurationsarray
	private $DBConnection   = NULL;          // Datenbankverbindung
	private $DBSelected     = NULL;          // Die gewählte Datenbank
	private $DBError        = "";            // Wird gefüllt wenn ein Fehler bei der Datanbankarbeit auftritt
	
	/**
	 * Konstruktor, setzt die Werte für die Klasse
	 */
	public function __construct($Config) {
		$this->Config = $Config;
		
		// Erzwingen dass Session-Cookies benutzt werden und die SID nicht per URL übertragen wird
		ini_set('session.use_only_cookies', '1');
		ini_set('session.use_trans_sid', '0');
		
		// Notices zeigen, oder nicht:
        if ($this->Config['Notices']) {
            error_reporting(E_ALL|E_STRICT);
            ini_set('display_errors', '1');
        } else {
            error_reporting(0);
            ini_set('display_errors', '0');
        }
		
		// Wenn keine Datenbankverbindung geöffnet ist, Verbinden ansonsten anpingen
		if($this->DBConnection === NULL) {
			$this->DBConnect();
		} else {
			$this->DBCheckCon();
		}
	}
	
	/**
	 **************************************************************************
	 * Datenbankfunktionen
	 **************************************************************************
	 */
	
	
	/**
	 * Baut eine Verbindung zur Datenbank auf
	 */
	private function DBConnect() {
		// Wenn noch keine Verbindung vorhanden ist, eine neue Etablieren
		if($this->DBConnection !== NULL) {
			// Prüft ob eine Datenbankverbindung offen ist
			$this->DBCheckCon();
			return TRUE;
		}
		
		// Neue MySQLi-Klasse
		$this->DBConnection = new mysqli($this->Config['DBHost'], $this->Config['DBUser'], $this->Config['DBPass'], $this->Config['DBName']);
		
		// Ist ein Fehler beim Verbinden aufgetreten?
		if (mysqli_connect_error()) {
			// Fehler speichern
			$this->DBError = 'Connect Error (' . mysqli_connect_errno() . ') '.mysqli_connect_error()." in <b>". __CLASS__ ."::". __FUNCTION__ ."</b>";
			
			// DatenbankVariable wieder leeren
			$this->DBConnection = NULL;
			
			// Fehler verarbeiten
			$this->DBDebug();
			return FALSE;
		}
		return TRUE;
	}
	
	/**
	 * Prüft ob eine Verbindung zu Datenbank vorhanden ist
	 */
	private function DBCheckCon() {
		// Anpingen der Datenbank
		if(!$this->DBConnection->ping()) {
			// DatenbankVariable wieder leeren
			$this->DBConnection = NULL;
			
			// Neue Datenbankverdingung aufbauen
			$this->DBConnect();
		}
	}
	
	/**
	 * DebugMethode, Verarbeitung von Fehlern
	 */
	private function DBDebug() {
		if($this->Config['Debug']) {
			echo $this->DBError;
		}
		return TRUE;
	}
	
	/**
	 **************************************************************************
	 * Login
	 **************************************************************************
	 */
	
	
	/**
	 * Sollte ein Login fehlschlagen, Ip und Zeit speichern. Verhindert Brute-Force-Angriffe
	 */
	function LoginSaveFails() {
		// Überprüft DB-Con
		$this->DBCheckCon();  		
		
		// Query festlegen
		$Query = "INSERT INTO `".$this->Config['TablePrefix']."failed_logins` (`ip`) VALUES (?)";
		
		// Query vorbereiten
		if(!$Insert = $this->DBConnection->prepare($Query)) {
			// Fehler verarbeiten
			$this->DBError = "Query Error in <b>". __CLASS__ ."::". __FUNCTION__ ."</b>";
			$this->DBDebug();
		}
		
		// Entsprechende Variablen festlegen
		$RemoteAddr = $_SERVER["REMOTE_ADDR"];
		
		// Paramter einfügen
		$Insert->bind_param('s', $RemoteAddr);
		
		// Ausführen
		$Insert->execute();
		
		// Prüfen ob erfolgreich war
		if ($Insert->affected_rows != 1) {
			// Fehler verarbeiten
			$this->DBError = 'Query Error (' . $Insert->errno . ') '.$Insert->error." in <b>". __CLASS__ ."::". __FUNCTION__ ."</b>";
			$this->DBDebug();
		}
		
		// Ergebnis freigeben
		$Insert->close();
		
		return TRUE;
	}
	
	/**
	 * Überprüft die Fehlgeschlagenen Loginversuche
	 */
	function LoginCheckFails() {
		// Überprüft DB-Con
		$this->DBCheckCon();    
		
		// Query festlegen
		$Query = "SELECT `ip`, `time` FROM `".$this->Config['TablePrefix']."failed_logins` WHERE `ip` = ? AND `time` > ?";
		
		// Query vorbereiten
		$Insert = $this->DBConnection->stmt_init();
		if(!$Insert->prepare($Query)) {
			// Fehler verarbeiten
			$this->DBError = "Query Error in <b>". __CLASS__ ."::". __FUNCTION__ ."</b>";
			$this->DBDebug();
		}
		
		// Entsprechende Variablen festlegen
		$RemoteAddr = $_SERVER["REMOTE_ADDR"];
		$TimeDif = (time() - $this->Config['LoginTimeout']);
		
		// Paramter einfügen
		$Insert->bind_param('si', $RemoteAddr, $TimeDif);
		
		// Ausführen
		$Insert->execute();
		
		// Ergebnis speichern
		$Insert->store_result();
		
		// Auf Fehler überprüfen
		if($Insert->errno != 0) {
			// Fehler verarbeiten
			$this->DBError = 'Query Error (' . $Insert->errno . ') '.$Insert->error." in <b>". __CLASS__ ."::". __FUNCTION__ ."</b>";
			$this->DBDebug();
		}
		
		// Die Anzahl der Datensätze speichern
		$NumRows = $Insert->num_rows;
		
		// Verbindung schließen
		$Insert->close();
		
		return $NumRows;
	}  
	
	/**
	 * Ließt die Anzahl der Fehlgeschlagenen Versuche aus. Ist sie zu hoch, return FALSE
	 */
	function LoginTrialsAvailable() {
		// Überprüfen der Fehlversuche
		if($this->LoginCheckFails() < $this->Config['LoginRetrys']) {
			return TRUE;
		} else {
			return FALSE;
		}
	}
	
	/**
	 * Prüft ob der User existiert und überprüft das gegebene Passwort
	 */
	function LoginUserAuth($User, $Pass, $FromCookie = FALSE) {
		// Prüft die Verbindung zur Datenbank
		$this->DbCheckCon();    
		
		// Query festlegen
		$Query = "SELECT `id`, `nickname`, `password`, `is_admin`, `salt`, `cookie_hash` FROM `".$this->Config['TablePrefix']."user` WHERE LOWER(`nickname`) = LOWER(?)";
		
		// Query vorbereiten
		$Insert = $this->DBConnection->stmt_init();
		if(!$Insert->prepare($Query)) {
			// Fehler verarbeiten
			$this->DBError = 'Query Error (' . $Insert->errno . ') '.$Insert->error." in <b>". __CLASS__ ."::". __FUNCTION__ ."</b>";
			$this->DBDebug();
		}
		
		// Paramter einfügen
		$Insert->bind_param('s', $User);
		
		// Ausführen
		$Insert->execute();
		
		// Ergebnis speichern
		$Insert->store_result();
	
		// Die Anzahl der Datensätze speichern
		$NumRows = $Insert->num_rows;
	
		if($NumRows == 1) {				
			// Ergebnis an die Variablen binden
			$Insert->bind_result($DBId, $DBNick, $DBPass, $DBIsAdmin, $DBSalt, $DBCookieHash);
			
			// Variablen füllen
			$Insert->fetch();
			
			// Daten überprüfen, entweder Passwort oder CookieHash
			if($FromCookie) {
				if($DBCookieHash != $Pass) {
					return FALSE;
				}
			} else {
				if($DBPass != md5($Pass.$DBSalt)) {
					return FALSE;
				}
			}
			
			// Prüfen ob der user Admin ist		
			if($DBIsAdmin) {
				// Als Admin authentifizieren
				$this->AdminAuth();    
			}
			
			// Werte speichern
			$this->UserId   = $DBId;
			$this->Username = $DBNick;
			$this->Password = $DBPass;
			$this->Salt     = $DBSalt;
			
			// Verbindung schließen
			$Insert->close();
			
			// User Vorhanden
			return TRUE;
		}
		
		// User nicht vorhanden
		return FALSE;
	}

	
	/**
	 * Loggt den übergebenen User ein
	 */
	function LoginUser($User, $Pass, $StayLoggedIn = FALSE) {
		// Escapes entfernen wenn MagicQuotes aktiv sind
		if(get_magic_quotes_gpc()) {
			$User = stripslashes($User);
			$Pass = stripslashes($Pass);
		}
		
		// Leerzeichen entfernen
		$User = trim($User);
		
		// User vorhanden?
		$UserAuth = $this->LoginUserAuth($User, $Pass);
		
		// Wenn vorhanden und richtige Daten
		if($UserAuth) {
			// Wenn dauerhaft einloggen
			if($StayLoggedIn) {
				// Cookies setzen
				$this->CookieSetup($this->Username, $this->CookieGenerateHash());
			}
			
			// In Session speichern
			$this->SessionSetup($User);
			
			// Gegen zu viele Querys hintereinander von Hackern
			// Simuliert eine ServerAntwortZeit zw. 0.5 und 1.5 s
			usleep(rand(500000,1500000));
			
			// Einloggen erfolgreich
			return TRUE;
		}
		
		// Gegen zu viele Querys hintereinander von Hackern
		// Simuliert eine ServerAntwortZeit zw. 0.5 und 1.5 s
		sleep(rand(2,4));
		
		// Einloggen nicht erfolgreich
		return FALSE;
	}
	
	/**
	 * Ist der User eingloggt?
	 */
	function LoginCheck() {
		// Prüfen ob das Cookie gesetzt ist
		if(isset($_COOKIE[$this->Config['CookieName'].'user_login'])) {
			// String auslesen, wenn Cookie nicht vorhanden Abbrechen
			$String = $_COOKIE[$this->Config['CookieName'].'user_login'];
			
			// String exploden
			$Explode = explode($this->Config['CookieSeperator'], $String);
			
			// In Variablen speichern
			if(is_array($Explode)) {
				$User = $Explode[0];
				$Hash = $Explode[1];
			} else {
				echo "Fehler beim Auslesen des Cookies!";
				return FALSE;
			}
			
			// Prüfen ob die Userdaten korrekt sind
			if($this->LoginUserAuth($User, $Hash, TRUE)) {
				return TRUE;
			}
		} 
		
		// Prüfen ob Sessons verwendet werden
		if(isset($_SESSION['UserData'])) {
			// Wenn die Daten richtig sind
			if(isset($_SESSION['UserData']['Name']) AND $_SESSION['UserData']['Name'] === $this->Username AND isset($_SESSION['UserData']['Login']) AND $_SESSION['UserData']['Login']) {
				return TRUE;
			}
		}
		
		return FALSE;
	}	
	
	/**
        * Logt den User aus
	 */
	function Logout() {
		// Cookies zerstören, wenn vorhanden
		if(isset($_COOKIE[$this->Config['CookieName'].'user_login'])) {
			$this->CookiesDestroy();
		}
		
		// Session zerstören          
		$this->SessionDestroy();
		
		return TRUE;
	}
	
	/**
	 **************************************************************************
	 * Session und Cookie-Handling
	 **************************************************************************
	 */
	
	
	/**
	 * Login per Cookie
	 */
	function CookieSetup($User, $Hash) {
		// Cookie setzen
		$CookieString = $User.$this->Config['CookieSeperator'].$Hash;    
		setcookie($this->Config['CookieName'].'user_login', $CookieString, time() + $this->Config['CookieTimeout'], $this->Config['CookiePath']);
		
		// Query festlegen
		$Query = 'UPDATE `'.$this->Config['TablePrefix'].'user` SET `cookie_hash` = ? WHERE LOWER(`nickname`) = LOWER(?)';
		
		// Query vorbereiten
		$Insert = $this->DBConnection->stmt_init();
		if(!$Insert->prepare($Query)) {
			// Fehler verarbeiten
			$this->DBError = "Query Error in <b>". __CLASS__ ."::". __FUNCTION__ ."</b>";
			$this->DBDebug();
		}
		
		// Paramter einfügen
		$Insert->bind_param('ss', $Hash, $User);
		
		// Ausführen
		$Insert->execute();
		
		// Verbindung schließen
		$Insert->close();
		
		return TRUE;
	}

	/**
	 *  Login per Sesion
	 */
	function SessionSetup($User) {
		$_SESSION['UserData']['Name'] = $User;
		$_SESSION['UserData']['Login'] = TRUE;
		return TRUE;
	}
	
	/**
	 * Cookies zerstören
	 */
	private function CookiesDestroy() {
		// Cookie leeren und auf 0 Lebensdauer setzen
		setcookie($this->Config['CookieName'].'user_login', '', 0, $this->Config['CookiePath']);
		return TRUE;
	} 
	 
	/**
	 * Session zerstören
	 */
	private function SessionDestroy() {
		// Unset
		session_unset();
		
		// Sicher gehen
		$_SESSION = array();
		
		// Zerstören
		session_destroy();
		
		return TRUE;
	}
	
	/**
	 * Erstellt einen Hash, für den CookieLogin
	 */
	private function CookieGenerateHash() {
		// Variable Initialisieren
		$Hash = ""; 
		
		// Wie viele Zeichen soll der Hash beinhalten?
		$HashSize = 32;
		
		// Zufallszahlengenerator Initialisieren
		srand((double)microtime()*1000000); 
		
		// So lange durchlaufen lasse, bis man genügend Zeichen hat
		for($i=0; $i < $HashSize; $i++) {
			// Zufallszahl erzeugen
			$Number = rand(48,120);
			// neue Zufallszahl wenn außerhalb des normalen ASCII-Alphabets
			while (($Number >= 58 && $Number <= 64) || ($Number >= 91 && $Number <= 96)) {
				$Number = rand(48,120);
			}
			// Hash erweitern
			$Hash .= chr($Number);
		}
		// Zurückgeben des Hashes
		return $Hash;
	}
	
	/**
	 **************************************************************************
	 * User
	 **************************************************************************
	 */
	
	
	/**
	 **************************************************************************
	 * Admin
	 **************************************************************************
	 */
	 
	
	/**
	 * Prüfen ob der User Admin ist
	 */
	function IsAdmin() {
		// Wenn der Inhalt der Varible Wahr ist, TRUE zurückgeben
		if($this->IsAdmin) {
			return TRUE;
		}
		return FALSE;
	}
	
	/*
	 * Neuen Nutzer einfügen
	 */
	function AdminUserInsert($User, $Pass, $IsAdmin) {
		// Prüfen ob der User Admin ist
		if(!$this->IsAdmin()) {
			return FALSE;
		}

		// Existiert der User bereits?
		
		// Query festlegen
		$Query = 'SELECT NULL FROM `'.$this->Config['TablePrefix'].'user` WHERE LOWER(`nickname`) = ?';
		
		// Query vorbereiten
		$Insert = $this->DBConnection->stmt_init();
		if(!$Insert->prepare($Query)) {
			// Fehler verarbeiten
			$this->DBError = 'Query Error (' . $Insert->errno . ') '.$Insert->error." in <b>". __CLASS__ ."::". __FUNCTION__ ."</b>";
			$this->DBDebug();
		}
		
		// Paramter einfügen
		$Insert->bind_param('s', strtolower($User));
		
		// Ausführen
		$Insert->execute();
		
		// Ergebnis speichern
		$Insert->store_result();
			
		// Die Anzahl der Datensätze speichern
		$NumRows = $Insert->num_rows;
		
		// Verbindung schließen
		$Insert->close();
		
		// Existiert bereits, Fehlermeldung und Abbruch
		if($NumRows > 0) {		
			// Fehlerauswurf
			echo "Der User konnte nicht erstellt werden, es existiert bereits ein User mit diesem Namen!";
			return TRUE;
		}

		// Neuen User erzeugen
		$Query = 'INSERT INTO `'.$this->Config['TablePrefix'].'user` (`nickname`, `password`, `is_admin`) VALUES (?, ?, ?)';
		
		// Query vorbereiten
		$Insert = $this->DBConnection->stmt_init();
		if(!$Insert->prepare($Query)) {
			// Fehler verarbeiten
			$this->DBError = "Query Error in <b>". __CLASS__ ."::". __FUNCTION__ ."</b>";
			$this->DBDebug();
		}
		
		// Paramter einfügen
		$Insert->bind_param('ssi', $User, $Pass, $IsAdmin);
		
		// Ausführen
		$Insert->execute();
		
		// Auf Fehler überprüfen
		if($Insert->errno != 0) {
			// Fehler verarbeiten
			$this->DBError = 'Query Error (' . $Insert->errno . ') '.$Insert->error." in <b>". __CLASS__ ."::". __FUNCTION__ ."</b>";
			$this->DBDebug();
		}
		
		// Verbindung schließen
		$Insert->close();
		
		return true;
	}
	
	/*
	 * Einen User löschen
	 */
	function AdminUserDelete($UserId) {
		// Prüfen ob der User Admin ist
		if(!$this->IsAdmin()) {
			return FALSE;
		}
		
		// Query festlegen
		$Query = 'DELETE FROM `'.$this->Config['TablePrefix'].'user` WHERE `id` = ? LIMIT 1';
		
		// Query vorbereiten
		$Insert = $this->DBConnection->stmt_init();
		if(!$Insert->prepare($Query)) {
			// Fehler verarbeiten
			$this->DBError = "Query Error in <b>". __CLASS__ ."::". __FUNCTION__ ."</b>";
			$this->DBDebug();
		}
		
		// Paramter einfügen
		$Insert->bind_param('i', $UserId);
		
		// Ausführen
		$Insert->execute();
		
		// Auf Fehler überprüfen
		if($Insert->errno != 0) {
			// Fehler verarbeiten
			$this->DBError = 'Query Error (' . $Insert->errno . ') '.$Insert->error." in <b>". __CLASS__ ."::". __FUNCTION__ ."</b>";
			$this->DBDebug();
		}
		
		// Verbindung schließen
		$Insert->close();
		
		return TRUE;
	}
	
	/*
	 * Alle Nutzer auslesen und in ein Array speichern
	 */
	function AdminGetUsers() {
		// Prüfen ob der User Admin ist
		if(!$this->IsAdmin()) {
			return FALSE;
		}
		
		// Query festlegen
		$Query = 'SELECT `id`, `nickname`, `password`, `is_admin` AS `admin` FROM `'.$this->Config['TablePrefix'].'user` ORDER BY `nickname` ASC';
		
		// Variable initialisieren
		$AllUsers = array();
		
		// Das Ergebnis in ein Array speichern
		if($Result = $this->DBConnection->query($Query)) {
			while($Row = $Result->fetch_object()) {
				$AllUsers[] = $Row;
			}
		}
		
		// Alle Nutzer als Array zurückgeben
		return $AllUsers;
	}
	
	/**
	 * Den Nutzer als Admin authentifizieren
	 */
	function AdminAuth() {
		// Variable TRUE sezten
		$this->IsAdmin = TRUE;
		return TRUE;
	}
	
}
?>

Danke an diejenigen die sich die Mühe machen =)

gr und gute Nacht
CB

Parantatatam · 4. Oktober 2009

Was mir aufgefallen ist, ist die Sache, dass du eine Konfigurationseinstellung hast, die $Config['MySQLForm'] heißt, du diese aber nirgendwo verarbeitest.

CookieBuster · 5. Oktober 2009

Diese Konfiguration ist für später gedacht, sodass man auch ohne MySQLi-Erweiterung die Klasse benutzen kann.
Wird dementsprechend noch erweitert.

Aber interessant, dass soetwas auffällt

ZodiacXP · 5. Oktober 2009

Was wenn jemand Postgre, SQLite, etc. nutzt oder die MySQLi-Erweiterung fehlt bzw. deaktiviert ist?

Eine Adapter-Klasse hilft:

PHP:

interface SQLAdapter
{
  function query($host, $user, $pass, $database);
  function connect();
  function fetch();
}

class SQLAdapterMySQLi implements SQLAdapter
{

  function connect($host, $user, $pass, $database = NULL)
  {
    ...
  }

  ...

}

class SQLAdapterPDO implements SQLAdapter
{

  function connect($host, $user, $pass, $database = NULL)
  {
    ...
  }

  ...
}

Und deine Klasse agiert fast als Factory:

PHP:

function __construct($config)
{
  switch (strtolower($config['system']))
  {
    case 'mysqli':
      if (extension_loaded('mysqli'))
      {
        $this->sql = new SQLAdapterMySQLi
      }
      else
      {
        throw new Error('MySQLi not available');
      }
      break;

    case 'pdo':
      ...
  }
}

Aber Vorsicht, damit bist du auf dem Weg ein Framework zu entwickeln und die gibt es schon wie Sand am Meer

CookieBuster · 5. Oktober 2009

Danke für die Antwort Zodiac, sie hat mich überzeugt, das ganze exakt auf meine Vorstellungen zurrechtzustutzen. Ein Framework habe ich eig nicht vor zu entwickeln :O

Sehe ich das richtig, dass ein Interface nur angiebt welche Funktionen definitiv vorhanden sein müssen?

ZodiacXP · 5. Oktober 2009

CookieBuster hat gesagt.:
Sehe ich das richtig, dass ein Interface nur angiebt welche Funktionen definitiv vorhanden sein müssen?

Jap. Das bietet einige Vorteile in der Wiederverwendung ähnlich zu abstrakten Klassen. Quasi ein Regelwerk, damit sich keiner ärgert, dass beim umstellen eine Funktion fehlt.

Verbesserungsvorschläge zu Login-Klasse

CookieBuster

Erfahrenes Mitglied

Anhänge

Parantatatam

mag Cookies & Kekse

CookieBuster

Erfahrenes Mitglied

ZodiacXP

Erfahrenes Mitglied

CookieBuster

Erfahrenes Mitglied

ZodiacXP

Erfahrenes Mitglied

Neue Beiträge