Obblm\Core\Entity\Team

Complexity

Total Complexity

45

Size/Duplication

Total Lines	334
Duplicated Lines	0 %

Test Coverage

Coverage

15.04%

Importance

Changes	1
Bugs	0	Features	0

36 Methods

Rating	Name	Duplication	Size	Complexity
A	setCoverMimeType()	0	4	1
A	__construct()	0	4	1
A	getRule()	0	3	1
A	getAnthem()	0	3	1
A	getAvailablePlayers()	0	8	1
A	addVersion()	0	8	2
A	getId()	0	3	1
A	getCoach()	0	3	1
A	setCoverFilename()	0	4	1
A	isLockedByManagment()	0	3	1
A	setReady()	0	5	1
A	getLockedByManagment()	0	3	1
A	setRule()	0	5	1
A	removePlayer()	0	11	3
A	setFluff()	0	5	1
A	setName()	0	5	1
A	getName()	0	3	1
A	setLogoFilename()	0	4	1
A	setCoach()	0	5	1
A	getPlayers()	0	3	1
A	getCoverFilename()	0	3	1
A	getReady()	0	3	1
A	getVersions()	0	3	1
A	getCoverMimeType()	0	3	1
A	getRoster()	0	3	1
A	removeVersion()	0	11	3
A	addPlayer()	0	8	2
A	setAnthem()	0	5	1
A	isReady()	0	3	1
A	getFluff()	0	3	1
A	getAvailablePlayersSheet()	0	16	4
A	getLogoMimeType()	0	3	1
A	setRoster()	0	5	1
A	setLogoMimeType()	0	4	1
A	getLogoFilename()	0	3	1
A	setLockedByManagment()	0	5	1

<?php

namespace Obblm\Core\Entity;

use Obblm\Core\Helper\Rule\CanHaveRuleInterface;
use Obblm\Core\Repository\TeamRepository;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Collections\Criteria;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity(repositoryClass=TeamRepository::class)
 * @ORM\Table(name="obblm_team")
 */
class Team implements CanHaveRuleInterface
{
    /**
     * @ORM\Id()
     * @ORM\GeneratedValue()
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @ORM\Column(type="string", length=255)
     */
    private $name;

    /**
     * @ORM\ManyToOne(targetEntity=Coach::class, inversedBy="teams")
     * @ORM\JoinColumn(nullable=false)
     */
    private $coach;

    /**
     * @ORM\ManyToOne(targetEntity=Rule::class, inversedBy="teams")
     */
    private $rule;

    /**
     * @ORM\Column(type="text", nullable=true)
     */
    private $anthem;

    /**
     * @ORM\Column(type="text", nullable=true)
     */
    private $fluff;

    /**
     * @ORM\Column(type="string", length=50)
     */
    private $roster;

    /**
     * @ORM\OneToMany(targetEntity=Player::class, fetch="EAGER", mappedBy="team", orphanRemoval=true, cascade={"persist", "remove"})
     * @ORM\OrderBy({"number"="ASC"})
     */
    private $players;

    /**
     * @ORM\Column(type="string", nullable=true)
     */
    private $logoFilename;

    /**
     * @ORM\Column(type="string", nullable=true)
     */
    private $logoMimeType;

    /**
     * @ORM\Column(type="string", nullable=true)
     */
    private $coverFilename;

    /**
     * @ORM\Column(type="string", nullable=true)
     */
    private $coverMimeType;

    /**
     * @ORM\Column(type="boolean")
     */
    private $ready = false;

    /**
     * @ORM\Column(type="boolean")
     */
    private $lockedByManagment = false;

    /**
     * @ORM\OneToMany(targetEntity=TeamVersion::class, fetch="EAGER", mappedBy="team", orphanRemoval=true, cascade={"persist", "remove"})
     * @ORM\OrderBy({"id"="DESC"})
     */
    private $versions;

    public function __construct()
    {
        $this->players = new ArrayCollection();
        $this->versions = new ArrayCollection();
    }

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getName(): ?string
    {
        return $this->name;
    }

    public function setName(string $name): self
    {
        $this->name = $name;

        return $this;
    }

    public function getCoach(): ?Coach
    {
        return $this->coach;
    }

    public function setCoach(?Coach $coach): self
    {
        $this->coach = $coach;

        return $this;
    }

    public function getRule(): ?Rule
    {
        return $this->rule;
    }

