Trick::setCategory() - Code Metrics - Inspection of "Bump terser from 4.0.0 to 4.8.1" - Starbugstone/SnowTricks - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#101)

unknown

created 2022-07-20 04:00 UTC

Trick::setCategory() A

↳ Parent: Trick

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	2
c	0
b	0
f	0
dl	0
loc	5
rs	10
cc	1
nc	1
nop	1

<?php

namespace App\Entity;

use App\Serializer\TagSerializer;
use DateTimeInterface;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Symfony\Component\Validator\Constraints as Assert;
use Gedmo\Mapping\Annotation as Gedmo;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;

/**
 * @ORM\Entity(repositoryClass="App\Repository\TrickRepository")
 * @Gedmo\Loggable
 * @UniqueEntity(fields="name", message="this trick already exists")
 */
class Trick extends AbstractAppEntity
{

    const NUMBER_OF_DISPLAYED_TRICKS = 10;

    /**
     * @ORM\Id()
     * @ORM\GeneratedValue()
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @ORM\Column(type="string", length=255)
     * @Gedmo\Versioned
     * @Assert\Length(
     *     min=5,
     *     max=255,
     *     minMessage = "Title must be at least {{ limit }} characters",
     *     maxMessage = "Title can not exceed {{ limit }} characters"
     * )
     */
    private $name;

    /**
     * @ORM\Column(type="text")
     * @Gedmo\Versioned
     */
    private $text;

    /**
     * @ORM\Column(type="string", length=255, unique=true)
     * @Gedmo\Slug(fields={"name"})
     */
    private $slug;

    /**
     * @ORM\Column(type="datetime")
     * @Gedmo\Timestampable(on="create")
     */
    private $createdAt;

    /**
     * @ORM\Column(type="datetime")
     * @Gedmo\Timestampable(on="update")
     */
    private $editedAt;

    /**
     * @ORM\ManyToOne(targetEntity="App\Entity\Category", inversedBy="tricks")
     * @ORM\JoinColumn(nullable=false)
     */
    private $category;

    /**
     * @ORM\ManyToMany(targetEntity="App\Entity\Tag", inversedBy="trick", cascade={"persist"})
     */
    private $tags;

    /**
     * @ORM\OneToMany(targetEntity="App\Entity\Comment", mappedBy="trick", cascade={"remove", "persist"}, orphanRemoval=true)
     * @ORM\OrderBy({"createdAt" = "DESC"})
     *
     */
    private $comments;

    /**
     * @ORM\OneToMany(targetEntity="App\Entity\Image", mappedBy="trick", cascade={"remove", "persist"}, orphanRemoval=true)
     * @Assert\Valid
     */
    private $images;

    /**
     * @ORM\OneToMany(targetEntity="App\Entity\Video", mappedBy="trick", cascade={"remove", "persist"}, orphanRemoval=true)
     * @Assert\Valid
     */
    private $videos;

