Comodojo\Dispatcher\Router\Model

Complexity

Total Complexity

24

Size/Duplication

Total Lines	208
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

72.62%

Importance

Changes	2
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	17	1
A	getTable()	0	5	1
A	setTable()	0	5	1
A	bypassRouting()	0	9	1
A	bypassService()	0	7	1
A	getRoute()	0	5	1
B	route()	0	25	5
B	getServiceInstance()	0	27	3
B	compose()	0	61	7
A	parse()	0	23	3

<?php namespace Comodojo\Dispatcher\Router;

use \Comodojo\Dispatcher\Traits\CacheTrait;
use \Comodojo\Dispatcher\Traits\EventsTrait;
use \Comodojo\Dispatcher\Traits\RequestTrait;
use \Comodojo\Dispatcher\Traits\ResponseTrait;
use \Comodojo\Dispatcher\Traits\ExtraTrait;
use \Comodojo\Dispatcher\Components\AbstractModel;
use \Comodojo\Dispatcher\Request\Model as Request;
use \Comodojo\Dispatcher\Response\Model as Response;
use \Comodojo\Dispatcher\Extra\Model as Extra;
use \Comodojo\Foundation\Base\Configuration;
use \Comodojo\Foundation\Events\Manager as EventsManager;
use \Comodojo\SimpleCache\Manager as SimpleCacheManager;
use \Psr\Log\LoggerInterface;
use \Comodojo\Exception\DispatcherException;
use \Exception;

/**
 * @package     Comodojo Dispatcher
 * @author      Marco Giovinazzi <marco.giovinazzi@comodojo.org>
 * @author      Marco Castiello <marco.castiello@gmail.com>
 * @license     GPL-3.0+
 *
 * LICENSE:
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

class Model extends AbstractModel {

    use CacheTrait;
    use EventsTrait;
    use RequestTrait;
    use ResponseTrait;
    use ExtraTrait;

    protected $bypass_routing = false;
    protected $bypass_service = false;
    protected $table;
    protected $route;

    public function __construct(
        Configuration $configuration,
        LoggerInterface $logger,
        SimpleCacheManager $cache,
        EventsManager $events,
        Extra $extra
    ) {

        parent::__construct($configuration, $logger);

        $this->setCache($cache);
        $this->setExtra($extra);
        $this->setEvents($events);

        $this->setTable(new Table($cache, $this));

    }

    public function getTable() {

        return $this->table;

    }

    public function setTable(Table $table) {

        $this->table = $table;

    }

    public function bypassRouting(Route $route) {

        $this->bypass_routing = true;

        $this->route = $route;

        return $this;

    }

    public function bypassService() {

        $this->bypass_service = true;

        return $this;

    }

    public function getRoute() {

        return $this->route;

    }

    public function route(Request $request) {

        $method = (string) $request->getMethod();

        $methods = $this->configuration->get('allowed-http-methods');

        if ( !empty($methods) && in_array($method, $methods) === false ) {

            throw new DispatcherException("Method not allowed", 0, null, 405, array(
                "Allow" => implode(",",$methods)
            ));

        }

        $this->setRequest($request);

        if ( $this->bypass_routing === false ) {

            if ( !$this->parse() ) throw new DispatcherException("Unable to find a valid route for the specified uri", 0, null, 404);

        }

        return $this->route;

    }

    public function getServiceInstance() {

        $class = $this->route->getClassName();

        if ( class_exists($class) ) {

            // All the route parameters are also added to the query parameters
            foreach ($this->route->getRequestParameters() as $parameter => $value) {
                $this->getRequest()->getQuery()->set($parameter, $value);
            }

            return new $class(
                $this->getConfiguration(),
                $this->getLogger(),
                $this->getCache(),
                $this->getEvents(),
                $this->getRequest(),
                $this,
                $this->getResponse(),
                $this->getExtra()
            );

        }

        return null;

    }

    public function compose(Response $response) {

        $this->setResponse($response);

        if ( is_null($this->route) ) {

            throw new DispatcherException("Route has not been loaded!");

        }

        if ( $this->bypass_service ) {

            return;

        }

        $service = $this->getServiceInstance();

        if ( !is_null($service) ) {

            $result = "";

            $method = (string) $this->getRequest()->getMethod();

            $methods = $service->getImplementedMethods();

            if ( in_array($method, $methods) ) {

                $callable = $service->getMethod($method);

                try {

                    $result = call_user_func([$service, $callable]);

                } catch (DispatcherException $de) {

                    throw $de;

                } catch (Exception $e) {

                    throw new DispatcherException(sprintf("Service '%s' execution failed for method '%s': %s", $this->route->getClassName(), $method, $e->getMessage()), 0, $e, 500);

                }

            } else {

                throw new DispatcherException(sprintf("Service '%s' doesn't implement method '%s'", $this->route->getServiceName(), $method), 0, null, 501, array(
                    "Allow" => implode(",", $methods)
                ));

            }

            $this->getResponse()->getContent()->set($result);

        } else {

            throw new DispatcherException(sprintf("Unable to execute service '%s'", $this->route->getClassName()), 0, null, 500);

        }

    }

    private function parse() {

        $path = $this->getRequest()->route();

        foreach ($this->table->getRoutes() as $regex => $value) {

            // The current uri is checked against all the global regular expressions associated with the routes
            if ( preg_match("/" . $regex . "/", $path, $matches) ) {

                /* If a route is matched, all the bits of the route string are evalued in order to create
                 * new query parameters which will be available for the service class
                 */
                $this->route = $value->path($matches);

                return true;

            }

        }

        return false;

    }

}