@oat-sa/tao-core-ui 1.60.0 → 1.60.2

package/src/validator/Report.js

@@ -1,10 +1,10 @@
-var Report = function(type, data) {
-    this.type = type;
-    this.data = data;
-};
-
-Report.prototype.isError = function() {
-    return this.type === 'failure' || this.type === 'error';
-};
-
-export default Report;
+var Report = function(type, data) {
+    this.type = type;
+    this.data = data;
+};
+
+Report.prototype.isError = function() {
+    return this.type === 'failure' || this.type === 'error';
+};
+
+export default Report;

package/src/validator/Validator.js

@@ -1,108 +1,108 @@
-import _ from 'lodash';
-import async from 'async';
-import Report from 'ui/validator/Report';
-import validators from 'ui/validator/validators';
-
-var _buildRule = function(rule) {
-    var ret = null;
-    var _rules = validators.validators;
-    if (_.isString(rule) && _rules[rule]) {
-        ret = _rules[rule];
-    } else if (_.isObject(rule) && rule.name) {
-        if (_rules[rule.name]) {
-            ret = _.merge(_.cloneDeep(_rules[rule.name]), rule);
-        } else if (rule.message && _.isFunction(rule.validate)) {
-            ret = rule;
-        }
-    }
-    return ret;
-};
-
-var _defaultOptions = {
-    lazy: false
-};
-
-var _applyRules = function(value, rule, callback, options) {
-    options = _.merge(_.cloneDeep(rule.options), options);
-    rule.validate(value, callback, options);
-};
-
-var Validator = function(rules, options) {
-    this.options = _.merge(_.cloneDeep(_defaultOptions), options);
-    this.rules = [];
-    this.addRules(rules);
-};
-
-Validator.getDefaultOptions = function() {
-    return _.clone(_defaultOptions);
-};
-
-Validator.prototype.validate = function(value, arg1, arg2) {
-    var callstack = [],
-        callback,
-        options = _.cloneDeep(this.options);
-
-    if (_.isFunction(arg1)) {
-        callback = arg1;
-    } else if (_.isObject(arg1)) {
-        _.merge(options, arg1); //treat it like the options array:
-        if (_.isFunction(arg2)) {
-            callback = arg2;
-        }
-    }
-
-    _.each(this.rules, function(rule) {
-        //note: individual validating option reserved for a later usage:
-        var validatorOptions = {},
-            message;
-
-        callstack.push(function(cb) {
-            _applyRules(
-                value,
-                rule,
-                function(success) {
-                    if (success) {
-                        cb(null, new Report('success', { validator: rule.name }));
-                    } else {
-                        message = rule.options.message || rule.message;
-                        var report = new Report('failure', { validator: rule.name, message: message });
-                        if (options.lazy) {
-                            cb(new Error('lazy mode'), report); //stop execution now
-                        } else {
-                            cb(null, report);
-                        }
-                    }
-                },
-                validatorOptions
-            );
-        });
-    });
-
-    async.series(callstack, function(err, results) {
-        if (_.isFunction(callback)) {
-            callback(results);
-        }
-    });
-
-    return this;
-};
-
-Validator.prototype.addRule = function(rule) {
-    var _rules = validators.validators;
-    if (_.isString(rule) && _rules[rule]) {
-        this.rules.push(_rules[rule]);
-    } else if ((rule = _buildRule(rule))) {
-        this.rules.push(rule);
-    }
-    return this;
-};
-
-Validator.prototype.addRules = function(rules) {
-    var _this = this;
-    _.each(rules, function(rule) {
-        _this.addRule(rule);
-    });
-    return this;
-};
-
-export default Validator;
+import _ from 'lodash';
+import async from 'async';
+import Report from 'ui/validator/Report';
+import validators from 'ui/validator/validators';
+
+var _buildRule = function(rule) {
+    var ret = null;
+    var _rules = validators.validators;
+    if (_.isString(rule) && _rules[rule]) {
+        ret = _rules[rule];
+    } else if (_.isObject(rule) && rule.name) {
+        if (_rules[rule.name]) {
+            ret = _.merge(_.cloneDeep(_rules[rule.name]), rule);
+        } else if (rule.message && _.isFunction(rule.validate)) {
+            ret = rule;
+        }
+    }
+    return ret;
+};
+
+var _defaultOptions = {
+    lazy: false
+};
+
+var _applyRules = function(value, rule, callback, options) {
+    options = _.merge(_.cloneDeep(rule.options), options);
+    rule.validate(value, callback, options);
+};
+
+var Validator = function(rules, options) {
+    this.options = _.merge(_.cloneDeep(_defaultOptions), options);
+    this.rules = [];
+    this.addRules(rules);
+};
+
+Validator.getDefaultOptions = function() {
+    return _.clone(_defaultOptions);
+};
+
+Validator.prototype.validate = function(value, arg1, arg2) {
+    var callstack = [],
+        callback,
+        options = _.cloneDeep(this.options);
+
+    if (_.isFunction(arg1)) {
+        callback = arg1;
+    } else if (_.isObject(arg1)) {
+        _.merge(options, arg1); //treat it like the options array:
+        if (_.isFunction(arg2)) {
+            callback = arg2;
+        }
+    }
+
+    _.each(this.rules, function(rule) {
+        //note: individual validating option reserved for a later usage:
+        var validatorOptions = {},
+            message;
+
+        callstack.push(function(cb) {
+            _applyRules(
+                value,
+                rule,
+                function(success) {
+                    if (success) {
+                        cb(null, new Report('success', { validator: rule.name }));
+                    } else {
+                        message = rule.options.message || rule.message;
+                        var report = new Report('failure', { validator: rule.name, message: message });
+                        if (options.lazy) {
+                            cb(new Error('lazy mode'), report); //stop execution now
+                        } else {
+                            cb(null, report);
+                        }
+                    }
+                },
+                validatorOptions
+            );
+        });
+    });
+
+    async.series(callstack, function(err, results) {
+        if (_.isFunction(callback)) {
+            callback(results);
+        }
+    });
+
+    return this;
+};
+
+Validator.prototype.addRule = function(rule) {
+    var _rules = validators.validators;
+    if (_.isString(rule) && _rules[rule]) {
+        this.rules.push(_rules[rule]);
+    } else if ((rule = _buildRule(rule))) {
+        this.rules.push(rule);
+    }
+    return this;
+};
+
+Validator.prototype.addRules = function(rules) {
+    var _this = this;
+    _.each(rules, function(rule) {
+        _this.addRule(rule);
+    });
+    return this;
+};
+
+export default Validator;

