Rejestracja użytkownika Opcje

[charzak]

hej, piszę nową wersję mojej aplikacji i mam do was pytanie odnoście takiego rozwiązania jak poniżej. Co o tym myślicie? Jeśli macie jakieś sugestie proszę napisać.

[PHP] pobierz, plaintext 
	protected function insert() {
 
		$this->newUser = $_POST;
 
		$this->prepareUsers($this->newUser['users']);
		$this->prepareUsersAccounts($this->newUser['usersAccounts']);
		$this->prepareUsersData($this->newUser['usersData']);
		$this->prepareUsersHasLegalConsent($this->newUser['usersHasLegalConsent']);
	//	if ($this->newUser['other']['facture'] == true)
		$this->prepareUsersDataFactures($this->newUser['usersDataFactures']);
 
		$modelUsers->insertUsers($this->newUser['users']);
		$modelUsers->insertUsersAccounts($this->newUser['usersAccounts'], $this->userId);
		$modelUsers->insertUsersData($this->newUser['usersData'], $this->userId));
		$modelUsers->insertUsersHasLegalConsent($this->newUser['UsersHasLegalConsent'], $this->userId));
		if ($this->newUser['other']['facture'] == true)
			$this->insertUsersDataFactures($this->newUser['usersDataFactures']);
 
		if (errors::users())
			$this->redirect($this->insertUsersSuccess);
		else
			$this->redirect($this->insertUsersError);
 
	}
[PHP] pobierz, plaintext 

Ten post edytował charzak 16.11.2015, 21:15:46

[NickOver]

Musisz pokazać trochę więcej kodu. Chyba że chodzi tylko o ten kawałek, wtedy według mnie:

-brak zabezpieczeń przed xss'em (chyba że któreś z tych przygotowań to zabezpiecza)
-wszystkie prepare wrzucił bym do jednej metody
-wszystkie inserty również
-Masz 4 tabelki do przechowywania info użytkowniku/koncie? (Jeśli nie to po co 4 zapytania?)
Gdzie deklarujesz:

[PHP] pobierz, plaintext 
$this->userId
[PHP] pobierz, plaintext 

Gdzie sprawdzasz czy użytkownik istnieje?
Gdzie sprawdzasz czy jedna osoba nie zakłada kliku kont?
Czy te metody coś zwracają czy dopisują do $this i się kończą?

[charzak]

Dziękuję za odpowiedź. rzeczywiście trochę za mało kodu przedstawiłem na dniach postaram sie wrzucić całą klasę.

w metodach prepare będzie zabezpieczenie xss, metody zwarą poprawne dane do $this->user[usersData] (tak jak nazwy tabel) lub [users] ub [usersAcounts] i tak dalej. jeśli dane są nie poprawne to będzie zwrócony błąd i przekierowanie do poprawienia formularza (raczej takiej opcji nie zakładam bo będzie validator formularzy).

z tym rozdzieleniem insrtów i prepare chodzi mi o to, że np. przy rejstracji będzie zapis 4 lub 5 tabel ale już przy edycji np danych adresowych tylko 1 tabeli, stąd to rozdzielenie.

dane usera są podzielone na tabele:
users - login hasło aktywny zabokowany
usersAccount - punkty rabaty vouchery licencje itp
usersData - imie nazwisko dane adresowe
usersFactures - dane do factory
usersAddresses - dane do wysyłki
usersHasLegalConsent - zgody prawne

uważasz, że ten podział powinien być inny? jestem otwarty na sugestie i krytykę.

dodatkowo zastanawiam się na rozbiciem klasy users na:

Users extends Controller
UsersRegister extends Users - tylko rejestracje
UsersAuth extends Users - logowania
UsersEdit - edycja i usuwanie

ma to sens? i w Users extends Controller - byłyby metody prepare a inserty już w swoich klasach

Ten post edytował charzak 18.11.2015, 13:28:45

[lukaskolista]

Nie ma to sensu, bo w klasie Users robisz prepare, które z założenia nie zostaną wykorzystane. Kontrolery mają to do siebie, że nie stosuje się w nich typowego polimorfizmu.

[NickOver]

Ja bym to zrobił bardziej w ten sposób:
-uwierzytelnianie użytkownika (w tym przed Session injection co request)
-klasa rejestracji + model
-klasa logowania + model
Zamiast sprawdzać czy nie ma xss'a zrobił bym klase superglobal a w niej coś takiego:

[PHP] pobierz, plaintext 
<?php
 
class superglobal {
 
	function post($variable = null){
		if($variable != null){
			if(isset($_POST[$variable])){
				return htmlspecialchars($_POST[$variable]);
			}
		}
		return null;
	}
}
[PHP] pobierz, plaintext 

I analogicznie dla get, cookie itp. lub pobawić się z __call() lub switchem. Dzięki temu nie będziesz musiał za każdym razem pisać if(isset()) i htmlspecialchars() przez co kod będzie czytelniejszy.

[charzak]

zastanawiam się jeszcze czy na pewno warto rozbijać obsługę użytkownika na kilka klas: users, usersReg, usersLog, usersEdit, ma to być wykorzystane w portalu i osobno w sklepie internetowym

klasa logowania co o niej myślicie?

[PHP] pobierz, plaintext 
<?php
 
class UserLog {
 
	/**
	 * 
	 * id użytkonika
	 * 
	*/
	public $userId;
 
 
 
	/**
	 * 
	 * tablica błędów logowania
	 * 
	 * 101 - zablokowany
	 * 102 - nie aktywny
	*/
	public $error = array();
 
 
 
