Obblm\Core\Helper\Rule\Traits\AbstractTeamRuleTrait

Complexity

Total Complexity

23

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	calculateTeamRate()	0	3	1
A	getMaxTeamCost()	0	3	2
A	getRerollCost()	0	5	1
A	couldHaveApothecary()	0	5	1
A	getAvailableRosters()	0	3	1
A	getCheerleadersCost()	0	3	1
A	getTeamAvailablePlayerTypes()	0	3	1
A	getAssistantsCost()	0	3	1
A	getApothecaryCost()	0	3	1
A	getPopularityCost()	0	3	1
B	calculateTeamValue()	0	31	9
A	getMaxPlayersByType()	0	8	2
A	getInjuriesTable()	0	3	1

<?php

namespace Obblm\Core\Helper\Rule\Traits;

use Doctrine\Common\Collections\ArrayCollection;
use Obblm\Core\Entity\PlayerVersion;
use Obblm\Core\Entity\Team;
use Obblm\Core\Entity\TeamVersion;
use Obblm\Core\Exception\InvalidArgumentException;
use Obblm\Core\Exception\NotFoundRuleKeyExcepion;
use Obblm\Core\Exception\NoVersionException;
use Obblm\Core\Helper\PlayerHelper;
use Obblm\Core\Helper\Rule\Roster\Roster;
use Obblm\Core\Validator\Constraints\TeamValue;

/****************************
 * TEAM INFORMATION METHODS
 ***************************/
trait AbstractTeamRuleTrait
{
    public function getAvailableRosters(): ArrayCollection
    {
        return $this->getRosters();

It seems like getRosters() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * @return int
     */
    public function getMaxTeamCost():int
    {
        return ($this->rule['max_team_cost']) ? $this->rule['max_team_cost'] : TeamValue::LIMIT;
    }

    /**
     * @param Team $team
     * @return array
     */
    public function getTeamAvailablePlayerTypes(Team $team)
    {
        return $this->getAvailablePlayerTypes($team->getRoster());

The method getAvailablePlayerTypes() does not exist on Obblm\Core\Helper\Rule\Traits\AbstractTeamRuleTrait. Did you maybe mean getAvailableRosters()?

    }

    /**
     * @param Team $team
     * @return int
     * @throws \Exception
     */
    public function getRerollCost(Team $team):int
    {
        /** @var Roster $roster */
        $roster = $this->getRosters()->get($team->getRoster());
        return (int) $roster->getRerollCost();
    }

    /**
     * @param Team $team
     * @return int
     */
    public function getApothecaryCost(Team $team):int

The parameter $team is not used and could be removed.

    {
        return (int) $this->rule['sidelines_cost']['apothecary'];
    }

    /**
     * @param Team $team
     * @return int
     */
    public function getCheerleadersCost(Team $team):int

The parameter $team is not used and could be removed.

    {
        return (int) $this->rule['sidelines_cost']['cheerleaders'];
    }

    /**
     * @param Team $team
     * @return int
     */
    public function getAssistantsCost(Team $team):int

The parameter $team is not used and could be removed.

    {
        return (int) $this->rule['sidelines_cost']['assistants'];
    }

    /**
     * @param Team $team
     * @return int
     */
    public function getPopularityCost(Team $team):int

The parameter $team is not used and could be removed.

    {
        return (int) $this->rule['sidelines_cost']['popularity'];
    }

    /**
     * @param Team $team
     * @return bool
     * @throws \Exception
     */
    public function couldHaveApothecary(Team $team):bool
    {
        /** @var Roster $roster */
        $roster = $this->getRosters()->get($team->getRoster());
        return (bool) $roster->canHaveApothecary();
    }

    public function calculateTeamRate(TeamVersion $version):?int
    {
        return $this->calculateTeamValue($version) / 10000;
    }

    public function calculateTeamValue(TeamVersion $version, bool $excludeDisposable = false):int
    {
        if (!$version->getTeam()) {
            throw new InvalidArgumentException();
        }
        $value = 0;
        // Players
        // TODO: Bug => players are not version's one (because od dead players)
        foreach ($version->getTeam()->getAvailablePlayers() as $player) {
            if ($player->getType()) {
                try {
                    $playerVersion = PlayerHelper::getLastVersion($player);
                } catch (NoVersionException $e) { // It's a new player !
                    $playerVersion = (new PlayerVersion());
                    $player->addVersion($playerVersion);
                    $version->addPlayerVersion($playerVersion);
                    $this->setPlayerDefaultValues($playerVersion);
                }
                if (!$playerVersion->isMissingNextGame() && !($this->playerIsDisposable($playerVersion) && $excludeDisposable)) {
                    $value += $playerVersion->getValue();
                }
            }
        }
        // Sidelines
        $value += $version->getRerolls() * $this->getRerollCost($version->getTeam());
        $value += $version->getAssistants() * $this->getAssistantsCost($version->getTeam());
        $value += $version->getCheerleaders() * $this->getCheerleadersCost($version->getTeam());
        $value += $version->getPopularity() * $this->getPopularityCost($version->getTeam());
        $value += ($version->getApothecary()) ? $this->getApothecaryCost($version->getTeam()) : 0;

        return $value;
    }

    abstract public function setPlayerDefaultValues(PlayerVersion $version): ?PlayerVersion;
    abstract public function playerIsDisposable(PlayerVersion $version):bool;

    /**
     * @return array
     */
    public function getInjuriesTable():array
    {
        return $this->getInjuries();

The method getInjuries() does not exist on Obblm\Core\Helper\Rule\Traits\AbstractTeamRuleTrait. Did you maybe mean getInjuriesTable()?

    }

    public function getMaxPlayersByType($rosterKey, $typeKey): int
    {
        /** @var Roster $roster */
        $roster = $this->getRosters()->get($rosterKey);
        if (!$type = $roster->getPlayerTypes()[$typeKey]) {
            throw new NotFoundRuleKeyExcepion($typeKey, 'toto');

'toto' of type string is incompatible with the type integer expected by parameter $code of Obblm\Core\Exception\NotFoundRuleKeyExcepion::__construct().

        }
        return (int) $type['max'];
    }
}