eztech-core-components 1.0.0

package/utils/data-helper.js

@@ -0,0 +1,236 @@
+import * as moment from 'moment'
+import { get, has, last } from 'lodash'
+import { regexps } from './regexps'
+export const generateAppPassword = (length = 16) => {
+  const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()'
+  const randomValues = new Uint8Array(length)
+  crypto.getRandomValues(randomValues)
+  let password = ''
+  for (let i = 0; i < length; i++) {
+    password += charset[randomValues[i] % charset.length]
+  }
+  return password
+}
+export const getIdcardAddress = (response) => {
+  if (!response) {
+    return null
+  }
+  let passport_address = response.passportAddress
+  const lastAddress = last(response.listAddress)
+  if (lastAddress?.aimagCityName) {
+    const vals = [lastAddress.aimagCityName, lastAddress.soumDistrictName, lastAddress.bagKhorooName]
+    if (lastAddress.addressStreetName) {
+      vals.push(`${lastAddress.addressStreetName} гудамж`)
+    }
+    if (lastAddress.addressRegionName) {
+      vals.push(`${lastAddress.addressRegionName} хороолол`)
+    }
+    if (lastAddress.addressTownName) {
+      vals.push(`${lastAddress.addressTownName} хотхон`)
+    }
+    if (lastAddress.addressApartmentName) {
+      vals.push(`${lastAddress.addressApartmentName} байр`)
+    }
+    if (lastAddress.addressDoor) {
+      vals.push(`${lastAddress.addressDoor} тоот`)
+    }
+    passport_address = vals.join(', ')
+  }
+  return passport_address
+}
+export const isWorkDay = (date, holidays) => {
+  const days = holidays.map((c) => {
+    const reg_date = c.is_repeat ? moment(moment(date).format('YYYY') + moment(c.reg_date).format('-MM-DD')).toDate() : c.reg_date
+    const start_date = c.start_date || date
+    const end_date = c.end_date || date
+    return { ...c, reg_date, start_date, end_date }
+  })
+  const filterDay = days.find(c => moment(date).isBetween(c.start_date, c.end_date, 'days', '[]') && moment(c.reg_date).isSame(date, 'days'))
+  if (filterDay) {
+    return !filterDay.is_rest
+  } else {
+    return moment(date).isoWeekday() <= 5
+  }
+}
+export const getFormBoolean = (val) => {
+  return [1, '1', 'true', true, 'True', 'TRUE'].includes(val)
+}
+export const getDateString = (val) => {
+  if (!val) {
+    return null
+  }
+  return moment(val).format('YYYY-MM-DD')
+}
+export const getDatetimeString = (val) => {
+  if (!val) {
+    return
+  }
+  return moment(val).format('YYYY-MM-DD HH:mm')
+}
+
+export const getStringDatetime = (val) => {
+  if (!val) {
+    return
+  }
+  return moment(val, 'YYYY-MM-DD HH:mm').toDate()
+}
+export const getStringDate = (val) => {
+  if (!val) {
+    return null
+  }
+  return moment(val).toDate()
+}
+export const addBusinessDays = (startDate, days, holidays) => {
+  if (!holidays?.length) {
+    throw new Error('Required holidays')
+  }
+  if (!startDate || [null, undefined].includes(days)) {
+    return null
+  }
+  const currentDate = moment(startDate)
+  let addedDays = 0
+  if (isWorkDay(currentDate.toDate(), holidays)) {
+    addedDays++
+  }
+  while (addedDays < days) {
+    currentDate.add(1, 'days')
+    if (isWorkDay(currentDate.toDate(), holidays)) {
+      addedDays++
+    }
+  }
+  return currentDate.format('YYYY-MM-DD')
+}
+export const diffBusinessDays = (startDate, endDate, holidays) => {
+  if (!holidays?.length) {
+    throw new Error('Required holidays')
+  }
+  if (!startDate || !endDate) {
+    return null
+  }
+  const currentDate = moment(startDate)
+  const end = moment(endDate)
+  let daysBetween = 0
+  while (!currentDate.isAfter(end, 'day')) {
+    if (isWorkDay(currentDate.toDate(), holidays)) {
+      daysBetween++
+    }
+    currentDate.add(1, 'day')
+  }
+  return daysBetween
+}
+export const getGenderFromName = (gender, refs) => {
+  if (!refs) {
+    throw new Error('Required refs.')
+  }
+  const checkMan = gender?.toLowerCase()?.includes('эр')
+  const checkWomen = gender?.toLowerCase()?.includes('эм')
+  if (!checkMan && !checkWomen) {
+    return null
+  }
+  const genderCode = checkMan ? '1' : '2'
+  const genderId = refs.genders?.find(c => c.code === genderCode)?._id
+  return { _id: genderId, name: gender, code: genderCode }
+}
+export const getAgeFromDate = (date) => {
+  if (!date) {
+    return 0
+  }
+  const momentDate = moment(date)
+  const age1 = moment().diff(momentDate, 'years', false)
+  const month1 = Math.round(moment().subtract(age1, 'years').diff(momentDate, 'month', false) * 10) / 10
+  return Number(age1 + '.' + String(month1).padStart(2, '0'))
+}
+export const extractRegisterNum = (regnum, refs) => {
+  if (!refs) {
+    throw new Error('Required refs.')
+  }
+  let birth_date = null
+  let age = 0
+  let gender_id = null
+  const checkRegNum = regnum?.trim()?.toUpperCase()
+  if (typeof checkRegNum === 'string' && checkRegNum?.length === 10 && regexps.oldRegisterNum.pattern.test(checkRegNum)) {
+    let birthDate = checkRegNum.slice(2, 8)
+    if (['2', '3'].includes(birthDate[2])) {
+      birthDate = '20' + birthDate.slice(0, 2) + (Number(birthDate[2]) - 2) + birthDate.slice(3)
+    } else {
+      birthDate = '19' + birthDate
+    }
+    const momentDate = moment(birthDate, 'YYYYMMDD')
+    if (momentDate.isValid()) {
+      age = getAgeFromDate(momentDate.format('YYYY-MM-DD'))
+      const gender = String(Number(checkRegNum.slice(8, 9)) % 2 === 0 ? '2' : '1')
+      const genderId = refs.genders?.find(c => c.code === gender)?._id
+      if (!genderId) {
+        throw new Error('Системд ямар нэгэн алдаа гарлаа.')
+      }
+      gender_id = { _id: genderId, code: gender, name: gender === '1' ? 'Эрэгтэй' : 'Эмэгтэй' }
+      birth_date = momentDate.format('YYYY-MM-DD')
+    }
+  }
+  return { birth_date, age, gender_id }
+}
+export const getTriggerFields = (trigger_fields, actionType = 'search') => {
+  if (!trigger_fields) {
+    return []
+  }
+  return trigger_fields.split(',').map((c1) => {
+    const cc = c1.split(':')
+    const localKey = get(cc, '[0]')
+    const localVal = get(cc, '[1]')
+    const type = get(cc, '[2]')
+    const operation = get(cc, '[3]')
+    const searchType = get(cc, '[4]') || 'search'
+    const label = get(cc, '[5]')
+    return { localKey, localVal, type, operation, searchType, label }
+  }).filter(c1 => c1.searchType === actionType && c1.operation)
+}
+export const getTriggerEquals = (trigger_field, item, defaultValue) => {
+  let isEqual = defaultValue
+  const { type, localKey } = trigger_field
+  let localVal = trigger_field.localVal
+  let operation = trigger_field.operation
+  let tempVal = get(item, localKey)
+  if (localKey.includes('[].') && !tempVal && operation === 'eq') {
+    tempVal = get(item, localKey.split('[].')[0])?.map(c => c[localKey.split('[].')[1]]) || []
+    return tempVal.includes(localVal)
+  }
+  if (tempVal && typeof tempVal === 'object' && has(tempVal, '_id')) {
+    tempVal = type === 'number' ? Number(tempVal._id) : tempVal._id
+  }
+  if (type === 'number' && typeof tempVal === 'string') {
+    tempVal = Number(tempVal)
+  }
+  if (localVal === 'null') {
+    operation = 'ne'
+    localVal = null
+    tempVal = tempVal ? '' : null
+  } else if (localVal === 'notnull') {
+    operation = 'eq'
+    localVal = null
+    tempVal = tempVal ? '' : null
+  } else if (['in', 'nin'].includes(operation)) {
+    localVal = localVal.split(';').map(c => type === 'number' ? Number(c) : c)
+  } else if (type === 'number') {
+    localVal = Number(localVal)
+  } else if (type === 'boolean') {
+    localVal = ['true', '1', true, 'True'].includes(localVal)
+  }
+  if (operation === 'nin') {
+    isEqual = !localVal.includes(tempVal)
+  } else if (operation === 'in') {
+    isEqual = localVal.includes(tempVal)
+  } else if (operation === 'ne') {
+    isEqual = localVal !== tempVal
+  } else if (operation === 'eq') {
+    isEqual = localVal === tempVal
+  }
+  return isEqual
+}
+export function isValidJSON (str) {
+  try {
+    JSON.parse(str)
+    return true
+  } catch (error) {
+    return false
+  }
+}

