@progress/telerik-jquery-report-viewer 21.24.305 → 22.24.514

package/dist/cjs/parameterValidators.js

@@ -0,0 +1,167 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('./utils.js');
+var stringResources = require('./stringResources.js');
+var enums = require('./enums.js');
+
+var ParameterValidators = function() {
+  var validators = {};
+  function validateParameter(parameter, value, validatorFunc, compareFunc) {
+    var values = [].concat(value).map(function(value1) {
+      return checkAvailableValues(parameter, validatorFunc(value1), compareFunc);
+    });
+    if (parameter.multivalue) {
+      if (value == null || value.length == 0) {
+        if (parameter.allowNull) {
+          return value;
+        } else {
+          throw stringResources.stringResources.invalidParameter;
+        }
+      }
+      return values;
+    }
+    return values[0];
+  }
+  function isNull(parameter, value) {
+    return parameter.allowNull && -1 != [null, "", void 0].indexOf(value);
+  }
+  function checkAvailableValues(parameter, value, compareFunc) {
+    if (parameter.availableValues) {
+      var found = false;
+      utils.each(parameter.availableValues, function(i, av) {
+        found = compareFunc(value, av.value);
+        return !found;
+      });
+      if (!found) {
+        if (parameter.allowNull && !value) {
+          return value;
+        }
+        throw stringResources.stringResources.invalidParameter;
+      }
+    }
+    return value;
+  }
+  validators[enums.ParameterTypes.STRING] = {
+    validate: function(parameter, value) {
+      return validateParameter(
+        parameter,
+        value,
+        function(value2) {
+          if (!value2) {
+            if (parameter.allowNull) {
+              return null;
+            }
+            if (parameter.allowBlank) {
+              return "";
+            }
+            throw stringResources.stringResources.parameterIsEmpty;
+          }
+          return value2;
+        },
+        function(s1, s2) {
+          return s1 == s2;
+        }
+      );
+    }
+  };
+  validators[enums.ParameterTypes.FLOAT] = {
+    validate: function(parameter, value) {
+      return validateParameter(
+        parameter,
+        value,
+        function(value2) {
+          var num = utils.tryParseFloat(value2);
+          if (isNaN(num)) {
+            if (isNull(parameter, value2)) {
+              return null;
+            }
+            throw stringResources.stringResources.parameterIsEmpty;
+          }
+          return num;
+        },
+        function(f1, f2) {
+          return utils.tryParseFloat(f1) == utils.tryParseFloat(f2);
+        }
+      );
+    }
+  };
+  validators[enums.ParameterTypes.INTEGER] = {
+    validate: function(parameter, value) {
+      return validateParameter(
+        parameter,
+        value,
+        function(value2) {
+          var num = utils.tryParseInt(value2);
+          if (isNaN(num)) {
+            if (isNull(parameter, value2)) {
+              return null;
+            }
+            throw stringResources.stringResources.parameterIsEmpty;
+          }
+          return num;
+        },
+        function(n1, n2) {
+          return utils.tryParseInt(n1) == utils.tryParseFloat(n2);
+        }
+      );
+    }
+  };
+  validators[enums.ParameterTypes.DATETIME] = {
+    validate: function(parameter, value) {
+      return validateParameter(
+        parameter,
+        value,
+        function(value2) {
+          if (parameter.allowNull && (value2 === null || value2 === "" || value2 === void 0)) {
+            return null;
+          }
+          if (!isNaN(Date.parse(value2))) {
+            if (parameter.availableValues) {
+              return value2;
+            }
+            return utils.parseToLocalDate(value2);
+          }
+          throw stringResources.stringResources.invalidDateTimeValue;
+        },
+        function(d1, d2) {
+          d1 = utils.parseToLocalDate(d1);
+          d2 = utils.parseToLocalDate(d2);
+          return d1.getTime() == d2.getTime();
+        }
+      );
+    }
+  };
+  validators[enums.ParameterTypes.BOOLEAN] = {
+    validate: function(parameter, value) {
+      return validateParameter(
+        parameter,
+        value,
+        function(value2) {
+          if (-1 != ["true", "false"].indexOf(("" + value2).toLowerCase())) {
+            return Boolean(value2);
+          }
+          if (isNull(parameter, value2)) {
+            return null;
+          }
+          throw stringResources.stringResources.parameterIsEmpty;
+        },
+        function(b1, b2) {
+          return Boolean(b1) == Boolean(b2);
+        }
+      );
+    }
+  };
+  return {
+    validate: function(parameter, value) {
+      var v = validators[parameter.type];
+      if (!v) {
+        throw utils.stringFormat(stringResources.stringResources.cannotValidateType, parameter);
+      }
+      return v.validate(parameter, value);
+    }
+  };
+}();
+
+exports.ParameterValidators = ParameterValidators;