MessageProcessor::process() - Code Metrics - Inspection of "Message: Fix message status update on deletion for..." - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#5695)

unknown

created 2024-07-28 20:21 UTC

MessageProcessor::process() B

↳ Parent: MessageProcessor

Complexity

Conditions	10
Paths	12

Size

Total Lines	44
Code Lines	24

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	1

Metric	Value
cc	10
eloc	24
nc	12
nop	4
dl	0
loc	44
rs	7.6666
c	3
b	0
f	1

How to fix Complexity

<?php

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

declare(strict_types=1);

namespace Chamilo\CoreBundle\State;

use ApiPlatform\Metadata\DeleteOperationInterface;
use ApiPlatform\Metadata\Operation;
use ApiPlatform\Metadata\Patch;
use ApiPlatform\Metadata\Post;
use ApiPlatform\State\ProcessorInterface;
use Chamilo\CoreBundle\Entity\Message;
use Chamilo\CoreBundle\Entity\MessageAttachment;
use Chamilo\CoreBundle\Entity\MessageRelUser;
use Chamilo\CoreBundle\Repository\ResourceNodeRepository;
use Doctrine\ORM\EntityManagerInterface;
use Notification;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Component\HttpFoundation\RequestStack;
use Vich\UploaderBundle\Storage\FlysystemStorage;

final class MessageProcessor implements ProcessorInterface
{
    public function __construct(
        private readonly ProcessorInterface $persistProcessor,
        private readonly ProcessorInterface $removeProcessor,
        private readonly FlysystemStorage $storage,
        private readonly EntityManagerInterface $entityManager,
        private readonly ResourceNodeRepository $resourceNodeRepository,
        private readonly Security $security,
        private readonly RequestStack $requestStack
    ) {}

    public function process($data, Operation $operation, array $uriVariables = [], array $context = [])
    {
        if ($operation instanceof DeleteOperationInterface) {
            return $this->removeProcessor->process($data, $operation, $uriVariables, $context);
        }

        if ($operation instanceof Patch && str_contains($operation->getUriTemplate(), 'delete-for-user')) {
            return $this->processDeleteForUser($data);
        }

        if ($operation instanceof Patch && str_contains($operation->getUriTemplate(), 'check-and-update-status')) {
            return $this->checkAndUpdateMessageStatus($data);
        }

        /** @var Message $message */
        $message = $this->persistProcessor->process($data, $operation, $uriVariables, $context);

        foreach ($message->getAttachments() as $attachment) {
            $attachment->resourceNode->addResourceFile(
                $attachment->getResourceFileToAttach()
            );

            foreach ($message->getReceivers() as $receiver) {
                $attachment->addUserLink($receiver->getReceiver());
            }
        }

        $user = $this->security->getUser();
        if (!$user) {
            throw new \LogicException('User not found.');
        }
        $messageRelUser = new MessageRelUser();
        $messageRelUser->setMessage($message);
        $messageRelUser->setReceiver($user);
        $messageRelUser->setReceiverType(MessageRelUser::TYPE_SENDER);
        $this->entityManager->persist($messageRelUser);

        if ($message->getMsgType() === Message::MESSAGE_TYPE_INBOX) {
            $this->saveNotificationForInboxMessage($message);
        }

        $this->entityManager->flush();

        return $message;
    }

    private function processDeleteForUser($data): Message
    {
        /** @var Message $message */
        $message = $data;

        $request = $this->requestStack->getCurrentRequest();
        if (!$request) {
            throw new \LogicException('Cannot get current request');
        }

        $requestData = json_decode($request->getContent(), true);
        if (!isset($requestData['userId'])) {
            throw new \InvalidArgumentException('The field userId is required.');
        }

        $userId = $requestData['userId'];
        $messageRelUserRepository = $this->entityManager->getRepository(MessageRelUser::class);
        $messageRelUser = $messageRelUserRepository->findOneBy([
            'message' => $message,
            'receiver' => $userId,
        ]);

        if ($messageRelUser) {
            $this->entityManager->remove($messageRelUser);
            $this->entityManager->flush();
        }

        return $message;
    }

    private function checkAndUpdateMessageStatus($data): Message
    {
        /** @var Message $message */
        $message = $data;

        $messageRelUserRepository = $this->entityManager->getRepository(MessageRelUser::class);
        $remainingReceivers = $messageRelUserRepository->count(['message' => $message]);

        if ($remainingReceivers === 0) {
            $message->setStatus(Message::MESSAGE_STATUS_SENDER_DELETED);
            $this->entityManager->flush();
        }

        return $message;
    }

    private function saveNotificationForInboxMessage(Message $message): void
    {
        $sender_info = api_get_user_info(
            $message->getSender()->getId()
        );

        $userIdList = $message
            ->getReceivers()
            ->map(fn (MessageRelUser $messageRelUser): int => $messageRelUser->getReceiver()->getId())
            ->getValues()
        ;

        $attachmentList = [];

        /** @var MessageAttachment $messageAttachment */
        foreach ($message->getAttachments() as $messageAttachment) {
            $stream = $this->resourceNodeRepository->getResourceNodeFileStream(
                $messageAttachment->resourceNode
            );

            $attachmentList[] = [
                'stream' => $stream,
                'filename' => $messageAttachment->getFilename(),
            ];
        }

        (new Notification())
            ->saveNotification(
                $message->getId(),
                Notification::NOTIFICATION_TYPE_MESSAGE,
                $userIdList,
                $message->getTitle(),
                $message->getContent(),
                $sender_info,
                $attachmentList,
            )
        ;
    }
}