package/utils/default-nuxt-config.js

@@ -0,0 +1,116 @@
+// const { URL } = require('url')
+export const getDefaultConfig = (options) => {
+  const buildDir = process.env.BUILD_DIR || '.nuxt'
+  const routerBase = process.env.ROUTER_BASE || ''
+  const proxy = {}
+  const render = {
+    static: {
+      setHeaders (res) {
+        res.setHeader('X-XSS-Protection', '1; mode=block')
+        res.setHeader('Referrer-Policy', 'no-referrer')
+        res.setHeader('X-Frame-Options', 'DENY')
+        res.setHeader(
+          'Content-Security-Policy',
+          "default-src 'self'; frame-ancestors 'none'; script-src 'self'; style-src 'self'; img-src 'self' data:; font-src 'self'; connect-src 'self'"
+        )
+      }
+    }
+  }
+  const axios = {
+    baseURL: process.env.BASE_URL_SERVER || process.env.BASE_URL,
+    browserBaseURL: '/api',
+    credentials: true,
+    process: false
+  }
+  if (process.env.FILE_URL && !process.env.FILE_URL?.startsWith('/api')) {
+    axios.proxy = true
+    proxy['/api/file/'] = {
+      target: process.env.FILE_URL,
+      pathRewrite: { '^/api/file/': '' },
+      changeOrigin: true
+    }
+    // if (process.env.TOKEN_NAME) {
+    //   proxy['/api/file/'].headers = {
+    //     'x-pid': process.env.TOKEN_NAME
+    //   }
+    // }
+  }
+  if (!process.env.BASE_URL?.startsWith('/api')) {
+    axios.proxy = true
+    proxy['/api'] = {
+      target: process.env.BASE_URL,
+      pathRewrite: { '^/api/': '' },
+      changeOrigin: true
+    }
+    // if (process.env.TOKEN_NAME) {
+    //   proxy['/api'].headers = {
+    //     'x-pid': process.env.TOKEN_NAME
+    //   }
+    // }
+  }
+  if (process.env.SOCKET_URL) {
+    axios.proxy = true
+    proxy['/socketio/'] = {
+      target: process.env.SOCKET_URL,
+      ws: true,
+      changeOrigin: true
+    }
+  }
+  const server = {
+    host: process.env.HOST || '0.0.0.0',
+    port: process.env.PORT || 3000
+  }
+  const router = {
+    base: routerBase || '/',
+    middleware: []
+  }
+  if (!options?.ignoreConfirmLeave) {
+    router.middleware.push('confirm-leave')
+  }
+  const loading = false
+  const build = {
+    // webpack: {
+    //   performance: {
+    //     hints: 'warning',
+    //     maxAssetSize: 5000000, // Adjust the size limit (in bytes) if necessary
+    //     maxEntrypointSize: 5000000
+    //   }
+    // },
+    // performance: {
+    //   hints: false
+    // },
+    extend (config, { isClient }) {
+      // config.performance = {
+      //   hints: 'warning',
+      //   maxEntrypointSize: 5000000, // 5 MiB
+      //   maxAssetSize: 5000000, // 5 MiB
+      // }
+      if (isClient) {
+        config.externals = {}
+        if (options?.jquery) {
+          // config.externals.jquery = 'jQuery'
+        }
+      }
+    },
+    babel: {
+      plugins: [
+        '@babel/plugin-proposal-optional-chaining',
+        '@babel/plugin-proposal-nullish-coalescing-operator',
+        '@babel/plugin-proposal-object-rest-spread'
+      ]
+    }
+  }
+  if (!options?.ignoreElementUi) {
+    build.transpile = [/^element-ui/, '@eztech/core-components']
+  }
+  // ,
+  // vue: {
+  //   config: {
+  //     devtools: true
+  //   }
+  // },
+  // debug: true
+  return {
+    proxy, axios, server, buildDir, router, loading, build, routerBase, render
+  }
+}

