@mixd-id/web-scaffold 0.2.240702 → 0.2.240704

package/src/utils/dashboard.js

@@ -0,0 +1,1080 @@
+const {presetToSequelizeList} = require("./preset-selector");
+
+const backgroundColors = [
+  "#FF5733", // Bright Red
+  "#33FF57", // Bright Green
+  "#3357FF", // Bright Blue
+  "#FFC300", // Bright Yellow
+  "#28B463", // Emerald Green
+  "#2874A6", // Deep Blue
+  "#F39C12", // Orange
+  "#8E44AD", // Purple
+  "#1ABC9C", // Aqua
+  "#3498DB", // Sky Blue
+  "#2ECC71", // Green
+  "#F1C40F", // Yellow
+  "#34495E", // Dark Slate
+  "#7D3C98", // Amethyst
+  "#16A085", // Teal
+  "#E67E22", // Carrot Orange
+  "#2C3E50", // Dark Blue
+  "#D35400", // Pumpkin Orange
+  "#7FB3D5", // Light Blue
+  "#B03A2E", // Rust
+  "#1F618D", // Steel Blue
+  "#A93226", // Dark Red
+  "#48C9B0", // Light Teal
+  "#E74C3C", // Red
+  "#AF7AC5", // Lavender
+  "#45B39D", // Seafoam
+  "#5D6D7E", // Gray Blue
+  "#52BE80", // Light Green
+  "#F5B041", // Saffron
+  "#BDC3C7"  // Light Gray
+
+  /*'#5D9CEC',
+  '#A0D468',
+  '#FFCE54',
+  '#FC6E51',
+  '#48CFAD',
+  '#AC92EC',
+  '#4FC1E9',
+  '#FFCE54',
+  '#ED5565',
+  '#EC87C0'*/
+]
+
+const getModelFromDatasource = async (datasource, opt) => {
+
+  switch(datasource.type){
+
+    case 2:
+      return opt.conn.models[datasource.key]
+
+    default:
+      if(!opt.conn.models[datasource.datasourceUid]){
+        const tableColumns = await getSequelizeColumns(datasource.columns, opt)
+
+        opt.conn.define(datasource.datasourceUid, tableColumns, {
+          tableName: `datasource_${datasource.datasourceUid}`,
+          timestamps: false
+        })
+      }
+
+      return opt.conn.models[datasource.datasourceUid]
+  }
+}
+
+const getSequelizeColumns = async (columns, opt) => {
+
+  const { DataTypes } = opt.Sequelize
+
+  const tableColumns = {
+    id: {
+      type: DataTypes.INTEGER,
+      autoIncrement: true,
+      primaryKey: true,
+      allowNull: false,
+    }
+  }
+
+  for(let column of columns){
+    if(column.key === 'id') continue
+
+    let type
+    switch(column.type){
+      case 'date':
+        type = DataTypes.DATE
+        break
+      case 'number':
+        type = DataTypes.BIGINT
+        break
+
+      default:
+        type = DataTypes.STRING(column.maxLength ?? 40)
+        break
+    }
+
+    tableColumns[column.key] = {
+      type
+    }
+  }
+
+  return tableColumns
+}
+
+const getDatasourceItems = async (datasource, opt) => {
+
+  if(!datasource.itemsPerPage)
+    datasource.itemsPerPage = 20
+
+  const datasourceOpt = DatasourceService.getDatasourceParamsByUid(datasource.datasourceUid)
+
+  const Model = await getModelFromDatasource(datasource, opt)
+  const config = {
+    columns: datasource.columns
+  }
+
+  const findOpt = await presetToSequelizeList(datasource, {
+    config,
+    model: Model,
+    conn: opt.conn,
+    limit: 100,
+    ...datasourceOpt
+  })
+
+  const items = (await Model.findAll({
+    ...findOpt
+  }))
+    .map(_ => _.toJSON())
+
+  let hasNext = false
+  if(!datasource.pivot?.enabled && items.length > 20){
+    items.pop()
+    hasNext = true
+  }
+
+  if(!datasource.pivot?.enabled && datasource.computedColumns){
+    items.forEach(item => {
+      for(let column of datasource.computedColumns){
+        const value = column.value.replace(/{([^}]+)}/g, (match, key) => {
+          return item[key] ?? 0
+        })
+
+        const valueObj = parser.parse(value)
+
+        item[column.key] = valueObj?.result
+      }
+    })
+  }
+
+  return {
+    items,
+    hasNext
+  }
+}
+
+
+const loadBarChart = async(params, opt) => {
+  if(params.xAxes.filter(_ => !_).length > 0 ||
+    params.yAxes.filter(_ => !_).length > 0)
+    return { labels:[], datasets:[] }
+
+  const { items } = params
+
+  if(items.length === 200001)
+    throw new ValidationError({ count:[ 'Unable to load bar chart, max items count is 200000' ]})
+
+  const columns = (params.datasource.columns ?? []).reduce((res, cur) => {
+    res[cur['key']] = cur
+    return res
+  }, {})
+
+  let labels = []
+  let datasets = []
+
+  let xAxes
+  if(params.xAxeMultiple){
+    xAxes = params.xAxes
+  }
+  else{
+    const xAxesKey = params.xAxes[0].key
+    const xAxeModifier = params.xAxes[0].modifier
+
+    let reduced = {}
+    switch(xAxeModifier){
+
+      case 'hour':
+        for(let i = 0 ; i < 24 ; i++){
+          reduced[i] = { key:i.toString().padStart(2, '0'), parentKey:xAxesKey, modifier:xAxeModifier }
+        }
+        break
+
+      case 'minute':
+        for(let i = 0 ; i < 60 ; i++){
+          reduced[i] = { key:i.toString().padStart(2, '0'), parentKey:xAxesKey, modifier:xAxeModifier }
+        }
+        break
+
+      case 'month':
+        for(let i = 1 ; i <= 12 ; i++){
+          reduced[i] = { key:dayjs(`2020-${i.toString().padStart(2, '0')}-15`).format('MMM'), parentKey:xAxesKey, modifier:xAxeModifier }
+        }
+        break
+
+      case 'year':
+        const currentYear = parseInt(dayjs().format('YYYY'))
+        for(let i = currentYear - 20 ; i <= currentYear ; i++){
+          reduced[i] = { key:i.toString().padStart(2, '0'), parentKey:xAxesKey, modifier:xAxeModifier }
+        }
+        break
+
+      case 'date':
+        for(let i = 1 ; i <= 31 ; i++){
+          reduced[i] = { key:i.toString().padStart(2, '0'), parentKey:xAxesKey, modifier:xAxeModifier }
+        }
+        break
+
+      case 'last60Minutes':
+        let last60Minutes = dayjs()
+        for(let i = 60 ; i > 0 ; i--){
+          const cur = last60Minutes.subtract(i, 'minute').format('YYYYMMDDHHmm00')
+          reduced[cur] = { key:cur, parentKey:xAxesKey, modifier:xAxeModifier }
+        }
+        break
+
+      case 'last12Hours':
+        let last12Hours = dayjs()
+        for(let i = 11 ; i >= 0 ; i--){
+          const cur = last12Hours.subtract(i, 'hour')
+          const key = cur.format('YYYYMMDDHH0000')
+          const alias = cur.format('HH')
+          reduced[key] = { key, alias, parentKey:xAxesKey, modifier:xAxeModifier }
+        }
+        break
+
+      case 'last24Hours':
+        let last24Hours = dayjs()
+        for(let i = 23 ; i >= 0 ; i--){
+          const cur = last24Hours.subtract(i, 'hour')
+          const key = cur.format('YYYYMMDDHH0000')
+          const alias = cur.format('HH')
+          reduced[key] = { key, alias, parentKey:xAxesKey, modifier:xAxeModifier }
+        }
+        break
+
+      default:
+        reduced = items.reduce((acc, item) => {
+
+          let key = item[xAxesKey]
+          switch(params.xAxes[0].modifier){
+
+          }
+
+          acc[key] = { key, parentKey:xAxesKey, modifier:params.xAxes[0].modifier }
+          return acc
+        }, {})
+        break
+
+    }
+
+    xAxes = Object.values(reduced)
+  }
+
+  let yAxes
+  if(params.yAxeMultiple){
+    const yAxesKey = params.yAxes[0].key
+    const reduced = items.reduce((acc, item) => {
+      const key = item[yAxesKey]
+      acc[key] = { key, parentKey:yAxesKey, modifier:params.yAxes[0].modifier }
+      return acc
+    }, {})
+
+    yAxes = Object.values(reduced)
+  }
+  else{
+    yAxes = [ params.yAxes[0] ]
+  }
+
+  const yAxe0Column = params.datasource.columns.find(_ => _.key === params.yAxes[0].key)
+
+  switch(yAxe0Column?.type){
+
+    case 'enum':
+      if(yAxe0Column?.typeParams){
+        yAxes.map(yAxe => {
+          const obj = yAxe0Column?.typeParams.find(_ => _.value === yAxe.key)
+          yAxe.alias = obj?.text ?? yAxe.key
+        })
+      }
+      else if(yAxe0Column?.enumSrc){
+        const [ path, key, name ] = yAxe0Column.enumSrc.split(':')
+        if(typeof opt.enumFn === 'function'){
+          const { items } = await opt.enumFn(path, {}, opt.socket) ?? {}
+
+          if(Array.isArray(items)){
+            const itemsKey = items.reduce((res, cur) => {
+              res[cur[key]] = cur[name]
+              return res
+            }, {})
+
+            yAxes = yAxes.map(yAxe => {
+              yAxe.alias = itemsKey[yAxe.key] ?? yAxe.key
+              return yAxe
+            })
+          }
+        }
+      }
+      break
+
+  }
+
+  let idx = 0
+  const yLegends = []
+
+  const enums = {}
+  for(let xAxe of params.xAxes){
+    const datasourceColumn = columns[xAxe.key]
+    if(datasourceColumn){
+      if(datasourceColumn.type === 'enum'){
+        if(datasourceColumn.typeParams){
+          enums[xAxe.key] = datasourceColumn.typeParams.reduce((res, cur) => {
+            res[cur.value] = cur.text
+            return res
+          }, {})
+        }
+        else if(datasourceColumn.enumSrc){
+          const [ path, key, name ] = datasourceColumn.enumSrc.split(':')
+          if(typeof opt.enumFn === 'function'){
+            const { items } = await opt.enumFn(path, {}, opt.socket) ?? {}
+
+            if(Array.isArray(items)){
+              enums[xAxe.key] = items.reduce((res, cur) => {
+                res[cur[key]] = cur[name]
+                return res
+              }, {})
+            }
+          }
+        }
+      }
+    }
+  }
+
+  for(let yAxe of yAxes){
+
+    let data
+
+    let yAxeItems = items
+
+    if(params.yAxeMultiple){
+      yAxeItems = yAxeItems.filter(_ => _[yAxe.parentKey] === yAxe.key)
+    }
+
+    if(params.xAxeMultiple){
+      data = xAxes.map(_ => {
+        let value
+        switch(yAxe.modifier){
+          case 'count':
+            value = yAxeItems.length
+            break
+
+          case 'sum':
+          default:
+            value = yAxeItems.reduce((acc, item) => {
+              const value = parseFloat(item[params.yAxeMultiple ? _.key : yAxe.key])
+              return acc + (isNaN(value) ? 0 : value)
+            }, 0)
+        }
+
+        return value
+      })
+    }
+    else{
+      data = xAxes.map(_ => {
+
+        let curItems
+        switch(_.modifier){
+          case 'date':
+            curItems = yAxeItems.filter(__ => dayjs(__[_.parentKey]).format('DD') === _.key)
+            break
+
+          case 'month':
+            curItems = yAxeItems.filter(__ => dayjs(__[_.parentKey]).format('MMM') === _.key)
+            break
+
+          case 'year':
+            curItems = yAxeItems.filter(__ => dayjs(__[_.parentKey]).format('YYYY') === _.key)
+            break
+
+          case 'hour':
+            curItems = yAxeItems.filter(__ => dayjs(__[_.parentKey]).format('HH') === _.key)
+            break
+
+          case 'minute':
+            curItems = yAxeItems.filter(__ => dayjs(__[_.parentKey]).format('mm') === _.key)
+            break
+
+          case 'last12Hours':
+          case 'last24Hours':
+            curItems = yAxeItems.filter(__ => dayjs(__[_.parentKey]).format('YYYYMMDDHH0000') === _.key)
+            break
+
+          case 'last60Minutes':
+            curItems = yAxeItems.filter(__ => dayjs(__[_.parentKey]).format('YYYYMMDDHHmm00') === _.key)
+            break
+
+          default:
+            curItems = yAxeItems.filter(__ => __[_.parentKey] === _.key)
+        }
+
+        let value
+        switch(yAxe.modifier){
+          case 'count':
+            value = curItems.length
+            break
+
+          case 'countDistinct':
+            value = curItems.reduce((acc, item) => {
+              if(!acc.includes(item[yAxe.key]))
+                acc.push(item[yAxe.key])
+              return acc
+            }, []).length
+            break
+
+          case 'sum':
+          default:
+            value = curItems.reduce((acc, item) => {
+              const value = parseFloat(item[yAxe.key])
+              return acc + (isNaN(value) ? 0 : value)
+            }, 0)
+        }
+
+        return value
+      })
+    }
+
+    let label = yAxe.key
+    if(params.yAxeMultiple){
+      label = yAxe.alias ?? yAxe.key
+
+      if(columns[yAxe.parentKey]?.type === 'enum'){
+        if(columns[yAxe.parentKey]?.typeParams){
+          const obj = columns[yAxe.parentKey]?.typeParams.find(_ => _.value === label)
+          label = obj?.text ?? label
+        }
+      }
+    }
+
+    datasets.push({
+      label,
+      data,
+      backgroundColor: yAxes.length > 1 ?
+        [ backgroundColors[idx % backgroundColors.length] ]:
+        [ backgroundColors[0] ],
+      borderColor: yAxes.length > 1 ?
+        [ backgroundColors[idx % backgroundColors.length] ]:
+        [ backgroundColors[0] ],
+      borderWidth: 1
+    })
+
+    yLegends.push({
+      key: label ?? '(empty)',
+      color: backgroundColors[idx % backgroundColors.length]
+    })
+
+    idx++
+  }
+
+  labels = xAxes.map(_ => {
+    if(enums[_.parentKey])
+      return enums[_.parentKey][_.key] ?? (_.alias ?? _.key)
+    return _.alias ?? _.key
+  })
+
+  if(datasets.length > 0 && params.yAxeMultiple && params.usePercentage){
+
+    params.datasets = datasets
+
+    const segments = []
+    let segmentMax = -1
+    for(let i in datasets[0].data){
+
+      if(!segments[i])
+        segments[i] = { data:[] }
+
+      for(let j in datasets){
+        segments[i].data.push(datasets[j].data[i])
+      }
+
+      segments[i].max = Math.max(...segments[i].data)
+
+      if(segments[i].max > segmentMax)
+        segmentMax = segments[i].max
+    }
+
+    for(let i in datasets){
+
+      const data0 = []
+      for(let j in datasets[i].data){
+        const multipler = segmentMax / segments[j].max
+        data0.push(datasets[i].data[j])
+        datasets[i].data[j] = ((datasets[i].data[j] * multipler) / segmentMax * 100).toFixed(1)
+      }
+      datasets[i].data0 = data0
+    }
+  }
+
+  if(datasets.length > 500){
+    return { error:1, message:'Too many datasets' }
+  }
+  if(labels > 1000){
+    return { error:1, message:'Too many labels' }
+  }
+
+  return {
+    labels,
+    datasets,
+    yLegends
+  }
+}
+
+const loadMetric = async(params, opt) => {
+
+  const { column, datasource, columnModifier, column2Enabled, column2, column2Modifier } = params
+
+  const res = {
+    value: '',
+    comparedValue: '',
+    comparedPercent: ''
+  }
+
+  if(column){
+
+    let getValue
+    if('items' in params){
+      const { items } = params
+      getValue = async (column, modifier) => {
+        let value
+
+        switch(modifier){
+          case 'count':
+            value = items.length
+            break
+
+          case 'countDistinct':
+            value = items.reduce((acc, item) => {
+              if(item[column] && !acc.includes(item[column]))
+                acc.push(item[column])
+              return acc
+            }, []).length
+            break
+
+          case 'sum':
+            value = items.reduce((acc, item) => {
+              const val = parseFloat(item[column])
+              return acc + (isNaN(val) ? 0 : val)
+            }, 0)
+            break
+
+          case 'avg':
+            value = items.reduce((acc, item) => {
+              const val = parseFloat(item[column])
+              return acc + (isNaN(val) ? 0 : val)
+            }, 0) / items.length
+            break
+
+          case 'min':
+            value = items.reduce((acc, item) => {
+              const val = parseFloat(item[column])
+              return Math.min(acc, isNaN(val) ? Number.MAX_SAFE_INTEGER : val)
+            }, Number.MAX_SAFE_INTEGER)
+
+            if(value === Number.MAX_SAFE_INTEGER)
+              value = ''
+            break
+
+          case 'max':
+            value = items.reduce((acc, item) => {
+              const val = parseFloat(item[column])
+              return Math.max(acc, isNaN(val) ? Number.MIN_SAFE_INTEGER : val)
+            }, Number.MIN_SAFE_INTEGER)
+
+            if(value === Number.MIN_SAFE_INTEGER)
+              value = ''
+            break
+
+          case 'first':
+            value = (items[0] ?? {})[column]
+            break
+
+          case 'last':
+            value = (items[items.length - 1] ?? {})[column]
+            break
+        }
+
+        return value
+      }
+    }
+
+    else{
+      const Model = await getModelFromDatasource(datasource, opt)
+      const config = {
+        columns: datasource.columns
+      }
+      const findOpt = await presetToSequelizeList(datasource, {
+        config,
+        model: Model,
+        conn: opt.conn
+      })
+
+      getValue = async (column, modifier) => {
+        let value
+
+        switch(modifier){
+          case 'count':
+            value = await Model.count({
+              where: findOpt.where,
+              col: column
+            })
+            break
+
+          case 'countDistinct':
+            value = await Model.count({
+              where: findOpt.where,
+              distinct: true,
+              col: column
+            })
+            break
+
+          case 'sum':
+            value = await Model.sum(column, findOpt)
+            break
+
+          case 'avg':
+            const row = await Model.findOne({
+              ...findOpt,
+              attributes: [[fn('AVG', col(column)), 'avg']],
+            });
+            value = row?.dataValues.avg ?
+              round(row.dataValues.avg, 1) :
+              row?.dataValues.avg
+            break
+
+          case 'min':
+            value = await Model.min(column, findOpt)
+            break
+
+          case 'max':
+            value = await Model.max(column, findOpt)
+            break
+
+          case 'first':
+            const first = await Model.findOne({
+              ...findOpt,
+              attributes: [column],
+              order: [[column, 'ASC']]
+            })
+            value = first?.dataValues[column]
+            break
+
+          case 'last':
+            const last = await Model.findOne({
+              ...findOpt,
+              attributes: [column],
+              order: [[column, 'DESC']]
+            })
+            value = last?.dataValues[column]
+            break
+        }
+
+        return value
+      }
+    }
+
+    res.value = await getValue(column, columnModifier)
+    if(column2Enabled){
+      res.comparedValue = await getValue(column2, column2Modifier)
+      res.comparedPercent = round(res.value / res.comparedValue * 100, 1)
+    }
+  }
+
+  return res
+}
+
+const loadDoughnut = async(params, opt) => {
+
+  const { column, columnModifier, rowsModifier, datasource } = params
+
+  const { items } = params
+
+  let rowsEnum = {}
+  const datasourceColumn = datasource?.columns.find(_ => _.key === params.rows)
+  if(datasourceColumn?.type === 'enum'){
+    if(datasourceColumn?.typeParams){
+      rowsEnum = datasourceColumn.typeParams.reduce((res, cur) => {
+        res[cur.value] = cur.text
+        return res
+      }, {})
+    }
+    else if(datasourceColumn?.enumSrc) {
+      const [path, key, name] = datasourceColumn.enumSrc.split(':')
+      if (typeof opt.enumFn === 'function') {
+        const {items} = await opt.enumFn(path, {}, opt.socket) ?? {}
+
+        if (Array.isArray(items)) {
+          rowsEnum = items.reduce((res, cur) => {
+            res[cur[key]] = cur[name]
+            return res
+          }, {})
+        }
+      }
+    }
+  }
+
+  const labels = Object.values(items.reduce((res, cur) => {
+    let label = cur[params.rows]
+
+    let alias = rowsEnum[cur[params.rows]] ?? label
+    switch(rowsModifier){
+      case 'lowercase':
+        alias = label.toString().toLowerCase()
+        break
+
+      case 'uppercase':
+        alias = label.toString().toUpperCase()
+        break
+
+      case 'capitalize':
+        alias = capitalize(label)
+        break
+
+      case 'date':
+        label = alias = dayjs(label).format('DD/MM/YYYY')
+        break
+
+      case 'month':
+        label = alias = dayjs(label).format('MMM')
+        break
+
+      case 'year':
+        label = alias = dayjs(label).format('YYYY')
+        break
+
+      case 'hour':
+        label = alias = dayjs(label).format('HH')
+        break
+
+      case 'minute':
+        label = alias = dayjs(label).format('mm')
+        break
+    }
+
+    res[label] = {
+      label,
+      alias
+    }
+
+    return res
+  }, {}))
+
+  const datasets = []
+
+  const data = labels.map(({ label }) => {
+    const currentItems = items.filter(_ => {
+      switch(rowsModifier){
+
+        case 'date':
+          return dayjs(_[params.rows]).format('DD/MM/YYYY') === label
+
+        case 'month':
+          return dayjs(_[params.rows]).format('MMM') === label
+
+        case 'year':
+          return dayjs(_[params.rows]).format('YYYY') === label
+
+        case 'hour':
+          return dayjs(_[params.rows]).format('HH') === label
+
+        case 'minute':
+          return dayjs(_[params.rows]).format('mm') === label
+
+        default:
+          return _[params.rows] === label
+      }
+    })
+
+    let value
+    switch(columnModifier){
+
+      case 'count':
+        value = currentItems.length
+        break
+
+      case 'countDistinct':
+        value = currentItems.reduce((acc, item) => {
+          if(!acc.includes(item[column]))
+            acc.push(item[column])
+          return acc
+        }, []).length
+        break
+
+      case 'min':
+        value = currentItems.reduce((res, cur) => {
+          let val = parseFloat(cur[column])
+          return Math.min(res, isNaN(val) ? Number.MAX_SAFE_INTEGER : val)
+        })
+        break
+
+      case 'max':
+        value = currentItems.reduce((acc, item) => {
+          return Math.max(acc, item[column])
+        }, Number.MIN_SAFE_INTEGER)
+        break
+
+      case 'first':
+        value = (currentItems[0] ?? {})[column]
+        break
+
+      case 'last':
+        value = (currentItems[items.length - 1] ?? {})[column]
+        break
+
+      case 'sum':
+      default:
+        value = currentItems.reduce((res, cur) => {
+          let val = parseFloat(cur[column])
+          return isNaN(val) ? 0 : val
+        }, 0)
+    }
+
+    return value
+  })
+
+  const backgroundColor = labels.map((_, i) => backgroundColors[i % backgroundColors.length])
+
+  datasets.push({
+    label: column,
+    data: data,
+    backgroundColor,
+    hoverOffset: 4
+  })
+
+  return {
+    labels: labels.map(_ => _.alias),
+    datasets
+  }
+}
+
+const loadPie = async(params, opt) => {
+
+  const { rowsModifier, datasource } = params
+
+  const { items } = params
+
+  let rowsEnum = {}
+  const datasourceColumn = datasource?.columns.find(_ => _.key === params.rows)
+  if(datasourceColumn?.type === 'enum'){
+    if(datasourceColumn?.typeParams){
+      rowsEnum = datasourceColumn.typeParams.reduce((res, cur) => {
+        res[cur.value] = cur.text
+        return res
+      }, {})
+    }
+    else if(datasourceColumn?.enumSrc) {
+      const [path, key, name] = datasourceColumn.enumSrc.split(':')
+      if (typeof opt.enumFn === 'function') {
+        const {items} = await opt.enumFn(path, {}, opt.socket) ?? {}
+
+        if (Array.isArray(items)) {
+          rowsEnum = items.reduce((res, cur) => {
+            res[cur[key]] = cur[name]
+            return res
+          }, {})
+        }
+      }
+    }
+  }
+
+  const labels = Object.values(items.reduce((res, cur) => {
+    let label = cur[params.rows]
+
+    let alias = rowsEnum[cur[params.rows]] ?? label
+    switch(rowsModifier){
+      case 'lowercase':
+        alias = label.toString().toLowerCase()
+        break
+
+      case 'uppercase':
+        alias = label.toString().toUpperCase()
+        break
+
+      case 'capitalize':
+        alias = capitalize(label)
+        break
+
+      case 'date':
+        label = alias = dayjs(label).format('DD/MM/YYYY')
+        break
+
+      case 'month':
+        label = alias = dayjs(label).format('MMM')
+        break
+
+      case 'year':
+        label = alias = dayjs(label).format('YYYY')
+        break
+
+      case 'hour':
+        label = alias = dayjs(label).format('HH')
+        break
+
+      case 'minute':
+        label = alias = dayjs(label).format('mm')
+        break
+    }
+
+    res[label] = {
+      label,
+      alias
+    }
+
+    return res
+  }, {}))
+
+  const datasets = []
+
+  for(let column of params.column){
+
+    const data = labels.map(({ label }) => {
+
+      const currentItems = items.filter(_ => {
+
+        switch(rowsModifier){
+
+          case 'date':
+            return dayjs(_[params.rows]).format('DD/MM/YYYY') === label
+            break
+
+          case 'month':
+            return dayjs(_[params.rows]).format('MMM') === label
+            break
+
+          case 'year':
+            return dayjs(_[params.rows]).format('YYYY') === label
+            break
+
+          case 'hour':
+            return dayjs(_[params.rows]).format('HH') === label
+            break
+
+          case 'minute':
+            return dayjs(_[params.rows]).format('mm') === label
+            break
+
+          default:
+            return _[params.rows] === label
+        }
+      })
+
+      let value
+      switch(column.modifier){
+
+        case 'count':
+          value = currentItems.length
+          break
+
+        case 'countDistinct':
+          value = currentItems.reduce((acc, item) => {
+            if(!acc.includes(item[column.key]))
+              acc.push(item[column.key])
+            return acc
+          }, []).length
+          break
+
+        case 'min':
+          value = currentItems.reduce((res, cur) => {
+            let val = parseFloat(cur[column.key])
+            return Math.min(res, isNaN(val) ? Number.MAX_SAFE_INTEGER : val)
+          })
+          break
+
+        case 'max':
+          value = currentItems.reduce((acc, item) => {
+            return Math.max(acc, item[column.key])
+          }, Number.MIN_SAFE_INTEGER)
+          break
+
+        case 'first':
+          value = (currentItems[0] ?? {})[column.key]
+          break
+
+        case 'last':
+          value = (currentItems[items.length - 1] ?? {})[column.key]
+          break
+
+        case 'sum':
+        default:
+          value = currentItems.reduce((res, cur) => {
+            let val = parseFloat(cur[column.key])
+            return isNaN(val) ? 0 : val
+          }, 0)
+      }
+
+      return value
+    })
+
+    const backgroundColor = labels.map((_, i) => backgroundColors[i % backgroundColors.length])
+
+    datasets.push({
+      label: column.label ?? column.key,
+      data: data,
+      backgroundColor,
+      hoverOffset: 4
+    })
+
+    if(!params.multipleValues)
+      break
+  }
+
+  return {
+    labels: labels.map(_ => _.alias),
+    datasets
+  }
+}
+
+const loadPolarArea = async(params, opt) => {
+  return loadDoughnut(params, opt)
+}
+
+const loadVirtualTable = async(params, opt) => {
+
+  const res = await getDatasourceItems({
+    ...params.datasource,
+    sorts: [
+      { key:'id', type:'asc' }
+    ]
+  }, opt)
+
+  let { items, hasNext } = res
+  let { datasourceColumns } = params
+
+  items = items.map(item => {
+    const obj = {}
+
+    for(let column of datasourceColumns){
+      if(column.visible || [ 'id' ].includes(column.key)){
+        obj[column.key] = item[column.key]
+      }
+    }
+
+    return obj
+  })
+
+  return {
+    items,
+    hasNext
+  }
+}
+
+const loadGHeatMaps = async(params, opt) => {
+  return {
+    items: params.items
+  }
+}
+
+
+module.exports = {
+  getModelFromDatasource,
+  getDatasourceItems,
+  getSequelizeColumns,
+
+  backgroundColors,
+
+  loadBarChart,
+  loadMetric,
+  loadDoughnut,
+  loadPie,
+  loadPolarArea,
+  loadVirtualTable,
+  loadGHeatMaps
+}