prinick96 /
Ocrend-Framework
| Total Complexity | 45 |
| Total Lines | 462 |
| Duplicated Lines | 0 % |
| Changes | 0 | ||
Complex classes like Users often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use Users, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 25 | class Users extends Models implements IModels { |
||
| 26 | use DBModel; |
||
| 27 | |||
| 28 | /** |
||
| 29 | * Máximos intentos de inincio de sesión de un usuario |
||
| 30 | * |
||
| 31 | * @var int |
||
| 32 | */ |
||
| 33 | const MAX_ATTEMPTS = 5; |
||
| 34 | |||
| 35 | /** |
||
| 36 | * Tiempo entre máximos intentos en segundos |
||
| 37 | * |
||
| 38 | * @var int |
||
| 39 | */ |
||
| 40 | const MAX_ATTEMPTS_TIME = 120; # (dos minutos) |
||
| 41 | |||
| 42 | /** |
||
| 43 | * Log de intentos recientes con la forma 'email' => (int) intentos |
||
| 44 | * |
||
| 45 | * @var array |
||
| 46 | */ |
||
| 47 | private $recentAttempts = array(); |
||
| 48 | |||
| 49 | /** |
||
| 50 | * Hace un set() a la sesión login_user_recentAttempts con el valor actualizado. |
||
| 51 | * |
||
| 52 | * @return void |
||
| 53 | */ |
||
| 54 | private function updateSessionAttempts() { |
||
| 55 | global $session; |
||
| 56 | |||
| 57 | $session->set('login_user_recentAttempts', $this->recentAttempts); |
||
| 58 | } |
||
| 59 | |||
| 60 | /** |
||
| 61 | * Revisa si las contraseñas son iguales |
||
| 62 | * |
||
| 63 | * @param string $pass : Contraseña sin encriptar |
||
| 64 | * @param string $pass_repeat : Contraseña repetida sin encriptar |
||
| 65 | * |
||
| 66 | * @throws ModelsException cuando las contraseñas no coinciden |
||
| 67 | */ |
||
| 68 | private function checkPassMatch(string $pass, string $pass_repeat) { |
||
| 69 | if ($pass != $pass_repeat) { |
||
| 70 | throw new ModelsException('Las contraseñas no coinciden.'); |
||
| 71 | } |
||
| 72 | } |
||
| 73 | |||
| 74 | /** |
||
| 75 | * Verifica el email introducido, tanto el formato como su existencia en el sistema |
||
| 76 | * |
||
| 77 | * @param string $email: Email del usuario |
||
| 78 | * |
||
| 79 | * @throws ModelsException en caso de que no tenga formato válido o ya exista |
||
| 80 | */ |
||
| 81 | private function checkEmail(string $email) { |
||
| 82 | # Formato de email |
||
| 83 | if (!Helper\Strings::is_email($email)) { |
||
| 84 | throw new ModelsException('El email no tiene un formato válido.'); |
||
| 85 | } |
||
| 86 | # Existencia de email |
||
| 87 | $email = $this->db->scape($email); |
||
|
|
|||
| 88 | $query = $this->db->select('id_user', 'users', null, "email='$email'", 1); |
||
| 89 | if (false !== $query) { |
||
| 90 | throw new ModelsException('El email introducido ya existe.'); |
||
| 91 | } |
||
| 92 | } |
||
| 93 | |||
| 94 | /** |
||
| 95 | * Restaura los intentos de un usuario al iniciar sesión |
||
| 96 | * |
||
| 97 | * @param string $email: Email del usuario a restaurar |
||
| 98 | * |
||
| 99 | * @throws ModelsException cuando hay un error de lógica utilizando este método |
||
| 100 | * @return void |
||
| 101 | */ |
||
| 102 | private function restoreAttempts(string $email) { |
||
| 103 | if (array_key_exists($email, $this->recentAttempts)) { |
||
| 104 | $this->recentAttempts[$email]['attempts'] = 0; |
||
| 105 | $this->recentAttempts[$email]['time'] = null; |
||
| 106 | $this->updateSessionAttempts(); |
||
| 107 | } else { |
||
| 108 | throw new ModelsException('Error lógico'); |
||
| 109 | } |
||
| 110 | } |
||
| 111 | |||
| 112 | /** |
||
| 113 | * Genera la sesión con el id del usuario que ha iniciado |
||
| 114 | * |
||
| 115 | * @param array $user_data: Arreglo con información de la base de datos, del usuario |
||
| 116 | * |
||
| 117 | * @return void |
||
| 118 | */ |
||
| 119 | private function generateSession(array $user_data) { |
||
| 120 | global $session, $cookie, $config; |
||
| 121 | |||
| 122 | # Generar un session hash |
||
| 123 | $cookie->set('session_hash', md5(time()), $config['sessions']['user_cookie']['lifetime']); |
||
| 124 | |||
| 125 | # Generar la sesión del usuario |
||
| 126 | $session->set($cookie->get('session_hash') . '__user_id',(int) $user_data['id_user']); |
||
| 127 | |||
| 128 | # Generar data encriptada para prolongar la sesión |
||
| 129 | if($config['sessions']['user_cookie']['enable']) { |
||
| 130 | # Generar id encriptado |
||
| 131 | $encrypt = Helper\Strings::ocrend_encode($user_data['id_user'], $config['sessions']['user_cookie']['key_encrypt']); |
||
| 132 | |||
| 133 | # Generar cookies para prolongar la vida de la sesión |
||
| 134 | $cookie->set('appsalt', Helper\Strings::hash($encrypt), $config['sessions']['user_cookie']['lifetime']); |
||
| 135 | $cookie->set('appencrypt', $encrypt, $config['sessions']['user_cookie']['lifetime']); |
||
| 136 | } |
||
| 137 | } |
||
| 138 | |||
| 139 | /** |
||
| 140 | * Verifica en la base de datos, el email y contraseña ingresados por el usuario |
||
| 141 | * |
||
| 142 | * @param string $email: Email del usuario que intenta el login |
||
| 143 | * @param string $pass: Contraseña sin encriptar del usuario que intenta el login |
||
| 144 | * |
||
| 145 | * @return bool true: Cuando el inicio de sesión es correcto |
||
| 146 | * false: Cuando el inicio de sesión no es correcto |
||
| 147 | */ |
||
| 148 | private function authentication(string $email,string $pass) : bool { |
||
| 149 | $email = $this->db->scape($email); |
||
| 150 | $query = $this->db->select('id_user,pass','users',null, "email='$email'",1); |
||
| 151 | |||
| 152 | # Incio de sesión con éxito |
||
| 153 | if(false !== $query && Helper\Strings::chash($query[0]['pass'],$pass)) { |
||
| 154 | |||
| 155 | # Restaurar intentos |
||
| 156 | $this->restoreAttempts($email); |
||
| 157 | |||
| 158 | # Generar la sesión |
||
| 159 | $this->generateSession($query[0]); |
||
| 160 | return true; |
||
| 161 | } |
||
| 162 | |||
| 163 | return false; |
||
| 164 | } |
||
| 165 | |||
| 166 | /** |
||
| 167 | * Establece los intentos recientes desde la variable de sesión acumulativa |
||
| 168 | * |
||
| 169 | * @return void |
||
| 170 | */ |
||
| 171 | private function setDefaultAttempts() { |
||
| 172 | global $session; |
||
| 173 | |||
| 174 | if (null != $session->get('login_user_recentAttempts')) { |
||
| 175 | $this->recentAttempts = $session->get('login_user_recentAttempts'); |
||
| 176 | } |
||
| 177 | } |
||
| 178 | |||
| 179 | /** |
||
| 180 | * Establece el intento del usuario actual o incrementa su cantidad si ya existe |
||
| 181 | * |
||
| 182 | * @param string $email: Email del usuario |
||
| 183 | * |
||
| 184 | * @return void |
||
| 185 | */ |
||
| 186 | private function setNewAttempt(string $email) { |
||
| 187 | if (!array_key_exists($email, $this->recentAttempts)) { |
||
| 188 | $this->recentAttempts[$email] = array( |
||
| 189 | 'attempts' => 0, # Intentos |
||
| 190 | 'time' => null # Tiempo |
||
| 191 | ); |
||
| 192 | } |
||
| 193 | |||
| 194 | $this->recentAttempts[$email]['attempts']++; |
||
| 195 | $this->updateSessionAttempts(); |
||
| 196 | } |
||
| 197 | |||
| 198 | /** |
||
| 199 | * Controla la cantidad de intentos permitidos máximos por usuario, si llega al límite, |
||
| 200 | * el usuario podrá seguir intentando en self::MAX_ATTEMPTS_TIME segundos. |
||
| 201 | * |
||
| 202 | * @param string $email: Email del usuario |
||
| 203 | * |
||
| 204 | * @throws ModelsException cuando ya ha excedido self::MAX_ATTEMPTS |
||
| 205 | * @return void |
||
| 206 | */ |
||
| 207 | private function maximumAttempts(string $email) { |
||
| 208 | if ($this->recentAttempts[$email]['attempts'] >= self::MAX_ATTEMPTS) { |
||
| 209 | |||
| 210 | # Colocar timestamp para recuperar más adelante la posibilidad de acceso |
||
| 211 | if (null == $this->recentAttempts[$email]['time']) { |
||
| 212 | $this->recentAttempts[$email]['time'] = time() + self::MAX_ATTEMPTS_TIME; |
||
| 213 | } |
||
| 214 | |||
| 215 | if (time() < $this->recentAttempts[$email]['time']) { |
||
| 216 | # Setear sesión |
||
| 217 | $this->updateSessionAttempts(); |
||
| 218 | # Lanzar excepción |
||
| 219 | throw new ModelsException('Ya ha superado el límite de intentos para iniciar sesión.'); |
||
| 220 | } else { |
||
| 221 | $this->restoreAttempts($email); |
||
| 222 | } |
||
| 223 | } |
||
| 224 | } |
||
| 225 | |||
| 226 | /** |
||
| 227 | * Obtiene datos de un usuario según su id en la base de datos |
||
| 228 | * |
||
| 229 | * @param int $id: Id del usuario a obtener |
||
| 230 | * @param string $select : Por defecto es *, se usa para obtener sólo los parámetros necesarios |
||
| 231 | * |
||
| 232 | * @return false|array con información del usuario |
||
| 233 | */ |
||
| 234 | public function getUserById(int $id, string $select = '*') { |
||
| 235 | return $this->db->select($select,'users',null,"id_user='$id'",1); |
||
| 236 | } |
||
| 237 | |||
| 238 | /** |
||
| 239 | * Obtiene a todos los usuarios |
||
| 240 | * |
||
| 241 | * @param string $select : Por defecto es *, se usa para obtener sólo los parámetros necesarios |
||
| 242 | * |
||
| 243 | * @return false|array con información de los usuarios |
||
| 244 | */ |
||
| 245 | public function getUsers(string $select = '*') { |
||
| 246 | return $this->db->select($select,'users'); |
||
| 247 | } |
||
| 248 | |||
| 249 | /** |
||
| 250 | * Obtiene datos del usuario conectado actualmente |
||
| 251 | * |
||
| 252 | * @param string $select : Por defecto es *, se usa para obtener sólo los parámetros necesarios |
||
| 253 | * |
||
| 254 | * @throws ModelsException si el usuario no está logeado |
||
| 255 | * @return array con datos del usuario conectado |
||
| 256 | */ |
||
| 257 | public function getOwnerUser(string $select = '*') : array { |
||
| 258 | if(null !== $this->id_user) { |
||
| 259 | |||
| 260 | $user = $this->db->select($select,'users',null, "id_user='$this->id_user'",1); |
||
| 261 | |||
| 262 | # Si se borra al usuario desde la base de datos y sigue con la sesión activa |
||
| 263 | if(false === $user) { |
||
| 264 | $this->logout(); |
||
| 265 | } |
||
| 266 | |||
| 267 | return $user[0]; |
||
| 268 | } |
||
| 269 | |||
| 270 | throw new \RuntimeException('El usuario no está logeado.'); |
||
| 271 | } |
||
| 272 | |||
| 273 | /** |
||
| 274 | * Realiza la acción de login dentro del sistema |
||
| 275 | * |
||
| 276 | * @return array : Con información de éxito/falla al inicio de sesión. |
||
| 277 | */ |
||
| 278 | public function login() : array { |
||
| 279 | try { |
||
| 280 | global $http; |
||
| 281 | |||
| 282 | # Definir de nuevo el control de intentos |
||
| 283 | $this->setDefaultAttempts(); |
||
| 284 | |||
| 285 | # Obtener los datos $_POST |
||
| 286 | $email = strtolower($http->request->get('email')); |
||
| 287 | $pass = $http->request->get('pass'); |
||
| 288 | |||
| 289 | # Verificar que no están vacíos |
||
| 290 | if (Helper\Functions::e($email, $pass)) { |
||
| 291 | throw new ModelsException('Credenciales incompletas.'); |
||
| 292 | } |
||
| 293 | |||
| 294 | # Añadir intentos |
||
| 295 | $this->setNewAttempt($email); |
||
| 296 | |||
| 297 | # Verificar intentos |
||
| 298 | $this->maximumAttempts($email); |
||
| 299 | |||
| 300 | # Autentificar |
||
| 301 | if ($this->authentication($email, $pass)) { |
||
| 302 | return array('success' => 1, 'message' => 'Conectado con éxito.'); |
||
| 303 | } |
||
| 304 | |||
| 305 | throw new ModelsException('Credenciales incorrectas.'); |
||
| 306 | |||
| 307 | } catch (ModelsException $e) { |
||
| 308 | return array('success' => 0, 'message' => $e->getMessage()); |
||
| 309 | } |
||
| 310 | } |
||
| 311 | |||
| 312 | /** |
||
| 313 | * Realiza la acción de registro dentro del sistema |
||
| 314 | * |
||
| 315 | * @return array : Con información de éxito/falla al registrar el usuario nuevo. |
||
| 316 | */ |
||
| 317 | public function register() : array { |
||
| 318 | try { |
||
| 319 | global $http; |
||
| 320 | |||
| 321 | # Obtener los datos $_POST |
||
| 322 | $name = $http->request->get('name'); |
||
| 323 | $email = $http->request->get('email'); |
||
| 324 | $pass = $http->request->get('pass'); |
||
| 325 | $pass_repeat = $http->request->get('pass_repeat'); |
||
| 326 | |||
| 327 | # Verificar que no están vacíos |
||
| 328 | if (Helper\Functions::e($name, $email, $pass, $pass_repeat)) { |
||
| 329 | throw new ModelsException('Todos los datos son necesarios'); |
||
| 330 | } |
||
| 331 | |||
| 332 | # Verificar email |
||
| 333 | $this->checkEmail($email); |
||
| 334 | |||
| 335 | # Veriricar contraseñas |
||
| 336 | $this->checkPassMatch($pass, $pass_repeat); |
||
| 337 | |||
| 338 | # Registrar al usuario |
||
| 339 | $id_user = $this->db->insert('users', array( |
||
| 340 | 'name' => $name, |
||
| 341 | 'email' => $email, |
||
| 342 | 'pass' => Helper\Strings::hash($pass) |
||
| 343 | )); |
||
| 344 | |||
| 345 | # Iniciar sesión |
||
| 346 | $this->generateSession(array( |
||
| 347 | 'id_user' => $id_user |
||
| 348 | )); |
||
| 349 | |||
| 350 | return array('success' => 1, 'message' => 'Registrado con éxito.'); |
||
| 351 | } catch (ModelsException $e) { |
||
| 352 | return array('success' => 0, 'message' => $e->getMessage()); |
||
| 353 | } |
||
| 354 | } |
||
| 355 | |||
| 356 | /** |
||
| 357 | * Envía un correo electrónico al usuario que quiere recuperar la contraseña, con un token y una nueva contraseña. |
||
| 358 | * Si el usuario no visita el enlace, el sistema no cambiará la contraseña. |
||
| 359 | * |
||
| 360 | * @return array<string,integer|string> |
||
| 361 | */ |
||
| 362 | public function lostpass() : array { |
||
| 363 | try { |
||
| 364 | global $http, $config; |
||
| 365 | |||
| 366 | # Obtener datos $_POST |
||
| 367 | $email = $http->request->get('email'); |
||
| 368 | |||
| 369 | # Campo lleno |
||
| 370 | if (Helper\Functions::emp($email)) { |
||
| 371 | throw new ModelsException('El campo email debe estar lleno.'); |
||
| 372 | } |
||
| 373 | |||
| 374 | # Filtro |
||
| 375 | $email = $this->db->scape($email); |
||
| 376 | |||
| 377 | # Obtener información del usuario |
||
| 378 | $user_data = $this->db->select('id_user,name', 'users', null, "email='$email'", 1); |
||
| 379 | |||
| 380 | # Verificar correo en base de datos |
||
| 381 | if (false === $user_data) { |
||
| 382 | throw new ModelsException('El email no está registrado en el sistema.'); |
||
| 383 | } |
||
| 384 | |||
| 385 | # Generar token y contraseña |
||
| 386 | $token = md5(time()); |
||
| 387 | $pass = uniqid(); |
||
| 388 | $link = $config['build']['url'] . 'lostpass?token='.$token.'&user='.$user_data[0]['id_user']; |
||
| 389 | |||
| 390 | # Construir mensaje y enviar mensaje |
||
| 391 | $HTML = 'Hola <b>'. $user_data[0]['name'] .'</b>, ha solicitado recuperar su contraseña perdida, si no ha realizado esta acción no necesita hacer nada. |
||
| 392 | <br /> |
||
| 393 | <br /> |
||
| 394 | Para cambiar su contraseña por <b>'. $pass .'</b> haga <a href="'. $link .'" target="_blank">clic aquí</a> o en el botón de recuperar.'; |
||
| 395 | |||
| 396 | # Enviar el correo electrónico |
||
| 397 | $dest = array(); |
||
| 398 | $dest[$email] = $user_data[0]['name']; |
||
| 399 | $email_send = Helper\Emails::send($dest,array( |
||
| 400 | # Título del mensaje |
||
| 401 | '{{title}}' => 'Recuperar contraseña de ' . $config['build']['name'], |
||
| 402 | # Url de logo |
||
| 403 | '{{url_logo}}' => $config['build']['url'], |
||
| 404 | # Logo |
||
| 405 | '{{logo}}' => $config['mailer']['logo'], |
||
| 406 | # Contenido del mensaje |
||
| 407 | '{{content}} ' => $HTML, |
||
| 408 | # Url del botón |
||
| 409 | '{{btn-href}}' => $link, |
||
| 410 | # Texto del boton |
||
| 411 | '{{btn-name}}' => 'Recuperar Contraseña', |
||
| 412 | # Copyright |
||
| 413 | '{{copyright}}' => '© '.date('Y') .' <a href="'.$config['build']['url'].'">'.$config['build']['name'].'</a> - Todos los derechos reservados.' |
||
| 414 | ),0); |
||
| 415 | |||
| 416 | # Verificar si hubo algún problema con el envío del correo |
||
| 417 | if(false === $email_send) { |
||
| 418 | throw new ModelsException('No se ha podido enviar el correo electrónico.'); |
||
| 419 | } |
||
| 420 | |||
| 421 | # Actualizar datos |
||
| 422 | $id_user = $user_data[0]['id_user']; |
||
| 423 | $this->db->update('users',array( |
||
| 424 | 'tmp_pass' => Helper\Strings::hash($pass), |
||
| 425 | 'token' => $token |
||
| 426 | ),"id_user='$id_user'",1); |
||
| 427 | |||
| 428 | return array('success' => 1, 'message' => 'Se ha enviado un enlace a su correo electrónico.'); |
||
| 429 | } catch(ModelsException $e) { |
||
| 430 | return array('success' => 0, 'message' => $e->getMessage()); |
||
| 431 | } |
||
| 432 | } |
||
| 433 | |||
| 434 | /** |
||
| 435 | * Desconecta a un usuario si éste está conectado, y lo devuelve al inicio |
||
| 436 | * |
||
| 437 | * @return void |
||
| 438 | */ |
||
| 439 | public function logout() { |
||
| 440 | global $session, $cookie; |
||
| 441 | |||
| 442 | $session->remove($cookie->get('session_hash') . '__user_id'); |
||
| 443 | foreach($cookie->all() as $name => $value) { |
||
| 444 | $cookie->remove($name); |
||
| 445 | } |
||
| 446 | |||
| 447 | Helper\Functions::redir(); |
||
| 448 | } |
||
| 449 | |||
| 450 | /** |
||
| 451 | * Cambia la contraseña de un usuario en el sistema, luego de que éste haya solicitado cambiarla. |
||
| 452 | * Luego retorna al sitio de inicio con la variable GET success=(bool) |
||
| 453 | * |
||
| 454 | * La URL debe tener la forma URL/lostpass?token=TOKEN&user=ID |
||
| 455 | * |
||
| 456 | * @return void |
||
| 457 | */ |
||
| 458 | public function changeTemporalPass() { |
||
| 459 | global $config, $http; |
||
| 460 | |||
| 461 | # Obtener los datos $_GET |
||
| 462 | $id_user = $http->query->get('user'); |
||
| 463 | $token = $http->query->get('token'); |
||
| 464 | |||
| 465 | $success = false; |
||
| 466 | if (!Helper\Functions::emp($token) && is_numeric($id_user) && $id_user >= 1) { |
||
| 467 | # Filtros a los datos |
||
| 468 | $id_user = $this->db->scape($id_user); |
||
| 469 | $token = $this->db->scape($token); |
||
| 470 | # Ejecutar el cambio |
||
| 471 | $this->db->query("UPDATE users SET pass=tmp_pass, tmp_pass=NULL, token=NULL |
||
| 472 | WHERE id_user='$id_user' AND token='$token' LIMIT 1;"); |
||
| 473 | # Éxito |
||
| 474 | $success = true; |
||
| 475 | } |
||
| 476 | |||
| 477 | # Devolover al sitio de inicio |
||
| 478 | Helper\Functions::redir($config['build']['url'] . '?sucess=' . (int) $success); |
||
| 479 | } |
||
| 480 | |||
| 481 | /** |
||
| 482 | * __construct() |
||
| 483 | */ |
||
| 484 | public function __construct(IRouter $router = null) { |
||
| 487 | } |
||
| 488 | } |
This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces.
This is most likely a typographical error or the method has been renamed.