@mixd-id/web-scaffold 0.2.240705 → 0.2.250801009

package/src/utils/dashboard.js

@@ -65,7 +65,27 @@ const getModelFromDatasource = async (datasource, opt) => {
   }
 }
 
+const getDatasourceItems = async (datasource, opt) => {
+
+  const Model = await getModelFromDatasource(datasource, opt)
+  const config = {
+    columns: datasource.columns
+  }
+  const findOpt = await presetToSequelizeList(datasource, {
+    config,
+    model: Model,
+    conn: opt.conn,
+    limit: 100
+  })
+
+  return await Model.findAll({
+    ...findOpt,
+    raw: true
+  })
+}
+
 const getSequelizeColumns = async (columns, opt) => {
+  if(!columns) columns = []
 
   const { DataTypes } = opt.Sequelize
 
@@ -103,965 +123,6 @@ const getSequelizeColumns = async (columns, opt) => {
   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,
@@ -1070,11 +131,10 @@ module.exports = {
 
   backgroundColors,
 
-  loadBarChart,
+  /*loadBarChart,
   loadMetric,
   loadDoughnut,
   loadPie,
   loadPolarArea,
-  loadVirtualTable,
-  loadGHeatMaps
+  loadVirtualTable*/
 }