package/utils/eslint-rules.js

@@ -0,0 +1,12 @@
+module.exports = {
+  camelcase: 'off',
+  'vue/no-v-html': 'off',
+  'object-property-newline': 'off',
+  'vue/prop-name-casing': 'off',
+  'vue/multi-word-component-names': 'off',
+  'vue/require-prop-types': 'off',
+  'promise/param-names': 'off',
+  'prefer-regex-literals': 'off',
+  'vue/max-attributes-per-line': 'off',
+  'no-irregular-whitespace': 'off'
+}

package/utils/helpers.js

@@ -0,0 +1,67 @@
+export function openLinkNewTab (link) {
+  const a = document.createElement('a')
+  a.href = link
+  a.target = '_blank'
+  a.rel = 'noopener noreferrer'
+  document.body.appendChild(a)
+  a.click()
+  document.body.removeChild(a)
+}
+export const applyDrag = (arr, dragResult) => {
+  const { removedIndex, addedIndex, payload } = dragResult
+  if (removedIndex === null && addedIndex === null) { return arr }
+
+  const result = [...arr]
+  let itemToAdd = payload
+  if (removedIndex !== null) {
+    itemToAdd = result.splice(removedIndex, 1)[0]
+  }
+  if (addedIndex !== null) {
+    result.splice(addedIndex, 0, itemToAdd)
+  }
+  return result
+}
+export const getUnicodeName = (name) => {
+  const cyrillic = 'Ү_Ө_А_Б_В_Г_Д_Ђ_Е_Ё_Ж_З_И_Й_Ј_К_Л_Љ_М_Н_Њ_О_П_Р_С_Т_Ћ_У_Ф_Х_Ц_Ч_Џ_Ш_Щ_Ъ_Ы_Ь_Э_Ю_Яx'.split('_')
+  const latin = 'U_U_A_B_V_G_D_Đ_E_Ë_J_Z_I_I_J_K_L_Lj_M_N_Nj_O_P_R_S_T_Ć_U_F_H_TS_CH_Dž_SH_Ŝ_ʺ_Ii_ʹ_E_Yu_Ya'.split('_')
+  const text = name.split('').map(function (char) {
+    const index = cyrillic.indexOf(char)
+    if (!~index) {
+      const indexLower = cyrillic.indexOf(char.toUpperCase())
+      if (!~indexLower) {
+        return char
+      }
+      return latin[indexLower].toLowerCase()
+    }
+    return latin[index]
+  }).join('')
+  return text
+}
+export const uuidv4 = () => {
+  let d = new Date().getTime()
+  let d2 = ((typeof performance !== 'undefined') && performance.now && (performance.now() * 1000)) || 0
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    let r = Math.random() * 16// random number between 0 and 16
+    if (d > 0) {
+      r = (d + r) % 16 | 0
+      d = Math.floor(d / 16)
+    } else {
+      r = (d2 + r) % 16 | 0
+      d2 = Math.floor(d2 / 16)
+    }
+    return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16)
+  })
+}
+export function base64ToBlob (base64, mimeType) {
+  const base64Data = base64.split(',')[1] || base64
+  const byteCharacters = Uint8Array.from(atob(base64Data), c => c.charCodeAt(0))
+  return new Blob([byteCharacters], { type: mimeType })
+}
+export function blobToBase64 (blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader()
+    reader.readAsDataURL(blob) // Read as Data URL (Base64)
+    reader.onloadend = () => resolve(reader.result.split(',')[1]) // Extract Base64 part
+    reader.onerror = error => reject(error)
+  })
+}

