Mado\QueryBundle\Services\IdsChecker

Complexity

Total Complexity

20

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Test Coverage

Coverage

86.27%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	setFiltering()	0	3	1
A	setObjectFilter()	0	3	1
C	validateIds()	0	53	11
A	getFinalFilterIds()	0	3	1
A	setFilterKey()	0	3	1
A	getFilterKey()	0	3	1
A	setLogger()	0	3	1
A	log()	0	4	2
A	__construct()	0	3	1

<?php

namespace Mado\QueryBundle\Services;

use Mado\QueryBundle\Exceptions\ForbiddenContentException;
use Mado\QueryBundle\Objects\Filter;
use Psr\Log\LoggerInterface;

class IdsChecker
{
    private $idsMustBeSubset = true;

    private $filtering;

    private $additionalFilter;

    private $filterKey;

    private $finalFilterIds;

    private $logger;

    public function __construct()
    {
        $this->idsMustBeSubset = true;
    }

    public function setFiltering($filtering)
    {
        $this->filtering = $filtering;
    }

    public function setObjectFilter(Filter $additionalFilter)
    {
        $this->additionalFilter = $additionalFilter;
    }

    public function setFilterKey($filterKey)
    {
        $this->filterKey = $filterKey;
    }

    public function validateIds()
    {
        $rawFilteredIds = $this->additionalFilter->getIds();

        // guard
        $chiave = key($this->filtering);
        $chiaveEsplosa = explode('|' , $chiave);
        if (!isset($chiaveEsplosa[1]) || !in_array($chiaveEsplosa[1], ['list', 'nlist'])) {
            return;
        }

        // check
        foreach ($this->filtering as $key => $queryStringIds) {
            $querystringIds = explode(',', $queryStringIds);
            $additionalFiltersIds = explode(',', $this->additionalFilter->getIds());
            foreach ($querystringIds as $requestedId) {

                // list + list
                if ($this->additionalFilter->getOperator() == 'list') {
                    if (!in_array($requestedId, $additionalFiltersIds)) {
                        throw new ForbiddenContentException(
                            'Oops! Forbidden requested id ' . $requestedId
                            . ' is not available. '
                            . 'Available are ' . join(', ', $additionalFiltersIds) . ''
                        );
                    }
                }

                // list + nlist
                if ($this->additionalFilter->getOperator() == 'nlist') {
                    $queryStringOperator = explode('|', key($this->filtering));

The assignment to $queryStringOperator is dead and can be removed.

                    if (array_intersect($querystringIds, $additionalFiltersIds) == []) {
                        $this->filterKey = str_replace('nlist', 'list', $this->additionalFilter->getRawFilter());
                        $rawFilteredIds = join(',', $querystringIds);
                        $this->idsMustBeSubset = false;
                    }
                }


                // nlist + list

                // nlist + nlist

            }
        }

        $this->finalFilterIds = $rawFilteredIds;

        if (true == $this->idsMustBeSubset) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            foreach ($this->filtering as $key => $queryStringIds) {
                $querystringIds = explode(',', $queryStringIds);
                $additionalFiltersIds = explode(',', $this->additionalFilter->getIds());
                $this->finalFilterIds = join(',', array_intersect($querystringIds, $additionalFiltersIds));
            }
        }
    }

    public function getFilterKey()
    {
        return $this->filterKey;
    }

    public function getFinalFilterIds()
    {
        return $this->finalFilterIds;
    }

    public function setLogger(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    public function log($message)
    {
        if ($this->logger) {
            $this->logger->critical($message);
        }
    }
}