Mezon\Application\CommonApplication

Complexity

Total Complexity

36

Size/Duplication

Total Lines	280
Duplicated Lines	0 %

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	handleException()	0	5	1
A	baseFormatter()	0	12	3
A	result()	0	8	3
A	getActionMessage()	0	15	3
A	getActionMessageCode()	0	3	1
A	setSuccessMessage()	0	3	1
A	setTemplate()	0	3	1
A	setGetVar()	0	4	2
A	getTemplate()	0	3	1
A	noRouteFoundErrorHandler()	0	3	1
A	handleRestException()	0	7	1
B	run()	0	26	7
A	__construct()	0	12	1
A	crossRender()	0	3	1
A	createActionFromJsonConfig()	0	27	4
A	loadActoinsFromConfig()	0	11	5

<?php
namespace Mezon\Application;

use Mezon\HtmlTemplate\HtmlTemplate;
use Mezon\Rest;

/**
 * Class CommonApplication
 *
 * @package Mezon
 * @subpackage CommonApplication
 * @author Dodonov A.A.
 * @version v.1.0 (2019/08/07)
 * @copyright Copyright (c) 2019, aeon.org
 */

/**
 * Common application with any available template
 *
 * To load routes from the config call $this->load_routes_from_config('./conf/routes.json');
 *
 * The format of the *.json config must be like this:
 *
 * [
 * {
 * "route" : "/route1" ,
 * "callback" : "callback1" ,
 * "method" : "POST"
 * } ,
 * {
 * "route" : "/route2" ,
 * "callback" : "callback2" ,
 * "method" : ["GET" , "POST"]
 * }
 * ]
 */
class CommonApplication extends Application
{

    /**
     * Application's template
     *
     * @var HtmlTemplate
     */
    private $template = false;

    /**
     * Constructor
     *
     * @param HtmlTemplate $template
     *            Template
     */
    public function __construct(HtmlTemplate $template)
    {
        parent::__construct();

        $this->template = $template;

        $this->getRouter()->setNoProcessorFoundErrorHandler([
            $this,
            'noRouteFoundErrorHandler'
        ]);

        $this->loadActoinsFromConfig();
    }

    /**
     * Method handles 404 errors
     *
     * @codeCoverageIgnore
     */
    public function noRouteFoundErrorHandler(): void
    {
        $this->redirectTo('/404');
    }

    /**
     * Method renders common parts of all pages.
     *
     * @return array List of common parts.
     */
    public function crossRender(): array
    {
        return [];
    }

    /**
     * Method formats exception object
     *
     * @param \Exception $e
     *            Exception
     * @return object Formatted exception object
     */
    protected function baseFormatter(\Exception $e): object
    {
        $error = new \stdClass();
        $error->message = $e->getMessage();
        $error->code = $e->getCode();
        $error->call_stack = $this->formatCallStack($e);
        if (isset($_SERVER['HTTP_HOST']) && $_SERVER['REQUEST_URI']) {
            $error->host = $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
        } else {
            $error->host = 'undefined';
        }
        return $error;
    }

    /**
     * Method processes exception.
     *
     * @param Rest\Exception $e
     *            RestException object.
     */
    public function handleRestException(Rest\Exception $e): void
    {
        $error = $this->baseFormatter($e);

        $error->httpBody = $e->getHttpBody();

        print('<pre>' . json_encode($error, JSON_PRETTY_PRINT));
    }

    /**
     * Method processes exception.
     *
     * @param \Exception $e
     *            Exception object.
     */
    public function handleException(\Exception $e): void
    {
        $error = $this->baseFormatter($e);

        print('<pre>' . json_encode($error, JSON_PRETTY_PRINT));
    }

    /**
     * Method sets GET parameter as template var
     *
     * @param string $fieldName
     *            name of the GET parameter
     */
    protected function setGetVar(string $fieldName): void
    {
        if (isset($_GET[$fieldName])) {
            $this->template->setPageVar($fieldName, $_GET[$fieldName]);
        }
    }

