midway-fatcms 0.0.1-beta.1

package/dist/service/curd/CurdMixByDictService.js

@@ -0,0 +1,111 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurdMixByDictService = void 0;
+const core_1 = require("@midwayjs/core");
+const CurdProService_1 = require("./CurdProService");
+const CurdMixUtils_1 = require("./CurdMixUtils");
+const SystemTables_1 = require("../../models/SystemTables");
+const keys_1 = require("../../libs/crud-pro/models/keys");
+const MultiKeyMap_1 = require("../../libs/crud-pro/utils/MultiKeyMap");
+const _ = require("lodash");
+const RedisCacheService_1 = require("../base/RedisCacheService");
+const TMP_CTX_KEY = _.uniqueId('CurdMixByDictService');
+const dictMixUtils = new CurdMixUtils_1.CrudMixUtils(CurdMixUtils_1.RelatedType.dict);
+let CurdMixByDictService = class CurdMixByDictService {
+    async getFromCache(code) {
+        const cacheKey = `CurdMixByDictService@@${code}`;
+        return this.redisCacheService.getJsonObject(cacheKey);
+    }
+    async setToCache(code, value) {
+        const cacheKey = `CurdMixByDictService@@${code}`;
+        return this.redisCacheService.setJsonObject(cacheKey, value, 60 * 60);
+    }
+    async handleExecuteContextPrepare(executeContext) {
+        const codes = dictMixUtils.pickColumnRelationCodes(executeContext);
+        if (!codes || codes.length === 0) {
+            return;
+        }
+        const rows = await this.getDictItemRows(codes);
+        executeContext[TMP_CTX_KEY] = new MultiKeyMap_1.MultiKeyMap(rows, 'dict_code', 'value');
+    }
+    async getDictItemRows(codes) {
+        const noCacheCodes = [];
+        // 从缓存里面取
+        let cachedRows = [];
+        for (let i = 0; i < codes.length; i++) {
+            const code = codes[i];
+            const rows1 = await this.getFromCache(code);
+            // const rows1 = [];
+            if (rows1 && rows1.length > 0) {
+                cachedRows = cachedRows.concat(rows1);
+            }
+            else {
+                noCacheCodes.push(code);
+            }
+        }
+        // 从数据库里面取
+        let selectedRows = [];
+        if (noCacheCodes.length > 0) {
+            const res1 = await this.curdProService.executeCrudByCfg({
+                condition: { dict_code: { $in: noCacheCodes } },
+            }, {
+                sqlTable: SystemTables_1.SystemTables.sys_data_dict_item,
+                sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+                sqlDatabase: SystemTables_1.SystemDbName,
+                sqlDdType: SystemTables_1.SystemDbType,
+            });
+            selectedRows = res1.getResRows();
+            //放到缓存里
+            for (let i = 0; i < noCacheCodes.length; i++) {
+                const noCacheCode = noCacheCodes[i];
+                const rows1 = selectedRows.filter(e => e.dict_code === noCacheCode);
+                await this.setToCache(noCacheCode, rows1);
+            }
+        }
+        return cachedRows.concat(selectedRows);
+    }
+    async handleExecuteContext(executeContext) {
+        const multiKeyMap = executeContext[TMP_CTX_KEY];
+        if (!multiKeyMap || multiKeyMap.isEmpty()) {
+            return;
+        }
+        dictMixUtils.forEachRowAndColumnsRelation(executeContext, (row, columnRelation) => {
+            const sourceColumn = columnRelation.sourceColumn;
+            const targetColumns = columnRelation.targetColumns;
+            if (!Array.isArray(targetColumns) || targetColumns.length === 0) {
+                columnRelation.targetColumns = [
+                    {
+                        "from": "*",
+                        "to": `${sourceColumn}_info[$ARRAY_INDEX]`
+                    },
+                ];
+            }
+            dictMixUtils.copyColumnRelationToRow(row, multiKeyMap, columnRelation);
+        });
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], CurdMixByDictService.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdProService_1.CurdProService)
+], CurdMixByDictService.prototype, "curdProService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", RedisCacheService_1.RedisCacheService)
+], CurdMixByDictService.prototype, "redisCacheService", void 0);
+CurdMixByDictService = __decorate([
+    (0, core_1.Provide)()
+], CurdMixByDictService);
+exports.CurdMixByDictService = CurdMixByDictService;