package/src/validator/validators.js

@@ -1,220 +1,220 @@
-/*
- * This program 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; under version 2
- * of the License (non-upgradable).
- *
- * This program 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 this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * Copyright (c) 2016-2019 (original work) Open Assessment Technologies SA;
- *
- */
-
-/**
- * Enables you register validators and provide most common validators.
- *
- * @author Sam <sam@taotesting.com>
- * @author Bertrand Chevrier <bertrand@taotesting.com>
- */
-import $ from 'jquery';
-import _ from 'lodash';
-import __ from 'i18n';
-import urlUtil from 'util/url';
-import UrlParser from 'util/urlParser';
-
-/**
- * Defines the validation callback
- * @callback IsValidCallback
- * @param {Boolean} isValid - whether the value is valid or not
- */
-
-/**
- * The function called by a validator to validate a value
- * @callback Validate
- * @param {String|Boolean|Number} value - the value to validate
- * @param {IsValidCallback} callback - called with the validation result
- * @param {Object} [options] - additional options
- */
-
-/**
- * Validate with a regex pattern
- * @private
- * @param {String|Boolean|Number} value - the value to validate
- * @param {IsValidCallback} callback - called with the validation result
- * @param {Object} [options] - additional options
- * @param {String} [options.modifier] - pattern modifier
- * @param {String} [options.pattern] - the pattern itself
- */
-var _validatePattern = function _validatePattern(value, callback, options) {
-    var regex = new RegExp(options.pattern, options.modifier || ''),
-        match = value.match(regex),
-        r = match !== null;
-
-    if (typeof callback === 'function') {
-        callback.call(null, r);
-    }
-    return r;
-};
-
-/**
- * The current validators
- */
-var validators = {
-    numeric: {
-        name: 'numeric',
-        message: __('The value of this field must be numeric'),
-        options: {},
-        validate: function(value, callback) {
-            var parsedValue = parseFloat(value),
-                r = parsedValue.toString() === value.toString() && _.isNumber(parsedValue) && !_.isNaN(parsedValue);
-
-            if (typeof callback === 'function') {
-                callback.call(null, r);
-            }
-        }
-    },
-    notEmpty: {
-        name: 'notEmpty',
-        message: __('this is required'),
-        options: {},
-        validate: function(value, callback) {
-            var r;
-            if (_.isNumber(value)) {
-                r = true;
-            } else {
-                r = !_.isEmpty(value); //works for array/object/string
-            }
-            if (typeof callback === 'function') {
-                callback.call(null, r);
-            }
-        }
-    },
-    pattern: {
-        name: 'pattern',
-        message: __('does not match'),
-        options: { pattern: '', modifier: 'igm' },
-        validate: _validatePattern
-    },
-    length: {
-        name: 'length',
-        message: __('required length'),
-        options: { min: 0, max: 0 },
-        validate: function(value, callback, options) {
-            var r = false;
-            if (value.length >= options.min) {
-                if (options.max) {
-                    r = value.length <= options.max;
-                } else {
-                    r = true;
-                }
-            }
-            if (typeof callback === 'function') {
-                callback.call(null, r);
-            }
-        }
-    },
-    fileExists: {
-        name: 'fileExists',
-        message: __('no file not found in this location'),
-        options: { baseUrl: '' },
-        validate: (function() {
-            return function(value, callback, options) {
-                if (!value) {
-                    callback(false);
-                    return;
-                }
-
-                const parser = new UrlParser(value);
-                const protocol = parser.get('protocol');
-                const isHttp = protocol === 'http:' || protocol === 'https:';
-
-                if (!(urlUtil.isAbsolute(value) && isHttp) && !urlUtil.isBase64(value)) {
-                    //request HEAD only for bandwidth saving
-                    $.ajax({
-                        type: 'HEAD',
-                        //FIXME change this to use an URL without transfomations. the validator should be called with the right URL,
-                        //here it works only for the getFile service...
-                        url: options.baseUrl + encodeURIComponent(value),
-                        success: function() {
-                            callback(true);
-                        },
-                        error: function(jqXHR, textStatus, errorThrown) {
-                            callback(false);
-                        }
-                    });
-                } else {
-                    callback(true);
-                }
-            };
-        })()
-    },
-    validRegex: {
-        name: 'validRegex',
-        message: __('invalid regular expression'),
-        options: {},
-        validate: function(value, callback) {
-            if (typeof callback === 'function') {
-                var valid = false;
-                if (value !== '') {
-                    try {
-                        new RegExp('^' + value + '$');
-                        valid = true;
-                    } catch (e) {
-                        valid = false;
-                    }
-                } else {
-                    valid = true;
-                }
-                callback(valid);
-            }
-        }
-    }
-};
-
-/**
- * Register a new validator
- * @param {String} [name] - the validator name
- * @param {Object} validator - the validator
- * @param {String} [validator.name] - the name if not used in first parameter
- * @param {String} validator.message - the failure message
- * @param {Function} validator.validate - the validator
- * @param {Boolean} [force = false] - force to register the validator even if it is always registered
- */
-var register = function registerValidator(name, validator, force) {
-    if (_.isPlainObject(name) && name.name && !validator) {
-        validator = name;
-        name = validator.name;
-    }
-
-    if (!_.isString(name) || _.isEmpty(name)) {
-        throw new Error('Please name your validator');
-    }
-
-    if (!_.isObject(validator) || !_.isString(validator.message) || !_.isFunction(validator.validate)) {
-        throw new Error(
-            'A validator must be an object with a message and a validate method, but given : ' +
-            JSON.stringify(validator)
-        );
-    }
-
-    //do not override
-    if (!validators[name] || !!force) {
-        validators[name] = validator;
-    }
-};
-
-/**
- * Gives access to the validator and enable to register new validators
- * @exports validator/validators
- */
-export default {
-    validators: validators,
-    register: register
-};
+/*
+ * This program 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; under version 2
+ * of the License (non-upgradable).
+ *
+ * This program 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 this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * Copyright (c) 2016-2019 (original work) Open Assessment Technologies SA;
+ *
+ */
+
+/**
+ * Enables you register validators and provide most common validators.
+ *
+ * @author Sam <sam@taotesting.com>
+ * @author Bertrand Chevrier <bertrand@taotesting.com>
+ */
+import $ from 'jquery';
+import _ from 'lodash';
+import __ from 'i18n';
+import urlUtil from 'util/url';
+import UrlParser from 'util/urlParser';
+
+/**
+ * Defines the validation callback
+ * @callback IsValidCallback
+ * @param {Boolean} isValid - whether the value is valid or not
+ */
+
+/**
+ * The function called by a validator to validate a value
+ * @callback Validate
+ * @param {String|Boolean|Number} value - the value to validate
+ * @param {IsValidCallback} callback - called with the validation result
+ * @param {Object} [options] - additional options
+ */
+
+/**
+ * Validate with a regex pattern
+ * @private
+ * @param {String|Boolean|Number} value - the value to validate
+ * @param {IsValidCallback} callback - called with the validation result
+ * @param {Object} [options] - additional options
+ * @param {String} [options.modifier] - pattern modifier
+ * @param {String} [options.pattern] - the pattern itself
+ */
+var _validatePattern = function _validatePattern(value, callback, options) {
+    var regex = new RegExp(options.pattern, options.modifier || ''),
+        match = value.match(regex),
+        r = match !== null;
+
+    if (typeof callback === 'function') {
+        callback.call(null, r);
+    }
+    return r;
+};
+
+/**
+ * The current validators
+ */
+var validators = {
+    numeric: {
+        name: 'numeric',
+        message: __('The value of this field must be numeric'),
+        options: {},
+        validate: function(value, callback) {
+            var parsedValue = parseFloat(value),
+                r = parsedValue.toString() === value.toString() && _.isNumber(parsedValue) && !_.isNaN(parsedValue);
+
+            if (typeof callback === 'function') {
+                callback.call(null, r);
+            }
+        }
+    },
+    notEmpty: {
+        name: 'notEmpty',
+        message: __('this is required'),
+        options: {},
+        validate: function(value, callback) {
+            var r;
+            if (_.isNumber(value)) {
+                r = true;
+            } else {
+                r = !_.isEmpty(value); //works for array/object/string
+            }
+            if (typeof callback === 'function') {
+                callback.call(null, r);
+            }
+        }
+    },
+    pattern: {
+        name: 'pattern',
+        message: __('does not match'),
+        options: { pattern: '', modifier: 'igm' },
+        validate: _validatePattern
+    },
+    length: {
+        name: 'length',
+        message: __('required length'),
+        options: { min: 0, max: 0 },
+        validate: function(value, callback, options) {
+            var r = false;
+            if (value.length >= options.min) {
+                if (options.max) {
+                    r = value.length <= options.max;
+                } else {
+                    r = true;
+                }
+            }
+            if (typeof callback === 'function') {
+                callback.call(null, r);
+            }
+        }
+    },
+    fileExists: {
+        name: 'fileExists',
+        message: __('no file not found in this location'),
+        options: { baseUrl: '' },
+        validate: (function() {
+            return function(value, callback, options) {
+                if (!value) {
+                    callback(false);
+                    return;
+                }
+
+                const parser = new UrlParser(value);
+                const protocol = parser.get('protocol');
+                const isHttp = protocol === 'http:' || protocol === 'https:';
+
+                if (!(urlUtil.isAbsolute(value) && isHttp) && !urlUtil.isBase64(value)) {
+                    //request HEAD only for bandwidth saving
+                    $.ajax({
+                        type: 'HEAD',
+                        //FIXME change this to use an URL without transfomations. the validator should be called with the right URL,
+                        //here it works only for the getFile service...
+                        url: options.baseUrl + encodeURIComponent(value),
+                        success: function() {
+                            callback(true);
+                        },
+                        error: function(jqXHR, textStatus, errorThrown) {
+                            callback(false);
+                        }
+                    });
+                } else {
+                    callback(true);
+                }
+            };
+        })()
+    },
+    validRegex: {
+        name: 'validRegex',
+        message: __('invalid regular expression'),
+        options: {},
+        validate: function(value, callback) {
+            if (typeof callback === 'function') {
+                var valid = false;
+                if (value !== '') {
+                    try {
+                        new RegExp('^' + value + '$');
+                        valid = true;
+                    } catch (e) {
+                        valid = false;
+                    }
+                } else {
+                    valid = true;
+                }
+                callback(valid);
+            }
+        }
+    }
+};
+
+/**
+ * Register a new validator
+ * @param {String} [name] - the validator name
+ * @param {Object} validator - the validator
+ * @param {String} [validator.name] - the name if not used in first parameter
+ * @param {String} validator.message - the failure message
+ * @param {Function} validator.validate - the validator
+ * @param {Boolean} [force = false] - force to register the validator even if it is always registered
+ */
+var register = function registerValidator(name, validator, force) {
+    if (_.isPlainObject(name) && name.name && !validator) {
+        validator = name;
+        name = validator.name;
+    }
+
+    if (!_.isString(name) || _.isEmpty(name)) {
+        throw new Error('Please name your validator');
+    }
+
+    if (!_.isObject(validator) || !_.isString(validator.message) || !_.isFunction(validator.validate)) {
+        throw new Error(
+            'A validator must be an object with a message and a validate method, but given : ' +
+            JSON.stringify(validator)
+        );
+    }
+
+    //do not override
+    if (!validators[name] || !!force) {
+        validators[name] = validator;
+    }
+};
+
+/**
+ * Gives access to the validator and enable to register new validators
+ * @exports validator/validators
+ */
+export default {
+    validators: validators,
+    register: register
+};