Pomoc - Szukaj - Użytkownicy - Kalendarz
Pełna wersja: Rejestracja użytkownika
Forum PHP.pl > Forum > PHP
charzak
16.11.2015, 18:05:13
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 
  1. 	protected function insert() {
  2.  
  3. 		$this->newUser = $_POST;
  4.  
  5. 		$this->prepareUsers($this->newUser['users']);
  6. 		$this->prepareUsersAccounts($this->newUser['usersAccounts']);
  7. 		$this->prepareUsersData($this->newUser['usersData']);
  8. 		$this->prepareUsersHasLegalConsent($this->newUser['usersHasLegalConsent']);
  9. 	//	if ($this->newUser['other']['facture'] == true)
  10. 		$this->prepareUsersDataFactures($this->newUser['usersDataFactures']);
  11.  
  12. 		$modelUsers->insertUsers($this->newUser['users']);
  13. 		$modelUsers->insertUsersAccounts($this->newUser['usersAccounts'], $this->userId);
  14. 		$modelUsers->insertUsersData($this->newUser['usersData'], $this->userId));
  15. 		$modelUsers->insertUsersHasLegalConsent($this->newUser['UsersHasLegalConsent'], $this->userId));
  16. 		if ($this->newUser['other']['facture'] == true)
  17. 			$this->insertUsersDataFactures($this->newUser['usersDataFactures']);
  18.  
  19. 		if (errors::users())
  20. 			$this->redirect($this->insertUsersSuccess);
  21. 		else
  22. 			$this->redirect($this->insertUsersError);
  23.  
  24. 	}
[PHP] pobierz, plaintext
NickOver
17.11.2015, 16:02:42
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 
  1. $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
18.11.2015, 13:27:47
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
lukaskolista
18.11.2015, 13:32:40
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
18.11.2015, 15:38:08
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 
  1. <?php
  2.  
  3. class superglobal {
  4.  
  5. 	function post($variable = null){
  6. 		if($variable != null){
  7. 			if(isset($_POST[$variable])){
  8. 				return htmlspecialchars($_POST[$variable]);
  9. 			}
  10. 		}
  11. 		return null;
  12. 	}
  13. }
