Roukmoute\HashidsBundle\ParamConverter\HashidsParamConverter

Complexity

Total Complexity

22

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	allCharsAreInAlphabet()	0	3	1
A	continueWithNextParamConverters()	0	3	1
A	hasHashidDecoded()	0	3	3
A	supports()	0	3	1
A	__construct()	0	6	1
A	decodeHashidOnRoute()	0	14	3
A	apply()	0	9	2
B	decodeArgumentsController()	0	30	8
A	isSkippable()	0	3	2

<?php

declare(strict_types=1);

namespace Roukmoute\HashidsBundle\ParamConverter;

use Hashids\HashidsInterface;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
use Sensio\Bundle\FrameworkExtraBundle\Request\ParamConverter\ParamConverterInterface;
use Symfony\Component\HttpFoundation\Request;

class HashidsParamConverter implements ParamConverterInterface
{
    private string $alphabet;
    private bool $autoConvert;
    private HashidsInterface $hashids;
    private bool $passthrough;

    public function __construct(HashidsInterface $hashids, bool $passthrough, bool $autoConvert, string $alphabet)
    {
        $this->hashids = $hashids;
        $this->passthrough = $passthrough;
        $this->autoConvert = $autoConvert;
        $this->alphabet = $alphabet;
    }

    public function apply(Request $request, ParamConverter $configuration): bool
    {
        $decodedSuccessfuly = $this->decodeHashidOnRoute($request);

        if($decodedSuccessfuly === false) {
            $this->decodeArgumentsController($request, $configuration);
        }

        return $this->continueWithNextParamConverters();
    }

    public function supports(ParamConverter $configuration): bool
    {
        return true;
    }

    private function decodeHashidOnRoute(Request $request): bool
    {
        foreach (['hashid', 'id'] as $item) {
            $hashids = $this->hashids->decode($request->attributes->get($item));
            if ($this->hasHashidDecoded($hashids)) {
                $hashid = current($hashids);

                $request->attributes->remove($item);
                $request->attributes->set('id', $hashid);
                return true;
            }
        }

        return false;
    }

    private function decodeArgumentsController(Request $request, ParamConverter $configuration): void
    {
        $name = $configuration->getName();

        $attributes = array_map(function ($name) {
            return str_replace('_hash_', '', $name);
        }, $request->attributes->keys());

        $hash = null;

        if (in_array($name, $attributes, true)) {
            $hash = $request->attributes->get('_hash_' . $name);
        }

        if (!isset($hash) && $this->autoConvert) {
            $hash = (string) $request->attributes->get($name);
        }

        if ($this->isSkippable($hash)) {
            return;
        }

        $hashids = $this->hashids->decode($hash);

        if ($this->hasHashidDecoded($hashids)) {
            $request->attributes->set($name, current($hashids));
        }

        if (!$this->autoConvert && !$this->hasHashidDecoded($hashids)) {
            throw new \LogicException(sprintf('Unable to decode parameter "%s".', $name));
        }
    }

    private function isSkippable($hash): bool
    {
        return empty($hash) || !$this->allCharsAreInAlphabet($hash);
    }

    private function allCharsAreInAlphabet($hash): bool
    {
        return (bool) preg_match(sprintf('{^[%s]+$}', $this->alphabet), $hash);
    }

    private function hasHashidDecoded($hashids): bool
    {
        return $hashids && is_iterable($hashids) && is_int(reset($hashids));
    }

    private function continueWithNextParamConverters(): bool
    {
        return !$this->passthrough;
    }
}