Message::getReceivers() - Code Metrics - Inspection of "Merge pull request #5310 from AngelFQC/shortcuts" - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 1c618d...c1c6b0 )

by Yannick

created 2024-07-04 20:43 UTC

Message::getReceivers() A

↳ Parent: Message

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

declare(strict_types=1);

/* For licensing terms, see /license.txt */

namespace Chamilo\CoreBundle\Entity;

use ApiPlatform\Doctrine\Orm\Filter\BooleanFilter;
use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
use ApiPlatform\Metadata\ApiFilter;
use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Delete;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Post;
use ApiPlatform\Metadata\Put;
use Chamilo\CoreBundle\Filter\SearchOrFilter;
use Chamilo\CoreBundle\Repository\MessageRepository;
use Chamilo\CoreBundle\State\MessageByGroupStateProvider;
use Chamilo\CoreBundle\State\MessageProcessor;
use DateTime;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Collections\Criteria;
use Doctrine\ORM\Mapping as ORM;
use Gedmo\Mapping\Annotation as Gedmo;
use Symfony\Component\Serializer\Annotation\Groups;
use Symfony\Component\Validator\Constraints as Assert;

#[ORM\Table(name: 'message')]
#[ORM\Index(columns: ['user_sender_id'], name: 'idx_message_user_sender')]
#[ORM\Index(columns: ['group_id'], name: 'idx_message_group')]
#[ORM\Index(columns: ['msg_type'], name: 'idx_message_type')]
#[ORM\Entity(repositoryClass: MessageRepository::class)]
#[ApiResource(
    operations: [
        new Get(security: "is_granted('VIEW', object)"),
        new Put(security: "is_granted('EDIT', object)"),
        new Delete(security: "is_granted('DELETE', object)"),
        new GetCollection(
            uriTemplate: '/messages',
            security: "is_granted('ROLE_USER')",
            name: 'get_all_messages'
        ),
        new GetCollection(
            uriTemplate: '/messages/by-group/list',
            security: "is_granted('ROLE_USER')",
            name: 'get_messages_by_social_group',
            provider: MessageByGroupStateProvider::class
        ),
        new Post(securityPostDenormalize: "is_granted('CREATE', object)"),
    ],
    normalizationContext: [
        'groups' => ['message:read'],
    ],
    denormalizationContext: [
        'groups' => ['message:write'],
    ],
    security: "is_granted('ROLE_USER')",
    processor: MessageProcessor::class,
)]
#[ApiFilter(filterClass: OrderFilter::class, properties: ['title', 'sendDate'])]
#[ApiFilter(
    filterClass: SearchFilter::class,
    properties: [
        'msgType' => 'exact',
        'status' => 'exact',
        'sender' => 'exact',
        'receivers.receiver' => 'exact',
        'receivers.tags.tag' => 'exact',
        'parent' => 'exact',
    ]
)]
#[ApiFilter(
    BooleanFilter::class,
    properties: ['receivers.read']
)]
#[ApiFilter(SearchOrFilter::class, properties: ['title', 'content'])]
class Message
{
    public const MESSAGE_TYPE_INBOX = 1;
    public const MESSAGE_TYPE_GROUP = 5;
    public const MESSAGE_TYPE_INVITATION = 6;
    public const MESSAGE_TYPE_CONVERSATION = 7;
    // status
    public const MESSAGE_STATUS_DELETED = 3;
    public const MESSAGE_STATUS_DRAFT = 4;
    public const MESSAGE_STATUS_INVITATION_PENDING = 5;
    public const MESSAGE_STATUS_INVITATION_ACCEPTED = 6;
    public const MESSAGE_STATUS_INVITATION_DENIED = 7;

    #[ORM\Column(name: 'id', type: 'integer')]
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[Groups(['message:read'])]
    protected ?int $id = null;

    #[Assert\NotBlank]
    #[Groups(['message:read', 'message:write'])]
    #[ORM\ManyToOne(targetEntity: User::class, inversedBy: 'sentMessages')]
    #[ORM\JoinColumn(name: 'user_sender_id', referencedColumnName: 'id', onDelete: 'SET NULL')]
    protected ?User $sender = null;

    /**
     * @var Collection<int, MessageRelUser>
     */
    #[ORM\OneToMany(mappedBy: 'message', targetEntity: MessageRelUser::class, cascade: ['persist', 'remove'])]
    #[Groups(['message:write'])]
    protected Collection $receivers;

