UserPermissions\Controller\Component\UserPermissionsComponent

Complexity

Total Complexity

38

Size/Duplication

Total Lines	206
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

83.52%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	initialize()	0	16	2
A	allow()	0	10	2
A	setUserValues()	0	8	2
C	bindConfiguration()	0	33	11
A	applyGroupsRules()	0	12	3
A	searchForApplyGroupRules()	0	10	3
A	notInArrayAction()	0	4	2
A	applyViewsRules()	0	8	3
C	searchForApplyViewRules()	0	26	7
A	redirectIfIsSet()	0	11	3

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 17 and the first side effect is on line 18.

namespace UserPermissions\Controller\Component;

use Cake\Controller\Component;
use Cake\Controller\ComponentRegistry;
use Cake\Controller\Component\FlashComponent;
use Cake\Core\Exception\Exception;
use Cake\Datasource\ConnectionManager;
use Cake\Log\Log;
use Cake\ORM\TableRegistry;

/**
 * An instance of this exception should be thrown, if the
 * UserPermissionsComponent instance tries to call an handler which does not
 * exist.
 */
class MissingHandlerException extends Exception
{};

The opening class brace should be on a newline by itself.

class UserPermissionsComponent extends Component {

PSR1 recommends that each class should be in its own file to aid autoloaders.

    /**
     * Controller name
     *
     * @var string
     */
	public $controller = null;

    /**
     * Session
     *
     * @var string
     */
	public $session = null;

    /**
     * Components array
     *
     * @var array
     */
   	public $components = ['Flash'];

    private $actions;

    private $allow;

    private $redirect;

    private $params;

    private $message;

    private $userType;

    private $action;
	
	/**
	 * Boolean value which holds the configuration for the behavior in case of
	 * missing handlers.
	 */
	private $throwEx;

    /**
    * Initialization to get controller variable
    *
	* For this component available settings:
	* 	bool throwEx - default false - if set to true, an exception will be
	*		thrown, if a handler is about to be called but does not exist.
	*
    * @param array $config Configuration array for the component.
    */
    public function initialize(array $config)
    {
        parent::initialize($config);
        
        $this->controller = $this->_registry->getController();

It seems like $this->_registry->getController() of type object<Cake\Controller\Controller> is incompatible with the declared type string of property $controller.

        $this->session = $this->controller->request->session();

        $this->actions 		= array();
		$this->allow 		= true;
		$this->redirect 	= '';
		$this->params 		= '';
		$this->message 		= '';
		$this->userType 	= '';
		$this->action   	= null;
		$this->throwEx      = isset($config["throwEx"]) && $config["throwEx"];
    }

    /**
    * Initialization to get controller variable
    *
    * @param array $rules Array of rules for permissions.
    * @return bool false if user / group doesn't have permission, true if has permission
    */
    public function allow ($rules) {
    	$this->setUserValues();
    	$this->bindConfiguration($rules);

		if (!$this->applyGroupsRules($rules)) {
			$this->applyViewsRules($rules);
		}

		return $this->allow;
    }

    private function setUserValues()
    {
    	$userId = $this->session->read('Auth.User.id');

The method read cannot be called on $this->session (of type string).

    	if (!isset($userId)) {
			$this->userType = 'guest';
		}
    }

    private function bindConfiguration(array $rules) 
    {
    	foreach($rules as $key => $value){
			switch($key){
				case "user_type":
			        $this->userType = $value;
			        break;
			    case "redirect":
			        $this->redirect = $value;
			        break;
			    case "action":
			        $this->action = $value;
			        break;
			    case "controller":
			        $this->controller = $value;
					if(!is_object($value)) {
						Log::write("warn", sprintf("controller is not an object (%s)", gettype($value)));
					}
			        break;
			    case "message":
			        $this->message = $value;
			        break;
			}
		}

		foreach($rules['groups']  as $key => $value){
			if($key == $this->userType){
				foreach($value as $v){
					array_push($this->actions, $v);
				}
			}
		}
    }

    private function applyGroupsRules(array $rules)
    {
    	$existRulesForGroups = false;

    	if(isset($rules['groups'])){
			foreach($rules['groups'] as $key => $value){
				$this->searchForApplyGroupRules($key, $value);

The call to UserPermissionsComponent::searchForApplyGroupRules() has too many arguments starting with $value.

			}
		}

		return $existRulesForGroups;
    }

    private function searchForApplyGroupRules($key)
    {
    	if($key == $this->userType){
    		if ($this->notInArrayAction()) {
				$this->redirectIfIsSet();
				
				$this->allow = false;
			}
		}
    }

    private function notInArrayAction()
    {
    	return ((!in_array('*', $this->actions)) && (!in_array($this->action, $this->actions)));
    }

    private function applyViewsRules(array $rules)
    {
    	if(isset($rules['views'])){
			foreach($rules['views'] as $key => $value){
				$this->searchForApplyViewRules($key, $value);
			}
		}
    }

    private function searchForApplyViewRules($key, $value)
    {
    	if($key == $this->action){
			// about to call the view handler, so check first if it exists
			if(!method_exists($this->controller, $value)) {
				$msg = sprintf(
					"Controller %s (%s=%s) has no method called '%s'",
					$this->controller,
					is_object($this->controller) ? "class" : "type",
					is_object($this->controller) ? get_class($this->controller) : gettype($this->controller),
					$value
				);
				Log::write("debug", $msg);
				if($this->throwEx) {
					throw new MissingHandlerException($msg);
				}
				return;
			}
			
			if(!$this->controller->$value()){

The method $value cannot be called on $this->controller (of type string).

				$this->redirectIfIsSet();
				
				$this->allow = false;
			}
		}
    }

    private function redirectIfIsSet()
    {
    	if($this->redirect != ''){
			if($this->message != ''){
				$this->Flash->set($this->message);

The property Flash does not exist on object<UserPermissions\Controller\Component\UserPermissionsComponent>. Since you implemented __get, maybe consider adding a @property annotation.

			}
			
			header("Location: " . $this->redirect);
			exit;

The method redirectIfIsSet() contains an exit expression.

		}
	}
}