Management - Code Metrics - Inspection of "Removed bots support." - nazar-pc/CleverStyle-Framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c7c099...bc3d45 )

by Nazar

created 2016-03-27 13:37 UTC

Management C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	452
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
wmc	65
c	2
b	0
f	0
lcom	1
cbo	8
dl	0
loc	452
rs	5.7894

21 Methods

Rating	Name	Size	Complexity
A	init_session()	10	2
B	update_user_is()	18	5
A	admin()	3	1
A	user()	3	1
A	guest()	3	1
A	get_id()	3	2
A	get_user()	3	1
A	get()	5	1
C	get_internal()	23	8
A	is_good_session()	6	3
A	is_session_owner()	4	2
B	is_session_owner_internal()	20	7
B	load()	25	4
A	load_initialization()	6	1
B	is_user_active()	44	5
B	add()	32	6
B	create_unique_session()	28	3
A	del()	3	1
B	del_internal()	28	5
A	delete_old_sessions()	6	1
B	del_all()	23	5

How to fix Complexity

<?php
/**
 * @package   CleverStyle CMS
 * @author    Nazar Mokrynskyi <[email protected]>
 * @copyright Copyright (c) 2011-2016, Nazar Mokrynskyi
 * @license   MIT License, see license.txt
 */
namespace cs\Session;
use
	cs\Language\Prefix as Language_prefix,
	cs\Config,
	cs\Event,
	cs\Page,
	cs\Request,
	cs\Response,
	cs\User;

/**
 * @method \cs\DB\_Abstract db()
 * @method \cs\DB\_Abstract db_prime()
 */
