CCT\Component\ODMElasticsearch\Repository\RepositoryFactory

Complexity

Total Complexity

6

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	getRepository()	0	26	3
A	create()	0	13	2

<?php

declare(strict_types=1);

namespace CCT\Component\ODMElasticsearch\Repository;

use CCT\Component\ODMElasticsearch\Metadata\ClassMetadata;
use CCT\Component\ODMElasticsearch\Repository\Exception\InvalidArgumentException;
use CCT\Component\ODMElasticsearch\Repository\Exception\NoMetadataConfigException;
use CCT\Component\ODMElasticsearch\Repository\Model\DocumentSupportInterface;
use CCT\Component\ODMElasticsearch\Transformer\DataTransformerInterface;
use Metadata\MetadataFactory;

class RepositoryFactory
{
    /**
     * @var IndexMapping
     */
    protected $indexMapping;

    /**
     * @var DataTransformerInterface
     */
    protected $dataTransformer;

    /**
     * @var array
     */
    protected $repositories;

    /**
     * @var MetadataFactory
     */
    protected $metadataFactory;

    /**
     * RepositoryFactory constructor.
     *
     * @param IndexMapping $indexMapping
     * @param DataTransformerInterface $dataTransformer
     * @param MetadataFactory $metadataFactory
     */
    public function __construct(
        IndexMapping $indexMapping,
        DataTransformerInterface $dataTransformer,
        MetadataFactory $metadataFactory
    ) {
        $this->indexMapping = $indexMapping;
        $this->dataTransformer = $dataTransformer;
        $this->repositories = [];
        $this->metadataFactory = $metadataFactory;
    }

    /**
     * Gets repository for entity class name
     *
     * @param string $entityName the entity class name
     *
     * @return AbstractElasticsearchRepository|mixed
     * @throws \ReflectionException
     * @throws \Exception
     */
    public function getRepository(string $entityName)
    {
        $metadata = $this->metadataFactory->getMetadataForClass($entityName);

        if (null === $metadata) {
            throw new NoMetadataConfigException(
                sprintf('No metadata config was found for "%s"', $entityName)
            );
        }

        /** @var ClassMetadata $classMetadata */
        $classMetadata = $metadata->getRootClassMetadata();

The method getRootClassMetadata() does not exist on Metadata\MergeableClassMetadata.

        $customRepositoryName = $classMetadata->getCustomRepositoryName();

        $class = new \ReflectionClass($entityName);
        if (!$class->implementsInterface(DocumentSupportInterface::class)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Class "%s", does not implement interface "%s"',
                    $entityName,
                    DocumentSupportInterface::class
                )
            );
        }

        return $this->repositories[$entityName] ?? $this->create($entityName, $customRepositoryName);
    }

    /**
     * @param string $entityName
     * @param string|null $customRepositoryName
     *
     * @return AbstractElasticsearchRepository
     *
     * @throws \Exception
     */
    protected function create(string $entityName, string $customRepositoryName = null): AbstractElasticsearchRepository
    {
        if (null === $customRepositoryName) {
            $repository = new ElasticsearchRepository($entityName, $this->indexMapping, $this->dataTransformer);
            $this->repositories[$entityName] = $repository;

            return $repository;
        }

        $repository = new $customRepositoryName($entityName, $this->indexMapping, $this->dataTransformer);
        $this->repositories[$customRepositoryName] = $repository;

        return $repository;
    }
}