Jaxon\Request\Handler\RequestHandler

Complexity

Total Complexity

42

Size/Duplication

Total Lines	378
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
B	_processRequest()	0	47	9
A	__construct()	0	13	1
A	_cleanOutputBuffers()	0	8	2
B	processRequest()	0	42	7
A	getRequestMethod()	0	3	1
A	onError()	0	8	3
A	onAfter()	0	9	3
A	onInvalid()	0	8	3
A	canProcessRequest()	0	28	5
A	processArguments()	0	3	1
A	onBefore()	0	14	4
A	getCallbackManager()	0	3	1
A	onBoot()	0	5	2

<?php

/**
 * RequestHandler.php - Jaxon RequestPlugin Handler
 *
 * This class processes an incoming jaxon request.
 *
 * @package jaxon-core

Package name "jaxon-core" is not valid; consider "Jaxoncore" instead

 * @author Jared White

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author J. Max Wilson

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Joseph Woolley

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Steffen Konerow

Content of the @author tag must be in the form "Display Name <username@example.com>"

 * @author Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @copyright Copyright (c) 2005-2007 by Jared White & J. Max Wilson

@copyright tag must contain a year and the name of the copyright holder

 * @copyright Copyright (c) 2008-2010 by Joseph Woolley, Steffen Konerow, Jared White  & J. Max Wilson

@copyright tag must contain a year and the name of the copyright holder

 * @copyright 2016 Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link https://github.com/jaxon-php/jaxon-core
 */

PHP version not specified

Missing @category tag in file comment

namespace Jaxon\Request\Handler;

use Jaxon\Container\Container;
use Jaxon\Config\ConfigManager;
use Jaxon\Plugin\PluginManager;
use Jaxon\Plugin\RequestPlugin;
use Jaxon\Response\AbstractResponse;
use Jaxon\Response\ResponseManager;
use Jaxon\Response\Plugin\DataBag\DataBagPlugin;
use Jaxon\Exception\RequestException;
use Jaxon\Exception\SetupException;
use Jaxon\Utils\Translation\Translator;

use Exception;

use function call_user_func;
use function call_user_func_array;
use function error_reporting;
use function headers_sent;
use function ob_end_clean;
use function ob_get_level;

class RequestHandler

Missing doc comment for class RequestHandler