	/**
	 * logowanie użytkownika
	 * 
	 * Sprawdza czy login i hasło się zgadadza
	 * 
	 * @set array $_SESSION[user]
	 * @return userId
	*/
	public function login($login, $pass) {
 
		$model = $this->loadModel('userLog');
		$user = $model->login($login, $pass);
 
		if ($user) {
			if ($user['blocked'] === true) {
				array_push($this->error, 101);
				return false;
			}
			if ($user['active'] === false) {
				array_push($this->error, 102);
				return false;
			}
			$this->setUserSession($user);
			$this->userId = $user['id'];
			return $this->userId;
		} else {
			return false;
		}
	}
 
 
 
	/**
	 * ustawiwa sesje użytkownika na podstawie zwróconych danych z logowania
	 * 
	 * @param array $data
	 * 
	 * @set array $_SESSION[user] (id, email, name)
	*/
	private function setUserSession($data) {
 
		foreach ($data as $k=>$v) {
 
			$_SESSION['user'][$k] = $v;
		}
 
	}
 
 
 
	/**
	 * 
	 * niszczy sesje użytkownika
	 * 
	*/
	protected function logout($login) {
 
		session_destroy($_SESSION['user']);
	}
 
 
 
	/**
	 * 
	 * ładuje  model
	 * 
	*/
    public function loadModel($name, $path='model/') {
        $path=$path.$name.'.php';
        $name=$name.'Model';
        try {
            if(is_file($path)) {
                require $path;
                $ob=new $name();
            } else {
                throw new Exception('Can not open model '.$name.' in: '.$path);
            }
        }
        catch(Exception $e) {
            echo $e->getMessage().'<br />
                File: '.$e->getFile().'<br />
                Code line: '.$e->getLine().'<br />
                Trace: '.$e->getTraceAsString();
            exit;
        }
        return $ob;
    }
 
}
 
 
?>
[PHP] pobierz, plaintext 

klasa rejestracji

[PHP] pobierz, plaintext 
class UserReg {
 
	/**
	 * 
	 * id użytkonika
	 * 
	*/
	public $userId;
 
 
 
	/**
	 * 
	 * bool czy użytkownika przy zapisie ma zablokowane konto
	 * 
	*/
	public $userBlocked = 0;
 
 
 
	/**
	 * 
	 * bool czy użytkownika przy zapisie ma jeste aktywny
	 * 
	*/
	public $userActive = 1;
 
 
 
	/**
	 * 
	 * bool czy użytkownika po zapisie jest zalogowany
	 * 
	*/
	public $userLonin = 1;
 
 
 
	/**
	 * 
	 * Ustawia czy użytkownik ma być zalogowany po rejestracji
	 * 
	*/
	public function setUserLogin($bool) {
		$this->userLonin = $bool;
	}
 
 
 
	/**
	 * 
	 * Ustawia czy użytkownik ma być zablokowany
	 * 
	*/
	public function setUserBlocked($bool) {
		$this->userBlocked = $bool;
	}
 
 
 
	/**
	 * 
	 * Ustawia czy użytkownik ma być aktywny
	 * 
	*/
	public function setUserActive($bool) {
		$this->userActive = $bool;
	}
 
 
	/*
	 * sprawdza czy użytkownik istniej
	 * 
	 * @param string $email
	 * @return bool
	*/
	public function checkEmail($email) {
 
		$model = $this->loadModel('userReg');
		return $model->checkEmail($email);
	}
 
 
 
	/*
	 * zapis nowego użytkownika
	 * 
	 * @param array $data
	 * @set $_SESSION[user]
	 * @return userId
	*/
	public function save($data) {
 
		$data['users']['blocked'] = $this->userBlocked;
		$data['users']['active'] = $this->userActive;
 
		$model = $this->loadModel('userReg');
		$this->userId = $model->insert($data);
 
		if ($this->userId) {
			if ($this->userActive = 1) {
				$userSession = array(
					'id' = > $this->userId,
					'email' = > $data['email'],
					'name' = > $data['name'];
				);
				$this->setUserSession($userSession)
			}
			return $this->userId;
		} else {
			return false;
		}
	}
 
 
 
	/**
	 * ustawiwa sesje użytkownika na podstawie zwróconych danych z logowania
	 * 
	 * @param array $data
	 * 
	 * @set array $_SESSION[user] (id, email, name)
	*/
	private function setUserSession($data) {
 
		foreach ($data as $k=>$v) {
			$_SESSION['user'][$k] = $v;
		}
 
	}
 
 
 
	/**
	 * 
	 * ładuje  model
	 * 
	*/
    public function loadModel($name, $path='model/') {
        $path=$path.$name.'.php';
        $name=$name.'Model';
        try {
            if(is_file($path)) {
                require $path;
                $ob=new $name();
            } else {
                throw new Exception('Can not open model '.$name.' in: '.$path);
            }
        }
        catch(Exception $e) {
            echo $e->getMessage().'<br />
                File: '.$e->getFile().'<br />
                Code line: '.$e->getLine().'<br />
                Trace: '.$e->getTraceAsString();
            exit;
        }
        return $ob;
    }
 
 
}
[PHP] pobierz, plaintext 

Ten post edytował charzak 23.11.2015, 14:46:26

[!*!]

zastanawiam się jeszcze czy na pewno warto rozbijać obsługę użytkownika na kilka klas: users, usersReg, usersLog, usersEdit, ma to być wykorzystane w portalu i osobno w sklepie internetowym

Nie. Klasa do zarządzania użytkownikiem to klasa do zarządzania użytkownikiem (dodawanie, usuwanie, edycja, ew aktywacja). Autoryzacja użytkownika to osoba klasa (logowanie, wylogowanie, sprawdzanie czy zalogowany). Dobry przykład możesz obadać z zendzie.

Ten post edytował !*! 23.11.2015, 14:55:47