    public function setRule(?Rule $rule): self
    {
        $this->rule = $rule;

        return $this;
    }

    public function getAnthem(): ?string
    {
        return $this->anthem;
    }

    public function setAnthem(?string $anthem): self
    {
        $this->anthem = $anthem;

        return $this;
    }

    public function getFluff(): ?string
    {
        return $this->fluff;
    }

    public function setFluff(?string $fluff): self
    {
        $this->fluff = $fluff;

        return $this;
    }

    public function getRoster(): ?string
    {
        return $this->roster;
    }

    public function setRoster(string $roster): self
    {
        $this->roster = $roster;

        return $this;
    }

    /**
     * @return Collection|Player[]
     */
    public function getPlayers(): Collection
    {
        return $this->players;
    }

    /**
     * @return Collection|Player[]
     */
    public function getAvailablePlayers(): Collection
    {
        $criteria = Criteria::create()
            ->andWhere(Criteria::expr()->eq('dead', false))
            ->andWhere(Criteria::expr()->eq('fire', false))
            ->orderBy(['number' => 'ASC'])
        ;
        return $this->players->matching($criteria);
    }

    public function getAvailablePlayersSheet(): Collection
    {
        // In want to have 16 players in the list, no less, no more
        $usedNumbers = [];
        $newPlayerList = $this->getAvailablePlayers();
        foreach ($newPlayerList as $player) {
            $usedNumbers[$player->getNumber()] = $player;
        }
        for ($i=1; $i<=16; $i++) {
            if (!isset($usedNumbers[$i])) {
                $newPlayerList->add((new Player())->setNumber($i));
            }
        }
        $criteria = Criteria::create();
        $criteria->orderBy(['number' => 'ASC']);
        return $newPlayerList->matching($criteria);
    }

    public function addPlayer(Player $player): self
    {
        if (!$this->players->contains($player)) {
            $this->players[] = $player;
            $player->setTeam($this);
        }

        return $this;
    }

    public function removePlayer(Player $player): self
    {
        if ($this->players->contains($player)) {
            $this->players->removeElement($player);
            // set the owning side to null (unless already changed)
            if ($player->getTeam() === $this) {
                $player->setTeam(null);
            }
        }

        return $this;
    }

    public function getLogoFilename(): ?string
    {
        return $this->logoFilename;
    }

    public function setLogoFilename(?string $logoFilename): self
    {
        $this->logoFilename = $logoFilename;
        return $this;
    }

    public function getLogoMimeType(): ?string
    {
        return $this->logoMimeType;
    }

    public function setLogoMimeType(?string $logoMimeType): self
    {
        $this->logoMimeType = $logoMimeType;
        return $this;
    }

    public function getCoverFilename(): ?string
    {
        return $this->coverFilename;
    }

    public function setCoverFilename(?string $coverFilename): self
    {
        $this->coverFilename = $coverFilename;
        return $this;
    }

    public function getCoverMimeType(): ?string
    {
        return $this->coverMimeType;
    }

    public function setCoverMimeType(?string $coverMimeType): self
    {
        $this->coverMimeType = $coverMimeType;
        return $this;
    }

    public function getReady(): ?bool
    {
        return $this->ready;
    }

    public function isReady(): ?bool
    {
        return $this->getReady();
    }

    public function setReady(bool $ready): self
    {
        $this->ready = $ready;

        return $this;
    }

    public function getLockedByManagment(): ?bool
    {
        return $this->lockedByManagment;
    }

    public function isLockedByManagment(): ?bool
    {
        return $this->getLockedByManagment();
    }

    public function setLockedByManagment(bool $lockedByManagment): self
    {
        $this->lockedByManagment = $lockedByManagment;

        return $this;
    }

    /**
     * @return Collection|TeamVersion[]
     */
    public function getVersions(): Collection
    {
        return $this->versions;
    }

    public function addVersion(TeamVersion $version): self
    {
        if (!$this->versions->contains($version)) {
            $this->versions[] = $version;
            $version->setTeam($this);
        }

        return $this;
    }

    public function removeVersion(TeamVersion $version): self
    {
        if ($this->versions->contains($version)) {
            $this->versions->removeElement($version);
            // set the owning side to null (unless already changed)
            if ($version->getTeam() === $this) {
                $version->setTeam(null);
            }
        }

        return $this;
    }
}