@zohodesk/library-platform 1.1.7 → 1.1.8-alpha.1

package/es/platform/zform/frameworks/ui/ZFormBehaviourFactory.js

@@ -2,16 +2,13 @@ import Properties from "../../../../bc/zform/Properties";
 import EventHandlerFactory from "./EventHandlerFactory";
 
 class ZFormBehaviourFactory {
-  static create(_ref) {
-    let {
-      customValidators
-    } = _ref;
+  static create() {
     return {
       name: 'zform',
-      setInitialState: _ref2 => {
+      setInitialState: _ref => {
         let {
           properties
-        } = _ref2;
+        } = _ref;
         return {
           isMyFormFetching: true,
           isDependencyFetching: true,
@@ -20,9 +17,7 @@ class ZFormBehaviourFactory {
         };
       },
       properties: Properties,
-      eventHandlers: EventHandlerFactory.create({
-        customValidators
-      })
+      eventHandlers: EventHandlerFactory.create()
     };
   }
 

package/es/platform/zform/frameworks/validation-rules/DefaultCustomValidators.js

@@ -0,0 +1,340 @@
+import { i18NProviderUtils } from '@zohodesk/i18n';
+export function maxLengthValidation(_ref) {
+  let {
+    field,
+    value
+  } = _ref;
+  return new Promise(res => {
+    const {
+      i18NLabel,
+      maxLength
+    } = field;
+    const regexp = new RegExp(`^.{0,${maxLength}}$`);
+
+    if (!value || regexp.test(value)) {
+      res({
+        type: 'success'
+      });
+    } else {
+      res({
+        type: 'fail',
+        action: {
+          message: i18NProviderUtils.getI18NValue('support.form.more.than.max.length', [i18NLabel, maxLength])
+        }
+      });
+    }
+  });
+}
+export function emailValidation(_ref2) {
+  let {
+    field,
+    value
+  } = _ref2;
+  return new Promise(res => {
+    const {
+      i18NLabel
+    } = field;
+    const regexp = new RegExp(`^[\\wÀ-ž]([\\wÀ-ž\\-\\.\\+\\'\\&\\/]*)@([\\wÀ-ž\\-\\.]*)(\\.[a-zA-ZÀ-ž]{2,22}(\\.[a-zA-ZÀ-ž]{2}){0,2})$`);
+
+    if (!value || regexp.test(value)) {
+      res({
+        type: 'success'
+      });
+    } else {
+      res({
+        type: 'fail',
+        action: {
+          message: i18NProviderUtils.getI18NValue('crm.field.valid.check', [i18NLabel])
+        }
+      });
+    }
+  });
+}
+export function phoneValidation(_ref3) {
+  let {
+    field,
+    value
+  } = _ref3;
+  return new Promise(res => {
+    const {
+      i18NLabel
+    } = field;
+    const regexp = new RegExp(`^[0-9a-zA-Z_()\\+\\-\\.\\$@\\?\\,\\:\\'\\/\\!\\s]*$`);
+
+    if (!value || regexp.test(value)) {
+      res({
+        type: 'success'
+      });
+    } else {
+      res({
+        type: 'fail',
+        action: {
+          message: i18NProviderUtils.getI18NValue('crm.field.valid.check', [i18NLabel])
+        }
+      });
+    }
+  });
+}
+export function numberValidation(_ref4) {
+  let {
+    field,
+    value
+  } = _ref4;
+  return new Promise(res => {
+    const {
+      i18NLabel
+    } = field;
+    const regexp = new RegExp(`^-?\\d\\d*$`);
+
+    if (!value || regexp.test(value)) {
+      res({
+        type: 'success'
+      });
+    } else {
+      res({
+        type: 'fail',
+        action: {
+          message: i18NProviderUtils.getI18NValue('crm.field.valid.check', [i18NLabel])
+        }
+      });
+    }
+  });
+}
+export function decimalValidation(_ref5) {
+  let {
+    field,
+    value
+  } = _ref5;
+  return new Promise(res => {
+    const {
+      i18NLabel
+    } = field;
+    const regexp = new RegExp(`^-?[0-9]\\d*(|\\.\\d[0-9]*)$`);
+
+    if (!value || regexp.test(value)) {
+      res({
+        type: 'success'
+      });
+    } else {
+      res({
+        type: 'fail',
+        action: {
+          message: i18NProviderUtils.getI18NValue('crm.field.valid.check', [i18NLabel])
+        }
+      });
+    }
+  });
+}
+export function decimalPlacesValidation(_ref6) {
+  let {
+    field,
+    value
+  } = _ref6;
+  return new Promise(res => {
+    const {
+      decimalPlaces
+    } = field;
+    const regexp = new RegExp(`^\\d+(\\.\\d{0,${decimalPlaces}})?$`);
+
+    if (!value || regexp.test(value)) {
+      res({
+        type: 'success'
+      });
+    } else {
+      res({
+        type: 'fail',
+        action: {
+          message: i18NProviderUtils.getI18NValue('support.form.decimal.places.length.error.message', [decimalPlaces])
+        }
+      });
+    }
+  });
+}
+export function dateValidation(_ref7) {
+  let {
+    field,
+    value
+  } = _ref7;
+
+  function isValidDate(dateObj) {
+    if (dateObj == 'Invalid Date') {
+      return false;
+    }
+
+    if (dateObj || dateObj instanceof Date && dateObj.getFullYear() > 1000) {
+      return true;
+    }
+
+    return false;
+  }
+
+  return new Promise(res => {
+    const {
+      i18NLabel
+    } = field;
+
+    if (!value || isValidDate(value)) {
+      res({
+        type: 'success'
+      });
+    } else {
+      res({
+        type: 'fail',
+        action: {
+          message: i18NProviderUtils.getI18NValue('crm.field.valid.check', [i18NLabel])
+        }
+      });
+    }
+  });
+}
+const validator = {
+  isEmpty(value) {
+    const valueType = typeof value;
+
+    if (valueType === 'string') {
+      return this.isEmptyString(value);
+    }
+
+    if (Array.isArray(value)) {
+      return this.isEmptyArr(value);
+    }
+
+    if (valueType === 'object') {
+      return this.isEmptyObj(value);
+    }
+
+    if (valueType === 'boolean' || value) {
+      return false;
+    }
+
+    return true;
+  },
+
+  isEmptyString(value) {
+    if (value && typeof value === 'string' && value.trim()) {
+      return false;
+    }
+
+    return true;
+  },
+
+  isEmptyArr(value) {
+    if (Array.isArray(value) && value.length > 0) {
+      return false;
+    }
+
+    return true;
+  },
+
+  isEmptyMultiSelect(value) {
+    if (!this.isEmpty(value) && !(value.length <= 2 && value.every(val => this.isNoneValue(val)))) {
+      return false;
+    }
+
+    return true;
+  },
+
+  isEmptyPicklist(value) {
+    if (!this.isEmpty(value) && !this.isNoneValue(value)) {
+      return false;
+    }
+
+    return true;
+  },
+
+  isEmptyObj(value) {
+    for (const key in value) {
+      if (value.hasOwnProperty(key)) {
+        return false;
+      }
+    }
+
+    return true;
+  },
+
+  isNoneValue() {
+    let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    const inpVal = value.trim && value.trim();
+    const noneText = '-None-';
+    const i18nNoneValue = i18NProviderUtils.getI18NValue('-None-');
+
+    if (typeof inpVal === 'string' && (inpVal === noneText || inpVal === i18nNoneValue)) {
+      return true;
+    }
+
+    return false;
+  }
+
+};
+export function customMandatoryValidation(_ref8) {
+  let {
+    field,
+    value
+  } = _ref8;
+  return new Promise(res => {
+    const {
+      i18NLabel
+    } = field;
+
+    if (!validator.isEmpty(value)) {
+      res({
+        type: 'success'
+      });
+    } else {
+      res({
+        type: 'fail',
+        action: {
+          message: i18NProviderUtils.getI18NValue('crm.field.empty.check', [i18NLabel])
+        }
+      });
+    }
+  });
+}
+export function picklistMandatoryValidation(_ref9) {
+  let {
+    field,
+    value
+  } = _ref9;
+  return new Promise(res => {
+    const {
+      i18NLabel
+    } = field;
+
+    if (!validator.isEmptyPicklist(value)) {
+      res({
+        type: 'success'
+      });
+    } else {
+      res({
+        type: 'fail',
+        action: {
+          message: i18NProviderUtils.getI18NValue('crm.field.empty.check', [i18NLabel])
+        }
+      });
+    }
+  });
+}
+export function multiSelectMandatoryValidation(_ref10) {
+  let {
+    field,
+    value
+  } = _ref10;
+  return new Promise(res => {
+    const {
+      i18NLabel
+    } = field;
+
+    if (!validator.isEmptyMultiSelect(value)) {
+      res({
+        type: 'success'
+      });
+    } else {
+      res({
+        type: 'fail',
+        action: {
+          message: i18NProviderUtils.getI18NValue('crm.field.empty.check', [i18NLabel])
+        }
+      });
+    }
+  });
+}

package/es/platform/zform/frameworks/validation-rules/Validator.js

@@ -1,23 +1,89 @@
-import getValidationRuleActionsData from "./validationRules"; //need to move to gateway in adapter
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import getValidationRuleActionsData from "./validationRules";
+import * as defaultCustomValidators from "./DefaultCustomValidators"; //need to move to gateway in adapter
 
 export default class Validator {
-  constructor(customValidators) {
-    this.customValidators = customValidators;
+  constructor() {
+    _defineProperty(this, "customValidators", defaultCustomValidators);
+  }
+
+  init(state) {
+    this.customValidators = { ...defaultCustomValidators,
+      ...state.properties.customValidators
+    };
+  }
+
+  customValidationRunner(_ref) {
+    let {
+      fieldCondition,
+      fieldName,
+      formValues,
+      fieldDetails,
+      fieldNameMap2Field
+    } = _ref;
+    const {
+      customValidators
+    } = this;
+    const {
+      validator
+    } = fieldCondition;
+    const {
+      scriptId
+    } = validator;
+    const field = fieldNameMap2Field[fieldName];
+
+    if (scriptId && customValidators[scriptId]) {
+      const script = customValidators[scriptId];
+
+      function handleResult(result) {
+        if (result && result.type === 'fail') {
+          var _result$action;
+
+          const errorMessage = typeof result.message === 'string' ? result.message : (_result$action = result.action) === null || _result$action === void 0 ? void 0 : _result$action.message;
+          return {
+            fieldName,
+            actions: {
+              alert: errorMessage
+            }
+          };
+        }
+
+        return null;
+      }
+
+      const arg = {
+        value: formValues[fieldName],
+        fieldId: field.id,
+        fieldCondition,
+        fieldName,
+        field
+      };
+      return script(arg).then(handleResult).catch(handleResult);
+    } else {
+      console.warn(`Custom validator "${scriptId}" not found in customValidators`, customValidators);
+    }
+
+    return null;
   }
 
-  validateAsync(_ref) {
+  validateAsync(_ref2) {
     let {
       formData,
       myForm,
       validationRules
-    } = _ref;
-    let fieldDetails = {};
-    let fieldMapper = {};
+    } = _ref2;
+    const fieldDetails = {};
+    const fieldMapper = {};
+    const fieldNameMap2Field = {};
     const formUIData = {};
+    const formValues = {};
     myForm.sections.forEach(section => {
       section.fields.forEach(field => {
         fieldDetails[field.id] = field;
+        fieldNameMap2Field[field.apiName] = field;
         fieldMapper[field.apiName] = field.id;
+        formValues[field.apiName] = formData[field.apiName].value;
         formUIData[field.id] = { ...field,
           value: formData[field.apiName].value || null,
           isShowOnLayoutRuleApplied: true //hack
@@ -29,16 +95,32 @@ export default class Validator {
       fieldDetails,
       fieldMapper
     };
-    let result = getValidationRuleActionsData(validationRules, formUIData, formFields, this.customValidators);
-    let output = {};
-    Object.keys(result.data).forEach(key => {
-      if (!output[fieldDetails[key].apiName]) {
-        output[fieldDetails[key].apiName] = {};
-      }
 
-      output[fieldDetails[key].apiName].errorMessage = result.data[key].validationRuleMessage;
-    });
-    return Promise.resolve(output); // throw new Error("Method not implemented.");
+    const customValidationRunnerWrapper = _ref3 => {
+      let {
+        fieldCondition,
+        fieldName
+      } = _ref3;
+      return this.customValidationRunner({
+        fieldCondition,
+        fieldName,
+        formValues,
+        fieldDetails,
+        fieldNameMap2Field
+      });
+    };
+
+    return getValidationRuleActionsData(validationRules, formUIData, formFields, customValidationRunnerWrapper).then(result => {
+      const output = {};
+      Object.keys(result.data).forEach(key => {
+        if (!output[fieldDetails[key].apiName]) {
+          output[fieldDetails[key].apiName] = {};
+        }
+
+        output[fieldDetails[key].apiName].errorMessage = result.data[key].validationRuleMessage;
+      });
+      return Promise.resolve(output);
+    }); // throw new Error("Method not implemented.");
   }
 
 }

package/es/platform/zform/frameworks/validation-rules/formUtils.js

@@ -0,0 +1,7 @@
+import { i18NProviderUtils } from '@zohodesk/i18n';
+export function getNoneText() {
+  const valueNoneText = i18NProviderUtils.getI18NValue('-None-');
+  return {
+    valueNoneText
+  };
+}

package/es/platform/zform/frameworks/validation-rules/localization_utils.js

@@ -0,0 +1,15 @@
+export function getLocalizedFunction() {
+  let initialArg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return function () {
+    let args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return getLocalizedValue({ ...args,
+      ...initialArg
+    });
+  };
+}
+export function getLocalizedValue() {
+  let {
+    fieldValue
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return fieldValue;
+}