PTS\EndPoint\EndPoint

Complexity

Total Complexity

12

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

0%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	3
A	handle()	0	8	1
A	getParams()	0	6	1
A	getPoint()	0	12	1
	getControllerClass()	0	1	?
A	checkController()	0	6	2
A	checkAction()	0	6	2
A	getAction()	0	6	1
A	getRoute()	0	4	1

<?php
declare(strict_types=1);

namespace PTS\EndPoint;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use PTS\PSR15Routing\Route;

abstract class EndPoint implements RequestHandlerInterface
{
	/** @var string|null */
	protected $controller;
	/** @var string|null */
	protected $action;
	/** @var string */
    protected $prefix = '';

    public function __construct(array $params = [])
    {
        foreach ($params as $name => $param) {
            if (property_exists($this, $name)) {
                $this->{$name} = $param;
            }
        }
    }

    /**
     * @param ServerRequestInterface $request
     *
     * @return ResponseInterface
     * @throws \BadMethodCallException
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
	{
    	$route = $this->getRoute($request);
        $endPoint = $this->getPoint($request);

        $params = $this->getParams($route);
        return $endPoint(...$params);
    }

	/**
	 * Get params from router and remove all protected params (_controller/_action/_other)
	 *
	 * @param Route $route
	 * @return array
	 */
    protected function getParams(Route $route): array
	{
        return array_filter($route->getMatchesParams(), function ($name) {
            return $name[0] !== '_';
        }, ARRAY_FILTER_USE_KEY);
	}

    /**
     * @param ServerRequestInterface $request
     *
     * @return callable
     * @throws \BadMethodCallException
     */
	protected function getPoint(ServerRequestInterface $request) : callable
    {
        $controller = $this->getControllerClass($request);
        $this->checkController($controller);

        $controller = new $controller($request);

        $action = $this->getAction($request) ?? 'index';
        $this->checkAction($controller, $action);

        return [$controller, $action];
    }

    abstract protected function getControllerClass(ServerRequestInterface $request);

	/**
	 * @param string $controller
	 * @throws \BadMethodCallException
	 */
	protected function checkController(string $controller) : void
    {
        if (!class_exists($controller)) {
            throw new \BadMethodCallException('Controller not found');
        }
    }

	/**
	 * @param \object $controller

Should the type for parameter $controller not be object?

	 * @param string $action
	 * @throws \BadMethodCallException
	 */
	protected function checkAction(object $controller, string $action) : void
    {
        if (!method_exists($controller, $action)) {
            throw new \BadMethodCallException('Action not found');
        }
    }

	protected function getAction(ServerRequestInterface $request): ?string
	{
        $route = $this->getRoute($request);
        $matches = $route->getMatchesParams();
		return $matches['_action'] ?? $this->action ?? null;
	}

	protected function getRoute(ServerRequestInterface $request): Route
    {
        return $request->getAttribute('route');
    }
}