WebHemi\Application\ServiceAdapter\AbstractAdapter::invokeMiddleware()

Complexity

Conditions	5
Paths	14

Size

Total Lines	48
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	27
CRAP Score	5

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
	AbstractAdapter::run()	0	1	?
	AbstractAdapter::renderOutput()	0	1	?
	AbstractAdapter::sendOutput()	0	1	?

<?php
/**
 * WebHemi.
 *
 * PHP version 7.1
 *
 * @copyright 2012 - 2018 Gixx-web (http://www.gixx-web.com)
 * @license   https://opensource.org/licenses/MIT The MIT License (MIT)
 *
 * @link      http://www.gixx-web.com
 */
declare(strict_types = 1);

namespace WebHemi\Application\ServiceAdapter;

use Throwable;
use WebHemi\Application\ServiceInterface;
use WebHemi\DependencyInjection\ServiceInterface as DependencyInjectionInterface;
use WebHemi\Http\ResponseInterface;
use WebHemi\Http\ServerRequestInterface;
use WebHemi\Http\ServiceInterface as HttpInterface;
use WebHemi\I18n\ServiceInterface as I18nInterface;

/**
 * Class AbstractAdapter
 */
abstract class AbstractAdapter implements ServiceInterface
{
    /** @var Throwable */
    public $error;
    /** @var DependencyInjectionInterface */
    protected $container;
    /** @var ServerRequestInterface */
    protected $request;
    /** @var ResponseInterface */
    protected $response;
    /** @var I18nInterface */
    protected $i18n;

    /**
     * ServiceAdapter constructor.
     *
     * @param DependencyInjectionInterface $container
     */
    public function __construct(DependencyInjectionInterface $container)
    {
        $this->container = $container;
        /** @var HttpInterface $httpAdapter */
        $httpAdapter = $this->container->get(HttpInterface::class);
        /** @var ServerRequestInterface $request */
        $this->request = $httpAdapter->getRequest();
        /** @var ResponseInterface $response */
        $this->response = $httpAdapter->getResponse();
    }

    /**
     * Starts the session.
     *
     * @return ServiceInterface
     */
    abstract public function initSession() : ServiceInterface;

    /**
     * Initializes the I18n Service.
     *
     * @return ServiceInterface
     */
    public function initInternationalization() : ServiceInterface
    {
        $this->i18n = $this->container->get(I18nInterface::class);

        return $this;
    }

    /**
     * Runs the application. This is where the magic happens.
     * According tho the environment settings this must build up the middleware pipeline and execute it.
     *
     * a Pre-Routing Middleware can be; priority < 0:
     *  - LockCheck - check if the client IP is banned > S102|S403
     *  - Auth - if the user is not logged in, but there's a "Remember me" cookie, then logs in > S102
     *
     * Routing Middleware is fixed (RoutingMiddleware::class); priority = 0:
     *  - A middleware that routes the incoming Request and delegates to the matched middleware. > S102|S404|S405
     *    The RouteResult should be attached to the Request.
     *    If the Routing is not defined explicitly in the pipeline, then it will be injected with priority 0.
     *
     * a Post-Routing Middleware can be; priority between 0 and 100:
     *  - Acl - checks if the given route is available for the client. Also checks the auth > S102|S401|S403
     *  - CacheReader - checks if a suitable response body is cached. > S102|S200
     *
     * Dispatcher Middleware is fixed (DispatcherMiddleware::class); priority = 100:
     *  - A middleware which gets the corresponding Action middleware and applies it > S102
     *    If the Dispatcher is not defined explicitly in the pipeline, then it will be injected with priority 100.
     *    The Dispatcher should not set the response Status Code to 200 to let Post-Dispatchers to be called.
     *
     * a Post-Dispatch Middleware can be; priority > 100:
     *  - CacheWriter - writes response body into DataStorage (DB, File etc.) > S102
     *
     * Final Middleware is fixed (FinalMiddleware:class):
     *  - This middleware behaves a bit differently. It cannot be ordered, it's always the last called middleware:
     *    - when the middleware pipeline reached its end (typically when the Status Code is still 102)
     *    - when one item of the middleware pipeline returns with return response (status code is set to 200|40*|500)
     *    - when during the pipeline process an Exception is thrown.
     *
     * When the middleware pipeline is finished the application prints the header and the output.
     *
     * If a middleware other than the Routing, Dispatcher and Final Middleware has no priority set, it will be
     * considered to have priority = 50.
     *
     * @return ServiceInterface
     */
    abstract public function run() : ServiceInterface;

    /**
     * Renders the response body and sends it to the client.
     *
     * @return void
     *
     * @codeCoverageIgnore - no output for tests
     */
    abstract public function renderOutput() : void;

    /**
     * Sends the response body to the client.
     *
     * @return void
     *
     * @codeCoverageIgnore - no output for tests
     */
    abstract public function sendOutput() : void;
}