package/dist/service/curd/CurdMixByLinkToCustomService.d.ts

@@ -0,0 +1,22 @@
+import { Context } from '@midwayjs/koa';
+import { CurdProService } from './CurdProService';
+import { ExecuteContext, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
+import { RedisCacheService } from "../base/RedisCacheService";
+export declare class CurdMixByLinkToCustomService implements IExecuteContextHandler {
+    protected ctx: Context;
+    protected curdProService: CurdProService;
+    protected redisCacheService: RedisCacheService;
+    handleExecuteContextPrepare(executeContext: ExecuteContext): Promise<void>;
+    handleExecuteContext(executeContext: ExecuteContext): Promise<void>;
+    queryInfoByLinkToCustom(code: string): Promise<Map<string, any>>;
+    /**
+     * code形如：mysql_________fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name
+     * code形如：fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name
+     * code形如：fatcms~~~sys_perm_role~~~id,*
+     * 【数据库】~~~【表名】~~~【value】,【label】，【style】
+     * @param code
+     * @private
+     */
+    private queryInfoByLinkToCustomImpl;
+    private loadInfoByLinkToCustomMap;
+}

package/dist/service/curd/CurdMixByLinkToCustomService.js

@@ -0,0 +1,154 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurdMixByLinkToCustomService = void 0;
+const core_1 = require("@midwayjs/core");
+const _ = require("lodash");
+const CurdProService_1 = require("./CurdProService");
+const CurdMixUtils_1 = require("./CurdMixUtils");
+const keys_1 = require("../../libs/crud-pro/models/keys");
+const devops_1 = require("../../models/devops");
+const exceptions_1 = require("../../libs/crud-pro/exceptions");
+const RedisCacheService_1 = require("../base/RedisCacheService");
+const DatabaseName_1 = require("../../libs/crud-pro/utils/DatabaseName");
+const linkToCustomMixUtils = new CurdMixUtils_1.CrudMixUtils(CurdMixUtils_1.RelatedType.linkToCustom);
+const TMP_CTX_KEY = _.uniqueId('CurdMixByLinkToCustomService');
+let CurdMixByLinkToCustomService = class CurdMixByLinkToCustomService {
+    async handleExecuteContextPrepare(executeContext) {
+        const relations = linkToCustomMixUtils.pickColumnRelations(executeContext);
+        if (!relations || relations.length === 0) {
+            return;
+        }
+        executeContext[TMP_CTX_KEY] = await this.loadInfoByLinkToCustomMap(relations);
+    }
+    async handleExecuteContext(executeContext) {
+        const dataInfoMap = executeContext[TMP_CTX_KEY];
+        if (!dataInfoMap || dataInfoMap.size === 0) {
+            return;
+        }
+        linkToCustomMixUtils.forEachRowAndColumnsRelation(executeContext, (row, columnRelation) => {
+            const relatedCode = columnRelation.relatedCode;
+            const dataMap = dataInfoMap.get(relatedCode);
+            if (dataMap) {
+                const sourceColumn = columnRelation.sourceColumn;
+                const targetColumns = columnRelation.targetColumns;
+                if (!Array.isArray(targetColumns) || targetColumns.length === 0) {
+                    columnRelation.targetColumns = [
+                        {
+                            "from": "*",
+                            "to": `${sourceColumn}_info[$ARRAY_INDEX]`
+                        },
+                    ];
+                }
+                // this.ctx.logger.info("CurdMixByLinkToCustomService ==> dataMap", dataMap)
+                linkToCustomMixUtils.copyColumnRelationToRowNoRelatedCode(row, dataMap, columnRelation);
+            }
+        });
+    }
+    async queryInfoByLinkToCustom(code) {
+        const cacheKey = "linkToCustom@@" + code;
+        let values;
+        const expireSecond = 2 * 60; // 2分钟
+        const enumMap = await this.redisCacheService.getJsonObject(cacheKey);
+        if (!enumMap || Object.keys(enumMap).length === 0) {
+            values = await this.queryInfoByLinkToCustomImpl(code);
+            await this.redisCacheService.setJsonObject(cacheKey, values, expireSecond);
+        }
+        return values;
+    }
+    /**
+     * code形如：mysql_________fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name
+     * code形如：fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name
+     * code形如：fatcms~~~sys_perm_role~~~id,*
+     * 【数据库】~~~【表名】~~~【value】,【label】，【style】
+     * @param code
+     * @private
+     */
+    async queryInfoByLinkToCustomImpl(code) {
+        const arr = code
+            .split('~~~')
+            .map(s => s.trim())
+            .filter(Boolean);
+        if (arr.length !== 3) {
+            throw new devops_1.BizException('linkToCustom枚举值查询字符串，必须符合固定格式', exceptions_1.Exceptions.CFG_ERROR);
+        }
+        const [sqlDatabase, sqlTable, fields] = arr;
+        const { dbType, dbName } = (0, DatabaseName_1.parseDatabaseName)(sqlDatabase);
+        const fieldsArr = fields
+            .split(',')
+            .map(s => s.trim())
+            .filter(Boolean);
+        if (fieldsArr.length < 2) {
+            throw new devops_1.BizException('linkToCustom枚举值查询字符串，fields字段必须符合固定格式', exceptions_1.Exceptions.CFG_ERROR);
+        }
+        const valueKey = fieldsArr[0];
+        const labelKey = fieldsArr[1];
+        const isObjectMode = fieldsArr.length > 2 || labelKey === "*";
+        const res1 = await this.curdProService.executeCrudByCfg({
+            condition: {},
+            columns: labelKey === "*" ? null : fields,
+            limit: 4000,
+            offset: 0,
+        }, {
+            sqlTable,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: dbName,
+            sqlDdType: dbType,
+            maxLimit: 4000,
+        });
+        const rows = res1.getResRows();
+        const map = new Map();
+        for (let i = 0; i < rows.length; i++) {
+            const rowObj = rows[i];
+            const value = rowObj[valueKey];
+            if (typeof value !== 'undefined') {
+                const valueStr = "" + value;
+                if (isObjectMode) {
+                    map.set(valueStr, rowObj);
+                }
+                else {
+                    const label = rowObj[labelKey];
+                    if (label) {
+                        map.set(valueStr, label);
+                    }
+                }
+            }
+        }
+        return map;
+    }
+    async loadInfoByLinkToCustomMap(relations) {
+        const bigMap = new Map();
+        for (let i = 0; i < relations.length; i++) {
+            const relation = relations[i];
+            const code = relation.relatedCode || "";
+            const codeTrim = code.trim();
+            const map = await this.queryInfoByLinkToCustom(codeTrim);
+            bigMap.set(codeTrim, map);
+        }
+        return bigMap;
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], CurdMixByLinkToCustomService.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdProService_1.CurdProService)
+], CurdMixByLinkToCustomService.prototype, "curdProService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", RedisCacheService_1.RedisCacheService)
+], CurdMixByLinkToCustomService.prototype, "redisCacheService", void 0);
+CurdMixByLinkToCustomService = __decorate([
+    (0, core_1.Provide)()
+], CurdMixByLinkToCustomService);
+exports.CurdMixByLinkToCustomService = CurdMixByLinkToCustomService;