    public function __construct()
    {
        $this->tags = new ArrayCollection();
        $this->comments = new ArrayCollection();
        $this->images = new ArrayCollection();
        $this->videos = 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 getText(): ?string
    {
        return $this->text;
    }

    public function setText(string $text): self
    {
        $this->text = $text;

        return $this;
    }

    public function getSlug(): ?string
    {
        return $this->slug;
    }

    public function setSlug(string $slug): self
    {
        $this->slug = $slug;

        return $this;
    }

    public function getCreatedAt(): ?DateTimeInterface
    {
        return $this->createdAt;
    }

    public function setCreatedAt(DateTimeInterface $createdAt): self
    {
        $this->createdAt = $createdAt;

        return $this;
    }

    public function getEditedAt(): ?DateTimeInterface
    {
        return $this->editedAt;
    }

    public function setEditedAt(DateTimeInterface $editedAt): self
    {
        $this->editedAt = $editedAt;

        return $this;
    }

    public function getCategory(): ?Category
    {
        return $this->category;
    }

    public function setCategory(?Category $category): self
    {
        $this->category = $category;

        return $this;
    }

    public function __toString()
    {
        return $this->name;
    }

    /**
     * @return Collection|Tag[]
     */
    public function getTags(): Collection
    {
        return $this->tags;
    }

    public function getTagsJson()
    {

        $tagSerializer = new TagSerializer();
        return $tagSerializer->trickTagsJson($this);

    }

    public function addTag(Tag $tag): self
    {
        if (!$this->tags->contains($tag)) {
            $this->tags[] = $tag;
            $tag->addTrick($this);
        }

        return $this;
    }

    public function removeTag(Tag $tag): self
    {
        if ($this->tags->contains($tag)) {
            $this->tags->removeElement($tag);
            $tag->removeTrick($this);
        }

        return $this;
    }

    /**
     * @return Collection|Comment[]
     */
    public function getComments(): Collection
    {
        return $this->comments;
    }

    public function addComment(Comment $comment): self
    {
        if (!$this->comments->contains($comment)) {
            $this->comments[] = $comment;
            $comment->setTrick($this);
        }

        return $this;
    }

    public function removeComment(Comment $comment): self
    {
        if ($this->comments->contains($comment)) {
            $this->comments->removeElement($comment);
            // set the owning side to null (unless already changed)
            if ($comment->getTrick() === $this) {
                $comment->setTrick(null);
            }
        }

        return $this;
    }

    /**
     * @return Collection|Image[]
     */
    public function getImages(): Collection
    {
        return $this->images;
    }

    public function addImage(Image $image): self
    {
        if (!$this->images->contains($image)) {
            $this->images[] = $image;
            $image->setTrick($this);
        }

        return $this;
    }

    public function removeImage(Image $image): self
    {
        if ($this->images->contains($image)) {
            $this->images->removeElement($image);
            // set the owning side to null (unless already changed)
            if ($image->getTrick() === $this) {
                $image->setTrick(null);
            }
        }

        return $this;
    }

    /**
     * Get the primary images associated with the trick
     * @return Collection|null
     */
    public function getPrimaryImages(): ?Collection
    {
        return $this->getImages()->filter(function (Image $image){
            return $image->getPrimaryImage() === true;
        });
    }

    /**
     * @return Collection|Video[]
     */
    public function getVideos(): Collection
    {
        return $this->videos;
    }

    public function addVideo(Video $video): self
    {
        if (!$this->videos->contains($video)) {
            $this->videos[] = $video;
            $video->setTrick($this);
        }

        return $this;
    }

    public function removeVideo(Video $video): self
    {
        if ($this->videos->contains($video)) {
            $this->videos->removeElement($video);
            // set the owning side to null (unless already changed)
            if ($video->getTrick() === $this) {
                $video->setTrick(null);
            }
        }

        return $this;
    }
}


1			<?php
2
3			namespace App\Entity;
4
5			use App\Serializer\TagSerializer;
6			use DateTimeInterface;
7			use Doctrine\Common\Collections\ArrayCollection;
8			use Doctrine\Common\Collections\Collection;
9			use Symfony\Component\Validator\Constraints as Assert;
10			use Gedmo\Mapping\Annotation as Gedmo;
11			use Doctrine\ORM\Mapping as ORM;
12			use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
13
14			/**
15			* @ORM\Entity(repositoryClass="App\Repository\TrickRepository")
16			* @Gedmo\Loggable
17			* @UniqueEntity(fields="name", message="this trick already exists")
18			*/
19			class Trick extends AbstractAppEntity
20			{
21
22			const NUMBER_OF_DISPLAYED_TRICKS = 10;
23
24			/**
25			* @ORM\Id()
26			* @ORM\GeneratedValue()
27			* @ORM\Column(type="integer")
28			*/
29			private $id;
30
31			/**
32			* @ORM\Column(type="string", length=255)
33			* @Gedmo\Versioned
34			* @Assert\Length(
35			* min=5,
36			* max=255,
37			* minMessage = "Title must be at least {{ limit }} characters",
38			* maxMessage = "Title can not exceed {{ limit }} characters"
39			* )
40			*/
41			private $name;
42
43			/**
44			* @ORM\Column(type="text")
45			* @Gedmo\Versioned
46			*/
47			private $text;
48
49			/**
50			* @ORM\Column(type="string", length=255, unique=true)
51			* @Gedmo\Slug(fields={"name"})
52			*/
53			private $slug;
54
55			/**
56			* @ORM\Column(type="datetime")
57			* @Gedmo\Timestampable(on="create")
58			*/
59			private $createdAt;
60
61			/**
62			* @ORM\Column(type="datetime")
63			* @Gedmo\Timestampable(on="update")
64			*/
65			private $editedAt;
66
67			/**
68			* @ORM\ManyToOne(targetEntity="App\Entity\Category", inversedBy="tricks")
69			* @ORM\JoinColumn(nullable=false)
70			*/
71			private $category;
72
73			/**
74			* @ORM\ManyToMany(targetEntity="App\Entity\Tag", inversedBy="trick", cascade={"persist"})
75			*/
76			private $tags;
77
78			/**
79			* @ORM\OneToMany(targetEntity="App\Entity\Comment", mappedBy="trick", cascade={"remove", "persist"}, orphanRemoval=true)
80			* @ORM\OrderBy({"createdAt" = "DESC"})
81			*
82			*/
83			private $comments;
84
85			/**
86			* @ORM\OneToMany(targetEntity="App\Entity\Image", mappedBy="trick", cascade={"remove", "persist"}, orphanRemoval=true)
87			* @Assert\Valid
88			*/
89			private $images;
90
91			/**
92			* @ORM\OneToMany(targetEntity="App\Entity\Video", mappedBy="trick", cascade={"remove", "persist"}, orphanRemoval=true)
93			* @Assert\Valid
94			*/
95			private $videos;
96
97			public function __construct()
98			{
99			$this->tags = new ArrayCollection();
100			$this->comments = new ArrayCollection();
101			$this->images = new ArrayCollection();
102			$this->videos = new ArrayCollection();
103			}
104
105			public function getId(): ?int
106			{
107			return $this->id;
108			}
109
110			public function getName(): ?string
111			{
112			return $this->name;
113			}
114
115			public function setName(string $name): self
116			{
117			$this->name = $name;
118
119			return $this;
120			}
121
122			public function getText(): ?string
123			{
124			return $this->text;
125			}
126
127			public function setText(string $text): self
128			{
129			$this->text = $text;
130
131			return $this;
132			}
133
134			public function getSlug(): ?string
135			{
136			return $this->slug;
137			}
138
139			public function setSlug(string $slug): self
140			{
141			$this->slug = $slug;
142
143			return $this;
144			}
145
146			public function getCreatedAt(): ?DateTimeInterface
147			{
148			return $this->createdAt;
149			}
150
151			public function setCreatedAt(DateTimeInterface $createdAt): self
152			{
153			$this->createdAt = $createdAt;
154
155			return $this;
156			}
157
158			public function getEditedAt(): ?DateTimeInterface
159			{
160			return $this->editedAt;
161			}
162
163			public function setEditedAt(DateTimeInterface $editedAt): self
164			{
165			$this->editedAt = $editedAt;
166
167			return $this;
168			}
169
170			public function getCategory(): ?Category
171			{
172			return $this->category;
173			}
174
175			public function setCategory(?Category $category): self
176			{
177			$this->category = $category;
178
179			return $this;
180			}
181
182			public function __toString()
183			{
184			return $this->name;
185			}
186
187			/**
188			* @return Collection\|Tag[]
189			*/
190			public function getTags(): Collection
191			{
192			return $this->tags;
193			}
194
195			public function getTagsJson()
196			{
197
198			$tagSerializer = new TagSerializer();
199			return $tagSerializer->trickTagsJson($this);
200
201			}
202
203			public function addTag(Tag $tag): self
204			{
205			if (!$this->tags->contains($tag)) {
206			$this->tags[] = $tag;
207			$tag->addTrick($this);
208			}
209
210			return $this;
211			}
212
213			public function removeTag(Tag $tag): self
214			{
215			if ($this->tags->contains($tag)) {
216			$this->tags->removeElement($tag);
217			$tag->removeTrick($this);
218			}
219
220			return $this;
221			}
222
223			/**
224			* @return Collection\|Comment[]
225			*/
226			public function getComments(): Collection
227			{
228			return $this->comments;
229			}
230
231			public function addComment(Comment $comment): self
232			{
233			if (!$this->comments->contains($comment)) {
234			$this->comments[] = $comment;
235			$comment->setTrick($this);
236			}
237
238			return $this;
239			}
240
241			public function removeComment(Comment $comment): self
242			{
243			if ($this->comments->contains($comment)) {
244			$this->comments->removeElement($comment);
245			// set the owning side to null (unless already changed)
246			if ($comment->getTrick() === $this) {
247			$comment->setTrick(null);
248			}
249			}
250
251			return $this;
252			}
253
254			/**
255			* @return Collection\|Image[]
256			*/
257			public function getImages(): Collection
258			{
259			return $this->images;
260			}
261
262			public function addImage(Image $image): self
263			{
264			if (!$this->images->contains($image)) {
265			$this->images[] = $image;
266			$image->setTrick($this);
267			}
268
269			return $this;
270			}
271
272			public function removeImage(Image $image): self
273			{
274			if ($this->images->contains($image)) {
275			$this->images->removeElement($image);
276			// set the owning side to null (unless already changed)
277			if ($image->getTrick() === $this) {
278			$image->setTrick(null);
279			}
280			}
281
282			return $this;
283			}
284
285			/**
286			* Get the primary images associated with the trick
287			* @return Collection\|null
288			*/
289			public function getPrimaryImages(): ?Collection
290			{
291			return $this->getImages()->filter(function (Image $image){
292			return $image->getPrimaryImage() === true;
293			});
294			}
295
296			/**
297			* @return Collection\|Video[]
298			*/
299			public function getVideos(): Collection
300			{
301			return $this->videos;
302			}
303
304			public function addVideo(Video $video): self
305			{
306			if (!$this->videos->contains($video)) {
307			$this->videos[] = $video;
308			$video->setTrick($this);
309			}
310
311			return $this;
312			}
313
314			public function removeVideo(Video $video): self
315			{
316			if ($this->videos->contains($video)) {
317			$this->videos->removeElement($video);
318			// set the owning side to null (unless already changed)
319			if ($video->getTrick() === $this) {
320			$video->setTrick(null);
321			}
322			}
323
324			return $this;
325			}
326			}
327

Starbugstone / SnowTricks

Pull Request — master (#101)

Trick::setCategory() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like