ActivityListener::onFlush() - Code Metrics - Inspection of "Merge remote-tracking branch 'remotes/dev/master'" - orocrm/crm - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 664fb1...60ffba )

unknown
created 2016-10-23 08:47 UTC
ActivityListener::onFlush() C

↳ Parent: ActivityListener
Complexity

Conditions	16
Paths	27
Size

Total Lines	80
Code Lines	55
Duplication

Lines	23
Ratio	28.75 %
Importance

Changes
Metric	Value
dl	23
loc	80
rs	5.0401
c	0
b	0
f	0
cc	16
eloc	55
nc	27
nop	1
How to fix Long Method Complexity

<?php

namespace Oro\Bundle\ActivityContactBundle\EventListener;

use Doctrine\Common\Util\ClassUtils;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Event\OnFlushEventArgs;
use Doctrine\ORM\Event\PostFlushEventArgs;

use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;

use Oro\Bundle\ActivityBundle\Event\ActivityEvent;
use Oro\Bundle\EntityBundle\ORM\DoctrineHelper;
use Oro\Bundle\EntityConfigBundle\Config\ConfigManager;
use Oro\Bundle\ActivityContactBundle\Model\TargetExcludeList;
use Oro\Bundle\ActivityContactBundle\Direction\DirectionProviderInterface;
use Oro\Bundle\ActivityContactBundle\EntityConfig\ActivityScope;
use Oro\Bundle\ActivityContactBundle\Provider\ActivityContactProvider;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class ActivityListener
{
    /** @var ActivityContactProvider */
    protected $activityContactProvider;

    /** @var DoctrineHelper */
    protected $doctrineHelper;

    /** @var array */
    protected $deletedEntities = [];

    /** @var array */
    protected $updatedEntities = [];

    /** @var ConfigManager */
    protected $configManager;

    /**
     * @param ActivityContactProvider $activityContactProvider
     * @param DoctrineHelper          $doctrineHelper
     * @param ConfigManager           $configManager
     */
    public function __construct(
        ActivityContactProvider $activityContactProvider,
        DoctrineHelper $doctrineHelper,
        ConfigManager $configManager
    ) {
        $this->activityContactProvider = $activityContactProvider;
        $this->doctrineHelper          = $doctrineHelper;
        $this->configManager           = $configManager;
    }

    /**
     * Recalculate activity contacts on add new activity to the target
     *
     * @param ActivityEvent $event
     */
    public function onAddActivity(ActivityEvent $event)
    {
        $activity        = $event->getActivity();
        $target          = $event->getTarget();
        $extendProvider  = $this->configManager->getProvider('extend');
        $targetClassName = ClassUtils::getClass($target);

        if (TargetExcludeList::isExcluded($targetClassName) ||
            !$extendProvider->getConfig($targetClassName)->is('is_extend')) {
            return;
        }

        $direction = $this->activityContactProvider->getActivityDirection($activity, $target);
        if ($direction !== DirectionProviderInterface::DIRECTION_UNKNOWN) {
            $accessor = PropertyAccess::createPropertyAccessor();

            $contactDate = $this->activityContactProvider->getActivityDate($activity);

            $accessor->setValue(
                $target,
                ActivityScope::CONTACT_COUNT,
                ((int)$accessor->getValue($target, ActivityScope::CONTACT_COUNT) + 1)
            );

            $lastContactDate = $accessor->getValue($target, ActivityScope::LAST_CONTACT_DATE);
            if ($lastContactDate < $contactDate) {
                $accessor->setValue($target, ActivityScope::LAST_CONTACT_DATE, $contactDate);
            }

            if ($direction === DirectionProviderInterface::DIRECTION_INCOMING) {
                $directionCountPath = ActivityScope::CONTACT_COUNT_IN;
                $contactDatePath    = ActivityScope::LAST_CONTACT_DATE_IN;
            } else {
                $directionCountPath = ActivityScope::CONTACT_COUNT_OUT;
                $contactDatePath    = ActivityScope::LAST_CONTACT_DATE_OUT;
            }

            $accessor->setValue(
                $target,
                $directionCountPath,
                ((int)$accessor->getValue($target, $directionCountPath) + 1)
            );

            $lastContactDate = $accessor->getValue($target, $contactDatePath);
            if ($lastContactDate < $contactDate) {
                $accessor->setValue($target, $contactDatePath, $contactDate);
            }
        }
    }

    /**
     * @param ActivityEvent $event
     */
    public function onRemoveActivity(ActivityEvent $event)
    {
        $activity = $event->getActivity();
        $target = $event->getTarget();
        $extendProvider  = $this->configManager->getProvider('extend');
        $targetClassName = ClassUtils::getClass($target);

        if (TargetExcludeList::isExcluded($targetClassName) ||
            !$extendProvider->getConfig($targetClassName)->is('is_extend')) {
            return;
        }

        $accessor = PropertyAccess::createPropertyAccessor();
        $accessor->setValue(
            $target,
            ActivityScope::CONTACT_COUNT,
            (int)$accessor->getValue($target, ActivityScope::CONTACT_COUNT) - 1
        );

        $direction = $this->activityContactProvider->getActivityDirection($activity, $target);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        list($directionProperty) = $this->getDirectionProperties($direction);
        $accessor->setValue(
            $target,
            $directionProperty,
            (int)$accessor->getValue($target, $directionProperty) - 1
        );
    }

    /**
     * Collect activities changes
     *
     * @param OnFlushEventArgs $args
     *
     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     */
    public function onFlush(OnFlushEventArgs $args)
    {
        $entitiesToDelete = $args->getEntityManager()->getUnitOfWork()->getScheduledEntityDeletions();
        $entitiesToUpdate = $args->getEntityManager()->getUnitOfWork()->getScheduledEntityUpdates();
        $extendProvider   = $this->configManager->getProvider('extend');
        if (!empty($entitiesToDelete) || !empty($entitiesToUpdate)) {
            foreach ($entitiesToDelete as $entity) {
                $class = $this->doctrineHelper->getEntityClass($entity);
                $entityIdentifiersByClassName = $this->doctrineHelper->getEntityIdentifierFieldNamesForClass($class);

                /**
                 * Skip entities where we can't get single identifier
                 */
                if (count($entityIdentifiersByClassName) > 1) {
                    return;
                }

                $id    = $this->doctrineHelper->getSingleEntityIdentifier($entity);
                $key   = $class . '_' . $id;
                if (!isset($this->deletedEntities[$key])
                    && $this->activityContactProvider->isSupportedEntity($class)
                ) {
                    $targets     = $entity->getActivityTargetEntities();
                    $targetsInfo = [];
                    foreach ($targets as $target) {

                        $targetClassName = ClassUtils::getClass($target);
                        if (!TargetExcludeList::isExcluded($targetClassName) &&
                            $extendProvider->getConfig($targetClassName)->is('is_extend')) {
                            $targetsInfo[] = [
                                'class' => $this->doctrineHelper->getEntityClass($target),
                                'id' => $this->doctrineHelper->getSingleEntityIdentifier($target),
                                'direction' => $this->activityContactProvider->getActivityDirection($entity, $target)
                            ];
                        }
                    }
                    $this->deletedEntities[$key] = [
                        'class'       => $class,
                        'id'          => $id,
                        'contactDate' => $this->activityContactProvider->getActivityDate($entity),
                        'targets'     => $targetsInfo
                    ];
                }
            }

            foreach ($entitiesToUpdate as $entity) {
                $class = $this->doctrineHelper->getEntityClass($entity);
                $id    = $this->doctrineHelper->getSingleEntityIdentifier($entity);
                $key   = $class . '_' . $id;
                if (!isset($this->updatedEntities[$key])
                    && $this->activityContactProvider->isSupportedEntity($class)
                ) {
                    $changes            = $args->getEntityManager()->getUnitOfWork()->getEntityChangeSet($entity);
                    $isDirectionChanged = $this->activityContactProvider
                        ->getActivityDirectionProvider($entity)
                        ->isDirectionChanged($changes);

                    $targets     = $entity->getActivityTargetEntities();
                    $targetsInfo = [];
                    foreach ($targets as $target) {

                        $targetClassName = ClassUtils::getClass($target);
                        if (!TargetExcludeList::isExcluded($targetClassName) &&
                            $extendProvider->getConfig($targetClassName)->is('is_extend')) {
                            $targetsInfo[] = [
                                'class' => $this->doctrineHelper->getEntityClass($target),
                                'id' => $this->doctrineHelper->getSingleEntityIdentifier($target),
                                'direction' => $this->activityContactProvider->getActivityDirection($entity, $target),
                                'is_direction_changed' => $isDirectionChanged
                            ];
                        }
                    }
                    $this->updatedEntities[$key] = [
                        'class'       => $class,
                        'id'          => $id,
                        'contactDate' => $this->activityContactProvider->getActivityDate($entity),
                        'targets'     => $targetsInfo
                    ];
                }
            }
        }
    }

    /**
     * Save collected changes
     *
     * @param PostFlushEventArgs $args
     * @throws \Exception
     */
    public function postFlush(PostFlushEventArgs $args)
    {
        $entityManager = $args->getEntityManager();
        if (empty($this->deletedEntities) && empty($this->updatedEntities)) {
            return;
        }

        $entityManager->beginTransaction();
        try {
            $accessor = PropertyAccess::createPropertyAccessor();
            $this->processDeletedEntities($entityManager, $accessor);
            $this->processUpdatedEntities($entityManager, $accessor);

            $entityManager->flush();
            $entityManager->commit();
        } catch (\Exception $e) {
            $entityManager->rollback();
            throw $e;
        }
    }

    /**
     * @param EntityManager $em
     * @param PropertyAccessorInterface $accessor
     */
    protected function processDeletedEntities(EntityManager $em, PropertyAccessorInterface $accessor)
    {
        foreach ($this->deletedEntities as $activityData) {
            foreach ($activityData['targets'] as $targetInfo) {
                $direction = $targetInfo['direction'];
                $target    = $em->getRepository($targetInfo['class'])->find($targetInfo['id']);
                $accessor->setValue(
                    $target,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                    ActivityScope::CONTACT_COUNT,
                    ((int)$accessor->getValue($target, ActivityScope::CONTACT_COUNT) - 1)
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                );

                $directionCountPath = ActivityScope::CONTACT_COUNT_OUT;
                $contactDatePath    = ActivityScope::LAST_CONTACT_DATE_OUT;
                if ($direction === DirectionProviderInterface::DIRECTION_INCOMING) {
                    $directionCountPath = ActivityScope::CONTACT_COUNT_IN;
                    $contactDatePath    = ActivityScope::LAST_CONTACT_DATE_IN;
                }

                $accessor->setValue(
                    $target,
                    $directionCountPath,
                    ((int)$accessor->getValue($target, $directionCountPath) - 1)
                );

                $activityDate = $this->activityContactProvider->getLastContactActivityDate(
                    $em,
                    $target,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                    $direction,
                    $activityData['id'],
                    $activityData['class']
                );
                if ($activityDate) {

                    $accessor->setValue($target, ActivityScope::LAST_CONTACT_DATE, $activityDate['all']);
                    $accessor->setValue($target, $contactDatePath, $activityDate['direction']);
                }

                $em->persist($target);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            }
        }

        $this->deletedEntities = [];
    }

    /**
     * @param EntityManager $em
     * @param PropertyAccessorInterface $accessor
     */
    protected function processUpdatedEntities(EntityManager $em, PropertyAccessorInterface $accessor)
    {
        foreach ($this->updatedEntities as $activityData) {
            foreach ($activityData['targets'] as $targetInfo) {
                $direction          = $targetInfo['direction'];
                $isDirectionChanged = $targetInfo['is_direction_changed'];
                $target             = $em->getRepository($targetInfo['class'])->find($targetInfo['id']);
                /** process dates */
                if ($direction === DirectionProviderInterface::DIRECTION_INCOMING) {
                    $contactDatePath         = ActivityScope::LAST_CONTACT_DATE_IN;
                    $oppositeContactDatePath = ActivityScope::LAST_CONTACT_DATE_OUT;
                    $oppositeDirection       = DirectionProviderInterface::DIRECTION_OUTGOING;
                } else {
                    $contactDatePath         = ActivityScope::LAST_CONTACT_DATE_OUT;
                    $oppositeContactDatePath = ActivityScope::LAST_CONTACT_DATE_IN;
                    $oppositeDirection       = DirectionProviderInterface::DIRECTION_INCOMING;
                }

                $lastActivityDate = $this->activityContactProvider
                    ->getLastContactActivityDate($em, $target, $direction);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                if ($lastActivityDate) {

                    $accessor->setValue($target, ActivityScope::LAST_CONTACT_DATE, $lastActivityDate['all']);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                    $accessor->setValue($target, $contactDatePath, $lastActivityDate['direction']);
                    $accessor->setValue(
                        $target,
                        $oppositeContactDatePath,
                        $this->activityContactProvider->getLastContactActivityDate(
                            $em,
                            $target,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                            $oppositeDirection
                        )['direction']
                    );
                }

                /** process counts (in case direction was changed) */
                if ($isDirectionChanged) {
                    list($oldDirection, $newDirection) = $this->getDirectionProperties($direction, $isDirectionChanged);
                    $accessor->setValue(
                        $target,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                        $newDirection,
                        (int)$accessor->getValue($target, $newDirection) + 1
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                    );
                    $accessor->setValue(
                        $target,
                        $oldDirection,
                        (int)$accessor->getValue($target, $oldDirection) - 1
                    );
                }

                $em->persist($target);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            }
        }

        $this->updatedEntities = [];
    }

    /**
     * @param string $currentDirection
     * @param bool $isDirectionChanged
     *
     * @return array Where first value is old property and second is new
     */
    protected function getDirectionProperties($currentDirection, $isDirectionChanged = false)
    {
        if ($isDirectionChanged) {
            $properties = [
                ActivityScope::CONTACT_COUNT_IN,
                ActivityScope::CONTACT_COUNT_OUT,
            ];

            return $currentDirection === DirectionProviderInterface::DIRECTION_INCOMING
                ? array_reverse($properties)
                : $properties;
        }

        return $currentDirection === DirectionProviderInterface::DIRECTION_INCOMING
            ? [ActivityScope::CONTACT_COUNT_IN, ActivityScope::CONTACT_COUNT_IN]
            : [ActivityScope::CONTACT_COUNT_OUT, ActivityScope::CONTACT_COUNT_OUT];
    }
}