package/dist/service/curd/CurdMixBySysConfigService.d.ts

@@ -0,0 +1,9 @@
+import { Context } from '@midwayjs/koa';
+import { CurdProService } from './CurdProService';
+import { ExecuteContext, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
+export declare class CurdMixBySysConfigService implements IExecuteContextHandler {
+    ctx: Context;
+    protected curdProService: CurdProService;
+    handleExecuteContextPrepare(executeContext: ExecuteContext): Promise<void>;
+    handleExecuteContext(executeContext: ExecuteContext): Promise<void>;
+}

package/dist/service/curd/CurdMixBySysConfigService.js

@@ -0,0 +1,78 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurdMixBySysConfigService = void 0;
+const core_1 = require("@midwayjs/core");
+const CurdProService_1 = require("./CurdProService");
+const CurdMixUtils_1 = require("./CurdMixUtils");
+const _ = require("lodash");
+const SystemTables_1 = require("../../models/SystemTables");
+const keys_1 = require("../../libs/crud-pro/models/keys");
+const MultiKeyMap_1 = require("../../libs/crud-pro/utils/MultiKeyMap");
+const parseConfig_1 = require("../../libs/utils/parseConfig");
+const dictMixUtils = new CurdMixUtils_1.CrudMixUtils(CurdMixUtils_1.RelatedType.sysCfgEnum);
+const TMP_CTX_KEY = _.uniqueId('CurdMixBySysConfigService');
+let CurdMixBySysConfigService = class CurdMixBySysConfigService {
+    async handleExecuteContextPrepare(executeContext) {
+        const codes = dictMixUtils.pickColumnRelationCodes(executeContext);
+        if (!codes || codes.length === 0) {
+            return;
+        }
+        const res1 = await this.curdProService.executeCrudByCfg({
+            condition: { config_code: { $in: codes } },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_configs,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+            sqlDatabase: SystemTables_1.SystemDbName,
+            sqlDdType: SystemTables_1.SystemDbType,
+        });
+        const rows = res1.getResRows();
+        const multiKeyMap = new MultiKeyMap_1.MultiKeyMap();
+        if (Array.isArray(rows)) {
+            for (let i = 0; i < rows.length; i++) {
+                const row = rows[i];
+                const { config_code } = row;
+                const config_content_rows = (0, parseConfig_1.parseConfigContentToEnumInfo)(row); // 数组元素必须有value字段
+                multiKeyMap.addRowsValue1(config_content_rows, config_code, 'value');
+            }
+        }
+        executeContext[TMP_CTX_KEY] = multiKeyMap;
+    }
+    async handleExecuteContext(executeContext) {
+        const multiKeyMap = executeContext[TMP_CTX_KEY];
+        if (!multiKeyMap || multiKeyMap.isEmpty()) {
+            return;
+        }
+        dictMixUtils.forEachRowAndColumnsRelation(executeContext, (row, columnRelation) => {
+            const sourceColumn = columnRelation.sourceColumn;
+            const targetColumns = columnRelation.targetColumns;
+            if (!Array.isArray(targetColumns) || targetColumns.length === 0) {
+                columnRelation.targetColumns = [
+                    { from: 'label', to: `${sourceColumn}_info.label` },
+                    { from: 'style', to: `${sourceColumn}_info.style` },
+                ];
+            }
+            dictMixUtils.copyColumnRelationToRow(row, multiKeyMap, columnRelation);
+        });
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], CurdMixBySysConfigService.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdProService_1.CurdProService)
+], CurdMixBySysConfigService.prototype, "curdProService", void 0);
+CurdMixBySysConfigService = __decorate([
+    (0, core_1.Provide)()
+], CurdMixBySysConfigService);
+exports.CurdMixBySysConfigService = CurdMixBySysConfigService;

