Starkerxp\StructureBundle\Manager\AbstractManager

Complexity

Total Complexity

17

Size/Duplication

Total Lines	168
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	insert()	0	11	2
A	update()	0	10	2
A	delete()	0	8	2
A	find()	0	4	1
A	findOneBy()	0	4	1
A	findBy()	0	4	1
A	findAll()	0	4	1
A	getRepository()	0	4	1
A	clear()	0	3	1
A	beginTransaction()	0	4	1
A	rollback()	0	5	1
A	flush()	0	6	2

<?php

namespace Starkerxp\StructureBundle\Manager;

use DateTime;
use Doctrine\ORM\EntityManager;

This use statement conflicts with another class in this namespace, Starkerxp\StructureBundle\Manager\EntityManager.

use Doctrine\ORM\EntityRepository;
use Starkerxp\StructureBundle\Entity\Entity;
use Starkerxp\StructureBundle\Manager\Exception\ObjectClassNotAllowedException;

abstract class AbstractManager implements ManagerInterface
{
    /** @var EntityManager */
    protected $entityManager;

    /** @var EntityRepository */
    protected $repository;

    private $modeTransactionnal = false;

    /**
     * @param EntityManager $entityManager
     * @param $entity
     */
    public function __construct(EntityManager $entityManager, $entity)

You have injected the EntityManager via parameter $entityManager. This is generally not recommended as it might get closed and become unusable. Instead, it is recommended to inject the ManagerRegistry and retrieve the EntityManager via getManager() each time you need it.

    {
        $this->entityManager = $entityManager;
        $this->repository = $this->entityManager->getRepository($entity);
    }

    /**
     * @param Entity $object
     *
     * @return Entity|boolean
     *
     * @throws ObjectClassNotAllowedException
     */
    public function insert(Entity $object)
    {
        if (!$this->getSupport($object)) {
            throw new ObjectClassNotAllowedException();
        }
        $object->setCreatedAt(new DateTime());
        $this->entityManager->persist($object);
        $this->flush();

        return $object;
    }

    /**
     * @param Entity $object
     *
     * @return Entity|boolean
     *
     * @throws ObjectClassNotAllowedException
     */
    public function update(Entity $object)
    {
        if (!$this->getSupport($object)) {
            throw new ObjectClassNotAllowedException();
        }
        $object->setUpdatedAt(new DateTime());
        $this->flush();

        return $object;
    }

    /**
     * @param Entity $object
     * @throws ObjectClassNotAllowedException
     */
    public function delete(Entity $object)
    {
        if (!$this->getSupport($object)) {
            throw new ObjectClassNotAllowedException();
        }
        $this->entityManager->remove($object);
        $this->flush();
    }

    /**
     * Finds an entity by its primary key / identifier.
     *
     * @param mixed $id The identifier.
     * @param int|null $lockMode One of the \Doctrine\DBAL\LockMode::* constants
     *                              or NULL if no specific lock mode should be used
     *                              during the search.
     * @param int|null $lockVersion The lock version.
     *
     * @return object|null The entity instance or NULL if the entity can not be found.
     */
    public function find($id, $lockMode = null, $lockVersion = null)
    {
        return $this->repository->find($id, $lockMode, $lockVersion);
    }

    /**
     * Finds a single entity by a set of criteria.
     *
     * @param array $criteria
     * @param array|null $orderBy
     *
     * @return object|null The entity instance or NULL if the entity can not be found.
     */
    public function findOneBy(array $criteria, array $orderBy = null)
    {
        return $this->repository->findOneBy($criteria, $orderBy);
    }

    /**
     * Finds entities by a set of criteria.
     *
     * @param array $criteria
     * @param array|null $orderBy
     * @param int|null $limit
     * @param int|null $offset
     *
     * @return array The objects.
     */
    public function findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
    {
        return $this->repository->findBy($criteria, $orderBy, $limit, $offset);
    }

    /**
     * Finds all entities in the repository.
     *
     * @return array The entities.
     */
    public function findAll()
    {
        return $this->repository->findAll();
    }

    /**
     * @return EntityRepository
     */
    public function getRepository()
    {
        return $this->repository;
    }

    /**
     * Vide l'UnitOfWork de l'entity manager.
     */
    public function clear(){
        $this->entityManager->clear();
    }

    /**
     * Permet de passer en gestion des transations manuelles. (Conseillé par SensioLabs).
     */
    public function beginTransaction(){
        $this->modeTransactionnal = true;
        $this->entityManager->beginTransaction();
    }

    /**
     * Dans le cas d'une gestion des transactions manuelles en cas d'échec on rollback le tout.
     */
    public function rollback(){
        $this->entityManager->rollback();
        $this->entityManager->close();
        $this->modeTransactionnal = false;
    }

    /**
     * Permet de gérer un flush en mode transactions manuelles.
     */
    private function flush(){
        if($this->modeTransactionnal){
            $this->entityManager->commit();
        }
        $this->entityManager->flush();
    }


}

As per coding style, files should not end with a newline character.