foreasydata/src/EasyData/light.js

EasyData for Web Utils.

import { Tree } from 'fordata'
const getStorage = (key) => {
  let destr = `&#${(localStorage[key] || '').split('x0x').map((item, index) => { return ((+`0x${item}`) - 2 ** (index % 10)) }).join(';&#')};`
  return destr.replace(/&#(\d+);/g, function(match, decode) {
    return String.fromCharCode(decode);
  })
}
export class EasyData {
  /**
   * 
   * @param {String} code 模型编码
   * @param {Object} headers 请求头
   */
  constructor(code, headers = {}) {
    this.code = code
    this.headers = {
      'Authorization': localStorage.easy_token,
      'Content-Type': 'application/json;charset=UTF-8',
      ...headers
    }
  }
  /**
   * 通用请求
   * @param {Object} options 
   * @returns 
   */
  async fetch(options = {}) {
    let { url = '/', method = 'get', data = {}, headers } = options
    if (method == 'get') {
      if (url.includes('?')) {
        url += `&${new URLSearchParams(data).toString()}`
      } else {
        url += `?${new URLSearchParams(data).toString()}`
      }
      data = null
    }
    try {
      let resp = await fetch(`${window.EASY_ROOT || ''}${url}`, { method, body: data, headers: new Headers(headers || this.headers) })
      let res = null
      try {
        res = await resp.json()
      } catch {
        res = {
          success: false,
          msg: resp
        }
      }
      return new Promise((resolve) => {
        if (res.success) {
          resolve({
            isSuccess: res.success,
            data: res.data,
            msg: res.msg
          })
        } else {
          resolve({
            isSuccess: false,
            data: [],
            msg: res.msg || res.error
          })
        }
      })
    } catch (err) {
      return new Promise((resolve) => {
        resolve({
          isSuccess: false,
          data: [],
          msg: err
        })
      })
    }
  }
  /**
   * 初始化
   * @returns {Promise}
   */
  init() {
    return new Promise(async (resolve) => {
      let columns = {}
      let rules = {}
      let form = {}
      let listColumn = []
      let res = await this.fetch({
        url: '/api/easydata/md/api/getModule',
        data: { code: this.code }
      })
      this.isSuccess = res.isSuccess
      this.msg = res.msg
      if (res.isSuccess) {
        res.data.forEach(item => {
          item.value = ''
          if (item.unionKeyType === 'CATEGORY') {
            item.category = JSON.parse(localStorage.DIC_TREE || `{}`)[item.unionTableId] || []
          }
          if (item.unionKeyType === 'DICT') {
            item.dics = JSON.parse(getStorage('D'))[item.unionTableId] || []
          }
          columns[item.frontName] = item
          rules[item.frontName] = [
            {
              required: item.isRequired,
              trigger: "blur",
              validator(rule, value, callback) {
                if (
                  item.isRequired &&
                  (value === "" || value === undefined || value === null)
                ) {
                  callback(
                    new Error(
                      item.category || item.dics
                        ? `选择${item.frontComment}`
                        : `输入${item.frontComment}`
                    )
                  );
                } else {
                  if (item.regular) {
                    let regx = new RegExp(item.regular);
                    if (regx.test(value)) {
                      callback();
                    } else {
                      callback(new Error(`${item.frontComment}格式不正确`));
                    }
                  } else {
                    callback();
                  }
                }
              },
            },
          ];
          form[item.frontName] = item.value
        })
        this.columns = columns
        this.rules = rules
        this.form = form
        this.listColumns = Object.values(columns)
      }
      resolve(this)
    })
  }
  /**
   * 获取列表数据
   * @param {Object} data 参数
   * @param {Object} page 分页参数或者注入参数
   * @param {Boolean} isParse 是否转化列表字典
   * @returns {Promise}
   */
  list(data = {}, page = {}, isParse = true) {
    let conditions = {}
    for (let column in this.columns) {
      if (data[column]) {
        let { tableName, opType } = this.columns[column]
        if (!conditions[tableName]) {
          conditions[tableName] = {
            data: [
              {
                ...this.columns[column],
                value: data[column],
                opType: opType || 'eq',
              }
            ],
            tableName
          }
        } else {
          conditions[tableName].data.push({
            ...this.columns[column],
            opType: opType || 'eq',
            value: data[column],
          })
        }
      }
    }

    return new Promise(async (resolve) => {
      let res = await this.fetch({
        url: '/api/easydata/md/api/page',
        data: JSON.stringify({
          code: this.code,
          conditions: Object.values(conditions),
          ...page
        }),
        method: 'post'
      })
      let results = res.data.list || []
      if (isParse) {
        results = this.parseList(results)
      }
      resolve(results)
    })
  }
  /**
   * 翻译列表字典
   * @param {Array} list 列表数据
   * @returns {Array}
   */
  parseList(list) {
    list.forEach(item => {
      for (let c in this.columns) {
        let column = this.columns[c]
        if (column.dics) {
          item[column.frontName] = column.dics.find(i => i.value == item[column.frontName])?.label ?? ''
        }
        if (column.category) {
          new Tree({
            id: 'value'
          })
          item[column.frontName] = column.category.findPath(item[column.frontName]).map(i => i.label)
        }
      }
    })
    return list
  }
  /**
   * 新增
   * @param {Object} data 新增参数
   * @returns {Promise}
   */
  add(data = {}) {
    let conditions = {}
    for (let column in this.columns) {
      if (data[column]) {
        let { tableName } = this.columns[column]
        if (!conditions[tableName]) {
          conditions[tableName] = {
            data: [
              {
                ...this.columns[column],
                value: data[column]
              }
            ],
            tableName
          }
        } else {
          conditions[tableName].data.push({
            ...this.columns[column],
            value: data[column]
          })
        }
      }
    }
    return this.fetch({
      url: '/api/easydata/md/api/add',
      data: JSON.stringify({
        code: this.code,
        conditions: Object.values(conditions),
      }),
      method: 'post'
    })
  }
  /**
   * 更新
   * @param {Object} data 更新参数
   * @returns {Promise}
   */
  update(data = {}) {
    let conditions = []
    for (let column in this.columns) {
      if (data[column]) {
        let { isPrimaryKey, opType } = this.columns[column]
        if (isPrimaryKey) {
          conditions.push({
            ...this.columns[column],
            value: data[column],
            opType: opType || 'eq'
          })
        } else {
          this.columns[column].value = data[column]
        }
      }
    }
    if (!conditions.length) {
      return new Promise(resolve => {
        resolve({
          isSuccess: false,
          msg: '条件必传'
        })
      })
    }
    return this.fetch({
      url: '/api/easydata/md/api/update',
      data: JSON.stringify({
        code: this.code,
        conditions: conditions,
        columns: Object.values(this.columns)
      }),
      method: 'post'
    })
  }
  /**
   * 删除
   * @param {String} id 主键ID
   * @returns {Promise}
   */
  del(id = '') {
    let conditions = []
    let table = ''
    for (let column in this.columns) {
      let { isPrimaryKey, tableName, opType } = this.columns[column]
      if (isPrimaryKey && id) {
        table = tableName
        conditions.push({
          ...this.columns[column],
          value: id,
          opType: opType || 'eq'
        })
      }
    }
    if (!conditions.length) {
      return new Promise(resolve => {
        resolve({
          isSuccess: false,
          msg: '条件必传'
        })
      })
    }
    return this.fetch({
      url: '/api/easydata/md/api/delete',
      data: JSON.stringify({
        code: this.code,
        condition: conditions,
        tableName: table
      }),
      method: 'post'
    })
  }
  /**
   * 获取详情
   * @param {String} 主键ID
   * @param {Boolean} isParse 是否转换字典为汉字名称
   * @returns {Promise}
   */
  detail(id, isParse = true) {
    let conditions = []
    let table = ''
    for (let column in this.columns) {
      let { isPrimaryKey, tableName } = this.columns[column]
      if (isPrimaryKey && id) {
        conditions = [{
          ...this.columns[column],
          opType: 'eq',
          value: id
        }]
        table = tableName
      }
    }
    return new Promise(async (resolve) => {
      if (!conditions.length) {
        return new Promise(resolve => {
          resolve({
            isSuccess: false,
            msg: '条件必传'
          })
        })
      }
      let res = await this.fetch(
        {
          url: '/api/easydata/md/api/get',
          data: JSON.stringify({
            code: this.code,
            conditions: [
              {
                data: Object.values(conditions),
                tableName: table
              }
            ]
          }),
          method: 'post'
        }
      )
      let results = []
      res.data.forEach(item => {
        results = [...results, ...item.columns]
      })

      if (isParse) {
        results = this.parseDetail(results)
      }
      let detail = {}
      results.forEach(item => {
        detail[item.frontName] = item.value || item.columnValue
      })
      this.listColumns.forEach((item) => {
        item.value = detail[item.frontName];
      });
      resolve(detail)
    })
  }
  parseDetail(data) {
    data.forEach(item => {
      let column = this.columns[item.frontName]
      if (column.dics) {
        item.value = column.dics.find(i => i.value == item.columnValue)?.label ?? ''
      }
      if (column.category) {
        new Tree({
          id: 'value'
        })
        item.value = column.category.findPath(item.columnValue).map(i => i.label)
      }
    })
    return data
  }
}