Jaxon\Request\Plugin\CallableFunction

Complexity

Total Complexity

24

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	3
A	getName()	0	4	1
A	getTarget()	0	8	2
B	register()	0	49	8
A	generateHash()	0	4	1
A	getScript()	0	11	2
A	canProcessRequest()	0	9	3
A	processRequest()	0	25	4

<?php

/**
 * CallableFunction.php - Jaxon user function plugin
 *
 * This class registers user defined functions, generates client side javascript code,
 * and calls them on user request
 *
 * @package jaxon-core
 * @author Jared White
 * @author J. Max Wilson
 * @author Joseph Woolley
 * @author Steffen Konerow
 * @author Thierry Feuzeu <thierry.feuzeu@gmail.com>
 * @copyright Copyright (c) 2005-2007 by Jared White & J. Max Wilson
 * @copyright Copyright (c) 2008-2010 by Joseph Woolley, Steffen Konerow, Jared White  & J. Max Wilson
 * @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
 */

namespace Jaxon\Request\Plugin;

use Jaxon\Jaxon;
use Jaxon\Plugin\Request as RequestPlugin;
use Jaxon\Request\Target;

class CallableFunction extends RequestPlugin
{
    use \Jaxon\Features\Validator;
    use \Jaxon\Features\Translator;

    /**
     * The registered user functions names
     *
     * @var array
     */
    protected $aFunctions = [];

    /**
     * The name of the function that is being requested (during the request processing phase)
     *
     * @var string
     */
    protected $sRequestedFunction = null;

    /**
     * The constructor
     */
    public function __construct()
    {
        if(isset($_GET['jxnfun']))
        {
            $this->sRequestedFunction = $_GET['jxnfun'];
        }
        if(isset($_POST['jxnfun']))
        {
            $this->sRequestedFunction = $_POST['jxnfun'];
        }
    }

    /**
     * Return the name of this plugin
     *
     * @return string
     */
    public function getName()
    {
        return Jaxon::CALLABLE_FUNCTION;
    }

    /**
     * Return the target function
     *
     * @return Target|null
     */
    public function getTarget()
    {
        if(!$this->sRequestedFunction)
        {
            return null;
        }
        return Target::makeFunction($this->sRequestedFunction);
    }

    /**
     * Register a user defined function
     *
     * @param string        $sType          The type of request handler being registered
     * @param string        $sCallableFunction  The name of the function being registered
     * @param array|string  $aOptions       The associated options
     *
     * @return \Jaxon\Request\Request
     */
    public function register($sType, $sCallableFunction, $aOptions)
    {
        $sType = trim($sType);
        if($sType != $this->getName())
        {
            return false;
        }

        if(!is_string($sCallableFunction))
        {
            throw new \Jaxon\Exception\Error($this->trans('errors.functions.invalid-declaration'));
        }

        if(is_string($aOptions))
        {
            $aOptions = ['include' => $aOptions];
        }
        if(!is_array($aOptions))
        {
            throw new \Jaxon\Exception\Error($this->trans('errors.functions.invalid-declaration'));
        }

        $sCallableFunction = trim($sCallableFunction);
        // Check if an alias is defined
        $sFunctionName = $sCallableFunction;
        foreach($aOptions as $sName => $sValue)
        {
            if($sName == 'alias')
            {
                $sFunctionName = $sValue;
                break;
            }
        }

        $this->aFunctions[$sFunctionName] = $aOptions;
        jaxon()->di()->set($sFunctionName, function () use ($sFunctionName, $sCallableFunction) {

function () use($sFunctionName, $sCallableFunction) { $xCallableFunction = new \Jaxon\Request\Support\CallableFunction($sCallableFunction); $aOptions = $this->aFunctions[$sFunctionName]; foreach ($aOptions as $sName => $sValue) { $xCallableFunction->configure($sName, $sValue); } return $xCallableFunction; } is of type object<Closure>, but the function expects a object<Jaxon\Utils\DI\Closure>.

            $xCallableFunction = new \Jaxon\Request\Support\CallableFunction($sCallableFunction);

            $aOptions = $this->aFunctions[$sFunctionName];
            foreach($aOptions as $sName => $sValue)
            {
                $xCallableFunction->configure($sName, $sValue);
            }

            return $xCallableFunction;
        });

        return true;
    }

    /**
     * Generate a hash for the registered user functions
     *
     * @return string
     */
    public function generateHash()
    {
        return md5(implode('', $this->aFunctions));
    }

    /**
     * Generate client side javascript code for the registered user functions
     *
     * @return string
     */
    public function getScript()
    {
        $di = jaxon()->di();
        $code = '';
        foreach(array_keys($this->aFunctions) as $sName)
        {
            $xFunction = $di->get($sName);
            $code .= $xFunction->getScript();
        }
        return $code;
    }

    /**
     * Check if this plugin can process the incoming Jaxon request
     *
     * @return boolean
     */
    public function canProcessRequest()
    {
        // Check the validity of the function name
        if(($this->sRequestedFunction) && !$this->validateFunction($this->sRequestedFunction))
        {
            $this->sRequestedFunction = null;
        }
        return ($this->sRequestedFunction != null);
    }

    /**
     * Process the incoming Jaxon request
     *
     * @return boolean
     */
    public function processRequest()
    {
        if(!$this->canProcessRequest())
        {
            return false;
        }

        // Security check: make sure the requested function was registered.
        if(!key_exists($this->sRequestedFunction, $this->aFunctions))
        {
            // Unable to find the requested function
            throw new \Jaxon\Exception\Error($this->trans('errors.functions.invalid',
                ['name' => $this->sRequestedFunction]));
        }

        $di = jaxon()->di();
        $xFunction = $di->get($this->sRequestedFunction);
        $aArgs = $di->getRequestHandler()->processArguments();
        $xResponse = $xFunction->call($aArgs);
        if(($xResponse))
        {
            $di->getResponseManager()->append($xResponse);
        }
        return true;
    }
}