trait Management {
	/**
	 * Id of current session
	 *
	 * @var false|string
	 */
	protected $session_id;
	/**
	 * User id of current session
	 *
	 * @var int
	 */
	protected $user_id;
	/**
	 * @var bool
	 */
	protected $is_admin;
	/**
	 * @var bool
	 */
	protected $is_user;
	/**
	 * @var bool
	 */
	protected $is_guest;
	/**
	 * Use cookie as source of session id, load session
	 */
	protected function init_session () {
		$Request = Request::instance();
		/**
		 * If session exists
		 */
		if ($Request->cookie('session')) {
			$this->user_id = $this->load();
		}
		$this->update_user_is();
	}
	/**
	 * Updates information about who is user accessed by methods ::guest() ::user() admin()
	 */
	protected function update_user_is () {
		$this->is_guest = $this->user_id == User::GUEST_ID;
		$this->is_user  = false;
		$this->is_admin = false;
		if ($this->is_guest) {
			return;
		}
		/**
		 * Checking of user type
		 */
		$groups = User::instance()->get_groups($this->user_id) ?: [];
		if (in_array(User::ADMIN_GROUP_ID, $groups)) {
			$this->is_admin = true;
			$this->is_user  = true;
		} elseif (in_array(User::USER_GROUP_ID, $groups)) {
			$this->is_user = true;
		}
	}
	/**
	 * Is admin
	 *
	 * @return bool
	 */
	function admin () {
		return $this->is_admin;
	}
	/**
	 * Is user
	 *
	 * @return bool
	 */
	function user () {
		return $this->is_user;
	}
	/**
	 * Is guest
	 *
	 * @return bool
	 */
	function guest () {
		return $this->is_guest;
	}
	/**
	 * Returns id of current session
	 *
	 * @return false|string
	 */
	function get_id () {
		return $this->session_id ?: false;
	}
	/**
	 * Returns user id of current session
	 *
	 * @return int
	 */
	function get_user () {
		return $this->user_id;
	}
	/**
	 * Returns session details by session id
	 *
	 * @param false|null|string $session_id If `null` - loaded from `$this->session_id`, and if that also empty - from cookies
	 *
	 * @return false|array
	 */
	function get ($session_id) {
		$session_data = $this->get_internal($session_id);
		unset($session_data['data']);
		return $session_data;
	}
	/**
	 * @param false|null|string $session_id
	 *
	 * @return false|array
	 */
	protected function get_internal ($session_id) {
		if (!$session_id) {
			if (!$this->session_id) {
				$this->session_id = Request::instance()->cookie('session');
			}
			$session_id = $this->session_id;
		}
		if (!is_md5($session_id)) {
			return false;
		}
		$data = $this->cache->get(
			$session_id,
			function () use ($session_id) {
				$data = $this->read($session_id);
				if (!$data || $data['expire'] <= time()) {
					return false;
				}
				$data['data'] = $data['data'] ?: [];
				return $data;
			}
		);
		return $this->is_good_session($data) ? $data : false;
	}
	/**
	 * Check whether session was not expired, user agent and IP corresponds to what is expected and user is actually active
	 *
	 * @param mixed $session_data
	 *
	 * @return bool
	 */
	protected function is_good_session ($session_data) {
		return
			isset($session_data['expire'], $session_data['user']) &&
			$session_data['expire'] > time() &&
			$this->is_user_active($session_data['user']);
	}
	/**
	 * Whether session data belongs to current visitor (user agent, remote addr and ip check)
	 *
	 * @param string $session_id
	 * @param string $user_agent
	 * @param string $remote_addr
	 * @param string $ip
	 *
	 * @return bool
	 */
	function is_session_owner ($session_id, $user_agent, $remote_addr, $ip) {
		$session_data = $this->get($session_id);
		return $session_data ? $this->is_session_owner_internal($session_data, $user_agent, $remote_addr, $ip) : false;
	}
	/**
	 * Whether session data belongs to current visitor (user agent, remote addr and ip check)
	 *
	 * @param array       $session_data
	 * @param string|null $user_agent
	 * @param string|null $remote_addr
	 * @param string|null $ip
	 *
	 * @return bool
	 */
	protected function is_session_owner_internal ($session_data, $user_agent = null, $remote_addr = null, $ip = null) {
		/**
		 * md5() as protection against timing attacks
		 */
		if ($user_agent === null && $remote_addr === null && $ip === null) {
			$Request     = Request::instance();
			$user_agent  = $Request->header('user-agent');
			$remote_addr = $Request->remote_addr;
			$ip          = $Request->ip;
		}
		return
			md5($session_data['user_agent']) == md5($user_agent) &&
			(
				!Config::instance()->core['remember_user_ip'] ||
				(
					md5($session_data['remote_addr']) == md5(ip2hex($remote_addr)) &&
					md5($session_data['ip']) == md5(ip2hex($ip))
				)
			);
	}
	/**
	 * Load session by id and return id of session owner (user), update session expiration
	 *
	 * @param false|null|string $session_id If not specified - loaded from `$this->session_id`, and if that also empty - from cookies
	 *
	 * @return int User id
	 */
	function load ($session_id = null) {
		$session_data = $this->get_internal($session_id);
		if (!$session_data || !$this->is_session_owner_internal($session_data)) {
			$this->add(User::GUEST_ID);
			return User::GUEST_ID;
		}
		/**
		 * Updating last online time and ip
		 */
		$Config = Config::instance();
		$time   = time();
		if ($session_data['expire'] - $time < $Config->core['session_expire'] * $Config->core['update_ratio'] / 100) {
			$session_data['expire'] = $time + $Config->core['session_expire'];
			$this->update($session_data);
			$this->cache->set($session_data['id'], $session_data);
		}
		unset($session_data['data']);
		Event::instance()->fire(
			'System/Session/load',
			[
				'session_data' => $session_data
			]
		);
		return $this->load_initialization($session_data['id'], $session_data['user']);
	}
	/**
	 * Initialize session (set user id, session id and update who user is)
	 *
	 * @param string $session_id
	 * @param int    $user_id
	 *
	 * @return int User id
	 */
	protected function load_initialization ($session_id, $user_id) {
		$this->session_id = $session_id;
		$this->user_id    = $user_id;
		$this->update_user_is();
		return $user_id;
	}
	/**
	 * Whether profile is activated, not disabled and not blocked
	 *
	 * @param int $user
	 *
	 * @return bool
	 */
	protected function is_user_active ($user) {
		/**
		 * Optimization, more data requested than actually used here, because data will be requested later, and it would be nice to have that data cached
		 */
		$data = User::instance()->get(
			[
				'login',
				'username',
				'language',
				'timezone',
				'status',
				'block_until',
				'avatar'
			],
			$user
		);
		if (!$data) {
			return false;
		}
		$L    = new Language_prefix('system_profile_sign_in_');
		$Page = Page::instance();
		switch ($data['status']) {
			case User::STATUS_INACTIVE:
				/**
				 * If user is disabled
				 */
				$Page->warning($L->your_account_disabled);
				return false;
			case User::STATUS_NOT_ACTIVATED:
				/**
				 * If user is not active
				 */
				$Page->warning($L->your_account_is_not_active);
				return false;
		}
		if ($data['block_until'] > time()) {
			/**
			 * If user if blocked
			 */
			$Page->warning($L->your_account_blocked_until(date($L->_datetime, $data['block_until'])));
			return false;
		}
		return true;
	}
	/**
	 * Create the session for the user with specified id
	 *
	 * @param int  $user
	 * @param bool $delete_current_session
	 *
	 * @return false|string Session id on success, `false` otherwise
	 */
	function add ($user, $delete_current_session = true) {
		$user = (int)$user;
		if (!$user) {
			return false;
		}
		if ($delete_current_session && is_md5($this->session_id)) {
			$this->del_internal($this->session_id, false);
		}
		if (!$this->is_user_active($user)) {
			/**
			 * If data was not loaded or account is not active - create guest session
			 */
			return $this->add(User::GUEST_ID);
		}
		$session_data = $this->create_unique_session($user);
		Response::instance()->cookie('session', $session_data['id'], $session_data['expire'], true);
		$this->load_initialization($session_data['id'], $session_data['user']);
		/**
		 * Delete old sessions using probability and system configuration of inserts limits and update ratio
		 */
		$Config = Config::instance();
		if (mt_rand(0, $Config->core['inserts_limit']) < $Config->core['inserts_limit'] / 100 * (100 - $Config->core['update_ratio']) / 5) {
			$this->delete_old_sessions();
		}
		Event::instance()->fire(
			'System/Session/add',
			[
				'session_data' => $session_data
			]
		);
		return $session_data['id'];
	}
	/**
	 * @param int $user
	 *
	 * @return array Session data
	 */
	protected function create_unique_session ($user) {
		$Config      = Config::instance();
		$Request     = Request::instance();
		$remote_addr = ip2hex($Request->remote_addr);
		$ip          = ip2hex($Request->ip);
		/**
		 * Many guests open only one page (or do not store any cookies), so create guest session only for 5 minutes max initially
		 */
		$expire_in = $user == User::GUEST_ID ? min($Config->core['session_expire'], self::INITIAL_SESSION_EXPIRATION) : $Config->core['session_expire'];
		$expire    = time() + $expire_in;
		/**
		 * Create unique session
		 */
		$session_data = [
			'id'          => null,
			'user'        => $user,
			'created'     => time(),
			'expire'      => $expire,
			'user_agent'  => $Request->header('user-agent'),
			'remote_addr' => $remote_addr,
			'ip'          => $ip,
			'data'        => []
		];
		do {
			$session_data['id'] = md5(random_bytes(1000));
		} while (!$this->create($session_data));
		return $session_data;
	}
	/**
	 * Destroying of the session
	 *
	 * @param null|string $session_id
	 *
	 * @return bool
	 */
	function del ($session_id = null) {
		return (bool)$this->del_internal($session_id);
	}
	/**
	 * Deletion of the session
	 *
	 * @param string|null $session_id
	 * @param bool        $create_guest_session
	 *
	 * @return bool
	 */
	protected function del_internal ($session_id = null, $create_guest_session = true) {
		$session_id = $session_id ?: $this->session_id;
		if (!is_md5($session_id)) {
			return false;
		}
		Event::instance()->fire(
			'System/Session/del/before',
			[
				'id' => $session_id
			]
		);
		unset($this->cache->$session_id);
		$this->session_id = false;
		Response::instance()->cookie('session', '');
		$result = $this->delete($session_id);
		if ($result) {
			if ($create_guest_session) {
				return (bool)$this->add(User::GUEST_ID);
			}
			Event::instance()->fire(
				'System/Session/del/after',
				[
					'id' => $session_id
				]
			);
		}
		return (bool)$result;
	}
	/**
	 * Delete all old sessions from DB
	 */
	protected function delete_old_sessions () {
		$this->db_prime()->aq(
			"DELETE FROM `[prefix]sessions`
			WHERE `expire` < ".time()
		);
	}
	/**
	 * Deletion of all user sessions
	 *
	 * @param false|int $user If not specified - current user assumed
	 *
	 * @return bool
	 */
	function del_all ($user = false) {
		$user = $user ?: $this->user_id;
		Event::instance()->fire(
			'System/Session/del_all',
			[
				'id' => $user
			]
		);
		$sessions = $this->db_prime()->qfas(
			"SELECT `id`
			FROM `[prefix]sessions`
			WHERE `user` = '$user'"
		);
		if (is_array($sessions)) {
			if (!$this->delete($sessions)) {
				return false;
			}
			foreach ($sessions as $session) {
				unset($this->cache->$session);
			}
		}
		return true;
	}
}


