beca-ui 2.0.19-beta.7 → 2.0.19-beta.70

package/dist/DynamicWorkflowScript.js

@@ -0,0 +1,1142 @@
+const docTien = new DocTienBangChu();
+const DEFAULT_MONEY_UNIT = 'đồng';
+
+var isDetail = false;
+var isMasterDetail = false;
+var colName = undefined;
+var mdCellId = undefined;
+var masterDetailId = undefined;
+
+function capitalize(word = '') {
+  word = word.toLowerCase();
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+
+function runScript(scriptString) {
+  eval(scriptString);
+}
+
+function isNumeric(n) {
+  return !isNaN(parseFloat(n)) && isFinite(n);
+}
+
+function getMoneyUnitName(unit) {
+  switch (unit) {
+    case 'VND':
+      return 'đồng';
+    case 'USD':
+      return 'đô la';
+    case 'EUR':
+      return 'ơ-rô';
+    case 'JPY':
+      return 'yên';
+    case 'SGD':
+      return 'đô la Singapore';
+    case 'KRW':
+      return 'won';
+    default:
+      return '';
+  }
+}
+
+function docSoTien(number, unit = DEFAULT_MONEY_UNIT, locale = 'vi') {
+  let result = '';
+  const numbers = number?.toString().split('.');
+
+  if (locale === 'en') {
+    const numberText1 = numberToTextEN(Number(numbers[0]));
+    result = numberText1.trim();
+  } else {
+    const numberText1 = docTien.doc(numbers[0]);
+    result = numberText1.trim();
+  }
+
+  if (numbers.length === 2) {
+    if (locale === 'en') {
+      const numberText2 = numberToTextEN(numbers[1]);
+      result += ` point ${numberText2.toLowerCase()}`;
+    } else {
+      const numberText2 = docTien.doc(numbers[1]);
+      result += ` phẩy ${numberText2.toLowerCase()}`;
+    }
+  }
+  result = capitalize(result);
+  if (unit?.trim() !== '') {
+    result += ` ${unit}`;
+  }
+
+  return result;
+}
+
+function fetchDataFromApi(api, from, property, to, fromName) {
+  var htmlElement = document.getElementById('field_' + fromName);
+  if (htmlElement && htmlElement.tagName === 'SPAN') {
+    return;
+  }
+  if (from && from[property]) {
+    if (!isNumeric(from[property])) {
+      return;
+    }
+    api = window.location.origin + api + from[property];
+    var myHeaders = new Headers();
+    myHeaders.append('Accept', '*/*');
+    myHeaders.append('Accept-Language', 'en');
+    myHeaders.append('Accept-Encoding', 'gzip, deflate, br');
+    myHeaders.append('Connection', 'keep-alive');
+    var requestOptions = {
+      method: 'GET',
+      headers: myHeaders,
+      redirect: 'follow',
+    };
+
+    fetch(api, requestOptions)
+      .then(response => response.text())
+      .then(result => {
+        result = result.replace(/"/g, '');
+
+        const textValue = document.getElementById('field_' + to);
+
+        if (textValue) {
+          if (result) {
+            textValue.innerHTML = result;
+          } else {
+            textValue.innerHTML = '';
+          }
+        }
+      })
+      .catch(error => console.log('error', error));
+  }
+}
+
+function getPathFromUrl(url) {
+  return url.split(/[?#]/)[0];
+}
+
+function searchDataByProperyName(api, from, to) {
+  api = window.location.origin + api + encodeURIComponent(from.value);
+  var myHeaders = new Headers();
+  myHeaders.append('Accept', '*/*');
+  myHeaders.append('Accept-Language', 'en');
+  myHeaders.append('Accept-Encoding', 'gzip, deflate, br');
+  myHeaders.append('Connection', 'keep-alive');
+  var requestOptions = {
+    method: 'GET',
+    headers: myHeaders,
+    redirect: 'follow',
+  };
+
+  fetch(api, requestOptions)
+    .then(response => response.json())
+    .then(result => {
+      mapArrayIntoChoiceProperty(to, result);
+    })
+    .catch(error => console.log('error', error));
+}
+
+function _searchDataAndMapIntoDropdown(api, from, to) {
+  searchDataAndMapIntoDropdown(api, from, to);
+}
+
+function searchDataAndMapIntoDropdown(api, from, to) {
+  if (from && !isHtmlCollection(from)) {
+    api = window.location.origin + api + encodeURIComponent(from.value);
+    var myHeaders = new Headers();
+    myHeaders.append('Accept', '*/*');
+    myHeaders.append('Accept-Language', 'en');
+    myHeaders.append('Accept-Encoding', 'gzip, deflate, br');
+    myHeaders.append('Connection', 'keep-alive');
+    var requestOptions = {
+      method: 'GET',
+      headers: myHeaders,
+      redirect: 'follow',
+    };
+
+    fetch(api, requestOptions)
+      .then(response => {
+        if (response.ok) {
+          return response.json();
+        }
+        console.log('Error: searchDataAndMapIntoDropdown');
+        throw new Error();
+      })
+      .then(result => {
+        mapDropDownValueIntoProperty(to, result);
+      });
+  }
+}
+
+function _searchDataFromMDAndMapIntoMD(api, from, to, fromName) {
+  searchDataFromMDAndMapIntoMD(api, from, to, fromName);
+}
+
+function mapMDFromMD({
+  from,
+  fromName = 'value',
+  masterDetailId,
+  fromMDName,
+  filterName = 'UserWorkflowId',
+  toMDName,
+}) {
+  searchDataFromMDAndMapIntoMD(
+    `/api/v2/workflowReport/SearchDataFromMDAndMapIntoMD/${masterDetailId}?filterName=${filterName}&mdName=${fromMDName}&filterValue=`,
+    from,
+    `${toMDName}`,
+    fromName
+  );
+}
+
+function searchDataFromMDAndMapIntoMD(api, from, to, fromName) {
+  if (from) {
+    api =
+      window.location.origin +
+      api +
+      encodeURIComponent(from[fromName ?? 'value']);
+
+    var myHeaders = new Headers();
+
+    myHeaders.append('Accept', '*/*');
+    myHeaders.append('Accept-Language', 'en');
+    myHeaders.append('Accept-Encoding', 'gzip, deflate, br');
+    myHeaders.append('Connection', 'keep-alive');
+
+    var requestOptions = {
+      method: 'GET',
+      headers: myHeaders,
+      redirect: 'follow',
+    };
+
+    fetch(api, requestOptions)
+      .then(response => response.json())
+      .then(result => {
+        mapMdValueIntoMD(to, result);
+      })
+      .catch(error => console.log('error', error));
+  }
+}
+
+// function reSearchDataByProperyName(api, from, fromProperty, to) {
+//   console.log('searchDataByProperyName');
+//   api = window.location.origin + api + from[fromProperty];
+//   var myHeaders = new Headers();
+//   myHeaders.append('Accept', '*/*');
+//   myHeaders.append('Accept-Language', 'en');
+//   myHeaders.append('Accept-Encoding', 'gzip, deflate, br');
+//   myHeaders.append('Connection', 'keep-alive');
+//   var requestOptions = {
+//     method: 'GET',
+//     headers: myHeaders,
+//     redirect: 'follow',
+//   };
+
+//   fetch(api, requestOptions)
+//     .then(response => response.json())
+//     .then(result => {
+//       console.log(result);
+//       mapArrayIntoChoiceProperty(to, result);
+//     })
+//     .catch(error => console.log('error', error));
+// }
+
+function fromSelectToText(dataFrom, dataTo) {
+  const selectElement = document.getElementById(dataFrom);
+  if (selectElement) {
+    const selectItems = selectElement.getElementsByClassName(
+      'ant-select-selection-item'
+    );
+    if (selectItems && selectItems.length > 0) {
+      const title = selectItems[0].title;
+      const textValue = document.getElementById('field_' + dataTo);
+      if (textValue) {
+        const value = title.split('=')[0].trim();
+        textValue.innerHTML = value;
+      }
+    }
+  }
+}
+
+function _numberToText(dataFrom, dataTo, unitId, locale) {
+  numberToText(dataFrom, dataTo, unitId, locale);
+}
+
+function numberToText(dataFrom, dataTo, unitId, locale) {
+  if (isDetail === undefined || isDetail === null || isDetail === false) {
+    let numberValue = getValue(dataFrom);
+    if (numberValue !== undefined && numberValue !== null) {
+      // numberValue = formatNumberString(numberValue, locale);
+
+      const textValueElement = getElementById(dataTo);
+      if (textValueElement) {
+        if (numberValue !== undefined && numberValue !== null) {
+          let unit = DEFAULT_MONEY_UNIT;
+
+          if (unitId) {
+            const unitElement = getElementById(unitId);
+
+            if (unitElement) {
+              const itemValue = getValue(unitId);
+              if (itemValue !== undefined) {
+                const unitName = getMoneyUnitName(itemValue);
+                unit = unitName;
+              }
+            } else {
+              unit = unitId;
+            }
+          }
+          let text = docSoTien(numberValue.toString(), unit, locale);
+          text = text?.replaceAll('  ', ' ');
+          textValueElement.innerHTML = text;
+        } else {
+          textValueElement.innerHTML = '';
+        }
+      }
+    }
+  } else {
+    numberToTextDetail(dataFrom, dataTo, unitId, locale);
+  }
+}
+
+function numberToTextEN(n) {
+  if (n < 0) return false;
+
+  // Arrays to hold words for single-digit, double-digit, and below-hundred numbers
+  single_digit = [
+    '',
+    'One',
+    'Two',
+    'Three',
+    'Four',
+    'Five',
+    'Six',
+    'Seven',
+    'Eight',
+    'Nine',
+  ];
+  double_digit = [
+    'Ten',
+    'Eleven',
+    'Twelve',
+    'Thirteen',
+    'Fourteen',
+    'Fifteen',
+    'Sixteen',
+    'Seventeen',
+    'Eighteen',
+    'Nineteen',
+  ];
+  below_hundred = [
+    'Twenty',
+    'Thirty',
+    'Forty',
+    'Fifty',
+    'Sixty',
+    'Seventy',
+    'Eighty',
+    'Ninety',
+  ];
+
+  if (n === 0) return 'Zero';
+
+  // Recursive function to translate the number into words
+  function translate(n) {
+    let word = '';
+    if (n < 10) {
+      word = single_digit[n] + ' ';
+    } else if (n < 20) {
+      word = double_digit[n - 10] + ' ';
+    } else if (n < 100) {
+      let rem = translate(n % 10);
+      word = below_hundred[(n - (n % 10)) / 10 - 2] + ' ' + rem;
+    } else if (n < 1000) {
+      word =
+        single_digit[Math.trunc(n / 100)] + ' Hundred ' + translate(n % 100);
+    } else if (n < 1000000) {
+      word =
+        translate(parseInt(n / 1000)).trim() +
+        ' Thousand ' +
+        translate(n % 1000);
+    } else if (n < 1000000000) {
+      word =
+        translate(parseInt(n / 1000000)).trim() +
+        ' Million ' +
+        translate(n % 1000000);
+    } else {
+      word =
+        translate(parseInt(n / 1000000000)).trim() +
+        ' Billion ' +
+        translate(n % 1000000000);
+    }
+    return word;
+  }
+
+  // Get the result by translating the given number
+  let result = translate(n);
+  return result.trim();
+}
+
+function readNumber(dataFrom, unitId, locale, dataTo = colName) {
+  if (isDetail === undefined || isDetail === null || isDetail === false) {
+    let numberValue = getFieldValue(dataFrom);
+    if (numberValue !== undefined && numberValue !== null) {
+      numberValue = formatNumberString(numberValue, locale);
+      const textValueElement = getElementById(dataTo);
+      if (textValueElement) {
+        if (numberValue !== undefined && numberValue !== null) {
+          let unit = DEFAULT_MONEY_UNIT;
+          if (unitId) {
+            const unitElement = getElementById(unitId);
+            if (unitElement) {
+              const itemValue = getValue(unitId);
+              if (itemValue !== undefined) {
+                const unitName = getMoneyUnitName(itemValue);
+                unit = unitName;
+              }
+            } else {
+              unit = unitId;
+            }
+          }
+          let text = docSoTien(numberValue.toString(), unit, locale);
+          text = text?.replaceAll('  ', ' ');
+          // textValueElement.innerHTML = text;
+          setValue(dataTo, text);
+        } else {
+          // textValueElement.innerHTML = '';
+          setValue(dataTo, '');
+        }
+      }
+    }
+  } else {
+    numberToTextDetail(dataFrom, dataTo, unitId, locale);
+  }
+}
+
+function numberToTextDetail(dataFrom, dataTo, unitId, locale) {
+  let unit = DEFAULT_MONEY_UNIT;
+  if (unitId) {
+    const unitElement = document.querySelector(`#${unitId}`);
+    if (unitElement) {
+      const itemElement = unitElement.querySelector(
+        '.ant-select-selection-item'
+      );
+      if (itemElement && itemElement.title) {
+        const unitName = getMoneyUnitName(itemElement.title);
+        unit = unitName;
+      }
+    } else {
+      unit = unitId;
+    }
+  }
+
+  const numberValue = getValueMD(dataFrom);
+  if (numberValue) {
+    const value = formatNumberString(numberValue);
+    const textValue = getElementById(dataTo, true);
+    if (textValue) {
+      if (value !== undefined && value !== null) {
+        let text = docSoTien(value, unit, locale);
+        text = text?.replaceAll('  ', ' ');
+        textValue.innerHTML = text;
+      } else {
+        textValue.innerHTML = '';
+      }
+    }
+  }
+}
+
+function textNumberToText(dataFrom, dataTo, unitId) {
+  const fromElement = document.getElementById('field_' + dataFrom);
+  if (fromElement) {
+    const fromValue = fromElement.innerHTML;
+    const numberValue = formatNumberString(fromValue);
+    const toElement = document.getElementById('field_' + dataTo);
+    if (toElement) {
+      if (numberValue) {
+        let unit = DEFAULT_MONEY_UNIT;
+        if (unitId) {
+          const unitElement = document.querySelector(`#${unitId}`);
+          if (unitElement) {
+            const itemElement = unitElement.querySelector(
+              '.ant-select-selection-item'
+            );
+            if (itemElement && itemElement.title) {
+              const unitName = getMoneyUnitName(itemElement.title);
+              unit = unitName;
+            }
+          } else {
+            unit = unitId;
+          }
+        }
+        let text = docSoTien(numberValue.toString(), unit);
+        text = text?.replaceAll('  ', ' ');
+        toElement.innerHTML = text;
+      } else {
+        toElement.innerHTML = '';
+      }
+    }
+  }
+}
+
+function _textNumberToText(dataFrom, dataTo, unitId) {
+  textNumberToText(dataFrom, dataTo, unitId);
+}
+
+// Locale: "vi" | "en"
+function formatNumberString(number, locale = 'vi') {
+  let result = '0';
+  if (locale === 'vi') {
+    result = number
+      ? number?.toString().replaceAll('.', '').replaceAll('= ', '')
+      : '0';
+    result = result.replaceAll(',', '.');
+  } else {
+    result = number;
+  }
+
+  return Number(result);
+}
+
+function setValue(toId, value, isMD = false) {
+  const name = toId ?? getCurrentId();
+  window.setFieldValue(name, value, isMD ? masterDetailId : undefined);
+}
+
+function setValueMD(name, value, mdId) {
+  window.setFieldValue(name, value, mdId);
+}
+
+function calc(name, string) {
+  try {
+    if (string && string.length > 0) {
+      const split = string.split(`'`);
+      for (let i in split) {
+        const splitItem = split[i].trim();
+
+        if (splitItem.length > 0 && isStringValid(splitItem)) {
+          string = calcSub(splitItem, string);
+        }
+      }
+      const money = eval(string);
+      setValue(name, money);
+      // const ele = document.getElementById('field_' + name);
+      // if (ele) {
+      //   if (ele.innerHTML.includes(' %')) {
+      //     result += ' %';
+      //   }
+      //   ele.innerHTML = result;
+      // }
+    }
+  } catch (e) {
+    console.log(e);
+  }
+}
+
+const getFieldValue = (name, isMD) => {
+  return window.getFieldValue(name, isMD);
+};
+
+const handleFormular = (formularString, isMD) => {
+  if (formularString?.length > 0) {
+    formularString = formularString.replace(/\s/g, '');
+    let name = '';
+    let adding = false;
+    const ids = [];
+
+    for (let i = 0; i < formularString.length; i++) {
+      if (formularString[i] === '[') {
+        adding = true;
+      } else if (formularString[i] === ']') {
+        ids.push(name);
+        adding = false;
+        name = '';
+      } else if (adding === true) {
+        name += formularString[i];
+      }
+    }
+
+    let formular = formularString;
+
+    if (ids.length > 0) {
+      ids.forEach(id => {
+        const value = getFieldValue(id, isMD) ?? 0;
+        formular = formular.replaceAll(`[${id}]`, value);
+      });
+    }
+
+    return { math: formular, elementIds: ids };
+  } else {
+    return { math: formularString, elementIds: [] };
+  }
+};
+
+function calculate(calcText, to = colName) {
+  try {
+    console.log('calculate');
+    if (calcText && calcText.length > 0) {
+      const formular = handleFormular(calcText, isMasterDetail);
+      const result = eval(formular.math);
+      setValue(to, result, masterDetailId);
+    }
+  } catch (e) {
+    console.log(e);
+  }
+}
+
+function _calculate(calcText, to) {
+  calculate(calcText, to);
+}
+
+function _calc(calcText, to) {
+  calc(calcText, to);
+}
+
+function calcSub(name, string) {
+  try {
+    let element =
+      getElementById(name) ??
+      document.getElementById(`dynamicWorkflowForm_${name}`);
+    if (element) {
+      const num = getValue(name) ?? 0;
+      string = string.replaceAll(
+        `'${name}'`,
+        `
+      ${num}
+    `
+      );
+    }
+  } catch (e) {
+    console.log('calcSub', e);
+  }
+  return string;
+}
+
+function isHtmlCollection(element) {
+  return HTMLCollection.prototype.isPrototypeOf(element);
+}
+
+function mapData(name, from, to, type) {
+  if (isHtmlCollection(from)) return;
+
+  let value = from ? from[name] : undefined;
+
+  if (value && type === 'number') {
+    value = convertNumberToText(value);
+  }
+  setValue(to, value);
+  // const toElement = getElementById(to);
+  // if (toElement) {
+  //   toElement.innerHTML = value ?? '';
+  // }
+}
+
+function _mapData(name, from, to, type) {
+  mapData(name, from, to, type);
+}
+
+function mapDataMasterDetail(
+  from,
+  fromProperty,
+  to,
+  id,
+  type,
+  isEditMasterDetail
+) {
+  try {
+    if (!isEditMasterDetail) {
+      if (fromProperty && to && id !== undefined) {
+        let value = '';
+        if (from) {
+          value = from[fromProperty];
+          // if (value && type === 'number') {
+          //   value = '= ' + convertNumberToText(value);
+          // }
+        }
+        // toElement.innerHTML = value ?? '';
+        setValueMD(to, value ?? '', id);
+      }
+    }
+  } catch (e) {
+    console.log('mapDataMasterDetailError:', e);
+  }
+}
+
+function _mapDataMasterDetail(from, fromProperty, to, id, isEditMasterDetail) {
+  mapDataMasterDetail(from, fromProperty, to, id, isEditMasterDetail);
+}
+
+function sendLinkToWebView(path, fileName) {
+  try {
+    let pathSendToWebView =
+      window.location.protocol +
+      '//' +
+      window.location.host +
+      path.replace('downloadFile', 'downloadFileAnonymous');
+    let data = {
+      path: pathSendToWebView,
+      fileName: fileName,
+    };
+    window.parent.postMessage(JSON.stringify(data), window.parent.origin);
+    window.postMessage(JSON.stringify(data), window.parent.origin);
+    window.ReactNativeWebView.postMessage(JSON.stringify(data));
+  } catch (error) {
+    console.log(error);
+  }
+}
+
+function fromSelectToTextMasterDetail(from, fromProperty, to, id) {
+  if (from) {
+    let value = from[fromProperty];
+    const toId = id.toString() + '_' + to;
+    const toElement = document.getElementById(toId);
+    if (toElement) {
+      if (value) {
+        const textValue = value.split('=')[0].trim();
+        toElement.innerHTML = textValue;
+      }
+    }
+  }
+}
+
+function isStringValid(string) {
+  let format = /[!@#$%^&*()+\-=\[\]{};':"\\|,.<>\/?]+/;
+  return !format.test(string);
+}
+
+function _mapNumberMD2F(fromId, toNumberId, toTextId) {
+  const num = _mapFromMasterDetail(fromId, toNumberId);
+
+  _numberToTextFromMD(num, toTextId);
+}
+
+function _mapFromMasterDetail(fromId, toId) {
+  let result;
+  const fromElement = getElementById(fromId, true);
+  if (fromElement) {
+    const fromValue = getValueMD(fromId) ?? 0;
+    const toElement = document.querySelector(`#field_${toId}`);
+    if (toElement) {
+      toElement.innerHTML = fromValue;
+      result = fromValue;
+    }
+  }
+  return result;
+}
+
+function _numberToTextFromMD(num, dataTo) {
+  const toElement = document.querySelector(`#field_${dataTo}`);
+  if (toElement) {
+    if (num) {
+      let number = formatNumberString(num);
+      if (toElement) {
+        if (number) {
+          toElement.innerHTML = docTien.doc(number);
+        } else {
+          toElement.innerHTML = '';
+        }
+      }
+    } else {
+      toElement.innerHTML = '';
+    }
+  }
+}
+
+function removeDuplicates(arr) {
+  return arr.filter((item, index) => arr.indexOf(item) === index);
+}
+
+function calcMD(calcText, to, id) {
+  try {
+    // const toElement = document.getElementById(`${id}_${to}`);
+    const toElement = to ? getElementById(`${to}`, true) : getCurrentElement();
+    let text = calcText.replace(/[^a-zA-Z0-9 ]/g, ' ');
+
+    text = text.trim().replace(/\s+/g, ' ');
+    let variables = text.split(' ');
+
+    if (toElement && variables.length > 0) {
+      variables = removeDuplicates(variables);
+
+      const names = [];
+
+      variables.forEach(variable => {
+        if (isNaN(variable)) {
+          names.push(variable);
+        }
+      });
+
+      let calc = calcText;
+      names.forEach(name => {
+        try {
+          const numberValue = getValueMD(name) ?? 0;
+          // const num = numberElement
+          //   ? Number(
+          //       formatNumberString(
+          //         numberElement.replace('= ', '').replace(' %', '')
+          //       )
+          //     )
+          //   : 0;
+
+          calc = calc.replaceAll(`'${name}'`, numberValue);
+        } catch (e) {
+          throw 'Not found element: ' + name;
+        }
+      });
+      const result = eval(calc);
+
+      // toElement.innerHTML = result;
+      // toElement.dataValue = result;
+      setValueMD(to, result, id ?? masterDetailId);
+      // toElement.innerHTML = `= ${Intl.NumberFormat('vi-VN', {}).format(
+      //   result
+      // )}`;
+    }
+  } catch (e) {
+    console.log(e);
+  }
+}
+
+function map(from, to) {}
+
+function _calcMMD(calcText, to) {
+  calcMMD(calcText, to);
+}
+
+function calcMMD(calcText, to) {
+  try {
+    const toElement = to ? getElementById(`${to}`) : getCurrentElement();
+
+    // const calcText = `('num1_mdsum' - 'num2_mdsum')`;
+    let calc = calcText;
+    let text = calcText.replaceAll('+', ' ');
+    text = text.replaceAll('-', ' ');
+    text = text.replaceAll('*', ' ');
+    text = text.replaceAll('/', ' ');
+    text = text.replaceAll('(', ' ');
+    text = text.replaceAll(')', ' ');
+    text = text.replaceAll("'", ' ');
+    text = text.replaceAll('"', ' ');
+
+    text = text.trim().replace(/\s+/g, ' ');
+
+    let variables = text.split(' ');
+
+    if (toElement && variables.length > 0) {
+      variables = removeDuplicates(variables);
+
+      const names = [];
+
+      variables.forEach(variable => {
+        if (isNaN(variable)) {
+          names.push(variable);
+        }
+      });
+
+      names.forEach(name => {
+        let val = 0;
+        const nameSplit = name.split('_');
+        if (nameSplit.length === 2) {
+          const tableElement = document.getElementById(`${nameSplit[0]}`);
+          if (tableElement) {
+            const valueElement = tableElement.querySelector(
+              `.sum-${nameSplit[1]}`
+            );
+
+            if (valueElement) {
+              val = valueElement.innerHTML;
+            }
+          }
+        }
+        if (val !== 0) {
+          val = formatNumberString(val);
+        }
+        calc = calc.replaceAll(`'${name}'`, val ?? 0);
+      });
+      const result = eval(calc !== '()' ? calc : '');
+      setValue(to, result);
+      // toElement.innerHTML = Intl.NumberFormat('vi-VN', {}).format(result);
+    }
+  } catch (e) {
+    console.log(e);
+  }
+}
+
+const getElementById = (name, isMD) => {
+  if (name) {
+    let isMasterDetailT = isMD;
+    if (!isMasterDetailT) {
+      const splitName = name.split('-');
+      if (splitName.length === 2 && splitName[0] === 'md') {
+        isMasterDetailT = true;
+      }
+    }
+    // check if master detail
+    if (isMasterDetailT && mdCellId) {
+      const ids = mdCellId.split('_');
+      if (ids.length === 3) {
+        const id = `${ids[0]}_${ids[1]}_${name}`;
+        const ele = document.getElementById(id);
+        if (ele) {
+          const element = ele.querySelector(`#${name}`);
+          if (element) {
+            return element;
+          } else {
+            return ele;
+          }
+        }
+      }
+    } else {
+      const ele = document.getElementById('field_' + name);
+
+      if (ele) {
+        return ele;
+      } else {
+        const classEle = document.querySelector(`.field_${name}`);
+        if (classEle) {
+          return classEle;
+        }
+        return document.getElementById('dynamicWorkflowForm_' + name);
+      }
+    }
+  }
+};
+
+const getValueMD = (name, mdId) => {
+  return getValue(name, mdId ?? masterDetailId ?? true);
+};
+
+const getValue = (name, mdId) => {
+  return window.getFieldValue(name, mdId);
+  // const element = getElementById(name, isMD);
+
+  // if (element) {
+  //   if (element.role === 'combobox') {
+  //     const parentElement = element.parentElement?.parentElement;
+  //     if (parentElement) {
+  //       const selectItem = parentElement.querySelector(
+  //         '.ant-select-selection-item'
+  //       );
+  //       if (selectItem) {
+  //         return selectItem.title;
+  //       }
+  //     }
+  //   }
+
+  //   if (element.value) {
+  //     return element.value;
+  //   }
+  //   return element.innerHTML;
+  // }
+};
+
+const getCurrentElement = isMD => {
+  let isMasterDetailT = isMasterDetail;
+  if (isMD !== undefined) {
+    isMasterDetailT = isMD;
+  }
+  if (isMasterDetailT) {
+    return document.getElementById(mdCellId);
+  } else {
+    return document.getElementById('field_' + colName);
+  }
+};
+
+const getCurrentId = isMD => {
+  let isMasterDetailT = isMasterDetail;
+  if (isMD !== undefined) {
+    isMasterDetailT = isMD;
+  }
+  if (isMasterDetailT) {
+    return mdCellId;
+  } else {
+    return colName;
+  }
+};
+
+function isValidDate(str) {
+  return dayjs(str, 'YYYY-MM-DD', true).isValid();
+}
+
+const datetime = {
+  formatDayjs(date) {
+    if (date) {
+      if (dayjs.isDayjs(date)) {
+        return date;
+      }
+      let dateTime;
+      if (date.length === 10) {
+        let dateSplit = date.split('/');
+
+        if (dateSplit[2].length === 4) {
+          dateSplit = dateSplit.reverse();
+        }
+        dateTime = dateSplit.join('/') + ' 00:00';
+      } else if (date.length === 16) {
+        const dateTimes = date.split(' ');
+        const dateSplit = dateTimes[0].split('/');
+        dateTime = dateSplit.reverse().join('/') + ` ${dateTimes[1]}`;
+      } else if (date.length === 19) {
+        return dayjs(date, 'YYYY-MM-DDTHH:mm:ss');
+      }
+      if (dateTime) {
+        return dayjs(dateTime, 'YYYY/MM/DD HH:mm');
+      } else if (isValidDate(date)) {
+        return dayjs(date);
+      }
+    }
+  },
+
+  count(type, fromDateName, toDateName, toId = colName) {
+    let result = '';
+
+    const fromDateValue = getFieldValue(fromDateName, isMasterDetail);
+    const toDateValue = getFieldValue(toDateName, isMasterDetail);
+
+    if (
+      fromDateValue &&
+      fromDateValue !== 'Invalid Date' &&
+      toDateValue &&
+      toDateValue !== 'Invalid Date'
+    ) {
+      let fromDate = this.formatDayjs(fromDateValue);
+      let toDate = this.formatDayjs(toDateValue);
+
+      let diff = '';
+      switch (type) {
+        case 'minutes':
+          diff = toDate.diff(fromDate, 'minutes');
+          break;
+        case 'hours':
+          diff = toDate.diff(fromDate, 'hours');
+          break;
+        case 'days':
+          diff = toDate.diff(fromDate, 'days') + 1;
+          break;
+        case 'months':
+          diff = toDate.diff(fromDate, 'months');
+          break;
+        case 'years':
+          diff = toDate.diff(fromDate, 'years');
+          break;
+
+        default:
+          break;
+      }
+      result = diff.toString();
+    }
+
+    setValue(toId, result, isMasterDetail);
+    // toElement.innerHTML = result;
+  },
+};
+
+const countYears = (fromDateName, toDateName, toId) => {
+  datetime.count('years', fromDateName, toDateName, toId);
+};
+
+const countMonths = (fromDateName, toDateName, toId) => {
+  datetime.count('months', fromDateName, toDateName, toId);
+};
+
+const countDays = (fromDateName, toDateName, toId) => {
+  datetime.count('days', fromDateName, toDateName, toId);
+};
+
+const countHours = (fromDateName, toDateName, toId) => {
+  datetime.count('hours', fromDateName, toDateName, toId);
+};
+
+const countMinutes = (fromDateName, toDateName, toId) => {
+  datetime.count('minutes', fromDateName, toDateName, toId);
+};
+
+const validateDatesRange = (startDate, toDate, dateType, count) => {
+  window.validateDatesRange(startDate, toDate, dateType, count);
+};
+
+const validatePhoneNumber = name => {
+  window.validatePhoneNumber(name);
+};
+
+const validateEmail = name => {
+  window.validateEmail(name);
+};
+
+const convertNumberToText = value => {
+  return new Intl.NumberFormat('vi-VN').format(Number(value));
+};
+
+const displayNumber = elementId => {
+  const id = elementId ?? colName;
+  const element = getElementById(id);
+  if (element) {
+    const value = getValue(id) ?? 0;
+    if (!value.includes('.')) {
+      element.innerHTML = new Intl.NumberFormat('vi-VN').format(Number(value));
+    }
+  }
+};
+
+const _displayNumber = elementId => {
+  displayNumber(elementId);
+};
+
+const validateForm = (isValid, elementIds, isMD) => {
+  window.handleActionButtons(isValid, elementIds, isMD);
+};
+
+const compareNumbers = (compareString, isMD) => {
+  const formular = handleFormularString(compareString, isMD);
+
+  window.handleActionButtons(eval(formular.math), formular.elementIds, isMD);
+};
+
+const compareNumbersMD = compareString => {
+  compareNumbers(compareString, true);
+};
+
+const handleFormularString = (formularString, isMD) => {
+  if (formularString?.length > 0) {
+    formularString = formularString.replace(/\s/g, '');
+    let name = '';
+    let adding = false;
+    const ids = [];
+
+    for (let i = 0; i < formularString.length; i++) {
+      if (formularString[i] === '[') {
+        adding = true;
+      } else if (formularString[i] === ']') {
+        ids.push(name);
+        adding = false;
+        name = '';
+      } else if (adding === true) {
+        name += formularString[i];
+      }
+    }
+
+    let formular = formularString;
+    if (ids.length > 0) {
+      ids.forEach(id => {
+        const value = formatNumberString(
+          isMD ? getValueMD(id) : getValue(id) ?? '0'
+        );
+        formular = formular.replaceAll(`[${id}]`, value);
+      });
+    }
+    return { math: formular, elementIds: ids };
+  } else {
+    return { math: formularString, elementIds: [] };
+  }
+};
+
+const valid = () => {
+  window.handleActionButtons(true);
+};
+
+const invalid = () => {
+  window.handleActionButtons(false);
+};
+
+const convertVIToENNumber = num => {
+  num = num.replaceAll(',', '-');
+  num = num.replaceAll('.', ',');
+  num = num.replaceAll('-', '.');
+  return num;
+};