Mezon\Service\ServiceTransport

Complexity

Total Complexity

47

Size/Duplication

Total Lines	423
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	errorResponse()	0	12	2
A	outputException()	0	3	1
A	callRoute()	0	3	1
A	fetchActions()	0	21	3
A	getParam()	0	3	1
A	__construct()	0	9	1
A	handleException()	0	5	1
A	setServiceLogic()	0	3	1
A	getRouter()	0	3	1
A	routeExists()	0	3	1
A	loadRoute()	0	12	5
A	die()	0	3	1
A	formatCallStack()	0	10	4
A	getParamsFetcher()	0	7	2
A	loadRoutesFromConfig()	0	8	2
A	callPublicLogic()	0	12	2
A	setParamsFetcher()	0	3	1
A	isDebug()	0	3	2
A	run()	0	10	3
A	addRoute()	0	18	2
A	loadRoutes()	0	4	2
A	getNecessaryLogic()	0	20	6
A	callLogic()	0	12	2

<?php
namespace Mezon\Service;
// TODO exclude it in separate package

/**
 * Base class for all transports
 *
 * @package Service
 * @subpackage ServiceTransport
 * @author Dodonov A.A.
 * @version v.1.0 (2019/08/17)
 * @copyright Copyright (c) 2019, aeon.org
 */

/**
 * Base class for all transports
 *
 * @author Dodonov A.A.
 */
abstract class ServiceTransport implements \Mezon\Service\ServiceTransportInterface
{

    /**
     * Request params fetcher
     *
     * @var \Mezon\Service\ServiceRequestParamsInterface
     */
    private $paramsFetcher = false;

    /**
     * Service's logic
     *
     * @var \Mezon\Service\ServiceLogic
     */
    private $serviceLogic = false;

    /**
     * Router
     *
     * @var \Mezon\Router\Router
     */
    private $router = false;

    /**
     * Constructor
     */
    public function __construct()
    {
        $this->router = new \Mezon\Router\Router();

        $this->router->setNoProcessorFoundErrorHandler(
            function (string $route) {
                $exception = new \Exception('Route ' . $route . ' was not found', - 1);

                $this->handleException($exception);
            });
    }

    /**
     * Method searches necessary logic object
     *
     * @param string $method
     *            Necessary method
     * @return \Mezon\Service\ServiceBaseLogicInterface Logic object
     */
    protected function getNecessaryLogic(string $method): \Mezon\Service\ServiceBaseLogicInterface
    {
        if (is_object($this->serviceLogic)) {
            if (method_exists($this->serviceLogic, $method)) {
                return $this->serviceLogic;
            } else {
                throw (new \Exception(
                    'The method "' . $method . '" was not found in the "' . get_class($this->serviceLogic) . '"',
                    - 1));
            }
        } elseif (is_array($this->serviceLogic)) {
            foreach ($this->serviceLogic as $logic) {
                if (method_exists($logic, $method)) {
                    return $logic;
                }
            }

            throw (new \Exception('The method "' . $method . '" was not found in the set of logic objects', - 1));
        } else {
            throw (new \Exception('Logic was not found', - 2));
        }
        // @codeCoverageIgnoreStart
    }

    // @codeCoverageIgnoreEnd

    /**
     * Method creates session
     *
     * @param bool|string $token
     *            Session token
     */
    public abstract function createSession(string $token): string;

    /**
     * Method adds's route
     *
     * @param string $route
     *            Route
     * @param string $callback
     *            Logic method to be called
     * @param string|array $requestMethod
     *            HTTP request method
     * @param string $callType
     *            Type of the call
     */
    public function addRoute(string $route, string $callback, $requestMethod, string $callType = 'callLogic'): void
    {
        $localServiceLogic = $this->getNecessaryLogic($callback);

        if ($callType == 'public_call') {
            $this->router->addRoute(
                $route,
                function () use ($localServiceLogic, $callback) {
                    return $this->callPublicLogic($localServiceLogic, $callback, []);
                },
                $requestMethod);

It seems like $requestMethod can also be of type array; however, parameter $requestMethod of Mezon\Router\Router::addRoute() does only seem to accept string, maybe add an additional type check?

        } else {
            $this->router->addRoute(
                $route,
                function () use ($localServiceLogic, $callback) {
                    return $this->callLogic($localServiceLogic, $callback, []);
                },
                $requestMethod);
        }
    }

