MessageManager::send_message()

Complexity

Conditions	55
Paths	> 20000

Size

Total Lines	315
Code Lines	188

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public static function send_message(
        $receiverUserId,
        $subject,
        $content,
        array $attachments = [],
        array $fileCommentList = [],
        $group_id = 0,
        $parent_id = 0,
        $editMessageId = 0,
        $topic_id = 0,
        $sender_id = 0,
        $directMessage = false,
        $forwardId = 0,
        $checkCurrentAudioId = false,
        $forceTitleWhenSendingEmail = false,
        $msgType = null,
        $baseUrl = null,
        $sendEmailNotification = true
    ) {
        $group_id = (int) $group_id;
        $receiverUserId = (int) $receiverUserId;
        $parent_id = (int) $parent_id;
        $editMessageId = (int) $editMessageId;
        $topic_id = (int) $topic_id;
        $user_sender_id = empty($sender_id) ? api_get_user_id() : (int) $sender_id;

        if (empty($user_sender_id) || empty($receiverUserId)) {
            return false;
        }

        $userSender = api_get_user_entity($user_sender_id);
        if (null === $userSender) {
            Display::addFlash(Display::return_message(get_lang('This user doesn\'t exist'), 'warning'));

            return false;
        }

        $userRecipient = api_get_user_entity($receiverUserId);

        if (null === $userRecipient) {
            return false;
        }

        // Disabling messages for inactive users.
        if (!$userRecipient->isActive()) {
            return false;
        }

        // Email notifications are enabled by default, but can be explicitly disabled (e.g., inbox copy after registration).
        $sendEmail = true;
        if (false === (bool) $sendEmailNotification) {
            $sendEmail = false;
        }

        // Disabling messages depending the pausetraining plugin (only relevant if email notifications are enabled).
        $allowPauseFormation =
            $sendEmail &&
            Container::getPluginHelper()->isPluginEnabled('PauseTraining') &&
            'true' === api_get_plugin_setting('PauseTraining', 'allow_users_to_edit_pause_formation');

        if ($allowPauseFormation) {
            $extraFieldValue = new ExtraFieldValue('user');
            $disableEmails = $extraFieldValue->get_values_by_handler_and_field_variable(
                $receiverUserId,
                'disable_emails'
            );

            // User doesn't want email notifications but chamilo inbox still available.
            if (!empty($disableEmails) &&
                isset($disableEmails['value']) && 1 === (int) $disableEmails['value']
            ) {
                $sendEmail = false;
            }

            if ($sendEmail) {
                // Check if user pause his formation.
                $pause = $extraFieldValue->get_values_by_handler_and_field_variable(
                    $receiverUserId,
                    'pause_formation'
                );
                if (!empty($pause) && isset($pause['value']) && 1 === (int) $pause['value']) {
                    $startDate = $extraFieldValue->get_values_by_handler_and_field_variable(
                        $receiverUserId,
                        'start_pause_date'
                    );
                    $endDate = $extraFieldValue->get_values_by_handler_and_field_variable(
                        $receiverUserId,
                        'end_pause_date'
                    );

                    if (!empty($startDate) && isset($startDate['value']) && !empty($startDate['value']) &&
                        !empty($endDate) && isset($endDate['value']) && !empty($endDate['value'])
                    ) {
                        $now = time();
                        $start = api_strtotime($startDate['value']);
                        $end = api_strtotime($endDate['value']);

                        if ($now > $start && $now < $end) {
                            $sendEmail = false;
                        }
                    }
                }
            }
        }

        $totalFileSize = 0;
        $attachmentList = [];
        if (is_array($attachments)) {
            $counter = 0;
            foreach ($attachments as $attachment) {
                $attachment['comment'] = $fileCommentList[$counter] ?? '';
                $fileSize = $attachment['size'] ?? 0;
                if (is_array($fileSize)) {
                    foreach ($fileSize as $size) {
                        $totalFileSize += $size;
                    }
                } else {
                    $totalFileSize += $fileSize;
                }
                $attachmentList[] = $attachment;
                $counter++;
            }
        }

        if ($checkCurrentAudioId) {
            // Add the audio file as an attachment
            $audio = Session::read('current_audio');
            if (!empty($audio) && isset($audio['name']) && !empty($audio['name'])) {
                $audio['comment'] = 'audio_message';
                // create attachment from audio message
                $attachmentList[] = $audio;
            }
        }

        // Validating fields
        if (empty($subject) && empty($group_id)) {
            Display::addFlash(
                Display::return_message(
                    get_lang('You should write a subject'),
                    'warning'
                )
            );

            return false;
        } elseif ($totalFileSize > (int) api_get_setting('message_max_upload_filesize')) {
            $warning = sprintf(
                get_lang('Files size exceeds'),
                format_file_size(api_get_setting('message_max_upload_filesize'))
            );

            Display::addFlash(Display::return_message($warning, 'warning'));

            return false;
        }

        $em = Database::getManager();
        $repo = $em->getRepository(Message::class);
        $parent = null;
        if (!empty($parent_id)) {
            $parent = $repo->find($parent_id);
        }

        // Just in case we replace the and \n and \n\r while saving in the DB
        if (!empty($receiverUserId) || !empty($group_id)) {
            // message for user friend
            //@todo it's possible to edit a message? yes, only for groups
            if (!empty($editMessageId)) {
                $message = $repo->find($editMessageId);
                if (null !== $message) {
                    $message->setTitle($subject);
                    $message->setContent($content);
                    $em->persist($message);
                    $em->flush();
                }
                $messageId = $editMessageId;
            } else {
                $group = Container::getUsergroupRepository()->find($group_id);

                $message = (new Message())
                    ->setSender($userSender)
                    ->addReceiverTo($userRecipient)
                    ->setTitle($subject)
                    ->setContent($content)
                    ->setGroup($group)
                    ->setParent($parent)
                ;

                if (isset($msgType)) {
                    $message->setMsgType($msgType);
                }

                $em->persist($message);
                $em->flush();
                $messageId = $message->getId();
            }

            // Forward also message attachments.
            if (!empty($forwardId)) {
                $forwardMessage = $repo->find($forwardId);
                if (null !== $forwardMessage) {
                    $forwardAttachments = $forwardMessage->getAttachments();
                    foreach ($forwardAttachments as $forwardAttachment) {
                        $message->addAttachment($forwardAttachment);
                    }
                    $em->persist($message);
                    $em->flush();
                }
            }

            // Save attachment file for inbox messages
            if (is_array($attachmentList)) {
                foreach ($attachmentList as $attachment) {
                    if (0 === ($attachment['error'] ?? 0)) {
                        self::saveMessageAttachmentFile(
                            $attachment,
                            $attachment['comment'] ?? '',
                            $message,
                        );
                    }
                }
            }

            // Add the sender as a receiver with TYPE_SENDER
            $messageRelUserRepository = $em->getRepository(MessageRelUser::class);
            $existingRelation = $messageRelUserRepository->findOneBy([
                'message' => $message,
                'receiver' => $userSender,
                'receiverType' => MessageRelUser::TYPE_SENDER
            ]);

            if (!$existingRelation) {
                $messageRelUserSender = new MessageRelUser();
                $messageRelUserSender->setMessage($message);
                $messageRelUserSender->setReceiver($userSender);
                $messageRelUserSender->setReceiverType(MessageRelUser::TYPE_SENDER);
                $em->persist($messageRelUserSender);
                $em->flush();
            }

            // Email notification (optional)
            if ($sendEmail) {
                $notification = new Notification();
                $sender_info = api_get_user_info($user_sender_id);
                $baseUrl = $baseUrl ?? api_get_path(WEB_PATH);
                $contentForEmail = self::processRelativeLinks($content, $baseUrl);

                // Add file attachment additional attributes
                $attachmentAddedByMail = [];
                foreach ($attachmentList as $attachment) {
                    $attachmentAddedByMail[] = [
                        'path' => $attachment['tmp_name'] ?? '',
                        'filename' => $attachment['name'] ?? '',
                    ];
                }

                if (empty($group_id)) {
                    $type = Notification::NOTIFICATION_TYPE_MESSAGE;
                    if ($directMessage) {
                        $type = Notification::NOTIFICATION_TYPE_DIRECT_MESSAGE;
                    }
                    $notification->saveNotification(
                        $messageId,
                        $type,
                        [$receiverUserId],
                        $subject,
                        $contentForEmail,
                        $sender_info,
                        $attachmentAddedByMail,
                        $forceTitleWhenSendingEmail,
                        $baseUrl
                    );
                } else {
                    $usergroup = new UserGroupModel();
                    $group_info = $usergroup->get($group_id);
                    $group_info['topic_id'] = $topic_id;
                    $group_info['msg_id'] = $messageId;

                    $user_list = $usergroup->get_users_by_group(
                        $group_id,
                        false,
                        [],
                        0,
                        1000
                    );

                    // Add more context for group message subject
                    $subjectGroup = sprintf(get_lang('There is a new message in group %s'), $group_info['title']);
                    $new_user_list = [];
                    foreach ($user_list as $user_data) {
                        $new_user_list[] = $user_data['id'];
                    }

                    $groupPayload = [
                        'group_info' => $group_info,
                        'user_info' => $sender_info,
                    ];

                    $notification->saveNotification(
                        $messageId,
                        Notification::NOTIFICATION_TYPE_GROUP,
                        $new_user_list,
                        $subjectGroup,
                        $contentForEmail,
                        $groupPayload,
                        $attachmentAddedByMail,
                        $forceTitleWhenSendingEmail,
                        $baseUrl
                    );
                }
            }

            return $messageId;
        }

        return false;
    }