@zohodesk/library-platform 1.1.8 → 1.1.9

package/es/platform/zform/applications/usecases/SubmitValidationCompletedUseCase.js

@@ -0,0 +1,62 @@
+import { CREATE_RECORD } from "../../../../bc/zrecord/Constants";
+import AbstractUseCase from "./AbstractUseCase";
+import { ZFORM_ERROR, ZFORM_VALIDATION_SUCCESS, ZFORM_SUBMIT_VALIDATION_FAILURE } from "../../../../bc/zform/Symbol";
+
+class SubmitValidationCompletedUseCase extends AbstractUseCase {
+  execute(params) {
+    const {
+      dispatch
+    } = params;
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const zFormEntity = repository.getFormEntity();
+    const isFormHasError = zFormEntity.hasError();
+
+    if (isFormHasError) {
+      const firstErrorField = zFormEntity.getFirstErrorField();
+      zFormEntity.setFocusedFieldName(firstErrorField);
+      presenter.updateFormResponse(zFormEntity.toObject());
+    } // NOTE: EVENT DISPATCH
+
+
+    if (isFormHasError) {
+      const errorMessages = zFormEntity.getVisibleFieldsErrorMessages();
+      dispatch({
+        type: ZFORM_SUBMIT_VALIDATION_FAILURE,
+        payload: {
+          errorMessages: errorMessages
+        }
+      });
+      dispatch({
+        type: ZFORM_ERROR,
+        payload: {
+          message: 'Form has error',
+          errorMessages: errorMessages
+        }
+      });
+    } else {
+      const moduleName = zFormEntity.getModuleName();
+      const record = zFormEntity.getVisibleFieldsAsRecord();
+      const visibleFieldsData = zFormEntity.getVisibleFieldsData();
+      dispatch({
+        type: ZFORM_VALIDATION_SUCCESS,
+        payload: {
+          formData: visibleFieldsData,
+          record
+        }
+      });
+      dispatch({
+        type: CREATE_RECORD,
+        payload: {
+          record,
+          moduleName
+        }
+      });
+    }
+  }
+
+}
+
+export default SubmitValidationCompletedUseCase;

package/es/platform/zform/applications/usecases/ValidateFieldUseCase.js

@@ -0,0 +1,33 @@
+import AbstractUseCase from "./AbstractUseCase";
+import { ZFORM_VALIDATION_RULES_EXECUTION_RESULT } from "../../../../bc/zform/Symbol";
+
+class ValidateFieldUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      fieldName,
+      dispatch,
+      eventName
+    } = input;
+    const {
+      repository,
+      validator
+    } = this.dependencies;
+    const zFormEntity = repository.getFormEntity();
+    const validationRules = zFormEntity.getFieldValidateRules(fieldName, eventName);
+    const myForm = zFormEntity.toObject();
+    const formData = zFormEntity.getFormData();
+    validator.validateAsync({
+      validationRules,
+      formData,
+      myForm
+    }).then(res => {
+      dispatch({
+        type: ZFORM_VALIDATION_RULES_EXECUTION_RESULT,
+        payload: res
+      });
+    });
+  }
+
+}
+
+export default ValidateFieldUseCase;

package/es/platform/zform/applications/usecases/ValidationRulesExecutionResultUseCase.js

@@ -0,0 +1,23 @@
+import { ZFORM_SET_FIELD_ERROR_MESSAGE } from "../../../../bc/zform/Symbol";
+import AbstractUseCase from "./AbstractUseCase";
+
+class ValidationRulesExecutionResultUseCase extends AbstractUseCase {
+  execute(params) {
+    const {
+      result,
+      dispatch
+    } = params;
+    Object.keys(result).forEach(fieldName => {
+      dispatch({
+        type: ZFORM_SET_FIELD_ERROR_MESSAGE,
+        payload: {
+          fieldApiName: fieldName,
+          errorMessage: result[fieldName].errorMessage
+        }
+      });
+    });
+  }
+
+}
+
+export default ValidationRulesExecutionResultUseCase;

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

@@ -19,10 +19,12 @@ export default class ZField {
       value,
       errorMessage,
       isVisible = true,
+      decimalPlaces,
       pickListValues,
       toolTip,
       toolTipType,
       defaultValue,
+      isPHI,
       subType
     } = _ref;
 
@@ -58,6 +60,8 @@ export default class ZField {
 
     _defineProperty(this, "isVisible", void 0);
 
+    _defineProperty(this, "decimalPlaces", void 0);
+
     _defineProperty(this, "pickListValues", void 0);
 
     _defineProperty(this, "defaultPickListValues", void 0);
@@ -70,6 +74,8 @@ export default class ZField {
 
     _defineProperty(this, "defaultValue", void 0);
 
+    _defineProperty(this, "isPHI", void 0);
+
     this.displayLabel = displayLabel;
     this.apiName = apiName;
     this.isCustomField = isCustomField;
@@ -86,12 +92,14 @@ export default class ZField {
     this.value = value;
     this.errorMessage = errorMessage;
     this.isVisible = isVisible;
+    this.decimalPlaces = decimalPlaces;
     this.defaultPickListValues = pickListValues;
     this.pickListValues = pickListValues;
     this.subType = subType;
     this.toolTip = toolTip;
     this.toolTipType = toolTipType;
-    this.defaultValue = defaultValue; // if(value===undefined){
+    this.defaultValue = defaultValue;
+    this.isPHI = isPHI; // if(value===undefined){
     //     this.setDefaultValue()
     // }
   }
@@ -148,6 +156,10 @@ export default class ZField {
   }
 
   setValue(value) {
+    if (this.value !== value) {
+      this.errorMessage = ""; // Reset error message when value changes
+    }
+
     this.value = value;
   }
 
@@ -159,6 +171,10 @@ export default class ZField {
     return this.errorMessage;
   }
 
+  hasErrorMessage() {
+    return Boolean(this.errorMessage);
+  }
+
   setProperties(fieldProperties) {
     this.displayLabel = fieldProperties.displayLabel !== undefined ? fieldProperties.displayLabel : this.displayLabel;
     this.i18NLabel = fieldProperties.i18NLabel !== undefined ? fieldProperties.i18NLabel : this.i18NLabel;
@@ -171,6 +187,7 @@ export default class ZField {
     this.pickListValues = fieldProperties.pickListValues !== undefined ? fieldProperties.pickListValues : this.pickListValues;
     this.defaultPickListValues = fieldProperties.defaultPickListValues !== undefined ? fieldProperties.defaultPickListValues : this.defaultPickListValues;
     this.toolTip = fieldProperties.toolTip !== undefined ? fieldProperties.toolTip : this.toolTip;
+    this.decimalPlaces = fieldProperties.decimalPlaces !== undefined ? fieldProperties.decimalPlaces : this.decimalPlaces;
   }
 
   setErrorMessage(errorMessage) {
@@ -218,10 +235,12 @@ export default class ZField {
       // NOTE: visibility is now isVisible, visibility is deprecated, only for backward compatibility of layout rules
       visibility: this.isVisible,
       isVisible: this.isVisible,
+      decimalPlaces: this.decimalPlaces,
       pickListValues: this.pickListValues,
       toolTip: this.toolTip,
       toolTipType: this.toolTipType,
       defaultValue: this.defaultValue,
+      isPHI: this.isPHI,
       subType: this.subType
     };
   }

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