@zohodesk/library-platform 1.1.7-exp.2 → 1.1.8-exp.1

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

@@ -5,7 +5,7 @@ import FormPresenter from "../../adapters/presenter/FormPresenter";
 import Service from "../../adapters/gateway/Service";
 import LifeCycleEvents from "../../../../cc/component/LifeCycleEventsEnum";
 import InitializeController from "../../adapters/controllers/IntializeController";
-import { ZFORM_DEPENDENCY_MAPPINGS_REQUEST, ZFORM_DEPENDENCY_MAPPINGS_SUCCESS, ZFORM_FIELD_VALUE_CHANGE_REQUEST, ZFORM_MY_FORM_REQUEST, ZFORM_MY_FORM_SUCCESS, ZFORM_MY_LAYOUTS_SUCCESS, ZFORM_SET_FIELD_ERROR_MESSAGE, ZFORM_SUBMIT_SUCCESS, ZFORM_VALIDATE_FIELD_REQUEST, ZFORM_VALIDATE_SUBMIT_FIELD_HAS_ERROR_MESSAGE, ZFORM_VALIDATION_ERROR, ZFORM_VALIDATION_RULES_REQUEST, ZFORM_VALIDATION_RULES_SUCCESS } from "../../../../bc/zform/Symbol";
+import { ZFORM_DEPENDENCY_MAPPINGS_REQUEST, ZFORM_DEPENDENCY_MAPPINGS_SUCCESS, ZFORM_FIELD_VALUE_CHANGE_REQUEST, ZFORM_MY_FORM_REQUEST, ZFORM_MY_FORM_SUCCESS, ZFORM_MY_LAYOUTS_SUCCESS, ZFORM_SET_FIELD_ERROR_MESSAGE, ZFORM_SUBMIT_SUCCESS, ZFORM_SUBMIT_VALIDATION_COMPLETED, ZFORM_VALIDATE_FIELD_REQUEST, ZFORM_VALIDATION_RULES_REQUEST, ZFORM_VALIDATION_RULES_SUCCESS, ZFORM_VALIDATION_RULES_EXECUTION_RESULT } from "../../../../bc/zform/Symbol";
 import MyLayoutSuccessController from "../../adapters/controllers/MyLayoutSuccessController";
 import MyFormSuccessController from "../../adapters/controllers/MyFromSuccessController";
 import DependenciesController from "../../adapters/controllers/DependenciesController";
@@ -20,21 +20,19 @@ import FieldValueChangeController from "../../adapters/controllers/FieldValueCha
 import FormConstants from "../../../../cc/form/Constants";
 import ValidateFieldRequestController from "../../adapters/controllers/ValidateFieldRequestController";
 import FormValidator from "../validation-rules/Validator";
-import { FIELD_VALIDATION_RESULT, VALIDATE_FIELDS_RESULT } from "../../../../bc/field-validation/Constants";
 import SetFieldErrorMessageController from "../../adapters/controllers/SetFieldErrorMessageController";
 import LayoutRuleApplier from "../layout-rules/LayoutRuleApplier";
-import ValidateErrorMessageController from "../../adapters/controllers/ValidateErrorMessageController";
-import { CREATE_RECORD, RECORD_EXECUTE_FAIL_CALLBACK, RECORD_EXECUTE_SUCCESS_CALLBACK } from "../../../../bc/zrecord/Constants";
+import { RECORD_EXECUTE_FAIL_CALLBACK, RECORD_EXECUTE_SUCCESS_CALLBACK } from "../../../../bc/zrecord/Constants";
 import SmartFormConstants from "../../../../cc/form-connected/Constants";
