doomiwork 4.1.9 → 4.2.0

package/core/actionresult.js

@@ -1,30 +0,0 @@
-const errnum = require('./enumconst')
-
-class ActionResult {
-    constructor({ successed = true, errcode = 0, errmessage = '', data = [] }) {
-        return { successed: successed, errorcode: errorcode, errmessage: errmessage, data: data }
-    }
-    //*为结果添加一些附加的值
-    static decorateResult(result, opts) {
-        Object.keys(opts).forEach(key => {
-            result[key] = opts[key];
-        });
-        return result;
-    }
-}
-ActionResult.DB_CONNECTED_FAILED = { successed: false, errmessage: 'DB_CONNECTED_FAILED', errorcode: errnum.DATABASE_ERROR.DATABASE_CONNECTED_ERROR };
-ActionResult.DB_EXECUTE_FAILED = { successed: false, errorcode: errnum.DATABASE_ERROR.DATABASE_EXECUTE_ERROR };
-ActionResult.DB_NO_EFFECTIVE = { successed: false, errmessage: 'DB_NO_EFFECTIVE', errorcode: errnum.DATABASE_ERROR.NO_RECORD_EFFECTED };
-ActionResult.DB_NO_RECORD_FOUND = { successed: false, errmessage: 'DB_NO_RECORD_FOUND', errorcode: errnum.DATABASE_ERROR.NO_RECORD_FOUND };
-
-ActionResult.SUCCESS_RESULT = { successed: true, errorcode: 0 };
-ActionResult.RETURN_TO_INDEX = { successed: false, errorcode: errnum.COMMON_ERROR.VISIT_TO_INDEX };
-ActionResult.TOKEN_IS_EXPIRED = { successed: false, errmessage: 'TOKEN_IS_EXPIRED', errorcode: errnum.COMMON_ERROR.TOKEN_EXPIRED , total: 0, rows: []  };
-ActionResult.TOKEN_IS_INVALID = { successed: false, errmessage: 'TOKEN_IS_INVALID', errorcode: errnum.COMMON_ERROR.TOKEN_IS_INVALID, total: 0, rows: []   };
-ActionResult.TOKEN_IS_MISSING = { successed: false, errmessage: 'TOKEN_IS_MISSING', errorcode: errnum.COMMON_ERROR.TOKEN_IS_MISSING, total: 0, rows: []   };
-ActionResult.UNAUTHORIZATION_RESULT = { successed: false, errmessage: 'UNAUTHORIZATION_RESULT', errorcode: errnum.COMMON_ERROR.UNAUTHORIZATION_ERROR, total: 0, rows: []  };
-ActionResult.NO_ACCESS_RIGHT_RESULT = { successed: false, errmessage: 'NO_ACCESS_RIGHT_RESULT', errorcode: errnum.COMMON_ERROR.NO_ACCESS_RIGHT, total: 0, rows: []   };
-ActionResult.API_PARAMETERS_ERROR_RESULT = { successed: false, errmessage: 'API_PARAMETERS_ERROR_RESULT', errorcode: errnum.COMMON_ERROR.API_PARAMETERS_ERROR, total: 0, rows: []   };
-ActionResult.VERIFY_CODE_ERROR = { successed: false, errmessage: 'VERIFY_CODE_ERROR', errorcode: errnum.COMMON_ERROR.VERIFY_CODE_ERROR, total: 0, rows: []   };
-
-exports = module.exports = ActionResult;

package/core/controller.js

