@zohodesk/library-platform 1.0.1 → 1.0.2-exp.1.1

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

@@ -0,0 +1,32 @@
+import ZValidationRule from "../../domain/ZValidationRule";
+import AbstractUseCase from "./AbstractUseCase";
+
+class LayoutRulesSuccessUseCase extends AbstractUseCase {
+  execute(input) {
+    let {
+      layoutRules
+    } = input;
+    let zformEntitiy = this.dependencies.repository.getFormEntity();
+    let zform = zformEntitiy.toObject();
+    let layoutRuleApplier = this.dependencies.layoutRuleApplier;
+    let layoutRuleEntities = layoutRules.map(layoutRule => {
+      return new ZValidationRule(layoutRule);
+    });
+    zformEntitiy.setLayoutRules(layoutRuleEntities, _ref => {
+      let {
+        layoutRules,
+        formData
+      } = _ref;
+      return layoutRuleApplier.applyRules({
+        layoutRules,
+        formData,
+        myForm: zformEntitiy.toObject()
+      });
+    });
+    zform = zformEntitiy.toObject();
+    this.dependencies.presenter.updateFormResponse(zform);
+  }
+
+}
+
+export default LayoutRulesSuccessUseCase;

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

@@ -0,0 +1,13 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class MyFormRequestUseCase extends AbstractUseCase {
+  execute(input) {
+    let zformEntitiy = this.dependencies.repository.getFormEntity();
+    zformEntitiy.setMyFormFetching(true);
+    let zform = zformEntitiy.toObject();
+    this.dependencies.presenter.updateFormResponse(zform);
+  }
+
+}
+
+export default MyFormRequestUseCase;

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

@@ -0,0 +1,52 @@
+import AbstractUseCase from "./AbstractUseCase";
+import ZSection from "../../domain/ZSection";
+import ZField from "../../domain/ZField";
+
+class MyFormSuccessUseCase extends AbstractUseCase {
+  execute(input) {
+    let {
+      dispatch,
+      myForm
+    } = input;
+    let {
+      sections
+    } = myForm;
+    let zformEntitiy = this.dependencies.repository.getFormEntity();
+    let layoutRuleApplier = this.dependencies.layoutRuleApplier;
+    let sectionEntities = sections.map(section => {
+      let fields = section.fields.map(field => {
+        return new ZField(field);
+      });
+      let sectionWithFields = { ...section,
+        fields
+      };
+      return new ZSection(sectionWithFields);
+    });
+    zformEntitiy.setSections(sectionEntities);
+    zformEntitiy.setFormProperties({
+      modifiedTime: myForm.modifiedTime,
+      isStandardLayout: myForm.isStandardLayout,
+      hasLogo: myForm.hasLogo,
+      departmentId: myForm.departmentId,
+      module: myForm.module,
+      layoutDisplayName: myForm.layoutDisplayName,
+      layoutDesc: myForm.layoutDesc,
+      isDefaultLayout: myForm.isDefaultLayout
+    }, _ref => {
+      let {
+        layoutRules,
+        formData
+      } = _ref;
+      return layoutRuleApplier.applyRules({
+        layoutRules,
+        formData,
+        myForm: zformEntitiy.toObject()
+      });
+    });
+    let zform = zformEntitiy.toObject();
+    this.dependencies.presenter.updateFormResponse(zform);
+  }
+
+}
+
+export default MyFormSuccessUseCase;

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

