@zohodesk/library-platform 1.1.1 → 1.1.2-exp.0

package/es/platform/zform/frameworks/validation-rules/utils.js

@@ -0,0 +1,552 @@
+/* eslint-disable default-case */
+
+/* eslint-disable no-param-reassign */
+export function getMissedFields() {
+  let rules = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let fieldMapper = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let missedFields = []; // let missedFieldsDetail = {};
+
+  let allFieldNames = Object.keys(fieldMapper);
+
+  function pushMissedField(fieldDetails) {
+    let {
+      displayLabel,
+      fieldName
+    } = fieldDetails;
+
+    if (allFieldNames.indexOf(fieldName) === -1 && missedFields.indexOf(fieldName) === -1 && displayLabel) {
+      missedFields.push(displayLabel);
+    }
+  }
+
+  rules.forEach(rule => {
+    let {
+      fieldConditions = []
+    } = rule;
+    fieldConditions.forEach(fieldCondition => {
+      let {
+        conditions = [],
+        actions = {}
+      } = fieldCondition;
+      let {
+        setMandatoryFields = []
+      } = actions;
+      conditions.forEach(condition => {
+        pushMissedField(condition);
+      });
+      setMandatoryFields.forEach(setMandatoryField => {
+        pushMissedField(setMandatoryField);
+      });
+    });
+  });
+  return missedFields;
+}
+export function getStatusMappingObj(statusMapping) {
+  let mappingObj = {
+    open: [],
+    closed: [],
+    onhold: [],
+    completed: []
+  };
+  statusMapping.forEach(status => {
+    let {
+      statusType,
+      name
+    } = status;
+
+    if (statusType === 'Open') {
+      mappingObj.open.push(name);
+    } else if (statusType === 'On Hold') {
+      mappingObj.onhold.push(name);
+    } else if (statusType === 'Closed') {
+      mappingObj.closed.push(name);
+    } else if (statusType === 'Completed') {
+      mappingObj.completed.push(name);
+    }
+  });
+  return mappingObj;
+}
+
+function checkFieldsAvailableInForm() {
+  let conditions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let fieldMapper = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return conditions.every(condition => {
+    let allFieldNames = Object.keys(fieldMapper);
+    let {
+      fieldName
+    } = condition;
+
+    if (allFieldNames.indexOf(fieldName) >= 0) {
+      return true;
+    }
+
+    return false;
+  });
+} //ignoreFields: assignee, multiselect, reminder, department, resolution
+// moduleEntityObj = {department: {}, contact:{}, account:{}, product:{}}
+
+
+function getFieldValue(fieldId, fieldUIStates, fieldDetails, moduleEntityObj) {
+  let {
+    type: fieldType,
+    apiName: fieldName
+  } = fieldDetails[fieldId];
+  let {
+    value,
+    createNew
+  } = fieldUIStates[fieldId];
+  return value;
+}
+
+function validateCondition() {
+  let type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let condition = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  let formValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
+  let statusMapping = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  {
+    formValue = formValue === null ? '' : formValue;
+    const Types = {
+      TEXT: 'Text',
+      EMAIL: 'Email',
+      PHONE: 'Phone',
+      URL: 'URL',
+      TEXTAREA: 'Textarea',
+      LOOKUP: 'LookUp',
+      NUMBER: 'Number',
+      PERCENT: 'Percent',
+      CURRENCY: 'Currency',
+      DECIMAL: 'Decimal',
+      BOOLEAN: 'Boolean',
+      DATETIME: 'DateTime',
+      DATE: 'Date',
+      PICKLIST: 'Picklist',
+      RADIO: 'Radio',
+      FAX: 'Fax'
+    };
+    const COMMON_COMPARATORS = {
+      ISEMPTY: 'is empty',
+      ISNOTEMPTY: 'is not empty'
+    };
+    const TEXT_COMPARATORS = {
+      IS: 'is',
+      ISNT: "isn't",
+      STARTSWITH: 'starts with',
+      ENDSWITH: 'ends with',
+      CONTAINS: 'contains',
+      DOESNTCONTAIN: "doesn't contain"
+    };
+    const NUMBER_COMPARATORS = {
+      EQUAL: '=',
+      NOTEQUAL: '<>',
+      LESSTHAN: '<',
+      LESSTHANEQUAL: '<=',
+      GREATERTHAN: '>',
+      GREATERTHANEQUAL: '>='
+    };
+    const DATE_COMPARATORS = {
+      ISAFTER: 'is after',
+      ISBEFORE: 'is before',
+      BETWEEN: 'between',
+      NOTBETWEEN: 'not between'
+    };
+    const STATUS_COMPARATORS = {
+      ISOPEN: 'is OPEN',
+      ISONHOLD: 'is ON HOLD',
+      ISCLOSED: 'is CLOSED',
+      ISCOMPLETED: 'is COMPLETED'
+    };
+
+    const validateText = function () {
+      let condition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+      let formValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+      let matched = false;
+
+      if (condition === COMMON_COMPARATORS.ISEMPTY) {
+        matched = formValue === '';
+      } else if (condition === COMMON_COMPARATORS.ISNOTEMPTY) {
+        matched = formValue !== '';
+      } else {
+        value = value !== null ? value.toLowerCase().trim() : '';
+        formValue = formValue !== null ? formValue.toLowerCase().trim() : '';
+
+        switch (condition) {
+          case TEXT_COMPARATORS.IS:
+            matched = formValue === value;
+            break;
+
+          case TEXT_COMPARATORS.ISNT:
+            matched = formValue !== value;
+            break;
+
+          case TEXT_COMPARATORS.STARTSWITH:
+            matched = formValue.startsWith(value);
+            break;
+
+          case TEXT_COMPARATORS.ENDSWITH:
+            matched = formValue.endsWith(value);
+            break;
+
+          case TEXT_COMPARATORS.CONTAINS:
+            matched = formValue.indexOf(value) !== -1;
+            break;
+
+          case TEXT_COMPARATORS.DOESNTCONTAIN:
+            matched = formValue.indexOf(value) === -1;
+            break;
+        }
+      }
+
+      return matched;
+    };
+
+    const validateNumber = function () {
+      let condition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+      let formValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+      let matched = false;
+
+      if (condition === COMMON_COMPARATORS.ISEMPTY) {
+        matched = formValue === '';
+      } else if (condition === COMMON_COMPARATORS.ISNOTEMPTY) {
+        matched = formValue !== '';
+      } else {
+        if (formValue === '') {
+          return false;
+        }
+
+        value = parseFloat(value);
+        formValue = parseFloat(formValue);
+
+        switch (condition) {
+          case NUMBER_COMPARATORS.EQUAL:
+            matched = formValue === value;
+            break;
+
+          case NUMBER_COMPARATORS.NOTEQUAL:
+            matched = formValue !== value;
+            break;
+
+          case NUMBER_COMPARATORS.LESSTHAN:
+            matched = formValue < value;
+            break;
+
+          case NUMBER_COMPARATORS.LESSTHANEQUAL:
+            matched = formValue <= value;
+            break;
+
+          case NUMBER_COMPARATORS.GREATERTHAN:
+            matched = formValue > value;
+            break;
+
+          case NUMBER_COMPARATORS.GREATERTHANEQUAL:
+            matched = formValue >= value;
+            break;
+        }
+      }
+
+      return matched;
+    };
+
+    const validateBoolean = function () {
+      let condition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+      let formValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+      formValue = String(formValue) || 'false';
+      value = String(value) || 'false';
+      let matched = false;
+
+      switch (condition) {
+        case TEXT_COMPARATORS.IS:
+          matched = formValue === value;
+          break;
+      }
+
+      return matched;
+    };
+
+    const validateDate = function () {
+      let condition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+      let formValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+      let matched = false;
+
+      if (condition === COMMON_COMPARATORS.ISEMPTY) {
+        matched = formValue === '';
+      } else if (condition === COMMON_COMPARATORS.ISNOTEMPTY) {
+        matched = formValue !== '';
+      } else {
+        if (formValue === '') {
+          return false;
+        }
+
+        formValue = new Date(formValue);
+
+        if (condition === DATE_COMPARATORS.BETWEEN || condition === DATE_COMPARATORS.NOTBETWEEN) {
+          const beforeVal = new Date(value[0]);
+          const afterVal = new Date(value[1]);
+
+          switch (condition) {
+            case DATE_COMPARATORS.BETWEEN:
+              matched = formValue.getTime() - beforeVal.getTime() >= 0 && formValue.getTime() - afterVal.getTime() <= 0;
+              break;
+
+            case DATE_COMPARATORS.NOTBETWEEN:
+              matched = !(formValue.getTime() - beforeVal.getTime() >= 0 && formValue.getTime() - afterVal.getTime() <= 0);
+              break;
+          }
+        } else {
+          value = new Date(value);
+
+          switch (condition) {
+            case TEXT_COMPARATORS.IS:
+              matched = formValue.getTime() - value.getTime() === 0;
+              break;
+
+            case TEXT_COMPARATORS.ISNT:
+              matched = formValue !== '' && formValue.getTime() - value.getTime() !== 0;
+              break;
+
+            case DATE_COMPARATORS.ISAFTER:
+              matched = formValue.getTime() - value.getTime() > 0;
+              break;
+
+            case DATE_COMPARATORS.ISBEFORE:
+              matched = formValue.getTime() - value.getTime() < 0;
+              break;
+          }
+        }
+      }
+
+      return matched;
+    };
+
+    const validatePicklist = function () {
+      let condition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+      let formValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+      let statusMapping = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
+      if ([STATUS_COMPARATORS.ISOPEN, STATUS_COMPARATORS.ISONHOLD, STATUS_COMPARATORS.ISCLOSED, STATUS_COMPARATORS.ISCOMPLETED].indexOf(condition) !== -1) {
+        let matched = false;
+
+        switch (condition) {
+          case STATUS_COMPARATORS.ISOPEN:
+            matched = statusMapping.open.indexOf(formValue) !== -1;
+            break;
+
+          case STATUS_COMPARATORS.ISONHOLD:
+            matched = statusMapping.onhold.indexOf(formValue) !== -1;
+            break;
+
+          case STATUS_COMPARATORS.ISCLOSED:
+            matched = statusMapping.closed.indexOf(formValue) !== -1;
+            break;
+
+          case STATUS_COMPARATORS.ISCOMPLETED:
+            matched = statusMapping.completed.indexOf(formValue) !== -1;
+            break;
+        }
+
+        return matched;
+      }
+
+      formValue = formValue === '-None-' ? null : formValue;
+      return validateText(condition, value, formValue);
+    };
+
+    const getRelatedDateISOString = (dateValue, isDateField) => {
+      if (dateValue === '${CURRENTTIME}') {
+        let currentDateObj = new Date();
+        dateValue = currentDateObj.toISOString();
+      }
+
+      if (isDateField) {
+        dateValue += 'T00:00:00.000Z';
+      } else {
+        let dateObj = new Date(dateValue);
+        dateObj.setSeconds(0);
+        dateObj.setMilliseconds(0);
+        dateValue = dateObj.toISOString();
+      }
+
+      return dateValue;
+    };
+
+    switch (type) {
+      case Types.TEXT:
+      case Types.EMAIL:
+      case Types.PHONE:
+      case Types.URL:
+      case Types.TEXTAREA:
+      case Types.LOOKUP:
+      case Types.FAX:
+        return validateText(condition, value, formValue);
+
+      case Types.NUMBER:
+      case Types.PERCENT:
+      case Types.CURRENCY:
+      case Types.DECIMAL:
+        return validateNumber(condition, value, formValue);
+
+      case Types.BOOLEAN:
+        return validateBoolean(condition, value, formValue);
+
+      case Types.DATETIME:
+      case Types.DATE:
+        if (condition !== COMMON_COMPARATORS.ISNOTEMPTY && condition !== COMMON_COMPARATORS.ISEMPTY) {
+          if (type === Types.DATE) {
+            value = getRelatedDateISOString(value, true);
+          } else {
+            if (condition === DATE_COMPARATORS.BETWEEN || condition === DATE_COMPARATORS.NOTBETWEEN) {
+              value[0] = getRelatedDateISOString(value[0], false);
+              value[1] = getRelatedDateISOString(value[1], false);
+            } else {
+              value = getRelatedDateISOString(value, false);
+            }
+          }
+        }
+
+        return validateDate(condition, value, formValue);
+
+      case Types.PICKLIST:
+      case Types.RADIO:
+        return validatePicklist(condition, value, formValue, statusMapping);
+
+      default:
+        return false;
+    }
+  }
+}
+
+function getConditionsMatchedResult() {
+  let conditions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let fieldUIStates = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let fieldMapper = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let fieldDetails = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  let statusMapping = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+  let moduleEntityObj = arguments.length > 5 ? arguments[5] : undefined;
+  let result = {};
+
+  if (!checkFieldsAvailableInForm(conditions, fieldMapper)) {
+    return result;
+  }
+
+  conditions.forEach((condition, conditionIndex) => {
+    let {
+      fieldName,
+      condition: conditionName,
+      value: values = []
+    } = condition;
+    let fieldId = fieldMapper[fieldName];
+    let {
+      type: fieldType
+    } = fieldDetails[fieldId];
+    let formValue = getFieldValue(fieldId, fieldUIStates, fieldDetails, moduleEntityObj);
+    let matched = false;
+
+    if (conditionName === 'between' || conditionName === 'not between') {
+      matched = validateCondition(fieldType, conditionName, values, formValue, statusMapping);
+    } else {
+      matched = values.some(value => {
+        if (validateCondition(fieldType, conditionName, value, formValue, statusMapping)) {
+          return true;
+        }
+
+        return false;
+      });
+    }
+
+    result[conditionIndex + 1] = matched;
+  });
+  return result;
+}
+
+function validatePattern() {
+  let pattern = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let matchedResult = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  let evalExpression = pattern => Function(`return (${pattern})`);
+
+  pattern = pattern.replace(/and/g, '&&').replace(/or/g, '||');
+  let newPattern = '';
+  let patternLen = pattern.length;
+
+  for (let i = 0; i < patternLen; i++) {
+    let char = pattern[i];
+
+    if (char !== '(' && char !== ')' && char !== '&' && char !== '|') {
+      char = parseInt(char);
+      char = matchedResult[char] || false;
+    }
+
+    newPattern += char;
+  }
+
+  return evalExpression(newPattern)();
+}
+
+export function getPassedFormRules() {
+  let rules = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let fieldUIStates = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let fieldMapper = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let fieldDetails = arguments.length > 3 ? arguments[3] : undefined;
+  let statusMapping = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+  let moduleEntityObj = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  let customValidators = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : {};
+  let passedRules = [];
+  statusMapping = getStatusMappingObj(statusMapping);
+  rules.forEach(rule => {
+    let allFieldNames = Object.keys(fieldMapper);
+    let {
+      fieldName,
+      fieldConditions
+    } = rule;
+
+    if (allFieldNames.indexOf(fieldName) !== -1) {
+      fieldConditions.forEach(fieldCondition => {
+        let {
+          conditions,
+          pattern,
+          actions,
+          validator
+        } = fieldCondition;
+
+        if (validator) {
+          let {
+            scriptId
+          } = validator;
+
+          if (customValidators[scriptId]) {
+            let value = getFieldValue(fieldMapper[fieldName], fieldUIStates, fieldDetails, moduleEntityObj);
+            let isValid = customValidators[scriptId](value);
+
+            if (!isValid) {
+              let obj = {
+                fieldName,
+                actions
+              };
+              passedRules.push(obj);
+            }
+          }
+        } else {
+          let matchedResult = getConditionsMatchedResult(conditions, fieldUIStates, fieldMapper, fieldDetails, statusMapping, moduleEntityObj);
+
+          if (Object.keys(matchedResult).length > 0) {
+            let isValid = validatePattern(pattern, matchedResult);
+
+            if (isValid) {
+              let obj = {
+                fieldName,
+                actions
+              };
+              passedRules.push(obj);
+            }
+          }
+        }
+      });
+    }
+  });
+  return passedRules;
+}

