no message

.gitignore

+.idea
+/out
+/node_modules
+/test
+/public
+/logs
+/video
+*.logs
+*.zip

.vscode/launch.json

+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+    
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "启动程序",
+            "program": "${workspaceFolder}/src/main.ts",
+            "outFiles": [
+                "${workspaceFolder}/**/*.js"
+            ]
+        }
+    ]
+}
\ No newline at end of file

package.json

+{
+  "name": "screen",
+  "version": "1.0.0",
+  "description": "",
+  "main": "main.ts",
+  "dependencies": {
+    "@alicloud/sms-sdk": "^1.1.6",
+    "@types/node": "^10.12.18",
+    "compression": "^1.7.4",
+    "express": "^4.17.1",
+    "express-async-handler": "^1.1.4",
+    "express-history-api-fallback": "^2.2.1",
+    "formidable": "^1.2.1",
+    "log4js": "^6.6.1",
+    "lru-cache": "^4.1.5",
+    "md5": "^2.2.1",
+    "moment": "^2.24.0",
+    "mongoose": "^5.4.0",
+    "mysql": "^2.18.1",
+    "mysql2": "^3.13.0",
+    "node-xlsx": "^0.16.1",
+    "nodemailer": "^6.1.1",
+    "officegen": "^0.6.5",
+    "qs": "^6.11.0",
+    "request": "^2.88.0",
+    "sequelize": "^6.37.5",
+    "svg-captcha": "^1.3.12",
+    "tencentcloud-sdk-nodejs": "^4.0.562",
+    "ws": "^5.2.2",
+    "xml2js": "^0.4.23"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "cjj",
+  "license": "ISC",
+  "bin": "./out/main.js",
+  "pkg": {
+    "scripts": "out/**/*.js",
+    "assets": [
+      "public/**/*",
+      "res/**/*",
+      "images/**/*",
+      "video/**/*"
+    ],
+    "outputPath": "dist"
+  }
+}

serverConfig.xml

+<config>
+    <port>13281</port>
+    <mongodb>
+        <path>127.0.0.1</path>
+        <port>27017</port>
+        <w>1</w>
+        <!-- <dataBase>baseDB</dataBase> -->
+        <dataBase>zjnt</dataBase>
+        <wtimeoutMS>30000</wtimeoutMS>
+    </mongodb>
+</config>

src/biz/caiShou.ts

+/**
+ * 采收逻辑
+ */
+import { TABLENAME } from "../config/dbEnum";
+import { CaiShouConfig } from "../config/eccParam";
+import { PLANTTYPE, ZHONGYANGTYPE } from "../config/enum";
+import * as caishouData from "../data/caishou";
+import * as dikuaiData from "../data/dikuai";
+import * as zhongzhiData from "../data/zhongzhi";
+import { randomId, successResult } from "../tools/system";
+import { changeEnumValue, eccEnumValue } from "../util/verificationEnum";
+import { eccFormParam } from "../util/verificationParam";
+import moment = require("moment");
+
+
+/**
+ * 添加采收
+ * @param reqUser 
+ * @param param 
+ * @returns 
+ */
+export async function addCaiShou(reqUser, param) {
+    let funName = `添加采收`;
+    eccFormParam(funName, CaiShouConfig, param );
+    eccEnumValue(funName, "plantType", PLANTTYPE, param.plantType);
+    
+    //修改种养
+    let zhongyangParam = {isEnd:0, plantType:param.plantType, dId:param.dId};
+    let zhongzhiList = await zhongzhiData.selectToParam(zhongyangParam);
+
+    let sizeCount = 0;
+    for (let i = 0; i < zhongzhiList.length; i++) {
+        let {dId, size} = zhongzhiList[i];
+        sizeCount += size;
+    }
+
+    //释放地块
+    let diKuaiInfo = await dikuaiData.selectOne({dId:param.dId});
+    diKuaiInfo.nullSize = diKuaiInfo.nullSize + sizeCount;
+    diKuaiInfo.useSize = diKuaiInfo.useSize - sizeCount;
+    await diKuaiInfo.save();
+
+    let  csId = randomId(TABLENAME.采收);
+    //改变种植面积
+    await zhongzhiData.updateManyToParam({isEnd:0, plantType:param.plantType}, {isEnd:1, csId});
+
+    //添加采收记录
+    let addInfo = {
+        csId,
+        dIdList:param.dIdList,
+        plantType:param.plantType,
+        operationTime:param.operationTime,
+        weight:param.weight,
+        ct:new Date().valueOf(),
+        createUser:reqUser.userId
+    };
+    await caishouData.addData(addInfo)
+
+    return successResult();
+}
+
+
+
+/**
+ * 采收列表
+ * @param selectStr 
+ * @param dId 
+ * @param zhongYangType 
+ * @param plantType 
+ * @param operationTime 
+ * @returns 
+ */
+export async function caiShouList(zhongYangType:number, selectStr:string, dId:string, plantType:number, operationTime:number) {
+    let funName = "采收列表";
+    eccEnumValue(funName, "zhongYangType", ZHONGYANGTYPE, zhongYangType);
+
+    let param:any = { plantType : {"$gte":zhongYangType, "$lt":zhongYangType+99} };
+    if (plantType) {
+        eccEnumValue(funName, "plantType", PLANTTYPE, plantType);
+        param.plantType = plantType;
+    }
+    if (dId) {
+        param.dIdList = {"$in":dId};
+    }
+    if (operationTime) {
+        let startMs = moment(operationTime).startOf("month").valueOf();
+        let endMs = moment(operationTime).endOf("month").valueOf();
+        param.useTime = {"$gt":startMs, "$lt":endMs};
+    }
+
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code} = info;
+        diKuaiMap[dId] = code;
+    });
+
+    let nongShiList = await caishouData.selectToParam(param);
+    let dataList = [];
+    nongShiList.forEach(item => {
+        let {plantType, dIdList, operationTime, weight } = item;
+        let dIds = dIdList;
+        let didStr = "";
+        dIds.forEach(dId => {
+            didStr += `${diKuaiMap[dId]} `;
+        })
+        dataList.push({
+            plantType:changeEnumValue(PLANTTYPE, plantType),
+            dIdList:didStr,
+            operationTime:moment(operationTime).format("YYYY-MM-DD"),
+            weight
+        });
+    });
+
+    return {dataList}
+}
\ No newline at end of file

src/biz/dataOut.ts

+/**
+ * 数据接口输出
+ */
+
+import moment = require("moment");
+import { LIANGSHI, NONGZITYPE, PLANTTYPE, PLOTTYPE } from "../config/enum";
+import { diKuaiSizeCountByParam } from "../data/dikuai";
+import { statisNongZiType, statisNongZiTypeCountByTime } from "../data/nongzi";
+import { selectToParam, zhongZhiTongJiCount } from "../data/zhongzhi"
+import * as nongshiData from "../data/nongshi"
+import * as xiaoshouData from "../data/xiaoshou"
+import { changeEnumValue } from "../util/verificationEnum";
+import { selectChanLiangOfMonth } from "../data/caishou";
+
+export async function getDataOut() {
+    let 种植总面积 = 0;
+    let 粮田面积 = 0;
+    let 菜田面积 = 0;
+    let 作物数量 = 0;
+
+    let zhongZhiList = await zhongZhiTongJiCount();
+    let zhongZhiZuoWuList = []; //结果
+    zhongZhiList.forEach(info => {
+        let {_id, sizeCount} = info;
+        种植总面积 += sizeCount;
+        if (_id == LIANGSHI.水稻 || _id == LIANGSHI.蚕豆) {
+            粮田面积 += sizeCount;
+        } else if (_id < 100) {
+            菜田面积 += sizeCount;
+        }
+        if ( !(_id > 100 && _id < 200)) {
+            作物数量 += 1;
+            zhongZhiZuoWuList.push({key:changeEnumValue(PLANTTYPE, _id), value:sizeCount});
+        }
+    });
+
+    let diKuaiInfo = await diKuaiSizeCountByParam({plotType:PLOTTYPE.地块});
+    let 地块使用率 = 0;
+    if (diKuaiInfo.totalSize && diKuaiInfo.totalUseSize) {
+        地块使用率 = Math.round(diKuaiInfo.totalUseSize/diKuaiInfo.totalSize * 100);
+    }
+    let zhongZhiTypeList = [
+        {key:"种植总面积", value:种植总面积},
+        {key:"菜田面积", value:菜田面积},
+        {key:"粮田面积", value:粮田面积},
+        {key:"作物数量", value:作物数量},
+        {key:"地块使用率", value:地块使用率},
+    ]; //结果
+
+    let 农资类型 = await statisNongZiType();
+    let 农资情况Map = {};
+    农资情况Map[NONGZITYPE.肥料] = {key:changeEnumValue(NONGZITYPE, NONGZITYPE.肥料), value:0};
+    农资情况Map[NONGZITYPE.农药] = {key:changeEnumValue(NONGZITYPE, NONGZITYPE.农药), value:0};
+    农资情况Map[NONGZITYPE.其他] = {key:changeEnumValue(NONGZITYPE, NONGZITYPE.其他), value:0};
+    农资类型.forEach(info => {
+        let {_id, count} = info;
+        if (农资情况Map[_id]) 农资情况Map[_id].value = count;
+    });
+    let nongZiList = Object.values(农资情况Map); //结果
+
+    let nongZiAllMonthList = await statisNongZiTypeCountByTime();
+    let nongZiCountInfo = {};//肥料用药情况
+    nongZiCountInfo[NONGZITYPE.农药] = {};
+    nongZiCountInfo[NONGZITYPE.肥料] = {};
+//     nongZiAllMonthList = [
+//         { "totalWeight" : 15, "year" : 2025, "month" : 1, "nzType" : 2 },
+// { "totalWeight" : 23, "year" : 2025, "month" : 2, "nzType" : 1 },
+// { "totalWeight" : 10, "year" : 2025, "month" : 3, "nzType" : 1 },
+//     ]
+    nongZiAllMonthList.forEach(info => {
+        let {year, month, nzType, totalWeight} = info;
+        if (nongZiCountInfo[nzType]) {
+            nongZiCountInfo[nzType][`${year}-${month}`] = totalWeight;
+        };
+    });
+    let 肥料  = [];
+    let 用药 = [];
+    for (let i = 9; i >= 0; i--) {
+        let key = moment().subtract(i, 'months').format("YYYY-M");
+        肥料.push({
+            key,
+            value:nongZiCountInfo[NONGZITYPE.肥料][key] || 0
+        });
+        用药.push({
+            key,
+            value:nongZiCountInfo[NONGZITYPE.农药][key] || 0
+        });
+    }
+    let feiliaoyongyaoqingkuang = [ //结果
+        {name:"肥料", data:肥料},
+        {name:"用药", data:用药},
+    ];
+ 
+    let nongShiCount = await nongshiData.selectCountByParam({}); //结果
+    let nongshiTyptList = await nongshiData.statisNongShiType();
+    let 操作趋势 = {};
+    let nongShiList = [];//结果
+    nongshiTyptList.forEach(info => {
+        let {year, month, count} = info;
+        操作趋势[`${year}-${month}`] = count;
+    });
+    for (let i = 9; i >= 0; i--) {
+        let key = moment().subtract(i, 'months').format("YYYY-M");
+        nongShiList.push({
+            key,
+            value:操作趋势[key] || 0
+        });
+    }
+
+
+     let monthDBList = await selectChanLiangOfMonth();
+    let 作物产量Map = {};
+    monthDBList.forEach(info => {
+        let {year, month, totalWeight} = info;
+        
+        let key = `${year}-${month}`;
+        if (!作物产量Map[key]) 作物产量Map[key] = 0;
+        作物产量Map[key] += totalWeight;
+    });
+
+
+    let 今年 = [];
+    let 去年 = [];
+    let thisYear = new Date().getFullYear();
+    let lastYear = thisYear - 1;
+    let 今年产量总数 = 0;
+    let 去年产量总数 = 0;
+    for (let i =1; i <=12; i++) {
+        let thisYearItem = 作物产量Map[`${thisYear}-${i}`] || 0;
+        let lastYearItem = 作物产量Map[`${lastYear}-${i}`] || 0;
+        今年.push({key: `${thisYear}-${i}`, value:thisYearItem });
+        去年.push({key: `${lastYear}-${i}`, value:lastYearItem });
+        今年产量总数 += thisYearItem;
+        去年产量总数 += lastYearItem;
+    }
+    let chanLiangList = [ //结果
+        {name:"今年", data:今年},
+        {name:"去年", data:去年},
+    ];
+
+    let 产量年同比 = 0;
+    if (今年产量总数 && 去年产量总数)  {
+        产量年同比 = Math.round((今年产量总数 - 去年产量总数)/ 去年产量总数*10000)/100
+    }
+    let chanLiangStatisList = [//结果
+        {key:"作物产量", value:今年产量总数},
+        {key:"同比", value:产量年同比}
+    ];
+
+    let xiaoshouStartMs = moment().subtract(1, "months").startOf('month').valueOf();
+    let xiaoshouEndMs = moment().startOf('month').valueOf();
+    let xiaoshouDBList = await xiaoshouData.selectToParam({operationTime:{"$gt":xiaoshouStartMs, "$lt":xiaoshouEndMs }});
+
+    let lastMonthXiaoShou = 0;
+    let lastMonthXiaoShouMap = {};
+    xiaoshouDBList.forEach(info => {
+        let {operationTime, weight} = info;
+        lastMonthXiaoShou += weight;
+        let key = moment(operationTime).format("MM-DD");
+        let dayKey = moment(operationTime).format("DD");
+        if (!lastMonthXiaoShouMap[key]) lastMonthXiaoShouMap[key] = {key:dayKey, value:0};
+        lastMonthXiaoShouMap[key].value += weight;
+    });
+    let lastMonthXiaoShouList = Object.values(lastMonthXiaoShouMap);//结果
+
+    return {
+        zhongZhiZuoWuList,
+        zhongZhiTypeList,
+        nongZiList,
+        feiliaoyongyaoqingkuang,
+        nongShiList,
+        nongShiCount,
+        chanLiangList,
+        chanLiangStatisList,
+        lastMonthXiaoShou,
+        lastMonthXiaoShouList
+    }
+
+}
+
+
+

src/biz/diKuai.ts

