dtable-statistic 4.4.24-alpha.9 → 5.0.0

package/es/utils/color-utils.js

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getValidColorRules = exports.getLabelColorFromSpecificColor = exports.getLabelColorFromColorRules = exports.getLabelColor = exports.getConvertedColorRules = void 0;
+var _dtableUtils = require("dtable-utils");
+var _constants = require("../constants");
+var _colorRules = require("../constants/color-rules");
+const getValidColorRules = colorRules => {
+  if (!Array.isArray(colorRules) || colorRules.length === 0) {
+    return [];
+  }
+  const columns = [];
+  const keyExistColumnMap = {};
+  colorRules.forEach(colorRule => {
+    colorRule.filters.forEach(filter => {
+      const filterType = filter.filter_type;
+      if (keyExistColumnMap[filterType]) {
+        return;
+      }
+      columns.push({
+        key: _colorRules.COLOR_RULE_FILTER_TYPE_MAP.NUMERIC_VALUE,
+        type: _colorRules.FILTER_TYPE_2_CELL_TYPE[filterType]
+      });
+      keyExistColumnMap[filterType] = true;
+    });
+  });
+  return colorRules.map(colorRule => {
+    const {
+      filters
+    } = colorRule;
+    const convertedFilters = filters.map(filter => {
+      return {
+        ...filter,
+        column_key: filter.filter_type
+      };
+    });
+    const validFilters = (0, _dtableUtils.getValidFilters)(convertedFilters, columns);
+    if (validFilters.length === 0) {
+      return null;
+    }
+    return {
+      ...colorRule,
+      filters: validFilters
+    };
+  }).filter(Boolean);
+};
+exports.getValidColorRules = getValidColorRules;
+const getConvertedColorRules = colorRules => {
+  const validColorRules = getValidColorRules(colorRules);
+  return validColorRules.map(colorRule => {
+    const convertedFilters = colorRule.filters.map(filter => {
+      const {
+        filter_type
+      } = filter;
+      return {
+        ...filter,
+        column_key: filter_type,
+        column: {
+          key: filter_type,
+          type: _colorRules.FILTER_TYPE_2_CELL_TYPE[filter_type]
+        }
+      };
+    });
+    return {
+      ...colorRule,
+      filters: convertedFilters
+    };
+  });
+};
+exports.getConvertedColorRules = getConvertedColorRules;
+const getLabelColorFromSpecificColor = chart => {
+  switch (chart.type) {
+    case _constants.STAT_TYPE.BAR:
+      {
+        return chart.y_axis_label_color;
+      }
+    case _constants.STAT_TYPE.HORIZONTAL_BAR:
+      {
+        return chart.horizontal_axis_label_color;
+      }
+    default:
+      {
+        return null;
+      }
+  }
+};
+exports.getLabelColorFromSpecificColor = getLabelColorFromSpecificColor;
+const getLabelColorFromColorRules = (colorRules, value) => {
+  if (!colorRules) {
+    return null;
+  }
+  const row = {
+    'numeric_value': value
+  };
+  let matchedRuleColor = null;
+  for (let i = 0, colorRulesLen = colorRules.length; i < colorRulesLen; i++) {
+    const colorRule = colorRules[i];
+    const {
+      color,
+      filter_conjunction,
+      filters
+    } = colorRule;
+    if ((0, _dtableUtils.filterRow)(row, filter_conjunction, filters)) {
+      matchedRuleColor = color;
+      break;
+    }
+  }
+  return matchedRuleColor;
+};
+exports.getLabelColorFromColorRules = getLabelColorFromColorRules;
+const getLabelColor = _ref => {
+  let {
+    chart,
+    colorRules,
+    value
+  } = _ref;
+  switch (chart.color_option) {
+    case _constants.TYPE_COLOR_USING.USE_SPECIFIC_COLORS:
+      {
+        return getLabelColorFromSpecificColor(chart);
+      }
+    case _constants.TYPE_COLOR_USING.USE_RULES:
+      {
+        return getLabelColorFromColorRules(colorRules, value);
+      }
+    default:
+      {
+        return null;
+      }
+  }
+};
+exports.getLabelColor = getLabelColor;

