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

/**

 * Plan actions via ajax.

 *

 * @module     tool_lp/planactions

 * @copyright  2015 David Monllao

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

 */

define(['jquery',

        'core/templates',

        'core/ajax',

        'core/notification',

        'core/str',

        'tool_lp/menubar',

        'tool_lp/dialogue'],

        function($, templates, ajax, notification, str, Menubar, Dialogue) {

    /**

     * PlanActions class.

     *

     * Note that presently this cannot be instantiated more than once per page.

     *

     * @param {String} type The type of page we're in.

     */

    var PlanActions = function(type) {

        this._type = type;

        if (type === 'plan') {

            // This is the page to view one plan.

            this._region = '[data-region="plan-page"]';

            this._planNode = '[data-region="plan-page"]';

            this._template = 'tool_lp/plan_page';

            this._contextMethod = 'tool_lp_data_for_plan_page';

        } else if (type === 'plans') {

            // This is the page to view a list of plans.

            this._region = '[data-region="plans"]';

            this._planNode = '[data-region="plan-node"]';

            this._template = 'tool_lp/plans_page';

            this._contextMethod = 'tool_lp_data_for_plans_page';

        } else {

            throw new TypeError('Unexpected type.');

        }

    };

    /** @property {String} Ajax method to fetch the page data from. */

    PlanActions.prototype._contextMethod = null;

    /** @property {String} Selector to find the node describing the plan. */

    PlanActions.prototype._planNode = null;

    /** @property {String} Selector mapping to the region to update. Usually similar to wrapper. */

    PlanActions.prototype._region = null;

    /** @property {String} Name of the template used to render the region. */

    PlanActions.prototype._template = null;

    /** @property {String} Type of page/region we're in. */

    PlanActions.prototype._type = null;

    /**

     * Resolve the arguments to refresh the region.

     *

     * @param  {Object} planData Plan data from plan node.

     * @return {Object} List of arguments.

     */

    PlanActions.prototype._getContextArgs = function(planData) {

        var self = this,

            args = {};

        if (self._type === 'plan') {

            args = {

                planid: planData.id

            };

        } else if (self._type === 'plans') {

            args = {

                userid: planData.userid

            };

        }

        return args;

    };

    /**

     * Refresh the plan view.

     *

     * This is useful when you only want to refresh the view.

     *

     * @param  {String} selector The node to search the plan data from.

     */

    PlanActions.prototype.refresh = function(selector) {

        var planData = this._findPlanData($(selector));

        this._callAndRefresh([], planData);

    };

    /**

     * Callback to render the region template.

     *

     * @param {Object} context The context for the template.

     * @return {Promise}

     */

    PlanActions.prototype._renderView = function(context) {

        var self = this;

        return templates.render(self._template, context)

            .then(function(newhtml, newjs) {

                $(self._region).replaceWith(newhtml);

                templates.runTemplateJS(newjs);

                return;

            });

    };

    /**

     * Call multiple ajax methods, and refresh.

     *

     * @param  {Array}  calls    List of Ajax calls.

     * @param  {Object} planData Plan data from plan node.

     * @return {Promise}

     */

    PlanActions.prototype._callAndRefresh = function(calls, planData) {

        // Because this function causes a refresh, we must track the JS completion from start to finish to prevent

        // stale reference issues in Behat.

        var callKey = 'tool_lp/planactions:_callAndRefresh-' + Math.floor(Math.random() * Math.floor(1000));

        M.util.js_pending(callKey);

        var self = this;

        calls.push({

            methodname: self._contextMethod,

            args: self._getContextArgs(planData)

        });

        // Apply all the promises, and refresh when the last one is resolved.

        return $.when.apply($, ajax.call(calls))

            .then(function() {

                return self._renderView(arguments[arguments.length - 1]);

            })

            .fail(notification.exception)

            .always(function() {

                return M.util.js_complete(callKey);

            });

    };

    /**

     * Delete a plan and reload the region.

     *

     * @param  {Object} planData Plan data from plan node.

     */

    PlanActions.prototype._doDelete = function(planData) {

        var self = this,

            calls = [{

                methodname: 'core_competency_delete_plan',

                args: {id: planData.id}

            }];

        self._callAndRefresh(calls, planData);

    };

    /**

     * Delete a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     */

    PlanActions.prototype.deletePlan = function(planData) {

        var self = this,

            requests;

        requests = ajax.call([{

            methodname: 'core_competency_read_plan',

            args: {id: planData.id}

        }]);

        requests[0].done(function(plan) {

            str.get_strings([

                {key: 'confirm', component: 'moodle'},

                {key: 'deleteplan', component: 'tool_lp', param: plan.name},

                {key: 'delete', component: 'moodle'},

                {key: 'cancel', component: 'moodle'}

            ]).done(function(strings) {

                notification.confirm(

                    strings[0], // Confirm.

                    strings[1], // Delete plan X?

                    strings[2], // Delete.

                    strings[3], // Cancel.

                    function() {

                        self._doDelete(planData);

                    }

                );

            }).fail(notification.exception);

        }).fail(notification.exception);

    };

    /**

     * Reopen plan and reload the region.

     *

     * @param  {Object} planData Plan data from plan node.

     */

    PlanActions.prototype._doReopenPlan = function(planData) {

        var self = this,

            calls = [{

                methodname: 'core_competency_reopen_plan',

                args: {planid: planData.id}

            }];

        self._callAndRefresh(calls, planData);

    };

    /**

     * Reopen a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     */

    PlanActions.prototype.reopenPlan = function(planData) {

        var self = this,

            requests = ajax.call([{

                methodname: 'core_competency_read_plan',

                args: {id: planData.id}

            }]);

        requests[0].done(function(plan) {

            str.get_strings([

                {key: 'confirm', component: 'moodle'},

                {key: 'reopenplanconfirm', component: 'tool_lp', param: plan.name},

                {key: 'reopenplan', component: 'tool_lp'},

                {key: 'cancel', component: 'moodle'}

            ]).done(function(strings) {

                notification.confirm(

                    strings[0], // Confirm.

                    strings[1], // Reopen plan X?

                    strings[2], // Reopen.

                    strings[3], // Cancel.

                    function() {

                        self._doReopenPlan(planData);

                    }

                );

            }).fail(notification.exception);

        }).fail(notification.exception);

    };

    /**

     * Complete plan and reload the region.

     *

     * @param  {Object} planData Plan data from plan node.

     */

    PlanActions.prototype._doCompletePlan = function(planData) {

        var self = this,

            calls = [{

                methodname: 'core_competency_complete_plan',

                args: {planid: planData.id}

            }];

        self._callAndRefresh(calls, planData);

    };

    /**

     * Complete a plan process.

     *

     * @param  {Object} planData Plan data from plan node.

     */

    PlanActions.prototype.completePlan = function(planData) {

        var self = this,

            requests = ajax.call([{

                methodname: 'core_competency_read_plan',

                args: {id: planData.id}

            }]);

        requests[0].done(function(plan) {

            str.get_strings([

                {key: 'confirm', component: 'moodle'},

                {key: 'completeplanconfirm', component: 'tool_lp', param: plan.name},

                {key: 'completeplan', component: 'tool_lp'},

                {key: 'cancel', component: 'moodle'}

            ]).done(function(strings) {

                notification.confirm(

                    strings[0], // Confirm.

                    strings[1], // Complete plan X?

                    strings[2], // Complete.

                    strings[3], // Cancel.

                    function() {

                        self._doCompletePlan(planData);

                    }

                );

            }).fail(notification.exception);

        }).fail(notification.exception);

    };

    /**

     * Unlink plan and reload the region.

     *

     * @param  {Object} planData Plan data from plan node.

     */

    PlanActions.prototype._doUnlinkPlan = function(planData) {

        var self = this,

            calls = [{

                methodname: 'core_competency_unlink_plan_from_template',

                args: {planid: planData.id}

            }];

        self._callAndRefresh(calls, planData);

    };

    /**

     * Unlink a plan process.

     *

     * @param  {Object} planData Plan data from plan node.

     */

    PlanActions.prototype.unlinkPlan = function(planData) {

        var self = this,

            requests = ajax.call([{

                methodname: 'core_competency_read_plan',

                args: {id: planData.id}

            }]);

        requests[0].done(function(plan) {

            str.get_strings([

                {key: 'confirm', component: 'moodle'},

                {key: 'unlinkplantemplateconfirm', component: 'tool_lp', param: plan.name},

                {key: 'unlinkplantemplate', component: 'tool_lp'},

                {key: 'cancel', component: 'moodle'}

            ]).done(function(strings) {

                notification.confirm(

                    strings[0], // Confirm.

                    strings[1], // Unlink plan X?

                    strings[2], // Unlink.

                    strings[3], // Cancel.

                    function() {

                        self._doUnlinkPlan(planData);

                    }

                );

            }).fail(notification.exception);

        }).fail(notification.exception);

    };

    /**

     * Request review of a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     * @method _doRequestReview

     */

    PlanActions.prototype._doRequestReview = function(planData) {

        var calls = [{

            methodname: 'core_competency_plan_request_review',

            args: {

                id: planData.id

            }

        }];

        this._callAndRefresh(calls, planData);

    };

    /**

     * Request review of a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     * @method requestReview

     */

    PlanActions.prototype.requestReview = function(planData) {

        this._doRequestReview(planData);

    };

    /**

     * Cancel review request of a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     * @method _doCancelReviewRequest

     */

    PlanActions.prototype._doCancelReviewRequest = function(planData) {

        var calls = [{

            methodname: 'core_competency_plan_cancel_review_request',

            args: {

                id: planData.id

            }

        }];

        this._callAndRefresh(calls, planData);

    };

    /**

     * Cancel review request of a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     * @method cancelReviewRequest

     */

    PlanActions.prototype.cancelReviewRequest = function(planData) {

        this._doCancelReviewRequest(planData);

    };

    /**

     * Start review of a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     * @method _doStartReview

     */

    PlanActions.prototype._doStartReview = function(planData) {

        var calls = [{

            methodname: 'core_competency_plan_start_review',

            args: {

                id: planData.id

            }

        }];

        this._callAndRefresh(calls, planData);

    };

    /**

     * Start review of a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     * @method startReview

     */

    PlanActions.prototype.startReview = function(planData) {

        this._doStartReview(planData);

    };

    /**

     * Stop review of a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     * @method _doStopReview

     */

    PlanActions.prototype._doStopReview = function(planData) {

        var calls = [{

            methodname: 'core_competency_plan_stop_review',

            args: {

                id: planData.id

            }

        }];

        this._callAndRefresh(calls, planData);

    };

    /**

     * Stop review of a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     * @method stopReview

     */

    PlanActions.prototype.stopReview = function(planData) {

        this._doStopReview(planData);

    };

    /**

     * Approve a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     * @method _doApprove

     */

    PlanActions.prototype._doApprove = function(planData) {

        var calls = [{

            methodname: 'core_competency_approve_plan',

            args: {

                id: planData.id

            }

        }];

        this._callAndRefresh(calls, planData);

    };

    /**

     * Approve a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     * @method approve

     */

    PlanActions.prototype.approve = function(planData) {

        this._doApprove(planData);

    };

    /**

     * Unapprove a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     * @method _doUnapprove

     */

    PlanActions.prototype._doUnapprove = function(planData) {

        var calls = [{

            methodname: 'core_competency_unapprove_plan',

            args: {

                id: planData.id

            }

        }];

        this._callAndRefresh(calls, planData);

    };

    /**

     * Unapprove a plan.

     *

     * @param  {Object} planData Plan data from plan node.

     * @method unapprove

     */

    PlanActions.prototype.unapprove = function(planData) {

        this._doUnapprove(planData);

    };

    /**

     * Display list of linked courses on a modal dialogue.

     *

     * @param  {Event} e The event.

     */

    PlanActions.prototype._showLinkedCoursesHandler = function(e) {

        e.preventDefault();

        var competencyid = $(e.target).data('id');

        var requests = ajax.call([{

            methodname: 'tool_lp_list_courses_using_competency',

            args: {id: competencyid}

        }]);

        requests[0].done(function(courses) {

            var context = {

                courses: courses

            };

            templates.render('tool_lp/linked_courses_summary', context).done(function(html) {

                str.get_string('linkedcourses', 'tool_lp').done(function(linkedcourses) {

                    new Dialogue(

                        linkedcourses, // Title.

                        html // The linked courses.

                    );

                }).fail(notification.exception);

            }).fail(notification.exception);

        }).fail(notification.exception);

    };

    /**

     * Plan event handler.

     *

     * @param  {String} method The method to call.

     * @param  {Event} e The event.

     * @method _eventHandler

     */

    PlanActions.prototype._eventHandler = function(method, e) {

        e.preventDefault();

        var data = this._findPlanData($(e.target));

        this[method](data);

    };

    /**

     * Find the plan data from the plan node.

     *

     * @param  {Node} node The node to search from.

     * @return {Object} Plan data.

     */

    PlanActions.prototype._findPlanData = function(node) {

        var parent = node.parentsUntil($(this._region).parent(), this._planNode),

            data;

        if (parent.length != 1) {

            throw new Error('The plan node was not located.');

        }

        data = parent.data();

        if (typeof data === 'undefined' || typeof data.id === 'undefined') {

            throw new Error('Plan data could not be found.');

        }

        return data;

    };

    /**

     * Enhance a menu bar.

     *

     * @param  {String} selector Menubar selector.

     */

    PlanActions.prototype.enhanceMenubar = function(selector) {

        Menubar.enhance(selector, {

            '[data-action="plan-delete"]': this._eventHandler.bind(this, 'deletePlan'),

            '[data-action="plan-complete"]': this._eventHandler.bind(this, 'completePlan'),

            '[data-action="plan-reopen"]': this._eventHandler.bind(this, 'reopenPlan'),

            '[data-action="plan-unlink"]': this._eventHandler.bind(this, 'unlinkPlan'),

            '[data-action="plan-request-review"]': this._eventHandler.bind(this, 'requestReview'),

            '[data-action="plan-cancel-review-request"]': this._eventHandler.bind(this, 'cancelReviewRequest'),

            '[data-action="plan-start-review"]': this._eventHandler.bind(this, 'startReview'),

            '[data-action="plan-stop-review"]': this._eventHandler.bind(this, 'stopReview'),

            '[data-action="plan-approve"]': this._eventHandler.bind(this, 'approve'),

            '[data-action="plan-unapprove"]': this._eventHandler.bind(this, 'unapprove'),

        });

    };

    /**

     * Register the events in the region.

     *

     * At this stage this cannot be used with enhanceMenubar or multiple handlers

     * will be added to the same node.

     */

    PlanActions.prototype.registerEvents = function() {

        var wrapper = $(this._region);

        wrapper.find('[data-action="plan-delete"]').click(this._eventHandler.bind(this, 'deletePlan'));

        wrapper.find('[data-action="plan-complete"]').click(this._eventHandler.bind(this, 'completePlan'));

        wrapper.find('[data-action="plan-reopen"]').click(this._eventHandler.bind(this, 'reopenPlan'));

        wrapper.find('[data-action="plan-unlink"]').click(this._eventHandler.bind(this, 'unlinkPlan'));

        wrapper.find('[data-action="plan-request-review"]').click(this._eventHandler.bind(this, 'requestReview'));

        wrapper.find('[data-action="plan-cancel-review-request"]').click(this._eventHandler.bind(this, 'cancelReviewRequest'));

        wrapper.find('[data-action="plan-start-review"]').click(this._eventHandler.bind(this, 'startReview'));

        wrapper.find('[data-action="plan-stop-review"]').click(this._eventHandler.bind(this, 'stopReview'));

        wrapper.find('[data-action="plan-approve"]').click(this._eventHandler.bind(this, 'approve'));

        wrapper.find('[data-action="plan-unapprove"]').click(this._eventHandler.bind(this, 'unapprove'));

        wrapper.find('[data-action="find-courses-link"]').click(this._showLinkedCoursesHandler.bind(this));

    };

    return PlanActions;

});