AbstractEntityService - Code Metrics - polderknowledge/entityservice - Measure and Improve Code Quality continuously with Scrutinizer

AbstractEntityService B
last analyzed 2018-11-02 12:08 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	519
Duplicated Lines	6.74 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

100%

Importance

Changes

Metric	Value
wmc	51
lcom	1
cbo	8
dl	35
loc	519
ccs	173
cts	173
cp	1
rs	7.92
c	0
b	0
f	0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getRepository()	0	4	1
A	getEvent()	0	10	2
A	getEventManager()	0	8	2
A	setEventManager()	0	20	4
B	attach()	35	77	6
A	getEntityServiceName()	0	4	1
A	delete()	0	10	2
A	deleteBy()	0	10	2
A	countBy()	0	10	2
A	find()	0	10	2
A	findAll()	0	8	2
A	findBy()	0	10	2
A	findOneBy()	0	10	2
A	persist()	0	10	2
A	multiPersist()	0	10	2
A	trigger()	0	14	3
A	beginTransaction()	0	11	2
A	commitTransaction()	0	11	2
A	rollbackTransaction()	0	11	2
A	isTransactionEnabled()	0	4	1
A	isRepositoryWritable()	0	4	1
A	isRepositoryReadable()	0	4	1
A	isRepositoryDeletable()	0	4	1
A	createNotDeletableException()	0	7	1
A	createNotReadableException()	0	7	1
A	createNotWritableException()	0	7	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like AbstractEntityService often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use AbstractEntityService, and based on these observations, apply Extract Interface, too.

<?php
/**
 * Polder Knowledge / entityservice (https://polderknowledge.com)
 *
 * @link https://github.com/polderknowledge/entityservice for the canonical source repository
 * @copyright Copyright (c) 2016 Polder Knowledge (https://polderknowledge.com)
 * @license https://github.com/polderknowledge/entityservice/blob/master/LICENSE.md MIT
 */

namespace PolderKnowledge\EntityService;

use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Collections\Criteria;
use PolderKnowledge\EntityService\Event\EntityEvent;
use PolderKnowledge\EntityService\Exception\RuntimeException;
use PolderKnowledge\EntityService\Exception\ServiceException;
use PolderKnowledge\EntityService\Feature\TransactionAwareInterface;
use PolderKnowledge\EntityService\Repository\EntityRepositoryInterface;
use PolderKnowledge\EntityService\Repository\Feature\DeletableInterface;
use PolderKnowledge\EntityService\Repository\Feature\FlushableInterface;
use PolderKnowledge\EntityService\Repository\Feature\ReadableInterface;
use PolderKnowledge\EntityService\Repository\Feature\WritableInterface;
use Traversable;
use Zend\EventManager\AbstractListenerAggregate;
use Zend\EventManager\EventManager;
use Zend\EventManager\EventManagerInterface;

/**
 * Base class for application specific EntityServices. This is a fully event driven class.
 * Each method trigger a method for extendability.
 */