@@ -0,0 +1,136 @@
+import AbstractUseCase from "./AbstractUseCase";
+import { ZFORM_DEPENDENCY_MAPPINGS_SUCCESS, ZFORM_LAYOUT_RULES_SUCCESS, ZFORM_MY_FORM_SUCCESS, ZFORM_VALIDATION_RULES_SUCCESS } from "../../../../bc/zform/Symbol";
+import { DATA_SOURCE_EXECUTE as DATA_BROKER_EXECUTE } from "../../../../bc/zdata-source/Constants";
+import { DATA_SOURCE_SUCCESS as DATA_BROKER_SUCCESS, DATA_SOURCE_NO_CONTENT as DATA_BROKER_NO_CONTENT } from "../../../../bc/zdata-source/Symbols";
+
+class MyLayoutSuccessUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      disableValidationRule,
+      disableLayoutRule
+    } = input;
+    let {
+      dispatch,
+      layouts,
+      orgName
+    } = input;
+    let layoutObject = layouts.find(layout => layout.isDefaultLayout == true); // dispatch({type:ZFORM_MY_FORM_REQUEST,payload:{isFetching:true}}) 
+
+    const zformEntity = this.dependencies.repository.getFormEntity();
+    const context = { ...zformEntity.getContext(),
+      layoutId: layoutObject === null || layoutObject === void 0 ? void 0 : layoutObject.id
+    };
+    dispatch({
+      type: DATA_BROKER_EXECUTE,
+      payload: {
+        actionName: "fetchMyForm",
+        props: context
+      },
+      metaData: {
+        actionName: "fetchMyForm",
+        //hack
+        [DATA_BROKER_NO_CONTENT]: {
+          type: ZFORM_MY_FORM_SUCCESS,
+          metaData: {
+            actionName: "fetchMyForm"
+          }
+        },
+        //hack
+        [DATA_BROKER_SUCCESS]: {
+          type: ZFORM_MY_FORM_SUCCESS,
+          metaData: {
+            actionName: "fetchMyForm"
+          }
+        }
+      }
+    });
+    dispatch({
+      type: DATA_BROKER_EXECUTE,
+      payload: {
+        actionName: "fetchDependencyMappings",
+        props: context
+      },
+      metaData: {
+        actionName: "fetchDependencyMappings",
+        //hack
+        [DATA_BROKER_SUCCESS]: {
+          type: ZFORM_DEPENDENCY_MAPPINGS_SUCCESS,
+          metaData: {
+            actionName: "fetchDependencyMappings"
+          }
+        },
+        [DATA_BROKER_NO_CONTENT]: {
+          type: ZFORM_DEPENDENCY_MAPPINGS_SUCCESS,
+          metaData: {
+            actionName: "fetchDependencyMappings"
+          }
+        }
+      }
+    });
+
+    if (!disableValidationRule) {
+      dispatch({
+        type: DATA_BROKER_EXECUTE,
+        payload: {
+          actionName: "fetchValidationRules",
+          props: { ...context,
+            activeRulesOnly: true
+          }
+        },
+        metaData: {
+          actionName: "fetchDependencyMappings",
+          //hack
+          [DATA_BROKER_NO_CONTENT]: {
+            type: ZFORM_VALIDATION_RULES_SUCCESS,
+            metaData: {
+              actionName: "fetchValidationRules"
+            }
+          },
+          [DATA_BROKER_SUCCESS]: {
+            type: ZFORM_VALIDATION_RULES_SUCCESS,
+            metaData: {
+              actionName: "fetchValidationRules"
+            }
+          }
+        }
+      });
+    } else {
+      zformEntity.setValidationRulesFetching(false);
+    }
+
+    if (!disableLayoutRule) {
+      dispatch({
+        type: DATA_BROKER_EXECUTE,
+        payload: {
+          actionName: "fetchLayoutRules",
+          props: { ...context,
+            activeRulesOnly: true
+          }
+        },
+        metaData: {
+          actionName: "fetchDependencyMappings",
+          //hack
+          [DATA_BROKER_NO_CONTENT]: {
+            type: ZFORM_LAYOUT_RULES_SUCCESS,
+            metaData: {
+              actionName: "fetchLayoutRules"
+            }
+          },
+          [DATA_BROKER_SUCCESS]: {
+            type: ZFORM_LAYOUT_RULES_SUCCESS,
+            metaData: {
+              actionName: "fetchLayoutRules"
+            }
+          }
+        }
+      });
+    } else {
+      zformEntity.setLayoutRulesFetching(false);
+    }
+
+    this.dependencies.presenter.updateFormResponse(zformEntity.toObject());
+  }
+
+}
+
+export default MyLayoutSuccessUseCase;

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

@@ -0,0 +1,17 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class SetFieldErrorMessageUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      fieldApiName,
+      errorMessage
+    } = input;
+    const zformEntity = this.dependencies.repository.getFormEntity();
+    zformEntity.setFieldErrorMessage(fieldApiName, errorMessage);
+    const zform = zformEntity.toObject();
+    this.dependencies.presenter.updateFormResponse(zform);
+  }
+
+}
+
+export default SetFieldErrorMessageUseCase;

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

