UserPermissions\Controller\Component\UserPermissionsComponent

Complexity

Total Complexity

42

Size/Duplication

Total Lines	221
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

94.57%

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	applyGroupsRules()	0	12	3
A	applyViewsRules()	0	8	3
A	searchForApplyViewRules()	0	10	4
A	initialize()	0	17	2
A	allow()	0	10	2
A	setUserValues()	0	8	2
C	bindConfiguration()	0	33	11
A	searchForApplyGroupRules()	0	10	3
A	notInArrayAction()	0	4	2
B	checkForHandler()	0	18	5
B	redirectIfIsSet()	0	17	5

<?php
namespace UserPermissions\Controller\Component;

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

class UserPermissionsComponent extends Component {

    /**
     * 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;

	/**
	 * Boolean value true if an redirect is already invoked.
	 */
	private $isRedirecting;

    /**
    * 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 	 = null;
		$this->params 		 = '';
		$this->message 		 = '';
		$this->userType 	 = '';
		$this->action   	 = null;
		$this->throwEx       = isset($config["throwEx"]) && $config["throwEx"];
		$this->isRedirecting = false;
    }

    /**
    * 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("warning", 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) {
			if(!$this->checkForHandler($this->controller, $value) || !$this->controller->$value()){

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

				$this->redirectIfIsSet();
				
				$this->allow = false;
			}
		}
    }
	
	private function checkForHandler($controller, $handler)
	{
		if(!method_exists($controller, $handler)) {
			$msg = sprintf(
				"Controller %s=%s has no method called '%s'",
				is_object($controller) ? "class" : "type",
				is_object($controller) ? get_class($controller) : gettype($controller),
				$handler
			);
			Log::write("debug", $msg);
			if($this->throwEx) {
				throw new MissingHandlerException($msg);
			}
			return false;
		}
		
		return true;
	}
	
    private function redirectIfIsSet()
    {
    	if($this->redirect && !$this->isRedirecting){
			$this->isRedirecting = true;
			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.

			}
			
			if(method_exists($this->controller, "redirect")) {
				$this->controller->redirect($this->redirect);

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

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

The method redirectIfIsSet() contains an exit expression.

			}
		}
	}
}