mm_dao 1.8.3 → 1.8.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/dao.js CHANGED
@@ -1,6 +1,6 @@
1
1
  const path = require('path');
2
2
  const Item = require('mm_machine').Mod;
3
- const { string, array, date, file } = require('mm_helper');
3
+ const { string, array, file } = require('mm_helper');
4
4
  const { getRet } = require('mm_ret');
5
5
  const dbAdmin = require('mm_dbs');
6
6
 
@@ -11,6 +11,7 @@ const dbAdmin = require('mm_dbs');
11
11
  */
12
12
  class Dao extends Item {
13
13
  static config = {
14
+ // 驱动脚本(由加载方决定是否执行,此处保留配置位)
14
15
  main: '',
15
16
  // 表名 {0} 代表可前端传参自定义查询的表
16
17
  table: '{0}',
@@ -28,7 +29,11 @@ class Dao extends Item {
28
29
  field_hide: ['*password*', '*token*', 'salt'],
29
30
  // 分页大小,默认一页显示条数
30
31
  page_size: 30,
31
- /* 过滤参数 */
32
+ /* 参数过滤:参数名 → 数据管理器属性名
33
+ * 生成 SQL 条件前,先按此表把控制参数抽走:值为属性名则顺带赋值给数据管理器,
34
+ * 值为空字符串则只抽取(如 db 仅用于选择数据源、org_id 仅用于选择机构库)。
35
+ * 业务可在 dao.json 的 filter 中追加自己的非表字段,缺项自动继承默认清单。
36
+ */
32
37
  filter: {
33
38
  /**
34
39
  * 表名
@@ -58,6 +63,14 @@ class Dao extends Item {
58
63
  * 统计结果: 统计符合条件的结果数,只有当page等于1或0时才会统计
59
64
  */
60
65
  count_ret: 'count_ret',
66
+ /**
67
+ * 数据域:仅用于选择数据源,没有对应的数据管理器属性(db 是方法名)
68
+ */
69
+ db: '',
70
+ /**
71
+ * 分组:供 sum、avg、count 使用
72
+ */
73
+ groupby: 'groupby',
61
74
  },
62
75
  // 分隔符 用于查询时的多条件处理
63
76
  separator: '|',
@@ -179,6 +192,18 @@ Dao.prototype._getDict = function () {
179
192
  return this._getInject('dict') || {};
180
193
  };
181
194
 
195
+ /**
196
+ * 获取当前用户ID(用于默认条件与默认字段的 {user_id} 占位)
197
+ * @param {object} db 数据库管理器
198
+ * @returns {string|number} 用户ID, 无登录态时为 '0'
199
+ * @private
200
+ */
201
+ Dao.prototype._getUserId = function (db) {
202
+ var id = this._getDict().user_id;
203
+ var user = db.user;
204
+ return user && user[id] ? user[id] : '0';
205
+ };
206
+
182
207
  /**
183
208
  * 执行前, 可用于过滤参数
184
209
  * @param {object} params 参数对象 (object) 包含query和body 如{ query, body }
@@ -210,7 +235,7 @@ Dao.prototype.after = async function (params, db) {
210
235
  };
211
236
 
212
237
  /**
213
- * 更新缓存
238
+ * 更新缓存(预留扩展点,由业务/上层覆盖)
214
239
  * @param {string} table 表名
215
240
  * @param {object} sql 缓存sql语句
216
241
  */
@@ -229,7 +254,7 @@ Dao.prototype.run = async function (query, body, db) {
229
254
  body,
230
255
  };
231
256
  params = await this.before(params, db);
232
- if (this.check(params, db)) {
257
+ if (await this.check(params, db)) {
233
258
  var ret = await this.main(params, db);
234
259
  if (!ret.error) {
235
260
  db.ret = ret;
@@ -241,6 +266,32 @@ Dao.prototype.run = async function (query, body, db) {
241
266
  return null;
242
267
  };
243
268
 
269
+ /**
270
+ * 获取参数过滤表(本 dao 配置优先,缺项由默认配置补齐)
271
+ * @param {object} cg 配置
272
+ * @returns {object} 参数名 → 数据管理器属性名
273
+ * @private
274
+ */
275
+ Dao.prototype._getFilter = function (cg) {
276
+ return Object.assign({}, Dao.config.filter, cg.filter);
277
+ };
278
+
279
+ /**
280
+ * 取数据管理器的错误信息
281
+ * 当操作影响 0 行时(如修改不存在的记录)数据管理器不会置错误,
282
+ * 直接读 db.error.message 会抛 TypeError,这里统一兜底
283
+ * @param {object} db 数据管理器
284
+ * @returns {string} 错误信息,无错误时为空串
285
+ * @private
286
+ */
287
+ Dao.prototype._errMsg = function (db) {
288
+ var err = db && db.error;
289
+ if (!err) {
290
+ return '';
291
+ }
292
+ return err.message || err.toString();
293
+ };
294
+
244
295
  /**
245
296
  * SQL操作准备
246
297
  * @param {object} db 数据库操作类
@@ -251,14 +302,45 @@ Dao.prototype.run = async function (query, body, db) {
251
302
  Dao.prototype.ready = function (db, query, body) {
252
303
  var cg = this.config;
253
304
  var qy = { ...query };
254
- Object.assign(db.config.filter, cg.filter);
255
- db.filter(qy);
305
+ this._extractQuery(db, qy, cg);
256
306
  return {
257
307
  cg,
258
308
  qy,
259
309
  };
260
310
  };
261
311
 
312
+ /**
313
+ * 抽取控制参数,确保 qy 中只剩真正的 SQL 查询条件
314
+ * 按 filter 清单逐个抽取,与取值真假无关(page=0、size='' 同样会被抽走),
315
+ * 只有真值才赋给数据管理器,避免把空值写成 ''
316
+ * @param {object} db 数据库操作类
317
+ * @param {object} qy 查询条件
318
+ * @param {object} cg 配置
319
+ * @returns {object} 清理后的查询条件
320
+ * @private
321
+ */
322
+ Dao.prototype._extractQuery = function (db, qy, cg) {
323
+ var f = this._getFilter(cg);
324
+ for (var k in f) {
325
+ var name = f[k] || k;
326
+ var value = qy[name];
327
+ if (value === undefined) {
328
+ continue;
329
+ }
330
+ if (f[k] && value) {
331
+ db[k] = value;
332
+ }
333
+ delete qy[name];
334
+ }
335
+ // 空值不作为查询条件,避免被拼成 `field` = 'undefined'
336
+ for (var key in qy) {
337
+ if (qy[key] === undefined || qy[key] === null) {
338
+ delete qy[key];
339
+ }
340
+ }
341
+ return qy;
342
+ };
343
+
262
344
  /**
263
345
  * 转为查询条件字符串
264
346
  * @param {object} db 数据库管理器
@@ -267,9 +349,7 @@ Dao.prototype.ready = function (db, query, body) {
267
349
  * @returns {string} 返回查询条件
268
350
  */
269
351
  Dao.prototype.toWhere = function (db, query, method) {
270
- var { cg, qy: originalQy } = this.ready(db, query, {});
271
- // 创建 qy 对象的副本,避免修改原始参数
272
- var qy = { ...originalQy };
352
+ var { cg, qy } = this.ready(db, query, {});
273
353
  this._setDbConfig(db, cg, query);
274
354
  qy = this._setQueryField(db, query, cg, method, qy);
275
355
  qy = this._setOrderBy(db, query, cg, qy);
@@ -284,8 +364,10 @@ Dao.prototype.toWhere = function (db, query, method) {
284
364
  * @private
285
365
  */
286
366
  Dao.prototype._setDbConfig = function (db, cg, query) {
287
- db.config.separator = cg.separator;
288
- if (!query.size && cg.page_size) {
367
+ var f = this._getFilter(cg);
368
+ // 只有未传 size 时才套用配置的分页大小(显式传 0 表示不分页,不能被覆盖)
369
+ var size = query[f.size];
370
+ if ((size === undefined || size === null || size === '') && cg.page_size) {
289
371
  db.size = cg.page_size + 0;
290
372
  }
291
373
  if (db.size > 0 && db.page === 0) {
@@ -304,7 +386,8 @@ Dao.prototype._setDbConfig = function (db, cg, query) {
304
386
  * @private
305
387
  */
306
388
  Dao.prototype._setQueryField = function (db, query, cg, method, qy) {
307
- var f = db.config.filter;
389
+ // 取本 dao 的配置(默认 + cg),不读 db.config.filter:后者是共享配置记录,会被其他 dao 覆盖
390
+ var f = this._getFilter(cg);
308
391
  var field = query[f.field];
309
392
  if (string.has(cg.field, '*{0}*')) {
310
393
  if (field) {
@@ -338,7 +421,8 @@ Dao.prototype._setQueryField = function (db, query, cg, method, qy) {
338
421
  * @private
339
422
  */
340
423
  Dao.prototype._setOrderBy = function (db, query, cg, qy) {
341
- var f = db.config.filter;
424
+ // 同上:按本 dao 的配置取参数名
425
+ var f = this._getFilter(cg);
342
426
  var orderby = query[f.orderby];
343
427
  if (string.has(cg.orderby, '*{0}*')) {
344
428
  if (orderby) {
@@ -369,26 +453,64 @@ Dao.prototype._setOrderBy = function (db, query, cg, qy) {
369
453
  * @private
370
454
  */
371
455
  Dao.prototype._buildQueryString = function (db, qy, cg) {
372
- var query_str = db.tplQuery(qy, cg.query);
373
- var qt = cg.query_default;
374
- if (Object.keys(qt).length > 0) {
375
- var id = this._getDict().user_id;
376
- var id_key = '{' + id + '}';
377
- var user_id = '0';
378
- var user = db.user;
379
- if (user && user[id]) {
380
- user_id = user[id];
381
- }
382
- for (var k in qt) {
383
- if (!qy[k]) {
384
- query_str += ' && ' + string.replaceAll(qt[k], id_key, user_id);
385
- }
456
+ return this._appendDefault(this._tplQuery(db, qy, cg), qy, cg.query_default, db);
457
+ };
458
+
459
+ /**
460
+ * 按本 dao 的分隔符拼接查询条件
461
+ * 分隔符存放在数据管理器的共享配置记录中,直接赋值会串到同表模型的其它请求,
462
+ * 因此仅在本次拼接期间生效,用完立即还原
463
+ * @param {object} db 数据库管理器
464
+ * @param {object} qy 查询条件对象
465
+ * @param {object} cg 配置
466
+ * @returns {string} 查询条件字符串
467
+ * @private
468
+ */
469
+ Dao.prototype._tplQuery = function (db, qy, cg) {
470
+ var cf = db.config;
471
+ if (!cf) {
472
+ return db.tplQuery(qy, cg.query);
473
+ }
474
+ var prev = cf.separator;
475
+ var sep = cg.separator;
476
+ if (sep === prev) {
477
+ return db.tplQuery(qy, cg.query);
478
+ }
479
+ cf.separator = sep;
480
+ try {
481
+ return db.tplQuery(qy, cg.query);
482
+ } finally {
483
+ if (prev === undefined) {
484
+ delete cf.separator;
485
+ } else {
486
+ cf.separator = prev;
386
487
  }
387
- if (query_str.startsWith(' && ')) {
388
- query_str = query_str.replace(' && ', '');
488
+ }
489
+ };
490
+
491
+ /**
492
+ * 追加默认查询条件
493
+ * @param {string} query_str 已有查询条件
494
+ * @param {object} qy 查询条件对象
495
+ * @param {object} qt 默认查询条件模板
496
+ * @param {object} db 数据库管理器
497
+ * @returns {string} 追加后的查询条件
498
+ * @private
499
+ */
500
+ Dao.prototype._appendDefault = function (query_str, qy, qt, db) {
501
+ if (!qt || Object.keys(qt).length === 0) {
502
+ return query_str;
503
+ }
504
+ var id_key = '{' + this._getDict().user_id + '}';
505
+ var user_id = this._getUserId(db);
506
+ for (var k in qt) {
507
+ if (!qy[k]) {
508
+ // 用 AND 而非 &&:&& 只有 MySQL 认,SQLite 会当成语法错误,
509
+ // 而默认条件通常是用户/机构隔离条件,必须与具体数据库无关
510
+ query_str += ' AND ' + string.replaceAll(qt[k], id_key, user_id);
389
511
  }
390
512
  }
391
- return query_str;
513
+ return query_str.replace(/^ AND /, '');
392
514
  };
393
515
 
394
516
  /**
@@ -401,7 +523,7 @@ Dao.prototype._buildQueryString = function (db, qy, cg) {
401
523
  Dao.prototype.getMain = async function (db, query, method) {
402
524
  var ret;
403
525
  if (string.has(this.config.field, '*{0}*')) {
404
- var field = query[db.config.filter.field];
526
+ var field = query[this._getFilter(this.config).field];
405
527
  if (field && array.getMatch(this.config.field_hide, field)) {
406
528
  return getRet().error(70003, '不合法的查询参数');
407
529
  }
@@ -409,7 +531,7 @@ Dao.prototype.getMain = async function (db, query, method) {
409
531
  var query_str = this.toWhere(db, query, method);
410
532
 
411
533
  // 查询
412
- if (db.count_ret === 'true') {
534
+ if (db.count_ret === 'true' || db.count_ret === true) {
413
535
  ret = getRet().body(await db.getCountSql(query_str, db.orderby, db.field), null);
414
536
  } else {
415
537
  ret = getRet().list(await db.getSql(query_str, db.orderby, db.field));
@@ -465,30 +587,12 @@ Dao.prototype.setMain = async function (db, query, body) {
465
587
  if (body[key]) {
466
588
  qy[key] = body[key];
467
589
  }
468
- var query_str = db.tplQuery(qy, cg.query);
469
-
470
- var qt = cg.query_default;
471
- if (Object.keys(qt).length > 0) {
472
- var id = this._getDict().user_id;
473
- var id_key = '{' + id + '}';
474
- var user_id = '0';
475
- var user = db.user;
476
- if (user && user[id]) {
477
- user_id = user[id];
478
- }
479
- for (var k in qt) {
480
- if (!qy[k]) {
481
- query_str += ' && ' + qt[k].replace(id_key, user_id);
482
- }
483
- }
484
- if (query_str.startsWith(' && ')) {
485
- query_str = query_str.replace(' && ', '');
486
- }
487
- }
590
+ var query_str = this._buildQueryString(db, qy, cg);
488
591
  var n = await db.setSql(query_str, db.tplBody(body, cg.update));
489
592
 
490
593
  if (n < 1) {
491
- ret = getRet().error(500, '修改失败!\n' + db.error.message);
594
+ var msg = this._errMsg(db);
595
+ ret = getRet().error(500, msg ? '修改失败!\n' + msg : '修改失败!');
492
596
  } else {
493
597
  ret = getRet().bl(true, '修改成功!');
494
598
  }
@@ -506,6 +610,45 @@ Dao.prototype.set = async function (db, query, body) {
506
610
  return await this.setMain(db, query, body);
507
611
  };
508
612
 
613
+ /**
614
+ * 填充默认写入值
615
+ * body_default 是「字段 = 值」模板,常用于补 user_id、org_id 这类隔离字段;
616
+ * 查询条件里的 query_default 会校验同样的字段,写入侧必须把值补齐,否则
617
+ * 新增的记录缺少隔离字段,按同一用户再也查不到(表现为反复新增重复数据)
618
+ * @param {object} db 数据库管理器
619
+ * @param {object} body 待写入数据
620
+ * @param {object} cg 配置
621
+ * @returns {object} 补充默认值后的数据副本
622
+ * @private
623
+ */
624
+ Dao.prototype._fillBodyDefault = function (db, body, cg) {
625
+ // 复制一份,默认值只补进本 dao 的数据,不改调用方的参数对象
626
+ var dt = { ...body };
627
+ var bt = cg.body_default;
628
+ if (!bt || Object.keys(bt).length === 0) {
629
+ return dt;
630
+ }
631
+ var id_key = '{' + this._getDict().user_id + '}';
632
+ var user_id = this._getUserId(db);
633
+ for (var k in bt) {
634
+ var tpl = String(string.replaceAll(bt[k], id_key, user_id));
635
+ // 模板格式:`字段` = 值(空格、反引号、引号可省略)
636
+ // 不能用 left/right/trim 按单字符截取:值里带空格时会残留成 `user_id`` 这种非法字段名
637
+ var arr = tpl.split('=');
638
+ if (arr.length < 2) {
639
+ continue;
640
+ }
641
+ var fkey = arr[0].replace(/`/g, '').trim();
642
+ var fval = arr.slice(1).join('=').trim().replace(/^'(.*)'$/, '$1');
643
+ // 已有值的字段不覆盖
644
+ if (!fkey || dt[fkey]) {
645
+ continue;
646
+ }
647
+ dt[fkey] = fval;
648
+ }
649
+ return dt;
650
+ };
651
+
509
652
  /**
510
653
  * 添加(主要)
511
654
  * @param {object} db 数据库操作类
@@ -516,26 +659,11 @@ Dao.prototype.addMain = async function (db, body) {
516
659
  var ret;
517
660
  var cg = this.config;
518
661
  if (Object.keys(body).length > 0) {
519
- var bt = cg.body_default;
520
- if (Object.keys(bt).length > 0) {
521
- var id = this._getDict().user_id;
522
- var id_key = '{' + id + '}';
523
- var user_id = '0';
524
- var user = db.user;
525
- if (user && user[id]) {
526
- user_id = user[id];
527
- }
528
- for (var k in bt) {
529
- if (!body[k]) {
530
- var str = bt[k].replace(id_key, user_id);
531
- var key = string.trim(string.left(str, '='), '`');
532
- body[key] = string.trim(string.right(str, '='), "'");
533
- }
534
- }
535
- }
536
- var n = await db.add(body);
662
+ var dt = this._fillBodyDefault(db, body, cg);
663
+ var n = await db.add(dt);
537
664
  if (n < 1) {
538
- ret = getRet().error(500, '添加失败!\n' + db.error.message);
665
+ var msg = this._errMsg(db);
666
+ ret = getRet().error(500, msg ? '添加失败!\n' + msg : '添加失败!');
539
667
  } else {
540
668
  ret = getRet().bl(true, '添加成功!');
541
669
  }
@@ -613,10 +741,17 @@ Dao.prototype.addList = async function (db, list) {
613
741
  Dao.prototype.delMain = async function (db, query) {
614
742
  var ret;
615
743
  var { cg, qy } = this.ready(db, query, {});
616
- var query_str = db.tplQuery(qy, cg.query);
744
+ // 与 get / set 保持一致:删除同样追加 query_default,
745
+ // 否则“查到的范围”与“删掉的范围”不一致(默认条件常用于用户/机构隔离,缺失会删到别人数据)
746
+ var query_str = this._buildQueryString(db, qy, cg);
747
+ // 拒绝空条件删除:部分适配器会把空 where 当成“全删”,不能靠它们兜底
748
+ if (!query_str) {
749
+ return getRet().error(30001, '删除条件不能为空');
750
+ }
617
751
  var bl = await db.delSql(query_str);
618
752
  if (bl < 1) {
619
- ret = getRet().error(500, '删除失败!\n' + db.error.message);
753
+ var msg = this._errMsg(db);
754
+ ret = getRet().error(500, msg ? '删除失败!\n' + msg : '删除失败!');
620
755
  } else {
621
756
  ret = getRet().bl(true, '删除成功!');
622
757
  }
@@ -644,13 +779,35 @@ Dao.prototype.del = async function (db, query, body = {}) {
644
779
  * @param {object} body 修改项
645
780
  * @returns {object} 返回修改结果
646
781
  */
647
- Dao.prototype.addorsetMain = async function (db, query, body) {
782
+ Dao.prototype.addOrSetMain = async function (db, query, body) {
648
783
  var ret;
649
784
  var { cg, qy } = this.ready(db, query, body);
650
785
  if (Object.keys(body).length > 0 && Object.keys(qy).length > 0) {
651
- var n = await db.addOrSet(qy, body);
786
+ // 与 get / set / del 同源:判断「是否已存在」同样带上 query_default,
787
+ // 否则会命中他人的记录并直接改掉(默认条件通常是用户/机构隔离条件)
788
+ var where = this._buildQueryString(db, qy, cg);
789
+ if (!where) {
790
+ return getRet().error(30001, '条件不能为空');
791
+ }
792
+ // 新增分支不会用到 where 里的隔离字段,需把 body_default 补进写入数据,
793
+ // 否则插入的记录缺少隔离字段,后续按同一用户再也查不到(反复新增重复数据)
794
+ var dt = this._fillBodyDefault(db, body, cg);
795
+ var n;
796
+ if (typeof db.countSql === 'function') {
797
+ // 自行判断存在性再分派:部分适配器的 addOrSet 在新增分支只写 set 的数据,
798
+ // 不会把条件字段写进新记录,导致新记录不满足条件,下次调用又新增一条(重复数据)
799
+ var count = await db.countSql(where);
800
+ if (count > 0) {
801
+ n = await db.setSql(where, db.tplBody(body, cg.update));
802
+ } else {
803
+ n = await db.add({ ...qy, ...dt });
804
+ }
805
+ } else {
806
+ n = await db.addOrSet(where, dt);
807
+ }
652
808
  if (n < 1) {
653
- ret = getRet().error(500, '操作失败!\n' + db.error.message);
809
+ var msg = this._errMsg(db);
810
+ ret = getRet().error(500, msg ? '操作失败!\n' + msg : '操作失败!');
654
811
  } else {
655
812
  ret = getRet().bl(true, '操作成功!');
656
813
  }
@@ -674,17 +831,19 @@ Dao.prototype.addOrSet = async function (db, query, body) {
674
831
  return await this.addOrSetMain(db, query, body);
675
832
  };
676
833
 
834
+ // 历史命名(全小写)保留为别名,避免既有调用方失效
835
+ Dao.prototype.addorsetMain = Dao.prototype.addOrSetMain;
836
+
677
837
  /**
678
838
  * 获取数据类型
679
839
  * @param {string} data_type 数据类型
680
840
  * @returns {string} 返回数据类型
681
841
  */
682
842
  Dao.prototype.getType = function (data_type) {
683
- if (data_type.indexOf('int') !== -1) {
684
- return 'number';
685
- } else {
843
+ if (!data_type) {
686
844
  return 'string';
687
845
  }
846
+ return String(data_type).indexOf('int') !== -1 ? 'number' : 'string';
688
847
  };
689
848
 
690
849
  /**
@@ -777,7 +936,9 @@ Dao.prototype._filterFields = function (lt, field, cg) {
777
936
  * @returns {Array} 格式列表
778
937
  */
779
938
  Dao.prototype.getFormat = async function (db) {
780
- var dbs = { ...db };
939
+ // 用原型继承派生一个“不分页”的视图:直接 {...db} 只复制自有属性,
940
+ // getSql 等原型方法会丢失,取格式数据时会报 dbs.getSql is not a function
941
+ var dbs = Object.create(db);
781
942
  dbs.size = 0;
782
943
  var fmt = this.config.format;
783
944
  for (var i = 0; i < fmt.length; i++) {
@@ -810,11 +971,11 @@ Dao.prototype.getFormat = async function (db) {
810
971
  Dao.prototype.importMain = async function (db, filename) {
811
972
  var params = await this.getParam(db);
812
973
  var format = await this.getFormat(db);
813
- var file = this._processFilePath(filename);
814
- if (!file.hasFile(file)) {
815
- return getRet().error(30001, file + '文件不存在!');
974
+ var fpath = this._processFilePath(filename);
975
+ if (!file.hasFile(fpath)) {
976
+ return getRet().error(30001, fpath + '文件不存在!');
816
977
  }
817
- var jarr = await this._loadImport(file, params, format);
978
+ var jarr = await this._loadImport(fpath, params, format);
818
979
  if (!jarr || !jarr.length) {
819
980
  return getRet().error(10000, '要导入的数据不能为空!');
820
981
  }
@@ -829,40 +990,42 @@ Dao.prototype.importMain = async function (db, filename) {
829
990
  * @private
830
991
  */
831
992
  Dao.prototype._processFilePath = function (filename) {
832
- var file = filename;
993
+ // 局部变量不能叫 file,否则会遮蔽 mm_helper 的 file 助手(hasFile/fullname 会变 undefined)
994
+ var fpath = filename || '';
833
995
  var run_path = this._getInject('run_path') || '';
834
- if (file.indexOf(run_path) !== 0) {
835
- file = file.replace(this.url_path, this.save_dir);
836
- var base_path = this._getPath();
837
- file = file.fullname(file, base_path);
996
+ // 未配置 run_path 时 indexOf('') 恒为 0,不能据此判断“已在运行目录下”
997
+ if (!run_path || fpath.indexOf(run_path) !== 0) {
998
+ // save_dir 是相对运行目录的,基准也必须是运行目录(原来用 _getPath 会拼出 static/static/file)
999
+ var base_path = run_path || process.cwd();
1000
+ fpath = file.fullname(fpath.replace(this.url_path, this.save_dir), base_path);
838
1001
  }
839
- return file;
1002
+ return fpath;
840
1003
  };
841
1004
 
842
1005
  /**
843
1006
  * 加载导入数据
844
- * @param {string} file 文件路径
1007
+ * @param {string} fpath 文件路径
845
1008
  * @param {Array} params 参数列表
846
1009
  * @param {Array} format 格式列表
847
1010
  * @returns {Array} 数据数组
848
1011
  * @private
849
1012
  */
850
- Dao.prototype._loadImport = async function (file, params, format) {
851
- if (file.endsWith('.json')) {
852
- return file.loadJson(file);
853
- } else if (file.endsWith('.xml')) {
854
- return file.loadXml(file);
855
- } else {
856
- const Excel = require('mm_excel');
857
- var excel = new Excel({ file, params, format });
858
- try {
859
- return await excel.load();
860
- } catch (e) {
861
- this.log('error', '导入文件', e);
862
- } finally {
863
- excel.clear();
864
- excel = null;
865
- }
1013
+ Dao.prototype._loadImport = async function (fpath, params, format) {
1014
+ if (fpath.endsWith('.json')) {
1015
+ return file.loadJson(fpath);
1016
+ }
1017
+ if (fpath.endsWith('.xml')) {
1018
+ return file.loadXml(fpath);
1019
+ }
1020
+ const Excel = require('mm_excel');
1021
+ var excel = new Excel({ file: fpath, params, format });
1022
+ try {
1023
+ return await excel.load();
1024
+ } catch (e) {
1025
+ this.log('error', '导入文件', e);
1026
+ } finally {
1027
+ excel.clear();
1028
+ excel = null;
866
1029
  }
867
1030
  return [];
868
1031
  };
@@ -952,19 +1115,20 @@ Dao.prototype.import = async function (db, query, body) {
952
1115
  */
953
1116
  Dao.prototype.exportMain = async function (db, query, body) {
954
1117
  var by = await this.getMain(db, query);
955
- if (db.error) {
956
- return getRet().error(10000, db.error.message);
1118
+ if (by.error) {
1119
+ return by;
1120
+ }
1121
+ var err = this._errMsg(db);
1122
+ if (err) {
1123
+ return getRet().error(10000, err);
957
1124
  }
958
1125
  var config = this._prepareExportConfig(query, body);
959
1126
  var params = await this.getParam(db, config.fields);
960
1127
  var format = await this.getFormat(db);
961
- var file = await this._saveExportFile(
962
- config.file,
963
- params,
964
- format,
965
- by.result.list,
966
- );
967
- return this._buildExport(file, config.name);
1128
+ // 统计模式下 getMain 返回的是条数而非列表,此处兜底避免取 list 报错
1129
+ var list = (by.result && by.result.list) || [];
1130
+ var fpath = await this._saveExportFile(config.file, params, format, list);
1131
+ return this._buildExport(fpath, config.name);
968
1132
  };
969
1133
 
970
1134
  /**
@@ -975,23 +1139,19 @@ Dao.prototype.exportMain = async function (db, query, body) {
975
1139
  * @private
976
1140
  */
977
1141
  Dao.prototype._prepareExportConfig = function (query, body) {
978
- var path = body.path;
979
- var file = body.file;
1142
+ var path = body.path || this._getPath();
1143
+ var file_name = body.file;
980
1144
  var fields = body.fields;
981
1145
  var table = this._getDict().table || this.config.table;
982
- if (!path) {
983
- path = this._getPath();
984
- }
985
- if (!file) {
986
- var date = new Date();
987
- file = this.save_dir + table + '_' + date.stamp(date) + '.xlsx';
1146
+ if (!file_name) {
1147
+ file_name = this.save_dir + table + '_' + new Date().stamp() + '.xlsx';
988
1148
  }
989
1149
  if (!fields) {
990
1150
  fields =
991
- query.field ||
1151
+ query[this._getFilter(this.config).field] ||
992
1152
  (this.config.field_default !== '*' ? this.config.field_default : '');
993
1153
  }
994
- return { path, file, fields, name: file.split('/').pop() };
1154
+ return { path, file: file_name, fields, name: file_name.split('/').pop() };
995
1155
  };
996
1156
 
997
1157
  /**
@@ -1009,16 +1169,15 @@ Dao.prototype._getPath = function () {
1009
1169
 
1010
1170
  /**
1011
1171
  * 保存导出文件
1012
- * @param {string} file 文件路径
1172
+ * @param {string} fpath 文件路径
1013
1173
  * @param {Array} params 参数列表
1014
1174
  * @param {Array} format 格式列表
1015
1175
  * @param {Array} list 数据列表
1016
1176
  * @returns {string} 保存后的文件路径
1017
1177
  * @private
1018
1178
  */
1019
- Dao.prototype._saveExportFile = async function (file, params, format, list) {
1020
- var export_path = this._getPath();
1021
- var save_file = file.fullname(file, export_path);
1179
+ Dao.prototype._saveExportFile = async function (fpath, params, format, list) {
1180
+ var save_file = file.fullname(fpath, this._getPath());
1022
1181
  file.addDir(save_file);
1023
1182
  const Excel = require('mm_excel');
1024
1183
  var excel = new Excel({ file: save_file, params, format });
@@ -1035,14 +1194,14 @@ Dao.prototype._saveExportFile = async function (file, params, format, list) {
1035
1194
 
1036
1195
  /**
1037
1196
  * 构建导出结果
1038
- * @param {string} file 文件路径
1197
+ * @param {string} fpath 文件路径
1039
1198
  * @param {string} name 文件名
1040
1199
  * @returns {object} 导出结果
1041
1200
  * @private
1042
1201
  */
1043
- Dao.prototype._buildExport = function (file, name) {
1044
- var body = getRet().bl(!!file, file ? '导出成功!' : '导出失败!');
1045
- body.result.file = file;
1202
+ Dao.prototype._buildExport = function (fpath, name) {
1203
+ var body = getRet().bl(!!fpath, fpath ? '导出成功!' : '导出失败!');
1204
+ body.result.file = fpath;
1046
1205
  body.result.url = this.url_path + name;
1047
1206
  return body;
1048
1207
  };
@@ -1068,44 +1227,63 @@ Dao.prototype.delRepeatMain = async function (db, params) {
1068
1227
  var pm = { ...params };
1069
1228
  var msg = '';
1070
1229
  var cg = this.config.del_repeat;
1071
- var order_by = pm.orderby || cg.orderby;
1072
- delete pm.orderby;
1073
- var group_by_val = pm.groupby || cg.groupby;
1230
+ var f = this._getFilter(this.config);
1231
+ var order_by = pm[f.orderby] || cg.orderby;
1232
+ var group_by_val = pm[f.groupby] || cg.groupby;
1074
1233
  var group_by =
1075
1234
  (typeof group_by_val === 'string' && string.validate(group_by_val, 'username') ? group_by_val : '') ||
1076
1235
  cg.groupby ||
1077
1236
  '';
1078
- delete pm.groupby;
1079
- var f = db.config.filter;
1080
- // 设置查询字段
1237
+ var field_val = pm[f.field];
1081
1238
  var field =
1082
- (typeof pm[f.field] === 'string' && string.validate(pm[f.field], 'username') ? pm[f.field] : '') ||
1083
- group_by;
1084
- delete pm[f.field];
1085
- db.field = field;
1086
- var sql = db
1087
- .toGetSql(pm)
1088
- .replace(' * ', ' `' + field + '`, count(*) as len ');
1089
- sql += ` GROUP BY ${group_by}`;
1090
- sql = 'SELECT * FROM (' + sql + ') a WHERE len > 1';
1091
- var list = await db.run(sql);
1092
- if (list.length) {
1093
- db.page = 1;
1094
- db.size = 1;
1095
- var key = this.config.key;
1096
- for (var i = 0; i < list.length; i++) {
1097
- var o = list[i];
1098
- var len = o.len - 1;
1099
- delete o.len;
1100
- for (var n = 0; n < len; n++) {
1101
- var obj = await db.getObj(o, order_by, key);
1102
- if (obj) {
1103
- await db.del(obj);
1239
+ (typeof field_val === 'string' && string.validate(field_val, 'username') ? field_val : '') || group_by;
1240
+ // 去重过程会改动分页与字段设置(扫全表 -> 逐条取单条),先记下原值,结束后还原
1241
+ var old_page = db.page;
1242
+ var old_size = db.size;
1243
+ var old_field = db.field;
1244
+ // 抽走 page、size、table、method、org_id 等控制参数,只留真正的查询条件,
1245
+ // 否则会被拼成 `page` = '1' 之类的条件,导致去重查不到数据
1246
+ var qy = this.ready(db, pm, {}).qy;
1247
+ // 分组与取行都要带 query_default(用户/机构隔离),否则会跨用户分组并删掉别人的记录
1248
+ var where = this._buildQueryString(db, qy, this.config);
1249
+ var list = [];
1250
+ try {
1251
+ // 去重要扫全表,不能带分页(LIMIT 拼到 GROUP BY 前面会直接语法错误)
1252
+ db.page = 0;
1253
+ db.size = 0;
1254
+ db.field = field;
1255
+ // 用 toQuery 而不是 toGetSql:view 固定为 *,替换分组字段时不受适配器默认字段影响
1256
+ var sql = db
1257
+ .toQuery(where, '', '*')
1258
+ .replace(' * ', ' `' + field + '`, count(*) as len ');
1259
+ sql += ` GROUP BY ${group_by}`;
1260
+ sql = 'SELECT * FROM (' + sql + ') a WHERE len > 1';
1261
+ list = (await db.run(sql)) || [];
1262
+ if (list.length) {
1263
+ db.page = 1;
1264
+ db.size = 1;
1265
+ var key = this.config.key;
1266
+ for (var i = 0; i < list.length; i++) {
1267
+ var o = list[i];
1268
+ var len = o.len - 1;
1269
+ delete o.len;
1270
+ // 取行同样叠加隔离条件:只按分组字段取第一条会取到他人的记录
1271
+ var owhere = this._buildQueryString(db, o, this.config);
1272
+ for (var n = 0; n < len; n++) {
1273
+ var rows = (await db.getSql(owhere, order_by, key)) || [];
1274
+ if (!rows.length) {
1275
+ break;
1276
+ }
1277
+ await db.del(rows[0]);
1104
1278
  }
1105
1279
  }
1280
+ } else {
1281
+ msg = '没有重复项。';
1106
1282
  }
1107
- } else {
1108
- msg = '没有重复项。';
1283
+ } finally {
1284
+ db.page = old_page;
1285
+ db.size = old_size;
1286
+ db.field = old_field;
1109
1287
  }
1110
1288
  return getRet().bl(!msg, msg ? '去重失败!原因:' + msg : '去重成功!');
1111
1289
  };
@@ -1132,7 +1310,9 @@ Dao.prototype.main = async function (params, db) {
1132
1310
  var { query, body } = params;
1133
1311
 
1134
1312
  var cg = this.config;
1135
- var method = query.method;
1313
+ // 参数名统一按本 dao 的 filter 配置取,支持 dao.json 重命名控制参数
1314
+ var f = this._getFilter(cg);
1315
+ var method = query[f.method];
1136
1316
 
1137
1317
  if (!method) {
1138
1318
  method = 'get';
@@ -1142,12 +1322,11 @@ Dao.prototype.main = async function (params, db) {
1142
1322
  }
1143
1323
  method = this._getMethodName(method);
1144
1324
  var qy = { ...query };
1145
- delete qy.method;
1325
+ delete qy[f.method];
1146
1326
  if (this[method]) {
1147
1327
  db.method = method;
1148
1328
 
1149
- // 过滤查询参数
1150
- var f = cg.filter;
1329
+ // 取数据表名
1151
1330
  var table = query[f.table];
1152
1331
  var safe_table = typeof table === 'string' && string.validate(table, 'username') ? table : '';
1153
1332
 
@@ -1168,8 +1347,8 @@ Dao.prototype.main = async function (params, db) {
1168
1347
  db.table = table_name;
1169
1348
 
1170
1349
  // 兼容传入数据管理器(无 config,只有 new/getSql 等方法)的场景:
1171
- // 派生一张绑定表名的表模型,使 getSql/getCountSql/groupCountSql 等
1172
- // 表级方法与 config.filter 可用;传入的已是表模型时保持不变
1350
+ // 派生一张绑定表名的表模型,使 getSql/getCountSql/groupCountSql 等表级方法可用;
1351
+ // 传入的已是表模型时保持不变
1173
1352
  if (db && db.config === undefined && typeof db.new === 'function') {
1174
1353
  db = db.new(table_name, cg.key);
1175
1354
  }
@@ -1204,34 +1383,41 @@ Dao.prototype._getMethodName = function (method) {
1204
1383
  };
1205
1384
 
1206
1385
  /**
1207
- * 总计
1386
+ * 分组统计(sum、avg、count 共用)
1208
1387
  * @param {object} db 数据库管理器
1209
1388
  * @param {object} param 查询条件
1389
+ * @param {string} method 统计方法名 groupSumSql / groupAvgSql / groupCountSql
1210
1390
  * @returns {object} 返回执行结果
1391
+ * @private
1211
1392
  */
1212
- Dao.prototype.sumMain = async function (db, param) {
1393
+ Dao.prototype._statMain = async function (db, param, method) {
1213
1394
  var pm = { ...param };
1214
- var ret;
1215
- var orderby = pm.orderby || '';
1216
- delete pm.orderby;
1217
- var groupby = pm.groupby;
1218
- delete pm.groupby;
1219
- var f = db.config.filter;
1395
+ var f = this._getFilter(this.config);
1396
+ var orderby = pm[f.orderby] || '';
1397
+ var groupby = pm[f.groupby];
1220
1398
  var field = pm[f.field];
1399
+ delete pm[f.orderby];
1400
+ delete pm[f.groupby];
1221
1401
  delete pm[f.field];
1222
- var query_str = this.toWhere(db, pm, 'get_list');
1223
-
1224
1402
  if (!groupby || !field) {
1225
- ret = getRet().error(30000, '参数groupby、field是必须的,且值不能为空!');
1226
- } else {
1227
- var list = await db.groupSumSql(query_str, groupby, field, orderby);
1228
- if (!list.length && db.error) {
1229
- ret = getRet().body(db.error);
1230
- } else {
1231
- ret = getRet().list(list);
1232
- }
1403
+ return getRet().error(30000, '参数groupby、field是必须的,且值不能为空!');
1233
1404
  }
1234
- return ret;
1405
+ var query_str = this.toWhere(db, pm, 'get_list');
1406
+ var list = await db[method](query_str, groupby, field, orderby);
1407
+ if (!list.length && db.error) {
1408
+ return getRet().body(db.error);
1409
+ }
1410
+ return getRet().list(list);
1411
+ };
1412
+
1413
+ /**
1414
+ * 总计
1415
+ * @param {object} db 数据库管理器
1416
+ * @param {object} param 查询条件
1417
+ * @returns {object} 返回执行结果
1418
+ */
1419
+ Dao.prototype.sumMain = async function (db, param) {
1420
+ return await this._statMain(db, param, 'groupSumSql');
1235
1421
  };
1236
1422
 
1237
1423
  /**
@@ -1242,8 +1428,7 @@ Dao.prototype.sumMain = async function (db, param) {
1242
1428
  * @returns {object} 返回执行结果
1243
1429
  */
1244
1430
  Dao.prototype.sum = async function (db, query, body) {
1245
- var pm = { ...query, ...body };
1246
- return await this.sumMain(db, pm);
1431
+ return await this.sumMain(db, { ...query, ...body });
1247
1432
  };
1248
1433
 
1249
1434
  /**
@@ -1253,28 +1438,7 @@ Dao.prototype.sum = async function (db, query, body) {
1253
1438
  * @returns {object} 返回执行结果
1254
1439
  */
1255
1440
  Dao.prototype.avgMain = async function (db, param) {
1256
- var pm = { ...param };
1257
- var ret;
1258
- var orderby = pm.orderby || '';
1259
- delete pm.orderby;
1260
- var groupby = pm.groupby;
1261
- delete pm.groupby;
1262
- var f = db.config.filter;
1263
- var field = pm[f.field];
1264
- delete pm[f.field];
1265
- var query_str = this.toWhere(db, pm, 'get_list');
1266
-
1267
- if (!groupby || !field) {
1268
- ret = getRet().error(30000, '参数groupby、field是必须的,且值不能为空!');
1269
- } else {
1270
- var list = await db.groupAvgSql(query_str, groupby, field, orderby);
1271
- if (!list.length && db.error) {
1272
- ret = getRet().body(db.error);
1273
- } else {
1274
- ret = getRet().list(list);
1275
- }
1276
- }
1277
- return ret;
1441
+ return await this._statMain(db, param, 'groupAvgSql');
1278
1442
  };
1279
1443
 
1280
1444
  /**
@@ -1285,51 +1449,28 @@ Dao.prototype.avgMain = async function (db, param) {
1285
1449
  * @returns {object} 返回执行结果
1286
1450
  */
1287
1451
  Dao.prototype.avg = async function (db, query, body) {
1288
- var pm = { ...query, ...body };
1289
- return await this.avgMain(db, pm);
1452
+ return await this.avgMain(db, { ...query, ...body });
1290
1453
  };
1291
1454
 
1292
1455
  /**
1293
- * 总计
1456
+ * 计数
1294
1457
  * @param {object} db 数据库管理器
1295
1458
  * @param {object} param 查询条件
1296
1459
  * @returns {object} 返回执行结果
1297
1460
  */
1298
1461
  Dao.prototype.countMain = async function (db, param) {
1299
- var pm = { ...param };
1300
- var ret;
1301
- var orderby = pm.orderby || '';
1302
- delete pm.orderby;
1303
- var groupby = pm.groupby;
1304
- delete pm.groupby;
1305
- var f = db.config.filter;
1306
- var field = pm[f.field];
1307
- delete pm[f.field];
1308
- var query_str = this.toWhere(db, pm, 'get_list');
1309
-
1310
- if (!groupby || !field) {
1311
- ret = getRet().error(30000, '参数groupby、field是必须的,且值不能为空!');
1312
- } else {
1313
- var list = await db.groupCountSql(query_str, groupby, field, orderby);
1314
- if (!list.length && db.error) {
1315
- ret = getRet().body(db.error);
1316
- } else {
1317
- ret = getRet().list(list);
1318
- }
1319
- }
1320
- return ret;
1462
+ return await this._statMain(db, param, 'groupCountSql');
1321
1463
  };
1322
1464
 
1323
1465
  /**
1324
- * 总计
1466
+ * 计数
1325
1467
  * @param {object} db 数据库管理器
1326
1468
  * @param {object} query 查询条件
1327
1469
  * @param {object} body 正文参数
1328
1470
  * @returns {object} 返回执行结果
1329
1471
  */
1330
1472
  Dao.prototype.count = async function (db, query, body) {
1331
- var pm = { ...query, ...body };
1332
- return await this.countMain(db, pm);
1473
+ return await this.countMain(db, { ...query, ...body });
1333
1474
  };
1334
1475
 
1335
1476
  /**