[Summary view] [Print] [Text view]

   1  // This file is part of Moodle - http://moodle.org/
   2  //
   3  // Moodle is free software: you can redistribute it and/or modify
   4  // it under the terms of the GNU General Public License as published by
   5  // the Free Software Foundation, either version 3 of the License, or
   6  // (at your option) any later version.
   7  //
   8  // Moodle is distributed in the hope that it will be useful,
   9  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  // GNU General Public License for more details.
  12  //
  13  // You should have received a copy of the GNU General Public License
  14  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  15  
  16  /**
  17   * User evidence actions.
  18   *
  19   * @module     tool_lp/user_evidence_actions
  20   * @package    tool_lp
  21   * @copyright  2015 Frédéric Massart - FMCorz.net
  22   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23   */
  24  define(['jquery',
  25          'core/templates',
  26          'core/ajax',
  27          'core/notification',
  28          'core/str',
  29          'tool_lp/menubar',
  30          'tool_lp/competencypicker_user_plans'],
  31          function($, templates, ajax, notification, str, Menubar, PickerUserPlans) {
  32  
  33      /**
  34       * UserEvidenceActions class.
  35       *
  36       * Note that presently this cannot be instantiated more than once per page.
  37       *
  38       * @param {String} type The type of page we're in.
  39       */
  40      var UserEvidenceActions = function(type) {
  41          this._type = type;
  42  
  43          if (type === 'evidence') {
  44              // This is the page to view one evidence.
  45              this._region = '[data-region="user-evidence-page"]';
  46              this._evidenceNode = '[data-region="user-evidence-page"]';
  47              this._template = 'tool_lp/user_evidence_page';
  48              this._contextMethod = 'tool_lp_data_for_user_evidence_page';
  49  
  50          } else if (type === 'list') {
  51              // This is the page to view a list of evidence.
  52              this._region = '[data-region="user-evidence-list"]';
  53              this._evidenceNode = '[data-region="user-evidence-node"]';
  54              this._template = 'tool_lp/user_evidence_list_page';
  55              this._contextMethod = 'tool_lp_data_for_user_evidence_list_page';
  56  
  57          } else {
  58              throw new TypeError('Unexpected type.');
  59          }
  60      };
  61  
  62      /** @type {String} Ajax method to fetch the page data from. */
  63      UserEvidenceActions.prototype._contextMethod = null;
  64      /** @type {String} Selector to find the node describing the evidence. */
  65      UserEvidenceActions.prototype._evidenceNode = null;
  66      /** @type {String} Selector mapping to the region to update. Usually similar to wrapper. */
  67      UserEvidenceActions.prototype._region = null;
  68      /** @type {String} Name of the template used to render the region. */
  69      UserEvidenceActions.prototype._template = null;
  70      /** @type {String} Type of page/region we're in. */
  71      UserEvidenceActions.prototype._type = null;
  72  
  73      /**
  74       * Resolve the arguments to refresh the region.
  75       *
  76       * @param  {Object} evidenceData Evidence data from evidence node.
  77       * @return {Object} List of arguments.
  78       */
  79      UserEvidenceActions.prototype._getContextArgs = function(evidenceData) {
  80          var self = this,
  81              args = {};
  82  
  83          if (self._type === 'evidence') {
  84              args = {
  85                  id: evidenceData.id
  86              };
  87  
  88          } else if (self._type === 'list') {
  89              args = {
  90                  userid: evidenceData.userid
  91              };
  92          }
  93  
  94          return args;
  95      };
  96  
  97      /**
  98       * Callback to render the region template.
  99       *
 100       * @param {Object} context The context for the template.
 101       */
 102      UserEvidenceActions.prototype._renderView = function(context) {
 103          var self = this;
 104          templates.render(self._template, context)
 105              .done(function(newhtml, newjs) {
 106                  templates.replaceNode($(self._region), newhtml, newjs);
 107              })
 108              .fail(notification.exception);
 109      };
 110  
 111      /**
 112       * Call multiple ajax methods, and refresh.
 113       *
 114       * @param  {Array}  calls    List of Ajax calls.
 115       * @param  {Object} evidenceData Evidence data from evidence node.
 116       * @return {Promise}
 117       */
 118      UserEvidenceActions.prototype._callAndRefresh = function(calls, evidenceData) {
 119          var self = this;
 120  
 121          calls.push({
 122              methodname: self._contextMethod,
 123              args: self._getContextArgs(evidenceData)
 124          });
 125  
 126          // Apply all the promises, and refresh when the last one is resolved.
 127          return $.when.apply($.when, ajax.call(calls))
 128              .then(function() {
 129                  self._renderView(arguments[arguments.length - 1]);
 130              })
 131              .fail(notification.exception);
 132      };
 133  
 134      /**
 135       * Delete a plan and reload the region.
 136       *
 137       * @param  {Object} evidenceData Evidence data from evidence node.
 138       */
 139      UserEvidenceActions.prototype._doDelete = function(evidenceData) {
 140          var self = this,
 141              calls = [{
 142                  methodname: 'core_competency_delete_user_evidence',
 143                  args: {id: evidenceData.id}
 144              }];
 145          self._callAndRefresh(calls, evidenceData);
 146      };
 147  
 148      /**
 149       * Delete a plan.
 150       *
 151       * @param  {Object} evidenceData Evidence data from evidence node.
 152       */
 153      UserEvidenceActions.prototype.deleteEvidence = function(evidenceData) {
 154          var self = this,
 155              requests;
 156  
 157          requests = ajax.call([{
 158              methodname: 'core_competency_read_user_evidence',
 159              args: {id: evidenceData.id}
 160          }]);
 161  
 162          requests[0].done(function(evidence) {
 163              str.get_strings([
 164                  {key: 'confirm', component: 'moodle'},
 165                  {key: 'deleteuserevidence', component: 'tool_lp', param: evidence.name},
 166                  {key: 'delete', component: 'moodle'},
 167                  {key: 'cancel', component: 'moodle'}
 168              ]).done(function(strings) {
 169                  notification.confirm(
 170                      strings[0], // Confirm.
 171                      strings[1], // Delete evidence X?
 172                      strings[2], // Delete.
 173                      strings[3], // Cancel.
 174                      function() {
 175                          self._doDelete(evidenceData);
 176                      }
 177                  );
 178              }).fail(notification.exception);
 179          }).fail(notification.exception);
 180  
 181      };
 182  
 183      /**
 184       * Delete evidence handler.
 185       *
 186       * @param  {Event} e The event.
 187       */
 188      UserEvidenceActions.prototype._deleteEvidenceHandler = function(e) {
 189          e.preventDefault();
 190          var data = this._findEvidenceData($(e.target));
 191          this.deleteEvidence(data);
 192      };
 193  
 194      /**
 195       * Link a competency and reload.
 196       *
 197       * @param {Object} evidenceData Evidence data from evidence node.
 198       * @param {Number} competencyIds The competency IDs.
 199       * @param {Boolean} requestReview Send competencies to review.
 200       */
 201      UserEvidenceActions.prototype._doCreateUserEvidenceCompetency = function(evidenceData, competencyIds) {
 202          var self = this,
 203              calls = [];
 204  
 205          $.each(competencyIds, function(index, competencyId) {
 206              calls.push({
 207                  methodname: 'core_competency_create_user_evidence_competency',
 208                  args: {
 209                      userevidenceid: evidenceData.id,
 210                      competencyid: competencyId,
 211                  }
 212              });
 213          });
 214  
 215          self._callAndRefresh(calls, evidenceData);
 216      };
 217  
 218      /**
 219       * Create a user evidence competency.
 220       *
 221       * @param  {Object} evidenceData Evidence data from evidence node.
 222       */
 223      UserEvidenceActions.prototype.createUserEvidenceCompetency = function(evidenceData) {
 224          var self = this,
 225              picker = new PickerUserPlans(evidenceData.userid);
 226  
 227          picker.on('save', function(e, data) {
 228              var competencyIds = data.competencyIds;
 229              self._doCreateUserEvidenceCompetency(evidenceData, competencyIds, data.requestReview);
 230          });
 231  
 232          picker.display();
 233      };
 234  
 235      /**
 236       * Create user evidence competency handler.
 237       *
 238       * @param  {Event} e The event.
 239       */
 240      UserEvidenceActions.prototype._createUserEvidenceCompetencyHandler = function(e) {
 241          e.preventDefault();
 242          var data = this._findEvidenceData($(e.target));
 243          this.createUserEvidenceCompetency(data);
 244      };
 245  
 246      /**
 247       * Remove a linked competency and reload.
 248       *
 249       * @param {Object} evidenceData Evidence data from evidence node.
 250       * @param {Number} competencyId The competency ID.
 251       */
 252      UserEvidenceActions.prototype._doDeleteUserEvidenceCompetency = function(evidenceData, competencyId) {
 253          var self = this,
 254              calls = [];
 255  
 256          calls.push({
 257              methodname: 'core_competency_delete_user_evidence_competency',
 258              args: {
 259                  userevidenceid: evidenceData.id,
 260                  competencyid: competencyId,
 261              }
 262          });
 263  
 264          self._callAndRefresh(calls, evidenceData);
 265      };
 266  
 267      /**
 268       * Delete a user evidence competency.
 269       *
 270       * @param  {Object} evidenceData Evidence data from evidence node.
 271       * @param  {Number} competencyId The competency ID.
 272       */
 273      UserEvidenceActions.prototype.deleteUserEvidenceCompetency = function(evidenceData, competencyId) {
 274          this._doDeleteUserEvidenceCompetency(evidenceData, competencyId);
 275      };
 276  
 277      /**
 278       * Delete user evidence competency handler.
 279       *
 280       * @param  {Event} e The event.
 281       */
 282      UserEvidenceActions.prototype._deleteUserEvidenceCompetencyHandler = function(e) {
 283          var data = this._findEvidenceData($(e.currentTarget)),
 284              competencyId = $(e.currentTarget).data('id');
 285          e.preventDefault();
 286          this.deleteUserEvidenceCompetency(data, competencyId);
 287      };
 288  
 289      /**
 290       * Send request review for user evidence competencies and reload the region.
 291       *
 292       * @param  {Object} evidenceData Evidence data from evidence node.
 293       */
 294      UserEvidenceActions.prototype._doReviewUserEvidenceCompetencies = function(evidenceData) {
 295          var self = this,
 296              calls = [{
 297                  methodname: 'core_competency_request_review_of_user_evidence_linked_competencies',
 298                  args: {id: evidenceData.id}
 299              }];
 300          self._callAndRefresh(calls, evidenceData);
 301      };
 302  
 303      /**
 304       * Send request review for user evidence competencies.
 305       *
 306       * @param  {Object} evidenceData Evidence data from evidence node.
 307       */
 308      UserEvidenceActions.prototype.reviewUserEvidenceCompetencies = function(evidenceData) {
 309          var self = this,
 310              requests;
 311  
 312          requests = ajax.call([{
 313              methodname: 'core_competency_read_user_evidence',
 314              args: {id: evidenceData.id}
 315          }]);
 316  
 317          requests[0].done(function(evidence) {
 318              str.get_strings([
 319                  {key: 'confirm', component: 'moodle'},
 320                  {key: 'sendallcompetenciestoreview', component: 'tool_lp', param: evidence.name},
 321                  {key: 'confirm', component: 'moodle'},
 322                  {key: 'cancel', component: 'moodle'}
 323              ]).done(function(strings) {
 324                  notification.confirm(
 325                      strings[0], // Confirm.
 326                      strings[1], // Send all competencies in review for X?
 327                      strings[2], // Confirm.
 328                      strings[3], // Cancel.
 329                      function() {
 330                          self._doReviewUserEvidenceCompetencies(evidenceData);
 331                      }
 332                  );
 333              }).fail(notification.exception);
 334          }).fail(notification.exception);
 335  
 336      };
 337  
 338      /**
 339       * Send request review for user evidence competencies handler.
 340       *
 341       * @param  {Event} e The event.
 342       */
 343      UserEvidenceActions.prototype._reviewUserEvidenceCompetenciesHandler = function(e) {
 344          e.preventDefault();
 345          var data = this._findEvidenceData($(e.target));
 346          this.reviewUserEvidenceCompetencies(data);
 347      };
 348  
 349      /**
 350       * Find the evidence data from the evidence node.
 351       *
 352       * @param  {Node} node The node to search from.
 353       * @return {Object} Evidence data.
 354       */
 355      UserEvidenceActions.prototype._findEvidenceData = function(node) {
 356          var parent = node.parentsUntil($(this._region).parent(), this._evidenceNode),
 357              data;
 358  
 359          if (parent.length != 1) {
 360              throw new Error('The evidence node was not located.');
 361          }
 362  
 363          data = parent.data();
 364          if (typeof data === 'undefined' || typeof data.id === 'undefined') {
 365              throw new Error('Evidence data could not be found.');
 366          }
 367  
 368          return data;
 369      };
 370  
 371      /**
 372       * Enhance a menu bar.
 373       *
 374       * @param  {String} selector Menubar selector.
 375       */
 376      UserEvidenceActions.prototype.enhanceMenubar = function(selector) {
 377          var self = this;
 378          Menubar.enhance(selector, {
 379              '[data-action="user-evidence-delete"]': self._deleteEvidenceHandler.bind(self),
 380              '[data-action="link-competency"]': self._createUserEvidenceCompetencyHandler.bind(self),
 381              '[data-action="send-competencies-review"]': self._reviewUserEvidenceCompetenciesHandler.bind(self),
 382          });
 383      };
 384  
 385      /**
 386       * Register the events in the region.
 387       *
 388       * At this stage this cannot be used with enhanceMenubar or multiple handlers
 389       * will be added to the same node.
 390       */
 391      UserEvidenceActions.prototype.registerEvents = function() {
 392          var wrapper = $(this._region),
 393              self = this;
 394  
 395          wrapper.find('[data-action="user-evidence-delete"]').click(self._deleteEvidenceHandler.bind(self));
 396          wrapper.find('[data-action="link-competency"]').click(self._createUserEvidenceCompetencyHandler.bind(self));
 397          wrapper.find('[data-action="delete-competency-link"]').click(self._deleteUserEvidenceCompetencyHandler.bind(self));
 398          wrapper.find('[data-action="send-competencies-review"]').click(self._reviewUserEvidenceCompetenciesHandler.bind(self));
 399      };
 400  
 401      return /** @alias module:tool_lp/user_evidence_actions */ UserEvidenceActions;
 402  });