1			<?php
2
3			/* For licensing terms, see /license.txt */
4
5			declare(strict_types=1);
6
7			namespace Chamilo\CoreBundle\State;
8
9			use ApiPlatform\Metadata\DeleteOperationInterface;
10			use ApiPlatform\Metadata\Operation;
11			use ApiPlatform\Metadata\Patch;
12			use ApiPlatform\Metadata\Post;
13			use ApiPlatform\State\ProcessorInterface;
14			use Chamilo\CoreBundle\Entity\Message;
15			use Chamilo\CoreBundle\Entity\MessageAttachment;
16			use Chamilo\CoreBundle\Entity\MessageRelUser;
17			use Chamilo\CoreBundle\Repository\ResourceNodeRepository;
18			use Doctrine\ORM\EntityManagerInterface;
19			use Notification;
20			use Symfony\Bundle\SecurityBundle\Security;
21			use Symfony\Component\HttpFoundation\RequestStack;
22			use Vich\UploaderBundle\Storage\FlysystemStorage;
23
24			final class MessageProcessor implements ProcessorInterface
25			{
26			public function __construct(
27			private readonly ProcessorInterface $persistProcessor,
28			private readonly ProcessorInterface $removeProcessor,
29			private readonly FlysystemStorage $storage,
30			private readonly EntityManagerInterface $entityManager,
31			private readonly ResourceNodeRepository $resourceNodeRepository,
32			private readonly Security $security,
33			private readonly RequestStack $requestStack
34			) {}
35
36			public function process($data, Operation $operation, array $uriVariables = [], array $context = [])
37			{
38			if ($operation instanceof DeleteOperationInterface) {
39			return $this->removeProcessor->process($data, $operation, $uriVariables, $context);
40			}
41
42			if ($operation instanceof Patch && str_contains($operation->getUriTemplate(), 'delete-for-user')) {
43			return $this->processDeleteForUser($data);
44			}
45
46			if ($operation instanceof Patch && str_contains($operation->getUriTemplate(), 'check-and-update-status')) {
47			return $this->checkAndUpdateMessageStatus($data);
48			}
49
50			/** @var Message $message */
51			$message = $this->persistProcessor->process($data, $operation, $uriVariables, $context);
52
53			foreach ($message->getAttachments() as $attachment) {
54			$attachment->resourceNode->addResourceFile(
55			$attachment->getResourceFileToAttach()
56			);
57
58			foreach ($message->getReceivers() as $receiver) {
59			$attachment->addUserLink($receiver->getReceiver());
60			}
61			}
62
63			$user = $this->security->getUser();
64			if (!$user) {
65			throw new \LogicException('User not found.');
66			}
67			$messageRelUser = new MessageRelUser();
68			$messageRelUser->setMessage($message);
69			$messageRelUser->setReceiver($user);
70			$messageRelUser->setReceiverType(MessageRelUser::TYPE_SENDER);
71			$this->entityManager->persist($messageRelUser);
72
73			if ($message->getMsgType() === Message::MESSAGE_TYPE_INBOX) {
74			$this->saveNotificationForInboxMessage($message);
75			}
76
77			$this->entityManager->flush();
78
79			return $message;
80			}
81
82			private function processDeleteForUser($data): Message
83			{
84			/** @var Message $message */
85			$message = $data;
86
87			$request = $this->requestStack->getCurrentRequest();
88			if (!$request) {
89			throw new \LogicException('Cannot get current request');
90			}
91
92			$requestData = json_decode($request->getContent(), true);
93			if (!isset($requestData['userId'])) {
94			throw new \InvalidArgumentException('The field userId is required.');
95			}
96
97			$userId = $requestData['userId'];
98			$messageRelUserRepository = $this->entityManager->getRepository(MessageRelUser::class);
99			$messageRelUser = $messageRelUserRepository->findOneBy([
100			'message' => $message,
101			'receiver' => $userId,
102			]);
103
104			if ($messageRelUser) {
105			$this->entityManager->remove($messageRelUser);
106			$this->entityManager->flush();
107			}
108
109			return $message;
110			}
111
112			private function checkAndUpdateMessageStatus($data): Message
113			{
114			/** @var Message $message */
115			$message = $data;
116
117			$messageRelUserRepository = $this->entityManager->getRepository(MessageRelUser::class);
118			$remainingReceivers = $messageRelUserRepository->count(['message' => $message]);
119
120			if ($remainingReceivers === 0) {
121			$message->setStatus(Message::MESSAGE_STATUS_SENDER_DELETED);
122			$this->entityManager->flush();
123			}
124
125			return $message;
126			}
127
128			private function saveNotificationForInboxMessage(Message $message): void
129			{
130			$sender_info = api_get_user_info(
131			$message->getSender()->getId()
132			);
133
134			$userIdList = $message
135			->getReceivers()
136			->map(fn (MessageRelUser $messageRelUser): int => $messageRelUser->getReceiver()->getId())
137			->getValues()
138			;
139
140			$attachmentList = [];
141
142			/** @var MessageAttachment $messageAttachment */
143			foreach ($message->getAttachments() as $messageAttachment) {
144			$stream = $this->resourceNodeRepository->getResourceNodeFileStream(
145			$messageAttachment->resourceNode
146			);
147
148			$attachmentList[] = [
149			'stream' => $stream,
150			'filename' => $messageAttachment->getFilename(),
151			];
152			}
153
154			(new Notification())
155			->saveNotification(
156			$message->getId(),
157			Notification::NOTIFICATION_TYPE_MESSAGE,
158			$userIdList,
159			$message->getTitle(),
160			$message->getContent(),
161			$sender_info,
162			$attachmentList,
163			)
164			;
165			}
166			}
167

chamilo / chamilo-lms

Pull Request — master (#5695)

MessageProcessor::process() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like