@@ -0,0 +1,33 @@
+import AbstractUseCase from "./AbstractUseCase";
+import { ZFORM_ERROR, ZFORM_SUBMIT_SUCCESS } from "../../../../bc/zform/Symbol";
+
+class ValidateErrorMessageUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      dispatch
+    } = input;
+    const zformEntitiy = this.dependencies.repository.getFormEntity();
+
+    if (zformEntitiy.hasError()) {
+      let errorMessages = zformEntitiy.getVisibleFieldsErrorMessages();
+      dispatch({
+        type: ZFORM_ERROR,
+        payload: {
+          message: "Form has error",
+          errorMessages: errorMessages
+        }
+      });
+    } else {
+      let visibleFieldsData = zformEntitiy.getVisibleFieldsData();
+      dispatch({
+        type: ZFORM_SUBMIT_SUCCESS,
+        payload: {
+          formData: visibleFieldsData
+        }
+      });
+    }
+  }
+
+}
+
+export default ValidateErrorMessageUseCase;

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

@@ -0,0 +1,56 @@
+import AbstractUseCase from "./AbstractUseCase";
+import { VALIDATE_FIELD } from "../../../../bc/field-validation/Constants";
+import { ZFORM_VALIDATION_ERROR } from "../../../../bc/zform/Symbol";
+
+class ValidateFieldRequestUseCase extends AbstractUseCase {
+  execute(input) {
+    let {
+      fieldName,
+      dispatch
+    } = input;
+    let zformEntitiy = this.dependencies.repository.getFormEntity();
+    let fieldEntity = zformEntitiy.getFieldByApiName(fieldName);
+
+    if (fieldEntity) {
+      let field = fieldEntity.toObject();
+      dispatch({
+        type: VALIDATE_FIELD,
+        payload: {
+          field: { ...field,
+            required: field.isMandatory
+          },
+          value: field.value
+        }
+      });
+      zformEntitiy.executeValidateRuleOnField(fieldName, _ref => {
+        let {
+          validationRules,
+          formData
+        } = _ref;
+        const zform = zformEntitiy.toObject();
+        return this.dependencies.validator.validateAsync({
+          validationRules,
+          formData,
+          myForm: zform
+        }).then(res => {
+          if (res) {
+            dispatch({
+              type: ZFORM_VALIDATION_ERROR,
+              payload: res
+            });
+          }
+
+          return true; //hack ts error
+        });
+      }).finally(() => {
+        dispatch({
+          type: "ZFORM#VALIDATE_SUBMIT_FIELD_HAS_ERROR_MESSAGE",
+          payload: zformEntitiy.toObject()
+        });
+      });
+    }
+  }
+
+}
+
+export default ValidateFieldRequestUseCase;

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

@@ -0,0 +1,13 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class ValidationRulesRequestUseCase extends AbstractUseCase {
+  execute(input) {
+    let zformEntitiy = this.dependencies.repository.getFormEntity();
+    zformEntitiy.setValidationRulesFetching(true);
+    let zform = zformEntitiy.toObject();
+    this.dependencies.presenter.updateFormResponse(zform);
+  }
+
+}
+
+export default ValidationRulesRequestUseCase;

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

@@ -0,0 +1,20 @@
+import ZValidationRule from "../../domain/ZValidationRule";
+import AbstractUseCase from "./AbstractUseCase";
+
+class ValidationRulesSuccessUseCase extends AbstractUseCase {
+  execute(input) {
+    let {
+      validationRules
+    } = input;
+    let zformEntitiy = this.dependencies.repository.getFormEntity();
+    let validationRuleEntities = validationRules.map(rule => {
+      return new ZValidationRule(rule);
+    });
+    zformEntitiy.setValidationRules(validationRuleEntities);
+    let zform = zformEntitiy.toObject();
+    this.dependencies.presenter.updateFormResponse(zform);
+  }
+
+}
+
+export default ValidationRulesSuccessUseCase;

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

@@ -0,0 +1,62 @@
+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; }
+
+export default class ZDependencyMapping {
+  constructor(_ref) {
+    let {
+      parentId,
+      childId,
+      mappings,
+      layoutId,
+      id,
+      parent,
+      child
+    } = _ref;
+
+    _defineProperty(this, "parentId", void 0);
+
+    _defineProperty(this, "childId", void 0);
+
+    _defineProperty(this, "mappings", void 0);
+
+    _defineProperty(this, "layoutId", void 0);
+
+    _defineProperty(this, "id", void 0);
+
+    _defineProperty(this, "parent", void 0);
+
+    _defineProperty(this, "child", void 0);
+
+    this.parentId = parentId;
+    this.childId = childId;
+    this.mappings = mappings;
+    this.layoutId = layoutId;
+    this.id = id;
+    this.parent = parent;
+    this.child = child;
+  }
+
+  getMappingsByParentValue(parentValue) {
+    return this.mappings[parentValue] || this.child.allowedValues;
+  }
+
+  getChildId() {
+    return this.childId;
+  }
+
+  getParentId() {
+    return this.parentId;
+  }
+
+  toObject() {
+    return {
+      parentId: this.parentId,
+      childId: this.childId,
+      mappings: this.mappings,
+      layoutId: this.layoutId,
+      id: this.id,
+      parent: this.parent,
+      child: this.child
+    };
+  }
+
+}

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

