Oro\Bundle\AnalyticsBundle\Model\RFMMetricStateManager

Complexity

Total Complexity

21

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
B	resetMetrics()	0	31	6
A	executeResetQuery()	0	23	3
C	scheduleRecalculation()	0	49	11

<?php

namespace Oro\Bundle\AnalyticsBundle\Model;

use JMS\JobQueueBundle\Entity\Job;

use Oro\Bundle\EntityBundle\ORM\DoctrineHelper;
use Oro\Bundle\AnalyticsBundle\Command\CalculateAnalyticsCommand;
use Oro\Bundle\AnalyticsBundle\Entity\RFMMetricCategory;
use Oro\Bundle\ChannelBundle\Entity\Channel;

class RFMMetricStateManager extends StateManager
{
    /**
     * @var string
     */
    protected $interface;

    /**
     * @var string
     */
    protected $channelClass;

    /**
     * @param DoctrineHelper $doctrineHelper
     * @param string         $interface
     * @param string         $channelClass
     */
    public function __construct(DoctrineHelper $doctrineHelper, $interface, $channelClass)
    {
        parent::__construct($doctrineHelper);

        $this->interface    = $interface;
        $this->channelClass = $channelClass;
    }

    /**
     * @param Channel $channel
     */
    public function resetMetrics(Channel $channel = null)
    {
        $criteria = [];

        if ($channel) {
            $criteria = ['id' => $this->doctrineHelper->getSingleEntityIdentifier($channel)];
        }

        /** @var Channel[] $channels */
        $channels = $this->doctrineHelper->getEntityRepository($this->channelClass)->findBy($criteria);

        $channelsByCustomerIdentity = [];
        foreach ($channels as $channel) {
            $customerIdentity = $channel->getCustomerIdentity();

            if (!$customerIdentity) {
                continue;
            }

            if (!in_array($this->interface, class_implements($customerIdentity), true)) {
                continue;
            }

            $channelsByCustomerIdentity[$customerIdentity][] = $this->doctrineHelper
                ->getSingleEntityIdentifier($channel);
        }

        foreach ($channelsByCustomerIdentity as $className => $channelIds) {
            $this->executeResetQuery($className, $channelIds);
        }
    }

    /**
     * @param string $className
     * @param array  $ids
     */
    protected function executeResetQuery($className, $ids)
    {
        if (!$ids) {

The expression $ids of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return;
        }

        $qb = $this->doctrineHelper

It seems like you code against a concrete implementation and not the interface Doctrine\Common\Persistence\ObjectManager as the method createQueryBuilder() does only exist in the following implementations of said interface: Doctrine\ORM\Decorator\EntityManagerDecorator, Doctrine\ORM\EntityManager, Oro\Bundle\EntityBundle\ORM\OroEntityManager, Oro\Bundle\TestFrameworkBundle\Test\Doctrine\ORM\Mocks\EntityManagerMock, Oro\Component\TestUtils\ORM\Mocks\EntityManagerMock.

            ->getEntityManager($className)
            ->createQueryBuilder()
            ->update($className, 'e');

        foreach (RFMMetricCategory::$types as $type) {
            $qb
                ->set(sprintf('e.%s', $type), sprintf(':%s', $type))
                ->setParameter($type, null);
        }

        $qb
            ->where($qb->expr()->in('e.dataChannel', ':dataChannels'))
            ->setParameter('dataChannels', $ids);

        $qb->getQuery()->execute();
    }

    /**
     * @param Channel $channel
     */
    public function scheduleRecalculation(Channel $channel = null)
    {
        if ($channel) {
            $argument = sprintf('--channel=%s', $channel->getId());

            if ($this->isJobRunning($argument)) {
                return;
            }

            $isActiveChannel = $channel->getStatus() === Channel::STATUS_ACTIVE;
            $channelData = $channel->getData();
            $rfmEnabled = !empty($channelData[RFMAwareInterface::RFM_STATE_KEY]);

            if (!$isActiveChannel || !$rfmEnabled) {
                return;
            }
        }

        if ($this->getJob()) {
            return;
        }

        $args = [];
        if ($channel) {
            $argument = sprintf('--channel=%s', $channel->getId());
            $channelJob = $this->getJob($argument);
            if ($channelJob) {

The expression $channelJob of type JMS\JobQueueBundle\Entity\Job[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                return;
            }

            $args = [$argument];
        }

        $job = new Job(CalculateAnalyticsCommand::COMMAND_NAME, $args);
        $em = $this->doctrineHelper->getEntityManager($job);

        if (!$channel) {
            $channelJobs = $this->getJob('--channel');

            if ($channelJobs) {

The expression $channelJobs of type JMS\JobQueueBundle\Entity\Job[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                foreach ($channelJobs as $channelJob) {
                    $em->remove($channelJob);
                }
            }
        }

        $em->persist($job);
        $em->flush($job);
    }
}