package/es/utils/column-utils.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getColorFromSingleSelectColumn = getColorFromSingleSelectColumn;
+exports.isWorldMapColumn = exports.isStatisticDateColumn = exports.isMirrorColumn = exports.isMapColumn = void 0;
+var _dtableUtils = require("dtable-utils");
+var _constants = require("../constants");
+function getColorFromSingleSelectColumn(column, target) {
+  let {
+    type: columnType,
+    data: columnData
+  } = column;
+  if (columnType !== _dtableUtils.CellType.SINGLE_SELECT) {
+    return null;
+  }
+  const options = columnData ? columnData.options : [];
+  const selectedOption = options.find(option => {
+    let id = target;
+    if (Array.isArray(target)) {
+      id = target[0];
+    }
+    return option.id === id;
+  });
+  const color = selectedOption && selectedOption.color;
+  return color || null;
+}
+const isStatisticDateColumn = column => {
+  if (!column) return false;
+  return (0, _dtableUtils.isDateColumn)(column);
+};
+exports.isStatisticDateColumn = isStatisticDateColumn;
+const isMapColumn = column => {
+  if (!column) return false;
+  const {
+    type,
+    data
+  } = column;
+  if (type === _dtableUtils.CellType.GEOLOCATION) {
+    const {
+      geo_format
+    } = data || {};
+    if (geo_format === 'lng_lat' || geo_format === 'country_region') {
+      return false;
+    }
+    return true;
+  }
+  if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[type]) {
+    const {
+      result_type,
+      array_type,
+      array_data
+    } = data || {};
+    if (result_type !== _dtableUtils.FORMULA_RESULT_TYPE.ARRAY || array_type !== _dtableUtils.CellType.GEOLOCATION) {
+      return false;
+    }
+    const {
+      geo_format
+    } = array_data || {};
+    if (geo_format === 'lng_lat' || geo_format === 'country_region') {
+      return false;
+    }
+    return true;
+  }
+  return false;
+};
+exports.isMapColumn = isMapColumn;
+const isMirrorColumn = column => {
+  if (!column) return false;
+  return _constants.MIRROR_COLUMN_LIST.includes(column.type);
+};
+exports.isMirrorColumn = isMirrorColumn;
+const isWorldMapColumn = column => {
+  if (!column) return false;
+  const {
+    type,
+    data
+  } = column;
+  if (type === _dtableUtils.CellType.TEXT) return true;
+  if (type === _dtableUtils.CellType.GEOLOCATION) {
+    const {
+      geo_format
+    } = data || {};
+    if (geo_format === 'country_region') {
+      return true;
+    }
+  }
+  if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[type]) {
+    const {
+      data
+    } = column;
+    const {
+      result_type,
+      array_type,
+      array_data
+    } = data || {};
+    if (result_type !== _dtableUtils.FORMULA_RESULT_TYPE.ARRAY || array_type !== _dtableUtils.CellType.GEOLOCATION) {
+      return false;
+    }
+    const {
+      geo_format
+    } = array_data || {};
+    if (geo_format === 'country_region') {
+      return true;
+    }
+  }
+  return false;
+};
+exports.isWorldMapColumn = isWorldMapColumn;

package/es/utils/column.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDateColumnFormat = getDateColumnFormat;
+exports.getSelectColumnOptions = getSelectColumnOptions;
+var _dtableUtils = require("dtable-utils");
+function getSelectColumnOptions(column) {
+  if (!column || !column.data || !Array.isArray(column.data.options)) {
+    return [];
+  }
+  return column.data.options;
+}
+function getDateColumnFormat(column) {
+  let format = column && column.data && column.data.format ? column.data.format : _dtableUtils.DEFAULT_DATE_FORMAT;
+  // Old Europe format is D/M/YYYY new format is DD/MM/YYYY
+  format = format.replace(/D\/M\/YYYY/, 'DD/MM/YYYY');
+  return format;
+}

package/es/utils/common-utils.js

