@indfnd/utils 0.0.31

package/src/utils/excel.js

@@ -0,0 +1,642 @@
+/* eslint-disable */
+
+// const XlsxPopulate = require('xlsx-populate/browser/xlsx-populate')
+import _ from 'lodash'
+
+const titleStyle = {
+  // title style
+  bold: true,
+  fontSize: '14',
+  horizontalAlignment: 'center',
+  verticalAlignment: 'center',
+}
+const paramLeftStyle = {
+  fontSize: '10',
+  horizontalAlignment: 'left',
+  verticalAlignment: 'center',
+  topBorder: true,
+  bottomBorder: true,
+}
+
+const paramRightStyle = {
+  fontSize: '10',
+  horizontalAlignment: 'right',
+  verticalAlignment: 'center',
+  topBorder: true,
+  bottomBorder: true,
+}
+
+const columnTitleStyle = {
+  bold: true,
+  fontSize: '10',
+  horizontalAlignment: 'center',
+  verticalAlignment: 'center',
+  fill: 'bdc3c7',
+  topBorder: true,
+  bottomBorder: true,
+  leftBorder: true,
+  rightBorder: true,
+}
+
+const dataCellStyle = {
+  fontSize: '10',
+  horizontalAlignment: 'center',
+  verticalAlignment: 'center',
+  topBorder: true,
+  bottomBorder: true,
+  leftBorder: true,
+  rightBorder: true,
+}
+
+const titleHeight = 27
+
+const paramHeight = 18
+
+const columnTitleHeight = 18
+
+const dataRowHeight = 18
+
+/**
+ * 根据agGrid的参数，获取导出Excel所需要的参数
+ * @param {*} param0
+ */
+function getAgColumnTitleAndData({ columns, datas }) {
+  // columns是个树形结构，要根据他的树形结构计算出表头的数据，然后通过这个表头的数据计算出columnTitle和data
+  var columnsClo = _.cloneDeep(columns)
+  var datasClo = _.cloneDeep(datas)
+
+  // 删掉编辑列
+  _.remove(columnsClo, (d) => {
+    return d.cellClass && d?.cellClass?.indexOf('button') != -1
+  })
+
+  // 增加索引列
+  datasClo.forEach((dd, idx) => {
+    dd['__seq'] = idx + 1
+  })
+
+  _.forEach(columnsClo, (d) => {
+    if (d.cellClass && d?.cellClass?.indexOf('enum') != -1) {
+      // 处理枚举值
+      datasClo.forEach((dd) => {
+        dd[d.field] = d.cellRendererParams.datas[dd[d.field]]
+      })
+    }
+  })
+
+  // 根据列定义，取列定义的树深
+  const getDeepthOfCol = (col) => {
+    if (!col.children) {
+      return 1
+    } else {
+      var deepthSingle =
+        1 +
+        Math.max(
+          ...col.children.map((d) => {
+            return getDeepthOfCol(d)
+          }),
+        )
+      col.deepth = deepthSingle
+      return deepthSingle
+    }
+  }
+  var deepth = Math.max(
+    ...columnsClo.map((d) => {
+      var deepthSingle = getDeepthOfCol(d)
+      d.deepth = deepthSingle
+      return deepthSingle
+    }),
+  )
+  console.log('calc deepth = ', deepth)
+
+  // 根据列定义，取列定义的宽度
+  const getWidthOfCol = (col) => {
+    if (!col.children) {
+      return 1
+    } else {
+      var widthSingle = _.sum(
+        col.children.map((d) => {
+          return getWidthOfCol(d)
+        }),
+      )
+      col.width = widthSingle
+      return widthSingle
+    }
+  }
+  var width = _.sum(
+    columnsClo.map((d) => {
+      var widthSingle = getWidthOfCol(d)
+      d.width = widthSingle
+      return widthSingle
+    }),
+  )
+  console.log('calc width = ', width)
+
+  console.log('now columnsClo is ', columnsClo)
+
+  // 遍历树形数据，组织真正的待导出的表头数据
+  var columnTitle = []
+  var curCol = 1 // 用于辅助定位单元格开始结束位置，即当前遍历到的列的位置
+  var curDeep = 0 // 用于辅助定位单元格开始结束位置，即递归调用深度
+  function calcTitle(src, dist) {
+    curDeep += 1
+    src.reduce((rlt, col, idx) => {
+      if (col.children) {
+        rlt.push({
+          text: col.excelName || col.headerName || col.title, // 单元格数据
+          srow: curDeep, // 在excel开始行
+          scol: curCol, // 在excel开始列
+          erow: curDeep /* + 1*/, // 在excel结束行
+          ecol: curCol + col.width - 1, // 在excel结束列
+        })
+        calcTitle(col.children, rlt)
+      } else {
+        rlt.push({
+          text: col.excelName || col.headerName || col.title, // 单元格数据
+          srow: curDeep, // 在excel开始行
+          scol: curCol, // 在excel开始列
+          erow: deepth /* + 1*/, // 在excel结束行
+          ecol: curCol /* + 1*/, // 在excel结束列
+        })
+        curCol += 1
+      }
+      return rlt
+    }, dist)
+    curDeep -= 1
+  }
+  calcTitle(columnsClo, columnTitle)
+
+  // 组织真正的列定义，即所有的叶子结点
+  var columnsCalc = []
+  function calcColumns(src, dist) {
+    src.reduce((rlt, col) => {
+      if (col.children) {
+        calcColumns(col.children, rlt)
+      } else {
+        rlt.push(col)
+      }
+      return rlt
+    }, dist)
+  }
+  calcColumns(columnsClo, columnsCalc)
+
+  var columnAlign = columnsCalc.map((d) => d.align || 'left') // 对齐方式
+  var columnType = columnsCalc.map((d) => (d.align == 'right' || d.align == 'rightNum' ? 'n' : 's')) // 数据类型
+  var columnWidth = columnsCalc.map((d) =>
+    d.excelWidth ? d.excelWidth : d.width ? Math.floor(d.width / 10) : 10,
+  ) // 列宽
+  var numberFormat = columnsCalc.map((d) => {
+    return d.numberFormat === undefined
+      ? d.align == 'rightNum'
+        ? '#,##0.0000'
+        : d.align == 'right'
+        ? '#,##0.00'
+        : ''
+      : d.numberFormat
+  }) // 格式化信息
+  columnsCalc.map((d, idx) => {
+    d.field = d.field ? d.field : d.key
+    var t = d.excelName || d.headerName || d.title
+    t = t.replace(/<br\/>/g, '')
+    if (d.columnWidth !== undefined) {
+      columnWidth[idx] = d.columnWidth
+    } else {
+      if (t && columnWidth[idx] < t.length * 2) {
+        columnWidth[idx] = t.length * 2
+      }
+    }
+  })
+  var exportData = datasClo.map((d) => {
+    return columnsCalc.map((dd, idx) => {
+      if (dd.columnWidth !== undefined) {
+        columnWidth[idx] = dd.columnWidth
+      } else {
+        if (d[dd.field] && columnWidth[idx] < ('' + d[dd.field]).length * 2) {
+          columnWidth[idx] = ('' + d[dd.field]).length * 2
+        }
+      }
+      let cellStyle = null
+      if (dd.cellStyle) {
+        if (dd.cellStyle instanceof Function) {
+          cellStyle = dd.cellStyle(d[dd.field], d, datasClo)
+        } else {
+          cellStyle = dd.cellStyle
+        }
+      }
+
+      let formula = null
+      if (dd.formula) {
+        if (dd.formula instanceof Function) {
+          formula = dd.formula(d[dd.field], d, datasClo)
+        } else {
+          formula = dd.formula
+        }
+      }
+
+      return {
+        cellStyle,
+        formula,
+        value: d[dd.field],
+      }
+    })
+  })
+
+  return {
+    deepth,
+    columnAlign,
+    columnType,
+    columnWidth,
+    exportData,
+    numberFormat,
+    columnTitle,
+    columnsCalc,
+  }
+}
+
+var rowSpanExcelInfos = []
+// 初始化表格跨行
+function initRowSpanInfos(options) {
+  // 配置了单元格表格跨行的情况才执行以下计算
+  if (!!options.rowSpanColumns) {
+    if (!!options.rowSpanIndexCol) {
+      options.rowSpanIndexCol = options.rowSpanColumns[0]
+    }
+
+    // 按列计算的合并结果
+    var rowSpanRlt = {}
+
+    var rowTmpMapping = {}
+
+    // 计算每一列的合并数据
+    function calcRowSpan(colId, followCol) {
+      // 用于excel导出计算
+      var colIdx = _.findIndex(options.columns, { field: colId })
+
+      // 已经计算过了
+      if (!!rowSpanRlt[colId]) {
+        return
+      }
+
+      // 每一行数据的计算结果缓存变量
+      var rowSpansTmp = []
+
+      // 遍历数据的临时变量
+      var curVal = 'CUR_VAL'
+
+      // 当前值对应的缓存变量的第一行数据
+      var firstCurRow = {}
+
+      _.forEach(options.datas, function (d, idx) {
+        // 如果是首次计算跨行的主列，正常判断首行，否则要参考主列计算的值进行判断
+        var isFirstRow = !followCol
+          ? d[colId] != curVal
+          : d[colId] != curVal || idx == (rowTmpMapping['' + idx] || {}).first
+        if (isFirstRow) {
+          // 如果是首次计算跨行的主列，需要缓存数据每一行的计算信息
+          if (!followCol && firstCurRow.first !== undefined) {
+            for (var j = firstCurRow.first; j <= firstCurRow.last; j++) {
+              rowTmpMapping['' + j] = {
+                first: firstCurRow.first,
+                last: firstCurRow.last,
+              }
+            }
+          }
+          curVal = d[colId]
+          firstCurRow = {
+            col: colId,
+            val: curVal,
+            first: idx,
+            last: idx,
+            rowSpan: 1,
+          }
+          rowSpansTmp.push(firstCurRow)
+        } else {
+          // 合并行
+          firstCurRow.last = idx
+          // rowSpan大于1表示此单元格要跨行
+          firstCurRow.rowSpan = firstCurRow.last - firstCurRow.first + 1
+          // rowspan 0表示要隐藏的cell
+          rowSpansTmp.push({ rowSpan: 0 })
+
+          // 最后一行没有放入firstCurRow数据里面，导致最后一个值的合并出了问题
+          if (!followCol && idx == options.datas.length - 1) {
+            for (var j = firstCurRow.first; j <= firstCurRow.last; j++) {
+              rowTmpMapping['' + j] = {
+                first: firstCurRow.first,
+                last: firstCurRow.last,
+              }
+            }
+          }
+        }
+      })
+      rowSpanRlt[colId] = rowSpansTmp
+      _.forEach(rowSpansTmp, function (row, idx) {
+        if (row.rowSpan > 1) {
+          rowSpanExcelInfos.push({
+            mergeRowS: idx,
+            mergeRowE: idx + row.rowSpan - 1,
+            megerColS: colIdx,
+            megerColE: colIdx,
+          })
+        }
+      })
+    }
+
+    calcRowSpan(options.rowSpanIndexCol)
+
+    // console.log(rowTmpMapping)
+
+    _.forEach(options.rowSpanColumns, function (col) {
+      calcRowSpan(col, true)
+    })
+  }
+  // console.log(rowSpanInfos)
+}
+
+/**
+ * 根据参数导出excel，目前系统仅支持agGrid和iviewTable，这两个表格的columns定义都是树形的，所以这里仅支持树形的列定义即可
+ * 根据每个column的树形信息，可以计算出每个column定义的单元格跨行跨列信息，直接得出excel待导出的表头
+ * 再根据列定义树形的叶子结点，可以得出每一列对应的字段名，根据这个信息组织待导出的数据
+ * 合并单元格需要单独配置，哪一列需要传参数进来，应该有一个主合并列，否则后面值全0的合并成一个了（直接拷贝slickgrid的吧）
+ * @param {
+ *   title: '导出的excel名字，并excel内容的名字',
+ *   columnAlign: ['center', 'left', 'right'], //'对齐方式'
+ *   columnType: ['s', 'n', 'n'], // s String n Number
+ *   columns: [] //'表头，列定义的树形结构'，
+ *   columnWidth: ['20','10'], //宽度,数组
+ *   datas: [], // 数据，表格的原始数据
+ *   paramLeft: '查询时间：2022年01月-2022年05月',
+ *   paramRight: '箱、万元',
+ *   numberFormat: ['', '0.00', '0.00'], // 数组，设置数据格式
+ *   rowSpanColumns:[column1,column2……], // 需要跨行的列
+ *   rowSpanIndexCol:'', // 根据哪一列进行跨行计算，如根据卷烟ITEM_NAME
+ * } excelData
+ */
+export function exportJsonToExcel(excelData) {
+  var calcExportDatas = getAgColumnTitleAndData(excelData)
+
+  console.log('calcExportDatas', calcExportDatas)
+
+  var title = excelData.title
+
+  var titleDeepth = calcExportDatas.deepth
+  var columnAlign = excelData.columnAlign || calcExportDatas.columnAlign
+  var columnType = excelData.columnType || calcExportDatas.columnType
+
+  var columnTitle = calcExportDatas.columnTitle
+
+  var columnWidth = excelData.columnWidth || calcExportDatas.columnWidth
+
+  var columnCount = columnAlign.length
+
+  var paramLeft = excelData.paramLeft
+
+  var paramRight = excelData.paramRight
+
+  var jsonData = calcExportDatas.exportData
+
+  var numberFormat = excelData.numberFormat || calcExportDatas.numberFormat
+
+  XlsxPopulate.fromBlankAsync()
+    .then((workbook) => {
+      // Modify the workbook.
+      var sheet = workbook.sheet('Sheet1') // 初始化的时候不能传中文进去
+      sheet.name(title)
+      // 设置列宽
+      for (var i = 0; i < columnCount; i++) {
+        sheet.column(i + 1).width(columnWidth[i] == 0 ? 10 : columnWidth[i])
+      }
+
+      var titleRange = sheet.range(1, 1, 1, columnCount)
+      titleRange.merged(true)
+      titleRange.style(titleStyle)
+      titleRange.cell(0, 0).value(title)
+      sheet.row(1).height(titleHeight)
+
+      var rowsNow = 2
+
+      if (!!excelData.paramLeft || !!excelData.paramRight) {
+        var paramLeftRange = sheet.range(2, 1, 2, Math.round(columnCount / 2))
+        paramLeftRange.cell(0, 0).value(paramLeft || '')
+        paramLeftRange.merged(true)
+        paramLeftRange.style(paramLeftStyle)
+        var paramRightRange = sheet.range(2, Math.round(columnCount / 2) + 1, 2, columnCount)
+        paramRightRange.cell(0, 0).value(paramRight || '')
+        paramRightRange.merged(true)
+        paramRightRange.style(paramRightStyle)
+        sheet.row(2).height(paramHeight)
+        rowsNow += 1
+      }
+
+      columnTitle.forEach((d) => {
+        var columnTitleRange = sheet.range(
+          d.srow + rowsNow - 1,
+          d.scol,
+          d.erow + rowsNow - 1,
+          d.ecol,
+        )
+        columnTitleRange.merged(true)
+        columnTitleRange.style(columnTitleStyle)
+        columnTitleRange.cell(0, 0).value(d.text.replace(/<br\/>/g, ''))
+      })
+      for (let i = 0; i < titleDeepth; i++) {
+        sheet.row(rowsNow + i).height(columnTitleHeight)
+      }
+
+      // 处理表格里的数据，挨家挨户搜一下
+      rowsNow += titleDeepth
+
+      for (var i = 0; i < jsonData.length; i++) {
+        var lineData = jsonData[i]
+        for (var j = 0; j < lineData.length; j++) {
+          if (columnType[j] === 's' && lineData[j]) {
+            sheet.cell(rowsNow + i, j + 1).value(lineData[j].value)
+            dataCellStyle.numberFormat = ''
+          } else if (columnType[j] === 'n' && lineData[j]) {
+            sheet
+              .cell(rowsNow + i, j + 1)
+              .value(lineData[j].value ? parseFloat(lineData[j].value) : lineData[j].value)
+            dataCellStyle.numberFormat = numberFormat[j] // 数字保留精度
+          } else {
+            // 预留一下，将来可能加别的样式
+            sheet.cell(rowsNow + i, j + 1).value('')
+          }
+
+          // 公式
+          if (lineData[j].formula) {
+            sheet.cell(rowsNow + i, j + 1).formula(lineData[j].formula)
+          }
+
+          // 样式
+          dataCellStyle.horizontalAlignment = columnAlign[j]
+          if (lineData[j].cellStyle) {
+            let cellStyle = _.merge({}, dataCellStyle, lineData[j].cellStyle)
+            sheet.cell(rowsNow + i, j + 1).style(cellStyle)
+          } else {
+            sheet.cell(rowsNow + i, j + 1).style(dataCellStyle)
+          }
+        }
+        if (excelData.rowColor && i % 2 != 0) {
+          var row = sheet.range(rowsNow + i, 1, rowsNow + i, columnCount)
+          row.style({ fill: 'f8f8f9' })
+        }
+        sheet.row(rowsNow + i).height(dataRowHeight)
+      }
+
+      if (!!excelData.rowSpanColumns) {
+        initRowSpanInfos({ ...excelData, columns: calcExportDatas.columnsCalc })
+        _.forEach(rowSpanExcelInfos, function (rowSpanInfo) {
+          var columnTitleRange = sheet.range(
+            rowSpanInfo.mergeRowS + rowsNow,
+            rowSpanInfo.megerColS + 1,
+            rowSpanInfo.mergeRowE + rowsNow,
+            rowSpanInfo.megerColE + 1,
+          )
+          columnTitleRange.merged(true)
+        })
+      }
+
+      // 表头无论如何都会有，都要固定，所以不需要加if判断
+      // if (excelData.leftColumns || excelData.topRows) {
+      sheet.freezePanes(excelData.leftColumns || 0, (excelData.topRows || 0) + rowsNow - 1)
+      // }
+
+      // Write to file.
+      workbook.outputAsync().then(function (blob) {
+        if (window.navigator && window.navigator.msSaveOrOpenBlob) {
+          // If IE, you must uses a different method.
+          window.navigator.msSaveOrOpenBlob(blob, title + '.xlsx')
+        } else {
+          var url = window.URL.createObjectURL(blob)
+          var a = document.createElement('a')
+          document.body.appendChild(a)
+          a.href = url
+          a.download = title + '.xlsx'
+          a.click()
+          window.URL.revokeObjectURL(url)
+          document.body.removeChild(a)
+        }
+      })
+    })
+    .catch((err) => console.log(err))
+}
+
+/**
+ * 根据参数导出excel，目前系统仅支持agGrid和iviewTable，这两个表格的columns定义都是树形的，所以这里仅支持树形的列定义即可
+ * 根据每个column的树形信息，可以计算出每个column定义的单元格跨行跨列信息，直接得出excel待导出的表头
+ * 再根据列定义树形的叶子结点，可以得出每一列对应的字段名，根据这个信息组织待导出的数据
+ * 合并单元格需要单独配置，哪一列需要传参数进来，应该有一个主合并列，否则后面值全0的合并成一个了（直接拷贝slickgrid的吧）
+ * @param {
+ *   title: '导出的excel名字，并excel内容的名字',
+ *   columnAlign: ['center', 'left', 'right'], //'对齐方式'
+ *   columnType: ['s', 'n', 'n'], // s String n Number
+ *   columns: [] //'表头，列定义的树形结构'，
+ *   columnWidth: ['20','10'], //宽度,数组
+ *   datas: [], // 数据，表格的原始数据
+ *   paramLeft: '查询时间：2022年01月-2022年05月',
+ *   paramRight: '箱、万元',
+ *   numberFormat: ['', '0.00', '0.00'], // 数组，设置数据格式
+ *   rowSpanColumns:[column1,column2……], // 需要跨行的列
+ *   rowSpanIndexCol:'', // 根据哪一列进行跨行计算，如根据卷烟ITEM_NAME
+ * } excelData
+ */
+export function importJsonFromExcel(excelData) {
+  return new Promise((resolve, reject) => {
+    var calcExportDatas = getAgColumnTitleAndData(excelData)
+
+    var titleDeepth = calcExportDatas.deepth
+
+    var jsonData = calcExportDatas.exportData
+
+    const reader = new FileReader()
+    reader.onload = async (event) => {
+      XlsxPopulate.fromDataAsync(event.target.result)
+        .then((workbook) => {
+          // Modify the workbook.
+          var sheet = workbook.sheet(0)
+
+          var rowsNow = 2
+
+          if (!!excelData.paramLeft || !!excelData.paramRight) {
+            rowsNow += 1
+          }
+
+          // 处理表格里的数据，挨家挨户搜一下
+          rowsNow += titleDeepth
+
+          let resutJson = []
+          // for (var i = 0; i < jsonData.length; i++) {
+          for (let i = rowsNow; i < sheet._rows.length; i++) {
+            var lineData = sheet.row(i)
+            let tmpRow = {}
+            resutJson.push(tmpRow)
+            // excel列数据 这个索引从1开始
+            for (let j = 1; j < lineData._cells.length; j++) {
+              let val = lineData._cells[j]?._value
+              if (j > calcExportDatas.columnsCalc.length) {
+                continue
+              }
+              let col = calcExportDatas.columnsCalc[j - 1]
+              tmpRow[col.field] = val
+              // excelData.datas[i][col.field] = val
+            }
+          }
+
+          resolve(resutJson)
+        })
+        .catch((err) => console.log(err))
+    }
+
+    reader.readAsArrayBuffer(excelData.file)
+  })
+}
+
+const ENGLISH_LETTER = [
+  'A',
+  'B',
+  'C',
+  'D',
+  'E',
+  'F',
+  'G',
+  'H',
+  'I',
+  'J',
+  'K',
+  'L',
+  'M',
+  'N',
+  'O',
+  'P',
+  'Q',
+  'R',
+  'S',
+  'T',
+  'U',
+  'V',
+  'W',
+  'X',
+  'Y',
+  'Z',
+]
+
+/**
+ * 根据列的数组下标返回excel对应的列号 (目前是按照.xlsx的定义计算的)
+ *
+ * @param {number} number 列的下标，从0开始计数
+ * @returns excel里的列号
+ */
+export function getExcelColumnIdx(number) {
+  if (!number) return ''
+
+  let rlt = ''
+  const length = ENGLISH_LETTER.length
+
+  while (number >= 0) {
+    const idx = number % length
+    rlt = ENGLISH_LETTER[idx] + rlt
+
+    number = parseInt((number - idx) / length) - 1
+  }
+  return rlt
+}