    #[Assert\NotBlank]
    #[Groups(['message:read', 'message:write'])]
    #[ORM\Column(name: 'msg_type', type: 'smallint', nullable: false)]
    protected int $msgType;

    #[Assert\NotBlank]
    #[Groups(['message:read', 'message:write'])]
    #[ORM\Column(name: 'status', type: 'smallint', nullable: false)]
    protected int $status;

    #[Groups(['message:read'])]
    #[ORM\Column(name: 'send_date', type: 'datetime', nullable: false)]
    protected DateTime $sendDate;

    #[Assert\NotBlank]
    #[Groups(['message:read', 'message:write'])]
    #[ORM\Column(name: 'title', type: 'string', length: 255, nullable: false)]
    protected string $title;

    #[Assert\NotBlank]
    #[Groups(['message:read', 'message:write'])]
    #[ORM\Column(name: 'content', type: 'text', nullable: false)]
    protected string $content;

    #[Groups(['message:read', 'message:write'])]
    #[ORM\ManyToOne(targetEntity: Usergroup::class)]
    #[ORM\JoinColumn(name: 'group_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
    protected ?Usergroup $group = null;

    /**
     * @var Collection<int, Message>
     */
    #[ORM\OneToMany(mappedBy: 'parent', targetEntity: self::class)]
    protected Collection $children;

    #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'children')]
    #[ORM\JoinColumn(name: 'parent_id', referencedColumnName: 'id')]
    protected ?Message $parent = null;

    #[Gedmo\Timestampable(on: 'update')]
    #[ORM\Column(name: 'update_date', type: 'datetime', nullable: true)]
    protected ?DateTime $updateDate;

    #[ORM\Column(name: 'votes', type: 'integer', nullable: true)]
    protected ?int $votes;