@@ -1,380 +0,0 @@
-/* 
-*   Controller 基类
-*   所有Node编写的业务处理控制类都集成此基类，路由的配置直接配置在roterConfig.json中
-*   功能：
-*       基类主要实现了数据基础的增删改查的基本操作，如无特殊业务逻辑子类已无需再
-*   重新实现，如有特殊的业务可以重写几个方法
-*/
-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 {
-    /**
-     * 构造函数，每个Controller传递进来本业务的数据访问实例
-     * @param {*} application app 对象
-     * @param {*} dao DAO层
-     */
-    constructor(application, dao) {
-        this.app = application;
-        ///高速缓存
-        this._redisHelper = this.app.redis;
-        ///日志记录器
-        this.logger = this.app.logger;
-        ///用户行为记录器
-        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);
-
-    }
-    get router() { return this._router; }
-    get baseUrl() { return null };
-    /**
-     * 权限的业务sql过滤
-     */
-    PermissonBusiness(_req){
-        return null;
-    }
-   /**
-    * 导出数据到Excel 中
-    * @param {*} data 
-    * @param {*} excelkey 
-    */
-    async export2Excel(data,excelkey) {
-        let excelResult = await exportUtility.recordset2ExcelFile(data,excelkey, this.beforeExportExcel)
-        return excelResult;
-    }
-    /**
-    * 导出数据到Excel的多个workseet中
-    * @param {*} data 
-    * @param {*} excelkey 
-    */
-    async export2MutlisheetExcel(datainfo) {
-        if (!Array.isArray(datainfo) || datainfo.length == 0) return {successed:false};
-        let excelResult = await exportUtility.recordset2MutlisheetExcelFile(datainfo, this.beforeExportExcel)
-        return excelResult;
-    }
-    /**
-     * 写入Excel数据
-     * @param {*} data 
-     * @param {*} excelkey 
-     * @returns 
-     */
-    async writeExcel(data, excelkey){
-        let excelResult = await exportUtility.writeExcel(data, excelkey)
-        return excelResult;
-    }
-    /**
-     * 记录用户的操作行为
-     * req:HttpRequest
-     * business:业务信息
-     * action:操作的行为
-     * successed:操作是否成功
-     * 
-     */
-    logUserAction(req,business,action,successed=0,memo=null){
-        if (this.actionLogger && business && action)  this.actionLogger.log(req,business,action,successed,memo)
-    }
-    /**
-     * 创建基于CRUD的基础路由方式
-     * @param {*} actionType 
-     * @param {*} req 
-     * @param {*} res 
-     */
-    createCRUDRoute(actionType,url,datakey,middleware){
-        let instance = this;
-        instance.router[actionType.method](url, middleware ? middleware : (req, res, next)=>{return next()},async (req,res)=>{
-            ////执行CRUD之前，可由继承的子类实现规则验证
-            ////如果返回successed：false，则不再继续
-            let beforeResult =  await instance.beforeCRUD(actionType,req,res)
-            if (!beforeResult.successed) return res.json(beforeResult);
-           ////具体执行基类的CRUD方法
-           let result;
-           if (actionType.method==='delete')
-               result = await instance.delete(req,req.params.id);
-           else
-               result = await instance[actionType.func](req, datakey);
-            ////执行完CRUD方法之后的处理
-            result = await instance.afterCRUD(result,actionType,datakey,url,req,res)
-            return res.json(result)
-        })
-    }
-    /**
-     * 快速构造Controller中的CRUD各个路由,大部分基础表都可复用
-     * @param {*} url  ////基础地址，根据RESTFUL的风格生成CRUD风格的
-     * CREATE : POST url  
-     * UPDATE : PUT url/{id}   
-     * LIST : GET url  
-     * DELETE : DELETE url/{id}
-     * @param {*} datakey 对应在dataconfig.json中的key，方便实体和传递的数据的映射以及SQL
-     * @param {*} action 操作的组合 CRUDS
-     */
-    initializeCRUDRouter(url, datakey, action = 'SCRUD', middleware){
-        if(!url || !datakey)  return;
-        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)
-        if (action.indexOf('U') >= 0) this.createCRUDRoute(constEnum.CRUDAction.Update, urlWithId, datakey, middleware)
-        if (action.indexOf('D') >= 0) this.createCRUDRoute(constEnum.CRUDAction.Delete, urlWithId, datakey, middleware)
-    }
-    /**
-     * CRUD真正进入数据库之前的处理，可由继承的类来处理
-     * 不处理则默认返回继续
-     * @param {*} result 
-     * @param {*} action 
-     */
-    async beforeCRUD(_action, _req,_res){
-        return {successed:true}
-    }
-    /**
-     * CRUD执行数据库之后的处理，可由继承的类来处理
-     * @param {*} result 
-     * @param {*} action 
-     */
-    async afterCRUD(result,_action,_datakey,_url, _req,_res){
-        return result;
-    }
-    /*
-    * 初始化路由处理器(空方法,待继承的子类去实现)
-    * 除了在routerConfig中配置的路由以外，继承的子类可以重写实现此方法来
-    * 继续配置你的路由
-    */
-    initializeRouter(_instance) { }
-    /*
-    *  数据加载之前的动作
-    *  子类可以重写该方法
-    */
-    async beforeAccessDB(_req, sql, sqlParams, _type, _instance) {
-        return { sql: sql, sqlParams: sqlParams, canceled: false };
-    }
-    /**
-     * 数据导出到Excel之前可以由继承类再进行处理
-     * @param {*} dataOption 
-     */
-    beforeExportExcel(dataOption) {
-        return dataOption;
-    }
-    /**
-     * 执行批量操作更新
-     * @param {*} model 需要更新的字段和值
-     */
-    async batchUpdate(req,model,id){
-        if (!id) id = req.params.id;
-        if (!id) return {successed:false,errcode:-2,errmsg:'缺失批量操作的id'}
-        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;
-    }
-    /*
-    * 获取查询列表记录的方法
-    */
-    async getListData(req, dataKey, configFile = 0) {
-        if (this.logger) this.logger.trace("准备获取dataconfig文件中对应的 %s list数据",dataKey)
-        const listinfo = getListInfo(req, dataKey, configFile, this._daoModel);  //, ignorefilter==1
-        if (!listinfo) return { successed: false, errcode: -10, errmsg:`缺失${dataKey}对应的查询语句`};
-
-        ////直接操作数据库之前，可由子类再次Handler
-        let beforeData = await this.beforeAccessDB(req, listinfo.sql, listinfo.params, "list", this);
-        ////如果返回Null,则表示不加载数据了
-        if (beforeData.canceled === true) return { successed: false, errorcode: 1, errmsg: "操作取消" };
-        ////操作数据库
-        let result = await this._daoModel.loadData(beforeData.sql, beforeData.sqlParams);
-        if(!result.successed) {
-            ////失败也需要记录
-            if (req.query.exportexcel==='true') this.logUserAction(req,this._daoModel.getBusiness(),5,-1);
-            return result;
-        }
-        ///从数据库中获取到了原始数据
-        if (result.rows) {
-            ///将从数据库中获得的结果集根据dataconfig中的配置进行映射转换
-            let resultItem = Data2View(result.rows[0], listinfo.fields)
-            ///输出的结果是否需要装饰带有successed,total等，便于列表
-            let outputData = { successed: true, page: listinfo.page, rows: resultItem.data };
-            ///需要进行尾部统计的列表
-            if (listinfo.hascounter) {
-                let footerItem = Data2View(result.rows[2], listinfo.footers)
-                outputData.footer = footerItem.data;
-            }
-            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(result){
-        return result.rows[1][0].total;
-    }
-    /*
-    * 获取详细记录的方法
-    */
-    async getDataById(req, dataKey, sqlCommand,idValue) {
-        if (this.logger) this.logger.trace("准备获取dataconfig文件中对应的 %s 详细数据",dataKey)
-        const detailinfo = getDetailInfo(req, dataKey);
-        if (!detailinfo) return { successed: false, errcode: -10, errmsg: `缺失${dataKey}对应的详情配置` };
-        let beforeData = await this.beforeAccessDB(req, sqlCommand || this._daoModel.getByIdSql(), idValue ||req.params.id, "detail", this);
-        ////如果返回Null,则表示不加载数据了
-        if (beforeData.canceled===true) return { successed: false, errorcode: 1, errormessage: "操作已取消" };
-        /////处理SQL中的一些定义符
-        let parseSql = parseTagInSql(req,beforeData.sql);
-        ////操作数据库
-        let result = await this._daoModel.getBykey(parseSql, beforeData.sqlParams);
-        if (!result.successed) return result;
-        if (result.rows && result.rows.length == 1) {
-            ///如果对象有数据权限控制，则需要插入
-            ///提交的权限设置
-            ///将从数据库中获得的结果集根据dataconfig中的配置进行映射转换
-            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) {
-                    resultMapping.data[0].managepermission = accessResult.managepermission;
-                    resultMapping.data[0].consumepermission = accessResult.consumepermission;
-                }
-            }
-            return { successed: true, rows: resultMapping.data[0], id: req.params.id };
-        }
-        return apiResult.DB_NO_RECORD_FOUND;
-    }
-    /*
-    * 新增实体记录的方法
-    */
-    async create(req, dataKey, sqlCommand) {
-        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) {
-            detailinfo = getDetailInfo(req, dataKey);
-            if (!detailinfo) return { successed: false, errcode: -10, errmsg: `缺失${dataKey}对应的详情配置` };
-            resultItem = View2Data(req, detailinfo.fields, "create");
-            ///如果转换的验证过程中出现错误，则返回
-            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: "操作取消" };
-        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 && detailinfo.primary) {
-            ///自动增长的主键字段
-            if (detailinfo.autoincrease === true) primaryKey = result.rows.insertId;
-            else {
-                if (typeof (detailinfo.primary) === "string") primaryKey = beforeData.sqlParams[detailinfo.primary];
-                if (typeof (detailinfo.primary) === "object")
-                    primaryKey = detailinfo.primary.map(element => { return beforeData.sqlParams[element]; });
-            }
-        }
-        ///如果对象有数据权限控制，则需要插入
-        ///提交的权限设置
-        if (this._daoModel.hasPermissionControl){
-            let param = {}
-            if (req.body.managepermission) 
-                param.managepermission =  JSON.parse(req.body.managepermission);
-            else
-                param.managepermission= {};
-            if (req.body.consumepermission) 
-                param.consumepermission = JSON.parse(req.body.consumepermission);
-            else
-                param.consumepermission = {}
-            this._daoModel.saveDataPermissionSetting(primaryKey, param)
-        }
-        this.logUserAction(req,this._daoModel.getBusiness(),1,0);
-        return { successed: true, data: resultItem.data, id: primaryKey };
-    }
-    /*
-    * 修改实体记录的方法
-    */
-    async update(req, dataKey, sqlCommand, id) {
-        if (this.logger)  this.logger.trace("准备根据dataconfig文件中对应的 %s 配置修改数据",dataKey)
-        if (id == null) id = req.params.id;
-        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) {
-            detailinfo = getDetailInfo(req, dataKey);
-            if (!detailinfo) return { successed: false, errcode: -10, errmsg: `缺失${dataKey}对应的详情配置` };
-            ///从Request中获取到用户提交的数据
-            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: "操作取消" };
-        if (this.logger)  this.logger.trace("修改数据准备 : ",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);
-            return result;
-        }
-        ///更新成功
-        if (result.rows.affectedRows == 1) {
-            ///如果对象有数据权限控制，则需要插入
-            ///提交的权限设置
-            if (this._daoModel.hasPermissionControl) {
-                let param = {}
-                if (req.body.managepermission) 
-                    param.managepermission = JSON.parse(req.body.managepermission);
-                else
-                    param.managepermission = {}
-                if (req.body.consumepermission) 
-                    param.consumepermission = JSON.parse(req.body.consumepermission);
-                else
-                    param.consumepermission = {}
-                this._daoModel.saveDataPermissionSetting(id, param)
-            }
-            this.logUserAction(req,this._daoModel.getBusiness(),3,0);
-            return { successed: true, data: resultItem.data, id: id };
-        }
-        ///更新失败
-        return apiResult.DB_NO_EFFECTIVE; //{successed:false,errorcode:errorcode.DATABASE_ERROR.NO_RECORD_EFFECTED,data:resultItem.data};
-    }
-
-    /*
-    * 删除实体记录的方法
-    */
-    async delete(req, id, sqlCommand) {
-        if (this.logger)  this.logger.trace("准备删除数据",id)
-        let beforeData = await this.beforeAccessDB(req, sqlCommand || this._daoModel.deleteSql(id), id, "delete", this);
-        ////如果返回Null,则表示不加载数据了
-        if (beforeData.canceled) return { successed: false, errorcode: 1, errormessage: "操作取消" };
-        /////处理SQL中的一些定义符
-        let parseSql = parseTagInSql(req,beforeData.sql);
-        ////操作数据库
-        let result = await this._daoModel.delete(parseSql, beforeData.sqlParams,req.user?.id)
-        if(!result.successed) {
-            this.logUserAction(req,this._daoModel.getBusiness(),2,-1);
-            return result;
-        }
-        this.logUserAction(req,this._daoModel.getBusiness(),2,0);
-        return { successed: true, id: id, count: result.rows.affectedRows };
-    }
-}
-exports = module.exports = controller;