Xiidea\EasyConfigBundle\Services\Repository\ConfigRepository

Complexity

Total Complexity

26

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Importance

Changes	3
Bugs	1	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	getConfigurationByUsernameAndGroup()	0	19	1
A	isRecognizedEntity()	0	4	2
A	__construct()	0	4	1
A	removeByKey()	0	7	2
A	getConfigurationValue()	0	9	2
A	getConfigurationByUsernameAndKey()	0	14	1
A	getNormalizedArray()	0	11	3
A	loadAllByGroup()	0	23	3
A	findByKey()	0	3	1
A	save()	0	22	5
A	getValuesByGroupKey()	0	3	1
A	createQueryBuilder()	0	3	1
A	saveMultiple()	0	7	2
A	getValue()	0	3	1

<?php

namespace Xiidea\EasyConfigBundle\Services\Repository;

use Doctrine\ORM\EntityManagerInterface;
use Xiidea\EasyConfigBundle\Exception\UnrecognizedEntityException;
use Xiidea\EasyConfigBundle\Model\BaseConfig;

class ConfigRepository implements ConfigRepositoryInterface
{
    private $repository;

    public function __construct(private EntityManagerInterface $em, private $entityClass)
    {
        $this->isRecognizedEntity($entityClass);
        $this->repository = $em->getRepository($entityClass);
    }

    /**
     * @param $entityClass
     * @return void
     * @throws UnrecognizedEntityException
     */
    private function isRecognizedEntity($entityClass): void
    {
        if (!new $entityClass('') instanceof BaseConfig) {
            throw new UnrecognizedEntityException();
        }
    }

    public function getConfigurationByUsernameAndGroup(string $username, string $groupKey)
    {
        $qb = $this->createQueryBuilder('c');

        return $qb
            ->setCacheable(true)
            ->setCacheRegion('config_group')
            ->where($qb->expr()->like('c.id', ':username'))
            ->setParameter('username', $username.'.'.$groupKey.'.%')
            ->orWhere(
                $qb->expr()->andX(
                    $qb->expr()->like('c.id', ':groupKey'),
                    $qb->expr()->eq('c.isGlobal', ':isGlobal')
                )
            )
            ->setParameter('groupKey', $groupKey.'.%')
            ->setParameter('isGlobal', 1)
            ->getQuery()
            ->getResult();
    }

    public function getConfigurationByUsernameAndKey(string $username, string $key)
    {
        $qb = $this->createQueryBuilder('c');

        return $qb
            ->setCacheable(true)
            ->setCacheRegion('config_key')
            ->where('c.id=:username')
            ->setParameter('username', $username.'.'.$key)
            ->orWhere('c.id=:key')
            ->setParameter('key', $key)
            ->orderBy('c.isGlobal', 'DESC')
            ->getQuery()
            ->getResult();
    }

    private function createQueryBuilder(string $alias)
    {
        return $this->repository->createQueryBuilder($alias);
    }

    public function loadAllByGroup($groupKey, $valueOnly = false, $frontendOnly = false): array
    {
        $qb = $this->createQueryBuilder('c');

        $qb = $qb
            ->where($qb->expr()->like('c.id', ':group_key'))
            ->setCacheable(true)
            ->setCacheRegion('master_entity_region')
            ->setParameter('group_key', $groupKey.'.%');

        if ($frontendOnly) {
            $qb
                ->andWhere($qb->expr()->eq('c.frontend', ':is_frontend'))
                ->setParameter('is_frontend', true);
        }

        $configurations = $qb->getQuery()->getResult();

        if (!$configurations) {
            return [];
        }

        return $this->getNormalizedArray($groupKey, $configurations, $valueOnly);
    }

    private function getNormalizedArray($groupKey, $configurations, $valueOnly): array
    {
        $keyLength = strlen($groupKey) + 1;
        $return = [];

        foreach ($configurations as $configuration) {
            $return[substr($configuration->getId(), $keyLength)] = $valueOnly ? $configuration->getAs(
            ) : $configuration;
        }

        return $return;
    }


    public function getValuesByGroupKey($configurationGroup)
    {
        return array_map([$this, 'getValue'], (array)$this->loadAllByGroup($configurationGroup));
    }

    protected function getValue($configuration)
    {
        return $configuration->getValue();
    }

    public function saveMultiple($baseKey, array $values = [], array $types = [])
    {
        foreach ($values as $key => $value) {
            $this->save($baseKey.".{$key}", $value, isset($types[$key]) ?? $types[$key], false, false, false);
        }

        $this->em->flush();
    }

    /**
     * @param $key
     * @param $value
     * @param $type
     * @param bool $locked
     * @param bool $force
     * @param bool $flush
     * @return BaseConfig
     */
    public function save($key, $value, $type = null, bool $locked = false, bool $force = false, bool $flush = true)
    {
        $configuration = $this->repository->find($key);

        if (!$configuration) {
            $configuration = new $this->entityClass($key);
            $configuration->setId($key);
        } elseif ($configuration->isLocked() && !$force) {
            return $configuration;
        }

        $configuration->setValue($value);
        $configuration->setType($type);
        $configuration->setLocked($locked);

        $this->em->persist($configuration);

        if ($flush) {
            $this->em->flush($configuration);

The call to Doctrine\Persistence\ObjectManager::flush() has too many arguments starting with $configuration.

        }

        return $configuration;
    }

    public function removeByKey($key)
    {
        $config = $this->repository->find($key);

        if ($config) {
            $this->em->remove($config);
            $this->em->flush();
        }
    }

    public function getConfigurationValue($key)
    {
        $configuration = $this->repository->find($key);

        if (null == $configuration) {
            return null;
        }

        return $configuration->getValue();
    }

    public function findByKey($key)
    {
        return $this->repository->find($key);
    }
}