@zohodesk/library-platform 1.1.1 → 1.1.2

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

@@ -0,0 +1,478 @@
+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 ZForm {
+  /*hack*/
+
+  /*hack end*/
+  constructor(_ref) {
+    let {
+      modifiedTime,
+      isStandardLayout,
+      hasLogo,
+      departmentId,
+      module,
+      layoutDisplayName,
+      layoutDesc,
+      isDefaultLayout,
+      sections,
+      validationRules,
+      layoutRules,
+      dependencyMappings,
+      context,
+
+      /*hack*/
+      isMyFormFetching,
+      isDependencyFetching,
+      isLayoutRulesFetching,
+      isValidationRulesFetching
+      /*hack end*/
+
+    } = _ref;
+
+    _defineProperty(this, "modifiedTime", void 0);
+
+    _defineProperty(this, "isStandardLayout", void 0);
+
+    _defineProperty(this, "hasLogo", void 0);
+
+    _defineProperty(this, "departmentId", void 0);
+
+    _defineProperty(this, "module", void 0);
+
+    _defineProperty(this, "layoutDisplayName", void 0);
+
+    _defineProperty(this, "layoutDesc", void 0);
+
+    _defineProperty(this, "isDefaultLayout", void 0);
+
+    _defineProperty(this, "sections", void 0);
+
+    _defineProperty(this, "validationRules", void 0);
+
+    _defineProperty(this, "layoutRules", void 0);
+
+    _defineProperty(this, "dependencyMappings", void 0);
+
+    _defineProperty(this, "context", void 0);
+
+    _defineProperty(this, "isMyFormFetching", void 0);
+
+    _defineProperty(this, "isDependencyFetching", void 0);
+
+    _defineProperty(this, "isLayoutRulesFetching", void 0);
+
+    _defineProperty(this, "isValidationRulesFetching", void 0);
+
+    this.modifiedTime = modifiedTime;
+    this.isStandardLayout = isStandardLayout;
+    this.hasLogo = hasLogo;
+    this.departmentId = departmentId;
+    this.module = module;
+    this.layoutDisplayName = layoutDisplayName;
+    this.layoutDesc = layoutDesc;
+    this.isDefaultLayout = isDefaultLayout;
+    this.sections = sections;
+    this.validationRules = validationRules;
+    this.layoutRules = layoutRules;
+    this.dependencyMappings = dependencyMappings;
+    this.context = context;
+    /*hack*/
+
+    this.isMyFormFetching = isMyFormFetching;
+    this.isDependencyFetching = isDependencyFetching;
+    this.isLayoutRulesFetching = isLayoutRulesFetching;
+    this.isValidationRulesFetching = isValidationRulesFetching;
+    /*hack end*/
+  }
+
+  setDependencyMappings(dependencyMappings) {
+    this.dependencyMappings = dependencyMappings;
+    this.isDependencyFetching = false;
+  }
+
+  getContext() {
+    const {
+      module,
+      departmentId
+    } = this;
+    const {
+      orgName,
+      servicePrefix
+    } = this.context;
+    return {
+      module,
+      departmentId: departmentId,
+      orgName,
+      servicePrefix: servicePrefix || 'supportapi/zd' // FIX: servicePrefix defaultValue should be available from properties
+
+    };
+  }
+
+  setFormProperties(properties, layoutRuleHelper) {
+    this.modifiedTime = properties.modifiedTime;
+    this.isStandardLayout = properties.isStandardLayout;
+    this.hasLogo = properties.hasLogo;
+    this.departmentId = properties.departmentId;
+    this.module = properties.module;
+    this.layoutDisplayName = properties.layoutDisplayName;
+    this.layoutDesc = properties.layoutDesc;
+    this.isDefaultLayout = properties.isDefaultLayout;
+    this.isMyFormFetching = false;
+    this.executeLayoutRules(layoutRuleHelper);
+  }
+
+  setLayoutRules(layoutRules, layoutRuleHelper) {
+    if (layoutRules) {
+      this.layoutRules = layoutRules;
+      this.isLayoutRulesFetching = false;
+    }
+
+    this.executeLayoutRules(layoutRuleHelper);
+  }
+
+  setMyFormFetching(isMyFormFetching) {
+    this.isMyFormFetching = isMyFormFetching;
+  }
+
+  setDependencyFetching(isDependencyFetching) {
+    this.isDependencyFetching = isDependencyFetching;
+  }
+
+  setLayoutRulesFetching(isLayoutRulesFetching) {
+    this.isLayoutRulesFetching = isLayoutRulesFetching;
+  }
+
+  setValidationRulesFetching(isValidationRulesFetching) {
+    this.isValidationRulesFetching = isValidationRulesFetching;
+  }
+
+  setSections(sections) {
+    this.sections = sections;
+  }
+
+  appendSection(section) {
+    this.sections = [...this.sections, section];
+  }
+
+  updateSection(section) {
+    this.sections = this.sections.map(s => {
+      if (s.getId() === section.getId()) {
+        return section;
+      }
+
+      return s;
+    });
+  }
+
+  insertSectionAtPosition(section, position) {
+    this.sections = [...this.sections.slice(0, position), section, ...this.sections.slice(position)];
+  }
+
+  deleteSection(sectionId) {
+    this.sections = this.sections.filter(s => {
+      return s.getId() !== sectionId;
+    });
+  }
+
+  toggleSectionVisibility(sectionId) {
+    this.sections = this.sections.map(s => {
+      if (s.getId() === sectionId) {
+        s.toggleVisibility();
+      }
+
+      return s;
+    });
+  }
+
+  appendFieldInSection(sectionId, field) {
+    this.sections = this.sections.map(s => {
+      if (s.getId() === sectionId) {
+        s.appendField(field);
+      }
+
+      return s;
+    });
+  }
+
+  insertFieldAtPositionInSection(sectionId, field, position) {
+    this.sections = this.sections.map(s => {
+      if (s.getId() === sectionId) {
+        s.insertFieldAtPosition(field, position);
+      }
+
+      return s;
+    });
+  }
+
+  deleteFields(fieldIds) {
+    this.sections = this.sections.map(s => {
+      s.deleteFields(fieldIds);
+      return s;
+    });
+  }
+
+  deleteField(fieldId) {
+    this.sections = this.sections.map(s => {
+      s.deleteField(fieldId);
+      return s;
+    });
+  }
+
+  setValidationRules(validationRules) {
+    if (validationRules) {
+      this.validationRules = validationRules;
+      this.isValidationRulesFetching = false;
+    }
+  }
+
+  appendValidationRule(validationRule) {
+    this.validationRules = [...this.validationRules, validationRule];
+  }
+
+  removeValidationRule(validationRuleId) {
+    this.validationRules = this.validationRules.filter(vr => {
+      return vr.getId() !== validationRuleId;
+    });
+  }
+
+  activateValidationRule(validationRuleId) {
+    this.validationRules = this.validationRules.map(vr => {
+      if (vr.getId() === validationRuleId) {
+        vr.activate();
+      }
+
+      return vr;
+    });
+  }
+
+  deActivateValidationRule(validationRuleId) {
+    this.validationRules = this.validationRules.map(vr => {
+      if (vr.getId() === validationRuleId) {
+        vr.activate();
+      }
+
+      return vr;
+    });
+  }
+
+  insertValidationRuleAtPosition(validationRule, position) {
+    this.validationRules = [...this.validationRules.slice(0, position), validationRule, ...this.validationRules.slice(position)];
+  }
+
+  executeLayoutRules(layoutRuleHelper) {
+    if (!this.isLayoutRulesFetching && !this.isMyFormFetching) {
+      let layoutRules = this.getLayoutRules().map(layoutRule => {
+        return layoutRule.toObject();
+      });
+      let {
+        sectionResult,
+        fieldResult
+      } = layoutRuleHelper({
+        layoutRules,
+        formData: this.getFormData()
+      });
+      this.applyLayoutRulesResult(sectionResult, fieldResult);
+    } else {
+      console.log("Layout rules are fetching or my form is fetching");
+    }
+  }
+
+  getChildsByParentId(parentId) {
+    let childIds = this.dependencyMappings.filter(dm => {
+      return dm.getParentId() === parentId;
+    }).map(dm => {
+      return dm.getChildId();
+    });
+    return childIds;
+  }
+
+  getMappedOptions(parentId, childId, newValue) {
+    const fieldDependency = this.dependencyMappings.find(dependencyMapping => dependencyMapping.getParentId() === parentId && dependencyMapping.getChildId() === childId);
+    return fieldDependency ? fieldDependency.getMappingsByParentValue(newValue) : [];
+  }
+
+  setFieldValue(fieldApiName, value, layoutRuleHelper) {
+    let fields = this.sections.flatMap(s => s.getFields());
+    let field = fields.find(f => {
+      return f.getApiName() === fieldApiName;
+    });
+
+    if (field) {
+      field.setValue(value);
+
+      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.executeLayoutRules(layoutRuleHelper);
+    }
+  }
+
+  setFieldErrorMessage(fieldApiName, errorMessage) {
+    this.sections = this.sections.map(s => {
+      s.setFieldErrorMessage(fieldApiName, errorMessage);
+      return s;
+    });
+  }
+
+  getFieldByApiName(fieldApiName) {
+    let field = null;
+    this.sections.forEach(s => {
+      let f = s.getFieldByApiName(fieldApiName);
+
+      if (f) {
+        field = f;
+      }
+    });
+    return field;
+  }
+
+  getAllFields() {
+    let fields = [];
+    this.sections.forEach(s => {
+      fields = [...fields, ...s.getFields()];
+    });
+    return fields;
+  }
+
+  getVisibleFieldsData() {
+    let fields = this.getAllFields();
+    let visibleFieldsData = {};
+    fields.forEach(f => {
+      if (f.isVisibile()) {
+        visibleFieldsData[f.getApiName()] = f.getValue();
+      }
+    });
+    return visibleFieldsData;
+  }
+
+  getVisibleFieldsErrorMessages() {
+    let fields = this.getAllFields();
+    let visibleFieldsErrorMessages = {};
+    fields.forEach(f => {
+      if (f.isVisibile() && f.getErrorMessage() != "") {
+        visibleFieldsErrorMessages[f.getApiName()] = f.getErrorMessage();
+      }
+    });
+    return visibleFieldsErrorMessages;
+  }
+
+  getFormData() {
+    let formData = {};
+    this.sections.flatMap(section => section.getFields()).forEach(field => {
+      formData[field.getApiName()] = {
+        value: field.getValue(),
+        errorMessage: field.getErrorMessage()
+      };
+    });
+    return formData;
+  }
+
+  getLayoutRules() {
+    return this.layoutRules;
+  }
+
+  validate() {
+    let isValid = true;
+    return isValid;
+  }
+
+  applyLayoutRulesResult(sectionVisibilityMap, fieldVisibilityAndMandatoryMap) {
+    this.sections.forEach(s => {
+      let sectionName = s.getName();
+
+      if (sectionVisibilityMap[sectionName]) {
+        s.setVisibility(sectionVisibilityMap[sectionName].visibility);
+      }
+    });
+    this.getAllFields().forEach(f => {
+      let fieldApiName = f.getApiName();
+
+      if (fieldVisibilityAndMandatoryMap[fieldApiName]) {
+        f.setVisibility(fieldVisibilityAndMandatoryMap[fieldApiName].visibility);
+        f.setMandatory(fieldVisibilityAndMandatoryMap[fieldApiName].isMandatory);
+      }
+    });
+  }
+
+  executeValidateRule(validator) {
+    let validationRules = this.validationRules.map(vr => vr.toObject());
+    return validator({
+      validationRules: validationRules,
+      formData: this.getFormData()
+    });
+  }
+
+  executeValidateRuleOnField(fieldApiName, validator) {
+    let validationRules = this.validationRules.filter(rule => rule.getFieldApiName() == fieldApiName).map(vr => vr.toObject());
+    return validator({
+      validationRules: validationRules,
+      formData: this.getFormData()
+    });
+  }
+
+  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;
+  }
+
+  toObject() {
+    return {
+      modifiedTime: this.modifiedTime,
+      isStandardLayout: this.isStandardLayout,
+      hasLogo: this.hasLogo,
+      departmentId: this.departmentId,
+      module: this.module,
+      layoutDisplayName: this.layoutDisplayName,
+      layoutDesc: this.layoutDesc,
+      isDefaultLayout: this.isDefaultLayout,
+      sections: this.sections.map(s => s.toObject()),
+      validationRules: this.validationRules.map(vr => vr.toObject()),
+      layoutRules: this.layoutRules.map(lr => lr.toObject()),
+      dependencyMappings: this.dependencyMappings.map(dm => dm.toObject()),
+
+      /*hack*/
+      isMyFormFetching: this.isMyFormFetching,
+      isDependencyFetching: this.isDependencyFetching,
+      isLayoutRulesFetching: this.isLayoutRulesFetching,
+      isValidationRulesFetching: this.isValidationRulesFetching
+      /*hack end*/
+
+    };
+  }
+
+}

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