    /**
     * @var Collection<int, MessageAttachment>
     */
    #[Assert\Valid]
    #[Groups(['message:read', 'message:write'])]
    #[ORM\OneToMany(
        mappedBy: 'message',
        targetEntity: MessageAttachment::class,
        cascade: ['persist'],
        orphanRemoval: true,
    )]
    protected Collection $attachments;

    #[ORM\OneToMany(mappedBy: 'message', targetEntity: MessageFeedback::class, orphanRemoval: true)]
    protected Collection $likes;

    public function __construct()
    {
        $this->sendDate = new DateTime('now');
        $this->updateDate = $this->sendDate;
        $this->msgType = self::MESSAGE_TYPE_INBOX;
        $this->content = '';
        $this->attachments = new ArrayCollection();
        $this->children = new ArrayCollection();
        $this->receivers = new ArrayCollection();
        $this->likes = new ArrayCollection();
        $this->votes = 0;
        $this->status = 0;
    }

    /**
     * @return Collection<int, MessageRelUser>
     */
    public function getReceivers(): Collection
    {
        return $this->receivers;
    }

    #[Groups(['message:read'])]
    public function getReceiversTo(): array
    {
        return $this->receivers
            ->filter(
                fn (MessageRelUser $messageRelUser) => MessageRelUser::TYPE_TO === $messageRelUser->getReceiverType()
            )->getValues()
        ;
    }

    #[Groups(['message:read'])]
    public function getReceiversCc(): array
    {
        return $this->receivers
            ->filter(
                fn (MessageRelUser $messageRelUser) => MessageRelUser::TYPE_CC === $messageRelUser->getReceiverType()
            )
            ->getValues()
        ;
    }

    #[Groups(['message:read'])]
    public function getFirstReceiver(): ?MessageRelUser
    {
        if ($this->receivers->count() > 0) {
            return $this->receivers->first();
        }

        return null;
    }

    public function hasUserReceiver(User $receiver): bool
    {
        if ($this->receivers->count()) {
            $criteria = Criteria::create()
                ->where(
                    Criteria::expr()->eq('receiver', $receiver)
                )
                ->andWhere(
                    Criteria::expr()->eq('message', $this)
                )
            ;

            return $this->receivers->matching($criteria)->count() > 0;
        }

        return false;
    }

    public function addReceiverTo(User $receiver): self
    {
        $messageRelUser = (new MessageRelUser())
            ->setReceiver($receiver)
            ->setReceiverType(MessageRelUser::TYPE_TO)
        ;

        $this->addReceiver($messageRelUser);

        return $this;
    }

    public function addReceiver(MessageRelUser $messageRelUser): self
    {
        if (!$this->receivers->contains($messageRelUser)) {
            $this->receivers->add($messageRelUser);

            $messageRelUser->setMessage($this);
        }

        return $this;
    }

    public function addReceiverCc(User $receiver): self
    {
        $messageRelUser = (new MessageRelUser())
            ->setReceiver($receiver)
            ->setReceiverType(MessageRelUser::TYPE_CC)
        ;

        $this->addReceiver($messageRelUser);

        return $this;
    }

    public function removeReceiver(MessageRelUser $messageRelUser): self
    {
        $this->receivers->removeElement($messageRelUser);

        return $this;
    }

    public function getSender(): ?User
    {
        return $this->sender;
    }

    public function setSender(?User $sender): self
    {
        $this->sender = $sender;

        return $this;
    }

    public function getMsgType(): int
    {
        return $this->msgType;
    }

    public function setMsgType(int $msgType): self
    {
        $this->msgType = $msgType;

        return $this;
    }

    public function getSendDate(): DateTime
    {
        return $this->sendDate;
    }

    public function setSendDate(DateTime $sendDate): self
    {
        $this->sendDate = $sendDate;

        return $this;
    }

    public function getTitle(): string
    {
        return $this->title;
    }

    public function setTitle(string $title): self
    {
        $this->title = $title;

        return $this;
    }

    public function getContent(): string
    {
        return $this->content;
    }

    public function setContent(string $content): self
    {
        $this->content = $content;

        return $this;
    }

    public function getUpdateDate(): ?DateTime
    {
        return $this->updateDate;
    }

    public function setUpdateDate(DateTime $updateDate): self
    {
        $this->updateDate = $updateDate;

        return $this;
    }

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

    public function getVotes(): int
    {
        return $this->votes;

    }

    public function setVotes(int $votes): self
    {
        $this->votes = $votes;

        return $this;
    }

    /**
     * @return Collection<int, MessageAttachment>
     */
    public function getAttachments(): Collection
    {
        return $this->attachments;
    }

    public function addAttachment(MessageAttachment $attachment): static
    {
        if (!$this->attachments->contains($attachment)) {
            $this->attachments->add($attachment);
            $attachment
                ->setMessage($this)
                ->setParent($this->sender)
                ->setCreator($this->sender)
            ;
        }

        return $this;
    }

    public function removeAttachment(MessageAttachment $attachment): static
    {
        if ($this->attachments->removeElement($attachment)) {
            if ($attachment->getMessage() === $this) {
                $attachment->setMessage(null);
            }
        }

        return $this;
    }

    public function getParent(): ?self
    {
        return $this->parent;
    }

    public function setParent(?self $parent): self
    {
        $this->parent = $parent;

        return $this;
    }

    /**
     * @return Collection<int, Message>
     */
    public function getChildren(): Collection
    {
        return $this->children;
    }

    public function addChild(self $child): self
    {
        $this->children[] = $child;
        $child->setParent($this);

        return $this;
    }

    public function getGroup(): ?Usergroup
    {
        return $this->group;
    }

    public function setGroup(?Usergroup $group): self
    {
        //        $this->msgType = self::MESSAGE_TYPE_GROUP;
        $this->group = $group;

        return $this;
    }

    public function getStatus(): int
    {
        return $this->status;
    }

    public function setStatus(int $status): self
    {
        $this->status = $status;

        return $this;
    }

    public function getLikes(): Collection
    {
        return $this->likes;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/* For licensing terms, see /license.txt */
6
7			namespace Chamilo\CoreBundle\Entity;
8
9			use ApiPlatform\Doctrine\Orm\Filter\BooleanFilter;
10			use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
11			use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
12			use ApiPlatform\Metadata\ApiFilter;
13			use ApiPlatform\Metadata\ApiResource;
14			use ApiPlatform\Metadata\Delete;
15			use ApiPlatform\Metadata\Get;
16			use ApiPlatform\Metadata\GetCollection;
17			use ApiPlatform\Metadata\Post;
18			use ApiPlatform\Metadata\Put;
19			use Chamilo\CoreBundle\Filter\SearchOrFilter;
20			use Chamilo\CoreBundle\Repository\MessageRepository;
21			use Chamilo\CoreBundle\State\MessageByGroupStateProvider;
22			use Chamilo\CoreBundle\State\MessageProcessor;
23			use DateTime;
24			use Doctrine\Common\Collections\ArrayCollection;
25			use Doctrine\Common\Collections\Collection;
26			use Doctrine\Common\Collections\Criteria;
27			use Doctrine\ORM\Mapping as ORM;
28			use Gedmo\Mapping\Annotation as Gedmo;
29			use Symfony\Component\Serializer\Annotation\Groups;
30			use Symfony\Component\Validator\Constraints as Assert;
31
32			#[ORM\Table(name: 'message')]
33			#[ORM\Index(columns: ['user_sender_id'], name: 'idx_message_user_sender')]
34			#[ORM\Index(columns: ['group_id'], name: 'idx_message_group')]
35			#[ORM\Index(columns: ['msg_type'], name: 'idx_message_type')]
36			#[ORM\Entity(repositoryClass: MessageRepository::class)]
37			#[ApiResource(
38			operations: [
39			new Get(security: "is_granted('VIEW', object)"),
40			new Put(security: "is_granted('EDIT', object)"),
41			new Delete(security: "is_granted('DELETE', object)"),
42			new GetCollection(
43			uriTemplate: '/messages',
44			security: "is_granted('ROLE_USER')",
45			name: 'get_all_messages'
46			),
47			new GetCollection(
48			uriTemplate: '/messages/by-group/list',
49			security: "is_granted('ROLE_USER')",
50			name: 'get_messages_by_social_group',
51			provider: MessageByGroupStateProvider::class
52			),
53			new Post(securityPostDenormalize: "is_granted('CREATE', object)"),
54			],
55			normalizationContext: [
56			'groups' => ['message:read'],
57			],
58			denormalizationContext: [
59			'groups' => ['message:write'],
60			],
61			security: "is_granted('ROLE_USER')",
62			processor: MessageProcessor::class,
63			)]
64			#[ApiFilter(filterClass: OrderFilter::class, properties: ['title', 'sendDate'])]
65			#[ApiFilter(
66			filterClass: SearchFilter::class,
67			properties: [
68			'msgType' => 'exact',
69			'status' => 'exact',
70			'sender' => 'exact',
71			'receivers.receiver' => 'exact',
72			'receivers.tags.tag' => 'exact',
73			'parent' => 'exact',
74			]
75			)]
76			#[ApiFilter(
77			BooleanFilter::class,
78			properties: ['receivers.read']
79			)]
80			#[ApiFilter(SearchOrFilter::class, properties: ['title', 'content'])]
81			class Message
82			{
83			public const MESSAGE_TYPE_INBOX = 1;
84			public const MESSAGE_TYPE_GROUP = 5;
85			public const MESSAGE_TYPE_INVITATION = 6;
86			public const MESSAGE_TYPE_CONVERSATION = 7;
87			// status
88			public const MESSAGE_STATUS_DELETED = 3;
89			public const MESSAGE_STATUS_DRAFT = 4;
90			public const MESSAGE_STATUS_INVITATION_PENDING = 5;
91			public const MESSAGE_STATUS_INVITATION_ACCEPTED = 6;
92			public const MESSAGE_STATUS_INVITATION_DENIED = 7;
93
94			#[ORM\Column(name: 'id', type: 'integer')]
95			#[ORM\Id]
96			#[ORM\GeneratedValue]
97			#[Groups(['message:read'])]
98			protected ?int $id = null;
99
100			#[Assert\NotBlank]
101			#[Groups(['message:read', 'message:write'])]
102			#[ORM\ManyToOne(targetEntity: User::class, inversedBy: 'sentMessages')]
103			#[ORM\JoinColumn(name: 'user_sender_id', referencedColumnName: 'id', onDelete: 'SET NULL')]
104			protected ?User $sender = null;
105
106			/**
107			* @var Collection<int, MessageRelUser>
108			*/
109			#[ORM\OneToMany(mappedBy: 'message', targetEntity: MessageRelUser::class, cascade: ['persist', 'remove'])]
110			#[Groups(['message:write'])]
111			protected Collection $receivers;
112
113			#[Assert\NotBlank]
114			#[Groups(['message:read', 'message:write'])]
115			#[ORM\Column(name: 'msg_type', type: 'smallint', nullable: false)]
116			protected int $msgType;
117
118			#[Assert\NotBlank]
119			#[Groups(['message:read', 'message:write'])]
120			#[ORM\Column(name: 'status', type: 'smallint', nullable: false)]
121			protected int $status;
122
123			#[Groups(['message:read'])]
124			#[ORM\Column(name: 'send_date', type: 'datetime', nullable: false)]
125			protected DateTime $sendDate;
126
127			#[Assert\NotBlank]
128			#[Groups(['message:read', 'message:write'])]
129			#[ORM\Column(name: 'title', type: 'string', length: 255, nullable: false)]
130			protected string $title;
131
132			#[Assert\NotBlank]
133			#[Groups(['message:read', 'message:write'])]
134			#[ORM\Column(name: 'content', type: 'text', nullable: false)]
135			protected string $content;
136
137			#[Groups(['message:read', 'message:write'])]
138			#[ORM\ManyToOne(targetEntity: Usergroup::class)]
139			#[ORM\JoinColumn(name: 'group_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
140			protected ?Usergroup $group = null;
141
142			/**
143			* @var Collection<int, Message>
144			*/
145			#[ORM\OneToMany(mappedBy: 'parent', targetEntity: self::class)]
146			protected Collection $children;
147
148			#[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'children')]
149			#[ORM\JoinColumn(name: 'parent_id', referencedColumnName: 'id')]
150			protected ?Message $parent = null;
151
152			#[Gedmo\Timestampable(on: 'update')]
153			#[ORM\Column(name: 'update_date', type: 'datetime', nullable: true)]
154			protected ?DateTime $updateDate;
155
156			#[ORM\Column(name: 'votes', type: 'integer', nullable: true)]
157			protected ?int $votes;
158
159			/**
160			* @var Collection<int, MessageAttachment>
161			*/
162			#[Assert\Valid]
163			#[Groups(['message:read', 'message:write'])]
164			#[ORM\OneToMany(
165			mappedBy: 'message',
166			targetEntity: MessageAttachment::class,
167			cascade: ['persist'],
168			orphanRemoval: true,
169			)]
170			protected Collection $attachments;
171
172			#[ORM\OneToMany(mappedBy: 'message', targetEntity: MessageFeedback::class, orphanRemoval: true)]
173			protected Collection $likes;
174
175			public function __construct()
176			{
177			$this->sendDate = new DateTime('now');
178			$this->updateDate = $this->sendDate;
179			$this->msgType = self::MESSAGE_TYPE_INBOX;
180			$this->content = '';
181			$this->attachments = new ArrayCollection();
182			$this->children = new ArrayCollection();
183			$this->receivers = new ArrayCollection();
184			$this->likes = new ArrayCollection();
185			$this->votes = 0;
186			$this->status = 0;
187			}
188
189			/**
190			* @return Collection<int, MessageRelUser>
191			*/
192			public function getReceivers(): Collection
193			{
194			return $this->receivers;
195			}
196
197			#[Groups(['message:read'])]
198			public function getReceiversTo(): array
199			{
200			return $this->receivers
201			->filter(
202			fn (MessageRelUser $messageRelUser) => MessageRelUser::TYPE_TO === $messageRelUser->getReceiverType()
203			)->getValues()
204			;
205			}
206
207			#[Groups(['message:read'])]
208			public function getReceiversCc(): array
209			{
210			return $this->receivers
211			->filter(
212			fn (MessageRelUser $messageRelUser) => MessageRelUser::TYPE_CC === $messageRelUser->getReceiverType()
213			)
214			->getValues()
215			;
216			}
217
218			#[Groups(['message:read'])]
219			public function getFirstReceiver(): ?MessageRelUser
220			{
221			if ($this->receivers->count() > 0) {
222			return $this->receivers->first();
223			}
224
225			return null;
226			}
227
228			public function hasUserReceiver(User $receiver): bool
229			{
230			if ($this->receivers->count()) {
231			$criteria = Criteria::create()
232			->where(
233			Criteria::expr()->eq('receiver', $receiver)
234			)
235			->andWhere(
236			Criteria::expr()->eq('message', $this)
237			)
238			;
239
240			return $this->receivers->matching($criteria)->count() > 0;
241			}
242
243			return false;
244			}
245
246			public function addReceiverTo(User $receiver): self
247			{
248			$messageRelUser = (new MessageRelUser())
249			->setReceiver($receiver)
250			->setReceiverType(MessageRelUser::TYPE_TO)
251			;
252
253			$this->addReceiver($messageRelUser);
254
255			return $this;
256			}
257
258			public function addReceiver(MessageRelUser $messageRelUser): self
259			{
260			if (!$this->receivers->contains($messageRelUser)) {
261			$this->receivers->add($messageRelUser);
262
263			$messageRelUser->setMessage($this);
264			}
265
266			return $this;
267			}
268
269			public function addReceiverCc(User $receiver): self
270			{
271			$messageRelUser = (new MessageRelUser())
272			->setReceiver($receiver)
273			->setReceiverType(MessageRelUser::TYPE_CC)
274			;
275
276			$this->addReceiver($messageRelUser);
277
278			return $this;
279			}
280
281			public function removeReceiver(MessageRelUser $messageRelUser): self
282			{
283			$this->receivers->removeElement($messageRelUser);
284
285			return $this;
286			}
287
288			public function getSender(): ?User
289			{
290			return $this->sender;
291			}
292
293			public function setSender(?User $sender): self
294			{
295			$this->sender = $sender;
296
297			return $this;
298			}
299
300			public function getMsgType(): int
301			{
302			return $this->msgType;
303			}
304
305			public function setMsgType(int $msgType): self
306			{
307			$this->msgType = $msgType;
308
309			return $this;
310			}
311
312			public function getSendDate(): DateTime
313			{
314			return $this->sendDate;
315			}
316
317			public function setSendDate(DateTime $sendDate): self
318			{
319			$this->sendDate = $sendDate;
320
321			return $this;
322			}
323
324			public function getTitle(): string
325			{
326			return $this->title;
327			}
328
329			public function setTitle(string $title): self
330			{
331			$this->title = $title;
332
333			return $this;
334			}
335
336			public function getContent(): string
337			{
338			return $this->content;
339			}
340
341			public function setContent(string $content): self
342			{
343			$this->content = $content;
344
345			return $this;
346			}
347
348			public function getUpdateDate(): ?DateTime
349			{
350			return $this->updateDate;
351			}
352
353			public function setUpdateDate(DateTime $updateDate): self
354			{
355			$this->updateDate = $updateDate;
356
357			return $this;
358			}
359
360			public function getId(): ?int
361			{
362			return $this->id;
363			}
364
365			public function getVotes(): int
366			{
367			return $this->votes;
			0 ignored issues – show Bug Best Practice introduced 2021-03-06 19:18 UTC by Report Bug Copy Issue Report The expression `return $this->votes` could return the type `null` which is incompatible with the type-hinted return `integer`. Consider adding an additional type-check to rule them out. Loading history...
368			}
369
370			public function setVotes(int $votes): self
371			{
372			$this->votes = $votes;
373
374			return $this;
375			}
376
377			/**
378			* @return Collection<int, MessageAttachment>
379			*/
380			public function getAttachments(): Collection
381			{
382			return $this->attachments;
383			}
384
385			public function addAttachment(MessageAttachment $attachment): static
386			{
387			if (!$this->attachments->contains($attachment)) {
388			$this->attachments->add($attachment);
389			$attachment
390			->setMessage($this)
391			->setParent($this->sender)
392			->setCreator($this->sender)
393			;
394			}
395
396			return $this;
397			}
398
399			public function removeAttachment(MessageAttachment $attachment): static
400			{
401			if ($this->attachments->removeElement($attachment)) {
402			if ($attachment->getMessage() === $this) {
403			$attachment->setMessage(null);
404			}
405			}
406
407			return $this;
408			}
409
410			public function getParent(): ?self
411			{
412			return $this->parent;
413			}
414
415			public function setParent(?self $parent): self
416			{
417			$this->parent = $parent;
418
419			return $this;
420			}
421
422			/**
423			* @return Collection<int, Message>
424			*/
425			public function getChildren(): Collection
426			{
427			return $this->children;
428			}
429
430			public function addChild(self $child): self
431			{
432			$this->children[] = $child;
433			$child->setParent($this);
434
435			return $this;
436			}
437
438			public function getGroup(): ?Usergroup
439			{
440			return $this->group;
441			}
442
443			public function setGroup(?Usergroup $group): self
444			{
445			// $this->msgType = self::MESSAGE_TYPE_GROUP;
446			$this->group = $group;
447
448			return $this;
449			}
450
451			public function getStatus(): int
452			{
453			return $this->status;
454			}
455
456			public function setStatus(int $status): self
457			{
458			$this->status = $status;
459
460			return $this;
461			}
462
463			public function getLikes(): Collection
464			{
465			return $this->likes;
466			}
467			}
468

chamilo / chamilo-lms

Push — master ( 1c618d...c1c6b0 )

Message::getReceivers() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like