Notification::setSessionManager() - Code Metrics - szmnmichalowski/SzmNotification - Measure and Improve Code Quality continuously with Scrutinizer

Notification::setSessionManager() A
last analyzed 2017-03-25 14:53 UTC

↳ Parent: Notification

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	6
ccs	3
cts	3
cp	1
rs	9.4285
cc	1
eloc	3
nc	1
nop	1
crap	1

<?php
/**
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license.
 */

namespace SzmNotification\Controller\Plugin;

use Zend\Mvc\Controller\Plugin\AbstractPlugin;
use Zend\Session\ManagerInterface as Manager;
use Zend\Session\Container;
use Zend\Stdlib\SplQueue;

class Notification extends AbstractPlugin
{
    /**
     * Namespace for info notifications
     */
    const NAMESPACE_INFO = 'info';

    /**
     * Namespace for success notifications
     */
    const NAMESPACE_SUCCESS = 'success';

    /**
     * Namespace for warning notifications
     */
    const NAMESPACE_WARNING = 'warning';

    /**
     * Namespace for error notifications
     */
    const NAMESPACE_ERROR = 'error';

    /**
     * @var Container
     */
    protected $container;

    /**
     * @var Manager
     */
    protected $sessionManager;

    /**
     * @var array
     */
    protected $notifications = [];

    /**
     * @var bool
     */
    protected $isAdded = false;

    /**
     * @var array
     */
    protected $customMethods = [
        'add',
        'get',
        'getcurrent',
        'has',
        'hascurrent'
    ];

    /**
     * @param Manager $manager
     * @return $this
     */
    public function setSessionManager(Manager $manager)
    {
        $this->sessionManager = $manager;

        return $this;
    }

    /**
     * @return Manager
     */
    public function getSessionManager()
    {
        if (!$this->sessionManager instanceof Manager) {
            $this->setSessionManager(Container::getDefaultManager());
        }

        return $this->sessionManager;
    }

    /**
     * @return Container
     */
    public function getContainer()
    {
        if ($this->container instanceof Container) {
            return $this->container;
        }

        $manager = $this->getSessionManager();
        $this->container = new Container('notifications', $manager);

        return $this->container;
    }

    /**
     * @param $type
     * @param $message
     * @param int $hops
     * @return $this
     */
    public function add($type, $message, $hops = 1)
    {
        $container = $this->getContainer();

        if (!$this->isAdded) {
            $this->getNotificationsFromContainer();
            $container->setExpirationHops($hops);
        }

        if (!isset($container->{$type}) || !$container->{$type} instanceof SplQueue) {
            $container->{$type} = new SplQueue();
        }

        $container->{$type}->push($message);
        $this->isAdded = true;

        return $this;
    }

    /**
     * @param $message
     * @return $this
     */
    public function addInfo($message)
    {
        return $this->add(self::NAMESPACE_INFO, $message);
    }

    /**
     * @param $message
     * @return $this
     */
    public function addSuccess($message)
    {
        return $this->add(self::NAMESPACE_SUCCESS, $message);
    }

    /**
     * @param $message
     * @return $this
     */
    public function addWarning($message)
    {
        return $this->add(self::NAMESPACE_WARNING, $message);
    }

    /**
     * @param $message
     * @return $this
     */
    public function addError($message)
    {
        return $this->add(self::NAMESPACE_ERROR, $message);
    }

    /**
     * @param $type
     * @param $message
     * @return $this
     */
    public function __invoke($type = null, $message = null)
    {
        if (!$type || !$message) {
            return $this;
        }

        return $this->add($type, $message);
    }

    /**
     * @param $namespace
     * @return array
     */
    public function get($namespace)
    {
        if ($this->has($namespace)) {
            return $this->notifications[$namespace]->toArray();
        }

        return [];
    }

    /**
     * @return array
     */
    public function getAll()
    {
        $this->getNotificationsFromContainer();

        return $this->notifications;
    }

    /**
     * @return array
     */
    public function getInfo()
    {
        return $this->get(self::NAMESPACE_INFO);
    }

    /**
     * @return array
     */
    public function getSuccess()
    {
        return $this->get(self::NAMESPACE_SUCCESS);
    }

    /**
     * @return array
     */
    public function getWarning()
    {
        return $this->get(self::NAMESPACE_WARNING);
    }

    /**
     * @return array
     */
    public function getError()
    {
        return $this->get(self::NAMESPACE_ERROR);
    }

    /**
     * @param $namespace
     * @return bool
     */
    public function has($namespace)
    {
        $this->getNotificationsFromContainer();

        return isset($this->notifications[$namespace]);
    }

