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

package/es/platform/zform/domain/ZForm.js

@@ -19,6 +19,7 @@ export default class ZForm {
       layoutRules,
       dependencyMappings,
       context,
+      focusedFieldName,
 
       /*hack*/
       isMyFormFetching,
@@ -55,6 +56,10 @@ export default class ZForm {
 
     _defineProperty(this, "context", void 0);
 
+    _defineProperty(this, "focusedFieldName", void 0);
+
+    _defineProperty(this, "layoutId", void 0);
+
     _defineProperty(this, "isMyFormFetching", void 0);
 
     _defineProperty(this, "isDependencyFetching", void 0);
@@ -76,6 +81,7 @@ export default class ZForm {
     this.layoutRules = layoutRules;
     this.dependencyMappings = dependencyMappings;
     this.context = context;
+    this.focusedFieldName = focusedFieldName || null;
     /*hack*/
 
     this.isMyFormFetching = isMyFormFetching;
@@ -90,6 +96,18 @@ export default class ZForm {
     this.isDependencyFetching = false;
   }
 
+  setFocusedFieldName(fieldName) {
+    this.focusedFieldName = fieldName;
+  }
+
+  getLayoutId() {
+    return this.layoutId;
+  }
+
+  setLayoutId(layoutId) {
+    this.layoutId = layoutId;
+  }
+
   getContext() {
     const {
       module,
@@ -341,6 +359,16 @@ export default class ZForm {
     this.validationRules = [...this.validationRules.slice(0, position), validationRule, ...this.validationRules.slice(position)];
   }
 
+  getValidateRules() {
+    const validationRules = this.validationRules.map(vr => vr.toObject());
+    return validationRules;
+  }
+
+  getFieldValidateRules(fieldName, eventName) {
+    const validationRules = this.validationRules.map(vr => vr.toObject());
+    return validationRules.filter(vr => vr.fieldName === fieldName).filter(vr => vr.fieldConditions.every(condition => eventName ? condition !== null && condition !== void 0 && condition.executeOn ? condition.executeOn.includes(eventName) : false : true));
+  }
+
   executeLayoutRules(layoutRuleHelper) {
     if (!this.isLayoutRulesFetching && !this.isMyFormFetching) {
       let layoutRules = this.getLayoutRules().map(layoutRule => {
@@ -355,7 +383,7 @@ export default class ZForm {
       });
       this.applyLayoutRulesResult(sectionResult, fieldResult);
     } else {
-      console.log("Layout rules are fetching or my form is fetching");
+      console.log('Layout rules are fetching or my form is fetching');
     }
   }
 
@@ -373,6 +401,42 @@ export default class ZForm {
     return fieldDependency ? fieldDependency.getMappingsByParentValue(newValue) : [];
   }
 
+  updateChildFieldsRecursive(parentId, value) {
+    let visited = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();
+
+    if (visited.has(parentId)) {
+      console.warn(`Loop detected at field ${parentId}, skipping...`);
+      return;
+    }
+
+    visited.add(parentId); // Always recompute fields so it's in scope
+
+    let fields = this.sections.flatMap(s => s.getFields());
+    let childIds = this.getChildsByParentId(parentId) || [];
+    childIds.forEach(childId => {
+      let childField = fields.find(f => f.getId() === childId || f.getApiName() === childId);
+
+      if (!childField) {
+        console.warn(`Child field not found for id/apiName: ${childId}`);
+        return;
+      }
+
+      let newOptions = this.getMappedOptions(parentId, childId, value) || [];
+      let pickListValues = newOptions.map(option => ({
+        value: option
+      }));
+      childField.setOptions(pickListValues);
+
+      if (pickListValues.length > 0) {
+        let prevValue = childField.getValue();
+        let retained = pickListValues.find(o => o.value === prevValue);
+        childField.setValue(retained ? prevValue : pickListValues[0].value); // Recurse down
+
+        this.updateChildFieldsRecursive(childId, childField.getValue(), visited);
+      }
+    });
+  }
+
   setFieldValue(fieldApiName, value, layoutRuleHelper) {
     let fields = this.sections.flatMap(s => s.getFields());
     let field = fields.find(f => {
@@ -382,40 +446,20 @@ export default class ZForm {
     if (field) {
       field.setValue(value);
 
-      if (field.getType() == "Picklist") {
+      if (field.getType() === 'Picklist') {
         let parentId = field.getId();
-        let childIds = this.getChildsByParentId(parentId);
-        childIds.forEach(childId => {
-          let newOptions = this.getMappedOptions(parentId, childId, value);
-          let childField = fields.find(f => {
-            return f.getId() === childId;
-          });
-
-          if (childField) {
-            let pickListValues = newOptions.map(option => {
-              return {
-                value: option
-              };
-            });
-            childField.setOptions(pickListValues);
-
-            if (childField.getType() == "Picklist") {
-              childField.setValue(pickListValues[0].value);
-            } else {
-              childField.setValue(pickListValues[0].value);
-            }
-          }
-        }); //   fields[childId].value =
-        //     childField.type === 'MultiSelect'
-        //       ? handleChildFieldMultiSelect({ newOptions, retain, fieldValue })
-        //       : handleChildFieldSelect({ newOptions, retain, fieldValue });
-        // });
+        this.updateChildFieldsRecursive(parentId, value);
       }
 
       this.executeLayoutRules(layoutRuleHelper);
     }
   }
 
+  getFieldErrorMessage(fieldApiName) {
+    const field = this.getFieldByApiName(fieldApiName);
+    return field ? field.getErrorMessage() : undefined;
+  }
+
   setFieldErrorMessage(fieldApiName, errorMessage) {
     this.sections = this.sections.map(s => {
       s.setFieldErrorMessage(fieldApiName, errorMessage);
@@ -444,21 +488,52 @@ export default class ZForm {
   }
 
   getVisibleFieldsData() {
-    let fields = this.getAllFields();
-    let visibleFieldsData = {};
-    fields.forEach(f => {
-      if (f.isVisibile()) {
-        visibleFieldsData[f.getApiName()] = f.getValue();
-      }
+    const visibleFields = this.getAllFields().filter(f => f.isVisibile());
+    const visibleFieldsData = {};
+    visibleFields.forEach(f => {
+      visibleFieldsData[f.getApiName()] = f.getValue();
     });
     return visibleFieldsData;
   }
 
+  getModuleName() {
+    return this.module;
+  }
+
+  getVisibleFieldsAsRecord() {
+    const record = {
+      cf: {}
+    };
+    const visibleFields = this.getAllFields().filter(f => f.isVisibile());
+    visibleFields.forEach(f => {
+      const fieldName = f.getApiName();
+
+      if (fieldName.startsWith('cf_')) {
+        record.cf[fieldName] = f.getValue();
+      } else {
+        record[fieldName] = f.getValue();
+      }
+    });
+    return record;
+  }
+
+  getFirstErrorField() {
+    const fields = this.getAllFields();
+
+    for (const field of fields) {
+      if (field.isVisibile() && field.hasErrorMessage()) {
+        return field.getApiName();
+      }
+    }
+
+    return null;
+  }
+
   getVisibleFieldsErrorMessages() {
     let fields = this.getAllFields();
     let visibleFieldsErrorMessages = {};
     fields.forEach(f => {
-      if (f.isVisibile() && f.getErrorMessage() != "") {
+      if (f.isVisibile() && f.hasErrorMessage()) {
         visibleFieldsErrorMessages[f.getApiName()] = f.getErrorMessage();
       }
     });
@@ -520,16 +595,8 @@ export default class ZForm {
   }
 
   hasError() {
-    let hasError = false;
-    let fields = this.getAllFields();
-    fields.forEach(f => {
-      console.log("error", f.getErrorMessage());
-
-      if (f.getErrorMessage() != "" && f.isVisibile()) {
-        hasError = true;
-      }
-    });
-    return hasError;
+    const fields = this.getAllFields();
+    return fields.some(f => f.isVisibile() && f.hasErrorMessage());
   }
 
   toObject() {
@@ -546,6 +613,8 @@ export default class ZForm {
       validationRules: this.validationRules.map(vr => vr.toObject()),
       layoutRules: this.layoutRules.map(lr => lr.toObject()),
       dependencyMappings: this.dependencyMappings.map(dm => dm.toObject()),
+      focusedFieldName: this.focusedFieldName,
+      layoutId: this.layoutId,
 
       /*hack*/
       isMyFormFetching: this.isMyFormFetching,

package/es/platform/zform/domain/interfaces/IZForm.js

@@ -1 +1,5 @@
-;
+;
+export let ValidationEvents = /*#__PURE__*/function (ValidationEvents) {
+  ValidationEvents["blur"] = "blur";
+  return ValidationEvents;
+}({});

package/es/platform/zform/domain/interfaces/ValidationConditions.js

@@ -0,0 +1,142 @@
+// Union of all validation conditions
+// Text-based validation conditions
+export let TextValidationConditions = /*#__PURE__*/function (TextValidationConditions) {
+  TextValidationConditions["IsEmpty"] = "is empty";
+  TextValidationConditions["IsNotEmpty"] = "is not empty";
+  TextValidationConditions["Is"] = "is";
+  TextValidationConditions["IsNot"] = "isn't";
+  TextValidationConditions["StartsWith"] = "starts with";
+  TextValidationConditions["EndsWith"] = "ends with";
+  TextValidationConditions["Contains"] = "contains";
+  TextValidationConditions["DoesNotContain"] = "doesn't contain";
+  return TextValidationConditions;
+}({});
+export let EmailValidationConditions = /*#__PURE__*/function (EmailValidationConditions) {
+  EmailValidationConditions["IsEmpty"] = "is empty";
+  EmailValidationConditions["IsNotEmpty"] = "is not empty";
+  EmailValidationConditions["Is"] = "is";
+  EmailValidationConditions["IsNot"] = "isn't";
+  EmailValidationConditions["StartsWith"] = "starts with";
+  EmailValidationConditions["EndsWith"] = "ends with";
+  EmailValidationConditions["Contains"] = "contains";
+  EmailValidationConditions["DoesNotContain"] = "doesn't contain";
+  return EmailValidationConditions;
+}({});
+export let PhoneValidationConditions = /*#__PURE__*/function (PhoneValidationConditions) {
+  PhoneValidationConditions["IsEmpty"] = "is empty";
+  PhoneValidationConditions["IsNotEmpty"] = "is not empty";
+  PhoneValidationConditions["Is"] = "is";
+  PhoneValidationConditions["IsNot"] = "isn't";
+  PhoneValidationConditions["StartsWith"] = "starts with";
+  PhoneValidationConditions["EndsWith"] = "ends with";
+  PhoneValidationConditions["Contains"] = "contains";
+  PhoneValidationConditions["DoesNotContain"] = "doesn't contain";
+  return PhoneValidationConditions;
+}({});
+export let URLValidationConditions = /*#__PURE__*/function (URLValidationConditions) {
+  URLValidationConditions["IsEmpty"] = "is empty";
+  URLValidationConditions["IsNotEmpty"] = "is not empty";
+  URLValidationConditions["Is"] = "is";
+  URLValidationConditions["IsNot"] = "isn't";
+  URLValidationConditions["StartsWith"] = "starts with";
+  URLValidationConditions["EndsWith"] = "ends with";
+  URLValidationConditions["Contains"] = "contains";
+  URLValidationConditions["DoesNotContain"] = "doesn't contain";
+  return URLValidationConditions;
+}({});
+export let TextareaValidationConditions = /*#__PURE__*/function (TextareaValidationConditions) {
+  TextareaValidationConditions["IsEmpty"] = "is empty";
+  TextareaValidationConditions["IsNotEmpty"] = "is not empty";
+  TextareaValidationConditions["Is"] = "is";
+  TextareaValidationConditions["IsNot"] = "isn't";
+  TextareaValidationConditions["StartsWith"] = "starts with";
+  TextareaValidationConditions["EndsWith"] = "ends with";
+  TextareaValidationConditions["Contains"] = "contains";
+  TextareaValidationConditions["DoesNotContain"] = "doesn't contain";
+  return TextareaValidationConditions;
+}({}); // Numeric validation conditions
+
+export let NumberValidationConditions = /*#__PURE__*/function (NumberValidationConditions) {
+  NumberValidationConditions["IsEmpty"] = "is empty";
+  NumberValidationConditions["IsNotEmpty"] = "is not empty";
+  NumberValidationConditions["Equal"] = "=";
+  NumberValidationConditions["NotEqual"] = "<>";
+  NumberValidationConditions["LessThan"] = "<";
+  NumberValidationConditions["LessThanOrEqual"] = "<=";
+  NumberValidationConditions["GreaterThan"] = ">";
+  NumberValidationConditions["GreaterThanOrEqual"] = ">=";
+  return NumberValidationConditions;
+}({});
+export let PercentValidationConditions = /*#__PURE__*/function (PercentValidationConditions) {
+  PercentValidationConditions["IsEmpty"] = "is empty";
+  PercentValidationConditions["IsNotEmpty"] = "is not empty";
+  PercentValidationConditions["Equal"] = "=";
+  PercentValidationConditions["NotEqual"] = "<>";
+  PercentValidationConditions["LessThan"] = "<";
+  PercentValidationConditions["LessThanOrEqual"] = "<=";
+  PercentValidationConditions["GreaterThan"] = ">";
+  PercentValidationConditions["GreaterThanOrEqual"] = ">=";
+  return PercentValidationConditions;
+}({});
+export let CurrencyValidationConditions = /*#__PURE__*/function (CurrencyValidationConditions) {
+  CurrencyValidationConditions["IsEmpty"] = "is empty";
+  CurrencyValidationConditions["IsNotEmpty"] = "is not empty";
+  CurrencyValidationConditions["Equal"] = "=";
+  CurrencyValidationConditions["NotEqual"] = "<>";
+  CurrencyValidationConditions["LessThan"] = "<";
+  CurrencyValidationConditions["LessThanOrEqual"] = "<=";
+  CurrencyValidationConditions["GreaterThan"] = ">";
+  CurrencyValidationConditions["GreaterThanOrEqual"] = ">=";
+  return CurrencyValidationConditions;
+}({});
+export let DecimalValidationConditions = /*#__PURE__*/function (DecimalValidationConditions) {
+  DecimalValidationConditions["IsEmpty"] = "is empty";
+  DecimalValidationConditions["IsNotEmpty"] = "is not empty";
+  DecimalValidationConditions["Equal"] = "=";
+  DecimalValidationConditions["NotEqual"] = "<>";
+  DecimalValidationConditions["LessThan"] = "<";
+  DecimalValidationConditions["LessThanOrEqual"] = "<=";
+  DecimalValidationConditions["GreaterThan"] = ">";
+  DecimalValidationConditions["GreaterThanOrEqual"] = ">=";
+  return DecimalValidationConditions;
+}({}); // Boolean
+
+export let BooleanValidationConditions = /*#__PURE__*/function (BooleanValidationConditions) {
+  BooleanValidationConditions["Is"] = "is";
+  return BooleanValidationConditions;
+}({}); // Date and DateTime
+
+export let DateValidationConditions = /*#__PURE__*/function (DateValidationConditions) {
+  DateValidationConditions["IsEmpty"] = "is empty";
+  DateValidationConditions["IsNotEmpty"] = "is not empty";
+  DateValidationConditions["Is"] = "is";
+  DateValidationConditions["IsNot"] = "isn't";
+  DateValidationConditions["IsAfter"] = "is after";
+  DateValidationConditions["IsBefore"] = "is before";
+  DateValidationConditions["Between"] = "between";
+  DateValidationConditions["NotBetween"] = "not between";
+  return DateValidationConditions;
+}({});
+export let DateTimeValidationConditions = /*#__PURE__*/function (DateTimeValidationConditions) {
+  DateTimeValidationConditions["IsEmpty"] = "is empty";
+  DateTimeValidationConditions["IsNotEmpty"] = "is not empty";
+  DateTimeValidationConditions["Is"] = "is";
+  DateTimeValidationConditions["IsNot"] = "isn't";
+  DateTimeValidationConditions["IsAfter"] = "is after";
+  DateTimeValidationConditions["IsBefore"] = "is before";
+  DateTimeValidationConditions["Between"] = "between";
+  DateTimeValidationConditions["NotBetween"] = "not between";
+  return DateTimeValidationConditions;
+}({}); // Picklist
+
+export let PicklistValidationConditions = /*#__PURE__*/function (PicklistValidationConditions) {
+  PicklistValidationConditions["IsEmpty"] = "is empty";
+  PicklistValidationConditions["IsNotEmpty"] = "is not empty";
+  PicklistValidationConditions["Is"] = "is";
+  PicklistValidationConditions["IsNot"] = "isn't";
+  PicklistValidationConditions["StartsWith"] = "starts with";
+  PicklistValidationConditions["EndsWith"] = "ends with";
+  PicklistValidationConditions["Contains"] = "contains";
+  PicklistValidationConditions["DoesNotContain"] = "doesn't contain";
+  return PicklistValidationConditions;
+}({});

package/es/platform/zform/frameworks/layout-rules/calculateLayoutRulesResult.js

@@ -191,7 +191,7 @@ export function calculateLayoutRulesResult(state, formValues) {
   clearNotExistingData(hideFieldIds, isFieldExists);
   clearNotExistingData(showFieldIds, isFieldExists);
   clearNotExistingData(hideSectionIds, isSectionExists);
-  clearNotExistingData(hideSectionIds, isSectionExists);
+  clearNotExistingData(showSectionIds, isSectionExists);
   clearNotExistingData(removeMandatoryFieldIds, isFieldExists);
   clearNotExistingData(setMandatoryFieldIds, isFieldExists);
   return {

package/es/platform/zform/frameworks/layout-rules/runSingleFieldCondition.js

@@ -29,9 +29,9 @@ export function runSingleFieldCondition(_ref) {
   conditions.forEach((conditionObj, i) => {
     const {
       condition,
-      value,
       fieldName
     } = conditionObj;
+    const value = 'value' in conditionObj ? conditionObj.value : undefined;
 
     if (!fields[fieldName]) {
       isSomeFiledMissing = true;

package/es/platform/zform/frameworks/layout-rules/validator.js

@@ -312,7 +312,6 @@ export function validateCondition() {
               value[0] = getRelatedDateISOString(value[0], false);
               value[1] = getRelatedDateISOString(value[1], false);
             } else {
-              resultConditions;
               value = getRelatedDateISOString(value, false);
             }
           }

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

@@ -5,7 +5,8 @@ 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, ZFORM_LOOKUP_FIELD_SUCCESS } from "../../../../bc/zform/Symbol";
+import LookupFieldController from "../../adapters/controllers/LookupFieldController";
 import MyLayoutSuccessController from "../../adapters/controllers/MyLayoutSuccessController";
 import MyFormSuccessController from "../../adapters/controllers/MyFromSuccessController";
 import DependenciesController from "../../adapters/controllers/DependenciesController";
@@ -20,20 +21,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 } 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,
@@ -51,14 +51,37 @@ class EventHandlersFactory {
     const layoutRulesSuccessController = new LayoutRulesSuccessController(service);
     const validationRulesRequestController = new ValidationRulesRequestController(service);
     const validationRulesSuccessController = new ValidationRulesSuccessController(service);
+    const lookupFieldController = new LookupFieldController(service);
     const fieldValueChangeController = new FieldValueChangeController(service);
     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]: _ref => {
+        let {
+          action,
+          dispatch
+        } = _ref;
+        dispatch({
+          type: ZFORM_SUBMIT_SUCCESS,
+          payload: action.payload
+        });
+      },
+      [RECORD_EXECUTE_FAIL_CALLBACK]: _ref2 => {
+        let {
+          action,
+          dispatch
+        } = _ref2;
+        dispatch({
+          type: 'SMART_FORM#SUBMIT_FAILED',
+          payload: action.payload
+        });
+      },
       [ZFORM_MY_FORM_REQUEST]: myFormRequestController.handle,
       [ZFORM_MY_FORM_SUCCESS]: myFormSuccessController.handle,
       [ZFORM_DEPENDENCY_MAPPINGS_REQUEST]: dependenciesRequestController.handle,
@@ -70,145 +93,25 @@ class EventHandlersFactory {
       [ZFORM_FIELD_VALUE_CHANGE_REQUEST]: fieldValueChangeController.handle,
       [ZFORM_SET_FIELD_ERROR_MESSAGE]: setFieldErrorMessageController.handle,
       [ZFORM_VALIDATE_FIELD_REQUEST]: validateFieldRequestController.handle,
+      [SmartFormConstants.SMART_FORM_SUBMIT_CLICKED]: formSubmitController.handle,
       [ZFORM_SUBMIT]: formSubmitController.handle,
-      [ZFORM_SUBMIT_SUCCESS]: _ref2 => {
+      [FormConstants.FORM_SUBMIT]: _ref3 => {
         let {
           action,
-          state,
-          updateState,
-          dispatch
-        } = _ref2;
-        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]: _ref3 => {
-        let {
-          action,
-          state,
-          updateState,
           dispatch
         } = _ref3;
-        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]: _ref4 => {
-        let {
-          action,
-          state,
-          updateState,
-          dispatch
-        } = _ref4;
-        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]: _ref5 => {
-        let {
-          action,
-          state,
-          updateState,
-          dispatch
-        } = _ref5;
-        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]: _ref6 => {
-        let {
-          action,
-          dispatch
-        } = _ref6;
         dispatch({
           type: ZFORM_SUBMIT
         });
       },
-      [FormConstants.FORM_FIELD_BLURRED]: _ref7 => {
+      [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
-        } = _ref7;
-        dispatch({
-          type: ZFORM_VALIDATE_FIELD_REQUEST,
-          payload: {
-            fieldName: action.payload.fieldName
-          }
-        });
-      },
-      [FormConstants.FORM_FIELD_VALUE_CHANGE_REQUEST]: _ref8 => {
-        let {
-          action,
-          dispatch
-        } = _ref8;
+        } = _ref4;
         const {
           sectionId,
           fieldName,
@@ -223,7 +126,8 @@ class EventHandlersFactory {
           },
           metaData: {}
         });
-      }
+      },
+      [ZFORM_LOOKUP_FIELD_SUCCESS]: lookupFieldController.handle
     };
   }