1			<?php
2
3			namespace Oro\Bundle\ActivityContactBundle\EventListener;
4
5			use Doctrine\Common\Util\ClassUtils;
6			use Doctrine\ORM\EntityManager;
7			use Doctrine\ORM\Event\OnFlushEventArgs;
8			use Doctrine\ORM\Event\PostFlushEventArgs;
9
10			use Symfony\Component\PropertyAccess\PropertyAccess;
11			use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
12
13			use Oro\Bundle\ActivityBundle\Event\ActivityEvent;
14			use Oro\Bundle\EntityBundle\ORM\DoctrineHelper;
15			use Oro\Bundle\EntityConfigBundle\Config\ConfigManager;
16			use Oro\Bundle\ActivityContactBundle\Model\TargetExcludeList;
17			use Oro\Bundle\ActivityContactBundle\Direction\DirectionProviderInterface;
18			use Oro\Bundle\ActivityContactBundle\EntityConfig\ActivityScope;
19			use Oro\Bundle\ActivityContactBundle\Provider\ActivityContactProvider;
20
21			/**
22			* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
23			*/
24			class ActivityListener
25			{
26			/** @var ActivityContactProvider */
27			protected $activityContactProvider;
28
29			/** @var DoctrineHelper */
30			protected $doctrineHelper;
31
32			/** @var array */
33			protected $deletedEntities = [];
34
35			/** @var array */
36			protected $updatedEntities = [];
37
38			/** @var ConfigManager */
39			protected $configManager;
40
orocrm / crm

Push — master ( 664fb1...60ffba )

ActivityListener::onFlush() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