+/**
+ * 地块
+ */
+
+import { TABLENAME } from "../config/dbEnum";
+import { DiKuaiConfig, YangZhiChiConfig } from "../config/eccParam";
+import { AREARANGE, PLANTTYPE, PLOTTYPE, PURPOSE, ZHONGYANGTYPE } from "../config/enum";
+import { ERRORENUM } from "../config/errorEnum";
+import * as dikuaiData from "../data/dikuai";
+import { randomId, successResult } from "../tools/system";
+import { BizError } from "../util/bizError";
+import { changeEnumValue, eccEnumValue } from "../util/verificationEnum";
+import { eccFormParam } from "../util/verificationParam";
+
+
+/**
+ * 添加地块
+ * @param reqUser 
+ * @param plotType 
+ * @param param 
+ * @returns 
+ */
+export async function addDiKuai(reqUser, plotType, param) {
+    let funName = `添加地块`;
+    eccEnumValue(funName, "plottype", PLOTTYPE, plotType);
+
+    let purpose = PURPOSE.养殖;
+    if (plotType == PLOTTYPE.地块) {
+        eccFormParam(funName+changeEnumValue(PLOTTYPE, plotType), DiKuaiConfig, param);
+        eccEnumValue(funName, "param=>type", PURPOSE, param.type);
+        purpose = param.type;
+    } else {
+        eccFormParam(funName+changeEnumValue(PLOTTYPE, plotType), YangZhiChiConfig, param);
+    }
+
+    let addInfo = {
+        dId:randomId(TABLENAME.地块表),
+        size:param.size,
+        useSize:0,//使用大小默认0
+        nullSize:param.size,//初始可使用大小为大小
+        code:param.code,
+        name:param.code, //地块名称
+        plotType,
+        purpose,//用途 【枚举】 PURPOSE
+        createUser:reqUser.userId,
+        ct:new Date().valueOf()
+    };
+    await dikuaiData.addData(addInfo);
+
+    return successResult();
+}
+
+/**
+ * 地块信息
+ * @param plotType 
+ * @param selectStr 
+ * @param code 
+ * @param purpose 
+ * @param area 
+ * @returns 
+ */
+export async function diKuaiInfo(dId:String ) {
+    let funName = "地块信息";
+   
+    let dikuaiInfo = await dikuaiData.selectOne({dId});
+    let dataInfo = {
+        size:dikuaiInfo.size, 
+        dId:dikuaiInfo.dId, 
+        type:dikuaiInfo.purpose,
+        purpose:changeEnumValue(PURPOSE, dikuaiInfo.purpose),
+        code:dikuaiInfo.code
+    };
+
+    return {dataInfo}
+}
+
+
+/**
+ * 地块列表
+ * @param plotType 
+ * @param selectStr 
+ * @param code 
+ * @param purpose 
+ * @param area 
+ * @returns 
+ */
+export async function diKuaiList(plotType:number, selectStr:string, code:string, purpose:number, area:number ) {
+    let funName = "地块列表";
+    eccEnumValue(funName, "plottype", PLOTTYPE, plotType);
+   
+    let param:any = {plotType};
+    if (code) {
+        param.code = { "$regex":code };
+    }
+    if (purpose) {
+        eccEnumValue(funName, "purpose", PURPOSE, purpose);
+        param.purpose = purpose;
+    }
+    if (area) {
+        eccEnumValue(funName, "area", AREARANGE, area);
+        param.size = {"$lte": parseInt(AREARANGE[area].replace("<=", "")) };
+    }
+
+    let diKuaiList = await dikuaiData.selectToParam(param);
+    let dataList = [];
+    diKuaiList.forEach(item => {
+        let { size, dId, purpose, code } = item;
+        dataList.push({size,dId,type:changeEnumValue(PURPOSE, purpose),code});
+    });
+
+    return {dataList}
+}
+
+
+/**
+ * 修改地块信息
+ * @param reqUser 
+ * @param plotType 
+ * @param dId 
+ * @param param 
+ * @returns 
+ */
+export async function updateDiKuai(reqUser, plotType, dId, param) {
+    let funName = `修改地块`;
+    eccEnumValue(funName, "plottype", PLOTTYPE, plotType);
+
+    let purpose = PURPOSE.养殖;
+    if (plotType == PLOTTYPE.地块) {
+        eccFormParam(funName+changeEnumValue(PLOTTYPE, plotType), DiKuaiConfig, param);
+        eccEnumValue(funName, "param=>type", PURPOSE, param.type);
+        purpose = param.type;
+    } else {
+        eccFormParam(funName+changeEnumValue(PLOTTYPE, plotType), YangZhiChiConfig, param);
+    }
+
+    let dInfo = await dikuaiData.selectOne({dId});
+    if (!dInfo || !dInfo.dId) throw new BizError(ERRORENUM.地块不存在);
+
+    dInfo.code = param.code,
+    dInfo.size = param.size,
+    dInfo.purpose = purpose;
+
+    await dInfo.save();
+
+    return successResult();
+}
+
+
+
+/**
+ * 当前可种植地块
+ * @returns 
+ */
+export async function keXuanDiKuaiList(zhongYangType:number) {
+    let param:any = {};
+    if (zhongYangType) {
+        let purpose = 1;
+        if (zhongYangType == ZHONGYANGTYPE.水产) purpose = PURPOSE.养殖;
+        else if (zhongYangType == ZHONGYANGTYPE.花卉 ||zhongYangType == ZHONGYANGTYPE.蔬菜 ) purpose = PURPOSE.菜田;
+        else if (zhongYangType == ZHONGYANGTYPE.粮食) purpose = PURPOSE.粮田;
+        param.nullSize = {"$gt":0};
+        param.purpose = purpose;
+    }
+
+    console.log("------>", JSON.stringify(param));
+   
+    let dbList = await dikuaiData.selectToParam(param);
+
+    let dataList = [];
+
+    dbList.forEach(info => {
+        let {code, purpose, dId, size} = info;
+        dataList.push( {code, purpose:changeEnumValue(PURPOSE, purpose), dId, size});
+    });
+
+    return {dataList};
+}
+
+
+/**
+ * 当前采收地块列表
+ * @returns 
+ */
+export async function keCaiShouList(zhongYangType:number) {
+    let purpose = 1;
+    if (zhongYangType == ZHONGYANGTYPE.水产) purpose = PURPOSE.养殖;
+    else if (zhongYangType == ZHONGYANGTYPE.花卉 ||zhongYangType == ZHONGYANGTYPE.蔬菜 ) purpose = PURPOSE.菜田;
+    else if (zhongYangType == ZHONGYANGTYPE.粮食) purpose = PURPOSE.粮田;
+    let param = {useSize:{"$gt":0}, purpose:purpose};
+
+    let dbList = await dikuaiData.selectToParam(param);
+
+    let dataList = [];
+
+    dbList.forEach(info => {
+        let {code, purpose, dId, size} = info;
+        dataList.push( {code, purpose:changeEnumValue(PURPOSE, purpose), dId, size});
+    });
+
+    return {dataList}
+}
+
+/**
+ * 全部地块列表
+ * @param plotType 
+ * @param selectStr 
+ * @param code 
+ * @param purpose 
+ * @param area 
+ * @returns 
+ */
+export async function allDiKuaiList(plotType:number ) {
+    let funName = "地块列表";
+    eccEnumValue(funName, "plottype", PLOTTYPE, plotType);
+   
+    let param:any = {plotType};
+
+    let diKuaiList = await dikuaiData.selectToParam(param);
+    let dataList = [];
+    diKuaiList.forEach(item => {
+        let { size, dId, purpose, code } = item;
+        dataList.push({dId, code});
+    });
+
+    return {dataList}
+}
\ No newline at end of file

src/biz/nongShi.ts

+import { TABLENAME } from "../config/dbEnum";
+import { CaiShouConfig, NongShiConfig } from "../config/eccParam";
+import { NONGSHITYPE, PLANTTYPE } from "../config/enum";
+import * as nongshiData from "../data/nongshi";
+import * as dikuaiData from "../data/dikuai";
+import { getMySqlMs, randomId, successResult } from "../tools/system";
+import { changeEnumValue, eccEnumValue } from "../util/verificationEnum";
+import { eccFormParam } from "../util/verificationParam";
+import moment = require("moment");
+import { BizError } from "../util/bizError";
+import { ERRORENUM } from "../config/errorEnum";
+
+/**
+ * 添加农事
+ * @param reqUser 
+ * @param param 
+ * @returns 
+ */
+export async function addNongShi(reqUser, param) {
+    let funName = `添加农事`;
+    eccFormParam(funName, NongShiConfig, param );
+    eccEnumValue(funName, "nsType", NONGSHITYPE, param.nsType);
+    //确保添加时地块还在
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code} = info;
+        diKuaiMap[dId] = code;
+    });
+    if (!diKuaiMap[param.dIdList]) throw new BizError(ERRORENUM.地块不存在, param.dIdList);
+
+    let addInfo = {
+        nsId:randomId(TABLENAME.农事),
+        nsType:param.nsType,
+        dIdList:[param.dIdList],
+        operationTime:param.operationTime,
+        ct:new Date().valueOf()
+    };
+    await nongshiData.addData(addInfo)
+
+    return successResult();
+}
+
+/**
+ * 农事列表
+ * @param selectStr 
+ * @param dId 
+ * @param nsType 
+ * @param operationTime 
+ * @returns 
+ */
+export async function nongShiList(selectStr:string, dId:string, nsType:number, operationTime:number) {
+    let funName = "农事列表";
+    let param:any = {};
+    if (nsType) {
+        eccEnumValue(funName, "nsType", NONGSHITYPE, nsType);
+        param.nsType = nsType;
+    }
+    if (dId) {
+        param.dIdList = {"$in":dId};
+    }
+    if (operationTime) {
+        let startMs = moment(operationTime).startOf("month").valueOf();
+        let endMs = moment(operationTime).endOf("month").valueOf();
+        param.operationTime = {"$gt":startMs, "$lt":endMs};
+    }
+
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code} = info;
+        diKuaiMap[dId] = code;
+    });
+
+    let nongShiList = await nongshiData.selectToParam(param);
+    let dataList = [];
+    nongShiList.forEach(item => {
+        let {nsType, dIdList, operationTime } = item;
+        let didStr = "";
+        dIdList.forEach(dId => {
+            didStr += `${diKuaiMap[dId]} `;
+        });
+        dataList.push({
+            nsType:changeEnumValue(NONGSHITYPE, nsType),
+            dIdList:didStr,
+            operationTime:moment(operationTime).format("YYYY-MM-DD")
+        });
+    });
+
+    return {dataList}
+}
\ No newline at end of file

src/biz/nongzi.ts

+/**
+ * 农资
+ */
+
+import moment = require("moment");
+import { TABLENAME } from "../config/dbEnum";
+import { NongZiConfig } from "../config/eccParam";
+import { NONGZITYPE, PLANTTYPE } from "../config/enum";
+import * as nongziData from "../data/nongzi";
+import * as dikuaiData from "../data/dikuai";
+import { randomId, successResult } from "../tools/system";
+import { changeEnumValue, eccEnumValue } from "../util/verificationEnum";
+import { eccFormParam } from "../util/verificationParam";
+import { BizError } from "../util/bizError";
+import { ERRORENUM } from "../config/errorEnum";
+
+/**
+ * 添加农资
+ * @param reqUser 
+ * @param param 
+ * @returns 
+ */
+export async function addNongZi(reqUser, param) {
+    let funName = `添加农资`;
+    eccFormParam(funName, NongZiConfig, param );
+    eccEnumValue(funName, "nzType", NONGZITYPE, param.nzType);
+    eccEnumValue(funName, "plantType", PLANTTYPE, param.plantType);
+    //确保添加时地块还在
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code} = info;
+        diKuaiMap[dId] = code;
+    });
+    if (!diKuaiMap[param.dIdList]) throw new BizError(ERRORENUM.地块不存在, param.dIdList);
+
+    let addInfo = {
+        nzId:randomId(TABLENAME.农资),
+        nzType:param.nzType,
+        dIdList:[param.dIdList],
+        plantType:param.plantType,
+        count:param.count,
+        useTime:param.useTime,
+        ct:new Date().valueOf()
+    };
+    await nongziData.addData(addInfo)
+
+    return successResult();
+}
+
+
+/**
+ * 农资列表
+ * @param selectStr 
+ * @param dId 
+ * @param nzType 
+ * @param useTime 
+ * @returns 
+ */
+export async function nongZiList(selectStr:string, dId:string, nzType:number, useTime:number) {
+    let funName = "农资列表";
+    let param:any = {};
+    if (nzType) {
+        eccEnumValue(funName, "nzType", NONGZITYPE, nzType);
+        param.nzType = nzType;
+    }
+    if (dId) {
+        param.dIdList = {"$in":dId};
+    }
+    if (useTime) {
+        let startMs = moment(useTime).startOf("month").valueOf();
+        let endMs = moment(useTime).endOf("month").valueOf();
+        param.useTime = {"$gt":startMs, "$lt":endMs};
+    }
+
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code} = info;
+        diKuaiMap[dId] = code;
+    });
+
+    let diKuaiList = await nongziData.selectToParam( param );
+
+    let dataList = [];
+    diKuaiList.forEach(item => {
+        let {nzType, dIdList, plantType, count, useTime } = item;
+        let didStr = "";
+        dIdList.forEach(dId => {
+            didStr += `${diKuaiMap[dId]} `;
+        })
+        dataList.push({
+            nzType:changeEnumValue(NONGZITYPE, nzType),
+            dIdList:didStr,
+            plantType:changeEnumValue(PLANTTYPE, plantType),
+            count,
+            useTime:moment(useTime).format("YYYY-MM-DD")
+        });
+    });
+
+    return {dataList};
+}
\ No newline at end of file

src/biz/user.ts

+/**
+ * 用户
+ */
+
+
+import { ERRORENUM } from "../config/errorEnum";
+import { findUserInfoByLoginId, findUserInfoByUserId } from "../data/users";
+import { getPwdMd5, getToken, successResult } from "../tools/system";
+import { BizError } from "../util/bizError";
+import * as diKuaiData from "../data/dikuai";
+import * as zhongZhiData from "../data/zhongzhi";
+import { selectChanLiangOfMonth, selectChanLiangOfzuoWu } from "../data/caishou";
+import { changeEnumValue } from "../util/verificationEnum";
+import { PLANTTYPE } from "../config/enum";
+import { selectXiaoShouOfMonth, selectXiaoShouOfzuoWu } from "../data/xiaoshou";
+
+
+/**
+ * 登录
+ * @param loginId 
+ * @param pwd 
+ * @returns 
+ */
+export async function userLogin(loginId:string, pwd:string) {
+    let userInfo:any = await findUserInfoByLoginId(loginId);
+    if (!userInfo || !userInfo.userId) throw new BizError(ERRORENUM.账号不存在, loginId);
+
+    let checkPwd = getPwdMd5(loginId, pwd); 
+    if (userInfo.pwd != checkPwd) throw new BizError(ERRORENUM.密码错误);
+
+    let token = getToken(loginId);
+    
+    let resultUserInfo = {
+        loginId:userInfo.loginId,
+        name: userInfo.name,
+        userId:userInfo.userId,
+        token:token,
+    };
+
+    userInfo.token = token;
+    userInfo.tokenMs = new Date().valueOf();
+
+    await userInfo.save();
+    
+    return {dataInfo:resultUserInfo};
+}
+
+
+
+/**
+ * 登出
+ * @param userInfo 
+ */
+export async function userLogout(reqUserInfo) {
+    let userInfo = await findUserInfoByUserId(reqUserInfo.userId);
+
+    userInfo.token = getToken(userInfo.loginId);
+    userInfo.tokenMs = new Date().valueOf();
+
+    await userInfo.save();
+
+    return successResult(); 
+}
+
+
+/**
+ * 首页
+ * @param userInfo 
+ * @returns 
+ */
+export async function homePageChongHai(userInfo) {
+    // let param = {
+    //     state:SOLVESTATE.待解决,//待解决
+    // };
+    // let visitCount = await visitData.findDataCount(param);
+
+    // let enterpriseCount = await findEnterpriseCountByParam({RAS:RAS.续存});
+    // let industryCount = await statisIndustryEnterprise();
+
+    return {dataInfo:{title:"当前无虫害预警", state:0}};
+}
+
+
+/**
+ * 首页 顶部
+ * @param userInfo 
+ * @returns 
+ */
+export async function homePageTop(userInfo) {
+
+    return {dataInfo:{
+        name:userInfo.name,
+        title:userInfo.position
+    }};
+}
+
+
+/**
+ * 首页-统计页 顶部
+ * @param userInfo 
+ * @returns 
+ */
+export async function homePageStatisTop(userInfo) {
+    //面积
+    let {totalSize, totalUseSize} = await diKuaiData.diKuaiSizeCount();
+    let rate = 0;
+    if (totalSize && totalUseSize) {
+        Math.round(totalUseSize/totalSize*100);
+    }
+
+    //品种
+    let zhongZhiTypeList = await zhongZhiData.pingZhongCount();
+
+    let dataInfo = {
+        diKuaiCount : totalSize,
+        zhongYangCount : totalUseSize,
+        zhongYangPinZhong : zhongZhiTypeList.length,
+        shiYongLv:rate,
+    };
+
+    return {dataInfo};
+}
+
+
+
+/**
+ * 首页-统计页 底部
+ * @param userInfo 
+ * @returns 
+ */
+export async function homePageStatisBottom(userInfo) {
+
+    let dataInfo = {
+        congYe : 0,
+        zhuanYe : 0,
+        chanYeZhuTi : 0,
+    };
+
+    return {dataInfo};
+}
+
+
+
+/**
+ * 统计页产量统计
+ * @param type 
+ * @returns 
+ */
+export async function homePageStatisChanLiang(type:number) {
+    
+    //产量 时间分
+    let monthDBList = await selectChanLiangOfMonth();
+    let distinctMap = {};
+    let count = 0;
+    monthDBList.forEach(info => {
+        let {year, month, totalWeight} = info;
+        
+        let strKey = "";
+        if (type == 1) {//年
+            strKey = year;
+        } else if (type == 2) {//季度
+            let quarter = 1;
+            if (month >= 10) quarter = 4;
+            else if (month >= 7) quarter = 3;
+            else if (month >= 4) quarter = 2;
+            strKey = `${year}_${quarter}`;
+        } else {//月
+            strKey = `${year}_${month}`;
+        }
+
+        if (!distinctMap[strKey]) distinctMap[strKey] = {key:strKey, value:0};
+        distinctMap[strKey].value += totalWeight;
+
+        count += totalWeight;
+    });
+    let nongChanPin = Object.values(distinctMap);
+
+    //农作物产量
+    let zuoWuDBList = await selectChanLiangOfzuoWu();
+    let zuoWu = [];
+    zuoWuDBList.forEach(info => {
+        let {_id, totalWeight} = info;
+        zuoWu.push({
+            key:changeEnumValue(PLANTTYPE, _id),
+            value:totalWeight
+        });
+    });
+
+    let dataInfo = {
+        count,
+        nongChanPin,
+        zuoWu:zuoWu,
+    };
+
+    return {dataInfo};
+}
+
+
+/**
+ * 统计页销售量统计
+ * @param type 
+ * @returns 
+ */
+export async function homePageStatisXiaoShou() {
+    let thisYear = new Date().getFullYear();
+    //产量
+    let monthDBList = await selectXiaoShouOfMonth();
+    let distinctMap = {};
+    let count = 0;
+    let lastYearCount = 0;
+    monthDBList.forEach(info => {
+        let {year, month, totalWeight} = info;
+        
+        let strKey = `${year}_${month}`;
+
+        if (!distinctMap[strKey]) distinctMap[strKey] = {key:strKey, value:0};
+        distinctMap[strKey].value += totalWeight;
+
+        if (thisYear == year) count += totalWeight;
+        else if (year == (thisYear-1)) lastYearCount += totalWeight;
+    });
+
+    let xiaoShouList = Object.values(distinctMap);
+
+    let xiaoShouDBList = await selectXiaoShouOfzuoWu();
+
+    let xiaoShou = [];
+    xiaoShouDBList.forEach(info => {
+        let {_id, totalWeight} = info;
+        xiaoShou.push({
+            key:changeEnumValue(PLANTTYPE, _id),
+            value:totalWeight
+        });
+    });
+
+
+    
+    let dataInfo = {
+        count,//
+        mom:Math.round( (count-lastYearCount)/lastYearCount * 1000 )/10,
+        xiaoShou:xiaoShouList,
+        zuoWu:xiaoShou
+    };
+
+    return {dataInfo};
+}