@@ -0,0 +1,25 @@
+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 ZLayout {
+  constructor(departmentId, id, isDefaultLayout, isStandardLayout, layoutName, module) {
+    _defineProperty(this, "departmentId", void 0);
+
+    _defineProperty(this, "id", void 0);
+
+    _defineProperty(this, "isDefaultLayout", void 0);
+
+    _defineProperty(this, "isStandardLayout", void 0);
+
+    _defineProperty(this, "layoutName", void 0);
+
+    _defineProperty(this, "module", void 0);
+
+    this.departmentId = departmentId;
+    this.id = id;
+    this.isDefaultLayout = isDefaultLayout;
+    this.isStandardLayout = isStandardLayout;
+    this.layoutName = layoutName;
+    this.module = module;
+  }
+
+}

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

@@ -0,0 +1,86 @@
+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; }
+
+// ZLayoutRule Entity
+export default class ZLayoutRule {
+  constructor(_ref) {
+    let {
+      displayLabel,
+      fieldConditions,
+      modifiedTime,
+      fieldName,
+      description,
+      systemGenerated,
+      layoutId,
+      executeInHelpCentre,
+      createdBy,
+      name,
+      createdTime,
+      modifiedBy,
+      id,
+      status
+    } = _ref;
+
+    _defineProperty(this, "displayLabel", void 0);
+
+    _defineProperty(this, "fieldConditions", void 0);
+
+    _defineProperty(this, "modifiedTime", void 0);
+
+    _defineProperty(this, "fieldName", void 0);
+
+    _defineProperty(this, "description", void 0);
+
+    _defineProperty(this, "systemGenerated", void 0);
+
+    _defineProperty(this, "layoutId", void 0);
+
+    _defineProperty(this, "executeInHelpCentre", void 0);
+
+    _defineProperty(this, "createdBy", void 0);
+
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "createdTime", void 0);
+
+    _defineProperty(this, "modifiedBy", void 0);
+
+    _defineProperty(this, "id", void 0);
+
+    _defineProperty(this, "status", void 0);
+
+    this.displayLabel = displayLabel;
+    this.fieldConditions = fieldConditions;
+    this.modifiedTime = modifiedTime;
+    this.fieldName = fieldName;
+    this.description = description;
+    this.systemGenerated = systemGenerated;
+    this.layoutId = layoutId;
+    this.executeInHelpCentre = executeInHelpCentre;
+    this.createdBy = createdBy;
+    this.name = name;
+    this.createdTime = createdTime;
+    this.modifiedBy = modifiedBy;
+    this.id = id;
+    this.status = status;
+  }
+
+  toObject() {
+    return {
+      displayLabel: this.displayLabel,
+      fieldConditions: this.fieldConditions,
+      modifiedTime: this.modifiedTime,
+      fieldName: this.fieldName,
+      description: this.description,
+      systemGenerated: this.systemGenerated,
+      layoutId: this.layoutId,
+      executeInHelpCentre: this.executeInHelpCentre,
+      createdBy: this.createdBy,
+      name: this.name,
+      createdTime: this.createdTime,
+      modifiedBy: this.modifiedBy,
+      id: this.id,
+      status: this.status
+    };
+  }
+
+}

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