+import FieldBlurController from "../../adapters/controllers/FieldBlurController";
+import SubmitValidationCompletedController from "../../adapters/controllers/SubmitValidationCompletedController";
+import ValidationRulesExecutionResultController from "../../adapters/controllers/ValidationRulesExecutionResultController";
 
 class EventHandlersFactory {
-  static create(_ref) {
-    let {
-      customValidators
-    } = _ref;
+  static create() {
     const presenter = new FormPresenter();
     const repository = new FormRepository();
-    const validator = new FormValidator(customValidators);
+    const validator = new FormValidator();
     const layoutRuleApplier = new LayoutRuleApplier();
     const service = new Service({
       presenter,
@@ -56,25 +54,27 @@ class EventHandlersFactory {
     const validateFieldRequestController = new ValidateFieldRequestController(service);
     const formSubmitController = new FormSubmitController(service);
     const setFieldErrorMessageController = new SetFieldErrorMessageController(service);
-    const validateErrorMessageController = new ValidateErrorMessageController(service);
+    const fieldBlurController = new FieldBlurController(service);
+    const submitValidationCompletedController = new SubmitValidationCompletedController(service);
+    const validationRulesExecutionResultController = new ValidationRulesExecutionResultController(service);
     return {
       [LifeCycleEvents.MOUNT]: initializeController.handle,
       [ZFORM_MY_LAYOUTS_SUCCESS]: myLayoutSuccessController.handle,
-      [RECORD_EXECUTE_SUCCESS_CALLBACK]: _ref2 => {
+      [RECORD_EXECUTE_SUCCESS_CALLBACK]: _ref => {
         let {
           action,
           dispatch
-        } = _ref2;
+        } = _ref;
         dispatch({
-          type: "SMART_FORM#SUBMIT_SUCCESS",
+          type: ZFORM_SUBMIT_SUCCESS,
           payload: action.payload
         });
       },
-      [RECORD_EXECUTE_FAIL_CALLBACK]: _ref3 => {
+      [RECORD_EXECUTE_FAIL_CALLBACK]: _ref2 => {
         let {
           action,
           dispatch
-        } = _ref3;
+        } = _ref2;
         dispatch({
           type: "SMART_FORM#SUBMIT_FAILED",
           payload: action.payload
@@ -93,144 +93,23 @@ class EventHandlersFactory {
       [ZFORM_VALIDATE_FIELD_REQUEST]: validateFieldRequestController.handle,
       [SmartFormConstants.SMART_FORM_SUBMIT_CLICKED]: formSubmitController.handle,
       [ZFORM_SUBMIT]: formSubmitController.handle,
-      [ZFORM_SUBMIT_SUCCESS]: _ref4 => {
+      [FormConstants.FORM_SUBMIT]: _ref3 => {
         let {
           action,
-          state,
-          updateState,
           dispatch
-        } = _ref4;
-        let formData = action.payload.formData;
-        let moduleName = state.properties.moduleName;
-        let record = {
-          cf: {}
-        };
-        Object.keys(formData).forEach(key => {
-          if (key.startsWith("cf_")) {
-            record.cf[key] = formData[key];
-          } else {
-            record[key] = formData[key];
-          }
-        });
-        dispatch({
-          type: CREATE_RECORD,
-          payload: {
-            record,
-            moduleName: moduleName
-          }
-        });
-      },
-      [ZFORM_VALIDATION_ERROR]: _ref5 => {
-        let {
-          action,
-          state,
-          updateState,
-          dispatch
-        } = _ref5;
-        let formData = { ...state.behaviours.zform.formData
-        };
-        Object.keys(action.payload).forEach(key => {
-          dispatch({
-            type: ZFORM_SET_FIELD_ERROR_MESSAGE,
-            payload: {
-              fieldApiName: key,
-              errorMessage: action.payload[key].errorMessage
-            }
-          });
-        });
-      },
-      [ZFORM_VALIDATE_SUBMIT_FIELD_HAS_ERROR_MESSAGE]: validateErrorMessageController.handle,
-      [FIELD_VALIDATION_RESULT]: _ref6 => {
-        let {
-          action,
-          state,
-          updateState,
-          dispatch
-        } = _ref6;
-        let {
-          validationResult,
-          field
-        } = action.payload;
-
-        if (!validationResult.isValid) {
-          dispatch({
-            type: ZFORM_SET_FIELD_ERROR_MESSAGE,
-            payload: {
-              fieldApiName: field.apiName,
-              errorMessage: validationResult.message
-            }
-          });
-        } else {
-          dispatch({
-            type: ZFORM_SET_FIELD_ERROR_MESSAGE,
-            payload: {
-              fieldApiName: field.apiName,
-              errorMessage: ""
-            }
-          });
-        }
-      },
-      [VALIDATE_FIELDS_RESULT]: _ref7 => {
-        let {
-          action,
-          state,
-          updateState,
-          dispatch
-        } = _ref7;
-        let {
-          validationResults,
-          fields
-        } = action.payload;
-        let formData = { ...state.behaviours.zform.formData
-        };
-        validationResults.forEach((validationResult, index) => {
-          let field = fields[index];
-
-          if (!validationResult.isValid) {
-            dispatch({
-              type: ZFORM_SET_FIELD_ERROR_MESSAGE,
-              payload: {
-                fieldApiName: field.apiName,
-                errorMessage: validationResult.message
-              }
-            });
-          } else {
-            dispatch({
-              type: ZFORM_SET_FIELD_ERROR_MESSAGE,
-              payload: {
-                fieldApiName: field.apiName,
-                errorMessage: ""
-              }
-            });
-          }
-        });
-      },
-      [FormConstants.FORM_SUBMIT]: _ref8 => {
-        let {
-          action,
-          dispatch
-        } = _ref8;
+        } = _ref3;
         dispatch({
           type: ZFORM_SUBMIT
         });
       },
-      [FormConstants.FORM_FIELD_BLURRED]: _ref9 => {
-        let {
-          action,
-          dispatch
-        } = _ref9;
-        dispatch({
-          type: ZFORM_VALIDATE_FIELD_REQUEST,
-          payload: {
-            fieldName: action.payload.fieldName
-          }
-        });
-      },
-      [FormConstants.FORM_FIELD_VALUE_CHANGE_REQUEST]: _ref10 => {
+      [FormConstants.FORM_FIELD_BLURRED]: fieldBlurController.handle,
+      [ZFORM_VALIDATION_RULES_EXECUTION_RESULT]: validationRulesExecutionResultController.handle,
+      [ZFORM_SUBMIT_VALIDATION_COMPLETED]: submitValidationCompletedController.handle,
+      [FormConstants.FORM_FIELD_VALUE_CHANGE_REQUEST]: _ref4 => {
         let {
           action,
           dispatch
-        } = _ref10;
+        } = _ref4;
         const {
           sectionId,
           fieldName,

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])
+        }
+      });
+    }
+  });
+}