package/utils/message-helper.js

@@ -0,0 +1,19 @@
+import { Message } from 'element-ui'
+import * as _ from 'lodash'
+export const showError = (err) => {
+  const message = getResponseMessage(err)
+  Message({ message, type: 'warning' })
+}
+export const showSuccess = (message) => {
+  Message({ message, type: 'success' })
+}
+export const getResponseMessage = (err) => {
+  let message = _.get(err, 'response.data.message')
+  if (err.isCustomError) {
+    message = err.message
+  }
+  if (!message) {
+    message = err.message
+  }
+  return message
+}

package/utils/number-helper.js

@@ -0,0 +1,166 @@
+import {
+  digit,
+  digitPrefix,
+  oneVariant,
+  tents,
+  tentPrefix,
+  tenPowers,
+  tenPowersPrefix,
+  suffixIin,
+  suffixN,
+  suffixDahi,
+  suffixDugaar,
+  latinText
+} from './number-texts'
+
+const hundredsPrefix = (num) => {
+  if (num < 10) {
+    if (num === 0) {
+      return digit[9]
+    }
+    return digitPrefix[num - 1]
+  }
+  if (num < 100) {
+    if (num % 10 === 0) {
+      return tentPrefix[(num / 10) - 1]
+    }
+    const base = Math.floor(num / 10)
+    const remainder = num - base * 10 - 1
+    return `${tentPrefix[base - 1]} ${remainder === 0 ? oneVariant : digitPrefix[remainder]}`
+  }
+  if (num < 1000) {
+    const divisor = 100
+    const remainder = num % divisor
+    const divided = num / divisor
+    if (remainder === 0) {
+      return `${digitPrefix[divided - 1]} ${tenPowersPrefix[0]}`
+    }
+    const base = Math.floor(num / divisor)
+    if (remainder < 10) {
+      return `${digitPrefix[base - 1]} ${tenPowersPrefix[0]} ${remainder === 1 ? oneVariant : digitPrefix[remainder - 1]}`
+    }
+    return `${digitPrefix[base - 1]} ${tenPowersPrefix[0]} ${hundredsPrefix(remainder)}`
+  }
+  return ''
+}
+
+const toText = (num) => {
+  if (num < 10) {
+    if (num === 0) {
+      return digit[9]
+    }
+    return digit[num - 1]
+  }
+  if (num < 100) {
+    if (num % 10 === 0) {
+      return tents[(num / 10) - 1]
+    }
+    const base = Math.floor(num / 10)
+    return `${tentPrefix[base - 1]} ${digit[num - base * 10 - 1]}`
+  }
+
+  if (num < 1000) {
+    const divisor = 100
+    const remainder = num % divisor
+    const divided = num / divisor
+    if (remainder === 0) {
+      return `${digitPrefix[divided - 1]} ${tenPowers[0]}`
+    }
+    const base = Math.floor(num / divisor)
+    return `${digitPrefix[base - 1]} ${tenPowersPrefix[0]} ${toText(remainder)}`
+  }
+
+  if (num < 1000000) {
+    const divisor = 1000
+    const remainder = num % divisor
+    const divided = Math.floor(num / divisor)
+    if (remainder === 0) { return `${hundredsPrefix(divided)} ${tenPowers[1]}` }
+    return `${hundredsPrefix(divided)} ${tenPowers[1]} ${toText(remainder)}`
+  }
+
+  if (num < 1000000000) {
+    const divisor = 1000000
+    const remainder = num % divisor
+    const divided = Math.floor(num / divisor)
+    if (remainder === 0) { return `${hundredsPrefix(divided)} ${tenPowers[2]}` }
+    return `${hundredsPrefix(divided)} ${tenPowers[2]} ${toText(remainder)}`
+  }
+
+  if (num < 1000000000000) {
+    const divisor = 1000000000
+    const remainder = num % divisor
+    const divided = Math.floor(num / divisor)
+    if (remainder === 0) { return `${hundredsPrefix(divided)} ${tenPowers[3]}` }
+    return `${hundredsPrefix(divided)} ${tenPowers[3]} ${toText(remainder)}`
+  }
+
+  if (num < 1000000000000000) {
+    const divisor = 1000000000000
+    const remainder = num % divisor
+    const divided = Math.floor(num / divisor)
+    if (remainder === 0) { return `${hundredsPrefix(divided)} ${tenPowers[4]}` }
+    return `${hundredsPrefix(divided)} ${tenPowers[4]} ${toText(remainder)}`
+  }
+
+  return ''
+}
+
+export const toWords = (num, options) => {
+  if (num >= 1000000000000000) {
+    console.log('mon_num: The number exceeds the limit of 999999999999999')
+    return ''
+  }
+
+  let result = toText(num)
+
+  if (typeof options !== 'object' || !options) { return result }
+
+  const separated = result.split(' ')
+  if (separated.length > 0 && options.suffix) {
+    const lastWord = separated[separated.length - 1]
+    let collection = []
+
+    if (options.suffix === 'iin') {
+      collection = suffixIin
+    }
+    if (options.suffix === 'n') {
+      collection = suffixN
+    }
+    if (options.suffix === 'dugaar') {
+      collection = suffixDugaar
+    }
+    if (options.suffix === 'dahi') {
+      collection = suffixDahi
+    }
+
+    const transformation = collection.find(suffix => suffix.word === lastWord)
+    if (transformation) {
+      separated.pop()
+      if (options.suffix === 'n' && result === 'нэг') {
+        separated.push('нэг')
+      } else {
+        separated.push(transformation.tf)
+      }
+      result = separated.join(' ')
+    }
+  }
+
+  if (options.latin === true && separated.length > 0) {
+    const separatedNew = result.split(' ')
+    const transformedList = separatedNew.map((word) => {
+      const found = latinText.find(latin => latin.word === word)
+      return found ? found.tf : word
+    })
+    result = transformedList.join(' ')
+  }
+
+  if (options.ucFirst === true) {
+    result = result.charAt(0).toUpperCase() + result.slice(1)
+  }
+
+  if (options.upperCase === true) {
+    result = result.toUpperCase()
+  }
+
+  return result
+}