Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

namespace core_communication;

use core\context;

use core_communication\task\add_members_to_room_task;

use core_communication\task\create_and_configure_room_task;

use core_communication\task\delete_room_task;

use core_communication\task\remove_members_from_room;

use core_communication\task\synchronise_provider_task;

use core_communication\task\update_room_task;

use core_communication\task\update_room_membership_task;

use stdClass;

/**

 * Class api is the public endpoint of the communication api. This class is the point of contact for api usage.

 *

 * Communication api allows to add ad-hoc tasks to the queue to perform actions on the communication providers. This api will

 * not allow any immediate actions to be performed on the communication providers. It will only add the tasks to the queue. The

 * exception has been made for deletion of members in case of deleting the user. This is because the user will not be available.

 * The member management api part allows run actions immediately if required.

 *

 * Communication api does allow to have form elements related to communication api in the required forms. This is done by using

 * the form_definition method. This method will add the form elements to the form.

 *

 * @package    core_communication

 * @copyright  2023 Safat Shahin <safat.shahin@moodle.com>

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class api {

    /**

     * @var null|processor $communication The communication settings object

     */

    private ?processor $communication;

    /**

     * Communication handler constructor to manage and handle all communication related actions.

     *

     * This class is the entrypoint for all kinda usages.

     * It will be used by the other api to manage the communication providers.

     *

     * @param context $context The context of the item for the instance

     * @param string $component The component of the item for the instance

     * @param string $instancetype The type of the item for the instance

     * @param int $instanceid The id of the instance

     * @param string|null $provider The provider type - if null will load for this context's active provider.

     *

     */

    private function __construct(

        private context $context,

        private string $component,

        private string $instancetype,

        private int $instanceid,

        private ?string $provider = null,

    ) {

        $this->communication = processor::load_by_instance(

            context: $context,

            component: $component,

            instancetype: $instancetype,

            instanceid: $instanceid,

            provider: $provider,

        );

    }

    /**

     * Get the communication processor object.

     *

     * @param context $context The context of the item for the instance

     * @param string $component The component of the item for the instance

     * @param string $instancetype The type of the item for the instance

     * @param int $instanceid The id of the instance

     * @param string|null $provider The provider type - if null will load for this context's active provider.

     * @return api

     */

    public static function load_by_instance(

        context $context,

        string $component,

        string $instancetype,

        int $instanceid,

        ?string $provider = null,

    ): self {

        return new self(

            context: $context,

            component: $component,

            instancetype: $instancetype,

            instanceid: $instanceid,

            provider: $provider,

        );

    }

    /**

     * Reload in the internal instance data.

     */

    public function reload(): void {

        $this->communication = processor::load_by_instance(

            context: $this->context,

            component: $this->component,

            instancetype: $this->instancetype,

            instanceid: $this->instanceid,

            provider: $this->provider,

        );

    }

    /**

     * Return the underlying communication processor object.

     *

     * @return ?processor

     */

    public function get_processor(): ?processor {

        return $this->communication;

    }

    /**

     * Return the room provider.

     *

     * @return \core_communication\room_chat_provider

     */

    public function get_room_provider(): \core_communication\room_chat_provider {

        return $this->communication->get_room_provider();

    }

    /**

     * Return the user provider.

     *

     * @return \core_communication\user_provider

     */

    public function get_user_provider(): \core_communication\user_provider {

        return $this->communication->get_user_provider();

    }

    /**

     * Return the room user provider.

     *

     * @return \core_communication\room_user_provider

     */

    public function get_room_user_provider(): \core_communication\room_user_provider {

        return $this->communication->get_room_user_provider();

    }

    /**

     * Return the form provider.

     *

     * @return \core_communication\form_provider

     */

    public function get_form_provider(): \core_communication\form_provider {

        return $this->communication->get_form_provider();

    }

    /**

     * Check if the communication api is enabled.

     */

    public static function is_available(): bool {

        return (bool) get_config('core', 'enablecommunicationsubsystem');

    }

    /**

     * Get the communication room url.

     *

     * @return string|null

     */

    public function get_communication_room_url(): ?string {

        return $this->communication?->get_room_url();

    }

    /**

     * Get the list of plugins for form selection.

     *

     * @return array

     */

    public static function get_communication_plugin_list_for_form(): array {

        // Add the option to have communication disabled.

        $selection[processor::PROVIDER_NONE] = get_string('nocommunicationselected', 'communication');

        $communicationplugins = \core\plugininfo\communication::get_enabled_plugins();

        foreach ($communicationplugins as $pluginname => $notusing) {

            $provider = 'communication_' . $pluginname;

            if (processor::is_provider_available($provider)) {

                $selection[$provider] = get_string('pluginname', 'communication_' . $pluginname);

            }

        }

        return $selection;

    }

    /**

     * Get the enabled communication providers and default provider according to the selected provider.

     *

     * @param string|null $selecteddefaulprovider

     * @return array

     */

    public static function get_enabled_providers_and_default(string $selecteddefaulprovider = null): array {

        $communicationproviders = self::get_communication_plugin_list_for_form();

        $defaulprovider = processor::PROVIDER_NONE;

        if (!empty($selecteddefaulprovider) && array_key_exists($selecteddefaulprovider, $communicationproviders)) {

            $defaulprovider = $selecteddefaulprovider;

        }

        return [$communicationproviders, $defaulprovider];

    }

    /**

     * Define the form elements for the communication api.

     * This method will be called from the form definition method of the instance.

     *

     * @param \MoodleQuickForm $mform The form element

     * @param string $selectdefaultcommunication The default selected communication provider in the form field

     */

    public function form_definition(

        \MoodleQuickForm $mform,

        string $selectdefaultcommunication = processor::PROVIDER_NONE

    ): void {

        global $PAGE;

        [$communicationproviders, $defaulprovider] = self::get_enabled_providers_and_default($selectdefaultcommunication);

        $PAGE->requires->js_call_amd('core_communication/providerchooser', 'init');

        // List the communication providers.

        $mform->addElement(

            'select',

            'selectedcommunication',

            get_string('selectcommunicationprovider', 'communication'),

            $communicationproviders,

            ['data-communicationchooser-field' => 'selector'],

        );

        $mform->addHelpButton('selectedcommunication', 'selectcommunicationprovider', 'communication');

        $mform->setDefault('selectedcommunication', $defaulprovider);

        $mform->registerNoSubmitButton('updatecommunicationprovider');

        $mform->addElement(

            'submit',

            'updatecommunicationprovider',

            'update communication',

            ['data-communicationchooser-field' => 'updateButton', 'class' => 'd-none']

        );

        // Just a placeholder for the communication options.

        $mform->addElement('hidden', 'addcommunicationoptionshere');

        $mform->setType('addcommunicationoptionshere', PARAM_BOOL);

    }

    /**

     * Set the form definitions for the plugins.

     *

     * @param \MoodleQuickForm $mform The moodle form

     * @param string $provider The provider name

     */

    public function form_definition_for_provider(\MoodleQuickForm $mform, string $provider = processor::PROVIDER_NONE): void {

        if ($provider === processor::PROVIDER_NONE) {

            return;

        }

        // Room name for the communication provider.

        $mform->insertElementBefore(

            $mform->createElement(

                'text',

                $provider . 'roomname',

                get_string('communicationroomname', 'communication'),

                'maxlength="100" size="20"'

            ),

            'addcommunicationoptionshere'

        );

        $mform->setType($provider . 'roomname', PARAM_TEXT);

        $mform->insertElementBefore(

            $mform->createElement(

                'static',

                'communicationroomnameinfo',

                '',

                get_string('communicationroomnameinfo', 'communication'),

            ),

            'addcommunicationoptionshere',

        );

        processor::set_provider_specific_form_definition($provider, $mform);

    }

    /**

     * Get the avatar file.

     *

     * @return null|\stored_file

     */

    public function get_avatar(): ?\stored_file {

        $filename = $this->communication->get_avatar_filename();

        if ($filename === null) {

            return null;

        }

        $fs = get_file_storage();

        $args = (array) $this->get_avatar_filerecord($filename);

        return $fs->get_file(...$args) ?: null;

    }

    /**

     * Get the avatar file record for the avatar for filesystem.

     *

     * @param string $filename The filename of the avatar

     * @return stdClass

     */

    protected function get_avatar_filerecord(string $filename): stdClass {

        return (object) [

            'contextid' => \core\context\system::instance()->id,

            'component' => 'core_communication',

            'filearea' => 'avatar',

            'itemid' => $this->communication->get_id(),

            'filepath' => '/',

            'filename' => $filename,

        ];

    }

    /**

     * Get the avatar file.

     *

     * If null is set, then delete the old area file and set the avatarfilename to null.

     * This will make sure the plugin api deletes the avatar from the room.

     *

     * @param null|\stored_file $avatar The stored file for the avatar

     * @return bool

     */

    public function set_avatar(?\stored_file $avatar): bool {

        $currentfilename = $this->communication->get_avatar_filename();

        if ($avatar === null && empty($currentfilename)) {

            return false;

        }

        $currentfilerecord = $this->get_avatar();

        if ($avatar && $currentfilerecord) {

            $currentfilehash = $currentfilerecord->get_contenthash();

            $updatedfilehash = $avatar->get_contenthash();

            // No update required.

            if ($currentfilehash === $updatedfilehash) {

                return false;

            }

        }

        $context = \core\context\system::instance();

        $fs = get_file_storage();

        $fs->delete_area_files(

            $context->id,

            'core_communication',

            'avatar',

            $this->communication->get_id()

        );

        if ($avatar) {

            $fs->create_file_from_storedfile(

                $this->get_avatar_filerecord($avatar->get_filename()),

                $avatar,

            );

            $this->communication->set_avatar_filename($avatar->get_filename());

        } else {

            $this->communication->set_avatar_filename(null);

        }

        // Indicate that we need to sync the avatar when the update task is run.

        $this->communication->set_avatar_synced_flag(false);

        return true;

    }

    /**

     * A helper to fetch the room name

     *

     * @return string

     */

    public function get_room_name(): string {

        if (!$this->communication) {

            return '';

        }

        return $this->communication->get_room_name();

    }

    /**

     * Set the form data if the data is already available.

     *

     * @param \stdClass $instance The instance object

     */

    public function set_data(\stdClass $instance): void {

        if (!empty($instance->id) && $this->communication) {

            $instance->selectedcommunication = $this->communication->get_provider();

            $roomnameidentifier = $this->get_provider() . 'roomname';

            $instance->$roomnameidentifier = $this->communication->get_room_name();

            $this->communication->get_form_provider()->set_form_data($instance);

        }

    }

    /**

     * Get the communication provider.

     *

     * @return string

     */

    public function get_provider(): string {

        if (!$this->communication) {

            return '';

        }

        return $this->communication->get_provider();

    }

    /**

     * Configure the room and membership by provider selected for the communication instance.

     *

     * This method will add a task to the queue to configure the room and membership by comparing the change of provider.

     * There are some major cases to consider for this method to allow minimum duplication when this api is used.

     * Some of the major cases are:

     * 1. If the communication instance is not created at all, then create it and add members.

     * 2. If the current provider is none and the new provider is also none, then nothing to do.

     * 3. If the current and existing provider is the same, don't need to do anything.

     * 4. If provider set to none, remove all the members.

     * 5. If previous provider was not none and current provider is not none, but a different provider, remove members and add

     * for the new one.

     * 6. If previous provider was none and current provider is not none, don't need to remove, just

     * update the selected provider and add users to that provider. Do not queue the task to add members to room as the room

     * might not have created yet. The add room task adds the task to add members to room anyway.

     * 7. If it's a new provider, never used/created, now create the room after considering all these cases for a new provider.

     *

     * @param string $provider The provider name

     * @param \stdClass $instance The instance object

     * @param string $communicationroomname The communication room name

     * @param array $users The user ids to add to the room

     * @param null|\stored_file $instanceimage The stored file for the avatar

     * @param bool $queue Queue the task for the provider room or not

     */

    public function configure_room_and_membership_by_provider(

        string $provider,

        stdClass $instance,

        string $communicationroomname,

        array $users,

        ?\stored_file $instanceimage = null,

        bool $queue = true,

    ): void {

        // If the current provider is inactive and the new provider is also none, then nothing to do.

        if (

            $this->communication !== null &&

            $this->communication->get_provider_status() === processor::PROVIDER_INACTIVE &&

            $provider === processor::PROVIDER_NONE

        ) {

            return;

        }

        // If provider set to none, remove all the members.

        if (

            $this->communication !== null &&

            $this->communication->get_provider_status() === processor::PROVIDER_ACTIVE &&

            $provider === processor::PROVIDER_NONE

        ) {

            $this->remove_all_members_from_room();

            $this->update_room(

                active: processor::PROVIDER_INACTIVE,

                communicationroomname: $communicationroomname,

                avatar: $instanceimage,

                instance: $instance,

                queue: $queue,

            );

            return;

        }

        if (

            // If previous provider was active and not none and current provider is not none, but a different provider,

            // remove members and de-activate the previous provider.

            $this->communication !== null &&

            $this->communication->get_provider_status() === processor::PROVIDER_ACTIVE &&

            $provider !== $this->get_provider()

        ) {

            $this->remove_all_members_from_room();

            // Now deactivate the previous provider.

            $this->update_room(

                active: processor::PROVIDER_INACTIVE,

                instance: $instance,

                queue: $queue,

            );

        }

        // Now re-init the constructor for the new provider.

        $this->__construct(

            context: $this->context,

            component: $this->component,

            instancetype: $this->instancetype,

            instanceid: $this->instanceid,

            provider: $provider,

        );

        // If it's a new provider, never used/created, now create the room.

        if ($this->communication === null) {

            $this->create_and_configure_room(

                communicationroomname: $communicationroomname,

                avatar: $instanceimage,

                instance: $instance,

                queue: $queue,

            );

            $queueusertask = false;

        } else {

            // Otherwise update the room.

            $this->update_room(

                active: processor::PROVIDER_ACTIVE,

                communicationroomname: $communicationroomname,

                avatar: $instanceimage,

                instance: $instance,

                queue: $queue,

            );

            $queueusertask = true;

        }

        // Now add the members.

        $this->add_members_to_room(

            userids: $users,

            queue: $queueusertask,

        );

    }

    /**

     * Create a communication ad-hoc task for create operation.

     * This method will add a task to the queue to create the room.

     *

     * @param string $communicationroomname The communication room name

     * @param null|\stored_file $avatar The stored file for the avatar

     * @param \stdClass|null $instance The actual instance object

     * @param bool $queue Whether to queue the task or not

     */

    public function create_and_configure_room(

        string $communicationroomname,

        ?\stored_file $avatar = null,

        ?\stdClass $instance = null,

        bool $queue = true,

    ): void {

        if ($this->provider === processor::PROVIDER_NONE || $this->provider === '') {

            return;

        }

        // Create communication record.

        $this->communication = processor::create_instance(

            context: $this->context,

            provider: $this->provider,

            instanceid: $this->instanceid,

            component: $this->component,

            instancetype: $this->instancetype,

            roomname: $communicationroomname,

        );

        // Update provider record from form data.

        if ($instance !== null) {

            $this->communication->get_form_provider()->save_form_data($instance);

        }

        // Set the avatar.

        if (!empty($avatar)) {

            $this->set_avatar($avatar);

        }

        // Nothing else to do if the queue is false.

        if (!$queue) {

            return;

        }

        // Add ad-hoc task to create the provider room.

        create_and_configure_room_task::queue(

            $this->communication,

        );

    }

    /**

     * Create a communication ad-hoc task for update operation.

     * This method will add a task to the queue to update the room.

     *

     * @param null|int $active The selected active state of the provider

     * @param null|string $communicationroomname The communication room name

     * @param null|\stored_file $avatar The stored file for the avatar

     * @param \stdClass|null $instance The actual instance object

     * @param bool $queue Whether to queue the task or not

     */

    public function update_room(

        ?int $active = null,

        ?string $communicationroomname = null,

        ?\stored_file $avatar = null,

        ?\stdClass $instance = null,

        bool $queue = true,

    ): void {

        if (!$this->communication) {

            return;

        }

        // If the provider is none, we don't need to do anything from room point of view.

        if ($this->communication->get_provider() === processor::PROVIDER_NONE) {

            return;

        }

        $roomnamechange = null;

        $activestatuschange = null;

        // Check if the room name is being changed.

        if (

            $communicationroomname !== null &&

            $communicationroomname !== $this->communication->get_room_name()

        ) {

            $roomnamechange = $communicationroomname;

        }

        // Check if the active status of the provider is being changed.

        if (

            $active !== null &&

            $active !== $this->communication->is_instance_active()

        ) {

            $activestatuschange = $active;

        }

        if ($roomnamechange !== null || $activestatuschange !== null) {

            $this->communication->update_instance(

                active: $active,

                roomname: $communicationroomname,

            );

        }

        // Update provider record from form data.

        if ($instance !== null) {

            $this->communication->get_form_provider()->save_form_data($instance);

        }

        // Update the avatar.

        // If the value is `null`, then unset the avatar.

        $this->set_avatar($avatar);

        // Nothing else to do if the queue is false.

        if (!$queue) {

            return;

        }

        // Always queue a room update, even if none of the above standard fields have changed.

        // It is possible for providers to have custom fields that have been updated.

        update_room_task::queue(

            $this->communication,

        );

    }

    /**

     * Create a communication ad-hoc task for delete operation.

     * This method will add a task to the queue to delete the room.

     */

    public function delete_room(): void {

        if ($this->communication !== null) {

            // Add the ad-hoc task to remove the room data from the communication table and associated provider actions.

            delete_room_task::queue(

                $this->communication,

            );

        }

    }

    /**

     * Create a communication ad-hoc task for add members operation and add the user mapping.

     *

     * This method will add a task to the queue to add the room users.

     *

     * @param array $userids The user ids to add to the room

     * @param bool $queue Whether to queue the task or not

     */

    public function add_members_to_room(array $userids, bool $queue = true): void {

        // No communication object? something not done right.

        if (!$this->communication) {

            return;

        }

        // No user IDs or this provider does not manage users? No action required.

        if (empty($userids) || !$this->communication->supports_user_features()) {

            return;

        }

        $this->communication->create_instance_user_mapping($userids);

        if ($queue) {

            add_members_to_room_task::queue(

                $this->communication

            );

        }

    }

    /**

     * Create a communication ad-hoc task for updating members operation and update the user mapping.

     *

     * This method will add a task to the queue to update the room users.

     *

     * @param array $userids The user ids to add to the room

     * @param bool $queue Whether to queue the task or not

     */

    public function update_room_membership(array $userids, bool $queue = true): void {

        // No communication object? something not done right.

        if (!$this->communication) {

            return;

        }

        // No userids? don't bother doing anything.

        if (empty($userids)) {

            return;

        }

        $this->communication->reset_users_sync_flag($userids);

        if ($queue) {

            update_room_membership_task::queue(

                $this->communication

            );

        }

    }

    /**

     * Create a communication ad-hoc task for remove members operation or action immediately.

     *

     * This method will add a task to the queue to remove the room users.

     *

     * @param array $userids The user ids to remove from the room

     * @param bool $queue Whether to queue the task or not

     */

    public function remove_members_from_room(array $userids, bool $queue = true): void {

        // No communication object? something not done right.

        if (!$this->communication) {

            return;

        }

        $provider = $this->communication->get_provider();

        if ($provider === processor::PROVIDER_NONE) {

            return;

        }

        // No user IDs or this provider does not manage users? No action required.

        if (empty($userids) || !$this->communication->supports_user_features()) {

            return;

        }

        $this->communication->add_delete_user_flag($userids);

        if ($queue) {

            remove_members_from_room::queue(

                $this->communication

            );

        }

    }

    /**

     * Remove all users from the room.

     *

     * @param bool $queue Whether to queue the task or not

     */

    public function remove_all_members_from_room(bool $queue = true): void {

        // No communication object? something not done right.

        if (!$this->communication) {

            return;

        }

        if ($this->communication->get_provider() === processor::PROVIDER_NONE) {

            return;

        }

        // This provider does not manage users? No action required.

        if (!$this->communication->supports_user_features()) {

            return;

        }

        $this->communication->add_delete_user_flag($this->communication->get_all_userids_for_instance());

        if ($queue) {

            remove_members_from_room::queue(

                $this->communication

            );

        }

    }

    /**

     * Display the communication room status notification.

     */

    public function show_communication_room_status_notification(): void {

        // No communication, no room.

        if (!$this->communication) {

            return;

        }

        if ($this->communication->get_provider() === processor::PROVIDER_NONE) {

            return;

        }

        $roomstatus = $this->get_communication_room_url()

            ? constants::COMMUNICATION_STATUS_READY

            : constants::COMMUNICATION_STATUS_PENDING;

        $pluginname = get_string('pluginname', $this->get_provider());

        $message = get_string('communicationroom' . $roomstatus, 'communication', $pluginname);

        // We only show the ready notification once per user.

        // We check this with a custom user preference.

        $roomreadypreference = "{$this->component}_{$this->instancetype}_{$this->instanceid}_room_ready";

        switch ($roomstatus) {

            case constants::COMMUNICATION_STATUS_PENDING:

                \core\notification::add($message, \core\notification::INFO);

                unset_user_preference($roomreadypreference);

                break;

            case constants::COMMUNICATION_STATUS_READY:

                if (empty(get_user_preferences($roomreadypreference))) {

                    \core\notification::add($message, \core\notification::SUCCESS);

                    set_user_preference($roomreadypreference, true);

                }

                break;

        }

    }

    /**

     * Add the task to sync the provider data with local Moodle data.

     */

    public function sync_provider(): void {

        // No communication, return.

        if (!$this->communication) {

            return;

        }

        if ($this->communication->get_provider() === processor::PROVIDER_NONE) {

            return;

        }

        synchronise_provider_task::queue(

            $this->communication

        );

    }

}