    /**
     * Method loads single route
     *
     * @param array $route
     *            Route description
     */
    public function loadRoute(array $route): void
    {
        if (! isset($route['route'])) {
            throw (new \Exception('Field "route" must be set'));
        }
        if (! isset($route['callback'])) {
            throw (new \Exception('Field "callback" must be set'));
        }
        $method = isset($route['method']) ? $route['method'] : 'GET';
        $callType = isset($route['call_type']) ? $route['call_type'] : 'callLogic';

        $this->addRoute($route['route'], $route['callback'], $method, $callType);
    }

    /**
     * Method loads routes
     *
     * @param array $routes
     *            Route descriptions
     */
    public function loadRoutes(array $routes): void
    {
        foreach ($routes as $route) {
            $this->loadRoute($route);
        }
    }

    /**
     * Method loads routes from config file
     *
     * @param string $path
     *            Path to the routes description
     */
    public function loadRoutesFromConfig(string $path = './conf/routes.php')
    {
        if (file_exists($path)) {
            $routes = (include ($path));

            $this->loadRoutes($routes);
        } else {
            throw (new \Exception('Route ' . $path . ' was not found', 1));
        }
    }

    /**
     * Method runs logic functions
     *
     * @param \Mezon\Service\ServiceLogic $serviceLogic
     *            object with all service logic
     * @param string $method
     *            Logic's method to be executed
     * @param array $params
     *            Logic's parameters
     * @return mixed Result of the called method
     */
    public function callLogic(\Mezon\Service\ServiceBaseLogicInterface $serviceLogic, string $method, array $params = [])
    {
        try {
            $params['SessionId'] = $this->createSession($this->getParamsFetcher()
                ->getParam('session_id'));

            return call_user_func_array([
                $serviceLogic,
                $method
            ], $params);
        } catch (\Exception $e) {
            return $this->errorResponse($e);
        }
    }

    /**
     * Method runs logic functions
     *
     * @param \Mezon\Service\ServiceBaseLogicInterface $serviceLogic
     *            object with all service logic
     * @param string $method
     *            Logic's method to be executed
     * @param array $params
     *            Logic's parameters
     * @return mixed Result of the called method
     */
    public function callPublicLogic(
        \Mezon\Service\ServiceBaseLogicInterface $serviceLogic,
        string $method,
        array $params = [])
    {
        try {
            return call_user_func_array([
                $serviceLogic,
                $method
            ], $params);
        } catch (\Exception $e) {
            return $this->errorResponse($e);
        }
    }

    /**
     * Method returns true if the debug omde is ON
     */
    protected function isDebug(): bool
    {
        return defined('MEZON_DEBUG') && MEZON_DEBUG === true;
    }

    /**
     * Error response compilator
     *
     * @param mixed $e
     *            Exception object
     * @return array Error data
     */
    public function errorResponse($e): array
    {
        $result = [
            'message' => $e->getMessage(),
            'code' => $e->getCode()
        ];

        if ($this->isDebug()) {
            $result['call_stack'] = $this->formatCallStack($e);
        }

        return $result;
    }

    /**
     * Method returns parameter
     *
     * @param string $param
     *            Parameter name
     * @param mixed $default
     *            Default value
     * @return string Parameter value
     */
    public function getParam(string $param, $default = false)
    {
        return $this->getParamsFetcher()->getParam($param, $default);
    }

