mm_os 3.3.1 → 4.0.1

package/com/sql/drive.js

@@ -0,0 +1,1259 @@
+const Item = require('mm_machine').Drive;
+const Excel = require('mm_excel');
+
+/**
+ * Sql操作驱动类
+ * @augments {Item}
+ * @class
+ */
+class Drive extends Item {
+  static config = {
+    'main': '',
+    // 表名 {0} 代表可前端传参自定义查询的表
+    'table': '{0}',
+    // 主键 用于水平连表查询时 例如：id
+    'key': '',
+    // 排序 {0} 代表可前台传参自定义排序规则 格式: `name` asc, `id` desc
+    'orderby': '{0}',
+    // 默认排序 `id` desc
+    'orderby_default': '',
+    // 显示的字段 {0} 代表可前台传参自定义查询的字段, 例如: `id`,`username`,`name`,`email`
+    'field': '{0}',
+    // 默认显示字段 例如： `id`,`username`,`name`
+    'field_default': '*',
+    // 隐藏字段 有些字段即使前端请求也不能返回，这是通过隐藏字段将其过滤掉, 例如：password *表示包含匹配
+    'field_hide': ['*password*', '*token*', 'salt'],
+    // 分页大小，默认一页显示条数
+    'page_size': 30,
+    /* 过滤参数 */
+    'filter': {
+      /**
+       * 表名
+       */
+      'table': 'table',
+      /**
+       * 查询的页码
+       */
+      'page': 'page',
+      /**
+       * 查询每页条数
+       */
+      'size': 'size',
+      /**
+       * 操作方式: 传入参数method=add, 支持参数 add增、del删、set改、get查，为空则为get
+       */
+      'method': 'method',
+      /**
+       * 排序
+       */
+      'orderby': 'orderby',
+      /**
+       * 查询显示的字段
+       */
+      'field': 'field',
+      /**
+       * 统计结果: 统计符合条件的结果数，只有当page等于1或0时才会统计
+       */
+      'count_ret': 'count_ret'
+    },
+    // 分隔符 用于查询时的多条件处理
+    'separator': '|',
+    // 支持的方法 add增、del删、set改、get查, 只填get表示只支持查询 // import export del_repeat",
+    'method': 'add del set get get_obj import export del_repeat avg sum count update',
+    // sql查询语句
+    'query': {},
+    // 默认查询, 当查询条件中不包含该项时，默认添加该项。 例如: { "age": "`age` < 20" } , 当查询参含有age，不调用该项，不存在时，sql会增加该项
+    'query_default': {},
+    // sql更改语句
+    'update': {},
+    // 默认添加条件，当不包含该项时，默认添加该项。 例如: { "age": "`age` += 1" } , 当查询参含有age，不调用该项，不存在时，sql会增加该项
+    'body_default': {},
+    // 参数 []
+    'params': null,
+    // 格式
+    'format': [
+      /* {
+        // 表名，当选择转换方式 表转换时需填写
+        "table": "mm_web_region",
+        // 查询条件，用于加速转换
+        "query": {
+          "group": "市"
+        },
+        // 表标题名
+        "title": "所属省份",
+        // 转换ID
+        "id": "province_id",
+        // 转换主键
+        "key": "province",
+        // 取名
+        "name": "name",
+        // 列表
+        "list": [{
+            "province_id": 1,
+            "name": "广东省"
+          },
+          {
+            "province_id": 2,
+            "name": "广西省"
+          },
+          {
+            "province_id": 3,
+            "name": "湖南省"
+          }
+        ]
+      },
+      {
+        "title": "是否可见",
+        "key": "show",
+        "list": ["否", "是"]
+      } */
+    ],
+    /* 去重 */
+    'del_repeat': {
+      // 判断重复的字段，例如字段名 number
+      'groupBy': '',
+      // 排序方式 例如： `diJia` ASC
+      'orderBy': ''
+    },
+    /* 逻辑符 */
+    'logic': {},
+    // 输出sql语句 
+    'log': false
+  };
+
+
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   * @param {object} parent 父对象
+   * @class
+   */
+  constructor(config, parent) {
+    super({ ...Drive.config, ...config }, parent);
+    // 默认启用热更新
+    this.mode = 3;
+  }
+}
+
+/**
+ * 获取模板目录
+ * @returns {string} 模板目录
+ */
+Drive.prototype._getTplDir = function () {
+  return __dirname;
+};
+
+/**
+ * 预设
+ */
+Drive.prototype._preset = function () {
+  // 保存文件目录
+  this.save_dir = './static/file/';
+  // 读取文件目录
+  this.url_path = '/file/';
+  /* 通用项 */
+  this.params = null;
+};
+
+/**
+ * 执行前, 可用于过滤参数
+ * @param {object} params 参数对象 (object) 包含query和body 如{ query, body }
+ * @param {object} db 数据库管理器
+ * @returns {object} 过滤后的参数
+ */
+Drive.prototype.before = async function (params, db) {
+  return params;
+};
+
+/**
+ * 验证, 用于判断是否执行
+ * @param {object} params 参数对象 (object) 包含query和body
+ * @param {object} db 数据管理器
+ * @returns {boolean} 验证通过返回true, 失败返回false
+ */
+Drive.prototype.check = async function (params, db) {
+  return true;
+};
+
+/**
+ * 执行后, 可用于附加执行
+ * @param {object} params 参数对象 (object) 包含query和body
+ * @param {object} db 数据管理器
+ * @returns {object} 最终执行结果
+ */
+Drive.prototype.after = async function (params, db) {
+  return db.ret;
+};
+
+/**
+ * 更新缓存
+ * @param {string} table 表名
+ * @param {object} sql 缓存sql语句
+ */
+Drive.prototype.updateCache = async function (table, sql) {
+
+};
+
+/**
+ * @ 执行修改
+ * @param {object} query 查询url参数
+ * @param {object} body 修改时置入body的参数
+ * @param {object} db 数据库管理器
+ * @returns {object} 返回执行结果
+ */
+Drive.prototype.run = async function (query, body, db) {
+  var params = {
+    query,
+    body
+  };
+  params = await this.before(params, db);
+  if (this.check(params, db)) {
+    var ret = await this.main(params, db);
+    if (!ret.error) {
+      db.ret = ret;
+      return await this.after(params, db);
+    } else {
+      return ret;
+    }
+  }
+  return null;
+};
+
+
+/**
+ * SQL操作准备
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询条件
+ * @param {object} body 修改项
+ * @returns {object} 返回准备参数
+ */
+Drive.prototype.ready = function (db, query, body) {
+  var cg = this.config;
+  var qy = { ...query };
+  $.push(db.config.filter, cg.filter, true);
+  db.filter(qy);
+  return {
+    cg,
+    qy
+  };
+};
+
+/**
+ * 转为查询条件字符串
+ * @param {object} db 数据库管理器
+ * @param {object} query 查寻条件
+ * @param {object} method 方法
+ * @returns {string} 返回查询条件
+ */
+Drive.prototype.toWhere = function (db, query, method) {
+  var { cg, qy: originalQy } = this.ready(db, query, {});
+  // 创建 qy 对象的副本，避免修改原始参数
+  var qy = { ...originalQy };
+  this._setDbConfig(db, cg, query);
+  qy = this._setQueryField(db, query, cg, method, qy);
+  qy = this._setOrderBy(db, query, cg, qy);
+  return this._buildQueryString(db, qy, cg);
+};
+
+/**
+ * 设置数据库配置
+ * @param {object} db 数据库管理器
+ * @param {object} cg 配置
+ * @param {object} query 查询条件
+ * @private
+ */
+Drive.prototype._setDbConfig = function (db, cg, query) {
+  db.config.separator = cg.separator;
+  if (!query.size && cg.page_size) {
+    db.size = cg.page_size + 0;
+  }
+  if (db.size > 0 && db.page === 0) {
+    db.page = 1;
+  }
+};
+
+/**
+ * 设置查询字段
+ * @param {object} db 数据库管理器
+ * @param {object} query 查询条件
+ * @param {object} cg 配置
+ * @param {object} method 方法
+ * @param {object} qy 查询条件对象
+ * @returns {object} 更新后的查询条件对象
+ * @private
+ */
+Drive.prototype._setQueryField = function (db, query, cg, method, qy) {
+  var f = db.config.filter;
+  var field = query[f.field];
+  if (cg.field.has('*{0}*')) {
+    if (field) {
+      db.field = cg.field.replace('{0}', field);
+    } else if (method === 'get_obj' && cg.field_obj) {
+      db.field = cg.field_obj + '';
+    } else if (cg.field_default) {
+      db.field = cg.field_default + '';
+    }
+  } else {
+    db.field = cg.field + '';
+    if (field) {
+      return { ...qy, [f.field]: field };
+    }
+  }
+  return qy;
+};
+
+/**
+ * 设置排序方式
+ * @param {object} db 数据库管理器
+ * @param {object} query 查询条件
+ * @param {object} cg 配置
+ * @param {object} qy 查询条件对象
+ * @returns {object} 更新后的查询条件对象
+ * @private
+ */
+Drive.prototype._setOrderBy = function (db, query, cg, qy) {
+  var f = db.config.filter;
+  var orderby = query[f.orderby];
+  if (cg.orderby.has('*{0}*')) {
+    if (orderby) {
+      db.orderby = cg.orderby.replace('{0}', orderby);
+    } else if (cg.orderby_default) {
+      db.orderby = cg.orderby_default + '';
+    }
+  } else {
+    db.orderby = cg.orderby + '';
+    if (orderby) {
+      return { ...qy, [f.orderby]: orderby };
+    }
+  }
+  return qy;
+};
+
+/**
+ * 构建查询字符串
+ * @param {object} db 数据库管理器
+ * @param {object} qy 查询条件对象
+ * @param {object} cg 配置
+ * @returns {string} 查询字符串
+ * @private
+ */
+Drive.prototype._buildQueryString = function (db, qy, cg) {
+  var query_str = db.tplQuery(qy, cg.query);
+  var qt = cg.query_default;
+  if (Object.keys(qt).length > 0) {
+    var id = $.dict.user_id;
+    var id_key = '{' + id + '}';
+    var user_id = '0';
+    var user = db.user;
+    if (user && user[id]) {
+      user_id = user[id];
+    }
+    for (var k in qt) {
+      if (!qy[k]) {
+        query_str += ' && ' + qt[k].replaceAll(id_key, user_id);
+      }
+    }
+    if (query_str.startsWith(' && ')) {
+      query_str = query_str.replace(' && ', '');
+    }
+  }
+  return query_str;
+};
+
+/**
+ * 查询(主要)
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询条件
+ * @param {object} method 方法
+ * @returns {object} 返回查询结果
+ */
+Drive.prototype.getMain = async function (db, query, method) {
+  var ret;
+  if (this.config.field.has('*{0}*')) {
+    var field = query[db.config.filter.field];
+    if (field && this.config.field_hide.getMatch(field)) {
+      return $.ret.error(70003, '不合法的查询参数');
+    }
+  }
+  var query_str = this.toWhere(db, query, method);
+
+  // 查询
+  if (db.count_ret === 'true') {
+    ret = $.ret.body(await db.getCountSql(query_str, db.orderby, db.field));
+  } else {
+    ret = $.ret.list(await db.getSql(query_str, db.orderby, db.field));
+  }
+  return ret;
+};
+
+/**
+ * 查询
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询条件
+ * @param {object} body 修改项
+ * @returns {object} 返回查询结果
+ */
+Drive.prototype.get = async function (db, query, body) {
+  return await this.getMain(db, query);
+};
+
+/**
+ * 查询单条数据
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询条件
+ * @param {object} body 修改项
+ * @returns {object} 返回查询结果
+ */
+Drive.prototype.getObj = async function (db, query, body) {
+  var qy = { ...query };
+  qy.page = 1;
+  qy.size = 1;
+  var ret = await this.getMain(db, qy, 'get_obj');
+  if (ret.result) {
+    var list = ret.result.list;
+    if (list.length > 0) {
+      return $.ret.obj(list[0]);
+    } else {
+      return $.ret.obj(null);
+    }
+  }
+  return ret;
+};
+
+/**
+ * 修改(主要)
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询条件
+ * @param {object} body 修改项
+ * @returns {object} 返回修改结果
+ */
+Drive.prototype.setMain = async function (db, query, body) {
+  var ret;
+  var {
+    cg,
+    qy
+  } = this.ready(db, query, body);
+  var key = cg.key;
+  if (body[key]) {
+    qy[key] = body[key];
+  }
+  var query_str = db.tplQuery(qy, cg.query);
+
+  var qt = cg.query_default;
+  if (Object.keys(qt).length > 0) {
+    var id = $.dict.user_id;
+    var id_key = '{' + id + '}';
+    var user_id = '0';
+    var user = db.user;
+    if (user && user[id]) {
+      user_id = user[id];
+    }
+    for (var k in qt) {
+      if (!qy[k]) {
+        query_str += ' && ' + qt[k].replace(id_key, user_id);
+      }
+    }
+    if (query_str.startsWith(' && ')) {
+      query_str = query_str.replace(' && ', '');
+    }
+  }
+
+  var n = await db.setSql(query_str, db.tplBody(body, cg.update));
+
+  if (n < 1) {
+    ret = $.ret.error(500, '修改失败！\n' + db.error.message);
+  } else {
+    ret = $.ret.bl(true, '修改成功！');
+  }
+  return ret;
+};
+
+
+/**
+ * 修改
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询条件
+ * @param {object} body 修改项
+ * @returns {object} 返回查询结果
+ */
+Drive.prototype.set = async function (db, query, body) {
+  return await this.setMain(db, query, body);
+};
+
+/**
+ * 添加(主要)
+ * @param {object} db 数据库操作类
+ * @param {object} body 添加项
+ * @returns {object} 返回查询结果
+ */
+Drive.prototype.addMain = async function (db, body) {
+  var ret;
+  var cg = this.config;
+  if (Object.keys(body).length > 0) {
+    var bt = cg.body_default;
+    if (Object.keys(bt).length > 0) {
+      var id = $.dict.user_id;
+      var id_key = '{' + id + '}';
+      var user_id = '0';
+      var user = db.user;
+      if (user && user[id]) {
+        user_id = user[id];
+      }
+      for (var k in bt) {
+        if (!body[k]) {
+          var str = bt[k].replace(id_key, user_id);
+          var key = str.left('=').trim('`');
+          body[key] = str.right('=').trim("'");
+        }
+      }
+    }
+    var n = await db.add(body);
+    if (n < 1) {
+      ret = $.ret.error(500, '添加失败！\n' + db.error.message);
+    } else {
+      ret = $.ret.bl(true, '添加成功！');
+    }
+  } else {
+    ret = $.ret.error(30001, '参数不能为空');
+  }
+  if (cg.log) {
+    this.log('debug', '添加SQL语句', db.sql);
+  }
+  return ret;
+};
+
+/**
+ * 添加
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询条件
+ * @param {object} body 修改项
+ * @returns {object} 返回添加结果
+ */
+Drive.prototype.add = async function (db, query, body) {
+  return await this.addMain(db, body);
+};
+
+/**
+ * 删除(主要)
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询条件
+ * @returns {object} 返回查询结果
+ */
+Drive.prototype.delMain = async function (db, query) {
+  var ret;
+  var {
+    cg,
+    qy
+  } = this.ready(db, query, {});
+  var query_str = db.tplQuery(qy, cg.query);
+  var bl = await db.delSql(query_str);
+  if (bl < 1) {
+    ret = $.ret.error(500, '删除失败！\n' + db.error.message);
+  } else {
+    ret = $.ret.bl(true, '删除成功！');
+  }
+  if (cg.log) {
+    this.log('debug', '删除SQL语句', db.sql);
+  }
+  return ret;
+};
+
+/**
+ * 删除
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询条件
+ * @param {object} body 修改项
+ * @returns {object} 返回删除结果
+ */
+Drive.prototype.del = async function (db, query, body = {}) {
+  return await this.delMain(db, { ...query, ...body });
+};
+
+/**
+ * 添加或修改(主要)
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询条件
+ * @param {object} body 修改项
+ * @returns {object} 返回修改结果
+ */
+Drive.prototype.addorsetMain = async function (db, query, body) {
+  var ret;
+  var {
+    cg,
+    qy
+  } = this.ready(db, query, body);
+  if (Object.keys(body).length > 0 && Object.keys(qy).length > 0) {
+    var n = await db.addOrSet(qy, body);
+    if (n < 1) {
+      ret = $.ret.error(500, '操作失败！\n' + db.error.message);
+    } else {
+      ret = $.ret.bl(true, '操作成功！');
+    }
+  } else {
+    ret = $.ret.error(30001, '参数不能为空');
+  }
+  if (cg.log) {
+    this.log('debug', '添加或修改SQL语句', db.sql);
+  }
+  return ret;
+};
+
+/**
+ * 添加或修改
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询条件
+ * @param {object} body 修改项
+ * @returns {object} 返回查询结果
+ */
+Drive.prototype.addOrSet = async function (db, query, body) {
+  return await this.addOrSetMain(db, query, body);
+};
+
+/**
+ * 获取数据类型
+ * @param {string} data_type 数据类型
+ * @returns {string} 返回数据类型
+ */
+Drive.prototype.getType = function (data_type) {
+  if (data_type.indexOf('int') !== -1) {
+    return 'number';
+  } else {
+    return 'string';
+  }
+};
+
+/**
+ * 获取数据
+ * @param {object} db 数据库操作类
+ * @param {string} field 要获取的字段
+ * @returns {Array} 返回参数信息列表
+ */
+Drive.prototype.getParam = async function (db, field) {
+  var cg = this.config;
+  if (cg.params) {
+    return cg.params;
+  }
+  if (this.params) {
+    return this.params;
+  }
+  var lt = await this._getFieldsFromCache(cg);
+  if (!lt.length) {
+    lt = await this._getFieldsFromDb(db, cg);
+  }
+  return this._filterFields(lt, field, cg);
+};
+
+/**
+ * 从缓存获取字段列表
+ * @param {object} cg 配置
+ * @returns {Array} 字段列表
+ * @private
+ */
+Drive.prototype._getFieldsFromCache = function (cg) {
+  var lt = [];
+  if ($.pool.db) {
+    var pool = $.pool.db['sys'];
+    if (pool) {
+      var dt = pool.get(cg.table);
+      if (dt && dt.config) {
+        var list = dt.config.fields;
+        for (var i = 0; i < list.length; i++) {
+          var name = list[i].replace(/`/g, '');
+          lt.push({ name, title: name });
+        }
+      }
+    }
+  }
+  return lt;
+};
+
+/**
+ * 从数据库获取字段列表
+ * @param {object} db 数据库操作类
+ * @param {object} cg 配置
+ * @returns {Array} 字段列表
+ * @private
+ */
+Drive.prototype._getFieldsFromDb = async function (db, cg) {
+  var lt = [];
+  db.table = cg.table;
+  var list = await db.fields();
+  for (var i = 0; i < list.length; i++) {
+    var o = list[i];
+    var name = o.name;
+    var note = o.note ? o.note.replace(':', '：') : name;
+    lt.push({
+      name,
+      title: note.left('：', true),
+      type: this.getType(o.type)
+    });
+  }
+  return lt;
+};
+
+/**
+ * 过滤字段
+ * @param {Array} lt 字段列表
+ * @param {string} field 字段筛选
+ * @param {object} cg 配置
+ * @returns {Array} 过滤后的字段列表
+ * @private
+ */
+Drive.prototype._filterFields = function (lt, field, cg) {
+  var fields = field || cg.field_default;
+  if (fields && fields !== '*') {
+    var arr = fields.replace(/`/g, '').split(',');
+    return arr.map(name => lt.getObj({ name })).filter(obj => obj);
+  }
+  return lt;
+};
+
+/**
+ * 获取导入导出格式
+ * @param {object} db 数据库操作类
+ * @returns {Array} 格式列表
+ */
+Drive.prototype.getFormat = async function (db) {
+  var dbs = { ...db };
+  dbs.size = 0;
+  var fmt = this.config.format;
+  for (var i = 0; i < fmt.length; i++) {
+    var o = fmt[i];
+    if (o.table) {
+      if (!o.list || o.list.length == 0) {
+        dbs.table = o.table;
+        if (!o.id) {
+          o.id = o.key;
+        }
+        o.list = await dbs.getSql(o.where, null, o.id + ',' + o.name);
+        if (o.id !== o.key) {
+          for (var j = 0; j < o.list.length; j++) {
+            var m = o.list[j];
+            m[o.key] = m[o.name];
+          }
+        }
+      }
+    }
+  }
+  return fmt;
+};
+
+/**
+ * 导入数据(主要)
+ * @param {object} db 数据库操作类
+ * @param {string} filename 文件名
+ * @returns {object} 返回导入结果
+ */
+Drive.prototype.importMain = async function (db, filename) {
+  var params = await this.getParam(db);
+  var format = await this.getFormat(db);
+  var file = this._processFilePath(filename);
+  if (!file.hasFile()) {
+    return $.ret.error(30001, file + '文件不存在！');
+  }
+  var jarr = await this._loadImport(file, params, format);
+  if (!jarr || !jarr.length) {
+    return $.ret.error(10000, '要导入的数据不能为空!');
+  }
+  var result = await this._importToDb(db, jarr);
+  return this._buildImport(result);
+};
+
+/**
+ * 处理文件路径
+ * @param {string} filename 文件名
+ * @returns {string} 处理后的文件路径
+ * @private
+ */
+Drive.prototype._processFilePath = function (filename) {
+  var file = filename;
+  if (file.indexOf($.run_path) !== 0) {
+    file = file.replace(this.url_path, this.save_dir);
+    var path = this._getPath();
+    file = file.fullname(path);
+  }
+  return file;
+};
+
+/**
+ * 加载导入数据
+ * @param {string} file 文件路径
+ * @param {Array} params 参数列表
+ * @param {Array} format 格式列表
+ * @returns {Array} 数据数组
+ * @private
+ */
+Drive.prototype._loadImport = async function (file, params, format) {
+  if (file.ends('.json')) {
+    return file.loadJson();
+  } else if (file.ends('.xml')) {
+    return file.loadXml();
+  } else {
+    var excel = new Excel({ file, params, format });
+    try {
+      return await excel.load();
+    } catch (e) {
+      this.log('error', '导入文件', e);
+    } finally {
+      excel.clear();
+      excel = null;
+    }
+  }
+  return [];
+};
+
+/**
+ * 导入数据到数据库
+ * @param {object} db 数据库操作类
+ * @param {Array} jarr 数据数组
+ * @returns {object} 导入结果
+ * @private
+ */
+Drive.prototype._importToDb = async function (db, jarr) {
+  var list = [];
+  var errors = [];
+  var list_error = [];
+  db.table = db.table || this.config.table;
+  var key = this.config.key;
+  if (jarr[0][key]) {
+    for (var i = 0; i < jarr.length; i++) {
+      var o = jarr[i];
+      var qy = {};
+      qy[key] = o[key];
+      var n = await db.addOrSet(qy, o);
+      if (n < 1) {
+        errors.push(db.error);
+        list_error.push(o);
+      } else {
+        list.push(o);
+      }
+    }
+  } else {
+    for (var i = 0; i < jarr.length; i++) {
+      var o = jarr[i];
+      var n = await db.add(o);
+      if (n < 1) {
+        errors.push(db.error);
+        list_error.push(o);
+      } else {
+        list.push(o);
+      }
+    }
+  }
+  return { list, errors, list_error, total: jarr.length };
+};
+
+/**
+ * 构建导入结果
+ * @param {object} result 导入结果数据
+ * @returns {object} 返回结果对象
+ * @private
+ */
+Drive.prototype._buildImport = function (result) {
+  var bl = result.list.length === result.total;
+  var body = $.ret.bl(bl, bl ? '导入成功!' : '导入失败!');
+  body.result.list = result.list;
+  if (result.errors.length) {
+    body.result.list_error = result.list_error;
+    body.result.errors = result.errors;
+  }
+  return body;
+};
+
+
+/**
+ * 导入数据
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询条件
+ * @param {object} body 导入设置
+ * @returns {object} 返回执行结果
+ */
+Drive.prototype.import = async function (db, query, body) {
+  var params = { ...query, ...body };
+  if (!params.file) {
+    return $.ret.error(60000, '文件名（file）参数不能为空');
+  }
+  return await this.importMain(db, params.file);
+};
+
+/**
+ * 导出数据(主要)
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询参数
+ * @param {object} body 正文参数（导出设置）
+ * @property {string} body.fields 需要导出的字段 例如: `username`,`gm`,`vip`
+ * @property {string} body.file 文件名 例如: 用户名.xlsx 、用户信息.csv 、用户账户.xls
+ * @property {string} body.path 文件路径 例如: /static/download, 可不填写
+ * @returns {object} 返回执行结果
+ */
+Drive.prototype.exportMain = async function (db, query, body) {
+  var by = await this.getMain(db, query);
+  if (db.error) {
+    return $.ret.error(10000, db.error.message);
+  }
+  var config = this._prepareExportConfig(query, body);
+  var params = await this.getParam(db, config.fields);
+  var format = await this.getFormat(db);
+  var file = await this._saveExportFile(config.file, params, format, by.result.list);
+  return this._buildExport(file, config.name);
+};
+
+/**
+ * 准备导出配置
+ * @param {object} query 查询参数
+ * @param {object} body 正文参数
+ * @returns {object} 导出配置
+ * @private
+ */
+Drive.prototype._prepareExportConfig = function (query, body) {
+  var path = body.path;
+  var file = body.file;
+  var fields = body.fields;
+  var table = $.dict.table || this.config.table;
+  if (!path) {
+    path = this._getPath();
+  }
+  if (!file) {
+    var date = new Date();
+    file = this.save_dir + table + '_' + date.stamp() + '.xlsx';
+  }
+  if (!fields) {
+    fields = query.field || (this.config.field_default !== '*' ? this.config.field_default : '');
+  }
+  return { path, file, fields, name: file.split('/').pop() };
+};
+
+/**
+ * 获取路径
+ * @returns {string} 导出路径
+ * @private
+ */
+Drive.prototype._getPath = function () {
+  return $.config.get('user_path') || $.config.get('static_path') || './static/';
+};
+
+/**
+ * 保存导出文件
+ * @param {string} file 文件路径
+ * @param {Array} params 参数列表
+ * @param {Array} format 格式列表
+ * @param {Array} list 数据列表
+ * @returns {string} 保存后的文件路径
+ * @private
+ */
+Drive.prototype._saveExportFile = async function (file, params, format, list) {
+  var export_path = this._getPath();
+  var save_file = file.fullname(export_path);
+  save_file.addDir();
+  var excel = new Excel({ file: save_file, params, format });
+  try {
+    return await excel.save(list);
+  } catch (e) {
+    this.log('error', '导出保存文件失败！', e);
+  } finally {
+    excel.clear();
+    excel = null;
+  }
+  return '';
+};
+
+/**
+ * 构建导出结果
+ * @param {string} file 文件路径
+ * @param {string} name 文件名
+ * @returns {object} 导出结果
+ * @private
+ */
+Drive.prototype._buildExport = function (file, name) {
+  var body = $.ret.bl(!!file, file ? '导出成功!' : '导出失败!');
+  body.result.file = file;
+  body.result.url = this.url_path + name;
+  return body;
+};
+
+/**
+ * 导出数据
+ * @param {object} db 数据库操作类
+ * @param {object} query 查询条件
+ * @param {object} body 修改项
+ * @returns {object} 返回执行结果
+ */
+Drive.prototype.export = async function (db, query, body) {
+  return await this.exportMain(db, query, body);
+};
+
+/**
+ * 删除重复项（主要）
+ * @param {object} db 数据库管理器
+ * @param {object} params 查询参数
+ * @returns {object} 返回执行结果
+ */
+Drive.prototype.delRepeatMain = async function (db, params) {
+  var pm = { ...params };
+  var msg = '';
+  var cg = this.config.del_repeat;
+  var order_by = pm.orderby || cg.orderBy;
+  delete pm.orderby;
+  var group_by = pm.groupby || cg.groupBy;
+  delete pm.groupby;
+  var f = db.config.filter;
+  // 设置查询字段
+  var field = pm[f.field] || group_by;
+  delete pm[f.field];
+  db.field = field;
+  var sql = db.toGetSql(pm).replace(' * ', ' `' + field + '`, count(*) as len ');
+  sql += ` GROUP BY ${group_by}`;
+  sql = 'SELECT * FROM (' + sql + ') a WHERE len > 1';
+  var list = await db.run(sql);
+  if (list.length) {
+    db.page = 1;
+    db.size = 1;
+    var key = this.config.key;
+    for (var i = 0; i < list.length; i++) {
+      var o = list[i];
+      var len = o.len - 1;
+      delete o.len;
+      for (var n = 0; n < len; n++) {
+        var obj = await db.getObj(o, order_by, key);
+        if (obj) {
+          await db.del(obj);
+        }
+      }
+    }
+  } else {
+    msg = '没有重复项。';
+  }
+  return $.ret.bl(!msg, msg ? '去重失败!原因：' + msg : '去重成功!');
+};
+
+/**
+ * 删除重复项
+ * @param {object} db 数据库管理器
+ * @param {object} query 查询条件
+ * @param {object} body 正文参数
+ * @returns {object} 返回执行结果
+ */
+Drive.prototype.delRepeat = async function (db, query, body) {
+  var pm = { ...query, ...body };
+  return await this.delRepeatMain(db, pm);
+};
+
+/**
+ * 执行模板操作
+ * @param {object} params 参数对象 (object) 包含query和body
+ * @param {object} db 数据管理器
+ * @returns {object} 返回执行结果
+ */
+Drive.prototype.main = async function (params, db) {
+  var {
+    query,
+    body
+  } = params;
+
+  var cg = this.config;
+  var method = query.method;
+
+  if (!method) {
+    method = 'get';
+  }
+  if (!cg.method.has('*' + method + '*')) {
+    return $.ret.error(50001, '不支持的操作方式');
+  }
+  method = this._getMethodName(method);
+  var qy = { ...query };
+  delete qy.method;
+  if (this[method]) {
+    db.method = method;
+
+    // 过滤查询参数
+    var f = cg.filter;
+    var table = query[f.table];
+
+    // 设置操作的数据表
+    if (cg.table.has('*{0}*')) {
+      if (table) {
+        db.table = cg.table.replace('{0}', table);
+      } else {
+        return $.ret.error(30001, '表名不能为空');
+      }
+    } else {
+      db.table = cg.table + '';
+    }
+
+    return await this[method](db, qy, { ...body });
+  } else {
+    return $.ret.error(50001, '不支持的操作方式');
+  }
+};
+
+/**
+ * 获取方法名
+ * @param {string} method 方法名
+ * @returns {string} 方法名
+ * @private
+ */
+Drive.prototype._getMethodName = function (method) {
+  if (!method) {
+    return '';
+  }
+  if (method.indexOf('_') == -1) {
+    return method;
+  }
+  // 将小写蛇形改为小驼峰
+  let arr = method.split('_');
+  let new_name = arr[0].toLowerCase();
+  for (let i = 1; i < arr.length; i++) {
+    let name = arr[i];
+    new_name += name.charAt(0).toUpperCase() + name.substring(1);
+  }
+  return new_name;
+};
+
+/**
+ * 总计
+ * @param {object} db 数据库管理器
+ * @param {object} param 查询条件
+ * @returns {object} 返回执行结果
+ */
+Drive.prototype.sumMain = async function (db, param) {
+  var pm = { ...param };
+  var ret;
+  var orderby = pm.orderby || '';
+  delete pm.orderby;
+  var groupby = pm.groupby;
+  delete pm.groupby;
+  var f = db.config.filter;
+  var field = pm[f.field];
+  delete pm[f.field];
+  var query_str = this.toWhere(db, pm, 'get_list');
+
+  if (!groupby || !field) {
+    ret = $.ret.error(30000, '参数groupby、field是必须的，且值不能为空！');
+  } else {
+    var list = await db.groupSumSql(query_str, groupby, field, orderby);
+    if (!list.length && db.error) {
+      ret = $.ret.body(db.error);
+    } else {
+      ret = $.ret.list(list);
+    }
+  }
+  return ret;
+};
+
+/**
+ * 总计
+ * @param {object} db 数据库管理器
+ * @param {object} query 查询条件
+ * @param {object} body 正文参数
+ * @returns {object} 返回执行结果
+ */
+Drive.prototype.sum = async function (db, query, body) {
+  var pm = { ...query, ...body };
+  return await this.sumMain(db, pm);
+};
+
+/**
+ * 平均值
+ * @param {object} db 数据库管理器
+ * @param {object} param 查询条件
+ * @returns {object} 返回执行结果
+ */
+Drive.prototype.avgMain = async function (db, param) {
+  var pm = { ...param };
+  var ret;
+  var orderby = pm.orderby || '';
+  delete pm.orderby;
+  var groupby = pm.groupby;
+  delete pm.groupby;
+  var f = db.config.filter;
+  var field = pm[f.field];
+  delete pm[f.field];
+  var query_str = this.toWhere(db, pm, 'get_list');
+
+  if (!groupby || !field) {
+    ret = $.ret.error(30000, '参数groupby、field是必须的，且值不能为空！');
+  } else {
+    var list = await db.groupAvgSql(query_str, groupby, field, orderby);
+    if (!list.length && db.error) {
+      ret = $.ret.body(db.error);
+    } else {
+      ret = $.ret.list(list);
+    }
+  }
+  return ret;
+};
+
+/**
+ * 平均值
+ * @param {object} db 数据库管理器
+ * @param {object} query 查询条件
+ * @param {object} body 正文参数
+ * @returns {object} 返回执行结果
+ */
+Drive.prototype.avg = async function (db, query, body) {
+  var pm = { ...query, ...body };
+  return await this.avgMain(db, pm);
+};
+
+/**
+ * 总计
+ * @param {object} db 数据库管理器
+ * @param {object} param 查询条件
+ * @returns {object} 返回执行结果
+ */
+Drive.prototype.countMain = async function (db, param) {
+  var pm = { ...param };
+  var ret;
+  var orderby = pm.orderby || '';
+  delete pm.orderby;
+  var groupby = pm.groupby;
+  delete pm.groupby;
+  var f = db.config.filter;
+  var field = pm[f.field];
+  delete pm[f.field];
+  var query_str = this.toWhere(db, pm, 'get_list');
+
+  if (!groupby || !field) {
+    ret = $.ret.error(30000, '参数groupby、field是必须的，且值不能为空！');
+  } else {
+    var list = await db.groupCountSql(query_str, groupby, field, orderby);
+    if (!list.length && db.error) {
+      ret = $.ret.body(db.error);
+    } else {
+      ret = $.ret.list(list);
+    }
+  }
+  return ret;
+};
+
+/**
+ * 总计
+ * @param {object} db 数据库管理器
+ * @param {object} query 查询条件
+ * @param {object} body 正文参数
+ * @returns {object} 返回执行结果
+ */
+Drive.prototype.count = async function (db, query, body) {
+  var pm = { ...query, ...body };
+  return await this.countMain(db, pm);
+};
+
+
+/**
+ * 获取模型
+ * @param {string} type 模型类型
+ * @returns {object} 返回获取到的模型
+ */
+Drive.prototype.getModel = function (type) {
+  let model = { ...this.config };
+  let dir = this._getDir();
+  let l = $.slash;
+  let app_name = dir.between('app' + l, l);
+  let plugin_name = dir.between('plugin' + l, l);
+  let name = dir.basename();
+  model.app = app_name;
+  model.plugin = plugin_name;
+  model.name = model.name || app_name + '_' + name;
+  return model;
+};
+module.exports = Drive;