admin/tool/lp/amd/src/competency_rule_points.js

   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  * Competency rule points module.
  18  *
  19  * @package    tool_lp
  20  * @copyright  2015 Frédéric Massart - FMCorz.net
  21  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  22  */
  23
  24 define(['jquery',
  25         'core/str',
  26         'core/templates',
  27         'tool_lp/competency_rule',
  28         ],
  29         function($, Str, Templates, RuleBase) {
  30
  31     /**
  32      * Competency rule points class.
  33      */
  34     var Rule = function() {
  35         RuleBase.apply(this, arguments);
  36     };
  37     Rule.prototype = Object.create(RuleBase.prototype);
  38
  39     /** @type {Node} Reference to the container in which the template was included. */
  40     Rule.prototype._container = null;
  41     /** @type {Boolean} Whether or not the template was included. */
  42     Rule.prototype._templateLoaded = false;
  43
  44     /**
  45      * The config established by this rule.
  46      *
  47      * @return {String}
  48      * @method getConfig
  49      */
  50     Rule.prototype.getConfig = function() {
  51         return JSON.stringify({
  52             base: {
  53                 points: this._getRequiredPoints(),
  54             },
  55             competencies: this._getCompetenciesConfig()
  56         });
  57     };
  58
  59     /**
  60      * Gathers the input provided by the user for competencies.
  61      *
  62      * @return {Array} Containing id, points and required.
  63      * @method _getCompetenciesConfig
  64      * @protected
  65      */
  66     Rule.prototype._getCompetenciesConfig = function() {
  67         var competencies = [];
  68
  69         this._container.find('[data-competency]').each(function() {
  70             var node = $(this),
  71                 id = node.data('competency'),
  72                 points = parseInt(node.find('[name="points"]').val(), 10),
  73                 required = node.find('[name="required"]').prop('checked');
  74
  75             competencies.push({
  76                 id: id,
  77                 points: points,
  78                 required: required ? 1 : 0
  79             });
  80         });
  81
  82         return competencies;
  83     };
  84
  85     /**
  86      * Fetches the required points set by the user.
  87      *
  88      * @return {Number}
  89      * @method _getRequiredPoints
  90      * @protected
  91      */
  92     Rule.prototype._getRequiredPoints = function() {
  93         return parseInt(this._container.find('[name="requiredpoints"]').val() || 1, 10);
  94     };
  95
  96     /**
  97      * Return the type of the module.
  98      *
  99      * @return {String}
 100      * @method getType
 101      */
 102     Rule.prototype.getType = function() {
 103         return 'core_competency\\competency_rule_points';
 104     };
 105
 106     /**
 107      * Callback to inject the template.
 108      *
 109      * @param  {Node} container Node to inject in.
 110      * @return {Promise} Resolved when done.
 111      * @method injectTemplate
 112      */
 113     Rule.prototype.injectTemplate = function(container) {
 114         var self = this,
 115             children = this._tree.getChildren(this._competency.id),
 116             context,
 117             config = {
 118                 base: { points: 2 },
 119                 competencies: []
 120             };
 121
 122         this._templateLoaded = false;
 123
 124         // Only pre-load the configuration when the competency is using this rule.
 125         if (self._competency.ruletype == self.getType()) {
 126             try {
 127                 config = JSON.parse(self._competency.ruleconfig);
 128             } catch (e) {
 129             }
 130         }
 131
 132         context = {
 133             requiredpoints: (config && config.base) ? config.base.points : 2,
 134             competency: self._competency,
 135             children: []
 136         };
 137
 138         $.each(children, function(index, child) {
 139             var competency = {
 140                 id: child.id,
 141                 shortname: child.shortname,
 142                 required: false,
 143                 points: 0
 144             };
 145
 146             if (config) {
 147                 $.each(config.competencies, function(index, comp) {
 148                     if (comp.id == competency.id) {
 149                         competency.required = comp.required ? true : false;
 150                         competency.points = comp.points;
 151                     }
 152                 });
 153             }
 154
 155             context.children.push(competency);
 156         });
 157
 158         return Templates.render('tool_lp/competency_rule_points', context).then(function(html) {
 159             self._container = container;
 160             container.html(html);
 161             container.find('input').change(function() {
 162                 self._triggerChange();
 163             });
 164
 165             // We're done, let's trigger a change.
 166             self._templateLoaded = true;
 167             self._triggerChange();
 168         });
 169     };
 170
 171     /**
 172      * Whether or not the current config is valid.
 173      *
 174      * @return {Boolean}
 175      * @method isValid
 176      */
 177     Rule.prototype.isValid = function() {
 178         if (!this._templateLoaded) {
 179             return false;
 180         }
 181
 182         var required = this._getRequiredPoints(),
 183             max = 0,
 184             valid = true;
 185
 186         $.each(this._getCompetenciesConfig(), function(index, competency) {
 187             if (competency.points < 0) {
 188                 valid = false;
 189             }
 190             max += competency.points;
 191         });
 192
 193         valid = valid && max >= required;
 194         return valid;
 195     };
 196
 197     return /** @alias module:tool_lp/competency_rule_all */ Rule;
 198
 199 });