Mado\QueryBundle\Services\IdsChecker

Complexity

Total Complexity

22

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	idsAreSubset()	0	3	1
A	setAdditionalFiltersIds()	0	3	1
A	setFiltering()	0	3	1
A	setObjectFilter()	0	3	1
C	validateIds()	0	57	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 $additionalFiltersIds;

    private $objectFilter;

    private $filterKey;

    private $finalFilterIds;

    private $logger;

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

    /** @codeCoverageIgnore */
    public function setLogger(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

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

    public function setAdditionalFiltersIds($additionalFiltersIds)
    {
        $this->additionalFiltersIds = $additionalFiltersIds;
    }

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

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

    public function validateIds()
    {
        //$this->log('Start to check IDS');

        if (!$this->objectFilter) {
            throw new \RuntimeException(
                'Oops! Missing GenericFilter object!!!'
            );
        }

        if (!$this->filtering) {
            throw new \RuntimeException(
                'Oops! Filtering is missing!!!'
            );
        }

        $rawFilteredIds = $this->objectFilter->getIds();

        foreach ($this->filtering as $key => $queryStringIds) {
            $qsIds = explode(',', $queryStringIds);
            $addFilIds = explode(',', $this->additionalFiltersIds);
            foreach ($qsIds as $requestedId) {
                if ($this->objectFilter->getOperator() == 'list') {
                    if (!in_array($requestedId, $addFilIds)) {
                        throw new ForbiddenContentException(
                            'Oops! Forbidden requested id ' . $requestedId
                            . ' is not available. '
                            . 'Available are "' . join(', ', $addFilIds) . '"'
                        );
                    }
                }

                if ($this->objectFilter->getOperator() == 'nlist') {
                    $queryStringOperator = explode('|', key($this->filtering));

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

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

        $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) {
                $qsIds = explode(',', $queryStringIds);
                $addFilIds = explode(',', $this->additionalFiltersIds);
                $this->finalFilterIds = join(',', array_intersect($qsIds, $addFilIds));
            }
        }

        $this->log(var_export([
            'filterKey'      => $this->getFilterKey(),
            'finalFilterIds' => $this->getFinalFilterIds(),
        ], true));
    }

    public function idsAreSubset()
    {
        return $this->idsMustBeSubset;
    }

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

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

    /** @codeCoverageIgnore */
    public function log($message)
    {
        if ($this->logger) {
            $this->logger->debug('[IdsChecker] - ' . $message);
        }
    }
}