@@ -1,10 +1,20 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.generatorUniqueId = void 0;
+exports.arraysEqual = arraysEqual;
+exports.formatNumericValue = void 0;
+exports.formatPieChartData = formatPieChartData;
+exports.isShapeEqual = exports.isBoolean = exports.isArrayCellValue = exports.getSummaryResult = exports.getSummaryColumnMethod = exports.getLabelFontSize = exports.getImageUrl = exports.getCurrentTheme = exports.generatorUniqueId = void 0;
+exports.isStatItemEqual = isStatItemEqual;
+exports.shallowEqual = shallowEqual;
+exports.sortDataByGroupSum = exports.shouldCalculateStatItem = void 0;
 var _dtableUtils = require("dtable-utils");
+var _reactIntlUniversal = _interopRequireDefault(require("react-intl-universal"));
+var _constants = require("../constants");
+var _statUtils = _interopRequireDefault(require("./stat-utils"));
 const generatorUniqueId = list => {
   let uniqueId;
   let isUnique = false;
@@ -24,4 +34,344 @@ const generatorUniqueId = list => {
   }
   return uniqueId;
 };
-exports.generatorUniqueId = generatorUniqueId;
+exports.generatorUniqueId = generatorUniqueId;
+const getImageUrl = imageName => {
+  const {
+    mediaUrl
+  } = window.dtable;
+  return "".concat(mediaUrl, "dtable-statistic/img/").concat(imageName);
+};
+exports.getImageUrl = getImageUrl;
+const isShapeEqual = (position1, position2) => {
+  if (position1 && position2) {
+    return position1.w === position2.w && position1.h === position2.h;
+  }
+  if (!position1 && !position2) return true;
+  return false;
+};
+exports.isShapeEqual = isShapeEqual;
+function isStatItemEqual(prevStatItem, chart) {
+  let statItemType = prevStatItem.type;
+  if (statItemType !== chart.type) return false;
+  return shallowEqual(prevStatItem, chart);
+}
+function shallowEqual(objA, objB) {
+  if (objA === objB) {
+    return true;
+  }
+  if (typeof objA !== 'object' || !objA || typeof objB !== 'object' || !objB) {
+    return false;
+  }
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (let i = 0; i < keysA.length; i++) {
+    let key = keysA[i];
+    let valueA = objA[key];
+    let valueB = objB[key];
+    if (key === 'layout') continue;
+    // line | chart-bar | chart-bar-stack | chart-bar-group
+    if (key === 'show_x_axis_label') continue;
+    if (key === 'show_y_axis_label') continue;
+    if (key === 'x_axis_label_position') continue;
+    if (key === 'y_axis_label_position') continue;
+
+    // horizontal bar | horizontal group bar
+    if (key === 'show_vertical_axis_label') continue;
+    if (key === 'show_horizontal_axis_label') continue;
+    if (key === 'vertical_axis_label_position') continue;
+    if (key === 'horizontal_axis_label_position') continue;
+
+    // combination chart
+    if (key === 'show_y_axis_left_label') continue;
+    if (key === 'show_y_axis_right_label') continue;
+    if (key === 'y_axis_left_label_position') continue;
+    if (key === 'y_axis_right_label_position') continue;
+    if (objA.type !== 'basic_number_card' && objA.type !== _constants.STAT_TYPE.DASHBOARD && key === 'name') continue;
+    if (Object.prototype.hasOwnProperty.call(objB, key)) {
+      if (Array.isArray(valueA) && Array.isArray(valueB)) {
+        let isArrayEqual = arraysEqual(valueA, valueB);
+        if (!isArrayEqual) return false;
+      } else if (valueA !== valueB) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+  if (!isShapeEqual(objA.layout, objB.layout)) {
+    return false;
+  }
+  return true;
+}
+const IGNORE_STAT_KEYS = ['layout', 'name', 'show_y_axis_label', 'show_x_axis_label', 'show_vertical_axis_label', 'show_horizontal_axis_label', 'vertical_axis_label_position', 'horizontal_axis_label_position', 'horizontal_axis_label_color', 'y_axis_label_color', 'data_color', 'display_data', 'show_y_axis_left_label', 'show_y_axis_right_label', 'x_axis_label_position', 'y_axis_label_position', 'y_axis_left_color', 'y_axis_right_color', 'y_axis_left_label_position', 'y_axis_right_label_position', 'minimum_slice_percent', 'bubble_color', 'map_type', 'legend_direction', 'legend_size', 'completed_color', 'uncompleted_color', 'display_percentage', 'label_font_size'];
+const shouldCalculateStatItem = (prevStatItem, chart) => {
+  let statItemType = prevStatItem.type;
+  if (statItemType !== chart.type) return true;
+  if (prevStatItem === chart) {
+    return false;
+  }
+  if (typeof prevStatItem !== 'object' || !prevStatItem || typeof chart !== 'object' || !chart) {
+    return true;
+  }
+  const keysA = Object.keys(prevStatItem);
+  const keysB = Object.keys(chart);
+  if (keysA.length !== keysB.length) {
+    return true;
+  }
+  for (let i = 0; i < keysA.length; i++) {
+    let key = keysA[i];
+    let valueA = prevStatItem[key];
+    let valueB = chart[key];
+    if (IGNORE_STAT_KEYS.includes(key)) continue;
+    if (Object.prototype.hasOwnProperty.call(chart, key)) {
+      if (Array.isArray(valueA) && Array.isArray(valueB)) {
+        let isArrayEqual = arraysEqual(valueA, valueB);
+        if (!isArrayEqual) return true;
+      } else if (valueA !== valueB) {
+        return true;
+      }
+    } else {
+      return true;
+    }
+  }
+  return false;
+};
+exports.shouldCalculateStatItem = shouldCalculateStatItem;
+function arraysEqual(arrayA, arrayB) {
+  if (arrayA === null || arrayB === null) return false;
+  if (arrayA.length !== arrayB.length) return false;
+  for (let i = 0; i < arrayA.length; i++) {
+    if (!shallowEqual(arrayA[i], arrayB[i])) return false;
+  }
+  return true;
+}
+const isArrayCellValue = column => {
+  if (!column) return false;
+  const {
+    type,
+    data
+  } = column;
+  return _constants.MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP[type] || _dtableUtils.FORMULA_COLUMN_TYPES_MAP[type] && data && data.result_type === _dtableUtils.FORMULA_RESULT_TYPE.ARRAY && _dtableUtils.COLLABORATOR_COLUMN_TYPES.includes(data.array_type) // the collaborator lookup is not formatted
+  ;
+};
+exports.isArrayCellValue = isArrayCellValue;
+const getSummaryResult = function (results, summaryMethod) {
+  let precision = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 8;
+  const numericResults = Array.isArray(results) && results.length > 0 ? results.filter(res => (0, _dtableUtils.isNumber)(res)) : [];
+  switch (summaryMethod) {
+    case _constants.SUMMARY_METHOD_MAP.Max:
+      {
+        return getMax(numericResults);
+      }
+    case _constants.SUMMARY_METHOD_MAP.Min:
+      {
+        return getMin(numericResults);
+      }
+    case _constants.SUMMARY_METHOD_MAP.Sum:
+      {
+        return getSum(numericResults, precision);
+      }
+    case _constants.SUMMARY_METHOD_MAP.Mean:
+      {
+        return getMean(numericResults, precision);
+      }
+    case _constants.SUMMARY_METHOD_MAP.Distinct_values:
+      {
+        let count = 0;
+        let existMap = {};
+        Array.isArray(results) && results.forEach(resNum => {
+          let num = resNum;
+          if (!num) {
+            if (num === 0) {
+              num = '0';
+            } else {
+              num = !!num;
+            }
+          }
+          if (!existMap[num]) {
+            existMap[num] = true;
+            count++;
+          }
+        });
+        return count;
+      }
+    default:
+      {
+        return 0;
+      }
+  }
+};
+exports.getSummaryResult = getSummaryResult;
+const getMax = list => {
+  if (list.length === 0) return 0;
+  return Number.parseFloat(Math.max.apply(null, list));
+};
+const getMin = list => {
+  if (list.length === 0) return 0;
+  return Number.parseFloat(Math.min.apply(null, list).toFixed(8));
+};
+const getSum = function (list) {
+  let precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 8;
+  if (list.length === 0) return 0;
+  const sum = list.reduce((a, b) => {
+    return a + b;
+  }, 0);
+  return Number.parseFloat(Number(sum).toFixed(8));
+};
+const getMean = function (list) {
+  let precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 8;
+  if (list.length === 0) return 0;
+  const sum = getSum(list);
+  return Number.parseFloat((sum / list.length).toFixed(precision));
+};
+const getPieColor = (color_option, column, index, data, currentTheme) => {
+  let {
+    type: columnType,
+    data: columnData
+  } = column;
+  const {
+    colors
+  } = currentTheme;
+  if (color_option === _constants.PIE_COLOR_OPTIONS[1] && (columnType === _dtableUtils.CellType.SINGLE_SELECT || columnType === _dtableUtils.CellType.MULTIPLE_SELECT)) {
+    if (columnData && columnData.options) {
+      const selectedItem = columnData.options.find(item => item.name === data.name) || {};
+      return selectedItem.color || '#dbdbdb';
+    }
+  } else {
+    const sIndex = String(index);
+    const colorIndex = sIndex.charAt(sIndex.length - 1);
+    return colors[colorIndex];
+  }
+};
+function formatPieChartData(data, statItem, table, currentTheme) {
+  const {
+    groupby_column_key,
+    color_option,
+    summary_column_key,
+    summary_method: summaryMethod,
+    summary_type
+  } = statItem;
+  const isAdvanced = summary_type === 'advanced';
+  const column = (0, _dtableUtils.getTableColumnByKey)(table, groupby_column_key);
+  let sum = data.reduce((total, currentValue) => {
+    return total += currentValue.value;
+  }, 0);
+  const minimumSlicePercentage = typeof statItem.minimum_slice_percent === 'number' ? statItem.minimum_slice_percent : 1.5;
+  const threshold = sum * (minimumSlicePercentage / 100 || 0);
+  const filteredItems = [];
+  const colorSet = [];
+  const filteredData = [];
+  let stepIndex = 0;
+  data.forEach((item, index) => {
+    const value = item.value;
+    if (value >= threshold) {
+      const colorIndex = index - stepIndex;
+      item.percent = String(Number.parseFloat(value / sum * 100).toFixed(1)) + '%';
+      const color = getPieColor(color_option, column, colorIndex, item, currentTheme);
+      item.color = color;
+      colorSet.push(color);
+      filteredData.push(item);
+    } else {
+      stepIndex += 1;
+      filteredItems.push(item);
+    }
+  });
+  data = filteredData;
+  if (filteredItems.length > 0) {
+    const filteredSum = filteredItems.reduce((total, currentValue) => {
+      return total += currentValue.value;
+    }, 0);
+    let formattedValueSum = filteredSum;
+    if (isAdvanced) {
+      const summaryColumn = (0, _dtableUtils.getTableColumnByKey)(table, summary_column_key);
+      formattedValueSum = _statUtils.default.getFormattedValue(filteredSum, summaryColumn, summaryMethod);
+    }
+    let original_name_list = [];
+    let name_list = [];
+    let rows = [];
+    filteredItems.forEach(item => {
+      if (item.original_name) {
+        original_name_list.push(item.original_name);
+      }
+      if (item.name) {
+        name_list.push(item.name);
+      }
+      if (item.rows) {
+        rows.push(...item.rows);
+      }
+    });
+    data.push({
+      rows,
+      name_list,
+      original_name_list,
+      name: _reactIntlUniversal.default.get('Others'),
+      value: filteredSum,
+      formatted_value: formattedValueSum,
+      color: '#dbdbdb',
+      original_name: 'Others',
+      percent: String(Number.parseFloat(filteredSum / sum * 100).toFixed(1)) + '%'
+    });
+    colorSet.push('#dbdbdb');
+  }
+  data.total = sum;
+  data.colorSet = colorSet;
+  return data;
+}
+const formatNumericValue = function (value) {
+  let column = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const data = column.data || {};
+  let {
+    precision = 8
+  } = data;
+  value = value || 0;
+  return parseFloat(value.toFixed(precision));
+};
+exports.formatNumericValue = formatNumericValue;
+const getLabelFontSize = label_font_size => {
+  return (0, _dtableUtils.isNumber)(label_font_size) ? label_font_size : _constants.DEFAULT_LABEL_FONT_SIZE;
+};
+exports.getLabelFontSize = getLabelFontSize;
+const getSummaryColumnMethod = function (method, summaryColumnName) {
+  let useSingleQuote = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if (method === 'Distinct_values') {
+    return "COUNT(DISTINCT ".concat(summaryColumnName, ")");
+  }
+  return "".concat(method, "(").concat(useSingleQuote ? '`' : '').concat(summaryColumnName).concat(useSingleQuote ? '`' : '', ")");
+};
+exports.getSummaryColumnMethod = getSummaryColumnMethod;
+const getCurrentTheme = colorThemeName => {
+  if (colorThemeName) {
+    const currentColorTheme = _constants.CHART_STYLE_COLORS.find(item => item.name === colorThemeName);
+    return currentColorTheme || _constants.CHART_STYLE_COLORS[0];
+  }
+  return _constants.CHART_STYLE_COLORS[0];
+};
+
+// for stacked bar, stacked horizontal bar
+exports.getCurrentTheme = getCurrentTheme;
+const sortDataByGroupSum = (data, sortType) => {
+  const nameSumMap = [];
+  data.forEach(item => {
+    if (nameSumMap.filter(filteredItem => filteredItem.name === item.name).length === 0) {
+      const items = data.filter(originItem => originItem.name === item.name);
+      const valueSum = items.reduce((accumulator, currentItem) => accumulator + currentItem.value, 0);
+      nameSumMap.push({
+        name: item.name,
+        items,
+        valueSum
+      });
+    }
+  });
+
+  // sort group
+  _statUtils.default.sortDataByKey(nameSumMap, 'valueSum', sortType);
+  return nameSumMap.reduce((accumulator, currentItem) => accumulator.concat(currentItem.items), []);
+};
+exports.sortDataByGroupSum = sortDataByGroupSum;
+const isBoolean = val => {
+  return typeof val === 'boolean';
+};
+exports.isBoolean = isBoolean;

package/es/utils/date-format.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTodayDate = getTodayDate;
+exports.translateCalendar = translateCalendar;
+const zhCN = require('@seafile/seafile-calendar/lib/locale/zh_CN');
+const zhTW = require('@seafile/seafile-calendar/lib/locale/zh_TW');
+const enUS = require('@seafile/seafile-calendar/lib/locale/en_US');
+const frFR = require('@seafile/seafile-calendar/lib/locale/fr_FR');
+const deDE = require('@seafile/seafile-calendar/lib/locale/de_DE');
+const esES = require('@seafile/seafile-calendar/lib/locale/es_ES');
+const plPL = require('@seafile/seafile-calendar/lib/locale/pl_PL');
+const csCZ = require('@seafile/seafile-calendar/lib/locale/cs_CZ');
+const ruRU = require('@seafile/seafile-calendar/lib/locale/ru_RU');
+function translateCalendar() {
+  const locale = window.dtable ? window.dtable.lang : 'en';
+  let language;
+  switch (locale) {
+    case 'zh-cn':
+      language = zhCN;
+      break;
+    case 'zh-tw':
+      language = zhTW;
+      break;
+    case 'en':
+      language = enUS;
+      break;
+    case 'fr':
+      language = frFR;
+      break;
+    case 'de':
+      language = deDE;
+      break;
+    case 'es':
+      language = esES;
+      break;
+    case 'es-ar':
+      language = esES;
+      break;
+    case 'es-mx':
+      language = esES;
+      break;
+    case 'pl':
+      language = plPL;
+      break;
+    case 'cs':
+      language = csCZ;
+      break;
+    case 'ru':
+      language = ruRU;
+      break;
+    default:
+      language = enUS;
+  }
+  return language;
+}
+function getTodayDate() {
+  let todayDate = new Date();
+  let year = todayDate.getFullYear();
+  let month = todayDate.getMonth() + 1;
+  let date = todayDate.getDate();
+  let hour = todayDate.getHours();
+  let minute = todayDate.getMinutes();
+  month = month > 9 ? month : "0".concat(month);
+  date = date > 9 ? date : "0".concat(date);
+  hour = hour > 9 ? hour : "0".concat(hour);
+  minute = minute > 9 ? minute : "0".concat(minute);
+  return "".concat(year, "-").concat(month, "-").concat(date, " ").concat(hour, ":").concat(minute);
+}