src/biz/xiaoShou.ts

+/**
+ * 销售
+ */
+import { TABLENAME } from "../config/dbEnum";
+import { XiaoShouConfig } from "../config/eccParam";
+import { PLANTTYPE, XIAOSHOUQUXIANG } from "../config/enum";
+import * as xiaoshouData from "../data/xiaoshou";
+import { randomId, successResult } from "../tools/system";
+import { changeEnumValue, eccEnumValue } from "../util/verificationEnum";
+import { eccFormParam } from "../util/verificationParam";
+import moment = require("moment");
+
+/**
+ * 添加销售
+ * @param reqUser 
+ * @param param 
+ * @returns 
+ */
+export async function addXiaoShou(reqUser, param) {
+    let funName = `添加销售`;
+    eccFormParam(funName, XiaoShouConfig, param );
+    eccEnumValue(funName, "quXiang", XIAOSHOUQUXIANG, param.quXiang);
+    eccEnumValue(funName, "plantType", PLANTTYPE, param.plantType);
+    
+    let addInfo = {
+        xsId:randomId(TABLENAME.销售),
+        quXiang:param.quXiang,
+        plantType:param.plantType,
+        operationTime:param.operationTime,
+        weight:param.weight,
+        ct:new Date().valueOf(),
+        createUser:reqUser.userId
+    };
+
+    await xiaoshouData.addData(addInfo)
+
+    return successResult();
+}
+
+
+/**
+ * 销售列表
+ * @param selectStr 
+ * @param quXiang 
+ * @param plantType 
+ * @param operationTime 
+ * @returns 
+ */
+export async function xiaoShouList(selectStr:string, quXiang:string, plantType:number, operationTime:number) {
+    let funName = "销售列表";
+    let param:any = {};
+    if (plantType) {
+        eccEnumValue(funName, "plantType", PLANTTYPE, plantType);
+        param.plantType = plantType;
+    }
+    if (quXiang) {
+        eccEnumValue(funName, "quXiang", XIAOSHOUQUXIANG, quXiang);
+        param.quXiang = quXiang;
+    }
+    if (operationTime) {
+        let startMs = moment(operationTime).startOf("month").valueOf();
+        let endMs = moment(operationTime).endOf("month").valueOf();
+        param.useTime = {"$gt":startMs, "$lt":endMs};
+    }
+
+    let nongShiList = await xiaoshouData.selectToParam(param);
+    let dataList = [];
+    nongShiList.forEach(item => {
+        let {plantType, quXiang, operationTime, weight } = item;
+        
+        dataList.push({
+            plantType:changeEnumValue(PLANTTYPE, plantType),
+            quXiang:changeEnumValue(XIAOSHOUQUXIANG, quXiang),
+            operationTime:moment(operationTime).format("YYYY-MM-DD"),
+            weight
+        });
+    });
+
+    return {dataList}
+}
\ No newline at end of file

src/biz/zhongYang.ts

+/**
+ * 种养
+ */
+
+import moment = require("moment");
+import { TABLENAME } from "../config/dbEnum";
+import { DiKuaiConfig, ZhongYangConfig } from "../config/eccParam";
+import { PLANTTYPE, PLOTTYPE, ZHONGYANGTYPE } from "../config/enum";
+import * as zhongzhiData from "../data/zhongzhi";
+import * as dikuaiData from "../data/dikuai";
+import { randomId, successResult } from "../tools/system";
+import { changeEnumValue, eccEnumValue } from "../util/verificationEnum";
+import { eccFormParam } from "../util/verificationParam";
+import { BizError } from "../util/bizError";
+import { ERRORENUM } from "../config/errorEnum";
+
+/**
+ * 种养列表
+ * @param plantType 种养类型
+ * @param selectStr 
+ * @returns 
+ */
+export async function zhongYangDangQianList(zhongYangType:number, selectStr:string) {
+    let funName = `当前种养列表`;
+    eccEnumValue(funName, 'zhongYangType', ZHONGYANGTYPE, zhongYangType);
+
+    let param = {
+        plantType:{"$gte":zhongYangType, "$lt":zhongYangType+99},
+        isEnd:0
+    };
+    let zyList = await zhongzhiData.selectToParam( param );
+    
+    let typeMap = {};
+    zyList.forEach(info => {
+        let {plantType} = info;
+        typeMap[plantType] = {value:plantType, key:changeEnumValue(PLANTTYPE, plantType)};
+    });
+    let dataList = Object.values(typeMap);
+
+    return {dataList};
+}
+
+
+/**
+ * 添加种养
+ * @param reqUser 
+ * @param param 
+ * @returns 
+ */
+export async function addZhongYang(reqUser, param) {
+    let funName = `添加种养`;
+    eccFormParam(funName, ZhongYangConfig, param);
+    eccEnumValue(funName, "plantType", PLANTTYPE, param.plantType);
+
+    //校验地块大小是否符合扣除
+    let dkInfo = await dikuaiData.selectOne({dId:param.dId});
+    if (!dkInfo || !dkInfo.dId) throw new BizError(ERRORENUM.地块不存在);
+    if (dkInfo.nullSize < param.size) throw new BizError(ERRORENUM.地块大小不足);
+
+    let addInfo = {
+        zId:randomId(TABLENAME.种植表),
+        size:param.size,//种植大小
+        plantType:param.plantType,//
+        dId:param.dId,//地块id
+        plantTime:param.plantTime,//种植时间
+        uId:reqUser.userId,
+        isEnd:0,
+        ct:new Date().valueOf()
+    };
+
+    await zhongzhiData.addData(addInfo);
+
+    dkInfo.nullSize = dkInfo.size - param.size;
+    dkInfo.useSize = dkInfo.useSize + param.size;
+    await dkInfo.save();
+
+    return successResult();
+}
+
+
+/**
+ * 种养记录
+ * @param zhongYangType 
+ * @param selectStr 
+ * @param plantType 
+ * @param plantTime 
+ * @param dId 
+ * @returns 
+ */
+export async function zhongYangJiLu(zhongYangType:number, selectStr:string, plantType:number, plantTime:number, dId:string) {
+    let funName = `种养记录`;
+ 
+    let param:any = { plantType:{"$gte":zhongYangType, "$lt":zhongYangType+99} };
+    if (plantType) {
+        eccEnumValue(funName, "plantType", PLANTTYPE, plantType);
+        param.plantType = plantType;
+    }
+    if (dId) {
+        param.dId = dId;
+    }
+    if (plantTime) {
+        let selectStartTime = moment(plantTime).startOf('month').valueOf();
+        let selectEndTime = moment(plantTime).endOf("month").valueOf();
+        param.plantTime = {"$gt":selectStartTime, "$lt":selectEndTime};
+    }
+    
+    /**获取地块名称 */
+    let dikuaiList = await dikuaiData.selectToParam({});
+    let diKuaiMap = {};
+    dikuaiList.forEach(info => {
+        let {dId, code} = info;
+        diKuaiMap[dId] = code;
+    });
+
+    let dbList = await zhongzhiData.selectToParam(param);
+    let dataList = [];
+    dbList.forEach(info => {
+        dataList.push({
+            plantType:changeEnumValue(PLANTTYPE, info.plantType),
+            size:info.size,
+            code:diKuaiMap[info.dId],
+            plantTime:moment(info.plantTime).format("YYYY-MM-DD")
+        })
+    });
+
+    return {dataList};
+}
\ No newline at end of file

src/config/dbEnum.ts

+export enum TABLENAME {
+    地块表='dikuai',
+    用户表='users',
+    种植表='zhongzhi',
+    农资='nongzi',
+    农事='nongshi',
+    采收='caishou',
+    销售='xiaoshou'
+}
\ No newline at end of file

src/config/eccParam.ts

+export const DiKuaiConfig = {
+    code:{type:"String" },//编号
+    size:{type:"Number" },//地块大小
+    type:{type:"Number" },//地块类型 PLOTTYPE
+};
+
+
+export const YangZhiChiConfig = {
+    code:{type:"String" },//编号
+    size:{type:"Number" },//地块大小
+};
+
+export const ZhongYangConfig = {
+    plantType:{type:"Number" },//编号
+    dId:{type:"String" },//地块id
+    size:{type:"Number" },//地块大小
+    plantTime:{type:"Number" },//种植时间
+}
+
+
+export const NongZiConfig = {
+    nzType:{type:"Number" },//农资类型
+    dIdList:{type:"[String]" },//地块id
+    plantType:{type:"Number"}, //种植种类【枚举】 PLANTTYPE
+    count:{type:"Numbe", allowNull:false},//用量
+    useTime:{type:"Number"},//使用时间
+}
+
+
+export const NongShiConfig = {
+    nsType:{type:"Number" },//农事类型
+    dIdList:{type:"[String]" },//地块id
+    operationTime:{type:"Number"},//使用时间
+}
+
+
+export const CaiShouConfig = {
+    plantType:{type:"Number"}, //种植种类【枚举】 PLANTTYPE
+    dId:{type:"String" },//地块id
+    weight:{type:"Number"},//采收重量
+    operationTime:{type:"Number"},//使用时间
+}
+
+
+export const XiaoShouConfig = {
+    plantType:{type:"Number"}, //种植种类【枚举】 PLANTTYPE
+    quXiang:{type:"Number" },//销售去向
+    weight:{type:"Number"},//采收重量
+    operationTime:{type:"Number"},//使用时间
+}
\ No newline at end of file

src/config/enum.ts

+
+
+/**
+ * 地块类型
+ */
+export enum PLOTTYPE {
+    地块 = 1,
+    养殖池 = 2,
+}
+
+
+
+/**
+ * 用途
+ */
+export enum PURPOSE {
+    菜田 = 1,
+    粮田 = 2,
+    养殖 = 1000
+}
+
+
+
+/**
+ * 种养类型
+ */
+export enum ZHONGYANGTYPE {
+    蔬菜 = 1,
+    水产 = 100,
+    粮食 = 200,
+    花卉 = 300
+}
+
+
+/**
+ * 蔬菜
+ */
+export enum SHUCAI {
+    黄瓜 = 1,
+    罗马生菜,
+    大白菜,
+    西红柿,
+    茄子,
+    生菜,
+    菜用玉米,
+    马铃薯,
+    辣椒,
+    花椰菜,
+    萝卜,
+    青菜,
+    草莓,
+    莴笋,
+    小番茄,
+    球生菜,
+    黄心菜,
+    红菜苔,
+    杭白菜,
+    玉米,
+    米苋,
+    鸡毛菜,
+    番茄,
+    牛心菜,
+    茼蒿
+}
+
+
+
+/**
+ * 水产
+ */
+export enum SHUICHAN {
+    鲈鱼 = 101,
+    鳜鱼,
+    鲢鱼,
+    胭脂鱼,
+    青鱼,
+    鲤鱼,
+    鲫鱼,
+    鲫花,
+    细鳞鯝,
+    草鱼,
+    黄颡鱼,
+    鳊鱼,
+    翘嘴鲌,
+    暗纹东方鲀,
+    鳙鱼
+}
+
+
+/**
+ * 粮食
+ */
+export enum LIANGSHI {
+    水稻 = 201,
+    蚕豆 = 202
+}
+
+
+/**
+ * 花卉
+ */
+export enum HUAHUITYPE {
+    鲜切花 = 301,
+    盆栽植物,
+    盆景,
+    苗树
+}
+
+
+
+
+/**
+ * 种植种类
+ */
+export enum PLANTTYPE {
+    黄瓜 = 1,
+    罗马生菜,
+    大白菜,
+    西红柿,
+    茄子,
+    生菜,
+    菜用玉米,
+    马铃薯,
+    辣椒,
+    花椰菜,
+    萝卜,
+    青菜,
+    草莓,
+    莴笋,
+    小番茄,
+    球生菜,
+    黄心菜,
+    红菜苔,
+    杭白菜,
+    玉米,
+    米苋,
+    鸡毛菜,
+    番茄,
+    牛心菜,
+    茼蒿,
+    鲈鱼 = 101,
+    鳜鱼,
+    鲢鱼,
+    胭脂鱼,
+    青鱼,
+    鲤鱼,
+    鲫鱼,
+    鲫花,
+    细鳞鯝,
+    草鱼,
+    黄颡鱼,
+    鳊鱼,
+    翘嘴鲌,
+    暗纹东方鲀,
+    鳙鱼,
+    水稻 = 201,
+    蚕豆 = 202,
+    鲜切花 = 301,
+    盆栽植物,
+    盆景,
+    苗树
+}
+
+
+export enum AREARANGE {
+    '<=50' = 1,
+    '<=100' = 2,
+    '<=200'
+}
+
+/**
+ * 农资类型
+ */
+export enum NONGZITYPE {
+    肥料 = 1,
+    有机肥,
+    水溶肥,
+    复合肥,
+    追肥保果素,
+    银法利,
+    农药,
+    其他,
+}
+
+
+/**
+ * 农事类型
+ */
+export enum NONGSHITYPE {
+    绿色防控 = 1,
+    水肥一体,
+    土壤保育,
+    施肥,
+    翻羽耕井,
+    起垄,
+    用药,
+    灌溉,
+    追肥,
+    除草,
+    修剪,
+    移栽,
+    药水浸种,
+    高温闷棚,
+    种植结束
+}
+
+export enum XIAOSHOUQUXIANG {
+    田头销售 = 1,
+}
\ No newline at end of file