    /**
     * Formatting call stack
     *
     * @param mixed $e
     *            Exception object
     * @return array Call stack
     */
    protected function formatCallStack($e): array
    {
        $stack = $e->getTrace();

        foreach ($stack as $i => $call) {
            $stack[$i] = (@$call['file'] == '' ? 'lambda : ' : @$call['file'] . ' (' . $call['line'] . ') : ') .
                (@$call['class'] == '' ? '' : $call['class'] . '->') . $call['function'];
        }

        return $stack;
    }

    /**
     * Method runs router
     *
     * @codeCoverageIgnore
     */
    public function run(): void
    {
        try {
            if (isset($_GET['r']) === false) {
                throw (new \Exception('Route name was not found in $_GET[\'r\']'));
            }

            $this->callRoute();
        } catch (\Exception $e) {
            $this->handleException($e);
        }
    }

    /**
     * Method calls route in transport specific way
     */
    protected function callRoute(): void
    {
        print($this->router->callRoute($_GET['r']));

Are you sure $this->router->callRoute($_GET['r']) of type false|mixed|string can be used in print()?

    }

    /**
     * Method kills execution thread
     * @codeCoverageIgnore
     */
    protected function die(): void
    {
        die(0);

Using exit here is not recommended.

    }

    /**
     * Method outputs exception data
     *
     * @param array $e
     */
    public function outputException(array $e): void
    {
        print(json_encode($e));
    }

    /**
     * Method processes exception
     *
     * @param \Exception $e
     *            Exception object
     * @codeCoverageIgnore
     */
    public function handleException($e): void
    {
        $this->outputException($this->errorResponse($e));

        $this->die();
    }

    /**
     * Method fetches actions for routes
     *
     * @param \Mezon\Service\ServiceBaseLogicInterface $actionsSource
     *            Source of actions
     */
    public function fetchActions(\Mezon\Service\ServiceBaseLogicInterface $actionsSource): void
    {
        $methods = get_class_methods($actionsSource);

        foreach ($methods as $method) {
            if (strpos($method, 'action') === 0) {
                $route = \Mezon\Router\Utils::convertMethodNameToRoute($method);

                $this->router->addRoute(
                    $route,
                    function () use ($actionsSource, $method) {
                        return $this->callPublicLogic($actionsSource, $method, []);
                    },
                    'GET');

                $this->router->addRoute(
                    $route,
                    function () use ($actionsSource, $method) {
                        return $this->callPublicLogic($actionsSource, $method, []);
                    },
                    'POST');
            }
        }
    }

    /**
     * Method constructs request data fetcher
     *
     * @return \Mezon\Service\ServiceRequestParamsInterface Request data fetcher
     */
    public function getParamsFetcher(): \Mezon\Service\ServiceRequestParamsInterface
    {
        if ($this->paramsFetcher !== false) {

The condition $this->paramsFetcher !== false is always true.

            return $this->paramsFetcher;
        }

        return $this->paramsFetcher = $this->createFetcher();
    }

    /**
     * Method constructs request data fetcher
     *
     * @param \Mezon\Service\ServiceRequestParamsInterface $paramsFetcher
     *            Request data fetcher
     */
    public function setParamsFetcher(\Mezon\Service\ServiceRequestParamsInterface $paramsFetcher): void
    {
        $this->paramsFetcher = $paramsFetcher;
    }

    /**
     * Method returns true if the router exists
     *
     * @param string $route
     *            checking route
     * @return bool true if the router exists, false otherwise
     */
    public function routeExists(string $route): bool
    {
        return $this->router->routeExists($route);
    }

    /**
     * Method returns router
     *
     * @return \Mezon\Router\Router router
     */
    public function &getRouter(): \Mezon\Router\Router
    {
        return $this->router;
    }

    /**
     * Method sets service logic
     *
     * @param
     *            array|\Mezon\Service\ServiceBaseLogicInterface base logic object or array
     */
    public function setServiceLogic($serviceLogic): void
    {
        $this->serviceLogic = $serviceLogic;
    }
}