    /**
     * @return bool
     */
    public function hasInfo()
    {
        return $this->has(self::NAMESPACE_INFO);
    }

    /**
     * @return bool
     */
    public function hasSuccess()
    {
        return $this->has(self::NAMESPACE_SUCCESS);
    }

    /**
     * @return bool
     */
    public function hasWarning()
    {
        return $this->has(self::NAMESPACE_WARNING);
    }

    /**
     * @return bool
     */
    public function hasError()
    {
        return $this->has(self::NAMESPACE_ERROR);
    }

    /**
     * @param $namespace
     * @return array|mixed
     */
    public function getCurrent($namespace)
    {
        if ($this->hasCurrent($namespace)) {
            $container = $this->getContainer();

            return $container->{$namespace}->toArray();
        }

        return [];
    }

    /**
     * Get all current notifications
     *
     * @return array
     */
    public function getAllCurrent()
    {
        $notifications = [];
        $container = $this->getContainer();

        foreach ($container as $namespace => $notification) {
            $notifications[$namespace] = $this->getCurrent($namespace);
        }

        return $notifications;
    }

    /**
     * Get info notifications added during this request
     *
     * @return array|mixed
     */
    public function getCurrentInfo()
    {
        return $this->getCurrent(self::NAMESPACE_INFO);
    }

    /**
     * Get success notifications added during this request
     *
     * @return array|mixed
     */
    public function getCurrentSuccess()
    {
        return $this->getCurrent(self::NAMESPACE_SUCCESS);
    }

    /**
     * Get warning notifications added during this request
     *
     * @return array|mixed
     */
    public function getCurrentWarning()
    {
        return $this->getCurrent(self::NAMESPACE_WARNING);
    }

    /**
     * Get error notifications added during this request
     *
     * @return array|mixed
     */
    public function getCurrentError()
    {
        return $this->getCurrent(self::NAMESPACE_ERROR);
    }

    /**
     * @param $namespace
     * @return bool
     */
    public function hasCurrent($namespace)
    {
        $container = $this->getContainer();

        return isset($container->{$namespace});
    }

    /**
     * Check if info notifications have been added during this request
     *
     * @return bool
     */
    public function hasCurrentInfo()
    {
        return $this->hasCurrent(self::NAMESPACE_INFO);
    }

    /**
     * Check if success notifications have been added during this request
     *
     * @return bool
     */
    public function hasCurrentSuccess()
    {
        return $this->hasCurrent(self::NAMESPACE_SUCCESS);
    }

    /**
     * Check if warning notifications have been added during this request
     *
     * @return bool
     */
    public function hasCurrentWarning()
    {
        return $this->hasCurrent(self::NAMESPACE_WARNING);
    }

    /**
     * Check if error notifications have been added during this request
     *
     * @return bool
     */
    public function hasCurrentError()
    {
        return $this->hasCurrent(self::NAMESPACE_ERROR);
    }

    /**
     * @param $name
     * @param $arguments
     * @return mixed
     */
    public function __call($name, $arguments)
    {
        // we take first 3 chars from called method
        $length = 3;
        $name = strtolower($name);
        if (strpos($name, 'current')) {
            $length += strlen('current');
        }

        $method = substr($name, 0, $length);
        if (!in_array($method, $this->customMethods)) {
            return false;
        }

        $namespace = substr($name, $length);
        if ($method !== 'add') {
            return $this->$method($namespace);
        }

        // If user called add method then we have to check if he provided notification text
        if (!isset($arguments[0]) || !is_string($arguments[0])) {
            throw new \InvalidArgumentException(sprintf(
                '%s method must contains notification text, %s given.',
                $name,
                isset($arguments[0]) ? gettype($arguments[0]) : null
            ));
        }

        $this->$method($namespace, $arguments[0]);
        return $this;
    }

    /**
     * Clear notifications from container
     */
    protected function getNotificationsFromContainer()
    {
        if (!empty($this->notifications) || $this->isAdded) {
            return;
        }

        $container = $this->getContainer();
        $namespaces = [];

        foreach ($container as $namespace => $notification) {
            $this->notifications[$namespace] = $notification;
            $namespaces[] = $namespace;
        }

        $this->clearNotificationsFromContainer($namespaces);
    }

    /**
     * @param $namespaces
     */
    protected function clearNotificationsFromContainer($namespaces)
    {
        $namespaces = is_array($namespaces) ? $namespaces : [$namespaces];
        $container = $this->getContainer();

        foreach ($namespaces as $namespace) {
            unset($container->{$namespace});
        }
    }