package/es/platform/zform/frameworks/validation-rules/validationRules.js

@@ -0,0 +1,126 @@
+/* eslint-disable import/prefer-default-export */
+import { getPassedFormRules } from "./utils";
+
+function getValidRules() {
+  let validationRules = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let fieldMapper = arguments.length > 1 ? arguments[1] : undefined;
+  let fieldUIStates = arguments.length > 2 ? arguments[2] : undefined;
+  let validateOnlyShowedFields = arguments.length > 3 ? arguments[3] : undefined;
+  return validationRules.filter(rule => {
+    const {
+      fieldName
+    } = rule;
+    const fieldId = fieldMapper[fieldName];
+
+    if (fieldId) {
+      const {
+        isShowOnLayoutRuleApplied: isShow
+      } = fieldUIStates[fieldId];
+      return validateOnlyShowedFields ? isShow : true;
+    }
+
+    return false;
+  });
+}
+
+export default function getValidationRuleActionsData() {
+  let validationRules = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let fieldUIStates = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let formFields = arguments.length > 2 ? arguments[2] : undefined;
+  let customValidators = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  let statusMapping = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+  let moduleEntityObj = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  let validateOnlyShowedFields = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : true;
+  const {
+    fieldDetails,
+    fieldMapper
+  } = formFields;
+  const validValidationRules = getValidRules(validationRules, fieldMapper, fieldUIStates, validateOnlyShowedFields);
+  const passedRules = getPassedFormRules(validValidationRules, fieldUIStates, fieldMapper, fieldDetails, statusMapping, moduleEntityObj, customValidators);
+  const validationRuleActionsData = {};
+  let errorFieldId = '';
+  let isError = false;
+  let removeOldMessages = [];
+  const errorObj = {};
+  let hasErrorInHiddenFields = false;
+  let hasErrorInDisplayFields = false;
+  let errorFields = []; // Revamp the logic
+
+  validValidationRules.forEach(rule => {
+    // clear old validation rule message
+    const {
+      fieldName
+    } = rule;
+    const fieldId = fieldMapper[fieldName];
+    const {
+      messageObj
+    } = fieldUIStates[fieldId] || {};
+    const {
+      validationRuleMessage: message
+    } = messageObj || {};
+
+    if (message && fieldId) {
+      validationRuleActionsData[fieldId] = {
+        validationRuleMessage: ''
+      };
+    }
+  });
+  removeOldMessages = { ...validationRuleActionsData
+  };
+  let firstFieldId = '';
+  let firstDisplayedErrorFieldId = '';
+  passedRules.forEach(data => {
+    const {
+      actions = {},
+      fieldName
+    } = data || {};
+    const fieldId = fieldMapper[fieldName];
+    const {
+      alert = ''
+    } = actions;
+    firstFieldId = fieldMapper[passedRules[0].fieldName]; // let { messageObj } = fieldUIStates[fieldId] || {};
+    // let { validationRuleMessage: message } = messageObj || {};
+    // same field possible to throw 2 message.That case should be show 1st error msg
+
+    const {
+      validationRuleMessage = ''
+    } = validationRuleActionsData[fieldId] || {};
+
+    if (fieldId && !validationRuleMessage) {
+      validationRuleActionsData[fieldId] = {
+        validationRuleMessage: alert
+      };
+      errorObj[fieldId] = {
+        validationRuleMessage: alert
+      };
+      const {
+        isShowOnLayoutRuleApplied: isShow
+      } = fieldUIStates[fieldId];
+
+      if (isShow) {
+        hasErrorInDisplayFields = true;
+
+        if (!firstDisplayedErrorFieldId) {
+          firstDisplayedErrorFieldId = fieldId;
+        }
+
+        errorFields.push(fieldId);
+      } else {
+        hasErrorInHiddenFields = true;
+      }
+    }
+  });
+  errorFieldId = firstFieldId;
+  isError = !!passedRules.length;
+  return {
+    data: validationRuleActionsData,
+    errorFieldId,
+    isError,
+    removeOldMessages,
+    errorObj,
+    hasErrorInDisplayFields,
+    hasErrorInHiddenFields,
+    firstDisplayedErrorFieldId,
+    errorFields
+  };
+}

package/es/platform/zhttp/applications/usecases/FetchUseCase.js

@@ -33,7 +33,7 @@ class FetchUseCase extends AbstractUseCase {
     try {
       // NOTE: getResponse is hacky solution to get the data using function call instead of fetch, So any handling added to here needs to be added to fetch and vise versa
       if (typeof getResponse === 'function') {
-        const data = await getResponse();
+        const data = await getResponse(headers);
 
         if (data === undefined) {
           dispatch({