Kelemen\ApiNette\Api

Complexity

Total Complexity

16

Size/Duplication

Total Lines	167
Duplicated Lines	7.19 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

53.06%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	2
A	add()	0	4	1
A	get()	0	4	1
A	post()	0	4	1
A	put()	0	4	1
A	patch()	0	4	1
A	delete()	0	4	1
A	options()	0	4	1
A	run()	0	21	4
A	getFromContainer()	12	12	3

<?php

namespace Kelemen\ApiNette;

use Kelemen\ApiNette\Exception\HandlerException;
use Kelemen\ApiNette\Route\RouteResolverInterface;
use Kelemen\ApiNette\Route\Route;
use Kelemen\ApiNette\Route\RouteContainer;
use Kelemen\ApiNette\Validator\Input\CustomInput;
use Kelemen\ApiNette\Validator\Validator;
use Kelemen\ApiNette\Validator\ValidatorInterface;
use Nette\DI\Container;
use Nette\DI\MissingServiceException;
use Nette\Http\IResponse;
use Nette\Http\Request;
use Nette\Http\Response;
use Kelemen\ApiNette\Response\JsonApiResponse;

class Api
{
    /** @var RouteResolverInterface */
    private $routeResolver;

    /** @var RouteContainer */
    private $routes;

    /** @var Request */
    private $request;

    /** @var Response */
    private $response;

    /** @var Container */
    private $container;

    /** @var Validator */
    private $validator;

    /**
     * @param RouteResolverInterface $routeResolver
     * @param Request $request
     * @param Response $response
     * @param Container $container
     * @param ValidatorInterface $validator
     */
    public function __construct(
        RouteResolverInterface $routeResolver,
        Request $request,
        Response $response,
        Container $container,
        ValidatorInterface $validator = null
    ) {
        $this->routeResolver = $routeResolver;
        $this->request = $request;
        $this->response = $response;
        $this->container = $container;
        $this->validator = $validator ?: new Validator();

$validator ?: new \Kelemen\ApiNette\Validator\Validator() is of type object<Kelemen\ApiNette\Validator\ValidatorInterface>, but the property $validator was declared to be of type object<Kelemen\ApiNette\Validator\Validator>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        $this->routes = new RouteContainer();
    }

    /**
     * Add api call
     * @param string $method
     * @param string $pattern
     * @param string $handler
     * @param array $params
     */
    public function add($method, $pattern, $handler, $params = [])
    {
        $this->routes->add(new Route($method, $pattern, $handler, $params));
    }

    /**
     * Add get api call
     * @param string $pattern
     * @param string $handler
     * @param array $params
     */
    public function get($pattern, $handler, $params = [])
    {
        $this->add('get', $pattern, $handler, $params);
    }

    /**
     * Add post api call
     * @param string $pattern
     * @param string $handler
     * @param array $params
     */
    public function post($pattern, $handler, $params = [])
    {
        $this->add('post', $pattern, $handler, $params);
    }

    /**
     * Add put api call
     * @param string $pattern
     * @param string $handler
     * @param array $params
     */
    public function put($pattern, $handler, $params = [])
    {
        $this->add('put', $pattern, $handler, $params);
    }

    /**
     * Add patch api call
     * @param string $pattern
     * @param string $handler
     * @param array $params
     */
    public function patch($pattern, $handler, $params = [])
    {
        $this->add('patch', $pattern, $handler, $params);
    }

    /**
     * Add delete api call
     * @param string $pattern
     * @param string $handler
     * @param array $params
     */
    public function delete($pattern, $handler, $params = [])
    {
        $this->add('delete', $pattern, $handler, $params);
    }

    /**
     * Add options api call
     * @param string $pattern
     * @param string $handler
     * @param array $params
     */
    public function options($pattern, $handler, $params = [])
    {
        $this->add('options', $pattern, $handler, $params);
    }

    /**
     * Run api
     * @param string $url
     * @return JsonApiResponse
     * @throws Exception\ValidatorException
     * @throws HandlerException
     */
    public function run($url)
    {
        $resolvedRoute = $this->routeResolver->resolve($this->routes, $url);
        if (!$resolvedRoute) {
            return new JsonApiResponse(IResponse::S400_BAD_REQUEST, ['error' => 'Unresolved api route']);
        }

        $handler = $this->getFromContainer($resolvedRoute->getRoute()->getHandler());
        if (!$handler) {
            throw new HandlerException('Handler ' . $resolvedRoute->getRoute()->getHandler() . ' not found in container');
        }

        $this->validator->setInput('path', new CustomInput($resolvedRoute->getParams()));
        $this->validator->validate($handler->validate());
        $handler->setValidatedValues($this->validator->getValues());

        $middleware = $resolvedRoute->getRoute()->getConfig('middleware');
        $runner = new Runner($middleware ?: [], $handler, $this->container);
        $response = $runner($this->request, $this->response);
        return $response;
    }

    /**
     * Get service by type or name from container
     * @param string $entry
     * @return bool|object
     */
    private function getFromContainer($entry)

This method seems to be duplicated in your project.

    {
        try {
            if (substr($entry, 0, 1) === '#') {
                return $this->container->getService(substr($entry, 1));
            }

            return $this->container->getByType($entry);
        } catch (MissingServiceException $e) {
            return false;
        }
    }
}