OroCRM\Bundle\AnalyticsBundle\Validator\CategoriesValidator

Complexity

Total Complexity

27

Size/Duplication

Total Lines	174
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

7 Methods

Rating	Name	Duplication	Size	Complexity
A	validate()	0	10	4
A	isEmpty()	0	4	2
A	validatedBy()	0	4	1
D	validateBlank()	0	40	9
A	validateCount()	0	14	2
C	validateOrder()	0	44	7
A	isIncreasing()	0	5	2

<?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.
     *
     * 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);

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

        $orderedByValue = $value->matching(
            new Criteria(null, ['minValue' => $criteria])
        );

        if ($orderedByValue->toArray() !== $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.

            return;
        }

        if (!$isIncreasing) {
            return;
        }

        $invalidItems = $orderedByValue->filter(
            function (RFMMetricCategory $category) {
                $maxValue = $category->getMaxValue();
                if (!$maxValue) {
                    return false;
                }

                return $category->getMinValue() >= $maxValue;
            }
        );

        if (!$invalidItems->isEmpty()) {
            $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());
    }
}