package/dist/service/curd/CurdMixByWorkbenchService.d.ts

@@ -0,0 +1,10 @@
+import { Context } from '@midwayjs/koa';
+import { CurdProService } from './CurdProService';
+import { ExecuteContext, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
+export declare class CurdMixByWorkbenchService implements IExecuteContextHandler {
+    ctx: Context;
+    protected curdProService: CurdProService;
+    private loadWorkbenchListMap;
+    handleExecuteContextPrepare(executeContext: ExecuteContext): Promise<void>;
+    handleExecuteContext(executeContext: ExecuteContext): Promise<void>;
+}

package/dist/service/curd/CurdMixByWorkbenchService.js

@@ -0,0 +1,76 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurdMixByWorkbenchService = void 0;
+const core_1 = require("@midwayjs/core");
+const _ = require("lodash");
+const lru_cache_1 = require("lru-cache");
+const CurdProService_1 = require("./CurdProService");
+const CurdMixUtils_1 = require("./CurdMixUtils");
+const SystemTables_1 = require("../../models/SystemTables");
+const keys_1 = require("../../libs/crud-pro/models/keys");
+const MixinUtils_1 = require("../../libs/crud-pro/utils/MixinUtils");
+const lruCache = new lru_cache_1.LRUCache({
+    max: 500,
+    ttl: 1000 * 60 * 5,
+    ttlAutopurge: true,
+});
+const workbenchMixUtils = new CurdMixUtils_1.CrudMixUtils(CurdMixUtils_1.RelatedType.workbenchBasic);
+const TMP_CTX_KEY = _.uniqueId('CurdMixByWorkbenchService');
+let CurdMixByWorkbenchService = class CurdMixByWorkbenchService {
+    async loadWorkbenchListMap() {
+        let workbenchListMap = lruCache.get('workbenchListMap');
+        if (!workbenchListMap) {
+            const reqJson = {
+                columns: 'workbench_code,workbench_name,workbench_domain',
+                condition: {},
+            };
+            const res = await this.curdProService.executeCrudByCfg(reqJson, {
+                sqlTable: SystemTables_1.SystemTables.sys_workbench,
+                sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+                sqlDatabase: SystemTables_1.SystemDbName,
+                sqlDdType: SystemTables_1.SystemDbType,
+            });
+            const workbenchList = res.getResRows();
+            workbenchListMap = MixinUtils_1.MixinUtils.toNewMap(workbenchList, (obj) => obj.workbench_code);
+            lruCache.set('workbenchListMap', workbenchListMap);
+        }
+        return workbenchListMap;
+    }
+    async handleExecuteContextPrepare(executeContext) {
+        const relations = workbenchMixUtils.pickColumnRelations(executeContext);
+        if (!relations || relations.length === 0) {
+            return;
+        }
+        executeContext[TMP_CTX_KEY] = await this.loadWorkbenchListMap();
+    }
+    async handleExecuteContext(executeContext) {
+        const userInfoMap = executeContext[TMP_CTX_KEY];
+        if (!userInfoMap || userInfoMap.size === 0) {
+            return;
+        }
+        workbenchMixUtils.forEachRowAndColumnsRelation(executeContext, (row, columnRelation) => {
+            workbenchMixUtils.copyColumnRelationToRowNoRelatedCode(row, userInfoMap, columnRelation);
+        });
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], CurdMixByWorkbenchService.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdProService_1.CurdProService)
+], CurdMixByWorkbenchService.prototype, "curdProService", void 0);
+CurdMixByWorkbenchService = __decorate([
+    (0, core_1.Provide)()
+], CurdMixByWorkbenchService);
+exports.CurdMixByWorkbenchService = CurdMixByWorkbenchService;