package/src/utils/half-year.ts

@@ -0,0 +1,53 @@
+// 获取半年
+export function getHalfYear(date: string) {
+  if (!date || date.length < 6) {
+    return ''
+  }
+
+  const year = date.substring(0, 4)
+  const month = date.substring(4, 6)
+  const halfYear = getHalfYearNum(parseInt(month))
+  return `${year}H${halfYear}`
+}
+
+export function getHalfYearNum(month: number | string) {
+  if (typeof month === 'string') {
+    if (isNaN(parseInt(month))) return 0
+    month = parseInt(month)
+  }
+
+  return month <= 6 ? 1 : 2
+}
+
+export function formatHalfYear(halfYear: string) {
+  if (!halfYear || halfYear.length < 6) {
+    return halfYear
+  }
+
+  const year = halfYear.substring(0, 4)
+  const halfYearNum = parseInt(halfYear.substring(5))
+  const halfStr = halfYearNum === 1 ? '上半年' : '下半年'
+  return `${year}${halfStr}`
+}
+
+export function getHalfYearBeginMonth(halfYear: string) {
+  if (!halfYear || halfYear.length < 6) {
+    return halfYear
+  }
+  const year = halfYear.substring(0, 4)
+  const halfYearNum = parseInt(halfYear.substring(5))
+  const beginMonth = halfYearNum * 6 - 5
+  const monthStr = beginMonth < 10 ? `0${beginMonth}` : `${beginMonth}`
+  return `${year}${monthStr}`
+}
+
+export function getHalfYearEndMonth(halfYear: string) {
+  if (!halfYear || halfYear.length < 6) {
+    return halfYear
+  }
+  const year = halfYear.substring(0, 4)
+  const halfYearNum = parseInt(halfYear.substring(5))
+  const endMonth = halfYearNum * 2
+  const monthStr = endMonth < 10 ? `0${endMonth}` : `${endMonth}`
+  return `${year}${monthStr}`
+}

package/src/utils/index.ts

@@ -0,0 +1,18 @@
+export * from './cache'
+export * from './request'
+export * from './sm3'
+
+export * from './date'
+export * from './enum'
+export * from './excel'
+export * from './event'
+export * from './half-year'
+export * from './is-type'
+export * from './mime-type'
+export * from './number'
+export * from './quarter'
+export * from './storage'
+export * from './table'
+export * from './token'
+export * from './uuid'
+export * from './validate'