comprodls-sdk 2.107.0 → 2.109.0-thor.1

package/dist/comprodls-sdk.js

@@ -289,6 +289,7 @@ exports.AUTH_API_URLS = {
   validateSpaceCode: '/accounts/{accountid}/space-code/validate',
   validateClassCode: '/accounts/{accountid}/class-code/validate',
   joinInstituteSpace: '/accounts/{accountid}/join-institute-space',
+  provisionStudentInInstitutionalSpace: '/accounts/{accountid}/student/join-institute-space',
   provisionSpacesToStudent: '/accounts/{accountId}/student/provision-spaces',
   provisionSpacesToTeacher: '/accounts/{accountId}/teacher/provision-spaces',
   shadowProvision: '/org/{orgId}/shadow-provision',
@@ -371,6 +372,7 @@ exports.AUTHEXTN_API_URLS = {
 
   //Space related API
   entitleBulkUsersToProducts: '/accounts/{accountid}/entitle-users/bulk',
+  deleteUserAccount : '/accounts/{accountid}/ext-users/{ext_user_id}',
 
   // Assigned Path APIs
   userAssignedPaths: '/org/{orgid}/classes/{classid}/assigned-paths/{assignedpathid}/enroll-user/multi',
@@ -731,7 +733,9 @@ function setupAPIToken(request, token) {
 var ERROR_TYPES = {
   API_ERROR: 'API_ERROR',
   SDK_ERROR: 'SDK_ERROR',
-  CHANNEL_SUBSCRIPTION: 'CHANNEL_SUBSCRIPTION'
+  CHANNEL_SUBSCRIPTION: 'CHANNEL_SUBSCRIPTION',
+  UNEXPECTED_ERROR: 'UNEXPECTED_ERROR',
+  POLLING_INITIATION: 'POLLING_INITIATION'
 };
 
 var ERROR_CATEGORY = {
@@ -1006,13 +1010,129 @@ module.exports = {
  * comproDLS SDK Validator Helper Module
  * This module contains validation helper functions for comproDLS SDK
  ************************************************************/
-var validator = require('validate.js');
+
 var errors = require('./errors');
 var DLSError = errors.DLSError;
 
-exports.validate = validate;
-exports.isAuthenticated = validateIsAuthenticated;
-exports.isAuthenticatedV2 = validateIsAuthenticatedV2;
+/*********************************
+ * Core validator utilities
+ * Each validator follows the signature:
+ *   fn(field, value, options) → DLSError | undefined
+ *
+ * - field   : the constraint key name e.g. 'organization', 'token', 'token.access_token'
+ * - value   : the value from the options object for that field
+ * - options : the rule config, can be `true` or `{ message: '...' }`
+ *             For `contains`, options is a string or array of required keys.
+ *
+ * Returning a DLSError which stops validation immediately.
+ * Returning undefined means the check passed.
+ **********************************/
+var validators = {
+  /**
+   * Fails if value is null, undefined, or blank/whitespace-only string or empty object.
+   */
+  presence: function(field, value, options) {
+    if (value === undefined || value === null || value === '' ||
+      (typeof value == 'string' && value.trim() === '') ||
+      (typeof value == 'object' && Object.keys(value).length === 0)
+    ) {
+      return createError(options.message || field + ' can\'t be blank');
+    }
+  },
+
+  /**
+   * Fails if value is not a string.
+   */
+  isString: function(field, value, options) {
+    if (typeof value !== 'string') {
+      return createError(options.message || field + ' is not a valid string');
+    }
+  },
+
+  /**
+   * Fails if value is not an object.
+   */
+  isObject: function(field, value, options) {
+    if (typeof value !== 'object' || Array.isArray(value)) {
+      return createError(options.message || field + ' is not a valid object');
+    }
+  },
+
+  /**
+   * Fails if the object does not have the required key(s).
+   */
+  contains: function(field, value, options) {
+    var keys = Array.isArray(options) ? options : typeof options === 'string' ? [options] : [];
+
+    for (var i = 0; i < keys.length; i++) {
+      var requiredKey = keys[i];
+
+      if (!value.hasOwnProperty(requiredKey)) {
+        return createError(options.message || field + ' does not contain ' + requiredKey);
+      }
+    }
+  }
+};
+
+/*********************************
+ * Core validate function
+ *
+ * Iterates over each field in constraints, resolves its value from options,
+ * then runs each rule's validator function in order.
+ * Returns the first error encountered or undefined if all pass.
+ *
+ * @param {Object} options     - The input object to validate
+ * @param {Object} constraints - Map of field names to their rule constraints
+ * @returns {DLSError | undefined}
+ **********************************/
+function validate(options, constraints) {
+  for (var field in constraints) {
+    var fieldConstraintsObj = constraints[field];
+    var value = getValue(options, field);
+
+    for (var ruleName in fieldConstraintsObj) {
+      var ruleOptions = fieldConstraintsObj[ruleName];
+      var validatorFn = validators[ruleName];
+
+      if (!validatorFn) { continue; }
+
+      // Pass field name, field value, and field's rule constraint value to the validator function
+      var error = validatorFn(field, value, ruleOptions);
+      if (error) { return error; }
+    }
+  }
+
+  return undefined;
+}
+
+/*********************************
+ * Private helpers
+ **********************************/
+function getValue(obj, path) {
+  var keys = path.split('.');
+  var result = obj;
+
+  for (var i = 0; i < keys.length; i++) {
+    if (result === undefined || result === null) { return undefined; }
+    result = result[keys[i]];
+  }
+
+  return result;
+}
+
+function createError(message) {
+  var msg = message || 'Validation error';
+  msg = msg.charAt(0).toUpperCase() + msg.slice(1);
+
+  return new DLSError(errors.ERROR_TYPES.SDK_ERROR, {
+    message: msg,
+    description: msg
+  });
+}
+
+/*********************************
+ * Exported auth validators
+ **********************************/
 
 /**
  * This function validates if the SDK instance is authenticated.
@@ -1029,22 +1149,10 @@ function validateIsAuthenticatedV2(orgId, token) {
   return new DLSError(errors.ERROR_TYPES.SDK_ERROR, errObj);
 };
 
-function validate(options, constraints) {
-  var err = {};
-  var validation_errors = validator(options, constraints);
-  if (validation_errors) {
-    for (var validation_error in validation_errors) {
-      err.message = err.description = validation_errors[validation_error][0];
-      err = new DLSError(errors.ERROR_TYPES.SDK_ERROR, err);
-      return err;
-    }
-  } else {
-    return undefined;
-  }
-};
-
 /**
- * This function is deprecated. Please use validateIsAuthenticatedV2 instead.
+ * Validates if SDK instance is authenticated by checking presence of orgId and token.
+ * @param {String} orgId - Organization ID
+ * @param {Object} token - Token object { access_token: 'string' }
  */
 function validateIsAuthenticated(orgId, token) {
   var validate_options = {
@@ -1052,52 +1160,26 @@ function validateIsAuthenticated(orgId, token) {
     'token': token
   };
 
+  var errMsg = 'SDK Instance does not have valid orgid or token. ' +
+    'Please authenticate using authWithCredentials or authWithToken method.';
+
   var validate_constraints = {
     'organization': {
-      'presence': {
-        'message' : '^SDK Instance does not have valid orgid or token. Please authenticate using authWithCredentials or authWithToken method.'
-      }
+      'presence': { 'message': errMsg }
     },
     'token': {
-      'presence': {
-        'message' : '^SDK Instance does not have valid orgid or token. Please authenticate using authWithCredentials or authWithToken method.'
-      }
+      'presence': { 'message': errMsg }
     }
   };
 
   return validate(validate_options, validate_constraints);
 };
 
-/*********************************
- * Private Function definitions
- **********************************/
-validator.validators.isString = function(value, options) {
-  if (!validator.isString(value)) {
-    return options.message || 'is not a valid string';
-  }
-};
-
-validator.validators.isObject = function(value, options) {
-  if (!validator.isObject(value)) {
-    return options.message || 'is not a valid object';
-  }
-};
-
-validator.validators.contains = function(value, options) {
-  if (validator.isArray(options)) {
-    for (var key in options) {
-      if (!value || !value.hasOwnProperty(options[key])) {
-        return options.message || 'does not contain ' + options[key];
-      }
-    }
-  } else if (validator.isString(options)) {
-    if (!value || !value.hasOwnProperty(options)) {
-      return options.message || 'does not contain ' + options;
-    }
-  }
-};
+exports.validate = validate;
+exports.isAuthenticated = validateIsAuthenticated;
+exports.isAuthenticatedV2 = validateIsAuthenticatedV2;
 
-},{"./errors":6,"validate.js":44}],9:[function(require,module,exports){
+},{"./errors":6}],9:[function(require,module,exports){
 /*************************************************************************
  *
  * COMPRO CONFIDENTIAL
@@ -11300,39 +11382,45 @@ function changeSpaceCode(options) {
  */
 function joinInstituteSpace(options) {
   var self = this;
-  // Initializing promise
-  var dfd = q.defer();
 
-  if(options && options.ext_user_id &&
-      options.ext_role && options.space_code)
-  {
-    // Passed all validations, Contruct API url
-    var url = self.config.DEFAULT_HOSTS.AUTH +
-                               self.config.AUTH_API_URLS.joinInstituteSpace;
-    url = helpers.api.constructAPIUrl(url, { accountid : self.accountId });
-
-    // Setup request with URL and Params
-    var requestAPI = request.post(url)
-                     .set('Content-Type', 'application/json')
-                     .set('Accept', 'application/json')
-                     .send(options);
-    if(self.traceid) { requestAPI.set('X-Amzn-Trace-Id', self.traceid); }
+  return new Promise(function(resolve, reject) {
+    if (options && options.ext_user_id && options.ext_role) {
+      // Passed all validations, Contruct API url
 
-    requestAPI.end(function(error, response) {
-      if(error) {
-        err = new DLSError(helpers.errors.ERROR_TYPES.API_ERROR, error);
-        dfd.reject(err);
+      var url;
+      if (options.ext_role === 'student') {
+        url = self.config.DEFAULT_HOSTS.AUTH +
+          self.config.AUTH_API_URLS.provisionStudentInInstitutionalSpace;
       }
-      else { dfd.resolve(response.body); }
-    });
-  } else {
-    var err = {};
-    err.message = err.description = 'ext_user_id or ext_role or space_code not found in request options.';
-    err = new DLSError(helpers.errors.ERROR_TYPES.SDK_ERROR, err);
-    dfd.reject(err);
-  }
+      else {
+        url = self.config.DEFAULT_HOSTS.AUTH + self.config.AUTH_API_URLS.joinInstituteSpace;
+      }
+      url = helpers.api.constructAPIUrl(url, { accountid : self.accountId });
 
-  return dfd.promise;
+      // Setup request with URL and Params
+      var requestAPI = request.post(url)
+                     .set('Content-Type', 'application/json')
+                     .set('Accept', 'application/json');
+      if(self.traceid) { requestAPI.set('X-Amzn-Trace-Id', self.traceid); }
+
+      requestAPI
+      .send(options)
+      .agent(keepaliveAgent)
+      .end(function(error, response) {
+        if (error) {
+          var err = new DLSError(helpers.errors.ERROR_TYPES.API_ERROR, error);
+          reject(err);
+        }
+        else { resolve(response.body); }
+      });
+    } else {
+      var err = {};
+      err.message = err.description = 'ext_user_id or ext_role not found' +
+        ' in request options.';
+      err = new DLSError(helpers.errors.ERROR_TYPES.SDK_ERROR, err);
+      reject(err);
+    }
+  });
 }
 
 /**
@@ -11872,6 +11960,7 @@ function updateUserInformation(options) {
     };
     if(options.ref_id) { bodyParams.ref_id = options.ref_id; }
     if(options.ext_email) { bodyParams.ext_email = options.ext_email; }
+    if(options.ext_username) { bodyParams.ext_username = options.ext_username; }
     if(options.ext_first_name) { bodyParams.ext_first_name = options.ext_first_name; }
     if(options.ext_last_name) { bodyParams.ext_last_name = options.ext_last_name; }
     if(options.address) { bodyParams.address = options.address; }
@@ -12066,7 +12155,8 @@ function spacesextn(accountId) {
   this.accountId = accountId;
   return {
     entitleBulkUsersToProducts: entitleBulkUsersToProducts.bind(this),
-    setupUser: setupUser.bind(this)
+    setupUser: setupUser.bind(this),
+    deleteUserAccount : deleteUserAccount.bind(this)
   };
 }
 
@@ -12153,6 +12243,50 @@ function setupUser(options) {
   }
   return deferred.promise;
 }
+
+/**
+ * Wiki Link for SDK params
+ * https://github.com/comprodls/comprodls-sdk-js/wiki/04_AUTH-Adapter#getuserprofileparams
+ */
+function deleteUserAccount(options) {
+  var self = this;
+  return new Promise(function(resolve, reject) {
+
+    if (options.ext_user_id && options.body) {
+      //Passed all validations, Contruct API url
+      var url = self.config.DEFAULT_HOSTS.AUTHEXTN +
+        self.config.AUTHEXTN_API_URLS.deleteUserAccount;
+      url = helpers.api.constructAPIUrl(url, {
+        accountid: self.accountId,
+        ext_user_id: options.ext_user_id,
+      });
+
+      // Setup request
+      var requestAPI = request.delete(url)
+        .set('Content-Type', 'application/json')
+        .set('Accept', 'application/json');
+      if (self.traceid) { requestAPI.set('X-Amzn-Trace-Id', self.traceid); }
+
+      requestAPI
+        .send(options.body)
+        .agent(keepaliveAgent)
+        .end(function(error, response) {
+          if (error) {
+            var err = new DLSError(helpers.errors.ERROR_TYPES.API_ERROR, error);
+            reject(err);
+          } else {
+            resolve(response.body);
+          }
+        });
+    } else {
+      var err = {};
+      err.description = 'Mandatory field \'ext_user_id\' or \'body\' in request options.';
+      err.message = err.description;
+      err = new DLSError(helpers.errors.ERROR_TYPES.SDK_ERROR, err);
+      reject(err);
+    }
+  });
+}
 
 },{"../../helpers":3,"agentkeepalive":31,"q":36,"superagent":39}],25:[function(require,module,exports){
 /*************************************************************************
@@ -12184,6 +12318,7 @@ var q = require('q');
 var request = require('superagent');
 
 var helpers = require('../../helpers');
+var requestLayer = require('../../helpers/lib/requestLayer');
 
 var DLSError = helpers.errors.DLSError;
 
@@ -12205,34 +12340,32 @@ function superuser(accountId) {
  */
 function getAllInstitutions(options) {
   var self = this;
-  // Initializing promise
-  var dfd = q.defer();
 
-  var url = self.config.DEFAULT_HOSTS.AUTH +
-            self.config.AUTH_API_URLS.getAllInstitutions;
-  url = helpers.api.constructAPIUrl(url, { accountid : self.accountId });
+  var url = helpers.api.constructAPIUrl(
+    self.config.DEFAULT_HOSTS.AUTH + self.config.AUTH_API_URLS.getAllInstitutions,
+    { accountid : self.accountId }
+  );
 
   var params = {};
-  if(options) {
-    if(options.lookup) { params.lookup = options.lookup; }
-    if(options.cursor) { params.cursor = options.cursor; }
-    if(options.limit) { params.limit = options.limit; }
+  if (options) {
+    if (options.lookup) { params.lookup = options.lookup; }
+    if (options.cursor) { params.cursor = options.cursor; }
+    if (options.start) { params.start = options.start; }
+    if (options.end) { params.end = options.end; }
   }
 
-  //Setup request with URL and Params
-  var requestAPI = request.get(url).query(params);
-  if(self.traceid) { requestAPI.set('X-Amzn-Trace-Id', self.traceid); }
-
-  requestAPI.end(function(err, response) {
-    if(err) {
-        err = new DLSError(helpers.errors.ERROR_TYPES.API_ERROR, err);
-        dfd.reject(err);
-    } else {
-        dfd.resolve(response.body);
-    }
+  // Prepare request parameters & execute request
+  var reqOptions = {
+    params: params,
+    headers: { traceid: self.traceid }
+  };
+  return requestLayer.get(url, reqOptions)
+  .then(function (response) {
+    return response.body;
+  })
+  .catch(function (err) {
+    throw new DLSError(helpers.errors.ERROR_TYPES.API_ERROR, err);
   });
-
-  return dfd.promise;
 }
 
 /**
@@ -12316,7 +12449,7 @@ function provisionSpacesToSuperAdmin(options) {
   return dfd.promise;
 }
 
-},{"../../helpers":3,"q":36,"superagent":39}],26:[function(require,module,exports){
+},{"../../helpers":3,"../../helpers/lib/requestLayer":7,"q":36,"superagent":39}],26:[function(require,module,exports){
 /*************************************************************************
  *
  * COMPRO CONFIDENTIAL
@@ -18108,1093 +18241,5 @@ exports.cleanHeader = function(header, changesOrigin){
   return header;
 };
 
-},{}],44:[function(require,module,exports){
-/*!
- * validate.js 0.9.0
- *
- * (c) 2013-2015 Nicklas Ansman, 2013 Wrapp
- * Validate.js may be freely distributed under the MIT license.
- * For all details and documentation:
- * http://validatejs.org/
- */
-
-(function(exports, module, define) {
-  "use strict";
-
-  // The main function that calls the validators specified by the constraints.
-  // The options are the following:
-  //   - format (string) - An option that controls how the returned value is formatted
-  //     * flat - Returns a flat array of just the error messages
-  //     * grouped - Returns the messages grouped by attribute (default)
-  //     * detailed - Returns an array of the raw validation data
-  //   - fullMessages (boolean) - If `true` (default) the attribute name is prepended to the error.
-  //
-  // Please note that the options are also passed to each validator.
-  var validate = function(attributes, constraints, options) {
-    options = v.extend({}, v.options, options);
-
-    var results = v.runValidations(attributes, constraints, options)
-      , attr
-      , validator;
-
-    for (attr in results) {
-      for (validator in results[attr]) {
-        if (v.isPromise(results[attr][validator])) {
-          throw new Error("Use validate.async if you want support for promises");
-        }
-      }
-    }
-    return validate.processValidationResults(results, options);
-  };
-
-  var v = validate;
-
-  // Copies over attributes from one or more sources to a single destination.
-  // Very much similar to underscore's extend.
-  // The first argument is the target object and the remaining arguments will be
-  // used as sources.
-  v.extend = function(obj) {
-    [].slice.call(arguments, 1).forEach(function(source) {
-      for (var attr in source) {
-        obj[attr] = source[attr];
-      }
-    });
-    return obj;
-  };
-
-  v.extend(validate, {
-    // This is the version of the library as a semver.
-    // The toString function will allow it to be coerced into a string
-    version: {
-      major: 0,
-      minor: 9,
-      patch: 0,
-      metadata: null,
-      toString: function() {
-        var version = v.format("%{major}.%{minor}.%{patch}", v.version);
-        if (!v.isEmpty(v.version.metadata)) {
-          version += "+" + v.version.metadata;
-        }
-        return version;
-      }
-    },
-
-    // Below is the dependencies that are used in validate.js
-
-    // The constructor of the Promise implementation.
-    // If you are using Q.js, RSVP or any other A+ compatible implementation
-    // override this attribute to be the constructor of that promise.
-    // Since jQuery promises aren't A+ compatible they won't work.
-    Promise: typeof Promise !== "undefined" ? Promise : /* istanbul ignore next */ null,
-
-    EMPTY_STRING_REGEXP: /^\s*$/,
-
-    // Runs the validators specified by the constraints object.
-    // Will return an array of the format:
-    //     [{attribute: "<attribute name>", error: "<validation result>"}, ...]
-    runValidations: function(attributes, constraints, options) {
-      var results = []
-        , attr
-        , validatorName
-        , value
-        , validators
-        , validator
-        , validatorOptions
-        , error;
-
-      if (v.isDomElement(attributes) || v.isJqueryElement(attributes)) {
-        attributes = v.collectFormValues(attributes);
-      }
-
-      // Loops through each constraints, finds the correct validator and run it.
-      for (attr in constraints) {
-        value = v.getDeepObjectValue(attributes, attr);
-        // This allows the constraints for an attribute to be a function.
-        // The function will be called with the value, attribute name, the complete dict of
-        // attributes as well as the options and constraints passed in.
-        // This is useful when you want to have different
-        // validations depending on the attribute value.
-        validators = v.result(constraints[attr], value, attributes, attr, options, constraints);
-
-        for (validatorName in validators) {
-          validator = v.validators[validatorName];
-
-          if (!validator) {
-            error = v.format("Unknown validator %{name}", {name: validatorName});
-            throw new Error(error);
-          }
-
-          validatorOptions = validators[validatorName];
-          // This allows the options to be a function. The function will be
-          // called with the value, attribute name, the complete dict of
-          // attributes as well as the options and constraints passed in.
-          // This is useful when you want to have different
-          // validations depending on the attribute value.
-          validatorOptions = v.result(validatorOptions, value, attributes, attr, options, constraints);
-          if (!validatorOptions) {
-            continue;
-          }
-          results.push({
-            attribute: attr,
-            value: value,
-            validator: validatorName,
-            globalOptions: options,
-            attributes: attributes,
-            options: validatorOptions,
-            error: validator.call(validator,
-                value,
-                validatorOptions,
-                attr,
-                attributes,
-                options)
-          });
-        }
-      }
-
-      return results;
-    },
-
-    // Takes the output from runValidations and converts it to the correct
-    // output format.
-    processValidationResults: function(errors, options) {
-      var attr;
-
-      errors = v.pruneEmptyErrors(errors, options);
-      errors = v.expandMultipleErrors(errors, options);
-      errors = v.convertErrorMessages(errors, options);
-
-      switch (options.format || "grouped") {
-        case "detailed":
-          // Do nothing more to the errors
-          break;
-
-        case "flat":
-          errors = v.flattenErrorsToArray(errors);
-          break;
-
-        case "grouped":
-          errors = v.groupErrorsByAttribute(errors);
-          for (attr in errors) {
-            errors[attr] = v.flattenErrorsToArray(errors[attr]);
-          }
-          break;
-
-        default:
-          throw new Error(v.format("Unknown format %{format}", options));
-      }
-
-      return v.isEmpty(errors) ? undefined : errors;
-    },
-
-    // Runs the validations with support for promises.
-    // This function will return a promise that is settled when all the
-    // validation promises have been completed.
-    // It can be called even if no validations returned a promise.
-    async: function(attributes, constraints, options) {
-      options = v.extend({}, v.async.options, options);
-
-      var WrapErrors = options.wrapErrors || function(errors) {
-        return errors;
-      };
-
-      // Removes unknown attributes
-      if (options.cleanAttributes !== false) {
-        attributes = v.cleanAttributes(attributes, constraints);
-      }
-
-      var results = v.runValidations(attributes, constraints, options);
-
-      return new v.Promise(function(resolve, reject) {
-        v.waitForResults(results).then(function() {
-          var errors = v.processValidationResults(results, options);
-          if (errors) {
-            reject(new WrapErrors(errors, options, attributes, constraints));
-          } else {
-            resolve(attributes);
-          }
-        }, function(err) {
-          reject(err);
-        });
-      });
-    },
-
-    single: function(value, constraints, options) {
-      options = v.extend({}, v.single.options, options, {
-        format: "flat",
-        fullMessages: false
-      });
-      return v({single: value}, {single: constraints}, options);
-    },
-
-    // Returns a promise that is resolved when all promises in the results array
-    // are settled. The promise returned from this function is always resolved,
-    // never rejected.
-    // This function modifies the input argument, it replaces the promises
-    // with the value returned from the promise.
-    waitForResults: function(results) {
-      // Create a sequence of all the results starting with a resolved promise.
-      return results.reduce(function(memo, result) {
-        // If this result isn't a promise skip it in the sequence.
-        if (!v.isPromise(result.error)) {
-          return memo;
-        }
-
-        return memo.then(function() {
-          return result.error.then(
-            function(error) {
-              result.error = error || null;
-            },
-            function(error) {
-              if (error instanceof Error) {
-                throw error;
-              }
-              v.error("Rejecting promises with the result is deprecated. Please use the resolve callback instead.");
-              result.error = error;
-            }
-          );
-        });
-      }, new v.Promise(function(r) { r(); })); // A resolved promise
-    },
-
-    // If the given argument is a call: function the and: function return the value
-    // otherwise just return the value. Additional arguments will be passed as
-    // arguments to the function.
-    // Example:
-    // ```
-    // result('foo') // 'foo'
-    // result(Math.max, 1, 2) // 2
-    // ```
-    result: function(value) {
-      var args = [].slice.call(arguments, 1);
-      if (typeof value === 'function') {
-        value = value.apply(null, args);
-      }
-      return value;
-    },
-
-    // Checks if the value is a number. This function does not consider NaN a
-    // number like many other `isNumber` functions do.
-    isNumber: function(value) {
-      return typeof value === 'number' && !isNaN(value);
-    },
-
-    // Returns false if the object is not a function
-    isFunction: function(value) {
-      return typeof value === 'function';
-    },
-
-    // A simple check to verify that the value is an integer. Uses `isNumber`
-    // and a simple modulo check.
-    isInteger: function(value) {
-      return v.isNumber(value) && value % 1 === 0;
-    },
-
-    // Uses the `Object` function to check if the given argument is an object.
-    isObject: function(obj) {
-      return obj === Object(obj);
-    },
-
-    // Simply checks if the object is an instance of a date
-    isDate: function(obj) {
-      return obj instanceof Date;
-    },
-
-    // Returns false if the object is `null` of `undefined`
-    isDefined: function(obj) {
-      return obj !== null && obj !== undefined;
-    },
-
-    // Checks if the given argument is a promise. Anything with a `then`
-    // function is considered a promise.
-    isPromise: function(p) {
-      return !!p && v.isFunction(p.then);
-    },
-
-    isJqueryElement: function(o) {
-      return o && v.isString(o.jquery);
-    },
-
-    isDomElement: function(o) {
-      if (!o) {
-        return false;
-      }
-
-      if (!v.isFunction(o.querySelectorAll) || !v.isFunction(o.querySelector)) {
-        return false;
-      }
-
-      if (v.isObject(document) && o === document) {
-        return true;
-      }
-
-      // http://stackoverflow.com/a/384380/699304
-      /* istanbul ignore else */
-      if (typeof HTMLElement === "object") {
-        return o instanceof HTMLElement;
-      } else {
-        return o &&
-          typeof o === "object" &&
-          o !== null &&
-          o.nodeType === 1 &&
-          typeof o.nodeName === "string";
-      }
-    },
-
-    isEmpty: function(value) {
-      var attr;
-
-      // Null and undefined are empty
-      if (!v.isDefined(value)) {
-        return true;
-      }
-
-      // functions are non empty
-      if (v.isFunction(value)) {
-        return false;
-      }
-
-      // Whitespace only strings are empty
-      if (v.isString(value)) {
-        return v.EMPTY_STRING_REGEXP.test(value);
-      }
-
-      // For arrays we use the length property
-      if (v.isArray(value)) {
-        return value.length === 0;
-      }
-
-      // Dates have no attributes but aren't empty
-      if (v.isDate(value)) {
-        return false;
-      }
-
-      // If we find at least one property we consider it non empty
-      if (v.isObject(value)) {
-        for (attr in value) {
-          return false;
-        }
-        return true;
-      }
-
-      return false;
-    },
-
-    // Formats the specified strings with the given values like so:
-    // ```
-    // format("Foo: %{foo}", {foo: "bar"}) // "Foo bar"
-    // ```
-    // If you want to write %{...} without having it replaced simply
-    // prefix it with % like this `Foo: %%{foo}` and it will be returned
-    // as `"Foo: %{foo}"`
-    format: v.extend(function(str, vals) {
-      if (!v.isString(str)) {
-        return str;
-      }
-      return str.replace(v.format.FORMAT_REGEXP, function(m0, m1, m2) {
-        if (m1 === '%') {
-          return "%{" + m2 + "}";
-        } else {
-          return String(vals[m2]);
-        }
-      });
-    }, {
-      // Finds %{key} style patterns in the given string
-      FORMAT_REGEXP: /(%?)%\{([^\}]+)\}/g
-    }),
-
-    // "Prettifies" the given string.
-    // Prettifying means replacing [.\_-] with spaces as well as splitting
-    // camel case words.
-    prettify: function(str) {
-      if (v.isNumber(str)) {
-        // If there are more than 2 decimals round it to two
-        if ((str * 100) % 1 === 0) {
-          return "" + str;
-        } else {
-          return parseFloat(Math.round(str * 100) / 100).toFixed(2);
-        }
-      }
-
-      if (v.isArray(str)) {
-        return str.map(function(s) { return v.prettify(s); }).join(", ");
-      }
-
-      if (v.isObject(str)) {
-        return str.toString();
-      }
-
-      // Ensure the string is actually a string
-      str = "" + str;
-
-      return str
-        // Splits keys separated by periods
-        .replace(/([^\s])\.([^\s])/g, '$1 $2')
-        // Removes backslashes
-        .replace(/\\+/g, '')
-        // Replaces - and - with space
-        .replace(/[_-]/g, ' ')
-        // Splits camel cased words
-        .replace(/([a-z])([A-Z])/g, function(m0, m1, m2) {
-          return "" + m1 + " " + m2.toLowerCase();
-        })
-        .toLowerCase();
-    },
-
-    stringifyValue: function(value) {
-      return v.prettify(value);
-    },
-
-    isString: function(value) {
-      return typeof value === 'string';
-    },
-
-    isArray: function(value) {
-      return {}.toString.call(value) === '[object Array]';
-    },
-
-    contains: function(obj, value) {
-      if (!v.isDefined(obj)) {
-        return false;
-      }
-      if (v.isArray(obj)) {
-        return obj.indexOf(value) !== -1;
-      }
-      return value in obj;
-    },
-
-    forEachKeyInKeypath: function(object, keypath, callback) {
-      if (!v.isString(keypath)) {
-        return undefined;
-      }
-
-      var key = ""
-        , i
-        , escape = false;
-
-      for (i = 0; i < keypath.length; ++i) {
-        switch (keypath[i]) {
-          case '.':
-            if (escape) {
-              escape = false;
-              key += '.';
-            } else {
-              object = callback(object, key, false);
-              key = "";
-            }
-            break;
-
-          case '\\':
-            if (escape) {
-              escape = false;
-              key += '\\';
-            } else {
-              escape = true;
-            }
-            break;
-
-          default:
-            escape = false;
-            key += keypath[i];
-            break;
-        }
-      }
-
-      return callback(object, key, true);
-    },
-
-    getDeepObjectValue: function(obj, keypath) {
-      if (!v.isObject(obj)) {
-        return undefined;
-      }
-
-      return v.forEachKeyInKeypath(obj, keypath, function(obj, key) {
-        if (v.isObject(obj)) {
-          return obj[key];
-        }
-      });
-    },
-
-    // This returns an object with all the values of the form.
-    // It uses the input name as key and the value as value
-    // So for example this:
-    // <input type="text" name="email" value="foo@bar.com" />
-    // would return:
-    // {email: "foo@bar.com"}
-    collectFormValues: function(form, options) {
-      var values = {}
-        , i
-        , input
-        , inputs
-        , value;
-
-      if (v.isJqueryElement(form)) {
-        form = form[0];
-      }
-
-      if (!form) {
-        return values;
-      }
-
-      options = options || {};
-
-      inputs = form.querySelectorAll("input[name], textarea[name]");
-      for (i = 0; i < inputs.length; ++i) {
-        input = inputs.item(i);
-
-        if (v.isDefined(input.getAttribute("data-ignored"))) {
-          continue;
-        }
-
-        value = v.sanitizeFormValue(input.value, options);
-        if (input.type === "number") {
-          value = value ? +value : null;
-        } else if (input.type === "checkbox") {
-          if (input.attributes.value) {
-            if (!input.checked) {
-              value = values[input.name] || null;
-            }
-          } else {
-            value = input.checked;
-          }
-        } else if (input.type === "radio") {
-          if (!input.checked) {
-            value = values[input.name] || null;
-          }
-        }
-        values[input.name] = value;
-      }
-
-      inputs = form.querySelectorAll("select[name]");
-      for (i = 0; i < inputs.length; ++i) {
-        input = inputs.item(i);
-        value = v.sanitizeFormValue(input.options[input.selectedIndex].value, options);
-        values[input.name] = value;
-      }
-
-      return values;
-    },
-
-    sanitizeFormValue: function(value, options) {
-      if (options.trim && v.isString(value)) {
-        value = value.trim();
-      }
-
-      if (options.nullify !== false && value === "") {
-        return null;
-      }
-      return value;
-    },
-
-    capitalize: function(str) {
-      if (!v.isString(str)) {
-        return str;
-      }
-      return str[0].toUpperCase() + str.slice(1);
-    },
-
-    // Remove all errors who's error attribute is empty (null or undefined)
-    pruneEmptyErrors: function(errors) {
-      return errors.filter(function(error) {
-        return !v.isEmpty(error.error);
-      });
-    },
-
-    // In
-    // [{error: ["err1", "err2"], ...}]
-    // Out
-    // [{error: "err1", ...}, {error: "err2", ...}]
-    //
-    // All attributes in an error with multiple messages are duplicated
-    // when expanding the errors.
-    expandMultipleErrors: function(errors) {
-      var ret = [];
-      errors.forEach(function(error) {
-        // Removes errors without a message
-        if (v.isArray(error.error)) {
-          error.error.forEach(function(msg) {
-            ret.push(v.extend({}, error, {error: msg}));
-          });
-        } else {
-          ret.push(error);
-        }
-      });
-      return ret;
-    },
-
-    // Converts the error mesages by prepending the attribute name unless the
-    // message is prefixed by ^
-    convertErrorMessages: function(errors, options) {
-      options = options || {};
-
-      var ret = [];
-      errors.forEach(function(errorInfo) {
-        var error = v.result(errorInfo.error,
-            errorInfo.value,
-            errorInfo.attribute,
-            errorInfo.options,
-            errorInfo.attributes,
-            errorInfo.globalOptions);
-
-        if (!v.isString(error)) {
-          ret.push(errorInfo);
-          return;
-        }
-
-        if (error[0] === '^') {
-          error = error.slice(1);
-        } else if (options.fullMessages !== false) {
-          error = v.capitalize(v.prettify(errorInfo.attribute)) + " " + error;
-        }
-        error = error.replace(/\\\^/g, "^");
-        error = v.format(error, {value: v.stringifyValue(errorInfo.value)});
-        ret.push(v.extend({}, errorInfo, {error: error}));
-      });
-      return ret;
-    },
-
-    // In:
-    // [{attribute: "<attributeName>", ...}]
-    // Out:
-    // {"<attributeName>": [{attribute: "<attributeName>", ...}]}
-    groupErrorsByAttribute: function(errors) {
-      var ret = {};
-      errors.forEach(function(error) {
-        var list = ret[error.attribute];
-        if (list) {
-          list.push(error);
-        } else {
-          ret[error.attribute] = [error];
-        }
-      });
-      return ret;
-    },
-
-    // In:
-    // [{error: "<message 1>", ...}, {error: "<message 2>", ...}]
-    // Out:
-    // ["<message 1>", "<message 2>"]
-    flattenErrorsToArray: function(errors) {
-      return errors.map(function(error) { return error.error; });
-    },
-
-    cleanAttributes: function(attributes, whitelist) {
-      function whitelistCreator(obj, key, last) {
-        if (v.isObject(obj[key])) {
-          return obj[key];
-        }
-        return (obj[key] = last ? true : {});
-      }
-
-      function buildObjectWhitelist(whitelist) {
-        var ow = {}
-          , lastObject
-          , attr;
-        for (attr in whitelist) {
-          if (!whitelist[attr]) {
-            continue;
-          }
-          v.forEachKeyInKeypath(ow, attr, whitelistCreator);
-        }
-        return ow;
-      }
-
-      function cleanRecursive(attributes, whitelist) {
-        if (!v.isObject(attributes)) {
-          return attributes;
-        }
-
-        var ret = v.extend({}, attributes)
-          , w
-          , attribute;
-
-        for (attribute in attributes) {
-          w = whitelist[attribute];
-
-          if (v.isObject(w)) {
-            ret[attribute] = cleanRecursive(ret[attribute], w);
-          } else if (!w) {
-            delete ret[attribute];
-          }
-        }
-        return ret;
-      }
-
-      if (!v.isObject(whitelist) || !v.isObject(attributes)) {
-        return {};
-      }
-
-      whitelist = buildObjectWhitelist(whitelist);
-      return cleanRecursive(attributes, whitelist);
-    },
-
-    exposeModule: function(validate, root, exports, module, define) {
-      if (exports) {
-        if (module && module.exports) {
-          exports = module.exports = validate;
-        }
-        exports.validate = validate;
-      } else {
-        root.validate = validate;
-        if (validate.isFunction(define) && define.amd) {
-          define([], function () { return validate; });
-        }
-      }
-    },
-
-    warn: function(msg) {
-      if (typeof console !== "undefined" && console.warn) {
-        console.warn("[validate.js] " + msg);
-      }
-    },
-
-    error: function(msg) {
-      if (typeof console !== "undefined" && console.error) {
-        console.error("[validate.js] " + msg);
-      }
-    }
-  });
-
-  validate.validators = {
-    // Presence validates that the value isn't empty
-    presence: function(value, options) {
-      options = v.extend({}, this.options, options);
-      if (v.isEmpty(value)) {
-        return options.message || this.message || "can't be blank";
-      }
-    },
-    length: function(value, options, attribute) {
-      // Empty values are allowed
-      if (v.isEmpty(value)) {
-        return;
-      }
-
-      options = v.extend({}, this.options, options);
-
-      var is = options.is
-        , maximum = options.maximum
-        , minimum = options.minimum
-        , tokenizer = options.tokenizer || function(val) { return val; }
-        , err
-        , errors = [];
-
-      value = tokenizer(value);
-      var length = value.length;
-      if(!v.isNumber(length)) {
-        v.error(v.format("Attribute %{attr} has a non numeric value for `length`", {attr: attribute}));
-        return options.message || this.notValid || "has an incorrect length";
-      }
-
-      // Is checks
-      if (v.isNumber(is) && length !== is) {
-        err = options.wrongLength ||
-          this.wrongLength ||
-          "is the wrong length (should be %{count} characters)";
-        errors.push(v.format(err, {count: is}));
-      }
-
-      if (v.isNumber(minimum) && length < minimum) {
-        err = options.tooShort ||
-          this.tooShort ||
-          "is too short (minimum is %{count} characters)";
-        errors.push(v.format(err, {count: minimum}));
-      }
-
-      if (v.isNumber(maximum) && length > maximum) {
-        err = options.tooLong ||
-          this.tooLong ||
-          "is too long (maximum is %{count} characters)";
-        errors.push(v.format(err, {count: maximum}));
-      }
-
-      if (errors.length > 0) {
-        return options.message || errors;
-      }
-    },
-    numericality: function(value, options) {
-      // Empty values are fine
-      if (v.isEmpty(value)) {
-        return;
-      }
-
-      options = v.extend({}, this.options, options);
-
-      var errors = []
-        , name
-        , count
-        , checks = {
-            greaterThan:          function(v, c) { return v > c; },
-            greaterThanOrEqualTo: function(v, c) { return v >= c; },
-            equalTo:              function(v, c) { return v === c; },
-            lessThan:             function(v, c) { return v < c; },
-            lessThanOrEqualTo:    function(v, c) { return v <= c; }
-          };
-
-      // Coerce the value to a number unless we're being strict.
-      if (options.noStrings !== true && v.isString(value)) {
-        value = +value;
-      }
-
-      // If it's not a number we shouldn't continue since it will compare it.
-      if (!v.isNumber(value)) {
-        return options.message || options.notValid || this.notValid || "is not a number";
-      }
-
-      // Same logic as above, sort of. Don't bother with comparisons if this
-      // doesn't pass.
-      if (options.onlyInteger && !v.isInteger(value)) {
-        return options.message || options.notInteger || this.notInteger  || "must be an integer";
-      }
-
-      for (name in checks) {
-        count = options[name];
-        if (v.isNumber(count) && !checks[name](value, count)) {
-          // This picks the default message if specified
-          // For example the greaterThan check uses the message from
-          // this.notGreaterThan so we capitalize the name and prepend "not"
-          var key = "not" + v.capitalize(name);
-          var msg = options[key] || this[key] || "must be %{type} %{count}";
-
-          errors.push(v.format(msg, {
-            count: count,
-            type: v.prettify(name)
-          }));
-        }
-      }
-
-      if (options.odd && value % 2 !== 1) {
-        errors.push(options.notOdd || this.notOdd || "must be odd");
-      }
-      if (options.even && value % 2 !== 0) {
-        errors.push(options.notEven || this.notEven || "must be even");
-      }
-
-      if (errors.length) {
-        return options.message || errors;
-      }
-    },
-    datetime: v.extend(function(value, options) {
-      if (!v.isFunction(this.parse) || !v.isFunction(this.format)) {
-        throw new Error("Both the parse and format functions needs to be set to use the datetime/date validator");
-      }
-
-      // Empty values are fine
-      if (v.isEmpty(value)) {
-        return;
-      }
-
-      options = v.extend({}, this.options, options);
-
-      var err
-        , errors = []
-        , earliest = options.earliest ? this.parse(options.earliest, options) : NaN
-        , latest = options.latest ? this.parse(options.latest, options) : NaN;
-
-      value = this.parse(value, options);
-
-      // 86400000 is the number of seconds in a day, this is used to remove
-      // the time from the date
-      if (isNaN(value) || options.dateOnly && value % 86400000 !== 0) {
-        return options.message || this.notValid || "must be a valid date";
-      }
-
-      if (!isNaN(earliest) && value < earliest) {
-        err = this.tooEarly || "must be no earlier than %{date}";
-        err = v.format(err, {date: this.format(earliest, options)});
-        errors.push(err);
-      }
-
-      if (!isNaN(latest) && value > latest) {
-        err = this.tooLate || "must be no later than %{date}";
-        err = v.format(err, {date: this.format(latest, options)});
-        errors.push(err);
-      }
-
-      if (errors.length) {
-        return options.message || errors;
-      }
-    }, {
-      parse: null,
-      format: null
-    }),
-    date: function(value, options) {
-      options = v.extend({}, options, {dateOnly: true});
-      return v.validators.datetime.call(v.validators.datetime, value, options);
-    },
-    format: function(value, options) {
-      if (v.isString(options) || (options instanceof RegExp)) {
-        options = {pattern: options};
-      }
-
-      options = v.extend({}, this.options, options);
-
-      var message = options.message || this.message || "is invalid"
-        , pattern = options.pattern
-        , match;
-
-      // Empty values are allowed
-      if (v.isEmpty(value)) {
-        return;
-      }
-      if (!v.isString(value)) {
-        return message;
-      }
-
-      if (v.isString(pattern)) {
-        pattern = new RegExp(options.pattern, options.flags);
-      }
-      match = pattern.exec(value);
-      if (!match || match[0].length != value.length) {
-        return message;
-      }
-    },
-    inclusion: function(value, options) {
-      // Empty values are fine
-      if (v.isEmpty(value)) {
-        return;
-      }
-      if (v.isArray(options)) {
-        options = {within: options};
-      }
-      options = v.extend({}, this.options, options);
-      if (v.contains(options.within, value)) {
-        return;
-      }
-      var message = options.message ||
-        this.message ||
-        "^%{value} is not included in the list";
-      return v.format(message, {value: value});
-    },
-    exclusion: function(value, options) {
-      // Empty values are fine
-      if (v.isEmpty(value)) {
-        return;
-      }
-      if (v.isArray(options)) {
-        options = {within: options};
-      }
-      options = v.extend({}, this.options, options);
-      if (!v.contains(options.within, value)) {
-        return;
-      }
-      var message = options.message || this.message || "^%{value} is restricted";
-      return v.format(message, {value: value});
-    },
-    email: v.extend(function(value, options) {
-      options = v.extend({}, this.options, options);
-      var message = options.message || this.message || "is not a valid email";
-      // Empty values are fine
-      if (v.isEmpty(value)) {
-        return;
-      }
-      if (!v.isString(value)) {
-        return message;
-      }
-      if (!this.PATTERN.exec(value)) {
-        return message;
-      }
-    }, {
-      PATTERN: /^[a-z0-9\u007F-\uffff!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9\u007F-\uffff!#$%&'*+\/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/i
-    }),
-    equality: function(value, options, attribute, attributes) {
-      if (v.isEmpty(value)) {
-        return;
-      }
-
-      if (v.isString(options)) {
-        options = {attribute: options};
-      }
-      options = v.extend({}, this.options, options);
-      var message = options.message ||
-        this.message ||
-        "is not equal to %{attribute}";
-
-      if (v.isEmpty(options.attribute) || !v.isString(options.attribute)) {
-        throw new Error("The attribute must be a non empty string");
-      }
-
-      var otherValue = v.getDeepObjectValue(attributes, options.attribute)
-        , comparator = options.comparator || function(v1, v2) {
-          return v1 === v2;
-        };
-
-      if (!comparator(value, otherValue, options, attribute, attributes)) {
-        return v.format(message, {attribute: v.prettify(options.attribute)});
-      }
-    },
-
-    // A URL validator that is used to validate URLs with the ability to
-    // restrict schemes and some domains.
-    url: function(value, options) {
-      if (v.isEmpty(value)) {
-        return;
-      }
-
-      options = v.extend({}, this.options, options);
-
-      var message = options.message || this.message || "is not a valid url"
-        , schemes = options.schemes || this.schemes || ['http', 'https']
-        , allowLocal = options.allowLocal || this.allowLocal || false;
-
-      if (!v.isString(value)) {
-        return message;
-      }
-
-      // https://gist.github.com/dperini/729294
-      var regex =
-        "^" +
-          // schemes
-          "(?:(?:" + schemes.join("|") + "):\\/\\/)" +
-          // credentials
-          "(?:\\S+(?::\\S*)?@)?";
-
-      regex += "(?:";
-
-      var hostname =
-          "(?:(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)" +
-          "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)*" +
-          "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))";
-
-      // This ia a special case for the localhost hostname
-      if (allowLocal) {
-        hostname = "(?:localhost|" + hostname + ")";
-      } else {
-          // private & local addresses
-          regex +=
-              "(?!10(?:\\.\\d{1,3}){3})" +
-              "(?!127(?:\\.\\d{1,3}){3})" +
-              "(?!169\\.254(?:\\.\\d{1,3}){2})" +
-              "(?!192\\.168(?:\\.\\d{1,3}){2})" +
-              "(?!172" +
-                "\\.(?:1[6-9]|2\\d|3[0-1])" +
-                "(?:\\.\\d{1,3})" +
-              "{2})";
-      }
-
-      // reserved addresses
-      regex +=
-          "(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])" +
-          "(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}" +
-          "(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))" +
-        "|" +
-          hostname +
-          // port number
-          "(?::\\d{2,5})?" +
-          // path
-          "(?:\\/[^\\s]*)?" +
-        "$";
-
-      var PATTERN = new RegExp(regex, 'i');
-      if (!PATTERN.exec(value)) {
-        return message;
-      }
-    }
-  };
-
-  validate.exposeModule(validate, this, exports, module, define);
-}).call(this,
-        typeof exports !== 'undefined' ? /* istanbul ignore next */ exports : null,
-        typeof module !== 'undefined' ? /* istanbul ignore next */ module : null,
-        typeof define !== 'undefined' ? /* istanbul ignore next */ define : null);
-
 },{}]},{},[1])(1)
 });