Message::getSender() - Code Metrics - Inspection of "Message: Allow attachments" - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#5544)

by Angel Fernando Quiroz

created 2024-05-27 22:48 UTC

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

chamilo / chamilo-lms

Pull Request — master (#5544)

Message::getSender() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like