src/config/errorEnum.ts

+
+export enum ERRORENUM {
+    不存在表 = 1,
+    身份验证失败,
+    缺少必要参数_表名,
+    数据表不存在,
+    参数错误,
+    添加时数据对象为空,
+    修改时数据对象为空,
+    请完善信息,
+    地址数据不完整,
+    只能上传png或jpg图片,
+    文件上传失败,
+    地块不存在,
+    账号不存在,
+    密码错误,
+    非法登录,
+    身份验证过期,
+    地块大小不足
+ }
+ 
+ /**
+  * 只用做code码定义
+  */
+ export enum ERRORCODEENUM {
+    身份验证失败 = 401,
+    非法登录 = 402,
+    身份验证过期 = 403,
+    code无效 = 40029,
+    频繁操作请稍后再试 = 45011,
+    高风险等级用户 = 40226,
+    系统繁忙 = 40227
+ }
+ 
+ let bizErrorMsgMap = {};
+ for (let key in ERRORENUM) {
+     bizErrorMsgMap[ERRORENUM[key]] = key;
+ }
+ 
+ export function getBizMsg(param) {
+     return bizErrorMsgMap[param];
+ }
\ No newline at end of file

src/config/serverConfig.ts

+const path = require('path');
+import * as fs from "fs";
+import { BizError } from "../util/bizError";
+import { analysisXml } from "../util/myXML";
+import { ServerConfig } from "../config/systemClass";
+const os = require('os');
+
+export let systemConfig =  new ServerConfig;
+
+const ConfigName = "serverConfig.xml";
+export async function initConfig() {
+    try {
+        let buff = fs.readFileSync(path.join(__dirname.substring(0,__dirname.indexOf("out")), ConfigName));
+        let configStr = buff.toString();
+        let configInfo:any = await analysisXml(configStr);
+		if (!configInfo || !configInfo.config) throw new BizError('xml中无配置');
+		else {
+            
+            let {port, mongodb, getOpenIdUrl, appId, sms, baidumap } = configInfo.config;
+            systemConfig.port = parseInt(port[0]);
+            
+            const MongoPath = mongodb[0].path[0];
+            const MongoPort = mongodb[0].port[0];
+            const MongoW = mongodb[0].w[0];
+            const MongoDataBase = mongodb[0].dataBase[0];
+            const MongoWtimeoutMS = mongodb[0].wtimeoutMS[0];
+            systemConfig.mongodbStr = analysisMongoConnectStr( MongoPath, MongoPort, MongoDataBase, MongoW, MongoWtimeoutMS);
+
+		}
+        
+        console.log("config init success");
+
+    } catch(err) {
+        console.log('ERROR => 服务器配置解析错误 请检查根目录下 serverConfig.xml 文件是否正确');
+        console.log(err);
+        throw new BizError("服务器配置解析错误 请检查根目录下 serverConfig.xml 文件是否正确");
+    }
+}
+
+function analysisMongoConnectStr(path, port, dataBase, w, timeOutMs) {
+    return `mongodb://${path}:${port}/${dataBase}?w=${w}&wtimeoutMS=${timeOutMs}`
+}
\ No newline at end of file

src/config/systemClass.ts

+/**
+ * 系统配置类
+ * 
+ */
+
+export class ServerConfig {
+    /**系统配置 */
+    port:number;
+    mongodbStr:string;
+    secret:string;
+    /**小程序相关配置 */
+    getOpenIdUrl:string;
+    appId:string;
+    /**短信相关配置 */
+    smsSDKId:number;
+    smsAppKey:string;
+    smsSign:string;
+    smsModelChangePwd:number;
+    smsModelPointOut:number;
+    smsModelInitPointOut:number;
+    /**百度地图api */
+    ak:string
+}
\ No newline at end of file

src/config/tableConfig.ts

+const Sequelize = require('sequelize');
+
+export const TablesConfig = [
+    {
+        tableNameCn:'地块表',
+        tableName:'dikuai',
+        schema:{
+            dId: {
+                type:Sequelize.STRING(255), //表示属性的数据类型
+                allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
+                primaryKey:true, //表示主键
+                unique:true //表示该列的值必须唯一
+            },
+            size: {type:Sequelize.DECIMAL, allowNull:false}, //地块大小
+            useSize: {type:Sequelize.DECIMAL, allowNull:false}, //使用大小
+            code:{type:Sequelize.STRING(255)}, //编号
+            name: {type:Sequelize.STRING(255)}, //地块名称
+            plotType:{type:Sequelize.INTEGER}, //地块类型 【枚举】  PLOTTYPE
+            purpose:{type:Sequelize.STRING(255)},//用途 【枚举】 PURPOSE
+            createUser:{type:Sequelize.STRING(255)}, //创建人
+        },
+        association: []
+    },
+    {
+        tableNameCn:'用户表',
+        tableName:'users',
+        schema:{
+            uId: {
+                type:Sequelize.STRING(255), //表示属性的数据类型
+                allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
+                primaryKey:true, //表示主键
+                unique:true //表示该列的值必须唯一
+            },
+           
+        },
+        association: []
+    },
+    {
+        tableNameCn:'种植表',
+        tableName:'zhongzhi',
+        schema:{
+            zId: {
+                type:Sequelize.STRING(255), //表示属性的数据类型
+                allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
+                primaryKey:true, //表示主键
+                unique:true //表示该列的值必须唯一
+            },
+            size:{type:Sequelize.DECIMAL, allowNull:false}, //种植面积
+            plantType:{type:Sequelize.INTEGER}, //种植种类【枚举】 PLANTTYPE
+            dId:{type:Sequelize.STRING(255)}, //地块id
+            plantTime:{type:Sequelize.DATE}, //种植时间 
+            uId:{ype:Sequelize.STRING(255)},//用户id
+            isEnd:{type:Sequelize.INTEGER}//是否结束  0=否 1=是
+        },
+        association: []
+    },
+    {
+        tableNameCn:'农资',
+        tableName:'nongzi',
+        schema:{
+            nzId: {
+                type:Sequelize.STRING(255), //表示属性的数据类型
+                allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
+                primaryKey:true, //表示主键
+                unique:true //表示该列的值必须唯一
+            },
+            nzType:{type:Sequelize.INTEGER}, //农资类型 
+            dIdList:{type:Sequelize.STRING(255)}, //地块id
+            plantType:{type:Sequelize.INTEGER}, //作物名称【枚举】 PLANTTYPE
+            count:{type:Sequelize.DECIMAL, allowNull:false},//用量
+            useTime:{type:Sequelize.DATE},//使用时间
+            ct:{type:Sequelize.DATE},//创建时间
+        },
+        association: []
+    },
+    {
+        tableNameCn:'农事',
+        tableName:'nongshi',
+        schema:{
+            nsId: {
+                type:Sequelize.STRING(255), //表示属性的数据类型
+                allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
+                primaryKey:true, //表示主键
+                unique:true //表示该列的值必须唯一
+            },
+            nsType:{type:Sequelize.INTEGER}, //农事类型
+            dIdList:{type:Sequelize.STRING(255)}, //地块id
+            operationTime:{type:Sequelize.DATE},//操作时间
+            ct:{type:Sequelize.DATE},//创建时间
+
+        },
+        association: []
+    },
+    {
+        tableNameCn:'采收',
+        tableName:'caishou',
+        schema:{
+            csId: {
+                type:Sequelize.STRING(255), //表示属性的数据类型
+                allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
+                primaryKey:true, //表示主键
+                unique:true //表示该列的值必须唯一
+            },
+            dIdList:{type:Sequelize.STRING(255)}, //地块id
+            plantType:{type:Sequelize.INTEGER}, //种植种类【枚举】 PLANTTYPE
+            weight:{type:Sequelize.DECIMAL},//采收重量
+            operationTime:{type:Sequelize.DATE},//采收时间
+            ct:{type:Sequelize.DATE},//创建时间
+        },
+        association: []
+    },
+    {
+        tableNameCn:'销售',
+        tableName:'xiaoshou',
+        schema:{
+            xsId: {
+                type:Sequelize.STRING(255), //表示属性的数据类型
+                allowNull:false, //表示当前列是否允许为空， false表示该列不能为空
+                primaryKey:true, //表示主键
+                unique:true //表示该列的值必须唯一
+            },
+            plantType:{type:Sequelize.INTEGER}, //种植种类【枚举】 PLANTTYPE
+            quXiang:{type:Sequelize.INTEGER},//销售去向
+            weight:{type:Sequelize.DECIMAL},//重量
+            operationTime:{type:Sequelize.DATE},//销售时间
+            ct:{type:Sequelize.DATE},//创建时间
+        },
+        association: []
+    },
+
+
+]; 
\ No newline at end of file

src/data/add.ts

+import { mysqlModelMap} from "../db/sqlModelBind";
+
+/**
+ * 添加数据
+ * @param tableModel 
+ * @param data 
+ * @returns 
+ */
+export async function addData(tableEnumValue:string, data:any) {
+    let dataArray = [];
+    if (!Array.isArray(data)) {
+        dataArray.push(data);
+    } else dataArray = data;
+    
+    await mysqlModelMap[tableEnumValue].bulkCreate(dataArray);
+}
\ No newline at end of file

src/data/caishou.ts

