AbstractController::executionIsAllowed() - Code Metrics - Inspection of "Complete Controller test and add some improvements" - Pleets/dronephp - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 6b8118...1ac76f )

by Darío

created 2019-04-01 22:02 UTC

AbstractController::executionIsAllowed() A

↳ Parent: AbstractController

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php
/**
 * DronePHP (http://www.dronephp.com)
 *
 * @link      http://github.com/Pleets/DronePHP
 * @copyright Copyright (c) 2016-2018 Pleets. (http://www.pleets.org)
 * @license   http://www.dronephp.com/license
 * @author    Darío Rivera <[email protected]>
 */

namespace Drone\Mvc;

use Drone\Mvc\Exception;

/**
 * AbstractionController class
 *
 * This class manages the interaction between models and views
 */
abstract class AbstractController
{
    use \Drone\Util\ParamTrait;

    /**
     * Current module instance
     *
     * @var AbstractModule
     */
    private $module;

    /**
     * Current method
     *
     * @var string
     */
    private $method = null;

    /**
     * Layout name
     *
     * @var string
     */
    private $layout = "default";

    /**
     * Terminal mode
     *
     * @var boolean
     */
    private $terminal = true;

    /**
     * Indicates if the controller must show the views
     *
     * @var boolean
     */
    private $showView = true;

    /**
     * Defines method execution
     *
     * The only way to stop method execution is executing stopExecution() before execute().
     *
     * @var boolean
     */
    private $allowExecution = true;

    /**
     * Base path
     *
     * @var string
     */
    private $basePath;

    /**
     * Returns the current module instance
     *
     * @return AbstractModule
     */
    public function getModule()
    {
        return $this->module;
    }

    /**
     * Returns the current method
     *
     * @return string
     */
    public function getMethod()
    {
        return $this->method;
    }

    /**
     * Returns the mode of visualization
     *
     * @return boolean
     */
    public function getTerminal()
    {
        return $this->terminal;
    }

    /**
     * Returns the mode of viewing
     *
     * @return boolean
     */
    public function getShowView()
    {
        return $this->showView;
    }

    /**
     * Returns the current layout
     *
     * @return string
     */
    public function getLayout()
    {
        return $this->layout;
    }

    /**
     * Returns the base path
     *
     * @return string
     */
    public function getBasePath()
    {
        return $this->basePath;
    }

    /**
     * Sets the terminal mode
     *
     * @param boolean $terminal
     *
     * @return null
     */
    public function setTerminal($terminal = true)
    {
        $this->terminal = $terminal;
    }

    /**
     * Sets the showView parameter
     *
     * @param boolean $show
     *
     * @return null
     */
    public function setShowView($show = true)
    {
        $this->showView = $show;
    }

    /**
     * Sets layout name
     *
     * @param string $layout
     *
     * @return null
     */
    public function setLayout($layout)
    {
        $this->layout = $layout;
    }

    /**
     * Sets the method attribute
     *
     * @param string $method
     *
     * @return null
     */
    public function setMethod($method)
    {
        $this->method = $method;
    }

    /**
     * Constructor
     *
     * @param string $basePath
     *
     * @throws Exception\PageNotFoundException
     */
    public function __construct($basePath = null)
    {
        $this->basePath = $basePath;
    }

    /**
     * Creates the module instance
     *
     * @param string $module
     *
     * @return null
     */
    public function createModuleInstance($module)
    {
        if (!is_null($module))

        {
            /*
             * Module class instantiation
             *
             * Each module must have a class called Module in her namesapce. This class
             * is initilized here and can change the behavior of a controller using
             * stopExecution(), setMethod() or other methods.
             */

            $fqn_module = "\\" . $module . "\\Module";

            if (!class_exists($fqn_module))
                throw new Exception\ModuleNotFoundException("The module class '$fqn_module' does not exists!");

            $this->module = new $fqn_module($module, $this);
        }
    }

