1234 lines
36 KiB
PHP
1234 lines
36 KiB
PHP
<?php
|
|
/**
|
|
* FuzeWorks
|
|
*
|
|
* The FuzeWorks MVC PHP FrameWork
|
|
*
|
|
* Copyright (C) 2015 TechFuze
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* @author TechFuze
|
|
* @copyright Copyright (c) 2013 - 2015, Techfuze. (http://techfuze.net)
|
|
* @copyright Copyright (c) 1996 - 2015, Free Software Foundation, Inc. (http://www.fsf.org/)
|
|
* @license http://opensource.org/licenses/GPL-3.0 GPLv3 License
|
|
* @link http://fuzeworks.techfuze.net
|
|
* @since Version 0.0.1
|
|
* @version Version 0.0.1
|
|
*/
|
|
|
|
namespace Module\Users;
|
|
use \FuzeWorks\Module;
|
|
use \FuzeWorks\EventPriority;
|
|
use \FuzeWorks\Config;
|
|
use \FuzeWorks\Modules;
|
|
use \FuzeWorks\Events;
|
|
use \FuzeWorks\Logger;
|
|
use \FuzeWorks\Layout;
|
|
|
|
/**
|
|
* Main class of the Sessions and User Management module.
|
|
* Manages users and login requests from FuzeWorks.
|
|
* @package net.techfuze.fuzeworks.sessions
|
|
* @author Abel Hoogeveen <abel@techfuze.net>
|
|
* @copyright Copyright (c) 2013 - 2015, Techfuze. (http://techfuze.net)
|
|
*/
|
|
class Users extends Module {
|
|
|
|
/**
|
|
* UDT of the current session, send to the user
|
|
* @access public
|
|
* @var Array UDT's
|
|
*/
|
|
public $udt;
|
|
|
|
/**
|
|
* Database object for quick interaction
|
|
* @access private
|
|
* @var \Module\Database\Main Object Reference
|
|
*/
|
|
private $db;
|
|
|
|
/**
|
|
* Whether cookies should be set or the details should be returned as arrays
|
|
* @var boolean true for cookies, false for arrays
|
|
*/
|
|
public $setCookies = true;
|
|
|
|
/**
|
|
* Gets called upon module initialization
|
|
* @access public
|
|
*/
|
|
public function onLoad() {
|
|
require_once($this->getmodulePath() . "/class.events.php");
|
|
require_once($this->getModulePath() . "/class.cookie.php");
|
|
require_once($this->getModulePath() . "/class.udt.php");
|
|
$this->db = Modules::get('core/database');
|
|
}
|
|
|
|
/**
|
|
* Whether cookies should be set or the details should be returned as arrays
|
|
* @param boolean $boolean true for cookies, false for arrays
|
|
*/
|
|
public function setCookies($boolean = true) {
|
|
$this->setCookies = $boolean;
|
|
}
|
|
|
|
/**
|
|
* Validate a session using a sessionKey
|
|
* Looks up wether a session exists and returns sessionData
|
|
* @access public
|
|
* @param String SessionKey (optional)
|
|
* @return SessionData Array
|
|
* @todo Evaluate final conditions, vague
|
|
*/
|
|
public function start($sessionKey = null) {
|
|
// Fetch the sessionKey, if it exists
|
|
$sessionKey = (isset($_COOKIE[$this->cfg->cookie_name]) ? $_COOKIE[$this->cfg->cookie_name] : (isset($_REQUEST['sessionKey']) ? $_REQUEST['sessionKey'] : $sessionKey ));
|
|
|
|
// If a sessionKey is given, check it
|
|
if (is_null($sessionKey)) {
|
|
$data = false;
|
|
} else {
|
|
$data = $this->sessionIsValid($sessionKey, true);
|
|
}
|
|
|
|
$udt = null;
|
|
|
|
// Prepare for the event
|
|
if ($data !== false) {
|
|
$udt = $this->convertUserData($data);
|
|
$guest_session = false;
|
|
} else {
|
|
$udt = $this->getGuestUdt();
|
|
$guest_session = true;
|
|
}
|
|
|
|
$user_id = $udt->user_id;
|
|
$username = $udt->username;
|
|
$email = $udt->primaryEmail;
|
|
|
|
// Fire the event
|
|
$event = Events::fireEvent(new SessionStartEvent(), $user_id, $username, $email, $udt, $guest_session);
|
|
if ($event->isCancelled() || $event->guest_session) {
|
|
return $this->sendUserSession($udt);
|
|
}
|
|
|
|
if ($this->sessionBlocked($event->udt)) {
|
|
return $this->sendUserSession($udt);
|
|
}
|
|
|
|
return $this->sendUserSession($event->udt);
|
|
}
|
|
|
|
/**
|
|
* Send a Guest Session to the user
|
|
* @access private
|
|
* @return Guest UDT
|
|
*/
|
|
private function sendGuestSession() {
|
|
// Replace a cookie if present so the user will become a guest
|
|
if (isset($_COOKIE[$this->cfg->cookie_name])) {
|
|
$cookie = new Cookie($this->cfg->cookie_name, '', time()-3600, '/', Config::get('main')->SITE_DOMAIN);
|
|
// Set the cookie if required to do so
|
|
if ($this->setCookies) {
|
|
$cookie->place();
|
|
}
|
|
}
|
|
$udt = $this->getGuestUdt();
|
|
$this->udt = $udt;
|
|
$this->logSessionData();
|
|
return $udt;
|
|
}
|
|
|
|
/**
|
|
* Returns the standard User Data Table of a guest account
|
|
* @access private
|
|
* @return Array UDT
|
|
*/
|
|
private function getGuestUdt() {
|
|
$udt = new Udt(0,
|
|
'Guest',
|
|
'Guest@'.Config::get('main')->SITE_DOMAIN,
|
|
array(
|
|
'Guest@'.Config::get('main')->SITE_DOMAIN
|
|
),
|
|
array(
|
|
'GUEST' => 'GUEST',
|
|
'LOGIN' => 'LOGIN'
|
|
),
|
|
array(),
|
|
'0'
|
|
);
|
|
|
|
return $udt;
|
|
}
|
|
|
|
/**
|
|
* Send a user session to the user
|
|
* Also sets the module UDT to the input
|
|
* @access private
|
|
* @param Array UDT
|
|
* @return UDT
|
|
*/
|
|
private function sendUserSession($udt) {
|
|
$this->udt = $udt;
|
|
$this->logSessionData();
|
|
return $udt;
|
|
}
|
|
|
|
/**
|
|
* Log the session data to the FuzeWorks logger
|
|
* @access private
|
|
*/
|
|
private function logSessionData() {
|
|
Logger::newLevel("Activating Session");
|
|
Logger::logInfo("<br />SessionKey: " . $this->sessionKey . "<br />Username: " . $this->username . "<br/>Email: " . $this->primaryEmail . "<br/>Permissions: " . implode('-', $this->permissions));
|
|
Logger::stopLevel();
|
|
}
|
|
|
|
/**
|
|
* Convert the userdata from the database to UDT
|
|
* @access private
|
|
* @param Array SessionData
|
|
* @return Array Userdata
|
|
* @todo change this into a version that uses an external table for more user data
|
|
*/
|
|
private function convertUserData($userData) {
|
|
$udt = array();
|
|
for ($i=0; $i < count($userData); $i++) {
|
|
foreach ($userData[$i] as $key => $value) {
|
|
if (strpos($key, 'user_') === 0 || strpos($key, 'session_') === 0) {
|
|
$udt[$key] = $value;
|
|
}
|
|
}
|
|
$udt['permissions'][$userData[$i]['tag_name']] = $userData[$i]['tag_name'];
|
|
}
|
|
return $udt;
|
|
}
|
|
|
|
/**
|
|
* Check wether the UDT has a permission tag that blocks the account
|
|
* @access private
|
|
* @param Array UDT
|
|
* @return Boolean true if blocked, false if not
|
|
*/
|
|
private function sessionBlocked($udt) {
|
|
if (isset($udt['permissions']['UNVERIFIED']) || isset($udt['permissions']['BLOCKED'])) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Check wether a sessionKey is valid and active
|
|
* @access private
|
|
* @param String SessionKey
|
|
* @param Boolean fetchData (wether to return the sessionData)
|
|
* @return Boolean False if invalid, true if valid and no fetchData, array if valid and fetchData
|
|
*/
|
|
private function sessionIsValid($sessionKey, $fetchData = false) {
|
|
$prefix = $this->db->getPrefix();
|
|
$query = "
|
|
SELECT *
|
|
FROM ".$prefix."user_permissions AS permissions
|
|
|
|
LEFT JOIN ".$prefix."user_users AS users
|
|
ON permissions.permission_user_id=users.user_id
|
|
|
|
LEFT JOIN ".$prefix."user_tags AS tags
|
|
ON permissions.permission_tag_id=tags.tag_id
|
|
|
|
LEFT JOIN ".$prefix."user_sessions AS sessions
|
|
ON permissions.permission_user_id=sessions.session_user_id
|
|
|
|
WHERE sessions.session_hash = ?
|
|
AND sessions.session_active = 1
|
|
";
|
|
$stmnt = $this->db->prepare($query);
|
|
$stmnt->execute(array($sessionKey));
|
|
$result = $stmnt->fetchAll(\PDO::FETCH_ASSOC);
|
|
|
|
if (count($result) > 0) {
|
|
if (is_null($result[0]['session_hash'])) {
|
|
return false;
|
|
}
|
|
if ($fetchData) {
|
|
return $result;
|
|
}
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Logs a user into the system. Checks the password and generates a session hash
|
|
* @access public
|
|
* @param String identifier (email or username)
|
|
* @param String password
|
|
* @param Boolean Wether to remember the session (true for 100 years, false for incremental)
|
|
* @param Boolean propagate, wether the login should be propagated to the database (default true)
|
|
* @return Array SessionData
|
|
*/
|
|
public function login($identifier, $password, $remember_me = false, $propagate = true) {
|
|
// Get the user with this identifier
|
|
$prefix = $this->db->getPrefix();
|
|
$query = "
|
|
SELECT *
|
|
FROM ".$prefix."user_users AS users
|
|
WHERE users.user_email = :identifier OR users.user_username = :identifier";
|
|
$stmnt = $this->db->prepare($query);
|
|
$stmnt->execute(array('identifier' => $identifier));
|
|
$result = $stmnt->fetch(\PDO::FETCH_ASSOC);
|
|
|
|
// Prepare the return variable
|
|
$sessionData = array();
|
|
if (count($result) > 0) {
|
|
$sessionData = $result;
|
|
// If user found, check password
|
|
if (password_verify($password, $result['user_password'])) {
|
|
// If correct, prepare sessionData
|
|
// Create Session
|
|
$one = uniqid();
|
|
$two = sha1(uniqid() . $identifier);
|
|
$three = uniqid();
|
|
$hash = sha1($one . $two . $three);
|
|
|
|
// Add SessionInfo to the SessionData Array
|
|
$info['type'] = 'fuzeworks.sessions';
|
|
$info['agent'] = (isset($_SERVER['HTTP_USER_AGENT']) ? $_SERVER['HTTP_USER_AGENT'] : "");
|
|
$info['IP'] = (isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : "UNKNOWN");
|
|
|
|
$sessionData['info'] = json_encode($info);
|
|
$sessionData['ip'] = $info['IP'];
|
|
$sessionData['session_start'] = date('Y-m-d H:i:s',strtotime("now"));
|
|
$sessionData['hash'] = $hash;
|
|
$sessionData['valid_time'] = ($remember_me ? time()+(10*365*24*3600) : time()+3600*720);
|
|
|
|
// Add the success value
|
|
$sessionData['valid'] = true;
|
|
$valid = true;
|
|
} else {
|
|
// Password incorrect
|
|
$sessionData['valid'] = false;
|
|
$sessionData['reason'] = "PASSWORD_INCORRECT";
|
|
$sessionData['reason_explained'] = "Username and/or password is incorrect";
|
|
$valid = false;
|
|
}
|
|
} else {
|
|
// User not found
|
|
$sessionData['valid'] = false;
|
|
$sessionData['reason'] = "USER_NOT_FOUND";
|
|
$sessionData['reason_explained'] = "Username and/or password is incorrect";
|
|
$valid = false;
|
|
}
|
|
|
|
// Broadcast data with an event
|
|
if ($valid) {
|
|
// If valid, provide all required data
|
|
$event = Events::fireEvent(new SessionLoginEvent(),
|
|
$identifier,
|
|
$password,
|
|
$remember_me,
|
|
$sessionData['user_id'],
|
|
$sessionData['user_username'],
|
|
$sessionData['user_email']
|
|
);
|
|
} else {
|
|
// If not, provide only the identifiers
|
|
$event = Events::fireEvent(new SessionLoginEvent(), $identifier, $password, $remember_me);
|
|
}
|
|
|
|
// Firest check for full blown deny
|
|
if ($event->isCancelled()) {
|
|
$sessionData['valid'] = false;
|
|
$sessionData['reason'] = "USER_DENIED";
|
|
$sessionData['reason_explained'] = "The User has been denied by an internal proces";
|
|
}
|
|
|
|
// Then check for verification
|
|
if ($event->verified) {
|
|
$sessionData['user_id'] = $event->user_id;
|
|
$sessionData['user_username'] = $event->username;
|
|
$sessionData['username'] = $event->username;
|
|
$sessionData['user_email'] = $event->email;
|
|
$sessionData['email'] = $event->email;
|
|
} else {
|
|
// If not verified, deny access
|
|
$sessionData['valid'] = false;
|
|
if ($valid) {
|
|
// If denied by event, export reason
|
|
$sessionData['reason'] = "USER_DENIED";
|
|
$sessionData['reason_explained'] = "The User has been denied by an internal proces";
|
|
}
|
|
}
|
|
|
|
// Propagate if valid
|
|
if ($propagate) {
|
|
$this->propagate($sessionData);
|
|
}
|
|
|
|
return $sessionData;
|
|
}
|
|
|
|
/**
|
|
* Propagate a login to the database and set the cookie. Don't forget to redirect to apply the cookie
|
|
* @access public
|
|
* @param Array SessionData
|
|
* @return Boolean|\Module\Users\Cookie true on success, false on failure, \Module\Users\Cookie on success with cookie data
|
|
*/
|
|
public function propagate($sessionData) {
|
|
$prefix = $this->db->getPrefix();
|
|
// The variables to insert
|
|
$insert_array = array(
|
|
'hash' => $sessionData['hash'],
|
|
'user_id' => $sessionData['user_id'],
|
|
'info' => $sessionData['info'],
|
|
'ip' => $sessionData['ip'],
|
|
'session_start' => $sessionData['session_start']);
|
|
|
|
$query = "
|
|
INSERT INTO ".$prefix."user_sessions
|
|
(session_hash,session_user_id,session_info,session_ip,session_start)
|
|
VALUES (:hash, :user_id, :info, :ip, :session_start)
|
|
";
|
|
$stmnt = $this->db->prepare($query);
|
|
$stmnt->execute($insert_array);
|
|
if ($stmnt->rowCount() == 1) {
|
|
// Set the cookie
|
|
$cookie = new Cookie($this->cfg->cookie_name, $sessionData['hash'], $sessionData['valid_time'], '/', Config::get('main')->SITE_DOMAIN);
|
|
if ($this->setCookies)
|
|
$cookie->place();
|
|
else
|
|
return $cookie;
|
|
return true;
|
|
} else {
|
|
throw new SessionException("Could not log user in. Database error", 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sign a user out of the system
|
|
*
|
|
* @access public
|
|
* @param String SessionKey (optional)
|
|
* @param Boolean Propagate the logout to the database (default true)
|
|
* @return Boolean|\Module\Users\Cookie true on success, false on deny, \Moule\Users\Cookie on success without sending the cookie
|
|
* @throws SessionException on fatal error
|
|
*/
|
|
public function logout($sessionKey = null, $propagate = true) {
|
|
// Fetch the sessionKey, if it exists
|
|
$sessionKey = (isset($_COOKIE[$this->cfg->cookie_name]) ? $_COOKIE[$this->cfg->cookie_name] : (isset($_REQUEST['sessionKey']) ? $_REQUEST['sessionKey'] : $sessionKey ));
|
|
|
|
// If a sessionKey is given, check it
|
|
if (!is_null($sessionKey)) {
|
|
// Fetch the session data
|
|
$data = $this->sessionIsValid($sessionKey, true);
|
|
if ($data !== false) {
|
|
$username = $data[0]['user_username'];
|
|
$email = $data[0]['user_email'];
|
|
$user_id = $data[0]['user_id'];
|
|
|
|
// Then fire the event
|
|
$event = Events::fireEvent(new SessionLogoutEvent(), $user_id, $username, $email);
|
|
if ($event->isCancelled()) {
|
|
return false;
|
|
}
|
|
|
|
// If valid, remove the current session
|
|
$this->udt = null;
|
|
if ($propagate) {
|
|
// If set to propagete, edit the entry in the database
|
|
$prefix = $this->db->getPrefix();
|
|
$query = "UPDATE ".$prefix."user_sessions SET session_active = 0 WHERE session_hash = ?";
|
|
$stmnt = $this->db->prepare($query);
|
|
$stmnt->execute(array($sessionKey));
|
|
|
|
// And after that remove the cookie
|
|
if ($stmnt->rowCount() == 1) {
|
|
// Set the cookie
|
|
$cookie = new Cookie($this->cfg->cookie_name, $sessionKey, date('U') - 3600, '/', Config::get('main')->SITE_DOMAIN);
|
|
if ($this->setCookies) {
|
|
$cookie->place();
|
|
} else {
|
|
return $cookie;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
throw new SessionException("Could not log user out. Database error", 1);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
throw new SessionException("Could not log user out. SessionKey not found", 1);
|
|
}
|
|
|
|
/**
|
|
* Register a new User. Features input handling
|
|
* @access public
|
|
* @param String Username. Username of the new user
|
|
* @param String email. Email of the new user
|
|
* @param String password. Password of the new user
|
|
* @return Boolean true on success
|
|
* @throws SessionException on fatal error
|
|
*/
|
|
public function register($username, $email, $password) {
|
|
// First match if the username and email are valid
|
|
|
|
$errors = [];
|
|
// Email
|
|
if (!preg_match('/^[^\W][a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)*\@[a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)*\.[a-zA-Z]{2,4}$/',$email)) {
|
|
// Invalid
|
|
$errors[] = 'Invalid Email';
|
|
}
|
|
|
|
// Username
|
|
if (!preg_match('/^(?=.{1,15}$)[a-zA-Z][a-zA-Z0-9]*(?: [a-zA-Z0-9]+)*$/', $username)) {
|
|
// Invalid
|
|
$errors[] = "Invalid Username";
|
|
}
|
|
|
|
// And finally parse the error if there are errors present
|
|
if (!empty($errors)) {
|
|
throw new SessionException("Could not register user. " . implode(' .', $errors), 1);
|
|
}
|
|
|
|
// Fire the event
|
|
$event = Events::fireEvent(new SessionRegisterEvent(), $username, $email, $password);
|
|
if ($event->isCancelled()) {
|
|
return false;
|
|
}
|
|
|
|
// And perform the handling
|
|
try {
|
|
return $this->createUser($event->username, $event->email, $event->password, true);
|
|
} catch (SessionException $e) {
|
|
throw new SessionException("Could not register user. '" . $e->getMessage() . "'", 1, $e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a new User
|
|
* @access public
|
|
* @param String username
|
|
* @param String email
|
|
* @param String password
|
|
* @param Boolean Send Email of registration (default false)
|
|
* @throws SessionException on fatal error
|
|
* @return Boolean true on success
|
|
*/
|
|
public function createUser($username, $email, $password, $send_email = false) {
|
|
// Prepare the variables
|
|
$password = password_hash($password, PASSWORD_DEFAULT);
|
|
|
|
// Check for the existence of an account
|
|
$qry = "SELECT * FROM hi_user_users WHERE user_username = :username OR user_email = :email";
|
|
$stmnt = Modules::get('core/database')->prepare($qry);
|
|
$stmnt->execute(['username' => $username, 'email' => $email]);
|
|
$data = $stmnt->fetch(\PDO::FETCH_ASSOC);
|
|
if (empty($data)) {
|
|
// And put the data into the database
|
|
$prefix = $this->db->getPrefix();
|
|
$qry1 = "INSERT INTO ".$prefix."user_users (user_username,user_password,user_email,user_verify_code) VALUES (:username,:password,:email,:user_verify_code)";
|
|
$qry2 = "INSERT INTO ".$prefix."user_permissions (permission_tag_id,permission_user_id) VALUES (:tag_id,:user_id)";
|
|
|
|
Modules::get('core/database')->beginTransaction();
|
|
$stmnt1 = Modules::get('core/database')->prepare($qry1);
|
|
$stmnt2 = Modules::get('core/database')->prepare($qry2);
|
|
|
|
$stmnt1->execute(['username' => $username, 'password' => $password, 'email' => $email, 'user_verify_code' => substr(sha1(uniqid()), 0, 15)]);
|
|
$id = Modules::get('core/database')->lastInsertId();
|
|
$stmnt2->execute(['tag_id' => 1, 'user_id' => $id]);
|
|
|
|
// And then fire the event
|
|
$event = Events::fireEvent(new SessionUserCreateEvent(), $id, $username, $password);
|
|
if ($event->isCancelled()) {
|
|
Modules::get('core/database')->rollBack();
|
|
return false;
|
|
}
|
|
|
|
Modules::get('core/database')->commit();
|
|
|
|
// After that send a registration mail
|
|
if ($send_email) {
|
|
$this->registerMail($id);
|
|
}
|
|
|
|
return true;
|
|
} else {
|
|
throw new SessionException("Could not create user. Username or email already exists", 1);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sends a mail to a user when a registration happens
|
|
* @access private
|
|
* @param Int UserID
|
|
* @param Boolean Verify. Wether the user needs to verify using the email (default false)
|
|
* @throws SessionException on fatal error
|
|
*/
|
|
public function registerMail($userId, $verify = false) {
|
|
$udt = $this->getUsersByIds(intval($userId));
|
|
if (empty($udt)) {
|
|
throw new SessionException("Could not send mail. User not found", 1);
|
|
}
|
|
$udt = $udt[0];
|
|
|
|
// Load the mailer module
|
|
$mailer = Modules::get('core/mailer')->mailer;
|
|
$mailer->setFrom('no-reply@'.Config::get('main')->SITE_DOMAIN, 'Auth Service');
|
|
|
|
// First prepare the layout manager
|
|
Layout::setEngine('PHP');
|
|
|
|
// Assign all variables
|
|
$verifyCode = $udt['user_verify_code'];
|
|
if (empty($this->cfg->verify_controller) && $verify) {
|
|
throw new SessionException("Could not send mail. No verification controller set. Please set one in the sessions config.", 1);
|
|
}
|
|
$verifyURL = Config::get('main')->SITE_URL . "/" . $this->cfg->verify_controller . "?verify&code=".$verifyCode;
|
|
|
|
$event = Events::fireEvent(new SessionRegisterMailEvent(), $udt, $verifyCode, $verifyURL);
|
|
if ($event->isCancelled()) {
|
|
Logger::log("Sending of Registration Mail has been cancelled");
|
|
return false;
|
|
}
|
|
|
|
// Retrieve some variables
|
|
$udt = $event->udt;
|
|
|
|
// Assign new variables
|
|
Layout::assign('username', $udt['user_username']);
|
|
Layout::assign('email', $udt['user_email'] );
|
|
|
|
// More if there is a need to verify
|
|
if ($verify) {
|
|
Layout::assign('verifyURL', $event->verifyURL);
|
|
}
|
|
|
|
// Check if a custom HTML should be used
|
|
if ($event->customHtml) {
|
|
$html = $event->html;
|
|
} else {
|
|
// Or retrieve it from a layout file
|
|
$html = Layout::get('email_layout', $this->getModulePath() . "/Views/" );
|
|
}
|
|
|
|
// And finally send it
|
|
$mailer->addAddress($udt['email']);
|
|
$mailer->isHTML(true);
|
|
$mailer->Body = $html;
|
|
$mailer->Subject = Config::get('main')->SERVER_NAME . " | Registration";
|
|
$mailer->send();
|
|
if (!empty($mailer->ErrorInfo)) {
|
|
// Throw Exception if something goes wrong
|
|
throw new SessionException("Could not send mail. PHPMailer Error", 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Modifies a user entry
|
|
* @access public
|
|
* @param Int UserID to edit
|
|
* @param String column to edit
|
|
* @param Mixed value to apply
|
|
* @return true on success or false on deny
|
|
* @throws \Exception|SessionException on fatal error
|
|
*/
|
|
public function modifyUser($userId, $key, $value) {
|
|
// Fetch user data
|
|
$udt = $this->getUsersByIds($userId)[0];
|
|
|
|
// Check if key exists
|
|
if (isset($udt[$key])) {
|
|
$from = $udt[$key];
|
|
|
|
// Then fire the event
|
|
$event = Events::fireEvent(new SessionUserModifyEvent(), $userId, $key, $value, $from);
|
|
if ($event->isCancelled()) {
|
|
return false;
|
|
}
|
|
|
|
// And fetch tag information
|
|
$prefix = $this->db->getPrefix();
|
|
$stmnt = Modules::get('core/database')->prepare("UPDATE ".$prefix."user_users SET $key = ?");
|
|
$stmnt->execute([$value]);
|
|
if ($stmnt->rowCount() == 1) {
|
|
return true;
|
|
}
|
|
|
|
throw new SessionException("Could not modify user. Database error", 1);
|
|
}
|
|
|
|
throw new SessionException("Could not modify user. Key does not exist", 1);
|
|
}
|
|
|
|
/**
|
|
* Changes the password of a user
|
|
* @access public
|
|
* @param Int UserID to edit
|
|
* @param String|null Old password of the user or nothing if trying to change as admin
|
|
* @param String New password of the user
|
|
* @return true on success
|
|
* @throws \Exception|SessionException on fatal error
|
|
*/
|
|
public function changePassword($userId, $oldPassword = null, $newPassword) {
|
|
$udt = $this->getUsersByIds($userId)[0];
|
|
// First check if the oldPassword is correct
|
|
if (is_null($oldPassword) || password_verify($oldPassword, $udt['user_password'])) {
|
|
// Send out the event
|
|
$event = Events::fireEvent(new SessionChangePasswordEvent(),
|
|
$userId,
|
|
$udt['user_username'],
|
|
$oldPassword,
|
|
$newPassword
|
|
);
|
|
|
|
// Stop if cancelled
|
|
if ($event->isCancelled()) {
|
|
return false;
|
|
}
|
|
|
|
// Then apply the new password
|
|
$hash = password_hash($event->newPassword, PASSWORD_DEFAULT);
|
|
$this->modifyUser($userId, 'user_password', $hash);
|
|
return true;
|
|
}
|
|
|
|
throw new SessionException("Could not change password. Old password did not match", 1);
|
|
}
|
|
|
|
/**
|
|
* Suspends a user from using the system
|
|
* @access public
|
|
* @param Int UserID
|
|
* @return true on success
|
|
* @throws SessionException on fatal error
|
|
*/
|
|
public function suspendUser($userId) {
|
|
// First get all the relevant data
|
|
$udt = $this->getUsersByIds($userId)[0];
|
|
$user_id = $udt['user_id'];
|
|
$username = $udt['user_username'];
|
|
$email = $udt['user_email'];
|
|
|
|
// Then fire the event
|
|
$event = Events::fireEvent(new SessionUserSuspendEvent(), $user_id, $username, $email);
|
|
|
|
// Cancel if denied by module
|
|
if ($event->isCancelled()) {
|
|
return false;
|
|
}
|
|
|
|
return $this->addPermission('BLOCKED', $userId, false);
|
|
}
|
|
|
|
/**
|
|
* Allows a user to log in again
|
|
* @access public
|
|
* @param Int UserID
|
|
* @return true on success
|
|
* @throws SessionException on fatal error
|
|
*/
|
|
public function unsuspendUser($userId) {
|
|
// First get all the relevant data
|
|
$udt = $this->getUsersByIds($userId)[0];
|
|
$user_id = $udt['user_id'];
|
|
$username = $udt['user_username'];
|
|
$email = $udt['user_email'];
|
|
|
|
// Then fire the event
|
|
$event = Events::fireEvent(new SessionUserUnsuspendEvent(), $user_id, $username, $email);
|
|
|
|
// Cancel if denied by module
|
|
if ($event->isCancelled()) {
|
|
return false;
|
|
}
|
|
|
|
return $this->removePermission('BLOCKED', $userId, false);
|
|
}
|
|
|
|
/**
|
|
* Removes a user from the system
|
|
* @access public
|
|
* @param Int UserID
|
|
* @return true on success
|
|
* @throws SessionException on fatal error
|
|
*/
|
|
public function removeUser($userId) {
|
|
// First get all relevant data
|
|
$udt = $this->getUsersByIds($userId)[0];
|
|
$userId = $udt['user_id'];
|
|
$username = $udt['user_username'];
|
|
$email = $udt['user_email'];
|
|
|
|
// Then fire an event
|
|
$event = Events::fireEvent(new SessionUserRemoveEvent(), $userId, $username, $email);
|
|
if ($event->isCancelled()) {
|
|
return false;
|
|
}
|
|
|
|
// Remove the active permission, effectively removing the user
|
|
return $this->removePermission('ACTIVE', $userId, false, true);
|
|
}
|
|
|
|
/**
|
|
* Verify a user with a code to we can unsuspend them
|
|
* @access public
|
|
* @param String VerifyCode
|
|
* @return true on success
|
|
* @throws SessionException on fatal error
|
|
*/
|
|
public function verifyUser($verifyCode) {
|
|
// And fetch tag information
|
|
$prefix = $this->db->getPrefix();
|
|
$stmnt = Modules::get('core/database')->prepare("SELECT * FROM ".$prefix."user_users WHERE user_verify_code = ?");
|
|
$stmnt->execute([$verifyCode]);
|
|
$data = $stmnt->fetchAll(\PDO::FETCH_ASSOC);
|
|
if (count($data == 1)) {
|
|
$id = $data[0]['user_id'];
|
|
return $this->unsuspendUser($id);
|
|
} else {
|
|
throw new SessionException("Could not verify user. Code invalid", 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify if a password matches the user
|
|
* @param Int $userId User ID of the user
|
|
* @param String $password Password of the user
|
|
* @return true on valid, false on invalid
|
|
*/
|
|
public function verifyPassword($userId, $password) {
|
|
$prefix = $this->db->getPrefix();
|
|
$stmnt = Modules::get('core/database')->prepare("SELECT * FROM ".$prefix."user_users WHERE user_id = ?");
|
|
$stmnt->execute([$userId]);
|
|
$data = $stmnt->fetchAll(\PDO::FETCH_ASSOC);
|
|
if (!empty($data)) {
|
|
return password_verify($password, $data[0]['user_password']);
|
|
} else {
|
|
throw new SessionException("Could not verify password. User not found", 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks wether a user has permission to a certain action
|
|
* If a userID is provided, a specific user is checked. Otherwise the current session is used
|
|
* @access public
|
|
* @param String PermissionTag
|
|
* @param Int UserID (optional)
|
|
* @param Boolean Wether to ignore admin permission (default false)
|
|
* @throws SessionException on fatal error
|
|
* @return Boolean true on permission. False on no permission
|
|
*/
|
|
public function hasPermission($permissionTag, $userId = null, $ignoreAdmin = false) {
|
|
// First retrieve the UDT
|
|
if (is_null($userId)) {
|
|
if (!is_null($this->udt)) {
|
|
$udt = $this->udt;
|
|
} else {
|
|
throw new SessionException("Could not check for permission. No user logged in and no user provided", 1);
|
|
}
|
|
} else {
|
|
$udt = $this->getUsersByIds($userId);
|
|
if (!empty($udt)) {
|
|
$udt = $udt[0];
|
|
} else {
|
|
throw new SessionException("Could not check for permission. User not found", 1);
|
|
}
|
|
}
|
|
|
|
// Then read it and check for permission
|
|
$tag = strtoupper($permissionTag);
|
|
|
|
// What type to return if ignoring admin
|
|
if ($ignoreAdmin) {
|
|
if (isset($udt['permissions'][$tag])) {
|
|
return true;
|
|
}
|
|
} else {
|
|
if (isset($udt['permissions'][$tag]) || isset($udt['permissions']['ADMIN'])) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Removes a permission from a user
|
|
* If a userID is provided, a specific user is checked. Otherwise the current session is used
|
|
* @access public
|
|
* @param String PermissionTag
|
|
* @param Int UserID (optional)
|
|
* @param Boolean Wether to remove the tag if it is not used anymore
|
|
* @param Boolean wether to ignore the ACTIVE tag. Seriously, do not touch this
|
|
* @throws SessionException on fatal error
|
|
* @return Boolean true on success
|
|
*/
|
|
public function removePermission($permissionTag, $userId = null, $removeTag = false, $ignoreActive = false) {
|
|
// Check if the active tag is given
|
|
if (!$ignoreActive && strtoupper($permissionTag) == 'ACTIVE') {
|
|
throw new SessionException("Could not remove permission. ACTIVE tag removal is prohibited", 1);
|
|
}
|
|
|
|
// First retrieve the UDT
|
|
if (!$this->hasPermission($permissionTag, $userId, true)) {
|
|
throw new SessionException("Could not remove permission. User does not have permission", 1);
|
|
}
|
|
|
|
// Fetch the user ID
|
|
if (is_null($userId)) {
|
|
$user_id = $this->udt['user_id'];
|
|
} else {
|
|
$udt = $this->getUsersByIds($userId);
|
|
if (!empty($udt)) {
|
|
$udt = $udt[0];
|
|
$user_id = $udt['user_id'];
|
|
}
|
|
}
|
|
|
|
// And fetch tag information
|
|
$prefix = $this->db->getPrefix();
|
|
$stmnt = Modules::get('core/database')->prepare("SELECT * FROM ".$prefix."user_tags WHERE tag_name = ?");
|
|
$stmnt->execute([strtoupper($permissionTag)]);
|
|
$tag = $stmnt->fetch(\PDO::FETCH_ASSOC);
|
|
if (!empty($tag)) {
|
|
$tag_id = intval($tag['tag_id']);
|
|
}
|
|
|
|
// And now remove the reference in the database
|
|
$stmnt = Modules::get('core/database')->prepare("DELETE FROM ".$prefix."user_permissions WHERE permission_tag_id = :tag_id AND permission_user_id = :user_id");
|
|
$stmnt->execute(['tag_id' => $tag_id, 'user_id' => $user_id]);
|
|
if ($stmnt->rowCount() == 1) {
|
|
// Check if the tag is still used
|
|
if ($removeTag) {
|
|
$stmnt = Modules::get('core/database')->prepare("SELECT * FROM ".$prefix."user_permissions WHERE permission_tag_id = ?");
|
|
$stmnt->execute([strtoupper($permissionTag)]);
|
|
if (count($stmnt->fetchAll(\PDO::FETCH_ASSOC)) == 0) {
|
|
// Remove the tag
|
|
$stmnt = Modules::get('core/database')->prepare("DELETE FROM ".$prefix."user_tags WHERE tag_name = ?");
|
|
$stmnt->execute([strtoupper($permissionTag)]);
|
|
if ($stmnt->rowCount() == 0) {
|
|
// Something went wrong
|
|
throw new SessionException("Could not remove permission tag. Database error", 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
throw new SessionException("Could not remove permission. Database error", 1);
|
|
}
|
|
|
|
/**
|
|
* Adds a permission to a user
|
|
* If a userID is provided, a specific user is checked. Otherwise the current session is used
|
|
* @access public
|
|
* @param String PermissionTag
|
|
* @param Int UserID (optional)
|
|
* @throws SessionException on fatal error
|
|
* @return Boolean true on success
|
|
*/
|
|
public function addPermission($permissionTag, $userId = null) {
|
|
// First retrieve the UDT
|
|
if ($this->hasPermission($permissionTag, $userId, true)) {
|
|
throw new SessionException("Could not add permission. User does already have permission", 1);
|
|
}
|
|
|
|
// Fetch the user ID
|
|
if (is_null($userId)) {
|
|
$user_id = $this->udt['user_id'];
|
|
} else {
|
|
$udt = $this->getUsersByIds($userId);
|
|
if (!empty($udt)) {
|
|
$udt = $udt[0];
|
|
$user_id = $udt['user_id'];
|
|
}
|
|
}
|
|
|
|
// Check if the tag already exists
|
|
$prefix = $this->db->getPrefix();
|
|
$stmnt = Modules::get('core/database')->prepare("SELECT * FROM ".$prefix."user_tags WHERE tag_name = ?");
|
|
$stmnt->execute([strtoupper($permissionTag)]);
|
|
$d = $stmnt->fetchAll(\PDO::FETCH_ASSOC);
|
|
|
|
if (count($d) == 0) {
|
|
// Create tag
|
|
$stmnt = Modules::get('core/database')->prepare("INSERT INTO ".$prefix."user_tags (tag_name) VALUES (:tag_name)");
|
|
$stmnt->execute(['tag_name' => strtoupper($permissionTag)]);
|
|
$id = $stmnt->lastInsertId();
|
|
} elseif (count($d) == 1) {
|
|
// Get ID
|
|
$data = $d[0];
|
|
$id = $data['tag_id'];
|
|
}
|
|
|
|
// Add the permission
|
|
$stmnt = Modules::get('core/database')->prepare("INSERT INTO ".$prefix."user_permissions (permission_tag_id,permission_user_id) VALUES (:permission_tag_id,:permission_user_id)");
|
|
$stmnt->execute(['permission_tag_id' => $id, 'permission_user_id' => $user_id]);
|
|
|
|
if ($stmnt->rowCount() == 1) {
|
|
return true;
|
|
}
|
|
|
|
throw new SessionException("Could not add permission. Database Error", 1);
|
|
}
|
|
|
|
/**
|
|
* Get users by Usernames
|
|
* @access public
|
|
* @param Array of usernames
|
|
* @return Array of UDT's
|
|
*/
|
|
public function getUsersByName($usernames = array()) {
|
|
if (is_string($usernames)) {
|
|
$usernames = array($usernames);
|
|
}
|
|
$prefix = $this->db->getPrefix();
|
|
$query = "
|
|
SELECT *
|
|
FROM ".$prefix."user_permissions AS permissions
|
|
|
|
LEFT JOIN ".$prefix."user_users AS users
|
|
ON permissions.permission_user_id=users.user_id
|
|
|
|
LEFT JOIN ".$prefix."user_tags AS tags
|
|
ON permissions.permission_tag_id=tags.tag_id
|
|
|
|
WHERE users.user_username = ?
|
|
";
|
|
$stmnt = Modules::get('core/database')->prepare($query);
|
|
$users = array();
|
|
for ($i=0; $i < count($usernames); $i++) {
|
|
$username = $usernames[$i];
|
|
$stmnt->execute(array($username));
|
|
$user_data = $stmnt->fetchAll(\PDO::FETCH_ASSOC);
|
|
if (!empty($user_data)) {
|
|
$users[] = $this->handleUserSelectData($user_data);
|
|
}
|
|
}
|
|
return $users;
|
|
}
|
|
|
|
/**
|
|
* Get users by Identifier
|
|
* @access public
|
|
* @param Array of user ids OR Int of single ID
|
|
* @return Array of UDT's
|
|
*/
|
|
public function getUsersByIds($ids = array()) {
|
|
if (is_int($ids)) {
|
|
$ids = array($ids);
|
|
}
|
|
|
|
$prefix = $this->db->getPrefix();
|
|
$query = "
|
|
SELECT *
|
|
FROM ".$prefix."user_permissions AS permissions
|
|
|
|
LEFT JOIN ".$prefix."user_users AS users
|
|
ON permissions.permission_user_id=users.user_id
|
|
|
|
LEFT JOIN ".$prefix."user_tags AS tags
|
|
ON permissions.permission_tag_id=tags.tag_id
|
|
|
|
WHERE users.user_id = ?
|
|
";
|
|
$stmnt = Modules::get('core/database')->prepare($query);
|
|
$users = array();
|
|
for ($i=0; $i < count($ids); $i++) {
|
|
$id = $ids[$i];
|
|
$stmnt->execute(array($id));
|
|
$user_data = $stmnt->fetchAll(\PDO::FETCH_ASSOC);
|
|
if (!empty($user_data)) {
|
|
$users[] = $this->handleUserSelectData($user_data);
|
|
}
|
|
}
|
|
|
|
return $users;
|
|
}
|
|
|
|
/**
|
|
* Get users by their sessionKey
|
|
* @param array $sessionKeys Sessionkeys of the users
|
|
* @return array of UDT's
|
|
*/
|
|
public function getUsersBySessionKeys($sessionKeys = array()) {
|
|
if (is_string($sessionKeys)) {
|
|
$sessionKeys = array($sessionKeys);
|
|
}
|
|
|
|
$prefix = $this->db->getPrefix();
|
|
$query = "SELECT DISTINCT users.user_id
|
|
FROM ".$prefix."user_sessions AS sessions
|
|
|
|
LEFT JOIN ".$prefix."user_users AS users
|
|
ON sessions.session_user_id=users.user_id
|
|
|
|
WHERE sessions.session_hash = ?
|
|
";
|
|
|
|
$stmnt = $this->db->prepare($query);
|
|
|
|
$ids = array();
|
|
foreach ($sessionKeys as $hash) {
|
|
$stmnt->execute(array($hash));
|
|
$data = $stmnt->fetch(\PDO::FETCH_ASSOC);
|
|
if (!empty($data)) {
|
|
$ids[] = $data['user_id'];
|
|
}
|
|
}
|
|
|
|
// And afterwards retrieve the UDT's by parsing this result
|
|
return $this->getUsersByIds($ids);
|
|
}
|
|
|
|
/**
|
|
* Get users by Email address
|
|
* @access public
|
|
* @param Array of emails
|
|
* @return Array of UDT's
|
|
*/
|
|
public function getUsersByEmails($emails = array()) {
|
|
if (is_string($emails)) {
|
|
$emails = array($emails);
|
|
}
|
|
|
|
// First we will retrieve all the ids, and afterwards we will retrieve the user using these ids
|
|
$prefix = $this->db->getPrefix();
|
|
$query = "SELECT DISTINCT users.user_id
|
|
FROM ".$prefix."user_emails AS emails
|
|
|
|
LEFT JOIN ".$prefix."user_users AS users
|
|
ON emails.email_user_id=users.user_id";
|
|
|
|
$ids = Modules::get('core/database')->prepare($query);
|
|
foreach ($emails as $email) {
|
|
|
|
}
|
|
|
|
|
|
$query = "
|
|
SELECT *
|
|
FROM ".$prefix."user_permissions AS permissions
|
|
|
|
LEFT JOIN ".$prefix."user_users AS users
|
|
ON permissions.permission_user_id=users.user_id
|
|
|
|
LEFT JOIN ".$prefix."user_tags AS tags
|
|
ON permissions.permission_tag_id=tags.tag_id
|
|
|
|
WHERE users.user_email = ?
|
|
";
|
|
$stmnt = Modules::get('core/database')->prepare($query);
|
|
$users = array();
|
|
for ($i=0; $i < count($emails); $i++) {
|
|
$email = $emails[$i];
|
|
$stmnt->execute(array($email));
|
|
$user_data = $stmnt->fetchAll(\PDO::FETCH_ASSOC);
|
|
if (!empty($user_data)) {
|
|
$users[] = $this->handleUserSelectData($user_data);
|
|
}
|
|
}
|
|
return $users;
|
|
}
|
|
|
|
/**
|
|
* Get all users who have a specific permission tag
|
|
* @access public
|
|
* @param String Permission Tag
|
|
* @return Array of UDT's
|
|
*/
|
|
public function getUsersByPermissions($permissionTags = array()) {
|
|
if (is_string($permissionTags)) {
|
|
$permissionTags = array($permissionTags);
|
|
}
|
|
$prefix = $this->db->getPrefix();
|
|
$query = "
|
|
SELECT *
|
|
FROM ".$prefix."user_permissions AS permissions
|
|
|
|
LEFT JOIN ".$prefix."user_users AS users
|
|
ON permissions.permission_user_id=users.user_id
|
|
|
|
LEFT JOIN ".$prefix."user_tags AS tags
|
|
ON permissions.permission_tag_id=tags.tag_id
|
|
|
|
WHERE tags.tag_name = ?
|
|
";
|
|
$stmnt = Modules::get('core/database')->prepare($query);
|
|
$users = array();
|
|
for ($i=0; $i < count($permissionTags); $i++) {
|
|
$tag = $permissionTags[$i];
|
|
$stmnt->execute(array($tag));
|
|
|
|
$user_data = $stmnt->fetchAll(\PDO::FETCH_ASSOC);
|
|
if (!empty($user_data)) {
|
|
$users[] = $this->getUsersByIds(array($user_data[0]['user_id']))[0];
|
|
}
|
|
}
|
|
return $users;
|
|
}
|
|
|
|
/**
|
|
* Internal function used by the getUsersby* functions
|
|
* @access private
|
|
* @param Array PDO Data result
|
|
* @return UDT
|
|
*/
|
|
private function handleUserSelectData($user_data) {
|
|
$user = array();
|
|
$basic = $user_data[0];
|
|
foreach ($basic as $key => $value) {
|
|
if (strpos($key, 'user_') === 0) {
|
|
$user[$key] = $value;
|
|
}
|
|
}
|
|
$user['permissions'] = array();
|
|
|
|
for ($j=0; $j < count($user_data); $j++) {
|
|
$user['permissions'][ $user_data[$j]['tag_name'] ] = $user_data[$j]['tag_name'];
|
|
}
|
|
$user['username'] = $user['user_username'];
|
|
$user['email'] = $user['user_email'];
|
|
return $user;
|
|
}
|
|
|
|
/**
|
|
* Fetch data from the current UDT
|
|
* @access public
|
|
* @param Mixed Key
|
|
* @return Mixed Value
|
|
*/
|
|
public function __get($key) {
|
|
return $this->udt->$key;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Exception class for the Sessions Module
|
|
* @package net.techfuze.fuzeworks.sessions
|
|
* @author Abel Hoogeveen <abel@techfuze.net>
|
|
* @copyright Copyright (c) 2013 - 2015, Techfuze. (http://techfuze.net)
|
|
*/
|
|
class SessionException extends \Exception {}
|
|
|
|
?>
|