OroCRM\Bundle\AnalyticsBundle\Validator\CategoriesValidator

Complexity

Total Complexity

30

Size/Duplication

Total Lines	183
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	validate()	0	10	4
D	validateBlank()	0	40	9
A	isEmpty()	0	4	2
A	validateCount()	0	14	2
A	validatedBy()	0	4	1
A	isIncreasing()	0	5	2
B	orderByValue()	0	20	5
B	validateOrder()	0	23	5

<?php

namespace OroCRM\Bundle\AnalyticsBundle\Validator;

use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Collections\Criteria;
use Doctrine\ORM\PersistentCollection;

use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;

use OroCRM\Bundle\AnalyticsBundle\Entity\RFMMetricCategory;

class CategoriesValidator extends ConstraintValidator
{
    const MIN_CATEGORIES_COUNT = 2;

    /**
     * Validate collection.
     *
     * @param PersistentCollection|RFMMetricCategory[] $value
     * @param CategoriesConstraint $constraint
     *
     * {@inheritdoc}
     */
    public function validate($value, Constraint $constraint)
    {
        if (!$value instanceof PersistentCollection) {
            return;
        }

        if ($this->validateCount($value, $constraint) && $this->validateBlank($value, $constraint)) {

$constraint of type object<Symfony\Component\Validator\Constraint> is not a sub-type of object<OroCRM\Bundle\AnalyticsBundle\Validator\CategoriesConstraint>. It seems like you assume a child class of the class Symfony\Component\Validator\Constraint to be always present.

            $this->validateOrder($value, $constraint);

$constraint of type object<Symfony\Component\Validator\Constraint> is not a sub-type of object<OroCRM\Bundle\AnalyticsBundle\Validator\CategoriesConstraint>. It seems like you assume a child class of the class Symfony\Component\Validator\Constraint to be always present.

        }
    }

    /**
     * Check collection for empty values.
     *
     * @param PersistentCollection $value
     * @param CategoriesConstraint $constraint
     * @return bool
     */
    protected function validateBlank(PersistentCollection $value, CategoriesConstraint $constraint)
    {
        $orderedByIndex = $value->matching(new Criteria(null, ['categoryIndex' => Criteria::ASC]));
        $isIncreasing = $this->isIncreasing($orderedByIndex);

        if ($isIncreasing) {
            $firstMax = $orderedByIndex->first()->getMaxValue();
            $lastMin = $orderedByIndex->last()->getMinValue();
            $hasEmpty = $this->isEmpty($firstMax) || $this->isEmpty($lastMin);
        } else {
            $firstMin = $orderedByIndex->first()->getMinValue();
            $lastMax = $orderedByIndex->last()->getMaxValue();
            $hasEmpty = $this->isEmpty($firstMin) || $this->isEmpty($lastMax);
        }

        if (!$hasEmpty) {
            $orderedByIndexWithoutEmpty = $orderedByIndex->filter(
                function (RFMMetricCategory $category) use ($orderedByIndex) {
                    return !in_array($category, [$orderedByIndex->first(), $orderedByIndex->last()], true);
                }
            );

            /** @var RFMMetricCategory $category */
            foreach ($orderedByIndexWithoutEmpty->toArray() as $category) {
                $min = $category->getMinValue();
                $max = $category->getMaxValue();

                if ($this->isEmpty($min) || $this->isEmpty($max)) {
                    $hasEmpty = true;
                    break;
                }
            }
        }

        if ($hasEmpty) {
            $this->context->addViolationAt($constraint->getType(), $constraint->blankMessage);

The method Symfony\Component\Validator\ExecutionContextInterface::addViolationAt() has been deprecated with message: since version 2.5, to be removed in 3.0. Use {@link Context\ExecutionContextInterface::buildViolation()} instead.

        }

        return !$hasEmpty;
    }

    /**
     * @param mixed $value
     * @return bool
     */
    protected function isEmpty($value)
    {
        return $value === '' || $value === null;
    }

    /**
     * Check that number of categories not less than minimum defined number.
     *
     * @param PersistentCollection $value
     * @param CategoriesConstraint $constraint
     * @return bool
     */
    protected function validateCount(PersistentCollection $value, CategoriesConstraint $constraint)
    {
        if ($value->count() >= self::MIN_CATEGORIES_COUNT) {
            return true;
        }

        $this->context->addViolationAt(

The method Symfony\Component\Validator\ExecutionContextInterface::addViolationAt() has been deprecated with message: since version 2.5, to be removed in 3.0. Use {@link Context\ExecutionContextInterface::buildViolation()} instead.

            $constraint->getType(),
            $constraint->countMessage,
            ['%count%' => self::MIN_CATEGORIES_COUNT]
        );

        return false;
    }

    /**
     * Check that collection is in right order in next way:
     * 1) Compare elements that ordered by index with elements that ordered by min value
     * 2) Check if equality doesn't exist between different categories in min values
     * 3) Check if max value ( null value exclude from checking ) always greater than min value
     *
     * For increasing collection values must be in ascending order.
     * For decreasing collection value must be in descending order.
     *
     * @param PersistentCollection $value
     * @param CategoriesConstraint $constraint
     */
    protected function validateOrder(PersistentCollection $value, CategoriesConstraint $constraint)
    {
        if ($value->isEmpty()) {
            return;
        }

        $orderedByIndex = $value->matching(new Criteria(null, ['categoryIndex' => Criteria::ASC]));
        $isIncreasing = $this->isIncreasing($orderedByIndex);
        $orderedByValueArray = $value->toArray();

        if ($isIncreasing) {
            $inversion = 1;
            $criteria = Criteria::ASC;
        } else {
            $inversion = -1;
            $criteria = Criteria::DESC;
        }

        $isValid = $this->orderByValue($orderedByValueArray, $inversion);
        if (!$isValid || $orderedByValueArray !== $orderedByIndex->toArray()) {
            $this->context->addViolationAt($constraint->getType(), $constraint->message, ['%order%' => $criteria]);

The method Symfony\Component\Validator\ExecutionContextInterface::addViolationAt() has been deprecated with message: since version 2.5, to be removed in 3.0. Use {@link Context\ExecutionContextInterface::buildViolation()} instead.

        }
    }

    /**
     * {@inheritdoc}
     */
    public function validatedBy()
    {
        return 'orocrm_analytics.validator.categories';
    }

    /**
     * @param Collection $orderedByIndex
     * @return bool
     */
    protected function isIncreasing(Collection $orderedByIndex)
    {
        return is_null($orderedByIndex->first()->getMinValue())
        && is_null($orderedByIndex->last()->getMaxValue());
    }

    /**
     * @param array $value
     * @param int $inversion
     *
     * @return boolean
     */
    protected function orderByValue(array &$value, $inversion)
    {
        $isValid = true;
        uasort(
            $value,
            function (RFMMetricCategory $item1, RFMMetricCategory $item2) use (&$isValid, $inversion) {
                $minValue1 = $item1->getMinValue();
                $minValue2 = $item2->getMinValue();

                if ($minValue1 === $minValue2 ||
                    (!is_null($item1->getMaxValue()) && $item1->getMaxValue() <= $minValue1)) {
                    $isValid = false;
                }

                return (($minValue1 < $minValue2) ? -1 : 1) * $inversion;
            }
        );

        return $isValid;
    }
}