    /**
     * Executes the controller
     *
     * @return null
     */
    public function execute()
    {
        $method = $this->method;

        if (is_null($method))

            # This error is thrown because of 'setMethod' method has not been executed
            throw new \LogicException("No method has been setted to execute!");

        if ($this->allowExecution)
        {
            if (method_exists($this, $method))
            {
                $class = __CLASS__;

                $reflection = new \ReflectionMethod($this, $method);

                if (!$reflection->isPublic())
                    throw new Exception\PrivateMethodExecutionException("The method '$method' is not public in the control class '$class'");

                # Get the returned value of the method to send to the view
                $this->params = $this->$method();

                # The only way to manage views is through an AbstractModule
                if (!is_null($this->module))
                {
                    $params = $this->getParams();

                    $layout_params = (count($params) && array_key_exists('::Layout', $params)) ? $params["::Layout"] : [];

                    $layoutManager = new Layout($layout_params);
                    $layoutManager->fromController($this);
                }
            }
            else
            {
                $class = __CLASS__;
                throw new Exception\MethodNotFoundException("The method '$method' doesn't exists in the control class '$class'");
            }
        }
    }

    /**
     * Stops the execution of the specified method
     *
     * The only way to stop method execution before execute()
     *
     * @return null
     */
    public function stopExecution()
    {
        $this->allowExecution = false;
    }

    /**
     * Checks if allowExecution is true
     *
     * @return null
     */
    public function executionIsAllowed()
    {
        return $this->allowExecution;

    }

    /**
     * Returns the class name
     *
     * @return string
     */
    public static function getClassName()
    {
        return __CLASS__;
    }

    /**
     * Returns $_POST contents
     *
     * @return array
     */
    public function getPost()
    {
        if ($_SERVER['REQUEST_METHOD'] == 'POST' && empty($_POST))
            $_POST = json_decode(file_get_contents('php://input'), true);

        return (array) $_POST;
    }

    /**
     * Returns json contents
     *
     * @throws LogicException
     *
     * @return array
     */
    public function getJson()
    {
        if ($_SERVER['REQUEST_METHOD'] != 'JSON')
            throw new \LogicException("Request method is not JSON");

        $input =  file_get_contents('php://input');
        $array = explode("&", $input);

        $result = [];

        foreach ($array as $value)
        {
            $io = explode("=", $value);
            $result[$io[0]] = $io[1];
        }

        return $result;
    }

    /**
     * Checks if the current request is XmlHttpRequest (AJAX)
     *
     * @return boolean
     */
    public function isXmlHttpRequest()
    {
        # non standard (HTTP_X_REQUESTED_WITH is not a part of PHP)
        if (isset($_SERVER['HTTP_X_REQUESTED_WITH']))
            return true;
        return false;
    }

    /**
     * Checks if the current request is POST
     *
     * @return boolean
     */
    public function isPost()
    {
        if ($_SERVER["REQUEST_METHOD"] == "POST")
            return true;
        return false;
    }

    /**
     * Checks if the current request is GET
     *
     * @return boolean
     */
    public function isGet()
    {
        if ($_SERVER["REQUEST_METHOD"] == "GET")
            return true;
        return false;
    }
}

