Team::setName() - Code Metrics - Inspection of "Merge pull request #11 from obblm/v1.x-dev" - obblm/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 32373f...f18c17 )

by Benjamin

created 2020-10-02 15:44 UTC

Team::setName() A

↳ Parent: Team

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	2
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	5
ccs	0
cts	3
cp	0
crap	2
rs	10

<?php

namespace Obblm\Core\Entity;

use Obblm\Core\Entity\Traits\CoverTrait;
use Obblm\Core\Entity\Traits\LogoTrait;
use Obblm\Core\Entity\Traits\NameTrait;
use Obblm\Core\Entity\Traits\RuleTrait;
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;

    use NameTrait;

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

    use RuleTrait;

    /**
     * @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;

    use LogoTrait;

    use CoverTrait;

    /**
     * @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 getCoach(): ?Coach
    {
        return $this->coach;
    }

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

        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 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;
    }
}


1		<?php
2
3		namespace Obblm\Core\Entity;
4
5		use Obblm\Core\Entity\Traits\CoverTrait;
6		use Obblm\Core\Entity\Traits\LogoTrait;
7		use Obblm\Core\Entity\Traits\NameTrait;
8		use Obblm\Core\Entity\Traits\RuleTrait;
9		use Obblm\Core\Helper\Rule\CanHaveRuleInterface;
10		use Obblm\Core\Repository\TeamRepository;
11		use Doctrine\Common\Collections\ArrayCollection;
12		use Doctrine\Common\Collections\Collection;
13		use Doctrine\Common\Collections\Criteria;
14		use Doctrine\ORM\Mapping as ORM;
15
16		/**
17		* @ORM\Entity(repositoryClass=TeamRepository::class)
18		* @ORM\Table(name="obblm_team")
19		*/
20		class Team implements CanHaveRuleInterface
21		{
22		/**
23		* @ORM\Id()
24		* @ORM\GeneratedValue()
25		* @ORM\Column(type="integer")
26		*/
27		private $id;
28
29		use NameTrait;
30
31		/**
32		* @ORM\ManyToOne(targetEntity=Coach::class, inversedBy="teams")
33		* @ORM\JoinColumn(nullable=false)
34		*/
35		private $coach;
36
37		use RuleTrait;
38
39		/**
40		* @ORM\Column(type="text", nullable=true)
41		*/
42		private $anthem;
43
44		/**
45		* @ORM\Column(type="text", nullable=true)
46		*/
47		private $fluff;
48
49		/**
50		* @ORM\Column(type="string", length=50)
51		*/
52		private $roster;
53
54		/**
55		* @ORM\OneToMany(targetEntity=Player::class, fetch="EAGER", mappedBy="team", orphanRemoval=true, cascade={"persist", "remove"})
56		* @ORM\OrderBy({"number"="ASC"})
57		*/
58		private $players;
59
60		use LogoTrait;
61
62		use CoverTrait;
63
64		/**
65		* @ORM\Column(type="boolean")
66		*/
67		private $ready = false;
68
69		/**
70		* @ORM\Column(type="boolean")
71		*/
72		private $lockedByManagment = false;
73
74		/**
75		* @ORM\OneToMany(targetEntity=TeamVersion::class, fetch="EAGER", mappedBy="team", orphanRemoval=true, cascade={"persist", "remove"})
76		* @ORM\OrderBy({"id"="DESC"})
77		*/
78		private $versions;
79
80	3	public function __construct()
81		{
82	3	$this->players = new ArrayCollection();
83	3	$this->versions = new ArrayCollection();
84	3	}
85
86		public function getId(): ?int
87		{
88		return $this->id;
89		}
90
91		public function getCoach(): ?Coach
92		{
93		return $this->coach;
94		}
95
96		public function setCoach(?Coach $coach): self
97		{
98		$this->coach = $coach;
99
100		return $this;
101		}
102
103		public function getAnthem(): ?string
104		{
105		return $this->anthem;
106		}
107
108		public function setAnthem(?string $anthem): self
109		{
110		$this->anthem = $anthem;
111
112		return $this;
113		}
114
115		public function getFluff(): ?string
116		{
117		return $this->fluff;
118		}
119
120		public function setFluff(?string $fluff): self
121		{
122		$this->fluff = $fluff;
123
124		return $this;
125		}
126
127	2	public function getRoster(): ?string
128		{
129	2	return $this->roster;
130		}
131
132	3	public function setRoster(string $roster): self
133		{
134	3	$this->roster = $roster;
135
136	3	return $this;
137		}
138
139		/**
140		* @return Collection\|Player[]
141		*/
142		public function getPlayers(): Collection
143		{
144		return $this->players;
145		}
146
147		/**
148		* @return Collection\|Player[]
149		*/
150	1	public function getAvailablePlayers(): Collection
151		{
152	1	$criteria = Criteria::create()
153	1	->andWhere(Criteria::expr()->eq('dead', false))
154	1	->andWhere(Criteria::expr()->eq('fire', false))
155	1	->orderBy(['number' => 'ASC'])
156		;
157	1	return $this->players->matching($criteria);
158		}
159
160		public function getAvailablePlayersSheet(): Collection
161		{
162		// In want to have 16 players in the list, no less, no more
163		$usedNumbers = [];
164		$newPlayerList = $this->getAvailablePlayers();
165		foreach ($newPlayerList as $player) {
166		$usedNumbers[$player->getNumber()] = $player;
167		}
168		for ($i=1; $i<=16; $i++) {
169		if (!isset($usedNumbers[$i])) {
170		$newPlayerList->add((new Player())->setNumber($i));
171		}
172		}
173		$criteria = Criteria::create();
174		$criteria->orderBy(['number' => 'ASC']);
175		return $newPlayerList->matching($criteria);
176		}
177
178	1	public function addPlayer(Player $player): self
179		{
180	1	if (!$this->players->contains($player)) {
181	1	$this->players[] = $player;
182	1	$player->setTeam($this);
183		}
184
185	1	return $this;
186		}
187
188		public function removePlayer(Player $player): self
189		{
190		if ($this->players->contains($player)) {
191		$this->players->removeElement($player);
192		// set the owning side to null (unless already changed)
193		if ($player->getTeam() === $this) {
194		$player->setTeam(null);
195		}
196		}
197
198		return $this;
199		}
200
201		public function getReady(): ?bool
202		{
203		return $this->ready;
204		}
205
206		public function isReady(): ?bool
207		{
208		return $this->getReady();
209		}
210
211		public function setReady(bool $ready): self
212		{
213		$this->ready = $ready;
214
215		return $this;
216		}
217
218		public function getLockedByManagment(): ?bool
219		{
220		return $this->lockedByManagment;
221		}
222
223		public function isLockedByManagment(): ?bool
224		{
225		return $this->getLockedByManagment();
226		}
227
228		public function setLockedByManagment(bool $lockedByManagment): self
229		{
230		$this->lockedByManagment = $lockedByManagment;
231
232		return $this;
233		}
234
235		/**
236		* @return Collection\|TeamVersion[]
237		*/
238	1	public function getVersions(): Collection
239		{
240	1	return $this->versions;
241		}
242
243	1	public function addVersion(TeamVersion $version): self
244		{
245	1	if (!$this->versions->contains($version)) {
246	1	$this->versions[] = $version;
247	1	$version->setTeam($this);
248		}
249
250	1	return $this;
251		}
252
253		public function removeVersion(TeamVersion $version): self
254		{
255		if ($this->versions->contains($version)) {
256		$this->versions->removeElement($version);
257		// set the owning side to null (unless already changed)
258		if ($version->getTeam() === $this) {
259		$version->setTeam(null);
260		}
261		}
262
263		return $this;
264		}
265		}
266

obblm / core

Push — master ( 32373f...f18c17 )

Team::setName() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like