LAG\AdminBundle\Bridge\Doctrine\ORM\DataProvider\ORMDataProvider

Complexity

Total Complexity

22

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
B	getFields()	0	37	9
A	get()	0	17	2
A	getCollection()	0	30	2
A	getRepository()	0	3	1
A	save()	0	4	1
A	create()	0	5	1
A	delete()	0	7	2
A	isJoinColumnNullable()	0	11	3
A	__construct()	0	8	1

<?php

namespace LAG\AdminBundle\Bridge\Doctrine\ORM\DataProvider;

use Doctrine\Common\Persistence\ObjectRepository;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\Mapping\ClassMetadataInfo;
use LAG\AdminBundle\Admin\AdminInterface;
use LAG\AdminBundle\DataProvider\DataProviderInterface;
use LAG\AdminBundle\Event\Events;
use LAG\AdminBundle\Bridge\Doctrine\ORM\Event\ORMFilterEvent;
use LAG\AdminBundle\Exception\Exception;
use LAG\AdminBundle\Field\Definition\FieldDefinition;
use Pagerfanta\Adapter\DoctrineORMAdapter;
use Pagerfanta\Pagerfanta;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\HttpFoundation\RequestStack;

class ORMDataProvider implements DataProviderInterface
{
    /**
     * @var EntityManagerInterface
     */
    private $entityManager;

    /**
     * @var EventDispatcherInterface
     */
    private $eventDispatcher;

    /**
     * @var RequestStack
     */
    private $requestStack;

    /**
     * DoctrineORMDataProvider constructor.
     *
     * @param EntityManagerInterface $entityManager
     * @param EventDispatcherInterface $eventDispatcher
     * @param RequestStack $requestStack
     */
    public function __construct(
        EntityManagerInterface $entityManager,
        EventDispatcherInterface $eventDispatcher,
        RequestStack $requestStack
    ) {
        $this->entityManager = $entityManager;
        $this->eventDispatcher = $eventDispatcher;
        $this->requestStack = $requestStack;
    }

    /**
     * Load a collection of entities.
     *
     * @param AdminInterface $admin
     * @param array          $filters
     *
     * @return mixed
     */
    public function getCollection(AdminInterface $admin, array $filters = [])
    {
        $adminConfiguration = $admin->getConfiguration();
        $actionConfiguration = $admin->getAction()->getConfiguration();

        // Create a query builder for the configured entity class
        $queryBuilder = $this
            ->getRepository($adminConfiguration->getParameter('entity'))
            ->createQueryBuilder('entity')
        ;

        // Dispatch an event to allow filter alteration on the query builder
        $event = new ORMFilterEvent($queryBuilder, $admin, $filters);
        $this->eventDispatcher->dispatch(Events::DOCTRINE_ORM_FILTER, $event);

        if ('pagerfanta' === $actionConfiguration->getParameter('pager')) {
            $pageParameter = $actionConfiguration->getParameter('page_parameter');
            $request = $this->requestStack->getCurrentRequest();
            $page = (int) $request->get($pageParameter, 1);

            $adapter = new DoctrineORMAdapter($queryBuilder);
            $pager = new Pagerfanta($adapter);
            $pager->setCurrentPage($page);
            $pager->setMaxPerPage($actionConfiguration->getParameter('max_per_page'));
            $entities = $pager;
        } else {
            $entities = $queryBuilder->getQuery()->getResult();
        }

        return $entities;
    }

    /**
     * {@inheritdoc}
     */
    public function get(AdminInterface $admin, string $identifier)
    {
        $class = $admin->getConfiguration()->getParameter('entity');
        $item = $this
            ->getRepository($class)
            ->find($identifier)
        ;

        if (null === $item) {
            throw new Exception(sprintf(
                'Item of class "%s" with identifier "%s" not found.',
                $class,
                $identifier
            ));
        }

        return $item;
    }

    /**
     * {@inheritdoc}
     */
    public function save(AdminInterface $admin): void
    {
        $this->entityManager->persist($admin->getEntities()->first());
        $this->entityManager->flush();
    }

    /**
     * {@inheritdoc}
     */
    public function create(AdminInterface $admin)
    {
        $class = $admin->getConfiguration()->getParameter('entity');

        return new $class();
    }

    /**
     * {@inheritdoc}
     */
    public function delete(AdminInterface $admin): void
    {
        if ($admin->getEntities()->isEmpty()) {
            throw new Exception('The admin "'.$admin->getName().'" has no loaded entity');
        }
        $this->entityManager->remove($admin->getEntities()->first());
        $this->entityManager->flush();
    }

    /**
     * {@inheritdoc}
     */
    public function getFields(AdminInterface $admin): array
    {
        $metadata = $this->entityManager->getClassMetadata($admin->getEntityClass());
        $fieldNames = (array) $metadata->fieldNames;

Accessing fieldNames on the interface Doctrine\Common\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

        $fields = [];

        foreach ($fieldNames as $fieldName) {
            // Remove the primary key field if it's not managed manually
            if (!$metadata->isIdentifierNatural() && in_array($fieldName, $metadata->identifier)) {

The method isIdentifierNatural() does not exist on Doctrine\Common\Persistence\Mapping\ClassMetadata. Did you maybe mean isIdentifier()?

Accessing identifier on the interface Doctrine\Common\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

                continue;
            }
            $mapping = $metadata->getFieldMapping($fieldName);
            $formOptions = [];

            // When a field is defined as nullable in the Doctrine entity configuration, the associated form field
            // should not be required neither
            if (key_exists('nullable', $mapping) && true === $mapping['nullable']) {
                $formOptions['required'] = false;
            }
            $fields[$fieldName] = new FieldDefinition($metadata->getTypeOfField($fieldName), $formOptions);
        }

        foreach ($metadata->associationMappings as $fieldName => $relation) {

Accessing associationMappings on the interface Doctrine\Common\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

            $formOptions = [];
            $formType = 'choice';

            if (ClassMetadataInfo::MANY_TO_MANY === $relation['type']) {
                $formOptions['expanded'] = true;
                $formOptions['multiple'] = true;
            }
            if ($this->isJoinColumnNullable($relation)) {
                $formOptions['required'] = false;
            }
            $fields[$fieldName] = new FieldDefinition($formType, $formOptions);
        }

        return $fields;
    }

    /**
     * @param string $entityClass
     *
     * @return ObjectRepository|EntityRepository
     */
    private function getRepository(string $entityClass)
    {
        return $this->entityManager->getRepository($entityClass);
    }

    private function isJoinColumnNullable(array $relation)
    {
        if (!key_exists('joinColumns', $relation)) {
            return false;
        }

        if (!key_exists('nullable', $relation['joinColumns'])) {
            return false;
        }

        return false === $relation['joinColumns']['nullable'];
    }
}