Proyectos de Subversion Moodle

// 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/>.

import PluginManagementTable from 'core_admin/plugin_management_table';
import {call as fetchMany} from 'core/ajax';
import {refreshTableContent} from 'core_table/dynamic';
import Pending from 'core/pending';
import {fetchNotifications} from 'core/notification';
import {prefetchStrings} from 'core/prefetch';
import {getString} from 'core/str';
import DeleteCancelModal from 'core/modal_delete_cancel';
import ModalEvents from 'core/modal_events';

let watching = false;

/**
 * Handles setting plugin state for the AI provider management table.
 *
 * @module     core_ai/aiprovider_instance_management_table
 * @copyright  2024 Matt Porritt <matt.porritt@moodle.com>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
export default class extends PluginManagementTable {
    constructor() {
        super();
        this.addClickHandler(this.handleDelete);
    }

    /**
     * Initialise an instance of the class.
     *
     * This is just a way of making it easier to initialise an instance of the class from PHP.
     */
    static init() {
        if (watching) {
            return;
        }

        prefetchStrings('core_ai', [
            'providerinstancedelete',
            'providerinstancedeleteconfirm',
        ]);

        watching = true;
        new this();
    }

    /**
     * Call the delete service.
     *
     * @param {string} methodname The web service to call
     * @param {number} providerid The provider id.
     * @return {Promise} The promise.
     */
    deleteProvider(methodname, providerid) {
        return fetchMany([{
            methodname,
            args: {
                providerid,
            },
        }])[0];
    }

    /**
     * Handle delete.
     *
     * @param {HTMLElement} tableRoot
     * @param {Event} e
     */
    async handleDelete(tableRoot, e) {
        const deleteElement = e.target.closest('[data-delete-method]');
        if (deleteElement) {
            e.preventDefault();
            const providerId = e.target.dataset.id;
            const deleteMethod = e.target.dataset.deleteMethod;
            const bodyParams = {
                provider: e.target.dataset.provider,
                name: e.target.dataset.name,
            };
            const modal = await DeleteCancelModal.create({
                title: getString('providerinstancedelete', 'core_ai'),
                body: getString('providerinstancedeleteconfirm', 'core_ai', bodyParams),
                show: true,
                removeOnClose: true,
            });

            // Handle delete event.
            modal.getRoot().on(ModalEvents.delete, async(e) => {
                e.preventDefault();
                const pendingPromise = new Pending('core_table/dynamic:deleteProvider');
                await this.deleteProvider(deleteMethod, providerId);
                // Reload the table, so we get the updated list of providers, and any messages.
                await Promise.all([
                    refreshTableContent(tableRoot),
                    fetchNotifications(),
                ]);
                modal.destroy();
                pendingPromise.resolve();
            });
        }
    }
}