Silverback\ApiComponentsBundle\Repository\Core\FileInfoRepository

Complexity

Total Complexity

9

Size/Duplication

Total Lines	58
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
B	findByPathsAndFilters()	0	41	7
A	findOneByPathAndFilter()	0	5	1

<?php

/*
 * This file is part of the Silverback API Components Bundle Project
 *
 * (c) Daniel West <daniel@silverback.is>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Silverback\ApiComponentsBundle\Repository\Core;

use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
use Silverback\ApiComponentsBundle\Entity\Core\FileInfo;

/**
 * @author Daniel West <daniel@silverback.is>
 *
 * @method FileInfo|null find($id, $lockMode = null, $lockVersion = null)
 * @method FileInfo|null findOneBy(array $criteria, array $orderBy = null)
 * @method FileInfo[]    findAll()
 * @method FileInfo[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
 */
class FileInfoRepository extends ServiceEntityRepository
{
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, FileInfo::class);
    }

    /**
     * @return FileInfo[]
     */
    public function findByPathsAndFilters(array $paths, ?array $filters): array
    {
        if (!\count($paths)) {
            return [];
        }

        $queryBuilder = $this->createQueryBuilder('f');
        $expr = $queryBuilder->expr();

        $filterQueries = [];
        if ($filters) {

The expression $filters of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            foreach ($filters as $filterIndex => $filter) {
                if (!$filter) {
                    $filterQueries[] = $expr->isNull('f.filter');
                    continue;
                }
                $filterQueries[] = $expr->eq('f.filter', ':filter_' . $filterIndex);
                $queryBuilder->setParameter(':filter_' . $filterIndex, $filter);
            }
        }

        foreach ($paths as $pathIndex => $path) {
            if ($filterQueries) {
                $queryBuilder
                    ->orWhere(
                        $expr->andX(
                            $expr->eq('f.path', ':path_' . $pathIndex),
                            $expr->orX(...$filterQueries)
                        )
                    );
            } else {
                $queryBuilder
                    ->orWhere(
                        $expr->eq('f.path', ':path_' . $pathIndex)
                    );
            }

            $queryBuilder->setParameter(':path_' . $pathIndex, $path);
        }

        return $queryBuilder->getQuery()->getResult();
    }

    public function findOneByPathAndFilter(string $path, ?string $filter): ?FileInfo
    {
        return $this->findOneBy([
            'path' => $path,
            'filter' => $filter,
        ]);
    }
}