doomiwork 3.7.12 → 4.0.0

package/configuration/appsetting.js

@@ -1,8 +1,4 @@
-/**
- * configuration文件中AppSetting一节中的配置参数封装访问
- */
-var utility         = require('doomi-helper').commonHelper
-const path          = require('path');
+const path          = require('path');
 const fs            = require('fs');
 class appsetting{
     constructor(){
@@ -29,7 +25,7 @@ class appsetting{
     getSetting (settingKey,defaultValue) {
         if (!this.settingjson || !this.settingjson.appsetting) return defaultValue;
        const item= this.settingjson.appsetting[settingKey];
-       return utility.ifNull(item,defaultValue);
+       return item??defaultValue;
     }
     getSection(sectionName){
         return this.settingjson[sectionName];

package/configuration/routerconfig.js

@@ -1,144 +1,142 @@
 /*
 * dataconfig配置文件的处理模块
 */
-const fs            = require('fs');
-const path          = require('path')
+const fs = require('fs');
+const path = require('path')
 ////扫描Controller文件夹时需要排除的目录
-const IGNORE_FOLDER = ["script","scripts","js","image","data","video","images","style","css","app_themes"];
-class routerconfig {
-    constructor(routerfile) {
-        ///路由的配置文件
-        let configfile = path.join(process.cwd(), routerfile || 'routerconfig.json');
-        if (fs.existsSync(configfile)) {
-            this.routerconfig = require(configfile);
-        } else {
-            this.routerconfig = [];
-        }
-    }
-    /**
-     * 单例模式
-     * @param {*} config 
-     */
-    static getInstance() {
-        if (!routerconfig.setting) routerconfig.setting = new routerconfig();
-        return routerconfig.setting;
-    }
-    /**
-     * start all router in configuration
-     * @param {*} controllerconfig 
-     * @param {*} providerCollection 
-     */
-    loadController(app,routelist) {
-        ///定位置项目启动目录，准备遍历所有controller目录
-        let startupRoot = process.cwd();
-        let routes = routelist?routelist:this.routerconfig ;
-        
-        routes.forEach(element => {
-            //if (!element.routers || element.routers.length == 0) return;
-            ///路由被禁用，则略过
-            if (element.disabled) return;
-            ///包含文件
-            if (element.include) {
-                var includeRouteJson = path.join(startupRoot, element.include);
-                ///如果包含文件存在，则加载这个文件里面的路由
-                if (fs.existsSync(includeRouteJson)) {
-                    this.loadController(app,require(includeRouteJson));
-                }
-            }
-            else {
-                var modules = [];
-                let {baseUrl,groupName }  = element.routefolder?element.routefolder:element;
-                if (groupName && app.Interceptor[groupName]) app.use(baseUrl,app.Interceptor[groupName])
-                if (element.routefolder) {
-                    if (element.routefolder.folder) this.loadFolderFiles4Router(modules, element.routefolder);
-                }
-                ////单文件
-                else {
-                    if (fs.existsSync(path.join(startupRoot, element.controller)))
-                        modules.push(path.join(startupRoot, element.controller));
-                }
-
-                ////单个文件的加载
-                if (modules.length > 0) {
-                    modules.forEach(modulePath => {
-                        app.logger.trace('initlize controller [%s] for baseUrl [%s]',modulePath,baseUrl);
-                        var controllModule = require(modulePath);
-                        var controller = new controllModule(app);
-                        app.use(baseUrl, controller.router);
-                    })
-
-                }
-            }
-        });
-    }
-    /**
-     * 设置路由的认证中间组件
-     * @param {*} url 
-     * @param {*} providerCollection 
-     * @param {*} authorizeName 
-     */
-    // setAuthorizationProvider(app, url, authProvider) {
-    //     ////该控制器下的所有路由需要身份验证
-    //     if (authProvider)
-    //         app.use(url, authProvider.module.checkAuthorization);
-    // }
-    /**
+const IGNORE_FOLDER = ["script", "scripts", "js", "image", "data", "video", "images", "style", "css", "app_themes"];
+/**
      * 加载控制器目录下的所有JS文件形成路由
      * @param {*} result 
      * @param {*} routeGroup 
      */
-    loadFolderFiles4Router(result, routeGroup) {
-        let exceptFile = routeGroup.exceptfile;
-        let exceptfolder = routeGroup.exceptfolder;
-        let scanFolder = path.join(process.cwd(), routeGroup.folder);
-        this.getFolderControllerFiles(result, scanFolder, exceptFile, exceptfolder);
+function loadFolderFiles4Router(result, startPath, routeGroup) {
+    let exceptFile = routeGroup.exceptfile;
+    let exceptfolder = routeGroup.exceptfolder;
+    let scanFolder = path.join(startPath, routeGroup.folder);
+    getFolderControllerFiles(result, scanFolder, exceptFile, exceptfolder);
+}
+/**
+ * 遍历加载整个文件夹下面的所有文件形成路由
+ * @param {*} result 
+ * @param {*} startPath 
+ * @param {*} execfiles 
+ * @param {*} execfolder 
+ */
+function getFolderControllerFiles(result, startPath, execfiles, execfolder) {
+    let files = fs.readdirSync(startPath);
+    for (const val of files) {
+        let fPath = path.join(startPath, val);
+        let stats = fs.statSync(fPath);
+        ////是个目录
+        if (stats.isDirectory()) {
+            if (execfolder == null || execfolder.indexOf(fileName) < 0)
+                findFolderFiles(result, fPath, fPath, execfiles, execfolder);
+        }
+        ///是个文件
+        else if (stats.isFile()) {
+            let fileExtion = path.extname(fPath).toLowerCase();
+            if (fileExtion !== ".js") continue;
+            let fileName = path.basename(fPath);
+            fileName = fileName.substr(0, fileName.length - fileExtion.length);
+            if (!execfiles || execfiles.indexOf(fileName) < 0) result.push(fPath);
+        }
     }
+}
 
-    /*
-    * 遍历加载整个文件夹下面的所有文件形成路由
-    */
-    getFolderControllerFiles(result, startPath, execfiles, execfolder) {
-        let files = fs.readdirSync(startPath);
-        files.forEach((val) => {
-            let fPath = path.join(startPath, val);
-            let stats = fs.statSync(fPath);
-            if (stats.isDirectory()) {
-                if (execfolder == null || execfolder.indexOf(fileName) < 0)
-                    this.findFolderFiles(result, fPath, fPath, execfiles, execfolder);
+/**
+ * 遍历加载整个文件夹下面的所有文件形成路由
+ * @param {*} result 
+ * @param {*} baseFolder 
+ * @param {*} startPath 
+ * @param {*} execfiles 
+ * @param {*} execfolder 
+ */
+function findFolderFiles(result, baseFolder, startPath, execfiles, execfolder) {
+    let files = fs.readdirSync(startPath);
+    // files.forEach((val) => {
+    for (const val of files) {
+        let fPath = path.join(startPath, val), stats = fs.statSync(fPath), fileName = fPath.substr(baseFolder.length + 1);
+        if (stats.isDirectory()) {
+            ///排除基本的忽略目录
+            if (IGNORE_FOLDER.includes(fileName.toLowerCase())) continue;
+            if (execfolder == null || execfolder.indexOf(fileName) < 0)
+                findFolderFiles(result, baseFolder, fPath, execfiles, execfolder);
+        }
+        if (stats.isFile()) {
+            let fileExtion = path.extname(fPath).toLowerCase();
+            if (fileExtion != ".html") continue;
+            let fileName = fPath.substr(baseFolder.length + 1);
+            fileName = fileName.substr(0, fileName.length - fileExtion.length);
+            if (execfiles == null || execfiles.indexOf(fileName) < 0) result.push(fileName);
+        }
+    }
+}
+// class routerconfig {
+// constructor(routerfile) {
+//     ///路由的配置文件
+//     let configfile = path.join(process.cwd(), routerfile || 'routerconfig.json');
+//     if (fs.existsSync(configfile)) {
+//         this.routerconfig = require(configfile);
+//     } else {
+//         this.routerconfig = [];
+//     }
+// }
+// /**
+//  * 单例模式
+//  * @param {*} config 
+//  */
+// static getInstance() {
+//     if (!routerconfig.setting) routerconfig.setting = new routerconfig();
+//     return routerconfig.setting;
+// }
+/**
+ * 加载应用下所有配置的controller文件
+ * @param {*} controllerconfig 
+ * @param {*} providerCollection 
+ */
+module.exports.loadController=(app, routes)=> {
+    ///定位置项目启动目录，准备遍历所有controller目录
+    if (!Array.isArray(routes) || !routes.length) return;
+    let startupRoot = process.cwd();
+    //let routes = routelist?routelist:this.routerconfig ;
+    for (const element of routes) {
+        //if (!element.routers || element.routers.length == 0) return;
+        ///路由被禁用，则略过
+        if (element.disabled) continue;
+        ///包含文件
+        if (element.include) {
+            let includeRouteJson = path.join(startupRoot, element.include);
+            ///如果包含文件存在，则加载这个文件里面的路由
+            if (fs.existsSync(includeRouteJson)) {
+                this.loadController(app, require(includeRouteJson));
             }
-            if (stats.isFile()) {
-                let fileExtion = path.extname(fPath).toLowerCase();
-                if (fileExtion !== ".js") return;
-                let fileName = path.basename(fPath);
-                fileName = fileName.substr(0, fileName.length - fileExtion.length);
-                if (!execfiles || execfiles.indexOf(fileName) < 0) result.push(fPath);
+        }
+        else {
+            let modules = [];
+            let { baseUrl, groupName } = element.routefolder ? element.routefolder : element;
+            if (groupName && app.Interceptor[groupName]) app.use(baseUrl, app.Interceptor[groupName])
+            if (element.routefolder) {
+                if (element.routefolder.folder) loadFolderFiles4Router(modules, startupRoot, element.routefolder);
             }
-        });
-    }
-
-    /*
-   * 遍历加载整个文件夹下面的所有文件形成路由
-   */
-    findFolderFiles(result, baseFolder, startPath, execfiles, execfolder) {
-        let files = fs.readdirSync(startPath);
-        files.forEach((val) => {
-            let fPath = path.join(startPath, val);
-            let stats = fs.statSync(fPath);
-            let fileName = fPath.substr(baseFolder.length + 1);
-            if (stats.isDirectory()) {
-                ///排除基本的忽略目录
-                if (IGNORE_FOLDER.indexOf(fileName.toLowerCase()) >= 0) return;
-                if (execfolder == null || execfolder.indexOf(fileName) < 0)
-                    this.findFolderFiles(result, baseFolder, fPath, execfiles, execfolder);
+            ////单文件
+            else {
+                if (fs.existsSync(path.join(startupRoot, element.controller)))
+                    modules.push(path.join(startupRoot, element.controller));
             }
-            if (stats.isFile()) {
-                let fileExtion = path.extname(fPath).toLowerCase();
-                if (fileExtion != ".html") return;
-                let fileName = fPath.substr(baseFolder.length + 1);
-                fileName = fileName.substr(0, fileName.length - fileExtion.length);
-                if (execfiles == null || execfiles.indexOf(fileName) < 0) result.push(fileName);
+            ////单个文件的加载
+            if (modules.length > 0) {
+                for (const modulePath of modules) {
+                    if (app.logger) app.logger.trace('initlize controller [%s] for baseUrl [%s]', modulePath, baseUrl);
+                    const controllModule = require(modulePath);
+                    const controller = new controllModule(app);
+                    app.use(baseUrl, controller.router);
+                }
+
             }
-        });
+        }
     }
 }
-module.exports = routerconfig;
+
+// }
+// module.exports = routerconfig;

package/core/actionresult.js

@@ -1,4 +1,4 @@
-var errnum = require('./enumconst')
+const errnum = require('./enumconst')
 
 class ActionResult {
     constructor({ successed = true, errcode = 0, errmessage = '', data = [] }) {

package/core/controller.js

@@ -5,14 +5,14 @@
 *       基类主要实现了数据基础的增删改查的基本操作，如无特殊业务逻辑子类已无需再
 *   重新实现，如有特殊的业务可以重写几个方法
 */
-var express         = require('express');
-var parse           = require('../utilities/transferutility');
-const {commonHelper, excelHelper,stringHelper } = require('doomi-helper');
-const constEnum     = require('./enumconst');
-var rcp             = require('../utilities/requestparser');
-var apiResult       = require('./actionresult');
-var daoBase         = require('./database/daoBase');
-const exportUtility = excelHelper.getInstance();
+const express           = require('express');
+const {Data2View,View2Data} = require('../utilities/transferutility');
+const ExcelUtility      = require('../utilities/excelutility');
+const constEnum         = require('./enumconst');
+const { getListInfo, getDetailInfo, parseTagInSql }               = require('../utilities/requestparser');
+const apiResult         = require('./actionresult');
+const daoBase           = require('./database/daoBase');
+const exportUtility     = ExcelUtility.getInstance();
 
 class controller {
     /**
@@ -22,14 +22,16 @@ class controller {
      */
     constructor(application, dao) {
         this.app = application;
-        if (application.redis) this._redisHelper = this.app.redis;
+        ///高速缓存
+        this._redisHelper = this.app.redis;
         ///日志记录器
         this.logger = this.app.logger;
         ///用户行为记录器
-        this.actionLogger = application.actionLogger;
+        this.actionLogger = this.app.actionLogger;
         ///需要数据访问实体的实例
         this._daoModel = dao?dao:new daoBase();
         this._daoModel.actionLogger = this.actionLogger;
+        this._daoModel.logger =  application.logger;
         this._router = express.Router();
         ///实现的集成类中只需要去重写此方法
         this.initializeRouter(this);
@@ -84,12 +86,6 @@ class controller {
                result = await instance[actionType.func](req, datakey);
             ////执行完CRUD方法之后的处理
             result = await instance.afterCRUD(result,actionType,datakey,url,req,res)
-
-            //CJJ add
-            // if (req.query.exportexcel === 'true' && result.buffer && result.successed) {
-            //     res.attachment('export.xlsx');
-            //     return res.end(result.buffer);
-            // }
             return res.json(result)
         })
     }
@@ -105,7 +101,7 @@ class controller {
      */
     initializeCRUDRouter(url, datakey, action = 'SCRUD', middleware){
         if(!url || !datakey)  return;
-        let urlWithId = stringHelper.endsWith(url,'/')?`${url}:id`:`${url}/:id`;
+        let urlWithId = url.endsWith('/')?`${url}:id`:`${url}/:id`;
         if (action.indexOf('C') >= 0) this.createCRUDRoute(constEnum.CRUDAction.Create, url, datakey, middleware)
         if (action.indexOf('S') >= 0) this.createCRUDRoute(constEnum.CRUDAction.Single, urlWithId, datakey, middleware)
         if (action.indexOf('R') >= 0) this.createCRUDRoute(constEnum.CRUDAction.Retrieve, url, datakey, middleware)
@@ -118,7 +114,7 @@ class controller {
      * @param {*} result 
      * @param {*} action 
      */
-    async beforeCRUD(action,req,res){
+    async beforeCRUD(_action, _req,_res){
         return {successed:true}
     }
     /**
@@ -126,7 +122,7 @@ class controller {
      * @param {*} result 
      * @param {*} action 
      */
-    async afterCRUD(result,action,datakey,url, req,res){
+    async afterCRUD(result,_action,_datakey,_url, _req,_res){
         return result;
     }
     /*
@@ -134,12 +130,12 @@ class controller {
     * 除了在routerConfig中配置的路由以外，继承的子类可以重写实现此方法来
     * 继续配置你的路由
     */
-    initializeRouter(instance) { }
+    initializeRouter(_instance) { }
     /*
     *  数据加载之前的动作
     *  子类可以重写该方法
     */
-    async beforeAccessDB(req, sql, sqlParams, type, instance) {
+    async beforeAccessDB(_req, sql, sqlParams, _type, _instance) {
         return { sql: sql, sqlParams: sqlParams, canceled: false };
     }
     /**
@@ -156,7 +152,7 @@ class controller {
     async batchUpdate(req,model,id){
         if (!id) id = req.params.id;
         if (!id) return {successed:false,errcode:-2,errmsg:'缺失批量操作的id'}
-        let batchSql = rcp.parseAndReplaceSql(req,this._daoModel.BatchSql());
+        let batchSql = parseTagInSql(req,this._daoModel.BatchSql());
         let result = await this._daoModel.batchUpdate(batchSql, model, id, req.user?.id)
         this.logUserAction(req,this._daoModel.getBusiness(),6,result.successed?0:-1);
         return result;
@@ -165,13 +161,14 @@ class controller {
     * 获取查询列表记录的方法
     */
     async getListData(req, dataKey, configFile = 0) {
-        this.logger.trace("准备获取dataconfig文件中对应的 %s list数据",dataKey)
-        req.dataKey = dataKey;
-        rcp.getListInfo(req, configFile,this._daoModel);
+        if (this.logger) this.logger.trace("准备获取dataconfig文件中对应的 %s list数据",dataKey)
+        const listinfo = getListInfo(req, dataKey, configFile,this._daoModel);
+        if (!listinfo) return { successed: false, errcode: -10, errmsg:`缺失${dataKey}对应的查询语句`};
+
         ////直接操作数据库之前，可由子类再次Handler
-        let beforeData = await this.beforeAccessDB(req, req.listSql, req.sqlParams, "list", this);
+        let beforeData = await this.beforeAccessDB(req, listinfo.sql,null, "list", this);
         ////如果返回Null,则表示不加载数据了
-        if (beforeData.canceled != null && beforeData.canceled == true) return { successed: false, errorcode: 1, errormessage: "canceled" };
+        if (beforeData.canceled === true) return { successed: false, errorcode: 1, errmsg: "操作取消" };
         ////操作数据库
         let result = await this._daoModel.loadData(beforeData.sql, beforeData.sqlParams);
         if(!result.successed) {
@@ -179,49 +176,55 @@ class controller {
             if (req.query.exportexcel==='true') this.logUserAction(req,this._daoModel.getBusiness(),5,-1);
             return result;
         }
-        if (result.rows != null) {
+        ///从数据库中获取到了原始数据
+        if (result.rows) {
             ///将从数据库中获得的结果集根据dataconfig中的配置进行映射转换
-            let resultItem = parse.transferName2Mapping(result.rows[0], req.fieldsMapping)
-            ///输出的结果是否需要装饰带有successed,total等，便于
-            //给grid进行绑定
-            let outputData = { "successed": true, page: req.page, rows: resultItem.data };
+            let resultItem = Data2View(result.rows[0], listinfo.fields)
+            ///输出的结果是否需要装饰带有successed,total等，便于列表
+            let outputData = { successed: true, page: listinfo.page, rows: resultItem.data };
             ///需要进行尾部统计的列表
-            if (req.countSql) {
-                let footerItem = parse.transferName2Mapping(result.rows[2], req.footerMapping)
+            if (listinfo.hascounter) {
+                let footerItem = Data2View(result.rows[2], listinfo.footers)
                 outputData.footer = footerItem.data;
             }
-            outputData.total = result.rows[1][0].total;
+            outputData.total = await this.getListRecordCount(result);
             ///处理导出Excel
             if (req.query.exportexcel==='true') {
                 outputData= await this.export2Excel(outputData.rows,req.query.excelkey || dataKey)
                 this.logUserAction(req,this._daoModel.getBusiness(),5,0);
             }
-            
             return outputData;
         }
         return {successed:false, errcode: -1, total: 0, rows: [] };
     }
+    /**
+     * 返回数据结果的记录总数
+     * @param {*} data 
+     */
+    async getListRecordCount(data){
+        return result.rows[1][0].total;
+    }
     /*
     * 获取详细记录的方法
     */
     async getDataById(req, dataKey, sqlCommand) {
-        this.logger.trace("准备获取dataconfig文件中对应的 %s 详细数据",dataKey)
-        req.dataKey = dataKey;
-        rcp.getDetailInfo(req);
+        if (this.logger) this.logger.trace("准备获取dataconfig文件中对应的 %s 详细数据",dataKey)
+        const detailinfo = getDetailInfo(dataKey);
+        if (!detailinfo) return { successed: false, errcode: -10, errmsg: `缺失${dataKey}对应的详情配置` };
         let beforeData = await this.beforeAccessDB(req, sqlCommand || this._daoModel.getByIdSql(), req.params.id, "detail", this);
         ////如果返回Null,则表示不加载数据了
-        if (beforeData.canceled) return { successed: false, errorcode: 1, errormessage: "canceled" };
+        if (beforeData.canceled===true) return { successed: false, errorcode: 1, errormessage: "操作已取消" };
         /////处理SQL中的一些定义符
-        let parseSql = rcp.parseAndReplaceSql(req,beforeData.sql);
+        let parseSql = parseTagInSql(req,beforeData.sql);
         ////操作数据库
         let result = await this._daoModel.getBykey(parseSql, beforeData.sqlParams);
         if (!result.successed) return result;
-        if (result.rows != null && result.rows.length == 1) {
+        if (result.rows && result.rows.length == 1) {
             ///如果对象有数据权限控制，则需要插入
             ///提交的权限设置
-            
             ///将从数据库中获得的结果集根据dataconfig中的配置进行映射转换
-            let resultMapping = await parse.transferName2Mapping(result.rows, req.fieldsMapping);
+            let resultMapping = Data2View(result.rows, detailinfo.fields);
+            ///如果业务对象具备权限控制的业务，则需要将该数据的所赋予的权限对象加载出来
             if (this._daoModel.hasPermissionControl) {
                 const accessResult = await this._daoModel.getDataPermissionSetting(req.params.id,this.PermissonBusiness(req))
                 if (accessResult.successed) {
@@ -237,36 +240,34 @@ class controller {
     * 新增实体记录的方法
     */
     async create(req, dataKey, sqlCommand) {
-        this.logger.trace("准备根据dataconfig文件中对应的 %s 配置插入数据",dataKey)
-        let mapping = commonHelper.ifNull(req.query.Mapping, true);
-        let resultItem = { successed: true, data: req.body };
+        if (this.logger) this.logger.trace("准备根据dataconfig文件中对应的 %s 配置插入数据",dataKey)
+        let mapping = req.query.Mapping??true; //|| 'true'==='true' ;//commonHelper.ifNull(req.query.Mapping, true);
+        let detailinfo, resultItem = { successed: true, data: req.body };
         ///是否需要将data中的key-value值到配置文件中进行转换
         if (mapping == true) {
-            req.dataKey = dataKey;
-            rcp.getDetailInfo(req);
-            resultItem = parse.transferMapping2Name(req, req.fieldsMapping, "create");
+            detailinfo = getDetailInfo(dataKey);
+            if (!detailinfo) return { successed: false, errcode: -10, errmsg: `缺失${dataKey}对应的详情配置` };
+            resultItem = View2Data(req, detailinfo.fields, "create");
             ///如果转换的验证过程中出现错误，则返回
-            if (!resultItem.successed){
-                return resultItem;
-            }
+            if (!resultItem.successed) return resultItem;
         }
         let beforeData = await this.beforeAccessDB(req, sqlCommand || this._daoModel.insertSql(), resultItem.data, "create", this);
         ////如果返回Null,则表示不加载数据了
-        if (beforeData.canceled) return { successed: false, errorcode: 1, errormessage: "canceled" };
-        this.logger.trace("插入数据准备 : ",beforeData)
+        if (beforeData.canceled) return { successed: false, errorcode: 1, errormessage: "操作取消" };
+        if (this.logger) this.logger.trace("插入数据准备 : ",beforeData)
         let result = await this._daoModel.create(beforeData.sql, beforeData.sqlParams, req)
         if(!result.successed) {
             this.logUserAction(req,this._daoModel.getBusiness(),1,-1);
             return result;
         }
         let primaryKey;
-        if (mapping && req.primary) {
+        if (mapping && detailinfo.primary) {
             ///自动增长的主键字段
-            if (req.primaryIsAutoIncrease == true) primaryKey = result.rows.insertId;
+            if (detailinfo.autoincrease === true) primaryKey = result.rows.insertId;
             else {
-                if (typeof (req.primary) === "string") primaryKey = beforeData.sqlParams[req.primary];
-                if (typeof (req.primary) === "object")
-                    primaryKey = req.primary.map(element => { return beforeData.sqlParams[element]; });
+                if (typeof (detailinfo.primary) === "string") primaryKey = beforeData.sqlParams[detailinfo.primary];
+                if (typeof (detailinfo.primary) === "object")
+                    primaryKey = detailinfo.primary.map(element => { return beforeData.sqlParams[element]; });
             }
         }
         ///如果对象有数据权限控制，则需要插入
@@ -290,24 +291,24 @@ class controller {
     * 修改实体记录的方法
     */
     async update(req, dataKey, sqlCommand, id) {
-        this.logger.trace("准备根据dataconfig文件中对应的 %s 配置修改数据",dataKey)
+        if (this.logger)  this.logger.trace("准备根据dataconfig文件中对应的 %s 配置修改数据",dataKey)
         if (id == null) id = req.params.id;
-        let mapping = commonHelper.ifNull(req.query.Mapping, true);
-        var resultItem = { successed: true, data: req.body };
+        let mapping = req.query.Mapping??true;// commonHelper.ifNull(req.query.Mapping, true);
+        let detailinfo, resultItem = { successed: true, data: req.body };
         ///是否需要将data中的key-value值到配置文件中进行转换
         if (mapping == true) {
-            req.dataKey = dataKey;
-            rcp.getDetailInfo(req);
+            detailinfo = getDetailInfo(dataKey);
+            if (!detailinfo) return { successed: false, errcode: -10, errmsg: `缺失${dataKey}对应的详情配置` };
             ///从Request中获取到用户提交的数据
-            resultItem = parse.transferMapping2Name(req, req.fieldsMapping, "update");
+            resultItem = View2Data(req, detailinfo.fields, "update");
         }
         ///如果不需要转换，则直接使用前端提交上来的值
         let beforeData = await this.beforeAccessDB(req, sqlCommand || this._daoModel.updateSql(), resultItem.data, "update", this);
         ////如果返回Null,则表示不加载数据了
-        if (beforeData.canceled) return { successed: false, errorcode: 1, errormessage: "canceled" };
-        this.logger.trace("修改数据准备 : ",beforeData)
+        if (beforeData.canceled) return { successed: false, errorcode: 1, errormessage: "操作取消" };
+        if (this.logger)  this.logger.trace("修改数据准备 : ",beforeData)
         /////处理SQL中的一些定义符
-        let parseSql = rcp.parseAndReplaceSql(req,beforeData.sql);
+        let parseSql = parseTagInSql(req,beforeData.sql);
         let result = await this._daoModel.update(parseSql, beforeData.sqlParams, id);
         if(!result.successed) {
             this.logUserAction(req,this._daoModel.getBusiness(),3,-1);
@@ -340,12 +341,12 @@ class controller {
     * 删除实体记录的方法
     */
     async delete(req, id, sqlCommand) {
-        this.logger.trace("准备删除数据",id)
+        if (this.logger)  this.logger.trace("准备删除数据",id)
         let beforeData = await this.beforeAccessDB(req, sqlCommand || this._daoModel.deleteSql(), id, "delete", this);
         ////如果返回Null,则表示不加载数据了
-        if (beforeData.canceled) return { successed: false, errorcode: 1, errormessage: "canceled" };
+        if (beforeData.canceled) return { successed: false, errorcode: 1, errormessage: "操作取消" };
         /////处理SQL中的一些定义符
-        let parseSql = rcp.parseAndReplaceSql(req,beforeData.sql);
+        let parseSql = parseTagInSql(req,beforeData.sql);
         ////操作数据库
         let result = await this._daoModel.delete(parseSql, beforeData.sqlParams,req.user?.id)
         if(!result.successed) {