1			<?php
2			/**
3			* DronePHP (http://www.dronephp.com)
4			*
5			* @link http://github.com/Pleets/DronePHP
6			* @copyright Copyright (c) 2016-2018 Pleets. (http://www.pleets.org)
7			* @license http://www.dronephp.com/license
8			* @author Darío Rivera <[email protected]>
9			*/
10
11			namespace Drone\Mvc;
12
13			use Drone\Mvc\Exception;
14
15			/**
16			* AbstractionController class
17			*
18			* This class manages the interaction between models and views
19			*/
20			abstract class AbstractController
21			{
22			use \Drone\Util\ParamTrait;
23
24			/**
25			* Current module instance
26			*
27			* @var AbstractModule
28			*/
29			private $module;
30
31			/**
32			* Current method
33			*
34			* @var string
35			*/
36			private $method = null;
37
38			/**
39			* Layout name
40			*
41			* @var string
42			*/
43			private $layout = "default";
44
45			/**
46			* Terminal mode
47			*
48			* @var boolean
49			*/
50			private $terminal = true;
51
52			/**
53			* Indicates if the controller must show the views
54			*
55			* @var boolean
56			*/
57			private $showView = true;
58
59			/**
60			* Defines method execution
61			*
62			* The only way to stop method execution is executing stopExecution() before execute().
63			*
64			* @var boolean
65			*/
66			private $allowExecution = true;
67
68			/**
69			* Base path
70			*
71			* @var string
72			*/
73			private $basePath;
74
75			/**
76			* Returns the current module instance
77			*
78			* @return AbstractModule
79			*/
80			public function getModule()
81			{
82			return $this->module;
83			}
84
85			/**
86			* Returns the current method
87			*
88			* @return string
89			*/
90			public function getMethod()
91			{
92			return $this->method;
93			}
94
95			/**
96			* Returns the mode of visualization
97			*
98			* @return boolean
99			*/
100			public function getTerminal()
101			{
102			return $this->terminal;
103			}
104
105			/**
106			* Returns the mode of viewing
107			*
108			* @return boolean
109			*/
110			public function getShowView()
111			{
112			return $this->showView;
113			}
114
115			/**
116			* Returns the current layout
117			*
118			* @return string
119			*/
120			public function getLayout()
121			{
122			return $this->layout;
123			}
124
125			/**
126			* Returns the base path
127			*
128			* @return string
129			*/
130			public function getBasePath()
131			{
132			return $this->basePath;
133			}
134
135			/**
136			* Sets the terminal mode
137			*
138			* @param boolean $terminal
139			*
140			* @return null
141			*/
142			public function setTerminal($terminal = true)
143			{
144			$this->terminal = $terminal;
145			}
146
147			/**
148			* Sets the showView parameter
149			*
150			* @param boolean $show
151			*
152			* @return null
153			*/
154			public function setShowView($show = true)
155			{
156			$this->showView = $show;
157			}
158
159			/**
160			* Sets layout name
161			*
162			* @param string $layout
163			*
164			* @return null
165			*/
166			public function setLayout($layout)
167			{
168			$this->layout = $layout;
169			}
170
171			/**
172			* Sets the method attribute
173			*
174			* @param string $method
175			*
176			* @return null
177			*/
178			public function setMethod($method)
179			{
180			$this->method = $method;
181			}
182
183			/**
184			* Constructor
185			*
186			* @param string $basePath
187			*
188			* @throws Exception\PageNotFoundException
189			*/
190			public function __construct($basePath = null)
191			{
192			$this->basePath = $basePath;
193			}
194
195			/**
196			* Creates the module instance
197			*
198			* @param string $module
199			*
200			* @return null
201			*/
202			public function createModuleInstance($module)
203			{
204			if (!is_null($module))
			0 ignored issues – show introduced 2019-03-29 20:11 UTC by Report Bug Copy Issue Report The condition `is_null($module)` is always `false`. Loading history...
205			{
206			/*
207			* Module class instantiation
208			*
209			* Each module must have a class called Module in her namesapce. This class
210			* is initilized here and can change the behavior of a controller using
211			* stopExecution(), setMethod() or other methods.
212			*/
213
214			$fqn_module = "\\" . $module . "\\Module";
215
216			if (!class_exists($fqn_module))
217			throw new Exception\ModuleNotFoundException("The module class '$fqn_module' does not exists!");
218
219			$this->module = new $fqn_module($module, $this);
220			}
221			}
222
223			/**
224			* Executes the controller
225			*
226			* @return null
227			*/
228			public function execute()
229			{
230			$method = $this->method;
231
232			if (is_null($method))
			0 ignored issues – show introduced 2019-03-29 20:11 UTC by Report Bug Copy Issue Report The condition `is_null($method)` is always `false`. Loading history...
233			# This error is thrown because of 'setMethod' method has not been executed
234			throw new \LogicException("No method has been setted to execute!");
235
236			if ($this->allowExecution)
237			{
238			if (method_exists($this, $method))
239			{
240			$class = __CLASS__;
241
242			$reflection = new \ReflectionMethod($this, $method);
243
244			if (!$reflection->isPublic())
245			throw new Exception\PrivateMethodExecutionException("The method '$method' is not public in the control class '$class'");
246
247			# Get the returned value of the method to send to the view
248			$this->params = $this->$method();
249
250			# The only way to manage views is through an AbstractModule
251			if (!is_null($this->module))
252			{
253			$params = $this->getParams();
254
255			$layout_params = (count($params) && array_key_exists('::Layout', $params)) ? $params["::Layout"] : [];
256
257			$layoutManager = new Layout($layout_params);
258			$layoutManager->fromController($this);
259			}
260			}
261			else
262			{
263			$class = __CLASS__;
264			throw new Exception\MethodNotFoundException("The method '$method' doesn't exists in the control class '$class'");
265			}
266			}
267			}
268
269			/**
270			* Stops the execution of the specified method
271			*
272			* The only way to stop method execution before execute()
273			*
274			* @return null
275			*/
276			public function stopExecution()
277			{
278			$this->allowExecution = false;
279			}
280
281			/**
282			* Checks if allowExecution is true
283			*
284			* @return null
285			*/
286			public function executionIsAllowed()
287			{
288			return $this->allowExecution;
			0 ignored issues – show Bug Best Practice introduced 2019-04-01 22:04 UTC by Report Bug Copy Issue Report The expression `return $this->allowExecution` returns the type `boolean` which is incompatible with the documented return type `null`. Loading history...
289			}
290
291			/**
292			* Returns the class name
293			*
294			* @return string
295			*/
296			public static function getClassName()
297			{
298			return __CLASS__;
299			}
300
301			/**
302			* Returns $_POST contents
303			*
304			* @return array
305			*/
306			public function getPost()
307			{
308			if ($_SERVER['REQUEST_METHOD'] == 'POST' && empty($_POST))
309			$_POST = json_decode(file_get_contents('php://input'), true);
310
311			return (array) $_POST;
312			}
313
314			/**
315			* Returns json contents
316			*
317			* @throws LogicException
318			*
319			* @return array
320			*/
321			public function getJson()
322			{
323			if ($_SERVER['REQUEST_METHOD'] != 'JSON')
324			throw new \LogicException("Request method is not JSON");
325
326			$input = file_get_contents('php://input');
327			$array = explode("&", $input);
328
329			$result = [];
330
331			foreach ($array as $value)
332			{
333			$io = explode("=", $value);
334			$result[$io[0]] = $io[1];
335			}
336
337			return $result;
338			}
339
340			/**
341			* Checks if the current request is XmlHttpRequest (AJAX)
342			*
343			* @return boolean
344			*/
345			public function isXmlHttpRequest()
346			{
347			# non standard (HTTP_X_REQUESTED_WITH is not a part of PHP)
348			if (isset($_SERVER['HTTP_X_REQUESTED_WITH']))
349			return true;
350			return false;
351			}
352
353			/**
354			* Checks if the current request is POST
355			*
356			* @return boolean
357			*/
358			public function isPost()
359			{
360			if ($_SERVER["REQUEST_METHOD"] == "POST")
361			return true;
362			return false;
363			}
364
365			/**
366			* Checks if the current request is GET
367			*
368			* @return boolean
369			*/
370			public function isGet()
371			{
372			if ($_SERVER["REQUEST_METHOD"] == "GET")
373			return true;
374			return false;
375			}
376			}

Pleets / dronephp

Push — master ( 6b8118...1ac76f )

AbstractController::executionIsAllowed() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like