[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
23.11.2015, 14:45:52
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 
  1. <?php
  2.  
  3. class UserLog {
  4.  
  5. 	/**
  6. 	 * 
  7. 	 * id użytkonika
  8. 	 * 
  9. 	*/
  10. 	public $userId;
  11.  
  12.  
  13.  
  14. 	/**
  15. 	 * 
  16. 	 * tablica błędów logowania
  17. 	 * 
  18. 	 * 101 - zablokowany
  19. 	 * 102 - nie aktywny
  20. 	*/
  21. 	public $error = array();
  22.  
  23.  
  24.  
  25. 	/**
  26. 	 * logowanie użytkownika
  27. 	 * 
  28. 	 * Sprawdza czy login i hasło się zgadadza
  29. 	 * 
  30. 	 * @set array $_SESSION[user]
  31. 	 * @return userId
  32. 	*/
  33. 	public function login($login, $pass) {
  34.  
  35. 		$model = $this->loadModel('userLog');
  36. 		$user = $model->login($login, $pass);
  37.  
  38. 		if ($user) {
  39. 			if ($user['blocked'] === true) {
  40. 				array_push($this->error, 101);
  41. 				return false;
  42. 			}
  43. 			if ($user['active'] === false) {
  44. 				array_push($this->error, 102);
  45. 				return false;
  46. 			}
  47. 			$this->setUserSession($user);
  48. 			$this->userId = $user['id'];
  49. 			return $this->userId;
  50. 		} else {
  51. 			return false;
  52. 		}
  53. 	}
  54.  
  55.  
  56.  
  57. 	/**
  58. 	 * ustawiwa sesje użytkownika na podstawie zwróconych danych z logowania
  59. 	 * 
  60. 	 * @param array $data
  61. 	 * 
  62. 	 * @set array $_SESSION[user] (id, email, name)
  63. 	*/
  64. 	private function setUserSession($data) {
  65.  
  66. 		foreach ($data as $k=>$v) {
  67.  
  68. 			$_SESSION['user'][$k] = $v;
  69. 		}
  70.  
  71. 	}
  72.  
  73.  
  74.  
  75. 	/**
  76. 	 * 
  77. 	 * niszczy sesje użytkownika
  78. 	 * 
  79. 	*/
  80. 	protected function logout($login) {
  81.  
  82. 		session_destroy($_SESSION['user']);
  83. 	}
  84.  
  85.  
  86.  
  87. 	/**
  88. 	 * 
  89. 	 * ładuje  model
  90. 	 * 
  91. 	*/
  92.     public function loadModel($name, $path='model/') {
  93.         $path=$path.$name.'.php';
  94.         $name=$name.'Model';
  95.         try {
  96.             if(is_file($path)) {
  97.                 require $path;
  98.                 $ob=new $name();
  99.             } else {
  100.                 throw new Exception('Can not open model '.$name.' in: '.$path);
  101.             }
  102.         }
  103.         catch(Exception $e) {
  104.             echo $e->getMessage().'<br />
  105.                 File: '.$e->getFile().'<br />
  106.                 Code line: '.$e->getLine().'<br />
  107.                 Trace: '.$e->getTraceAsString();
  108.             exit;
  109.         }
  110.         return $ob;
  111.     }
  112.  
  113. }
  114.  
  115.  
  116. ?>
[PHP] pobierz, plaintext


klasa rejestracji

[PHP] pobierz, plaintext 
  1. class UserReg {
  2.  
  3. 	/**
  4. 	 * 
  5. 	 * id użytkonika
  6. 	 * 
  7. 	*/
  8. 	public $userId;
  9.  
  10.  
  11.  
  12. 	/**
  13. 	 * 
  14. 	 * bool czy użytkownika przy zapisie ma zablokowane konto
  15. 	 * 
  16. 	*/
  17. 	public $userBlocked = 0;
  18.  
  19.  
  20.  
  21. 	/**
  22. 	 * 
  23. 	 * bool czy użytkownika przy zapisie ma jeste aktywny
  24. 	 * 
  25. 	*/
  26. 	public $userActive = 1;
  27.  
  28.  
  29.  
  30. 	/**
  31. 	 * 
  32. 	 * bool czy użytkownika po zapisie jest zalogowany
  33. 	 * 
  34. 	*/
  35. 	public $userLonin = 1;
  36.  
  37.  
  38.  
  39. 	/**
  40. 	 * 
  41. 	 * Ustawia czy użytkownik ma być zalogowany po rejestracji
  42. 	 * 
  43. 	*/
  44. 	public function setUserLogin($bool) {
  45. 		$this->userLonin = $bool;
  46. 	}
  47.  
  48.  
  49.  
  50. 	/**
  51. 	 * 
  52. 	 * Ustawia czy użytkownik ma być zablokowany
  53. 	 * 
  54. 	*/
  55. 	public function setUserBlocked($bool) {
  56. 		$this->userBlocked = $bool;
  57. 	}
  58.  
  59.  
  60.  
  61. 	/**
  62. 	 * 
  63. 	 * Ustawia czy użytkownik ma być aktywny
  64. 	 * 
  65. 	*/
  66. 	public function setUserActive($bool) {
  67. 		$this->userActive = $bool;
  68. 	}
  69.  
  70.  
  71. 	/*
  72. 	 * sprawdza czy użytkownik istniej
  73. 	 * 
  74. 	 * @param string $email
  75. 	 * @return bool
  76. 	*/
  77. 	public function checkEmail($email) {
  78.  
  79. 		$model = $this->loadModel('userReg');
  80. 		return $model->checkEmail($email);
  81. 	}
  82.  
  83.  
  84.  
  85. 	/*
  86. 	 * zapis nowego użytkownika
  87. 	 * 
  88. 	 * @param array $data
  89. 	 * @set $_SESSION[user]
  90. 	 * @return userId
  91. 	*/
  92. 	public function save($data) {
  93.  
  94. 		$data['users']['blocked'] = $this->userBlocked;
  95. 		$data['users']['active'] = $this->userActive;
  96.  
  97. 		$model = $this->loadModel('userReg');
  98. 		$this->userId = $model->insert($data);
  99.  
  100. 		if ($this->userId) {
  101. 			if ($this->userActive = 1) {
  102. 				$userSession = array(
  103. 					'id' = > $this->userId,
  104. 					'email' = > $data['email'],
  105. 					'name' = > $data['name'];
  106. 				);
  107. 				$this->setUserSession($userSession)
  108. 			}
  109. 			return $this->userId;
  110. 		} else {
  111. 			return false;
  112. 		}
  113. 	}
  114.  
  115.  
  116.  
  117. 	/**
  118. 	 * ustawiwa sesje użytkownika na podstawie zwróconych danych z logowania
  119. 	 * 
  120. 	 * @param array $data
  121. 	 * 
  122. 	 * @set array $_SESSION[user] (id, email, name)
  123. 	*/
  124. 	private function setUserSession($data) {
  125.  
  126. 		foreach ($data as $k=>$v) {
  127. 			$_SESSION['user'][$k] = $v;
  128. 		}
  129.  
  130. 	}
  131.  
  132.  
  133.  
  134. 	/**
  135. 	 * 
  136. 	 * ładuje  model
  137. 	 * 
  138. 	*/
  139.     public function loadModel($name, $path='model/') {
  140.         $path=$path.$name.'.php';
  141.         $name=$name.'Model';
  142.         try {
  143.             if(is_file($path)) {
  144.                 require $path;
  145.                 $ob=new $name();
  146.             } else {
  147.                 throw new Exception('Can not open model '.$name.' in: '.$path);
  148.             }
  149.         }
  150.         catch(Exception $e) {
  151.             echo $e->getMessage().'<br />
  152.                 File: '.$e->getFile().'<br />
  153.                 Code line: '.$e->getLine().'<br />
  154.                 Trace: '.$e->getTraceAsString();
  155.             exit;
  156.         }
  157.         return $ob;
  158.     }
  159.  
  160.  
  161. }
[PHP] pobierz, plaintext
!*!
23.11.2015, 14:53:01
Cytat(charzak @ 23.11.2015, 14:45:52 ) *
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.
To jest wersja lo-fi głównej zawartości. Aby zobaczyć pełną wersję z większą zawartością, obrazkami i formatowaniem proszę kliknij tutaj.
Invision Power Board © 2001-2025 Invision Power Services, Inc.