abstract class AbstractEntityService extends AbstractListenerAggregate implements
    EntityServiceInterface,
    TransactionAwareInterface
{
    /**
     * The repository that is used for this entity service.
     *
     * @var EntityRepositoryInterface
     */
    private $repository;

    /**
     * EventManager handling all events triggered by this service
     *
     * @var EventManagerInterface
     */
    private $eventManager;

    /**
     * Initialized Event
     *
     * @var EntityEvent
     */
    private $event;

    /**
     * Initializes a new instance of this class.
     *
     * @param EntityRepositoryInterface $repository The repository that is used to communicate with.
     * @param string $entityClassName The FQCN of the entity.
     * @throws \PolderKnowledge\EntityService\Exception\RuntimeException
     */
    public function __construct(EntityRepositoryInterface $repository, $entityClassName)
    {
        $this->repository = $repository;
        $this->listeners = [];

        $this->getEvent()->setEntityClassName($entityClassName);
    }

    /**
     * Gets the repository that is used by the service.
     *
     * @return EntityRepositoryInterface
     */
    protected function getRepository()
    {
        return $this->repository;
    }

    /**
     * Get the pre initialized event object
     *
     * @return EntityEvent
     */
    protected function getEvent()
    {
        if (null === $this->event) {
            $this->event = $event = new EntityEvent;

            $event->setTarget($this);
        }

        return $this->event;
    }

    /**
     * Will create an EventManager when no EventManager was provided.
     * The returned EventManager is used to handle events triggered by this service instance.
     *
     * @return EventManagerInterface
     */
    public function getEventManager()
    {
        if (null === $this->eventManager) {
            $this->setEventManager(new EventManager);
        }

        return $this->eventManager;
    }

    /**
     * Set the EventManager used by this service instance to handle its events.
     * It will take care of disabling the old EventManager and will subscribe the internal
     * listeners to the new EventManager
     *
     * @param EventManagerInterface $eventManager
     */
    public function setEventManager(EventManagerInterface $eventManager)
    {
        if ($this->eventManager === $eventManager || $eventManager === null) {
            return;
        }

        if ($this->eventManager !== null) {
            $this->detach($this->eventManager);
        }

        $this->eventManager = $eventManager;
        $this->eventManager->addIdentifiers([
            'EntityService',
            'PolderKnowledge\EntityService\Service\EntityService',
            $this->getEntityServiceName(),
            trim($this->getEntityServiceName(), '\\'),
        ]);

        $this->attach($this->eventManager);
    }

    /**
     * {@inheritDoc}
     */
    public function attach(EventManagerInterface $events, $priority = 1)
    {
        $callback = function (EntityEvent $event) {

            $repository = $event->getTarget()->getRepository();

            $event->setResult(call_user_func_array(
                [$repository, $event->getName()],
                $event->getParams()
            ));
        };

        $this->listeners[] = $events->attach('countBy', $callback, 0);
        $this->listeners[] = $events->attach('find', $callback, 0);
        $this->listeners[] = $events->attach('findAll', $callback, 0);
        $this->listeners[] = $events->attach('findBy', $callback, 0);
        $this->listeners[] = $events->attach('findOneBy', $callback, 0);
        $this->listeners[] = $events->attach(
            'delete',
            function (EntityEvent $event) {

                $repository = $event->getTarget()->getRepository();

                call_user_func_array([$repository, 'delete'], $event->getParams());

                if ($repository instanceof FlushableInterface) {
                    $repository->flush();
                }
            },
            0
        );
        $this->listeners[] = $events->attach(
            'deleteBy',
            function (EntityEvent $event) {

                $repository = $event->getTarget()->getRepository();

                call_user_func_array([$repository, 'deleteBy'], $event->getParams());

                if ($repository instanceof FlushableInterface) {
                    $repository->flush();
                }
            },
            0
        );
        $this->listeners[] = $events->attach(
            'persist',
            function (EntityEvent $event) {

                $repository = $event->getTarget()->getRepository();

                call_user_func_array([$repository, 'persist'], $event->getParams());

                if ($repository instanceof FlushableInterface) {
                    $repository->flush();
                }
            },
            0
        );
        $this->listeners[] = $events->attach(
            'multiPersist',
            function (EntityEvent $event) {
                $repository = $event->getTarget()->getRepository();

                $entities = current($event->getParams());

                foreach ($entities as $entity) {
                    call_user_func_array([$repository, 'persist'], [$entity]);
                }

                if ($repository instanceof FlushableInterface) {
                    $repository->flush();
                }
            },
            0
        );

        $this->listeners[] = $events->attach('*', function (EntityEvent $event) {
            $event->disableStoppingOfPropagation();
        }, -1);
    }

    /**
     * Returns the FQCN of the entity handled by this service.
     *
     * @return string
     */
    protected function getEntityServiceName()
    {
        return $this->getEvent()->getEntityClassName();
    }

    /**
     * Deletes the given object from the repository
     *
     * @param object $entity The entity to delete.
     * @return mixed
     * @throws \Zend\EventManager\Exception\InvalidArgumentException
     * @throws \PolderKnowledge\EntityService\Exception\RuntimeException
     */
    public function delete($entity)
    {
        if (!$this->isRepositoryDeletable()) {
            throw $this->createNotDeletableException();
        }

        return $this->trigger(__FUNCTION__, [
            'entity' => $entity,
        ]);
    }

    /**
     * Deletes all objects matching the criteria from the repository
     *
     * @param array|Criteria $criteria The criteria values to match on.
     * @return mixed
     * @throws \Zend\EventManager\Exception\InvalidArgumentException
     * @throws \PolderKnowledge\EntityService\Exception\RuntimeException
     */
    public function deleteBy($criteria)
    {
        if (!$this->isRepositoryDeletable()) {
            throw $this->createNotDeletableException();
        }

        return $this->trigger(__FUNCTION__, [
            'criteria' => $criteria,
        ]);
    }

    /**
     * Count the objects matching the criteria respecting the order, limit and offset.
     *
     * @param array|Criteria $criteria The criteria values to match on.
     * @return int
     * @throws \Zend\EventManager\Exception\InvalidArgumentException
     * @throws \PolderKnowledge\EntityService\Exception\RuntimeException
     */
    public function countBy($criteria)
    {
        if (!$this->isRepositoryReadable()) {
            throw $this->createNotReadableException();
        }

        return $this->trigger(__FUNCTION__, [
            'criteria' => $criteria,
        ]);
    }

    /**
     * Find one object in the repository matching the $id
     *
     * @param mixed $id The id of the entity.
     * @return object|null
     * @throws \Zend\EventManager\Exception\InvalidArgumentException
     * @throws \PolderKnowledge\EntityService\Exception\RuntimeException
     */
    public function find($id)
    {
        if (!$this->isRepositoryReadable()) {
            throw $this->createNotReadableException();
        }

        return $this->trigger(__FUNCTION__, [
            'id' => $id,
        ]);
    }

    /**
     * Finds all entities in the repository.
     *
     * @return array Returns the entities that exist.
     * @throws \Zend\EventManager\Exception\InvalidArgumentException
     * @throws \PolderKnowledge\EntityService\Exception\RuntimeException
     */
    public function findAll()
    {
        if (!$this->isRepositoryReadable()) {
            throw $this->createNotReadableException();
        }

        return $this->trigger(__FUNCTION__, []);
    }

    /**
     * Find one or more objects in the repository matching the criteria respecting the order, limit and offset
     *
     * @param array|Criteria $criteria The array with criteria to search on.
     * @return array
     * @throws \Zend\EventManager\Exception\InvalidArgumentException
     * @throws \PolderKnowledge\EntityService\Exception\RuntimeException
     */
    public function findBy($criteria)
    {
        if (!$this->isRepositoryReadable()) {
            throw $this->createNotReadableException();
        }

        return $this->trigger(__FUNCTION__, [
            'criteria' => $criteria,
        ]);
    }

    /**
     * Find one object in the repository matching the criteria
     *
     * @param array|Criteria $criteria The criteria values to match on.
     * @return object|null
     * @throws \Zend\EventManager\Exception\InvalidArgumentException
     * @throws \PolderKnowledge\EntityService\Exception\RuntimeException
     */
    public function findOneBy($criteria)
    {
        if (!$this->isRepositoryReadable()) {
            throw $this->createNotReadableException();
        }

        return $this->trigger(__FUNCTION__, [
            'criteria' => $criteria,
        ]);
    }

    /**
     * Persist the given entity
     *
     * @param object $entity
     * @return mixed
     * @throws \Zend\EventManager\Exception\InvalidArgumentException
     * @throws RuntimeException
     */
    public function persist($entity)
    {
        if (!$this->isRepositoryWritable()) {
            throw $this->createNotWritableException();
        }

        return $this->trigger(__FUNCTION__, [
            'entity' => $entity,
        ]);
    }

    /**
     * Persist the given object and flushes it to the storage device.
     *
     * @param array|Collection|Traversable $entities The entities to persist.
     * @return mixed
     * @throws RuntimeException
     */
    public function multiPersist($entities)
    {
        if (!$this->isRepositoryWritable()) {
            throw $this->createNotWritableException();
        }

        return $this->trigger(__FUNCTION__, [
            'entities' => $entities,
        ]);
    }

    /**
     * will prepare the event object and trigger the event using the internal EventManager
     *
     * @param  string $name
     * @param  array $params
     * @return mixed
     * @throws \Zend\EventManager\Exception\InvalidArgumentException
     * @throws \PolderKnowledge\EntityService\Exception\RuntimeException
     */
    protected function trigger($name, array $params)
    {
        $event = clone $this->getEvent();
        $event->setName($name);
        $event->setParams($params);

        $responseCollection = $this->getEventManager()->triggerEvent($event);

        if ($responseCollection->stopped() && $event->isError()) {
            throw new RuntimeException($event->getError(), $event->getErrorNr());
        }

        return $event->getResult();
    }

    /**
     * Starts a new transaction.
     *
     * @throws ServiceException
     */
    public function beginTransaction()
    {
        if ($this->isTransactionEnabled() === false) {
            throw new ServiceException(sprintf(
                'The repository for %s doesn\'t support Transactions',
                $this->getEntityServiceName()
            ));
        }

        $this->getRepository()->beginTransaction();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
    }

    /**
     * Commits a started transaction.
     *
     * @throws ServiceException
     */
    public function commitTransaction()
    {
        if ($this->isTransactionEnabled() === false) {
            throw new ServiceException(sprintf(
                'The repository for %s doesn\'t support Transactions',
                $this->getEntityServiceName()
            ));
        }

        $this->getRepository()->commitTransaction();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
    }

    /**
     * Rolls back a started transaction.
     *
     * @throws ServiceException
     */
    public function rollbackTransaction()
    {
        if ($this->isTransactionEnabled() === false) {
            throw new ServiceException(sprintf(
                'The repository for %s doesn\'t support Transactions',
                $this->getEntityServiceName()
            ));
        }

        $this->getRepository()->rollbackTransaction();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
    }

    /**
     * Returns true when possible to start an transaction
     */
    public function isTransactionEnabled()
    {
        return $this->getRepository() instanceof TransactionAwareInterface;
    }

    /**
     * Returns true when the repository for $entityName is writable
     *
     * @return bool
     */
    protected function isRepositoryWritable()
    {
        return $this->getRepository() instanceof WritableInterface;
    }

    /**
     * Returns true when the repository for $entityName is readable
     *
     * @return bool
     */
    protected function isRepositoryReadable()
    {
        return $this->getRepository() instanceof ReadableInterface;
    }

    /**
     * Returns true when the repository for $entityName has delete behavior
     *
     * @return bool
     */
    protected function isRepositoryDeletable()
    {
        return $this->getRepository() instanceof DeletableInterface;
    }

    /**
     * Throws an exception for cases where it's not possible to delete from the repository.
     *
     * @throws RuntimeException
     */
    private function createNotDeletableException()
    {
        throw new RuntimeException(sprintf(
            'The entities of type "%s" cannot be deleted from its repository.',
            $this->getEntityServiceName()
        ));
    }

    /**
     * Throws an exception for cases where it's not possible to read from the repository.
     *
     * @throws RuntimeException
     */
    private function createNotReadableException()
    {
        throw new RuntimeException(sprintf(
            'It is not possible to read entities of type "%s" from its repository.',
            $this->getEntityServiceName()
        ));
    }

    /**
     * Throws an exception for cases where it's not possible to write to the repository.
     *
     * @throws RuntimeException
     */
    private function createNotWritableException()
    {
        throw new RuntimeException(sprintf(
            'The entities of type "%s" cannot be written to its repository.',
            $this->getEntityServiceName()
        ));
    }
}


AbstractEntityService B
last analyzed 2018-11-02 12:08 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

27 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

polderknowledge / entityservice

AbstractEntityService B last analyzed 2018-11-02 12:08 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

27 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

AbstractEntityService B
last analyzed 2018-11-02 12:08 UTC