Obblm\Core\Validator\Constraints\TeamCompositionValidator

Complexity

Total Complexity

13

Size/Duplication

Total Lines	54
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	2
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
B	validate()	0	26	9
A	getMaxPlayersByTypes()	0	14	3

<?php

namespace Obblm\Core\Validator\Constraints;

use Obblm\Core\Entity\Team;
use Obblm\Core\Entity\TeamVersion;
use Obblm\Core\Helper\PlayerHelper;
use Obblm\Core\Helper\TeamHelper;
use Symfony\Component\Form\Exception\UnexpectedTypeException;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;

class TeamCompositionValidator extends ConstraintValidator
{
    private $teamHelper;

    public function __construct(TeamHelper $teamHelper)
    {
        $this->teamHelper = $teamHelper;
    }

    public function validate($value, Constraint $constraint)
    {
        if (!$constraint instanceof TeamComposition) {
            throw new UnexpectedTypeException($constraint, TeamComposition::class);
        }
        if (!$value instanceof TeamVersion && !$value instanceof Team) {
            throw new UnexpectedTypeException($value, Team::class);
        }
        if ($value instanceof Team) {
            $value = TeamHelper::getLastVersion($value);
        }
        $count = [];

        /** @var TeamVersion $value */

        $maxPositions = $this->getMaxPlayersByTypes($value->getTeam());

It seems like $value->getTeam() can also be of type null; however, parameter $team of Obblm\Core\Validator\Constraints\TeamCompositionValidator::getMaxPlayersByTypes() does only seem to accept Obblm\Core\Entity\Team, maybe add an additional type check?

        foreach ($value->getNotDeadPlayerVersions() as $version) {
            if ($version->getPlayer()->getType()) {
                $limit = $maxPositions[$version->getPlayer()->getType()];
                $type = $version->getPlayer()->getType();
                isset($count[$type]) ? $count[$type]++ : $count[$type] = 1;
                if ($count[$type] > $limit) {
                    $this->context->buildViolation($constraint->limitMessage)
                        ->setParameter('{{ limit }}', $limit)
                        ->setParameter('{{ player_type }}', $type)
                        ->addViolation();
                }
            }
        }
    }

    protected function getMaxPlayersByTypes(Team $team):array
    {
        $helper = $this->teamHelper->getRuleHelper($team);
        $maxPositions = [];

        if ($helper->getAvailablePlayerTypes($team->getRoster())) {
            $types = $helper->getAvailablePlayerTypes($team->getRoster());
            foreach ($types as $key => $type) {
                $key = PlayerHelper::composePlayerKey($helper->getAttachedRule()->getRuleKey(), $team->getRoster(), $key);
                $maxPositions[$key] = $type['max'];
            }
        }

        return $maxPositions;
    }
}