+
+
+import {Schema} from 'mongoose';
+import { baseDB } from '../db/dbInit';
+
+const caishouSchema = new Schema({
+    csId:{type:String, index:true},//
+    dIdList:{type:[String]}, //地块id
+    plantType:Number, //种植种类【枚举】 PLANTTYPE
+    weight:Number,//采收重量
+    operationTime:Number,//采收时间 时间戳
+    ct:Number,//创建时间
+    createUser:String,//创建人
+});
+
+var caishouModel;
+export function initModel(){
+    caishouModel = baseDB.model('caishou', caishouSchema);
+    caishouModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await caishouModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+
+export async function addData(param) {
+    return await caishouModel.create(param);
+}
+
+export async function findOne(param) {
+    return await caishouModel.selectOnceData(param);
+}
+
+export async function selectToParam(param) {
+    return await caishouModel.find(param);
+}
+
+
+export async function selectChanLiangOfMonth() {
+    return await caishouModel.aggregate([
+        {
+          $group: {
+            _id: {
+              year: { $year: { date: { $toDate: "$operationTime" }, timezone: "UTC" } },
+              month: { $month: { date: { $toDate: "$operationTime" }, timezone: "UTC" } }
+            },
+            totalWeight: { $sum: "$weight" }
+          }
+        },
+        {
+          $project: {
+            _id: 0,
+            year: "$_id.year",
+            month: "$_id.month",
+            totalWeight: 1
+          }
+        },
+        {
+          $sort: { year: 1, month: 1 }
+        }
+      ]);
+}
+
+export async function selectChanLiangOfzuoWu() {
+    return await caishouModel.aggregate([
+        {
+          $group: {
+            _id:"$plantType",
+            totalWeight: { $sum: "$weight" }
+          }
+        }]);
+}

src/data/delete.ts

+/**
+ * 删除
+ */
+
+import { mysqlModelMap} from "../db/sqlModelBind";
+
+
+
+export async function delData(tableEnumValue:string, param) {
+    await mysqlModelMap[tableEnumValue].destroy({where:param});
+}
\ No newline at end of file

src/data/dikuai.ts

+/**
+ * 企业经营数据 数据层
+ * 
+ */
+
+import {Schema} from 'mongoose';
+import { baseDB } from '../db/dbInit';
+import { PLOTTYPE } from '../config/enum';
+
+const dikuaiSchema = new Schema({
+    dId: {type:String, index:true},//
+    size: Number, //地块大小
+    useSize: Number, //使用大小
+    nullSize:Number,//可使用大小
+    code:String, //编号
+    name:String, //地块名称 同code
+    area:String,//地块区域
+    plotType:Number, //地块类型 【枚举】  PLOTTYPE
+    purpose:Number,//用途 【枚举】 PURPOSE
+    createUser:String, //创建人
+    ct:Number,//创建时间
+});
+
+var dikuaiModel;
+export function initModel(){
+    dikuaiModel = baseDB.model('dikuai', dikuaiSchema);
+    dikuaiModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await dikuaiModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+
+export async function addData(param) {
+    return await dikuaiModel.create(param);
+}
+
+export async function addManyData(param) {
+    return await dikuaiModel.insertMany(param);
+}
+
+export async function selectOne(param) {
+    return await dikuaiModel.selectOnceData(param);
+}
+
+export async function selectToParam(param) {
+    return await dikuaiModel.find(param);
+}
+
+
+export async function diKuaiSizeCount() {
+    let list = await dikuaiModel.aggregate([
+        {
+            "$group":{
+                _id:null,
+                totalSize:{"$sum":"$size"},
+                totalUseSize:{"$sum":"$useSize"}
+            }
+        }
+    ]);
+
+    return list[0];
+}
+
+
+export async function diKuaiSizeCountByParam(param) {
+    let list = await dikuaiModel.aggregate([
+        { $match: param },
+        {
+            "$group":{
+                _id:null,
+                totalSize:{"$sum":"$size"},
+                totalUseSize:{"$sum":"$useSize"}
+            }
+        }
+    ]);
+
+    return list[0];
+}

src/data/nongshi.ts

+/**
+ * 企业经营数据 数据层
+ * 
+ */
+
+import {Schema} from 'mongoose';
+import { baseDB } from '../db/dbInit';
+
+const nongshiSchema = new Schema({
+    nsId: {type:String, index:true},//,
+    nsType:Number, //农事类型
+    dIdList:{type:[String], default:[]}, //地块id
+    operationTime:Number,//操作时间
+    ct:Number,//创建时间
+});
+
+var nongshiModel;
+export function initModel(){
+    nongshiModel = baseDB.model('nongshi', nongshiSchema);
+    nongshiModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await nongshiModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+
+export async function addData(param) {
+    return await nongshiModel.create(param);
+}
+
+export async function addManyData(param) {
+    return await nongshiModel.insertMany(param);
+}
+
+
+export async function findOne(param) {
+    return await nongshiModel.selectOnceData(param);
+}
+
+export async function selectToParam(param) {
+    return await nongshiModel.find(param);
+}
+
+export async function selectCountByParam(param) {
+    return await nongshiModel.find(param).countDocuments();
+}
+
+
+export async function statisNongShiType() {
+    let list = await nongshiModel.aggregate([
+        {
+            $group: {
+                _id: {
+                    year: { $year: { date: { $toDate: "$operationTime" }, timezone: "UTC" } },
+                    month: { $month: { date: { $toDate: "$operationTime" }, timezone: "UTC" } }
+                },
+                count: { $sum: 1 }
+            }
+        },
+        {
+            $project: {
+                _id: 0,
+                year: "$_id.year",
+                month: "$_id.month",
+                count: 1
+            }
+        },
+        {
+            $sort: { year: 1, month: 1 }
+        }
+    ]);
+
+    return list;
+}
\ No newline at end of file

src/data/nongzi.ts

+/**
+ * 企业经营数据 数据层
+ * 
+ */
+
+import {Schema} from 'mongoose';
+import { baseDB } from '../db/dbInit';
+
+const nongziSchema = new Schema({
+    nzId: {type:String, index:true},//,
+    nzType:Number, //农资类型 
+    dIdList:{type:[String], default:[]}, //地块id
+    plantType:Number, //作物名称【枚举】 PLANTTYPE
+    count:Number,//用量
+    useTime:Number,//使用时间
+    ct:Number,//创建时间
+});
+
+var nongziModel;
+export function initModel(){
+    nongziModel = baseDB.model('nongzi', nongziSchema);
+    nongziModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await nongziModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+
+export async function addData(param) {
+    return await nongziModel.create(param);
+}
+
+export async function addManyData(param) {
+    return await nongziModel.insertMany(param);
+}
+
+export async function findOne(param) {
+    return await nongziModel.selectOnceData(param);
+}
+
+export async function selectToParam(param) {
+    return await nongziModel.find(param);
+}
+
+
+export async function statisNongZiType() {
+    let list = await nongziModel.aggregate([
+        {
+            "$group":{
+                _id:"$nzType",
+                count:{"$sum":1}
+            }
+        }
+    ]);
+
+    return list;
+}
+
+
+export async function statisNongZiTypeCountByTime() {
+    let list = await nongziModel.aggregate([
+        {
+            $group: {
+                _id: {
+                    year: { $year: { date: { $toDate: "$useTime" }, timezone: "UTC" } },
+                    month: { $month: { date: { $toDate: "$useTime" }, timezone: "UTC" } },
+                    nzType:"$nzType"
+                },
+                totalWeight: { $sum: "$count" }
+            }
+        },
+        {
+            $project: {
+                _id: 0,
+                year: "$_id.year",
+                month: "$_id.month",
+                nzType:"$_id.nzType",
+                totalWeight: 1
+            }
+        },
+        {
+            $sort: { year: 1, month: 1 }
+        }
+    ]);
+
+    return list;
+}
\ No newline at end of file

src/data/select.ts

+import { Op, Sequelize } from "sequelize";
+import { ERRORENUM } from "../config/errorEnum";
+import { mysqlModelMap} from "../db/sqlModelBind";
+import { BizError } from "../util/bizError";
+
+
+/**
+ * where条件查询参数
+ * @param param 
+ * %like%：模糊查询 {列名: {"%like%": }}
+ * %gt%：大于 {列名: {"%gt%": }}
+ * %gte%：大于等于 {列名: {"%gte%": }}
+ * %lt%：小于 {列名: {"%lt%": }}
+ * %lte%：小于等于 {列名: {"%lte%": }}
+ * %between%：查询范围内数据 {列名: {"%between%": ["开始参数", "结束参数"]}} ---BETWEEN 开始参数 AND 结束参数 列>开始参数 and 列<结束参数
+ * %notBetween%：查询不在范围内数据 {列名: {"%notBetween%": ["开始参数", "结束参数"]}} ---NOT BETWEEN 开始参数 AND 结束参数
+ * %orderDesc%: order by DESC {"%orderDesc%": "列名"}
+ * %limit%: {"%limit%": 数量}
+ * @param column 
+ * @returns 
+ */
+function analysisParamToWhere(param, column) {
+    let where = {};
+    let order = [];
+    let group = "";
+    let limit = 0;
+    for (let key in param) {  
+        if (typeof param[key] == "object") {
+            where[key] = {};
+            for (let whereKey in param[key]){
+                switch(whereKey) {
+                    case "%like%":
+                        where[key][Op.like] = `%${param[key]["%like%"]}%`;
+                    break;
+                    case "%gt%":
+                        where[key][Op.gt] = param[key]["%gt%"];
+                    break;
+                    case "%gte%":
+                        where[key][Op.gte] = param[key]["%gte%"];
+                    break;
+                    case "%lt%":
+                        where[key][Op.lt] = param[key]["%lt%"];
+                    break;
+                    case "%lte%":
+                        where[key][Op.lte] = param[key]["%lte%"];
+                    break;
+                    case "%between%":
+                        where[key][Op.between] = param[key]["%between%"];
+                    break;
+                    case "%notBetween%":
+                        where[key][Op.notBetween] = param[key]["%notBetween%"];
+                    break;
+                    case "%in%":
+                        where[key][Op.in] = param[key]["%in%"];
+                    break;
+                    case "%notIn%":
+                        where[key][Op.notIn] = param[key]["%notIn%"];
+                    break;
+                    case "%ne%":
+                        where[key][Op.ne] = param[key]["%ne%"];
+                    break;
+                }
+            }
+        }else {
+            switch (key) {
+                case "%orderDesc%":
+                    order = [[Sequelize.col(param[key]), "DESC"]];
+                break;
+                case "%orderAsc%":
+                    order = [[Sequelize.col(param[key]), "ASC"]];
+                break;
+                case "%limit%":
+                    limit = param[key];
+                break;
+                case "%group%":
+                    group = param[key];
+                break;
+                default: where[key] = param[key];
+            }
+        }
+    }
+
+    let selectParam:any = {where};
+    if (column && column.length) selectParam.attributes = column;
+    if (order && order.length) selectParam.order = order;
+    if (limit) selectParam.limit = limit;
+    if (group) selectParam.group = group;
+    return selectParam;
+}
+
+
+
+/**
+ * 查询单个数据
+ * @param tableEnumValue 
+ * @param param 
+ * @param column 
+ * @returns 
+ */
+export async function selectOne(tableEnumValue, param, column) {
+    let selectParam = analysisParamToWhere(param, column);
+    return await mysqlModelMap[tableEnumValue].findOne(selectParam);
+}
+
+
+/**
+ * 查询多个数据
+ * @param tableEnumValue 
+ * @param param 
+ * @param column 
+ * @returns 
+ */
+export async function selectToParam(tableEnumValue, param, column) {
+    let selectParam = analysisParamToWhere(param, column);
+    return await mysqlModelMap[tableEnumValue].findAll(selectParam);
+}
+
+
+/**
+ * 分页查询
+ * @param tableEnumValue 
+ * @param param 
+ * @param column 
+ * @param pageNumber 
+ * @param pageSize 
+ * @returns 
+ */
+export async function selectToPage(tableEnumValue, param, column, pageNumber:number, pageSize:number) {
+    let selectParam:any = analysisParamToWhere(param, column);
+    selectParam.limit = pageSize || 10;
+    selectParam.offset = (pageNumber-1)*10;
+    return await mysqlModelMap[tableEnumValue].findAll(selectParam);
+}
+
+/**
+ * 查询数量
+ * @param tableModel 
+ * @param param 
+ * @returns 
+ */
+export async function selectCountByParam(tableEnumValue, param) {
+    let selectParam:any = analysisParamToWhere(param, []);
+    return await mysqlModelMap[tableEnumValue].count(selectParam);
+}
+
+
+
+/**
+ * 多表联查 列表
+ * @param tableEnumValue 
+ * @param includeConf {"表名":["",""] } 
+ * @param param 
+ * @param column 
+ * @returns 
+ */
+export async function selectManyTableToParam(tableEnumValue, includeConf, param, column) {
+    let include = [];
+    for (let tableName in includeConf) {
+        if (!mysqlModelMap[tableName]) throw new BizError(ERRORENUM.不存在表, `尝试进行多表联查，但是不存在${tableName}`);
+        let {where, column} = includeConf[tableName];
+        let includeInfomation = analysisParamToWhere(where, column);
+        includeInfomation.model = mysqlModelMap[tableName];
+        include.push(includeInfomation);
+    }
+
+    let selectParam:any = analysisParamToWhere(param, column);
+    selectParam.include = include;
+
+    return await mysqlModelMap[tableEnumValue].findAll(selectParam);
+}
+
+
+
+/**
+ * 多表联查 分页
+ * @param tableEnumValue 
+ * @param includeConf {"表名":["",""] } 
+ * @param param 
+ * @param column 
+ * @returns 
+ */
+export async function selectManyTableToParamToPage(tableEnumValue, includeConf, param, column, pageNumber:number, pageSize:number) {
+    let include = [];
+    for (let tableName in includeConf) {
+        if (!mysqlModelMap[tableName]) throw new BizError(ERRORENUM.不存在表, `尝试进行多表联查，但是不存在${tableName}`);
+        let {where, column, required} = includeConf[tableName];
+        let includeInfomation = analysisParamToWhere(where, column);
+        includeInfomation.model = mysqlModelMap[tableName];
+        // if (required != undefined) {
+        //     includeInfomation.required = required;
+        // }
+        include.push(includeInfomation);
+    }
+
+    let selectParam:any = analysisParamToWhere(param, column);
+    selectParam.include = include;
+    selectParam.limit = pageSize || 10;
+    selectParam.offset = (pageNumber-1)*10;
+
+    return await mysqlModelMap[tableEnumValue].findAll(selectParam);
+}
+
+
+/**
+ * 多表查询单个
+ * @param tableModel 
+ * @param includeConf 
+ * @param param 
+ * @param column 
+ * @returns 
+ */
+export async function selectOnceDataForManyTableToParam(tableEnumValue, includeConf, param, column) {
+    let include = [];
+    for (let tableName in includeConf) {
+        if (!mysqlModelMap[tableName]) throw new BizError(ERRORENUM.不存在表, `尝试进行多表联查，但是不存在${tableName}`);
+        let {where, column} = includeConf[tableName];
+        let includeInfomation = analysisParamToWhere(where, column);
+        includeInfomation.model = mysqlModelMap[tableName];
+        include.push(includeInfomation);
+    }
+
+    let selectParam:any = analysisParamToWhere(param, column);
+    selectParam.include = include;
+
+    return await mysqlModelMap[tableEnumValue].findOne(selectParam);
+}
+
+

src/data/update.ts

+
+import { Op, Sequelize } from "sequelize";
+import { mysqlModelMap} from "../db/sqlModelBind";
+
+/**
+ * where条件查询参数
+ * @param param 
+ * %like%：模糊查询 {列名: {"%like%": }}
+ * %gt%：大于 {列名: {"%gt%": }}
+ * %gte%：大于等于 {列名: {"%gte%": }}
+ * %lt%：小于 {列名: {"%lt%": }}
+ * %lte%：小于等于 {列名: {"%lte%": }}
+ * %between%：查询范围内数据 {列名: {"%between%": ["开始参数", "结束参数"]}} ---BETWEEN 开始参数 AND 结束参数
+ * %notBetween%：查询不在范围内数据 {列名: {"%notBetween%": ["开始参数", "结束参数"]}} ---NOT BETWEEN 开始参数 AND 结束参数
+ * %orderDesc%: order by DESC {"%orderDesc%": "列名"}
+ * %limit%: {"%limit%": 数量}
+ * @returns 
+ */
+function analysisParamToWhere(param) {
+    let where = {};
+    let order = [];
+    let limit = 0;
+    for (let key in param) {  
+        if (typeof param[key] == "object") {
+            where[key] = {};
+            for (let whereKey in param[key]){
+                switch(whereKey) {
+                    case "%like%":
+                        where[key][Op.like] = `%${param[key]["%like%"]}%`;
+                    break;
+                    case "%gt%":
+                        where[key][Op.gt] = param[key]["%gt%"];
+                    break;
+                    case "%gte%":
+                        where[key][Op.gte] = param[key]["%gte%"];
+                    break;
+                    case "%lt%":
+                        where[key][Op.lt] = param[key]["%lt%"];
+                    break;
+                    case "%lte%":
+                        where[key][Op.lte] = param[key]["%lte%"];
+                    break;
+                    case "%between%":
+                        where[key][Op.between] = param[key]["%between%"];
+                    break;
+                    case "%notBetween%":
+                        where[key][Op.notBetween] = param[key]["%notBetween%"];
+                    break;
+                    case "%in%":
+                        where[key][Op.in] = param[key]["%in%"];
+                    break;
+                    case "%notIn%":
+                        where[key][Op.notIn] = param[key]["%notIn%"];
+                    break;
+                }
+            }
+        }else {
+            switch (key) {
+                case "%orderDesc%":
+                    order = [[Sequelize.col(param[key]), "DESC"]];
+                break;
+                case "%orderAsc%":
+                    order = [[Sequelize.col(param[key]), "ASC"]];
+                break;
+                case "%limit%":
+                    limit = param[key];
+                break;
+                default: where[key] = param[key];
+            }
+        }
+    }
+
+    let selectParam:any = {where};
+    if (order && order.length) selectParam.order = order;
+    if (limit) selectParam.limit = limit;
+    return selectParam;
+}
+
+
+export async function updateManyData(tableEnumValue, param:object, data:object) {
+    let where = analysisParamToWhere(param);
+
+    await mysqlModelMap[tableEnumValue].update(data, where);
+}
\ No newline at end of file

src/data/users.ts

+/**
+ * 用户表
+ */
+import { Schema } from 'mongoose';
+import { baseDB } from '../db/dbInit';
+
+const userSchema = new Schema({
+    name:String,//名称
+    loginId: {type:String, index:true},//登录账号
+    userId:{type:String, index:true},
+    pwd:String,//密码
+    phone:{type:String, index:true},//登录手机号
+    token:String,
+    tokenMs:Number,
+    position:String,//职务
+});
+
+var userModel;
+export function initModel(){
+    userModel = baseDB.model('user', userSchema);
+    userModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await userModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+export async function findUserInfoByLoginId(loginId:string) {
+    return await userModel.selectOnceData({loginId});
+}
+
+export async function findUserInfoByUserId(userId:string) {
+    return await userModel.selectOnceData({userId});
+}
+
+export async function findUserMap() {
+    let map = {};
+    let userList = await userModel.find({});
+    userList.forEach(info => {
+        map[info.userId] = info.name;
+    });
+    return map;
+}
+
+
+export async function createUser(addInfo) {
+    await userModel.create(addInfo);
+}
+
+export async function createManyUser(userList) {
+    await userModel.insertMany(userList);
+}
\ No newline at end of file

src/data/xiaoshou.ts

+/**
+ * 企业经营数据 数据层
+ * 
+ */
+
+import {Schema} from 'mongoose';
+import { baseDB } from '../db/dbInit';
+
+const xiaoshouSchema = new Schema({
+    xsId: {type:String, index:true},//,
+    plantType:Number, //种植种类【枚举】 PLANTTYPE
+    quXiang:Number,//销售去向
+    weight:Number,//重量
+    operationTime:Number,//销售时间
+    ct:Number,//创建时间
+    createUser:String,//创建人
+});
+
+var xiaoshouModel;
+export function initModel(){
+    xiaoshouModel = baseDB.model('xiaoshou', xiaoshouSchema);
+    xiaoshouModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await xiaoshouModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+
+export async function addData(param) {
+    return await xiaoshouModel.create(param);
+}
+
+export async function addManyData(param) {
+    return await xiaoshouModel.insertMany(param);
+}
+
+export async function selectOne(param) {
+    return await xiaoshouModel.selectOnceData(param);
+}
+
+export async function selectToParam(param) {
+    return await xiaoshouModel.find(param);
+}
+
+
+export async function selectXiaoShouOfMonth() {
+    return await xiaoshouModel.aggregate([
+        {
+          $group: {
+            _id: {
+              year: { $year: { date: { $toDate: "$operationTime" }, timezone: "UTC" } },
+              month: { $month: { date: { $toDate: "$operationTime" }, timezone: "UTC" } }
+            },
+            totalWeight: { $sum: "$weight" }
+          }
+        },
+        {
+          $project: {
+            _id: 0,
+            year: "$_id.year",
+            month: "$_id.month",
+            totalWeight: 1
+          }
+        },
+        {
+          $sort: { year: 1, month: 1 }
+        }
+    ]);
+}
+
+export async function selectXiaoShouOfzuoWu() {
+    return await xiaoshouModel.aggregate([
+        {
+            $group: {
+            _id:"$plantType",
+            totalWeight: { $sum: "$weight" }
+            }
+    }]);
+}

src/data/zhongzhi.ts

+/**
+ * 
+ * 
+ */
+
+import {Schema} from 'mongoose';
+import { baseDB } from '../db/dbInit';
+
+const zhongzhiSchema = new Schema({
+    zId:{type:String, index:true},//
+    size:Number, //种植面积
+    plantType:Number, //种植种类【枚举】 PLANTTYPE
+    dId:String, //地块id
+    plantTime:Number, //种植时间
+    uId:String,//用户id
+    isEnd:{type:Number, default:0},//是否结束  0=否 1=是
+    ct:Number,
+    csId:String,//采收id
+});
+
+var zhongzhiModel;
+export function initModel(){
+    zhongzhiModel = baseDB.model('zhongzhi', zhongzhiSchema);
+    zhongzhiModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await zhongzhiModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+
+export async function addData(param) {
+    return await zhongzhiModel.create(param);
+}
+
+export async function addManyData(param) {
+    return await zhongzhiModel.insertMany(param);
+}
+
+export async function selectOne(param) {
+    return await zhongzhiModel.selectOnceData(param);
+}
+
+export async function selectToParam(param) {
+    return await zhongzhiModel.find(param);
+}
+
+export async function updateManyToParam(param, updateInfo) {
+    return await zhongzhiModel.updateMany(param, {"$set":updateInfo});
+}
+
+export async function pingZhongCount() {
+    let list = await zhongzhiModel.aggregate([
+        { $match: { isEnd: 0 } },
+        {
+            "$group":{
+                _id:"$plantType",
+                count:{"$sum":1}
+            }
+        }
+    ]);
+
+    return list;
+}
+
+
+export async function zhongZhiTongJiCount() {
+    let list = await zhongzhiModel.aggregate([
+        { $match: { isEnd: 0 } },
+        {
+            "$group":{
+                _id:"$plantType",
+                sizeCount:{"$sum":"$size"}
+            }
+        }
+    ]);
+
+    return list;
+}
+

src/db/dbConnect.ts

+import mongoose = require('mongoose');
+
+let defaultOptions = {
+    useNewUrlParser:true,
+    auto_reconnect:true,
+    // reconnectTries:1000,
+    // reconnectInterval:3000,
+    keepAlive: 1,
+    connectTimeoutMS: 3000,
+    useCreateIndex: true,
+    useUnifiedTopology: true
+};
+
+
+export async function createDbConnect(connectUrl:string, options?:object) {
+  if (!options) options = defaultOptions;
+  return await mongoose.createConnection(connectUrl, options).catch(
+    (err)=>{
+      throw err
+    });
+}

src/db/dbInit.ts

+
+
+import { systemConfig } from "../config/serverConfig";
+import { BizError } from "../util/bizError";
+import { createDbConnect } from "./dbConnect";
+import { initTable } from "./tableInit";
+var baseDB;
+
+export async function initDB() {
+    //如果配置了mongoServerConstVal 才会连接mongo
+    if (systemConfig.mongodbStr) {
+        console.log(systemConfig.mongodbStr);
+        baseDB = await createDbConnect(systemConfig.mongodbStr).catch(err => {
+            throw err
+        });
+    
+        await initTable();
+        console.log('mongodb init success');
+    } else {
+        throw new BizError("xml中未配置mongo连接字符串 无法连接到mongodb");
+    }
+   
+}
+
+export { baseDB };

src/db/mysqlInit.ts

+import { systemConfig } from "../config/serverConfig";
+//导入sequelize模块
+const Sequelize = require('sequelize');
+
+var mysqlDB;
+export async function initMysqlDB() {
+    mysqlDB = new Sequelize(systemConfig.mysqldb.dataBase,systemConfig.mysqldb.user,systemConfig.mysqldb.pwd,{
+        host:systemConfig.mysqldb.host,
+        port:systemConfig.mysqldb.port,
+        dialect:'mysql',   //数据库类型
+        pool:{  //数据库连接池
+            max:20,  //最大连接对象的个数
+            min:5,  //最小连接对象的个数
+            idle:1000  //最长等待时间，单位为毫秒
+        },
+        timezone: '+08:00', //东八时区
+        dialectOptions: {
+            dateStrings: true,
+            typeCast: true
+        },
+    }); 
+}
+
+export { mysqlDB };
\ No newline at end of file

src/db/sqlModelBind.ts

+/**
+ * mysql 数据层
+ */
+
+import { TablesConfig } from "../config/tableConfig";
+import { mysqlDB } from "../db/mysqlInit";
+
+let mysqlModelMap = {};
+
+export async function initMysqlModel() {
+
+    /**初始化表 */
+    for (let i =0; i < TablesConfig.length; i++) {
+        let { tableName, schema }  = TablesConfig[i];
+
+        let schemaConf = {
+            freezeTableName:true, //true表示使用给定的表名，false表示模型名后加s作为表名
+            timestamps:false  //true表示给模型加上时间戳属性(createAt updateAt),false表示不带时间戳属性
+        };
+
+        let model = mysqlDB.define( tableName, schema, schemaConf);
+        
+        mysqlModelMap[tableName] = await model.sync({}).then();
+        
+    }
+
+    /**初始化表关联 */
+    for (let i =0; i < TablesConfig.length; i++) {
+        let { tableName, association }  = TablesConfig[i];
+        association.forEach( (item:any) => {
+            if (item) {
+                let {type, check, foreignKey} = item;
+                if (type == "hasOne") {
+                    mysqlModelMap[check].hasOne(mysqlModelMap[tableName]);
+                } else if (type == "hasMany") {
+                    mysqlModelMap[tableName].hasMany(mysqlModelMap[check], {foreignKey});
+                }
+                mysqlModelMap[check].belongsTo(mysqlModelMap[tableName], {foreignKey});
+                console.log("---->", mysqlModelMap[tableName].getTableName());
+                console.log("====>", mysqlModelMap[check].getTableName());
+            }
+        });
+        
+    }
+
+
+}
+
+export { mysqlModelMap };
+
+    
+    
+    
+    
+    
+    
\ No newline at end of file

src/db/tableInit.ts

+import * as caishouModel  from "../data/caishou";
+import * as dikuaiModel  from "../data/dikuai";
+import * as nongshiModel  from "../data/nongshi";
+import * as nongziModel  from "../data/nongzi";
+import * as usersModel  from "../data/users";
+import * as xiaoshouModel  from "../data/xiaoshou";
+import * as zhongzhiModel  from "../data/zhongzhi";
+
+ 
+
+export async function initTable() {
+    caishouModel.initModel();
+    dikuaiModel.initModel();
+    nongshiModel.initModel();
+    nongziModel.initModel();
+    usersModel.initModel();
+    xiaoshouModel.initModel();
+    zhongzhiModel.initModel();
+}
\ No newline at end of file

src/main.ts

+
+import { initConfig, systemConfig } from "./config/serverConfig";
+import { httpServer } from "./net/http_server";
+import { initDB } from "./db/dbInit";
+import { dataInit } from "./biz/dataInt";
+import { getDataOut } from "./biz/dataOut";
+
+async function lanuch() {
+    /**初始化配置解析 */
+    await initConfig();
+    /**初始化数据库 */
+    await initDB();
+    /**创建http服务 */
+    httpServer.createServer(systemConfig.port);
+    console.log('This indicates that the server is started successfully.');
+ 
+    // await dataInit();
+
+}
+
+
+
+lanuch();
\ No newline at end of file

src/middleware/fromParam.ts

+import { ERRORENUM } from "../config/errorEnum";
+import { BizError } from "../util/bizError";
+
+var formidable = require("formidable");
+const path = require('path');
+
+export async function parseFormParam(req, res, next) {
+    var form = new formidable.IncomingForm();
+    form.uploadDir = path.join(__dirname.substring(0,__dirname.indexOf("out")), 'files');
+    form.parse(req, (err, fields, files)=>{
+        if (err) {
+            next(err)
+        }
+        else {
+            req.fields = fields;
+            req.files = files;
+            if (!files.file) {
+                return next(new BizError(ERRORENUM.文件上传失败) )
+            }
+            if ( files.file.type == 'image/png') {
+                req.fileType = '.png';
+                next();
+            } else if (files.file.type == 'image/jpg' || files.file.type == 'image/jpeg') {
+                req.fileType = '.jpg';
+                next();
+            } else {
+                return next(new BizError(ERRORENUM.只能上传png或jpg图片) )
+            }
+            
+            
+        }
+    })
+}

src/middleware/httpErrorHandler.ts

+import { bizlive } from "tencentcloud-sdk-nodejs";
+import { ERRORCODEENUM } from "../config/errorEnum";
+
+/**
+ * 中间件 错误返回
+ * @param err 
+ * @param req 
+ * @param res 
+ * @param next 
+ */
+export function httpErrorHandler(err, req, res, next) {
+    // console.log("in httpErrorHandler");
+    console.log(err);
+    //todo 自定义错误编码
+    if (err) {
+        if ( ERRORCODEENUM[err.message] ) {
+            res.success({success:false, msg:err.message, code:ERRORCODEENUM[err.message]});
+            next();
+        }
+        else {
+            console.log(req.ip, err.message);
+            res.send({success:false, msg:err.message, code:500});
+            // res.success({success:false, msg:err.message, code:500});
+            next();
+        }
+    }
+} 
\ No newline at end of file

src/middleware/user.ts

+
+import { ERRORENUM } from "../config/errorEnum";
+import { findUserInfoByUserId } from "../data/users";
+import { BizError } from "../util/bizError";
+
+
+/**
+ * 管委会小程序中间件
+ * @param req 
+ * @param res 
+ * @param next 
+ * @returns 
+ */
+export async function checkUserToken(req, res, next) {
+    console.log(req.originalUrl, JSON.stringify(req.body));
+    if (!req.headers) req.headers = {};
+    const reqToken = req.headers.token;
+    const userId = req.headers.userid || "";
+
+    if (!userId) return next(new BizError(ERRORENUM.身份验证失败, `userId:${userId} token:${reqToken}`));
+
+    let userInfo = await findUserInfoByUserId(userId);
+    if (!userInfo) return next(new BizError(ERRORENUM.非法登录, `userId:${userId} token:${reqToken}`));
+    
+    if (userInfo.token != reqToken ) return next(new BizError(ERRORENUM.身份验证过期, `userId:${userId} token:${reqToken}`));
+
+    req.userInfo = {
+        userId:userInfo.userId,
+        name:userInfo.name,
+        position:userInfo.position
+    }
+
+    next();
+}

src/middleware/watch.ts

+export function watch(req, res, next) {
+    res.success = success.bind({res:res, req:req});
+    
+    return next();
+}
+
+/**
+ * 中间件正确返回方法
+ * @param data 
+ */
+function success(data) {
+    let resultPack;
+    if (data ) {
+        if ( data.success === undefined || data.success === true ) {
+            resultPack = {data, success:true, code:200};
+        }
+        else {
+            resultPack = data;
+        }
+    }else {
+        resultPack = {code:500, success:false, msg:'result is null'};
+    }
+    this.res.send(resultPack);
+}
+

src/net/http_server.ts

+import express = require('express');
+import bodyParser = require('body-parser');
+import routers = require('../routers/router');
+import compression = require('compression');
+import { watch } from '../middleware/watch';
+import { httpErrorHandler } from '../middleware/httpErrorHandler';
+import * as path from "path";
+import * as fallback from 'express-history-api-fallback';
+
+export class httpServer {
+    static createServer(port:number) {
+        var httpServer = express();
+
+        httpServer.all('*', (req, res, next) => {
+            res.header('Access-Control-Allow-Origin', req.headers.origin);
+            res.header("Access-Control-Allow-Headers", "X-Requested-With");
+            res.header('Access-Control-Allow-Headers', 'Content-Type,request-origin,userid,token');
+            res.header("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS");
+            res.header('Access-Control-Allow-Credentials', true);
+            res.header("X-Powered-By", ' 3.2.1');
+            next();
+            // if(req.method === 'OPTIONS'){
+            //     res.statusCode = 200;
+            //     res.end();
+            //   }else{
+            //       next();
+            //   }
+        });
+
+        // httpServer.use(bodyParser.json({limit:'5mb'}));
+        // httpServer.use(bodyParser.urlencoded({limit:'5mb', extends:true}));
+
+        httpServer.use(express.static("./static") );
+        httpServer.use(express.static("./files") );
+        const root = path.join(__dirname, "../../public");
+        httpServer.use(express.static(root));
+        httpServer.use(fallback('index.html', { root }));
+        httpServer.use(compression());
+        httpServer.use(watch);
+        httpServer.use(bodyParser.json({limit:"5000kb"}));
+        routers.setRouter(httpServer);
+        httpServer.use(httpErrorHandler);
+
+        httpServer.listen(port);
+        console.log('server listen on port:'+port);
+    }
+}
\ No newline at end of file

src/routers/public.ts

+/**
+ * 公共资源路由
+ */
+import * as asyncHandler from 'express-async-handler';
+import * as enumConfig from '../config/enum';
+
+const config = {
+    "/zj/xcx/public/plottype":enumConfig.PLOTTYPE,//地块类型
+    "/zj/xcx/public/purpose":enumConfig.PURPOSE,//用途
+    "/zj/xcx/public/planttype":enumConfig.PLANTTYPE,//种植种类
+    "/zj/xcx/public/arearange":enumConfig.AREARANGE,//面积范围
+    "/zj/xcx/public/nongzitype":enumConfig.NONGZITYPE,//农资类型
+    "/zj/xcx/public/nongshitype":enumConfig.NONGSHITYPE,//农事类型
+    "/zj/xcx/public/zhongyangtype":enumConfig.ZHONGYANGTYPE,//种养类型
+    "/zj/xcx/public/zhongyangtype/shuichan":enumConfig.SHUICHAN,//水产
+    "/zj/xcx/public/zhongyangtype/huahui":enumConfig.HUAHUITYPE,//花卉
+    "/zj/xcx/public/zhongyangtype/liangshi":enumConfig.LIANGSHI,//粮食
+    "/zj/xcx/public/zhongyangtype/shucai":enumConfig.SHUCAI,//蔬菜
+    "/zj/xcx/public/xiaoshouquxiang":enumConfig.XIAOSHOUQUXIANG,//销售去向
+}
+
+
+export function setRouter(httpServer) {
+    for (let modelKey in config) {
+        httpServer.post(modelKey, asyncHandler(getEnumItf(config[modelKey])));
+    }
+}
+
+
+/**
+ * 
+ * @param req 
+ * @param res 
+ */
+function getEnumItf(enumCof) {
+    return async function (req, res) {
+        let dataList = [];
+        for (let key in enumCof) {
+            let anyKey:any = key;
+            if (isNaN(anyKey)) {
+                dataList.push({key, value:enumCof[key]});
+            }
+        }
+        res.success({dataList});
+    }
+   
+}
\ No newline at end of file

src/tools/system.ts

+/**
+ * 系统中使用的工具
+ * 包括 草稿箱id生成规则
+ * 包括 密码加密规则
+ */
+
+import moment = require("moment");
+const md5 = require("md5");
+
+
+/**
+ * 生成任务草稿箱Id
+ * @param uscc 
+ * @returns 
+ */
+export function getDraftId(uscc:string) {
+    return md5(`${uscc}${new Date().valueOf()}${Math.ceil(Math.random()*1000)}`);
+}
+
+
+
+/**
+ * 密码加密
+ * @param uscc 信用代码
+ * @param pwd 密码
+ * @returns md5后的密码
+ */
+export function getPwdMd5(uscc:string, pwd:string) {
+    return md5(uscc+pwd);
+}
+
+
+/**
+ * md5加密
+ * @param pwd 
+ * @returns pwd 加密后密码
+ */
+export function md5PwdStr(pwd:string) {
+    return md5(pwd);
+}
+
+
+/**
+ * 获取token
+ * @param uscc 统一信用代码
+ */
+export function getToken(uscc:string) {
+    return md5(`${uscc}${new Date().valueOf()}${Math.ceil(Math.random() *100)}`);
+}
+
+
+export function randomId(tableName:string) {
+    let randomStr = `${tableName}_${new Date().valueOf()}_${Math.ceil(Math.random()*100000)}`;
+    return md5(randomStr);
+}
+
+export function getMySqlMs(time?) {
+    time = time || new Date().valueOf();
+    return moment(time).format("YYYY-MM-DD HH:mm:ss");
+}
+
+export function successResult() {
+    return {isSuccess:true}
+}

src/tools/taskTool.ts

+/**
+ * 孵化器 任务相关工具
+ * 只允许被孵化器任务相关逻辑使用
+ * 
+ */
+import moment = require("moment");
+const md5 = require("md5");
+
+
+
+/**----------------------------------------------月度任务   */
+/**
+ * 获取日期的key
+ * @param timeMs 指定时间, 如果不传就是当前数据
+ * @returns YYYYM
+ */
+export function getTimeKey(timeMs?) {
+    if (timeMs) return parseInt(`${new Date(timeMs).getFullYear()}${new Date(timeMs).getMonth() + 1 }`);
+    return parseInt(`${new Date().getFullYear()}${new Date().getMonth() + 1 }`);
+}
+
+
+/**
+ * 生成月度任务id
+ * @param uscc 企业统一信用代码
+ *  @returns uscc+YYYYM
+ */
+export function generateMonthTaskId(uscc:string) {
+    return `${uscc}${getTimeKey()}`;
+}
+
+
+/**
+ * 获取当前时间月度任务id
+ * @param uscc 企业标识
+ * @returns uscc+YYYYM
+ */
+export function getTaskId(uscc:string) {
+    return `${uscc}${getTimeKey()}`;
+}
+
+
+/**
+ * 根据时间获取任务id
+ * @param uscc 企业标识
+ * @param timeMs 时间戳
+ * @returns uscc+YYYYM
+ */
+export function getMonthTaskIdByTime(uscc:string, timeMs:number) {
+    return `${uscc}${getTimeKey(timeMs) }`;
+}
+
+
+/**
+ * 获取上一个月的日期标识
+ * @returns YYYYM(当前月的上一个月)
+ */
+export function getLastMonthTimeKey() {
+    return moment().subtract(1,'months').format('YYYYM');
+}
+
+/** -----------------------------------------------  季度任务 */ 
+
+
+/**
+ * 生成季度任务id
+ * 生成时所在季度
+ * @param uscc 企业标识
+ * @returns uscc+YYYY+0+Quarter
+ */
+export function generateQuarterTaskId(uscc:string) {
+    let thisQuarter = moment().quarter();//当月填报季度
+    return `${uscc}${new Date().getFullYear()}0${thisQuarter}`;
+}
+
+
+/**
+ * 获取当前季度任务id
+ * 季度是以填报季度,也就是当前季度当前季度
+ * @param uscc 企业标识
+ * @returns uscc+YYYY+0+Quarter
+ */
+export function getQuarterTaskId(uscc:string) {
+    let thisQuarter = moment().quarter();//当月填报季度
+    return `${uscc}${new Date().getFullYear()}0${thisQuarter}`;
+}
+
+
+/**
+ * 获取当前季度的时间标识
+ * @returns YYYY+0+Quarter
+ */
+export function getQuarterTimeKey() {
+    return parseInt(`${new Date().getFullYear()}0${moment().quarter()}`);
+}
+
+
+/**
+ * 获取指定时间戳的任务id
+ * @param uscc 孵化器统一信用代码
+ * @param timeMs 时间标识
+ * @returns uscc+YYYY+0+Quarter
+ */
+export function getQuarterTaskIdByTime(uscc:string, timeMs:number) {
+    return `${uscc}${new Date(timeMs).getFullYear()}0${moment(timeMs).quarter() }`;
+}
+
+
+/**
+ * 根据指定年和季度生成任务id
+ * @param uscc 孵化器统一信用代码
+ * @param year 年
+ * @param quarter 季度 
+ * @returns uscc+YYYY+0+Quarter
+ */
+export function getQuarterTaskIdByYearAndQuarter(uscc:string, year:number, quarter:number) {
+    return `${uscc}${year}0${quarter }`;
+}
\ No newline at end of file

src/util/analysisExcel.ts

+const xlsx = require('node-xlsx');
+const path = require('path');
+
+/**
+ *   onceSheetBecomeOfblockData 将excel文件的指定sheet解析成数据块数据
+ * @param fileName 文件名称
+ * @param sheetName 表名称
+ * @returns [ {blockData:数据块(二维数组), blockTitle:"数据标题"}]
+ */
+export function onceSheetBecomeOfblockData(fileName, sheetName) {
+    let {sheetMap} = getExcel( path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", fileName ));
+    // return sheetMap;
+    let thisBlockData = getBlockData(sheetMap[sheetName]);
+    return thisBlockData;
+}
+
+/**
+ * excelBecomeOfBlockData 将excel所有的sheet解析成数据块
+ * @param fileName 文件名称
+ * @returns {"sheetName1":[ {blockData:数据块(二维数组), blockTitle:"数据标题"}], ...}
+ */
+export function excelBecomeOfBlockData(fileName) {
+    let {sheetMap} = getExcel( path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", fileName ));
+    let result = {};
+    for (let sheetName in sheetMap) {
+        result[sheetName] = getBlockData(sheetMap[sheetName]);
+    }
+    return result;
+}
+
+/**
+ *  planaryArrayBecomeOfBlockData  将符合excel规则的sheet二维数组转为 数据块
+ * @param dataList excel解出来的数据
+ * @returns thisBlockData 返回数据块集合 格式：blockList = [ {blockData:数据块(二维数组), blockTitle:"数据标题"}]
+ */
+export function planaryArrayBecomeOfBlockData(planaryArray) {
+    return getBlockData(planaryArray);;
+}
+
+
+//===
+
+/**
+ * getBlockData 数据分块 
+ * @param dataList  解析出来的excel二维数组
+ * @returns 返回数据块集合 格式：blockList = [ {blockData:数据块(二维数组), blockTitle:"数据标题"}]
+ */
+function getBlockData(dataList) {
+    let blockList = [];
+    for (let i = 0; i < 999; i++) {
+        let {blockData, blockTitle, notItem, delDataList} = checkBlock(dataList);
+        if (notItem) break;
+        dataList = delDataList;
+        if (blockTitle) blockList.push({blockData, blockTitle});
+    }
+    return blockList;
+}
+
+function getListFristNotNullItemIndex(list) { //获取起始坐标
+    if (!list.length) return null;
+    for (let i = 0; i < list.length; i++) {
+        if (list[i]) return i;
+    }
+}
+
+
+function getListFirstNullItemIndex(startX, list) { //获取第一个为空的坐标
+    if (!list.length) return null;
+    let checkItem = false;
+    let firstItemIndex = 0;
+    for (let i = startX; i <= list.length; i++) {
+        let item = list[i];
+        if (!checkItem && item) checkItem = true;
+        
+        if (checkItem && !item) {
+            firstItemIndex = i;
+            break;
+        }
+    }
+    return firstItemIndex;
+}
+function listRegionIsNull(list, startX, endX) { //指定区间内数据是否未空
+    let isNull = true;
+    if ( !list.length ) return isNull;
+
+    for (let i = startX; i < endX; i++) {
+        let item = list[i];
+        if (item) {
+            isNull = false;
+            break;
+        }
+    }
+    return isNull;
+}
+
+function thisListNotItem(list) {
+    for (let i = 0; i < list.length; i++) {
+        if (list[i]) return false;
+    }
+    return true
+}
+
+function checkBlock(dataList) {
+    //纵向有效起始点
+    let startY = 0;
+    let startX = 0;
+    let isNotBlockTitle = false; //没有块标题
+    let isLook = false;
+    let endX = 0;//x轴最长结束下标 【包括下标】
+    
+
+    let blockTitle = ''; //标题块名称
+
+    let notItem = true;
+
+    for (let i = 0; i < dataList.length; i++) {
+        let childList = dataList[i] || [];
+
+        if (!thisListNotItem(childList)) {
+            
+            if ( !isLook ) {
+                let thisRoowStartX = getListFristNotNullItemIndex(childList);
+                let thisRoowLastItem = childList[thisRoowStartX + 1];
+                let LastList = dataList[i+1] || [];
+                // let lastRoowStartX = getListFristNotNullItemIndex(LastList);
+                let lastRoowHaveItem = LastList[thisRoowStartX];
+                if ( thisRoowLastItem || (LastList.length && lastRoowHaveItem)  ) {
+                    
+                    if (lastRoowHaveItem && thisRoowLastItem ) {
+                        isNotBlockTitle = true; //不存在标题块
+                        blockTitle = `${thisRoowStartX}_${i}`;
+                        startY = i;
+                        startX = thisRoowStartX;
+                    }
+                    else {
+                        blockTitle = dataList[i][thisRoowStartX];
+                        dataList[i][thisRoowStartX] = null;
+
+                        if ( thisRoowLastItem ) { // 同行存在元素 标题在y轴上
+                            startY = i;
+                            startX = thisRoowStartX + 1;
+                        } else {  // 同行存在元素 标题在x轴上
+                            startY = i + 1;
+                            startX = thisRoowStartX;
+                        }
+                    }
+                    
+                    isLook = true;
+                } else { //只有标题 无内容
+                    console.log(dataList[i][thisRoowStartX]);
+                    dataList[i][thisRoowStartX] = null;
+                }
+                
+            } else {
+                //测量最大连续长度
+                let firstNullX = getListFirstNullItemIndex(startX, childList);
+                if (firstNullX) endX = Math.max(endX, firstNullX-1);
+                break;
+            }
+            notItem = false;
+        }
+    }
+    let endY = 0;//y轴连续下标 【包括下标】
+
+    let yInfoStart = false;
+    let yInfoEnd = false;
+
+    for (let y = startY; y < dataList.length; y++) {
+        //纵向找连续性
+        let thisRoow = dataList[y];
+        let regionIsNull = listRegionIsNull(thisRoow, startX, endX);
+        if (!regionIsNull) {
+            endY = y;
+            if (!yInfoStart) yInfoStart = true;
+        }
+        if (yInfoStart && regionIsNull) yInfoEnd = true;
+        if (yInfoEnd) break;
+    }
+    
+    let blockData = [];
+    for (let y = startY; y <= endY; y++) {
+        let onceList = [];
+        for (let x = startX; x <= endX; x++) {
+            onceList.push(dataList[y][x]);
+            dataList[y][x] = null;
+        }
+        blockData.push(onceList);
+    }
+
+    return {blockData, blockTitle, delDataList:dataList,notItem};
+}
+
+
+
+//获取单个excel文件的数据
+function getExcel(filePath) {
+    const workSheetsFromFile = xlsx.parse(filePath);
+    let sheetMap = {};
+    let sheetList = [];
+
+    for (let i = 0; i < workSheetsFromFile.length; i++) {
+        let sheetInfo = workSheetsFromFile[i];
+        sheetMap[sheetInfo.name] = sheetInfo.data;
+        sheetList.push(sheetInfo);
+    }
+
+    return {sheetMap, sheetList}  
+}
\ No newline at end of file

src/util/bizError.ts

+/**
+ * 异常类
+ * 需要和log4js共同使用
+ */
+
+import { getBizMsg } from "../config/errorEnum";
+import { logError } from "./log";
+
+export class BizError extends Error {
+    constructor(...msgs) {
+        let reqErrorMsg = '';
+        let logErrorMsg = '';
+        for (let i = 0; i <msgs.length; i++) {
+            if (!i) {
+                let msg = getBizMsg(msgs[i]);
+                reqErrorMsg = msg;
+                logErrorMsg = msg;
+            } else {
+                logErrorMsg += ` | ${msgs[i]} `;
+            }
+        }
+
+        logError(logErrorMsg);
+        super(reqErrorMsg);
+    }
+}

src/util/log.ts

+/**
+ * 日志类
+ * 包括错误日志 普通日志 
+ * 日志存放在根目录的logs内
+ */
+
+let log4js = require('log4js');
+let path = require('path');
+
+//log路径
+export const systemLogPath = {
+    errorLogFile:"error",
+    errorLogDir:"error",
+    handleLogFile:"handle",
+    handleLogDir:"handle"
+}
+
+//日志根目录
+// let baseLogPath = path.resolve(__dirname.substring(0, __dirname.indexOf("out")), 'logs');
+let baseLogPath = path.resolve('./', 'logs');
+let errFile = path.resolve(baseLogPath, systemLogPath.errorLogDir, systemLogPath.errorLogFile);
+let handFile =path.resolve(baseLogPath, systemLogPath.handleLogDir, systemLogPath.handleLogFile);
+let config = {
+    appenders:
+        {
+            "rule-console": {"type": "console"},
+            "errorLogger": {
+                "type": "dateFile", // 日志类型
+                "filename": errFile, // 输出文件名
+                "pattern": "yyyy-MM-dd.log", // 后缀
+                "alwaysIncludePattern": true, // 上面两个参数是否合并
+                "encoding": "utf-8", // 编码格式
+                "maxLogSize": 1000, // 最大存储内容
+                "numBackups": 3, // 当文件内容超过文件存储空间时，备份文件的数量
+                "path": `/${systemLogPath.errorLogDir}`
+            },
+            "handleLogger": {
+                "type": "dateFile",
+                "filename":  handFile,
+                "pattern": "yyyy-MM-dd.log",
+                "alwaysIncludePattern": true,
+                "encoding": "utf-8",
+                "maxLogSize": 1000,
+                "numBackups": 3,
+                "path": `/${systemLogPath.handleLogDir}`
+            }
+          
+        },
+    categories: {
+        "default": {"appenders": ["rule-console"], "level": "all"}, //这个配置一定要有
+        "errorLogger": {"appenders": ["errorLogger"], "level": "error"},
+        "handleLogger": {"appenders": ["handleLogger"], "level": "all"}
+    },
+    "baseLogPath": path.resolve(baseLogPath, systemLogPath.handleLogDir, systemLogPath.handleLogFile)
+};
+
+log4js.configure(config);  //加载配置文件
+
+//调用预先定义的日志名称
+let errorLogger = log4js.getLogger("errorLogger");
+let handleLogger = log4js.getLogger("handleLogger");
+let consoleLogger = log4js.getLogger("rule-console");
+
+//错误日志
+export function logError(...errStrs) {
+    let str = "";
+    errStrs.forEach(item => {
+        str += item + " |  ";
+    });
+    errorLogger.error(`errorInfo =>   ${str}`);
+}
+
+//普通日志
+export function logHandle(msgStr:string) {
+    handleLogger.info(`logInfo =>    ${msgStr}`);
+}
+
+//输出日志
+export function logConsole(logStr:string) {
+    consoleLogger.info(`logInfo =>   ${logStr}`);
+}

src/util/myXML.ts

+/**
+ * 解析xml
+ */
+
+var xml2js = require("xml2js");
+
+
+/**
+ * 
+ * @param str 需要解析的xml文本
+ * @returns 解析好的对象
+ */
+export function analysisXml(str) {
+    return new Promise( (resolve, reject) => {
+        xml2js.parseString(str, (err, result) => {
+            if (err) return reject(err);
+            return resolve(result);
+        });
+    });
+   
+}
\ No newline at end of file

src/util/piecemeal.ts

+/**
+ * 零碎的通用工具
+ */
+
+import moment = require("moment");
+
+/**
+ * 匹配新旧对象变化
+ * 将newObj 与 oldObj 比对，将newObj中发生变化的key返回
+ * 使用前需要校验对象中的内容
+ * @param newObj 新对象
+ * @param oldObj 旧对象
+ * @returns [key] 发生变化的key
+ */
+export function checkChange(newObj, oldObj) {
+    let changeKeyList = [];
+    for (let newKey in newObj) {
+        if (`${newObj[newKey]}` != `${oldObj[newKey]}`) changeKeyList.push(newKey);
+    }
+    return changeKeyList;
+}
+
+/**
+ * 根据conf截取data中的数据
+ * @param conf 
+ * @param data 
+ * @returns 
+ */
+export function extractData(conf, data, isAdmin) {
+    let result = {};
+    for (let key in conf) {
+        let confInfo = conf[key];
+        if (confInfo.changeDate) {
+            if (isAdmin) result[key] = data[key] ? moment(data[key]).format("YYYY-MM-DD") : '-';
+            else result[key] = data[key] || 0;
+        } else if (confInfo.isAdd && isAdmin) {
+            let addStr = "";
+            data[key].forEach(str => {
+                addStr += str;
+            });
+            result[key] = addStr;
+        }
+        else {
+            result[key] = data[key];
+            if (typeof result[key] == 'string' && !result[key]) result[key] = '';
+        }
+    }
+    return result;
+}
+
+
+/**
+ * 校验数据对象是否有空
+ * @param data 
+ * @param sensitive  敏感校验  true时  0 和 ""会校验失败  false时 校验成功
+ * @returns true/false true = 有空值   false=无空值
+ */
+export function checkDataHaveNull(data:object, sensitive:boolean) {
+    if (Array.isArray(data)) return data.length == 0;
+    if (Object.keys(data).length == 0) return true;
+    
+    let success = false;
+    for (let key in data) {
+        if (data[key] == null || data[key] == undefined) success = true;
+        if (sensitive) {
+            if (data[key] === 0 || data[key] === "" ) success = true;
+        }
+    }
+    return success;
+}
\ No newline at end of file

src/util/request.ts

+/**
+ * 请求工具
+ */
+
+import * as request from 'request';
+import { BizError } from './bizError';
+
+/**
+ * 请求接口（get）
+ * @param url 路由
+ * @param query 请求参数
+ * @param headers 请求头
+ * @returns 
+ */
+export function get(url:string, query?, headers?) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    return new Promise((resolve, reject)=>{
+        let paramater:any = { url, json:true };
+        if (query) paramater.qs = query;
+        if (headers) paramater.headers = headers;
+        request.get(paramater, function (err, r, body) {
+            if (err) return reject(err);
+            if (r && r.statusCode != 200) return reject(new Error('httpError:'+r.statusCode));
+            resolve(body);
+        });
+    })
+}
+
+
+export function post(url, body, headers) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    let header = {"content-type": "application/json"};  
+    return new Promise((resolve, reject)=>{
+        request({
+            url: url,
+            method: "POST",
+            json: true,
+            headers: Object.assign(header, headers),
+            body: body
+        }, function(error, response, resBody) {
+            if (!error && response.statusCode == 200) {
+                resolve(resBody);
+            }
+            else {
+                // reject(error)
+            }
+        });
+    })
+}
+
+export function postForm(url, body, headers) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    return new Promise((resolve, reject)=>{
+        request({
+            url: url,
+            method: "POST",
+            json: true,
+            form:body
+        }, function(error, response, res) {
+            if (!error) {
+                resolve(res);
+            }
+            else {
+                reject(error)
+            }
+        });
+    })
+}
+
+export function cozePost(url, body, headers) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    let header = {"content-type": "application/json"};  
+    return new Promise((resolve, reject)=>{
+        request({
+            url: url,
+            method: "POST",
+            json: true,
+            headers: Object.assign(header, headers),
+            body: body
+        }, function(error, response, resBody) {
+            if (!error) {
+                resolve(resBody);
+            }
+            else {
+                resolve(error);
+            }
+        });
+    })
+}
+
+
+export function cozeGet(url:string, query?, headers?) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    return new Promise((resolve, reject)=>{
+        let paramater:any = { url, json:true };
+        if (query) paramater.qs = query;
+        if (headers) paramater.headers = headers;
+        request.get(paramater, function (err, r, body) {
+            if (!err) {
+                resolve(body);
+            }
+            else {
+                resolve(err);
+            }
+        });
+    })
+}

src/util/verificationEnum.ts

+/**
+ * 校验枚举工具
+ * 
+ */
+
+import { ERRORENUM } from "../config/errorEnum";
+import { BizError } from "./bizError";
+
+
+/**
+ * 校验value是否符合传入的枚举
+ * @param name 被掉用名称 用于输出异常日志
+ * @param key 目标字段  用于输出异常日志
+ * @param enumConf 目标枚举
+ * @param value 目标值
+ * 无返回 有异常直接报错
+ */
+export function eccEnumValue(name:string, key:string, enumConf, value:any) {
+    let eccSuccess = true;
+    if ( typeof value == 'number' ) {
+        if (!enumConf[value] ) eccSuccess = false;
+    } else if (Array.isArray(value)) {
+        value.forEach(item => {
+            if ( !enumConf[item] ) eccSuccess = false;
+        });
+    }
+    
+    if (!eccSuccess) throw new BizError(ERRORENUM.请完善信息, `${name} 下的 ${key} 字段值为 ${value} 不满足枚举范围`);
+}
+
+
+/**
+ * 将枚举值转换成对应的枚举名(key)
+ * @param enumConf 目标枚举
+ * @param value 目标值
+ * @returns string  返回字符串 如果传入多个枚举值，就拼接字符串
+ */
+export function changeEnumValue(enumConf, value:any) {
+    if (!value) return '';
+    if ( typeof value == 'number' ) {
+        let str = enumConf[value];
+        /** 特化处理 中文引号在枚举中不适用*/
+        if (str == "_投资__孵化_类型") {
+            str = str.replace("__","+");
+            str = str.replace("_","“");
+            str = str.replace("_","”");
+        }
+        if (str == "经营成本过高_场地成本或人员成本_" || str == "办公空间拓展_无合适办公空间_") {
+            str = str.replace("_","(");
+            str = str.replace("_",")");
+        }
+        if (str == "迁出孵化器_仍在张江" || str == "迁出张江_仍在浦东" || str == "迁出浦东_仍在上海") {
+            str = str.replace("_",",");
+        }
+        if (str == "科技金融_风险投资_" || str == "科技金融_其他_" || str == "技术专家_法律专家_") {
+            str = str.replace("_","(");
+            str = str.replace("_",")");
+        }
+        return str
+    }
+    let str = "";
+    value.forEach((item, index) => {
+        let subStr = enumConf[item];
+        /** 特化处理 中文引号在枚举中不适用*/
+        if (subStr == "_投资__孵化_类型") {
+            subStr = subStr.replace("__","+");
+            subStr = subStr.replace("_","“");
+            subStr = subStr.replace("_","”");
+        }
+        if (subStr == "经营成本过高_场地成本或人员成本_" || subStr == "办公空间拓展_无合适办公空间_") {
+            subStr = subStr.replace("_","(");
+            subStr = subStr.replace("_",")");
+        }
+        if (subStr == "迁出孵化器_仍在张江" || subStr == "迁出张江_仍在浦东" || subStr == "迁出浦东_仍在上海") {
+            subStr = subStr.replace("_",",");
+        }
+        if (subStr == "科技金融_风险投资_" || subStr == "科技金融_其他_" || subStr == "技术专家_法律专家_") {
+            subStr = subStr.replace("_","(");
+            subStr = subStr.replace("_",")");
+        }
+        str += subStr;
+        if (index == value.length-1) str+="";
+        else str += ","
+    });
+
+    return str;
+}
+
+
+export function changeEnumManyValue(enumConf, value:any) {
+    let list = [];
+    value.forEach((item, index) => {
+        let subStr = enumConf[item];
+        /** 特化处理 中文引号在枚举中不适用*/
+        if (subStr == "_投资__孵化_类型") {
+            subStr = subStr.replace("__","+");
+            subStr = subStr.replace("_","“");
+            subStr = subStr.replace("_","”");
+        }
+        if (subStr == "经营成本过高_场地成本或人员成本_" || subStr == "办公空间拓展_无合适办公空间_") {
+            subStr = subStr.replace("_","(");
+            subStr = subStr.replace("_",")");
+        }
+        if (subStr == "迁出孵化器_仍在张江" || subStr == "迁出张江_仍在浦东" || subStr == "迁出浦东_仍在上海") {
+            subStr = subStr.replace("_",",");
+        }
+        if (subStr == "科技金融_风险投资_" || subStr == "科技金融_其他_" || subStr == "技术专家_法律专家_") {
+            subStr = subStr.replace("_","(");
+            subStr = subStr.replace("_",")");
+        }
+        list.push(subStr);
+    });
+
+    return list;
+}
\ No newline at end of file

src/util/verificationParam.ts

+/**
+ * 校验参数工具
+ * 
+ */
+
+import { ERRORENUM } from "../config/errorEnum";
+import { BizError } from "./bizError";
+
+/**
+ * 通过config校验表单参数param
+ * 包括类型 String, Number, Boolean, [Number], [Object]
+ * 参数是必填
+ * 方法会校验表单中存在的多余字段
+ * @param name 被调用的方法名
+ * @param config 校验配置
+ * @param param 需要校验的参数
+ * @returns true 无需关注返回
+ */
+export function eccFormParam(name:string, keyTypeConf:object, param:object) {
+    /**校验多余字段 */
+    for (let key in param) {
+        if (!keyTypeConf[key]) throw new BizError(ERRORENUM.参数错误, name, `多余${key}字段`);
+    }
+
+    /**校验已填参数 */
+    for (let key in keyTypeConf ) {
+        let {type, notMustHave} = keyTypeConf[key];
+
+        let isError = false; //校验是否异常
+        let errorStr = "";//异常说明
+
+        let value = param[key];
+        let valueType = typeof value;
+        
+        if ( value == null || value == undefined ) {
+            if (!notMustHave) throw new BizError(ERRORENUM.参数错误, name, `缺失${key}字段`);
+        } else {
+            switch(type) {
+                case 'Number':
+                    if ( type.toLowerCase() != valueType )  {
+                        isError = true;
+                    } else {
+                        if ((""+param[key]).indexOf('.') > -1) {
+                            param[key] = parseInt(`${param[key] *1000}`)/1000;
+                        }
+                    }
+                break;
+                case 'String':
+                case 'Boolean':
+                    if ( type.toLowerCase() != valueType ) isError = true;
+                break;
+                case '[Number]':
+                    if ( !Array.isArray(param[key]) ) isError = true;
+                    for (let i =0; i <  param[key].length; i++) {
+                        let item = param[key][i];
+                        if ( typeof item != 'number' ) {
+                            isError = true;
+                            errorStr = `${key}应是number型数组其中下标${i}是${typeof item}`;
+                        }
+                    }
+                break;
+                case '[Object]':
+                    if ( !Array.isArray(param[key]) ) isError = true;
+                    for (let i =0; i <  param[key].length; i++) {
+                        let item = param[key][i];
+                        if ( typeof item != 'object' ) {
+                            isError = true;
+                            errorStr = `${key}应是object型数组其中下标${i}是${typeof item}`;
+                        }
+                    }
+                break;
+                case 'Address':
+                    /**地址类型 基本数据类型为数组字符串但是要判断层级关系 */
+                    if ( !Array.isArray(param[key]) ) {
+                        isError = true;
+                        errorStr = `${key}应是数组形`;
+                    }
+                    if ( param[key].length != 4) {
+                        isError = true;
+                        errorStr = `${key}超过特定长度4 目前长度 ${param[key].length}`;
+                    }
+                    for (let i =0; i <  param[key].length; i++) {
+                        let item = param[key][i];
+                        if ( typeof item != 'string' ) {
+                            isError = true;
+                            errorStr = `${key}应是string型数组其中下标${i}是${typeof item}`;
+                        }
+                    }
+                    /** 不符合规则的 */
+                    let nullIndex = -1;
+                    for (let i = 0; i < param[key].length; i++) {
+                        if (nullIndex != -1) {//出现过空 第一次出现后的位置 都不能有值
+                            if (param[key]) {
+                                //做一个特化
+                                throw new BizError(ERRORENUM.地址数据不完整, name, `${key} 下标 ${nullIndex} 为空 `);
+                            }
+                        }
+                        if (nullIndex == -1 && !param[key][i]) {
+                            /**按顺序第一次赋值 */
+                            nullIndex = i;
+                        }
+                    }
+    
+                break;
+            }
+            errorStr = isError && errorStr == "" ? `${key}应该是${type}型 而不是${valueType}`: errorStr;
+            if ( isError ) throw new BizError(ERRORENUM.请完善信息, name, errorStr);
+        }
+
+       
+    }
+    return true;
+}
+
+
+/**
+ * 根据conf配置校验请求参数
+ * @param conf 配置  
+ * @param param 表单  
+ * @param skipKeys []不必填的字段
+ */
+export function eccReqParamater(conf:object, param, skipKeys?) {
+    skipKeys = skipKeys || [];
+
+    let skipMap = {};
+    skipKeys.forEach(keyName => {
+        skipMap[keyName] = 1;
+    });
+
+    /**校验多余字段 */
+    for (let key in param) {
+        if (!conf[key]) throw new BizError(ERRORENUM.参数错误, `多余${key}字段`);
+    }
+
+    /**校验必填和缺失字段 */
+    for (let key in conf) {
+        let confType = conf[key];
+        let value = param[key];
+        let valueType = typeof value;
+        
+        if ( value == null || value == undefined ) {
+            if (!skipMap[key]) throw new BizError(ERRORENUM.参数错误, `缺失${key}字段`);
+        } else {
+            let isError = false;
+            let errorStr = "";
+            switch(confType) {
+                case 'Number':
+                    if ( confType.toLowerCase() != valueType ) isError = true;
+                    else {
+                        if ((""+param[key]).indexOf('.') > -1) {
+                            param[key] = parseInt(`${param[key] *100}`)/100;
+                        }
+                    }
+                break;
+                case 'String':
+                case 'Boolean':
+                    if ( confType.toLowerCase() != valueType ) isError = true;
+                break;
+                case '[Number]':
+                    if ( !Array.isArray(param[key]) ) isError = true;
+                    for (let i =0; i <  param[key].length; i++) {
+                        let item = param[key][i];
+                        if ( typeof item != 'number' ) {
+                            isError = true;
+                            errorStr = `${key}应是number型数组其中下标${i}是${typeof item}`;
+                        }
+                    }
+                break;
+                case '[Object]':
+                    if ( !Array.isArray(param[key]) ) isError = true;
+                    for (let i =0; i <  param[key].length; i++) {
+                        let item = param[key][i];
+                        if ( typeof item != 'object' ) {
+                            isError = true;
+                            errorStr = `${key}应是object型数组其中下标${i}是${typeof item}`;
+                        }
+                    }
+                break;
+                case 'Address':
+                    /**地址类型 基本数据类型为数组字符串但是要判断层级关系 */
+                    if ( !Array.isArray(param[key]) ) {
+                        isError = true;
+                        errorStr = `${key}应是数组形`;
+                    }
+                    if ( param[key].length != 4) {
+                        isError = true;
+                        errorStr = `${key}超过特定长度4 目前长度 ${param[key].length}`;
+                    }
+                    for (let i =0; i <  param[key].length; i++) {
+                        let item = param[key][i];
+                        if ( typeof item != 'string' ) {
+                            isError = true;
+                            errorStr = `${key}应是string型数组其中下标${i}是${typeof item}`;
+                        }
+                    }
+                    /** 不符合规则的 */
+                    let nullIndex = -1;
+                    for (let i = 0; i < param[key].length; i++) {
+                        if (nullIndex != -1) {//出现过空 第一次出现后的位置 都不能有值
+                            if (param[key]) {
+                                //做一个特化
+                                throw new BizError(ERRORENUM.地址数据不完整, `${key} 下标 ${nullIndex} 为空 `);
+                            }
+                        }
+                        if (nullIndex == -1 && !param[key][i]) {
+                            /**按顺序第一次赋值 */
+                            nullIndex = i;
+                        }
+                    }
+    
+                break;
+            }
+            errorStr = isError && errorStr == "" ? `${key}应该是${confType}型 而不是${valueType}`: errorStr;
+            if (isError) throw new BizError(ERRORENUM.参数错误, errorStr);
+        }
+
+    }
+
+    return param;
+}
\ No newline at end of file