    /**
     * Running application.
     */
    public function run(): void
    {
        try {
            $callRouteResult = $this->callRoute();

            if (is_array($callRouteResult) === false) {
                throw (new \Exception('Route was not called properly'));
            }

            $result = array_merge($callRouteResult, $this->crossRender());

It seems like $callRouteResult can also be of type null and string and true; however, parameter $array1 of array_merge() does only seem to accept array, maybe add an additional type check?

            if (is_array($result)) {

The condition is_array($result) is always true.

                foreach ($result as $key => $value) {
                    $content = $value instanceof ViewInterface ? $value->render() : $value;

                    $this->template->setPageVar($key, $content);
                }
            }

            $this->setGetVar('redirect-to');

            print($this->template->compile());
        } catch (Rest\Exception $e) {
            $this->handleRestException($e);
        } catch (\Exception $e) {
            $this->handleException($e);
        }
    }

    /**
     * Getting template
     *
     * @return HtmlTemplate Application's template
     * @codeCoverageIgnore
     */
    public function getTemplate(): HtmlTemplate
    {
        return $this->template;
    }

    /**
     * Setting template
     *
     * @param HtmlTemplate $template
     *            Template
     * @codeCoverageIgnore
     */
    public function setTemplate(HtmlTemplate $template): void
    {
        $this->template = $template;
    }

    /**
     * Method returns localized error message by it's key
     *
     * @param string $actionMessageCode
     *            key of the message
     * @return string localized error message by it's key
     */
    protected function getActionMessage(string $actionMessageCode): string
    {
        $classPath = $this->getClassPath();

        if (file_exists($classPath . '/res/action-messages.json')) {
            $messages = json_decode(file_get_contents($classPath . '/res/action-messages.json'), true);

            if (isset($messages[$actionMessageCode])) {
                return $messages[$actionMessageCode];
            } else {
                throw (new \Exception('The message with locator "' . $actionMessageCode . '" was not found', - 1));
            }
        }

        return '';
    }

    /**
     * Method returns action-message or '' if not set
     *
     * @return string
     */
    protected function getActionMessageCode(): string
    {
        return $_GET['action-message'] ?? '';
    }

    /**
     * Method sets message variable
     *
     * @param string $actionMessageCode
     *            message code
     */
    protected function setSuccessMessage(string $actionMessageCode): void
    {
        $this->getTemplate()->setPageVar('action-message', $this->getActionMessage($actionMessageCode));
    }

    /**
     * Method compiles result record
     *
     * @param mixed $presenter
     *            main area presenter
     * @return array result record
     */
    public function result($presenter = null): void
    {
        if ($presenter !== null) {
            $presenter->run();
        }

        if ($actionMessage = $this->getActionMessageCode()) {
            $this->setSuccessMessage($actionMessage);
        }
    }

    /**
     * Method creates action from JSON config
     *
     * @param string $path
     *            path to JSON config
     */
    private function createActionFromJsonConfig(string $path): void
    {
        $method = 'action' . basename($path, '.json');

        $this->$method = function () use ($path): array {
            $result = [];
            $views = [];
            $presenter = null;
            $config = json_decode(file_get_contents($path), true);

            foreach ($config as $key => $value) {
                if (is_string($value)) {
                    $result[$key] = $value;
                } elseif ($key === 'presenter') {
                    $presenter = new $value['class'](
                        $views[$value['view']],
                        $value['name'],
                        $this->getRequestParamsFetcher());
                } else {
                    $views[$key] = new $value['class']($this->getTemplate(), $value['name']);
                    $result[$value['placeholder']] = $views[$key];
                }
            }

            $this->result($presenter);

            return $result;
        };
    }

    /**
     * Method loads all actions from ./actions directory
     */
    private function loadActoinsFromConfig(): void
    {
        $classPath = $this->getClassPath();

        if (file_exists($classPath . '/actions')) {
            $files = scandir($classPath . '/actions');

            foreach ($files as $file) {
                if (is_file($classPath . '/actions/' . $file)) {
                    if (strpos($file, '.json') !== false) {
                        $this->createActionFromJsonConfig($classPath . '/actions/' . $file);
                    }
                }
            }
        }
    }
}