{
    /**
     * @var Container
     */
    private $di;

Expected 1 blank line(s) before first member var; 0 found

    /**
     * @var ConfigManager
     */
    protected $xConfigManager;

    /**
     * The plugin manager.
     *
     * @var PluginManager
     */
    private $xPluginManager;

    /**
     * The response manager.
     *
     * @var ResponseManager
     */
    private $xResponseManager;

    /**
     * The argument manager.
     *
     * @var ArgumentManager
     */
    private $xArgumentManager;

    /**
     * The callbacks to run while processing the request
     *
     * @var CallbackManager
     */
    private $xCallbackManager;

    /**
     * @var UploadHandler
     */
    private $xUploadHandler;

    /**
     * The data bag response plugin
     *
     * @var DataBagPlugin
     */
    private $xDataBagPlugin;

    /**
     * @var Translator
     */
    private $xTranslator;

    /**
     * The request plugin that is able to process the current request
     *
     * @var RequestPlugin
     */
    private $xTargetRequestPlugin = null;

    /**
     * The constructor
     *
     * @param Container $di

Missing parameter comment

Expected 10 spaces after parameter type; 1 found

     * @param ConfigManager $xConfigManager

Missing parameter comment

Expected 6 spaces after parameter type; 1 found

     * @param ArgumentManager $xArgument

Missing parameter comment

Expected 4 spaces after parameter type; 1 found

     * @param PluginManager $xPluginManager

Missing parameter comment

Expected 6 spaces after parameter type; 1 found

     * @param ResponseManager $xResponseManager

Missing parameter comment

Expected 4 spaces after parameter type; 1 found

     * @param CallbackManager $xCallbackManager

Missing parameter comment

Expected 4 spaces after parameter type; 1 found

     * @param UploadHandler|null $xUploadHandler

Missing parameter comment

     * @param DataBagPlugin $xDataBagPlugin

Missing parameter comment

Expected 6 spaces after parameter type; 1 found

     * @param Translator $xTranslator

Missing parameter comment

Expected 9 spaces after parameter type; 1 found

     */
    public function __construct(Container $di, ConfigManager $xConfigManager, ArgumentManager $xArgument,

Expected 2 blank lines before function; 1 found

        PluginManager $xPluginManager, ResponseManager $xResponseManager, CallbackManager $xCallbackManager,
        ?UploadHandler $xUploadHandler, DataBagPlugin $xDataBagPlugin, Translator $xTranslator)
    {
        $this->di = $di;

Equals sign not aligned with surrounding assignments; expected 15 spaces but found 1 space

        $this->xConfigManager = $xConfigManager;

Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space

        $this->xPluginManager = $xPluginManager;

Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space

        $this->xResponseManager = $xResponseManager;
        $this->xArgumentManager = $xArgument;
        $this->xCallbackManager = $xCallbackManager;
        $this->xUploadHandler = $xUploadHandler;

Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space

        $this->xDataBagPlugin = $xDataBagPlugin;

Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space

        $this->xTranslator = $xTranslator;

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

    }

Expected 2 blank lines after function; 1 found

    /**
     * Return the method that was used to send the arguments from the client
     *
     * The method is one of: ArgumentManager::METHOD_UNKNOWN, ArgumentManager::METHOD_GET, ArgumentManager::METHOD_POST.
     *
     * @return int
     */
    public function getRequestMethod(): int
    {
        return $this->xArgumentManager->getRequestMethod();
    }

Expected 2 blank lines after function; 1 found

    /**
     * Return the array of arguments that were extracted and parsed from the GET or POST data
     *
     * @return array
     * @throws RequestException
     */
    public function processArguments(): array
    {
        return $this->xArgumentManager->process();
    }

Expected 2 blank lines after function; 1 found

    /**
     * Get the callback handler
     *
     * @return CallbackManager
     */
    public function getCallbackManager(): CallbackManager
    {
        return $this->xCallbackManager;
    }

Expected 2 blank lines after function; 1 found

    /**
     * These callbacks are called whenever an invalid request is processed.
     *
     * @return void
     */
    public function onBoot()
    {
        foreach($this->xCallbackManager->getBootCallbacks() as $xCallback)
        {
            call_user_func($xCallback);
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * These are the pre-request processing callbacks passed to the Jaxon library.
     *
     * @param bool $bEndRequest    If set to true, the request processing is interrupted.

Expected 1 spaces after parameter name; 4 found

     *
     * @return void
     */
    public function onBefore(bool &$bEndRequest)
    {
        $xTarget = $this->xTargetRequestPlugin->getTarget();
        // Call the user defined callback
        foreach($this->xCallbackManager->getBeforeCallbacks() as $xCallback)
        {
            $xReturn = call_user_func_array($xCallback, [$xTarget, &$bEndRequest]);
            if($bEndRequest)
            {
                return;
            }
            if($xReturn instanceof AbstractResponse)
            {
                $this->xResponseManager->append($xReturn);
            }
        }
    }

Expected 2 blank lines after function; 1 found

    /**

Parameter $bEndRequest should have a doc-comment as per coding-style.

     * These are the post-request processing callbacks passed to the Jaxon library.
     *
     * @return void
     */
    public function onAfter(bool $bEndRequest)
    {
        foreach($this->xCallbackManager->getAfterCallbacks() as $xCallback)
        {
            $xReturn = call_user_func_array($xCallback,
                [$this->xTargetRequestPlugin->getTarget(), $bEndRequest]);
            if($xReturn instanceof AbstractResponse)
            {
                $this->xResponseManager->append($xReturn);
            }
        }
    }

Expected 2 blank lines after function; 1 found

    /**

Parameter $sMessage should have a doc-comment as per coding-style.

     * These callbacks are called whenever an invalid request is processed.
     *
     * @return void
     */
    public function onInvalid(string $sMessage)
    {
        foreach($this->xCallbackManager->getInvalidCallbacks() as $xCallback)
        {
            $xReturn = call_user_func($xCallback, $sMessage);
            if($xReturn instanceof AbstractResponse)
            {
                $this->xResponseManager->append($xReturn);
            }
        }
    }

Expected 2 blank lines after function; 1 found

    /**

Parameter $xException should have a doc-comment as per coding-style.

     * These callbacks are called whenever an invalid request is processed.
     *
     * @var Exception $xException
     *
     * @return void
     */
    public function onError(Exception $xException)
    {
        foreach($this->xCallbackManager->getErrorCallbacks() as $xCallback)
        {
            $xReturn = call_user_func($xCallback, $xException);
            if($xReturn instanceof AbstractResponse)
            {
                $this->xResponseManager->append($xReturn);
            }
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * Check if the current request can be processed
     *
     * Calls each of the request plugins and determines if the current request can be processed by one of them.
     *
     * @return bool
     */
    public function canProcessRequest(): bool
    {
        // Return true if the request plugin was already found
        if($this->xTargetRequestPlugin !== null)
        {
            return true;
        }

        // Find a plugin to process the request
        foreach($this->xPluginManager->getRequestPlugins() as $sClassName)
        {
            if($sClassName::canProcessRequest())
            {
                $this->xTargetRequestPlugin = $this->di->get($sClassName);
                return true;
            }
        }

        // Check if the upload plugin is enabled
        if($this->xUploadHandler === null)
        {
            return false;
        }

        // If no other plugin than the upload plugin can process the request,
        // then it is an HTTP (not ajax) upload request
        $this->xUploadHandler->isHttpUpload();
        return $this->xUploadHandler->canProcessRequest();
    }

Expected 2 blank lines after function; 1 found

    /**
     * Process the current request and handle errors and exceptions.
     *
     * @return void
     * @throws RequestException
     * @throws SetupException
     */
    private function _processRequest()
    {
        $bEndRequest = false;
        // Handle before processing event
        if(($this->xTargetRequestPlugin))
        {
            $this->onBefore($bEndRequest);
        }
        if($bEndRequest)
        {
            return;
        }

        try
        {
            // Process uploaded files, if the upload plugin is enabled
            if($this->xUploadHandler !== null)
            {
                $this->xUploadHandler->processRequest();
            }
            // Process the request
            if(($this->xTargetRequestPlugin))
            {
                $this->xTargetRequestPlugin->processRequest();
            }
        }
        catch(Exception $e)
        {
            // An exception was thrown while processing the request.
            // The request missed the corresponding handler function,
            // or an error occurred while attempting to execute the handler.
            $this->xResponseManager->error($e->getMessage());
            if($e instanceof RequestException || $e instanceof SetupException)
            {
                $this->onInvalid($e->getMessage());
            }
            else
            {
                $this->onError($e);
            }
            throw $e;
        }

        // Handle after processing event
        if(($this->xTargetRequestPlugin))
        {
            $this->onAfter($bEndRequest);
        }
    }

Expected 2 blank lines after function; 1 found

    /**
     * Clean output buffers.
     *
     * @return void
     */
    private function _cleanOutputBuffers()
    {
        $er = error_reporting(0);
        while(ob_get_level() > 0)
        {
            ob_end_clean();
        }
        error_reporting($er);
    }

Expected 2 blank lines after function; 1 found

    /**
     * Process the current request.
     *
     * Calls each of the request plugins to request that they process the current request.
     * If any plugin processes the request, it will return true.
     *
     * @return void
     * @throws RequestException
     * @throws SetupException
     */
    public function processRequest()
    {
        // Check to see if headers have already been sent out, in which case we can't do our job
        if(headers_sent($sFilename, $nLineNumber))
        {
            echo $this->xTranslator->trans('errors.output.already-sent', [
                'location' => $sFilename . ':' . $nLineNumber
            ]), "\n", $this->xTranslator->trans('errors.output.advice');
            exit();

Using exit here is not recommended.

        }

        // Check if there is a plugin to process this request
        if(!$this->canProcessRequest())
        {
            return;
        }

        $this->_processRequest();

        // Process the databag
        $this->xDataBagPlugin->writeCommand();

        // Clean the processing buffer
        if(($this->xConfigManager->getOption('core.process.clean')))
        {
            $this->_cleanOutputBuffers();
        }

        // If the called function returned no response, take the global response
        if(!$this->xResponseManager->getResponse())
        {
            $this->xResponseManager->append($this->di->getResponse());
        }

        $this->xResponseManager->printDebug();

        if(($this->xConfigManager->getOption('core.response.send')))
        {
            $this->xResponseManager->sendOutput();
            if(($this->xConfigManager->getOption('core.process.exit')))
            {
                exit();

Using exit here is not recommended.

            }
        }
    }

Expected 2 blank lines after function; 0 found

}