    /**
     * Clear notifications from container if namespace is provided or clear all notifications
     * added during this request if namespace is not provided.
     *
     * @param null $namespace
     * @return bool
     */
    public function clearCurrent($namespace = null)
    {
        $container = $this->getContainer();

        if ($namespace) {
            if (!$container->offsetExists($namespace)) {
                return false;
            }

            unset($container->{$namespace});
            return true;
        }

        foreach ($container as $namespace => $notifications) {
            $container->offsetUnset($namespace);
        }

        return true;
    }

    /**
     * Clear notifications from previous request by provided namespace or clear all
     * notifications if namespace is not provided
     *
     * @param null $namespace
     * @return bool
     */
    public function clear($namespace = null)
    {
        $this->getNotificationsFromContainer();

        if ($namespace) {
            if (isset($this->notifications[$namespace])) {
                unset($this->notifications[$namespace]);
                return true;
            }

            return false;
        }

        foreach ($this->notifications as $nm => $type) {
            unset($this->notifications[$nm]);
        }

        return true;
    }
}

1		<?php
2		/**
3		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
5		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
6		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
7		* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
8		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
9		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
10		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
11		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
12		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
13		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14		*
15		* This software consists of voluntary contributions made by many individuals
16		* and is licensed under the MIT license.
17		*/
18
19		namespace SzmNotification\Controller\Plugin;
20
21		use Zend\Mvc\Controller\Plugin\AbstractPlugin;
22		use Zend\Session\ManagerInterface as Manager;
23		use Zend\Session\Container;
24		use Zend\Stdlib\SplQueue;
25
26		class Notification extends AbstractPlugin
27		{
28		/**
29		* Namespace for info notifications
30		*/
31		const NAMESPACE_INFO = 'info';
32
33		/**
34		* Namespace for success notifications
35		*/
36		const NAMESPACE_SUCCESS = 'success';
37
38		/**
39		* Namespace for warning notifications
40		*/
41		const NAMESPACE_WARNING = 'warning';
42
43		/**
44		* Namespace for error notifications
45		*/
46		const NAMESPACE_ERROR = 'error';
47
48		/**
49		* @var Container
50		*/
51		protected $container;
52
53		/**
54		* @var Manager
55		*/
56		protected $sessionManager;
57
58		/**
59		* @var array
60		*/
61		protected $notifications = [];
62
63		/**
64		* @var bool
65		*/
66		protected $isAdded = false;
67
68		/**
69		* @var array
70		*/
71		protected $customMethods = [
72		'add',
73		'get',
74		'getcurrent',
75		'has',
76		'hascurrent'
77		];
78
79		/**
80		* @param Manager $manager
81		* @return $this
82		*/
83	4	public function setSessionManager(Manager $manager)
84		{
85	4	$this->sessionManager = $manager;
86
87	4	return $this;
88		}
89
90		/**
91		* @return Manager
92		*/
93	4	public function getSessionManager()
94		{
95	4	if (!$this->sessionManager instanceof Manager) {
96	4	$this->setSessionManager(Container::getDefaultManager());
97	4	}
98
99	4	return $this->sessionManager;
100		}
101
102		/**
103		* @return Container
104		*/
105	4	public function getContainer()
106		{
107	4	if ($this->container instanceof Container) {
108	3	return $this->container;
109		}
110
111	4	$manager = $this->getSessionManager();
112	4	$this->container = new Container('notifications', $manager);
113
114	4	return $this->container;
115		}
116
117		/**
118		* @param $type
119		* @param $message
120		* @param int $hops
121		* @return $this
122		*/
123	5	public function add($type, $message, $hops = 1)
124		{
125	5	$container = $this->getContainer();
126
127	5	if (!$this->isAdded) {
128	5	$this->getNotificationsFromContainer();
129	5	$container->setExpirationHops($hops);
130	5	}
131
132	5	if (!isset($container->{$type}) \|\| !$container->{$type} instanceof SplQueue) {
133	5	$container->{$type} = new SplQueue();
134	5	}
135
136	5	$container->{$type}->push($message);
137	5	$this->isAdded = true;
138
139	5	return $this;
140		}
141
142		/**
143		* @param $message
144		* @return $this
145		*/
146	1	public function addInfo($message)
147		{
148	1	return $this->add(self::NAMESPACE_INFO, $message);
149		}
150
151		/**
152		* @param $message
153		* @return $this
154		*/
155	1	public function addSuccess($message)
156		{
157	1	return $this->add(self::NAMESPACE_SUCCESS, $message);
158		}
159
160		/**
161		* @param $message
162		* @return $this
163		*/
164	1	public function addWarning($message)
165		{
166	1	return $this->add(self::NAMESPACE_WARNING, $message);
167		}
168
169		/**
170		* @param $message
171		* @return $this
172		*/
173	1	public function addError($message)
174		{
175	1	return $this->add(self::NAMESPACE_ERROR, $message);
176		}
177
178		/**
179		* @param $type
180		* @param $message
181		* @return $this
182		*/
183	2	public function __invoke($type = null, $message = null)
184		{
185	2	if (!$type \|\| !$message) {
186	1	return $this;
187		}
188
189	1	return $this->add($type, $message);
190		}
191
192		/**
193		* @param $namespace
194		* @return array
195		*/
196	4	public function get($namespace)
197		{
198	4	if ($this->has($namespace)) {
199	3	return $this->notifications[$namespace]->toArray();
200		}
201
202	1	return [];
203		}
204
205		/**
206		* @return array
207		*/
208	1	public function getAll()
209		{
210	1	$this->getNotificationsFromContainer();
211
212	1	return $this->notifications;
213		}
214
215		/**
216		* @return array
217		*/
218	1	public function getInfo()
219		{
220	1	return $this->get(self::NAMESPACE_INFO);
221		}
222
223		/**
224		* @return array
225		*/
226	1	public function getSuccess()
227		{
228	1	return $this->get(self::NAMESPACE_SUCCESS);
229		}
230
231		/**
232		* @return array
233		*/
234	1	public function getWarning()
235		{
236	1	return $this->get(self::NAMESPACE_WARNING);
237		}
238
239		/**
240		* @return array
241		*/
242	1	public function getError()
243		{
244	1	return $this->get(self::NAMESPACE_ERROR);
245		}
246
247		/**
248		* @param $namespace
249		* @return bool
250		*/
251	3	public function has($namespace)
252		{
253	3	$this->getNotificationsFromContainer();
254
255	3	return isset($this->notifications[$namespace]);
256		}
257
258		/**
259		* @return bool
260		*/
261	1	public function hasInfo()
262		{
263	1	return $this->has(self::NAMESPACE_INFO);
264		}
265
266		/**
267		* @return bool
268		*/
269	1	public function hasSuccess()
270		{
271	1	return $this->has(self::NAMESPACE_SUCCESS);
272		}
273
274		/**
275		* @return bool
276		*/
277	1	public function hasWarning()
278		{
279	1	return $this->has(self::NAMESPACE_WARNING);
280		}
281
282		/**
283		* @return bool
284		*/
285	1	public function hasError()
286		{
287	1	return $this->has(self::NAMESPACE_ERROR);
288		}
289
290		/**
291		* @param $namespace
292		* @return array\|mixed
293		*/
294	3	public function getCurrent($namespace)
295		{
296	3	if ($this->hasCurrent($namespace)) {
297	2	$container = $this->getContainer();
298
299	2	return $container->{$namespace}->toArray();
300		}
301
302	1	return [];
303		}
304
305		/**
306		* Get all current notifications
307		*
308		* @return array
309		*/
310	1	public function getAllCurrent()
311		{
312	1	$notifications = [];
313	1	$container = $this->getContainer();
314
315	1	foreach ($container as $namespace => $notification) {
316	1	$notifications[$namespace] = $this->getCurrent($namespace);
317	1	}
318
319	1	return $notifications;
320		}
321
322		/**
323		* Get info notifications added during this request
324		*
325		* @return array\|mixed
326		*/
327	1	public function getCurrentInfo()
328		{
329	1	return $this->getCurrent(self::NAMESPACE_INFO);
330		}
331
332		/**
333		* Get success notifications added during this request
334		*
335		* @return array\|mixed
336		*/
337	1	public function getCurrentSuccess()
338		{
339	1	return $this->getCurrent(self::NAMESPACE_SUCCESS);
340		}
341
342		/**
343		* Get warning notifications added during this request
344		*
345		* @return array\|mixed
346		*/
347	1	public function getCurrentWarning()
348		{
349	1	return $this->getCurrent(self::NAMESPACE_WARNING);
350		}
351
352		/**
353		* Get error notifications added during this request
354		*
355		* @return array\|mixed
356		*/
357	1	public function getCurrentError()
358		{
359	1	return $this->getCurrent(self::NAMESPACE_ERROR);
360		}
361
362		/**
363		* @param $namespace
364		* @return bool
365		*/
366	2	public function hasCurrent($namespace)
367		{
368	2	$container = $this->getContainer();
369
370	2	return isset($container->{$namespace});
371		}
372
373		/**
374		* Check if info notifications have been added during this request
375		*
376		* @return bool
377		*/
378	1	public function hasCurrentInfo()
379		{
380	1	return $this->hasCurrent(self::NAMESPACE_INFO);
381		}
382
383		/**
384		* Check if success notifications have been added during this request
385		*
386		* @return bool
387		*/
388	1	public function hasCurrentSuccess()
389		{
390	1	return $this->hasCurrent(self::NAMESPACE_SUCCESS);
391		}
392
393		/**
394		* Check if warning notifications have been added during this request
395		*
396		* @return bool
397		*/
398	1	public function hasCurrentWarning()
399		{
400	1	return $this->hasCurrent(self::NAMESPACE_WARNING);
401		}
402
403		/**
404		* Check if error notifications have been added during this request
405		*
406		* @return bool
407		*/
408	1	public function hasCurrentError()
409		{
410	1	return $this->hasCurrent(self::NAMESPACE_ERROR);
411		}
412
413		/**
414		* @param $name
415		* @param $arguments
416		* @return mixed
417		*/
418	7	public function __call($name, $arguments)
419		{
420		// we take first 3 chars from called method
421	7	$length = 3;
422	7	$name = strtolower($name);
423	7	if (strpos($name, 'current')) {
424	2	$length += strlen('current');
425	2	}
426
427	7	$method = substr($name, 0, $length);
428	7	if (!in_array($method, $this->customMethods)) {
429	2	return false;
430		}
431
432	6	$namespace = substr($name, $length);
433	6	if ($method !== 'add') {
434	4	return $this->$method($namespace);
435		}
436
437		// If user called add method then we have to check if he provided notification text
438	6	if (!isset($arguments[0]) \|\| !is_string($arguments[0])) {
439	1	throw new \InvalidArgumentException(sprintf(
440	1	'%s method must contains notification text, %s given.',
441	1	$name,
442	1	isset($arguments[0]) ? gettype($arguments[0]) : null
443	1	));
444		}
445
446	5	$this->$method($namespace, $arguments[0]);
447	5	return $this;
448		}
449
450		/**
451		* Clear notifications from container
452		*/
453	4	protected function getNotificationsFromContainer()
454		{
455	4	if (!empty($this->notifications) \|\| $this->isAdded) {
456	1	return;
457		}
458
459	4	$container = $this->getContainer();
460	4	$namespaces = [];
461
462	4	foreach ($container as $namespace => $notification) {
463	3	$this->notifications[$namespace] = $notification;
464	3	$namespaces[] = $namespace;
465	4	}
466
467	4	$this->clearNotificationsFromContainer($namespaces);
468	4	}
469
470		/**
471		* @param $namespaces
472		*/
473	4	protected function clearNotificationsFromContainer($namespaces)
474		{
475	4	$namespaces = is_array($namespaces) ? $namespaces : [$namespaces];
476	4	$container = $this->getContainer();
477
478	4	foreach ($namespaces as $namespace) {
479	3	unset($container->{$namespace});
480	4	}
481	4	}
482
483		/**
484		* Clear notifications from container if namespace is provided or clear all notifications
485		* added during this request if namespace is not provided.
486		*
487		* @param null $namespace
488		* @return bool
489		*/
490	3	public function clearCurrent($namespace = null)
491		{
492	3	$container = $this->getContainer();
493
494	3	if ($namespace) {
495	2	if (!$container->offsetExists($namespace)) {
496	1	return false;
497		}
498
499	1	unset($container->{$namespace});
500	1	return true;
501		}
502
503	1	foreach ($container as $namespace => $notifications) {
504	1	$container->offsetUnset($namespace);
505	1	}
506
507	1	return true;
508		}
509
510		/**
511		* Clear notifications from previous request by provided namespace or clear all
512		* notifications if namespace is not provided
513		*
514		* @param null $namespace
515		* @return bool
516		*/
517	3	public function clear($namespace = null)
518		{
519	3	$this->getNotificationsFromContainer();
520
521	3	if ($namespace) {
522	2	if (isset($this->notifications[$namespace])) {
523	1	unset($this->notifications[$namespace]);
524	1	return true;
525		}
526
527	1	return false;
528		}
529
530	1	foreach ($this->notifications as $nm => $type) {
531	1	unset($this->notifications[$nm]);
532	1	}
533
534	1	return true;
535		}
536		}

szmnmichalowski / SzmNotification

Notification::setSessionManager() A last analyzed 2017-03-25 14:53 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Notification::setSessionManager() A
last analyzed 2017-03-25 14:53 UTC