EntityMiddleware::checkParamForEntity() - Code Metrics - Inspection of "Adding ability to check for entities and pass an e..." - valkyrjaio/valkyrja - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 557937...679e28 )

by Melech

created 2020-10-20 08:07 UTC

EntityMiddleware::checkParamForEntity() A

↳ Parent: EntityMiddleware

Complexity

Conditions	4
Paths	3

Size

Total Lines	16
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
eloc	5
c	1
b	0
f	0
nc	3
nop	4
dl	0
loc	16
rs	10

<?php

declare(strict_types=1);

/*
 * This file is part of the Valkyrja Framework package.
 *
 * (c) Melech Mizrachi <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Valkyrja\Routing\Middleware;

use Valkyrja\Http\Request;
use Valkyrja\Http\Response;
use Valkyrja\ORM\Entity;
use Valkyrja\ORM\ORM;
use Valkyrja\ORM\Repository;
use Valkyrja\Routing\Route;
use Valkyrja\Routing\Support\Abort;
use Valkyrja\Support\Type\Cls;
use Valkyrja\Support\Type\Str;

/**
 * Class EntityMiddleware.
 *
 * @author Melech Mizrachi
 */
class EntityMiddleware extends RouteMiddleware
{
    protected static ORM $orm;

    /**
     * Middleware handler for before a request is dispatched.
     *
     * @param Request $request The request
     *
     * @return Request|Response
     */
    public static function before(Request $request)
    {
        if (($route = self::$route ?? null) && $matches = $route->getMatches()) {
            static::checkParamsForEntities($route, $matches);
        }

        return $request;
    }

    /**
     * Get the ORM repository for a given entity.
     *
     * @param string $entity
     *
     * @return Repository
     */
    protected static function getOrmRepository(string $entity): Repository
    {
        return static::getOrm()->getRepository($entity);
    }

    /**
     * Get the ORM service.
     *
     * @return ORM
     */
    protected static function getOrm(): ORM
    {
        return self::$orm ?? self::$container->getSingleton(ORM::class);
    }

    /**
     * Check route params for entities.
     *
     * @param Route $route   The route
     * @param array $matches The matches
     *
     * @return void
     */
    protected static function checkParamsForEntities(Route $route, array $matches): void
    {
        $params       = $route->getParams() ?? [];
        $dependencies = $route->getDependencies() ?? [];
        $counter      = 0;

        // Iterate through the params
        foreach ($params as $param => $paramValue) {
            $counter++;

            static::checkParamForEntity($param, $dependencies, $matches, $counter);
        }

        $route->setMatches($matches);
        $route->setDependencies($dependencies);
    }

    /**
     * Check a route param for entity.
     *
     * @param string $param             The params
     * @param array  $routeDependencies The route dependencies
     * @param array  $matches           The matches
     * @param int    $counter           The counter
     *
     * @return void
     */
    protected static function checkParamForEntity(
        string $param,
        array &$routeDependencies,
        array &$matches,
        int $counter
    ): void {
        if (! Str::contains($param, '@')) {
            return;
        }

        // Get the class
        [, $class] = explode('@', $param);

        // Check if a param
        if ($class && Cls::inherits($class, Entity::class)) {
            static::checkDependenciesForEntities($param, $routeDependencies, $matches, $class, $counter);
        }
    }

    /**
     * Check dependencies for entities.
     *
     * @param string $param             The params
     * @param array  $routeDependencies The route dependencies
     * @param array  $matches           The matches
     * @param string $class             The entity class
     * @param int    $counter           The counter
     *
     * @return void
     */
    protected static function checkDependenciesForEntities(
        string $param,
        array &$routeDependencies,
        array &$matches,
        string $class,
        int $counter
    ): void {
        $dependencies = [];
        // Set found to false for this param
        $found = false;

        foreach ($routeDependencies as $dependencyKey => $dependency) {
            if (! $found && $class === $dependency) {
                static::findAndSetEntity($class, $param, $matches[$counter]);

                // Set found to true in case another dependency is also the same class
                $found = true;

                continue;
            }

            $dependencies[] = $dependency;
        }

        $routeDependencies = $dependencies;
    }

    /**
     * Find and set an entity.
     *
     * @param string $class The entity class
     * @param string $param The param name
     * @param mixed  $value [optional] The value
     *
     * @return void
     */
    protected static function findAndSetEntity(string $class, string $param, &$value): void
    {
        // Attempt to get the entity from the ORM repository
        $entity = static::findEntity($class, $value);

        if (! $entity) {
            static::entityNotFound($class, $value);
        }

        // Set the entity with the param name as the service id into the container
        self::$container->setSingleton($param, $entity);

        // Replace the route match with this entity
        $value = $entity;
    }

    /**
     * Find an entity.
     *
     * @param string $entity The entity class
     * @param mixed  $value  [optional] The value
     *
     * @return Entity|null
     */
    protected static function findEntity(string $entity, $value): ?Entity
    {
        return static::getOrmRepository($entity)
                     ->findOne($value)
                     ->getOneOrNull();
    }

    /**
     * Do when an entity was not found with the given value.
     *
     * @param string $entity The entity not found
     * @param mixed  $value  [optional] The value used to check for the entity
     *
     * @return void
     */
    protected static function entityNotFound(string $entity, $value): void
    protected static function entityNotFound(string $entity, /** @scrutinizer ignore-unused */ $value): void
    {
        Abort::abort();
    }
}


valkyrjaio / valkyrja

Push — master ( 557937...679e28 )

EntityMiddleware::checkParamForEntity() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like