@@ -0,0 +1,113 @@
+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 ZSection {
+  constructor(_ref) {
+    let {
+      name,
+      i18NLabel,
+      isCustomSection,
+      id,
+      fields,
+      visibility
+    } = _ref;
+
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "i18NLabel", void 0);
+
+    _defineProperty(this, "isCustomSection", void 0);
+
+    _defineProperty(this, "id", void 0);
+
+    _defineProperty(this, "fields", void 0);
+
+    _defineProperty(this, "visibility", void 0);
+
+    this.name = name;
+    this.i18NLabel = i18NLabel;
+    this.isCustomSection = isCustomSection;
+    this.id = id;
+    this.fields = fields;
+    this.visibility = visibility;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getId() {
+    return this.id;
+  }
+
+  toggleVisibility() {
+    this.visibility = !this.visibility;
+  }
+
+  appendField(field) {
+    this.fields = [...this.fields, field];
+  }
+
+  insertFieldAtPosition(field, position) {
+    this.fields = [...this.fields.slice(0, position), field, ...this.fields.slice(position)];
+  }
+
+  deleteFields(fieldIds) {
+    this.fields = this.fields.filter(field => {
+      return !fieldIds.includes(field.getId());
+    });
+  }
+
+  deleteField(fieldId) {
+    this.fields = this.fields.filter(field => {
+      return field.getId() !== fieldId;
+    });
+  }
+
+  setFieldValue(fieldApiName, value) {
+    this.fields = this.fields.map(field => {
+      if (field.getApiName() === fieldApiName) {
+        field.setValue(value);
+      }
+
+      return field;
+    });
+  }
+
+  setVisibility(visibility) {
+    this.visibility = visibility;
+  }
+
+  setFieldErrorMessage(fieldApiName, errorMessage) {
+    this.fields = this.fields.map(field => {
+      if (field.getApiName() === fieldApiName) {
+        field.setErrorMessage(errorMessage);
+      }
+
+      return field;
+    });
+  }
+
+  getFieldByApiName(fieldApiName) {
+    return this.fields.find(field => {
+      return field.getApiName() === fieldApiName;
+    }) || null;
+  }
+
+  getFields() {
+    return this.fields;
+  }
+
+  toObject() {
+    return {
+      name: this.name,
+      i18NLabel: this.i18NLabel,
+      isCustomSection: this.isCustomSection,
+      id: this.id,
+      fields: this.fields.map(field => {
+        return field.toObject();
+      }),
+      visibility: this.visibility
+    };
+  }
+
+}