1			<?php
2			/**
3			* @package CleverStyle CMS
4			* @author Nazar Mokrynskyi <[email protected]>
5			* @copyright Copyright (c) 2011-2016, Nazar Mokrynskyi
6			* @license MIT License, see license.txt
7			*/
8			namespace cs\Session;
9			use
10			cs\Language\Prefix as Language_prefix,
11			cs\Config,
12			cs\Event,
13			cs\Page,
14			cs\Request,
15			cs\Response,
16			cs\User;
17
18			/**
19			* @method \cs\DB\_Abstract db()
20			* @method \cs\DB\_Abstract db_prime()
21			*/
22			trait Management {
23			/**
24			* Id of current session
25			*
26			* @var false\|string
27			*/
28			protected $session_id;
29			/**
30			* User id of current session
31			*
32			* @var int
33			*/
34			protected $user_id;
35			/**
36			* @var bool
37			*/
38			protected $is_admin;
39			/**
40			* @var bool
41			*/
42			protected $is_user;
43			/**
44			* @var bool
45			*/
46			protected $is_guest;
47			/**
48			* Use cookie as source of session id, load session
49			*/
50			protected function init_session () {
51			$Request = Request::instance();
52			/**
53			* If session exists
54			*/
55			if ($Request->cookie('session')) {
56			$this->user_id = $this->load();
57			}
58			$this->update_user_is();
59			}
60			/**
61			* Updates information about who is user accessed by methods ::guest() ::user() admin()
62			*/
63			protected function update_user_is () {
64			$this->is_guest = $this->user_id == User::GUEST_ID;
65			$this->is_user = false;
66			$this->is_admin = false;
67			if ($this->is_guest) {
68			return;
69			}
70			/**
71			* Checking of user type
72			*/
73			$groups = User::instance()->get_groups($this->user_id) ?: [];
74			if (in_array(User::ADMIN_GROUP_ID, $groups)) {
75			$this->is_admin = true;
76			$this->is_user = true;
77			} elseif (in_array(User::USER_GROUP_ID, $groups)) {
78			$this->is_user = true;
79			}
80			}
81			/**
82			* Is admin
83			*
84			* @return bool
85			*/
86			function admin () {
87			return $this->is_admin;
88			}
89			/**
90			* Is user
91			*
92			* @return bool
93			*/
94			function user () {
95			return $this->is_user;
96			}
97			/**
98			* Is guest
99			*
100			* @return bool
101			*/
102			function guest () {
103			return $this->is_guest;
104			}
105			/**
106			* Returns id of current session
107			*
108			* @return false\|string
109			*/
110			function get_id () {
111			return $this->session_id ?: false;
112			}
113			/**
114			* Returns user id of current session
115			*
116			* @return int
117			*/
118			function get_user () {
119			return $this->user_id;
120			}
121			/**
122			* Returns session details by session id
123			*
124			* @param false\|null\|string $session_id If `null` - loaded from `$this->session_id`, and if that also empty - from cookies
125			*
126			* @return false\|array
127			*/
128			function get ($session_id) {
129			$session_data = $this->get_internal($session_id);
130			unset($session_data['data']);
131			return $session_data;
132			}
133			/**
134			* @param false\|null\|string $session_id
135			*
136			* @return false\|array
137			*/
138			protected function get_internal ($session_id) {
139			if (!$session_id) {
140			if (!$this->session_id) {
141			$this->session_id = Request::instance()->cookie('session');
142			}
143			$session_id = $this->session_id;
144			}
145			if (!is_md5($session_id)) {
146			return false;
147			}
148			$data = $this->cache->get(
149			$session_id,
150			function () use ($session_id) {
151			$data = $this->read($session_id);
152			if (!$data \|\| $data['expire'] <= time()) {
153			return false;
154			}
155			$data['data'] = $data['data'] ?: [];
156			return $data;
157			}
158			);
159			return $this->is_good_session($data) ? $data : false;
160			}
161			/**
162			* Check whether session was not expired, user agent and IP corresponds to what is expected and user is actually active
163			*
164			* @param mixed $session_data
165			*
166			* @return bool
167			*/
168			protected function is_good_session ($session_data) {
169			return
170			isset($session_data['expire'], $session_data['user']) &&
171			$session_data['expire'] > time() &&
172			$this->is_user_active($session_data['user']);
173			}
174			/**
175			* Whether session data belongs to current visitor (user agent, remote addr and ip check)
176			*
177			* @param string $session_id
178			* @param string $user_agent
179			* @param string $remote_addr
180			* @param string $ip
181			*
182			* @return bool
183			*/
184			function is_session_owner ($session_id, $user_agent, $remote_addr, $ip) {
185			$session_data = $this->get($session_id);
186			return $session_data ? $this->is_session_owner_internal($session_data, $user_agent, $remote_addr, $ip) : false;
187			}
188			/**
189			* Whether session data belongs to current visitor (user agent, remote addr and ip check)
190			*
191			* @param array $session_data
192			* @param string\|null $user_agent
193			* @param string\|null $remote_addr
194			* @param string\|null $ip
195			*
196			* @return bool
197			*/
198			protected function is_session_owner_internal ($session_data, $user_agent = null, $remote_addr = null, $ip = null) {
199			/**
200			* md5() as protection against timing attacks
201			*/
202			if ($user_agent === null && $remote_addr === null && $ip === null) {
203			$Request = Request::instance();
204			$user_agent = $Request->header('user-agent');
205			$remote_addr = $Request->remote_addr;
206			$ip = $Request->ip;
207			}
208			return
209			md5($session_data['user_agent']) == md5($user_agent) &&
210			(
211			!Config::instance()->core['remember_user_ip'] \|\|
212			(
213			md5($session_data['remote_addr']) == md5(ip2hex($remote_addr)) &&
214			md5($session_data['ip']) == md5(ip2hex($ip))
215			)
216			);
217			}
218			/**
219			* Load session by id and return id of session owner (user), update session expiration
220			*
221			* @param false\|null\|string $session_id If not specified - loaded from `$this->session_id`, and if that also empty - from cookies
222			*
223			* @return int User id
224			*/
225			function load ($session_id = null) {
226			$session_data = $this->get_internal($session_id);
227			if (!$session_data \|\| !$this->is_session_owner_internal($session_data)) {
228			$this->add(User::GUEST_ID);
229			return User::GUEST_ID;
230			}
231			/**
232			* Updating last online time and ip
233			*/
234			$Config = Config::instance();
235			$time = time();
236			if ($session_data['expire'] - $time < $Config->core['session_expire'] * $Config->core['update_ratio'] / 100) {
237			$session_data['expire'] = $time + $Config->core['session_expire'];
238			$this->update($session_data);
239			$this->cache->set($session_data['id'], $session_data);
240			}
241			unset($session_data['data']);
242			Event::instance()->fire(
243			'System/Session/load',
244			[
245			'session_data' => $session_data
246			]
247			);
248			return $this->load_initialization($session_data['id'], $session_data['user']);
249			}
250			/**
251			* Initialize session (set user id, session id and update who user is)
252			*
253			* @param string $session_id
254			* @param int $user_id
255			*
256			* @return int User id
257			*/
258			protected function load_initialization ($session_id, $user_id) {
259			$this->session_id = $session_id;
260			$this->user_id = $user_id;
261			$this->update_user_is();
262			return $user_id;
263			}
264			/**
265			* Whether profile is activated, not disabled and not blocked
266			*
267			* @param int $user
268			*
269			* @return bool
270			*/
271			protected function is_user_active ($user) {
272			/**
273			* Optimization, more data requested than actually used here, because data will be requested later, and it would be nice to have that data cached
274			*/
275			$data = User::instance()->get(
276			[
277			'login',
278			'username',
279			'language',
280			'timezone',
281			'status',
282			'block_until',
283			'avatar'
284			],
285			$user
286			);
287			if (!$data) {
288			return false;
289			}
290			$L = new Language_prefix('system_profile_sign_in_');
291			$Page = Page::instance();
292			switch ($data['status']) {
293			case User::STATUS_INACTIVE:
294			/**
295			* If user is disabled
296			*/
297			$Page->warning($L->your_account_disabled);
298			return false;
299			case User::STATUS_NOT_ACTIVATED:
300			/**
301			* If user is not active
302			*/
303			$Page->warning($L->your_account_is_not_active);
304			return false;
305			}
306			if ($data['block_until'] > time()) {
307			/**
308			* If user if blocked
309			*/
310			$Page->warning($L->your_account_blocked_until(date($L->_datetime, $data['block_until'])));
311			return false;
312			}
313			return true;
314			}
315			/**
316			* Create the session for the user with specified id
317			*
318			* @param int $user
319			* @param bool $delete_current_session
320			*
321			* @return false\|string Session id on success, `false` otherwise
322			*/
323			function add ($user, $delete_current_session = true) {
324			$user = (int)$user;
325			if (!$user) {
326			return false;
327			}
328			if ($delete_current_session && is_md5($this->session_id)) {
329			$this->del_internal($this->session_id, false);
330			}
331			if (!$this->is_user_active($user)) {
332			/**
333			* If data was not loaded or account is not active - create guest session
334			*/
335			return $this->add(User::GUEST_ID);
336			}
337			$session_data = $this->create_unique_session($user);
338			Response::instance()->cookie('session', $session_data['id'], $session_data['expire'], true);
339			$this->load_initialization($session_data['id'], $session_data['user']);
340			/**
341			* Delete old sessions using probability and system configuration of inserts limits and update ratio
342			*/
343			$Config = Config::instance();
344			if (mt_rand(0, $Config->core['inserts_limit']) < $Config->core['inserts_limit'] / 100 * (100 - $Config->core['update_ratio']) / 5) {
345			$this->delete_old_sessions();
346			}
347			Event::instance()->fire(
348			'System/Session/add',
349			[
350			'session_data' => $session_data
351			]
352			);
353			return $session_data['id'];
354			}
355			/**
356			* @param int $user
357			*
358			* @return array Session data
359			*/
360			protected function create_unique_session ($user) {
361			$Config = Config::instance();
362			$Request = Request::instance();
363			$remote_addr = ip2hex($Request->remote_addr);
364			$ip = ip2hex($Request->ip);
365			/**
366			* Many guests open only one page (or do not store any cookies), so create guest session only for 5 minutes max initially
367			*/
368			$expire_in = $user == User::GUEST_ID ? min($Config->core['session_expire'], self::INITIAL_SESSION_EXPIRATION) : $Config->core['session_expire'];
369			$expire = time() + $expire_in;
370			/**
371			* Create unique session
372			*/
373			$session_data = [
374			'id' => null,
375			'user' => $user,
376			'created' => time(),
377			'expire' => $expire,
378			'user_agent' => $Request->header('user-agent'),
379			'remote_addr' => $remote_addr,
380			'ip' => $ip,
381			'data' => []
382			];
383			do {
384			$session_data['id'] = md5(random_bytes(1000));
385			} while (!$this->create($session_data));
386			return $session_data;
387			}
388			/**
389			* Destroying of the session
390			*
391			* @param null\|string $session_id
392			*
393			* @return bool
394			*/
395			function del ($session_id = null) {
396			return (bool)$this->del_internal($session_id);
397			}
398			/**
399			* Deletion of the session
400			*
401			* @param string\|null $session_id
402			* @param bool $create_guest_session
403			*
404			* @return bool
405			*/
406			protected function del_internal ($session_id = null, $create_guest_session = true) {
407			$session_id = $session_id ?: $this->session_id;
408			if (!is_md5($session_id)) {
409			return false;
410			}
411			Event::instance()->fire(
412			'System/Session/del/before',
413			[
414			'id' => $session_id
415			]
416			);
417			unset($this->cache->$session_id);
418			$this->session_id = false;
419			Response::instance()->cookie('session', '');
420			$result = $this->delete($session_id);
421			if ($result) {
422			if ($create_guest_session) {
423			return (bool)$this->add(User::GUEST_ID);
424			}
425			Event::instance()->fire(
426			'System/Session/del/after',
427			[
428			'id' => $session_id
429			]
430			);
431			}
432			return (bool)$result;
433			}
434			/**
435			* Delete all old sessions from DB
436			*/
437			protected function delete_old_sessions () {
438			$this->db_prime()->aq(
439			"DELETE FROM `[prefix]sessions`
440			WHERE `expire` < ".time()
441			);
442			}
443			/**
444			* Deletion of all user sessions
445			*
446			* @param false\|int $user If not specified - current user assumed
447			*
448			* @return bool
449			*/
450			function del_all ($user = false) {
451			$user = $user ?: $this->user_id;
452			Event::instance()->fire(
453			'System/Session/del_all',
454			[
455			'id' => $user
456			]
457			);
458			$sessions = $this->db_prime()->qfas(
459			"SELECT `id`
460			FROM `[prefix]sessions`
461			WHERE `user` = '$user'"
462			);
463			if (is_array($sessions)) {
464			if (!$this->delete($sessions)) {
465			return false;
466			}
467			foreach ($sessions as $session) {
468			unset($this->cache->$session);
469			}
470			}
471			return true;
472			}
473			}
474

nazar-pc / CleverStyle-Framework

Push — master ( c7c099...bc3d45 )

Management C

Complexity

Size/Duplication

Coupling/Cohesion

Importance

21 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like