package/dist/service/curd/CurdMixService.d.ts

@@ -0,0 +1,17 @@
+import { IRequestCfgModel, IRequestModel, ISqlCfgModel } from '../../libs/crud-pro/interfaces';
+import { IRequestCfgModel2 } from '../../models/bizmodels';
+import { SqlDbType } from "../../libs/crud-pro/models/keys";
+export declare class CurdMixService {
+    private curdProService;
+    private curdMixByDictService;
+    private curdMixBySysConfigService;
+    private curdMixByAccountService;
+    private curdMixByWorkbenchService;
+    private curdMixByLinkToCustomService;
+    private prepare;
+    executeCrudByCfg(reqJson: IRequestModel, cfgModel: IRequestCfgModel2): Promise<import("../../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
+    getBbUtil(database: string, sqlDdType: SqlDbType): import("./CurdProService").DBUtils;
+    executeSQL(sqlCfgModel: ISqlCfgModel): Promise<any>;
+    executeCrud(reqJson: IRequestModel): Promise<import("../../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
+    getCachedCfgByMethod(method: string): Promise<IRequestCfgModel>;
+}

package/dist/service/curd/CurdMixService.js

@@ -0,0 +1,76 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurdMixService = void 0;
+const core_1 = require("@midwayjs/core");
+const CurdProService_1 = require("./CurdProService");
+const CurdMixByDictService_1 = require("./CurdMixByDictService");
+const CurdMixBySysConfigService_1 = require("./CurdMixBySysConfigService");
+const CurdMixByAccountService_1 = require("./CurdMixByAccountService");
+const CurdMixUtils_1 = require("./CurdMixUtils");
+const CurdMixByWorkbenchService_1 = require("./CurdMixByWorkbenchService");
+const CurdMixByLinkToCustomService_1 = require("./CurdMixByLinkToCustomService");
+let CurdMixService = class CurdMixService {
+    prepare() {
+        this.curdProService.setResponseCfgHandlers(CurdMixUtils_1.RelatedType.dict, this.curdMixByDictService);
+        this.curdProService.setResponseCfgHandlers(CurdMixUtils_1.RelatedType.sysCfgEnum, this.curdMixBySysConfigService);
+        this.curdProService.setResponseCfgHandlers(CurdMixUtils_1.RelatedType.accountBasic, this.curdMixByAccountService);
+        this.curdProService.setResponseCfgHandlers(CurdMixUtils_1.RelatedType.workbenchBasic, this.curdMixByWorkbenchService);
+        this.curdProService.setResponseCfgHandlers(CurdMixUtils_1.RelatedType.linkToCustom, this.curdMixByLinkToCustomService);
+    }
+    async executeCrudByCfg(reqJson, cfgModel) {
+        this.prepare();
+        return this.curdProService.executeCrudByCfg(reqJson, cfgModel);
+    }
+    getBbUtil(database, sqlDdType) {
+        this.prepare();
+        return this.curdProService.getBbUtil(database, sqlDdType);
+    }
+    async executeSQL(sqlCfgModel) {
+        this.prepare();
+        return this.curdProService.executeSQL(sqlCfgModel);
+    }
+    async executeCrud(reqJson) {
+        this.prepare();
+        return this.curdProService.executeCrud(reqJson);
+    }
+    async getCachedCfgByMethod(method) {
+        return this.curdProService.getCachedCfgByMethod(method);
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdProService_1.CurdProService)
+], CurdMixService.prototype, "curdProService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdMixByDictService_1.CurdMixByDictService)
+], CurdMixService.prototype, "curdMixByDictService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdMixBySysConfigService_1.CurdMixBySysConfigService)
+], CurdMixService.prototype, "curdMixBySysConfigService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdMixByAccountService_1.CurdMixByAccountService)
+], CurdMixService.prototype, "curdMixByAccountService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdMixByWorkbenchService_1.CurdMixByWorkbenchService)
+], CurdMixService.prototype, "curdMixByWorkbenchService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdMixByLinkToCustomService_1.CurdMixByLinkToCustomService)
+], CurdMixService.prototype, "curdMixByLinkToCustomService", void 0);
+CurdMixService = __decorate([
+    (0, core_1.Provide)()
+], CurdMixService);
+exports.CurdMixService = CurdMixService;

