Obblm\Core\Helper\Rule\Traits\AbstractTeamRuleTrait

Complexity

Total Complexity

22

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	calculateTeamRate()	0	3	1
B	calculateTeamValue()	0	27	8
A	getMaxTeamCost()	0	3	2
A	getRerollCost()	0	5	1
A	getMaxPlayersByType()	0	8	2
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
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\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
    {
        $team_cost = 0;
        // Players
        foreach ($version->getTeam()->getAvailablePlayers() as $basePlayer) {
            if ($basePlayer->getType()) {
                $player = (new PlayerVersion());

The assignment to $player is dead and can be removed.

                try {
                    $player = PlayerHelper::getLastVersion($basePlayer);
                } catch (NoVersionException $e) { // It's a new player !
                    $basePlayer->addVersion($player);
                    $version->addPlayerVersion($player);
                    $this->setPlayerDefaultValues($player);

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

                }
                if (!$player->isMissingNextGame() && !($this->playerIsDisposable($player) && $excludeDisposable)) {

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

                    $team_cost += $player->getValue();
                }
            }
        }
        // Sidelines
        $team_cost += $version->getRerolls() * $this->getRerollCost($version->getTeam());

It seems like $version->getTeam() can also be of type null; however, parameter $team of Obblm\Core\Helper\Rule\Traits\AbstractTeamRuleTrait::getRerollCost() does only seem to accept Obblm\Core\Entity\Team, maybe add an additional type check?

        $team_cost += $version->getAssistants() * $this->getAssistantsCost($version->getTeam());

It seems like $version->getTeam() can also be of type null; however, parameter $team of Obblm\Core\Helper\Rule\Traits\AbstractTeamRuleTrait::getAssistantsCost() does only seem to accept Obblm\Core\Entity\Team, maybe add an additional type check?

        $team_cost += $version->getCheerleaders() * $this->getCheerleadersCost($version->getTeam());

It seems like $version->getTeam() can also be of type null; however, parameter $team of Obblm\Core\Helper\Rule\Traits\AbstractTeamRuleTrait::getCheerleadersCost() does only seem to accept Obblm\Core\Entity\Team, maybe add an additional type check?

        $team_cost += $version->getPopularity() * $this->getPopularityCost($version->getTeam());

It seems like $version->getTeam() can also be of type null; however, parameter $team of Obblm\Core\Helper\Rule\Traits\AbstractTeamRuleTrait::getPopularityCost() does only seem to accept Obblm\Core\Entity\Team, maybe add an additional type check?

        $team_cost += ($version->getApothecary()) ? $this->getApothecaryCost($version->getTeam()) : 0;

It seems like $version->getTeam() can also be of type null; however, parameter $team of Obblm\Core\Helper\Rule\Traits\AbstractTeamRuleTrait::getApothecaryCost() does only seem to accept Obblm\Core\Entity\Team, maybe add an additional type check?

        return $team_cost;
    }

    /**
     * @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($roster_key, $type_key): int
    {
        /** @var Roster $roster */
        $roster = $this->getRosters()->get($roster_key);
        if (!$type = $roster->getPlayerTypes()[$type_key]) {
            throw new NotFoundRuleKeyExcepion($type_key, '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'];
    }
}