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

/**

 * Various actions on badges - enabling, disabling, etc.

 *

 * @module      core_badges/actions

 * @copyright   2024 Sara Arjona <sara@moodle.com>

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

 */

import selectors from 'core_badges/selectors';

import Notification from 'core/notification';

import {prefetchStrings} from 'core/prefetch';

import {getString} from 'core/str';

import Ajax from 'core/ajax';

import Pending from 'core/pending';

import {dispatchEvent} from 'core/event_dispatcher';

import {add as addToast} from 'core/toast';

import * as reportEvents from 'core_reportbuilder/local/events';

import * as reportSelectors from 'core_reportbuilder/local/selectors';

/**

 * Initialize module.

 */

export const init = () => {

    prefetchStrings('core_badges', [

        'reviewconfirm',

        'activatesuccess',

        'deactivatesuccess',

        'awardoncron',

        'numawardstat',

    ]);

    prefetchStrings('core', [

        'confirm',

        'enable',

    ]);

    registerEventListeners();

};

/**

 * Register events for delete preset option in action menu.

 */

const registerEventListeners = () => {

    document.addEventListener('click', (event) => {

        const enableOption = event.target.closest(selectors.actions.enablebadge);

        if (enableOption) {

            event.preventDefault();

            // Use triggerElement to return focus to the action menu toggle.

            const reportElement = event.target.closest(reportSelectors.regions.report);

            const triggerElement = reportElement ? enableOption.closest('.dropdown').querySelector('.dropdown-toggle') : null;

            const badgeId = enableOption.dataset.badgeid;

            const badgeName = enableOption.dataset.badgename;

            Notification.saveCancelPromise(

                getString('confirm', 'core'),

                getString('reviewconfirm', 'core_badges', badgeName),

                getString('enable', 'core'),

                {triggerElement}

            ).then(() => {

                return enableBadge(badgeId, badgeName, reportElement);

            }).catch(() => {

                return;

            });

        }

        const disableOption = event.target.closest(selectors.actions.disablebadge);

        if (disableOption) {

            event.preventDefault();

            const badgeId = disableOption.dataset.badgeid;

            const badgeName = disableOption.dataset.badgename;

            const reportElement = event.target.closest(reportSelectors.regions.report);

            disableBadge(badgeId, badgeName, reportElement);

        }

    });

};

/**

 * Enable the badge.

 *

 * @param {Number} badgeId The id of the badge to enable.

 * @param {String} badgeName The name of the badge to enable.

 * @param {HTMLElement} reportElement the report element.

 */

async function enableBadge(badgeId, badgeName, reportElement) {

    var request = {

        methodname: 'core_badges_enable_badges',

        args: {

            badgeids: [badgeId],

        }

    };

    const pendingPromise = new Pending('core_badges/enable');

    try {

        const result = await Ajax.call([request])[0];

        if (reportElement) {

            showEnableResultToast(badgeName, result);

            // Report element is present, reload the table.

            dispatchEvent(reportEvents.tableReload, {preservePagination: true}, reportElement);

        } else {

            // Report element is not present, add the parameters to the current page to display the message.

            const awards = result.result?.pop().awards;

            document.location = document.location.pathname + `?id=${badgeId}&awards=${awards}`;

        }

    } catch (error) {

        Notification.exception(error);

    }

    pendingPromise.resolve();

}

/**

 * Show the result of enabling a badge.

 *

 * @param {String} badgeName The name of the badge to enable.

 * @param {Object} result The result of enabling a badge.

 */

function showEnableResultToast(badgeName, result) {

    if (result.result?.length > 0) {

        addToast(getString('activatesuccess', 'core_badges', badgeName), {type: 'success'});

        const awards = result.result?.pop().awards;

        if (awards == 'cron') {

            addToast(getString('awardoncron', 'core_badges', {badgename: badgeName}));

        } else if (awards > 0) {

            addToast(getString('numawardstat', 'core_badges', {badgename: badgeName, awards: awards}));

        }

    } else if (result.warnings.length > 0) {

        addToast(result.warnings[0].message, {type: 'danger'});

    }

}

/**

 * Disable the badge.

 *

 * @param {Number} badgeId The id of the badge to disable.

 * @param {String} badgeName The name of the badge to enable.

 * @param {HTMLElement} reportElement the report element.

 */

async function disableBadge(badgeId, badgeName, reportElement) {

    var request = {

        methodname: 'core_badges_disable_badges',

        args: {

            badgeids: [badgeId],

        }

    };

    try {

        const result = await Ajax.call([request])[0];

        if (reportElement) {

            // Report element is present, show the message in a toast and reload the table.

            showDisableResultToast(badgeName, result);

            dispatchEvent(reportEvents.tableReload, {preservePagination: true}, reportElement);

        } else {

            // Report element is not present, the page should be reloaded.

            document.location = document.location.pathname + `?id=${badgeId}`;

        }

    } catch (error) {

        Notification.exception(error);

    }

}

/**

 * Show the result of disabling a badge.

 *

 * @param {String} badgeName The name of the badge to disable.

 * @param {Object} result The result of disabling a badge.

 */

function showDisableResultToast(badgeName, result) {

    if (result.result) {

        addToast(

            getString('deactivatesuccess', 'core_badges', badgeName),

            {type: 'success'}

        );

    } else if (result.warnings.length > 0) {

        addToast(

            result.warnings[0].message,

            {type: 'danger'}

        );

    }

}