@@ -0,0 +1,170 @@
+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; }
+
+export default class ZField {
+  constructor(_ref) {
+    let {
+      displayLabel,
+      apiName,
+      isCustomField,
+      i18NLabel,
+      isSystemMandatory,
+      type,
+      isReadOnly,
+      name,
+      isEncryptedField,
+      id,
+      isRemovable,
+      maxLength,
+      isMandatory,
+      value,
+      errorMessage,
+      visibility = true,
+      pickListValues,
+      subType
+    } = _ref;
+
+    _defineProperty(this, "displayLabel", void 0);
+
+    _defineProperty(this, "apiName", void 0);
+
+    _defineProperty(this, "isCustomField", void 0);
+
+    _defineProperty(this, "i18NLabel", void 0);
+
+    _defineProperty(this, "isSystemMandatory", void 0);
+
+    _defineProperty(this, "type", void 0);
+
+    _defineProperty(this, "isReadOnly", void 0);
+
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "isEncryptedField", void 0);
+
+    _defineProperty(this, "id", void 0);
+
+    _defineProperty(this, "isRemovable", void 0);
+
+    _defineProperty(this, "maxLength", void 0);
+
+    _defineProperty(this, "isMandatory", void 0);
+
+    _defineProperty(this, "value", void 0);
+
+    _defineProperty(this, "errorMessage", void 0);
+
+    _defineProperty(this, "visibility", void 0);
+
+    _defineProperty(this, "pickListValues", void 0);
+
+    _defineProperty(this, "defaultPickListValues", void 0);
+
+    _defineProperty(this, "subType", void 0);
+
+    this.displayLabel = displayLabel;
+    this.apiName = apiName;
+    this.isCustomField = isCustomField;
+    this.i18NLabel = i18NLabel;
+    this.isSystemMandatory = isSystemMandatory;
+    this.type = type;
+    this.isReadOnly = isReadOnly;
+    this.name = name;
+    this.isEncryptedField = isEncryptedField;
+    this.id = id;
+    this.isRemovable = isRemovable;
+    this.maxLength = maxLength;
+    this.isMandatory = isMandatory;
+    this.value = value;
+    this.errorMessage = errorMessage;
+    this.visibility = visibility;
+    this.defaultPickListValues = pickListValues;
+    this.pickListValues = pickListValues;
+    this.subType = subType;
+
+    if (value === undefined) {
+      this.setDefaultValue();
+    }
+  }
+
+  setDefaultValue() {
+    if (this.type === "Multiselect") {
+      this.value = [];
+    } else if (this.type === "Boolean") {
+      this.value = false;
+    } else {
+      this.value = "";
+    }
+  }
+
+  getId() {
+    return this.id;
+  }
+
+  getApiName() {
+    return this.apiName;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  setValue(value) {
+    this.value = value;
+  }
+
+  getValue() {
+    return this.value;
+  }
+
+  getErrorMessage() {
+    return this.errorMessage;
+  }
+
+  setErrorMessage(errorMessage) {
+    this.errorMessage = errorMessage;
+  }
+
+  toggleVisibility() {
+    this.visibility = !this.visibility;
+  }
+
+  setVisibility(visibility) {
+    this.visibility = visibility;
+  }
+
+  isVisibile() {
+    return this.visibility;
+  }
+
+  setMandatory(isMandatory) {
+    this.isMandatory = isMandatory;
+  }
+
+  setOptions(options) {
+    this.pickListValues = options;
+  }
+
+  toObject() {
+    return {
+      displayLabel: this.displayLabel,
+      apiName: this.apiName,
+      isCustomField: this.isCustomField,
+      i18NLabel: this.i18NLabel,
+      isSystemMandatory: this.isSystemMandatory,
+      type: this.type,
+      isReadOnly: this.isReadOnly,
+      name: this.name,
+      isEncryptedField: this.isEncryptedField,
+      id: this.id,
+      isRemovable: this.isRemovable,
+      maxLength: this.maxLength,
+      isMandatory: this.isMandatory,
+      value: this.value,
+      errorMessage: this.errorMessage,
+      visibility: this.visibility,
+      pickListValues: this.pickListValues,
+      subType: this.subType
+    };
+  }
+
+}