package/dist/service/curd/CurdMixUtils.d.ts

@@ -0,0 +1,28 @@
+import { ColumnRelation } from '../../libs/crud-pro/interfaces';
+import { ExecuteContext } from '../../libs/crud-pro/models/ExecuteContext';
+import { MultiKeyMap } from '../../libs/crud-pro/utils/MultiKeyMap';
+declare enum RelatedType {
+    dict = "dict",
+    sysCfgEnum = "sysCfgEnum",
+    linkToCustom = "linkToCustom",
+    accountBasic = "accountBasic",
+    workbenchBasic = "workbenchBasic"
+}
+declare type FuncRowColumnRelation = (row: any, columnRelation: ColumnRelation) => void;
+declare class CrudMixUtils {
+    private readonly relatedType;
+    constructor(relatedType: RelatedType);
+    private getColumnsRelation;
+    pickColumnRelations(exeCtx: ExecuteContext): ColumnRelation[];
+    pickColumnRelationCodes(exeCtx: ExecuteContext): string[];
+    forEachRowAndColumnsRelation(exeCtx: ExecuteContext, func: FuncRowColumnRelation): void;
+    copyColumnRelationToRow(row: any, multiKeyMap: MultiKeyMap, columnRelation: ColumnRelation): void;
+    /**
+     * 无relatedCode模式
+     * @param row
+     * @param map
+     * @param columnRelation
+     */
+    copyColumnRelationToRowNoRelatedCode(row: any, map: Map<string, any>, columnRelation: ColumnRelation): void;
+}
+export { CrudMixUtils, RelatedType, FuncRowColumnRelation };