no message

.gitignore

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

.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",
+    "node-xlsx": "^0.16.1",
+    "nodemailer": "^6.1.1",
+    "qs": "^6.11.0",
+    "request": "^2.88.0",
+    "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>40003</port>
+    <db>
+        <url>http://192.168.0.71:40002</url>
+        <sign>xxx90909082fsdahfjosadjfpoiwausjorip2hjklrhn1ioud0u124rx0qwejfokasjfolksaujfoas</sign>
+    </db>
+    <imgUrl>http://123.207.147.179:40003/</imgUrl>
+</config>
+ 
\ No newline at end of file

src/biz/abi/organizationalLife.ts

+/**
+ * ABI_智慧党建管理分析平台
+ * 组织生活
+ */
+
+//  import * as organizationalLifeData from "../../data/organizationalLife";
+ import * as configEnum from "../../config/enum";
+ 
+ /**
+  * ABI 组织生活
+  * @returns {activityCount:"活动开展次数", dataList:"组织生活扇形图"}
+  */
+ export async function getActivityCount() {
+     
+ }
+ 
+ 
\ No newline at end of file

src/biz/base.ts

+/**
+ * 首页基础数据
+ */
+
+import { changeEnumValue, eccEnumValue } from "../util/verificationEnum";
+import * as configEnum from "../config/enum";
+import * as clientConfigEnum from "../config/clientEnum";
+import { ERRORENUM } from "../config/errorEnum";
+import { BizError } from "../util/bizError";
+import { extractData } from "../util/piecemeal";
+import * as splitResultConfig from "../config/splitResultConfig";
+import moment = require("moment");
+import { selectData } from "../middleware/databaseSuccess";
+import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
+
+
+/**
+ * 主页基础数据
+ * @param bId 支部id
+ * @returns {支部名称, 党员总数, 党建质量总数, 党建质量指数, 党内职务人员列表}
+ */
+ export async function homeData(bId) {
+    if (bId && bId.length > 0) eccEnumValue("党建资讯列表查询", "支部名称", configEnum.BRANCHNAME, bId);
+    let branch = changeEnumValue(configEnum.BRANCHNAME, bId); //支部名称
+    // let bId = branchSystemData.getbIdBybId({bId});
+    let partyMemberNum = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党员基础信息表, {bId:{"%like%":bId}}, []); //党员总数
+
+    let param = {bId: {"%like%": bId}};
+    let partyQualityScore = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党建质量, param, ["thirdLevelScore", "currentScore"]);
+    let massIndex = 0;
+    let massSum = 0;
+    partyQualityScore.forEach( score => {
+        massSum += score.thirdLevelScore;
+        massIndex += score.currentScore; 
+    })
+
+    let partyPositions = []; //党内职务人员
+    for (let key in clientConfigEnum.PARTYPOSITIONS) {
+        let anyKey:any = key;
+        if (isNaN(anyKey)) { //枚举key  key = string
+            const EnumValue = parseInt(clientConfigEnum.PARTYPOSITIONS[key])
+            let param = {partyPositionsName:{"%like%":EnumValue}, bId};
+            let dataBaseList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党员基础信息表, param, ["partyPositionsName", "name"]);
+    
+            let nameList = [];
+            dataBaseList.forEach( info => {
+                nameList.push(info.name);
+            });
+
+            if(nameList.length <= 0) nameList.push("暂无数据");
+
+            partyPositions.push({
+                key,
+                list:nameList
+            });
+        }
+    }
+
+    return { branch, partyMemberNum, massSum, massIndex, partyPositions };
+}
+
+
+
+/**
+ * 查询党建资讯列表
+ * @param bId 支部id
+ * @returns dataList:[返回字段参考splitResultConfig文件中的partyInformamtionConfig配置]
+ */
+ export async function activitiesData(bId) {
+    if (bId && bId.length > 0) eccEnumValue("党建资讯列表查询", "支部名称", configEnum.BRANCHNAME, bId);
+
+    let param = {bId:{"%like%":bId}};
+    let partyInformationInfo = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.专题活动表, param, ["theme", "dataMonth"]);
+    if(!partyInformationInfo) throw new BizError(ERRORENUM.未找到数据, `库中不存在支部为${bId}的党建资讯列表`);
+
+    let dataList = [];
+    partyInformationInfo.forEach( info => {
+        let changeData:any = extractData(splitResultConfig.partyInformationConfig, info, true);
+        changeData.dataMonth = moment(info.dataMonth).format("YYYY-MM-DD");
+        dataList.push(changeData);
+    })
+
+    return dataList;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/biz/branchSystem.ts

+/**
+ * 支部制度
+ */
+
+import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
+import { ERRORENUM } from "../config/errorEnum";
+import { selectData } from "../middleware/databaseSuccess";
+import { BizError } from "../util/bizError";
+
+
+/**
+ * 支部制度列表
+ * @param bId 支部id
+ * @param systemTitle 制度主题 可模糊查询 
+ * @returns 
+ */
+export async function branchSystemList(bId, systemTitle) {
+    let param = {bId:{"%like%":bId}};
+    if(systemTitle) param["systemTitle"] = {"%like%": systemTitle};
+
+    let branchSystemData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.支部制度表, param, ["bsId", "systemTitle"]);
+    if(!branchSystemData) throw new BizError(ERRORENUM.未找到数据, `库中不存在支部为${bId}的支部制度列表`);
+
+    return branchSystemData;
+}
+
+
+/**
+ * 制度细则
+ * @param bsId 支部制度id 
+ * @returns 
+ */
+export async function branchSystemDetsils(bsId) {
+    let clomun = ["systemTitle", "fileName"];
+    let branchSystemData = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.支部制度表, {bsId}, clomun);
+    if(!branchSystemData) throw new BizError(ERRORENUM.未找到数据, `库中不存在制度id为${bsId}的支部制度细则`);
+    branchSystemData["fileName"] = JSON.parse(branchSystemData.fileName);
+
+    return branchSystemData;
+
+}
+
+
+

src/biz/memberLearning.ts

+/**
+ * 党员学习 memberLearning
+ * 学习进度 rateLearning
+ * 学习排行 learningPower
+ */
+
+import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
+import { selectData } from "../middleware/databaseSuccess";
+import moment = require("moment");
+import * as splitResultConfig from "../config/splitResultConfig";
+import * as verificationEnumTools from "../util/verificationEnum";
+import * as configEnum from "../config/enum";
+import { extractData } from "../util/piecemeal";
+
+
+/**
+ * 获取党员课程学习列表
+ * @param pmId 登录的党员id
+ * @param courseEntryType 学习类型 视频/文字
+ * @param courseTypeName 课程类型
+ * @param contentTitle 课程标题
+ * @returns 
+ */
+export async function memberLearningList(pmId, courseEntryType, courseTypeName, contentTitle) {
+    let rateLearningData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.学习进度表, {pmId}, ["mlId", "rateOfLearning", "learningCompleted"]);
+
+    let memberLearningList = [];
+    for (let i = 0; i < rateLearningData.length; i++) {
+        let rateLearning = rateLearningData[i];
+        let {mlId, rateOfLearning, learningCompleted} = rateLearning;
+        let param = {
+            mlId,
+            isUse: 1,
+            courseEntryType
+        };
+        if(courseTypeName) param["courseTypeName"] = courseTypeName;
+        if(contentTitle) param["contentTitle"] = {"%like%": contentTitle};
+
+        let clomun = ["contentTitle", "fileName"];
+        
+        let memberLearningData = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.党员学习表, param, clomun); 
+        if (!memberLearningData) continue;
+        memberLearningData.rateOfLearning = rateOfLearning;
+        memberLearningData.learningCompleted = learningCompleted;
+        memberLearningData.fileName = JSON.parse(memberLearningData.fileName);
+        
+        memberLearningList.push(memberLearningData);
+    }
+
+    return memberLearningList;
+}
+
+
+/**
+ * 本月学习排行
+ * 展示数据最新月份的每日积分总和
+ * @param bId 支部id
+ * @returns 
+ */
+ export async function branchRanking(bId) {
+    let orderParam = {"%orderDesc%": "dataTime", "%limit%": 1};
+    let monthData = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.学习强国, orderParam, ["dataTime"]);
+
+    let param = {
+        bId: {"%like%": bId}
+    }
+
+    let stTime = moment(monthData.dataTime).startOf("month").format("YYYY-MM-DD HH:mm:ss");
+    let etTime = moment(monthData.dataTime).endOf('month').format("YYYY-MM-DD HH:mm:ss");
+    if (monthData.dataTime) param["dataTime"] = {"%between%": [stTime, etTime]} //`DATE_FORMAT(dataMonth, '%Y-%m') = DATE_FORMAT(${dataMonth}, '%Y-%m')`;
+
+    let clomun = ["pmId", "partyMemberName", "bId", "dayIntegral", "dataTime"]
+    
+    let learningPowerData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.学习强国, param, clomun);
+
+    let partyMemberNameData = {};
+    learningPowerData.forEach( info => {
+        let {pmId, partyMemberName, bId, dayIntegral, dataTime} = info;
+        if (!partyMemberNameData[partyMemberName]) partyMemberNameData[partyMemberName] = [];
+        dataTime = moment(dataTime).format("YYYY-MM")
+        partyMemberNameData[partyMemberName].push({pmId, bId, dayIntegral, dataTime});
+    })
+
+    let learningPowerList = [];
+    for (let key in partyMemberNameData) {
+        let partyMemberDayData = partyMemberNameData[key];
+        let dayIntegralData = {pmId:"", name: key, bId:0, dayIntegral:0, dataTime:""};
+        partyMemberDayData.forEach( info => {
+            let {pmId, bId, dayIntegral, dataTime} = info;
+            dayIntegralData.pmId = pmId;
+            dayIntegralData.bId = bId;
+            dayIntegralData.dayIntegral += dayIntegral;
+            dayIntegralData.dataTime = dataTime;
+        })
+
+        let changeData:any = extractData(splitResultConfig.learningPowerConfig, dayIntegralData, false);
+        changeData.bId = verificationEnumTools.changeEnumValue(configEnum.BRANCHNAME, dayIntegralData.bId);
+        changeData.dataTime = moment(dayIntegralData.dataTime).format("YYYY-MM");
+        learningPowerList.push(changeData);
+    }
+
+    learningPowerList.sort( (a, b) => {
+        return b.dayIntegral - a.dayIntegral;
+    });
+
+    for ( let i = 0; i < learningPowerList.length; i++) {
+        learningPowerList[i]["ranking"] = i + 1;
+    }
+
+    return learningPowerList;
+}
+
+
+
+/**
+ * 本月学习排行
+ * 展示数据最新月份的每日积分总和
+ * @param bId 支部id
+ * @returns 
+ */
+export async function monthRanking() {
+    let orderParam = {"%orderDesc%": "dataTime", "%limit%": 1};
+    let monthData = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.学习强国, orderParam, ["dataTime"]);
+
+    let param = {}
+
+    let stTime = moment(monthData.dataTime).startOf("month").format("YYYY-MM-DD HH:mm:ss");
+    let etTime = moment(monthData.dataTime).endOf('month').format("YYYY-MM-DD HH:mm:ss");
+    if (monthData.dataTime) param["dataTime"] = {"%between%": [stTime, etTime]} //`DATE_FORMAT(dataMonth, '%Y-%m') = DATE_FORMAT(${dataMonth}, '%Y-%m')`;
+
+    let clomun = ["pmId", "partyMemberName", "bId", "dayIntegral", "dataTime"]
+    
+    let learningPowerData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.学习强国, param, clomun);
+
+    let partyMemberNameData = {};
+    learningPowerData.forEach( info => {
+        let {pmId, partyMemberName, bId, dayIntegral, dataTime} = info;
+        if (!partyMemberNameData[partyMemberName]) partyMemberNameData[partyMemberName] = [];
+        dataTime = moment(dataTime).format("YYYY-MM")
+        partyMemberNameData[partyMemberName].push({pmId, bId, dayIntegral, dataTime});
+    })
+
+    let learningPowerList = [];
+    for (let key in partyMemberNameData) {
+        let partyMemberDayData = partyMemberNameData[key];
+        let dayIntegralData = {pmId:"", name: key, bId:0, dayIntegral:0, dataTime:""};
+        partyMemberDayData.forEach( info => {
+            let {pmId, bId, dayIntegral, dataTime} = info;
+            dayIntegralData.pmId = pmId;
+            dayIntegralData.bId = bId;
+            dayIntegralData.dayIntegral += dayIntegral;
+            dayIntegralData.dataTime = dataTime;
+        })
+
+        let changeData:any = extractData(splitResultConfig.learningPowerConfig, dayIntegralData, false);
+        changeData.bId = verificationEnumTools.changeEnumValue(configEnum.BRANCHNAME, dayIntegralData.bId);
+        changeData.dataTime = moment(dayIntegralData.dataTime).format("YYYY-MM");
+        learningPowerList.push(changeData);
+    }
+
+    learningPowerList.sort( (a, b) => {
+        return b.dayIntegral - a.dayIntegral;
+    });
+
+    for ( let i = 0; i < learningPowerList.length; i++) {
+        learningPowerList[i]["ranking"] = i + 1;
+    }
+
+    return learningPowerList;
+}
+
+
+
+
+
+
+
+
+
+
+
+

src/biz/organizationalLife.ts

+/**
+ * 组织生活
+ */
+
+import moment = require("moment");
+import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
+import { ERRORENUM } from "../config/errorEnum";
+import { selectData } from "../middleware/databaseSuccess";
+import { BizError } from "../util/bizError";
+import { extractData } from "../util/piecemeal";
+import * as splitResultConfig from "../config/splitResultConfig";
+import * as verificationEnumTools from "../util/verificationEnum";
+import * as configEnum from "../config/enum";
+
+
+/**
+ * 获取组织生活列表
+ * @param bId 支部id
+ * @param theme 活动名称 模糊查询
+ * @param themeType 活动类型
+ * @param dataMonth 活动月份
+ * @returns 
+ */
+export async function organlzationalLifeList(bId, theme, themeType, dataMonth) {
+    let param = {
+        bId: {"%like%": bId}
+    }
+    if (theme) param["theme"] = {"%like%": theme};
+    if (themeType) param["themeType"] = themeType;
+    let stTime = moment(dataMonth).startOf("month").format("YYYY-MM-DD HH:mm:ss");
+    let etTime = moment(dataMonth).endOf('month').format("YYYY-MM-DD HH:mm:ss");
+    if (dataMonth) param["dataMonth"] = {"%between%": [stTime, etTime]} //`DATE_FORMAT(dataMonth, '%Y-%m') = DATE_FORMAT(${dataMonth}, '%Y-%m')`;
+
+    let clomun = ["oId", "theme", "themeType", "dataMonth"]
+    
+    let organizationalLifeData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.组织生活表, param, clomun);
+
+    let organlzationalLifeList = [];
+    organizationalLifeData.forEach( info => {
+        let changeData:any = extractData(splitResultConfig.organlzationalLifeConfig, info, false);
+        changeData.themeType = verificationEnumTools.changeEnumValue(configEnum.THEMETYPE, info.themeType);
+        changeData.dataMonth = moment(info.dataMonth).format("YYYY-MM-DD");
+        organlzationalLifeList.push(changeData);
+    })
+
+    return organlzationalLifeList;
+}
+
+
+/**
+ * 获取组织生活详情
+ * @param oId 组织生活id
+ * @returns 
+ */
+export async function organlzationalLifeListDetsils(oId) {
+    let clomun = ["oId", "theme", "themeType", "dataMonth", "fileName"];
+    let organizationalLifeData = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.组织生活表, {oId}, clomun);
+    if(!organizationalLifeData) throw new BizError(ERRORENUM.未找到数据, `库中找不到id为${oId}的组织生活详情`);
+
+    organizationalLifeData.themeType = verificationEnumTools.changeEnumValue(configEnum.THEMETYPE, organizationalLifeData.themeType);
+    organizationalLifeData.dataMonth = moment(organizationalLifeData.dataMonth).format("YYYY-MM-DD");
+    organizationalLifeData.fileName = JSON.parse(organizationalLifeData.fileName);
+    
+    return organizationalLifeData;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/biz/partyBuildingDynamic.ts

+/**
+ * 党建动态 partyBuildingDynamic
+ */
+
+import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
+import { selectData } from "../middleware/databaseSuccess";
+import { extractData } from "../util/piecemeal";
+import * as splitResultConfig from "../config/splitResultConfig";
+import * as configEnum from "../config/enum";
+import * as verificationEnumTools from "../util/verificationEnum";
+import moment = require("moment");
+
+/**
+ * 获取党建动态列表
+ * @param bId 
+ * @param honorName 
+ * @returns 
+ */
+export async function partyBuildingDynamicList(bId, theme, activityYear, activityMonth) {
+    let month = activityYear + "-" + activityMonth;
+    let stTime = moment(month).startOf("month").format("YYYY-MM-DD HH:mm:ss");
+    let etTime = moment(month).endOf('month').format("YYYY-MM-DD HH:mm:ss");
+
+    let param = {
+        bId: {"%like%": bId},
+        dataMonth: {"%between%": [stTime, etTime]}
+    }
+    if(theme) param["theme"] = {"%like%":theme};
+    let clomun = ["pbId", "theme", "dataMonth"];
+    
+    let partyBuildingDynamic = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党建动态表, param, clomun);
+    
+    let partyBuildingDynamicList = [];
+    partyBuildingDynamic.forEach( async info => {
+        let changeData:any = extractData(splitResultConfig.partyBuildingDynamicConfig, info, false);
+        changeData.dataMonth = moment(info.dataMonth).format("YYYY-MM-DD");
+
+        partyBuildingDynamicList.push(changeData);
+    });
+
+    return partyBuildingDynamicList;
+}
+
+
+/**
+ * 获取党建动态详情
+ * @param pbId 
+ * @returns 
+ */
+export async function partyBuildingDynamicDetsils(pbId) {
+    let param = {pbId};
+    let clomun = ["theme", "dataMonth", "fileName"];
+
+    let partyBuildingDynamic = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.党建动态表, param, clomun);
+
+    partyBuildingDynamic.dataMonth = moment(partyBuildingDynamic.dataMonth).format("YYYY-MM-DD");
+    partyBuildingDynamic.fileName = JSON.parse(partyBuildingDynamic.fileName);
+
+    return partyBuildingDynamic;
+}
+ 
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+

src/biz/partyExpenses.ts

+/**
+ * 党费管理
+ */
+
+import * as verificationEnumTools from "../util/verificationEnum";
+import * as configEnum from "../config/enum";
+import { extractData } from "../util/piecemeal";
+import * as splitResultConfig from "../config/splitResultConfig";
+import { selectData } from "../middleware/databaseSuccess";
+import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
+import * as clientEnum from "../config/clientEnum";
+import moment = require("moment");
+moment.suppressDeprecationWarnings = true;
+
+
+/**
+ * 获取党费管理数据
+ * @param bId 支部id
+ * @param name 党员名称
+ * @param payType 缴纳状态
+ * @param payableYear 缴纳时间-年份
+ * @param payableMonth 缴纳时间-月份
+ * @returns 
+ */
+ export async function partyExpensesData(bId, name, payType, payableYear, payableMonth) {
+    let month = payableYear + "-" + payableMonth;
+    let stTime = moment(month).startOf("month").format("YYYY-MM-DD HH:mm:ss");
+    let etTime = moment(month).endOf('month').format("YYYY-MM-DD HH:mm:ss");
+
+    let param = {
+        bId: {"%like%": bId},
+        payableMonth: {"%between%": [stTime, etTime]}
+    }
+    if(payType) param["payType"] = payType;
+    let clomun = ["peId", "pmId", "payType", "payTime"];
+    let partyExpensesData = await selectData(OPERATIONALDATATYPE.查询多个 , TABLENAME.党费管理表, param, clomun);
+
+    let baseData = {partyCount:0, paid:0, unpaid:0};
+    let paid = 0;
+    let unpaid = 0;
+
+    let partyExpensesList = [];
+    for (let i = 0; i < partyExpensesData.length; i++ ) {
+        let partyExpensesInfo = partyExpensesData[i];
+
+        if (partyExpensesInfo.payType == 1) paid ++;
+        if (partyExpensesInfo.payType == 2) unpaid ++;
+
+        let changeData:any = extractData(splitResultConfig.partyExpensesConfig, partyExpensesInfo, false);
+
+        let memberParam = {
+            // etId: 1, //正式党员才需要缴纳党费
+            pmId: partyExpensesInfo.pmId,
+            bId: {"%like%": bId},
+        }
+        if(name) memberParam["name"] = {"%like%": name};
+        let partyMenberData = await selectData(OPERATIONALDATATYPE.查询单个 , TABLENAME.党员基础信息表, memberParam, ["name", "partyPositionsName", "departmentName", "partyJoiningTime"]);
+        if (!partyMenberData) continue;
+        let menberChange:any = extractData(splitResultConfig.expensesMenberConfig, partyMenberData, false);
+
+        changeData.payType = verificationEnumTools.changeEnumValue(configEnum.PAYTYPE, partyExpensesInfo.payType); //缴纳状态
+        if(partyExpensesInfo.payTime) changeData.payTime = moment(partyExpensesInfo.payTime).format("YYYY-MM-DD");
+
+        changeData.name = menberChange.name;
+        changeData.partyPositionsName = verificationEnumTools.changeEnumValue(clientEnum.PARTYPOSITIONSICON, JSON.parse(menberChange.partyPositionsName)); //党内职务
+        changeData.departmentName = verificationEnumTools.changeEnumValue(configEnum.DEDPARTMENT, JSON.parse(menberChange.departmentName)); //所属科室
+
+        let time = moment(new Date()).format("YYYY");
+        let partyJoiningTime = moment(menberChange.partyJoiningTime).format("YYYY");
+        changeData.partyJoiningTime = parseInt(time) - parseInt(partyJoiningTime) + "年"; //党龄
+
+        partyExpensesList.push(changeData);
+    }
+
+    baseData["partyCount"] = partyExpensesData.length; //党员总数
+    baseData["paid"] = paid; //已缴纳
+    baseData["unpaid"] = unpaid; //未缴纳
+
+    return {baseData, partyExpensesList};
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/biz/partyMember.ts

+/**
+ * 党员基础信息
+ */
+
+import * as configEnum from "../config/enum";
+import * as clientEnum from "../config/clientEnum";
+import * as verificationEnumTools from "../util/verificationEnum";
+import { extractData } from "../util/piecemeal";
+import * as splitResultConfig from "../config/splitResultConfig";
+import moment = require("moment");
+import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
+import { selectData } from "../middleware/databaseSuccess";
+
+/**
+ * 获取党员名册
+ * @param branchId 支部id
+ * @returns 返回格式 {nameList:[返回字段参考splitResultConfig文件中的partyMemberConfig配置], partyMemberCount:{目前党员人数}}
+ */
+export async function partyMemberNameList(bId, name) {
+    let branchName = verificationEnumTools.changeEnumValue(configEnum.BRANCHNAME, bId);
+    
+    let partyMemberNum = await selectData(OPERATIONALDATATYPE.查询数据量, TABLENAME.党员基础信息表, {bId:{"%like%":bId}}, []); //党员总数
+    let partyMemberCount = {
+        key: branchName + "目前党员人数",
+        value: partyMemberNum || 0
+    };
+    let param = {bId:{"%like%":bId}}
+    if (name) param["name"] = {"%like%":name};
+    let clomun = ["pmId", "name", "etId", "partyPositionsName", "partyJoiningTime", "departmentName"];
+    let partyMemberList = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党员基础信息表, param, clomun);
+
+    let nameList = [];
+    /**截取返回字段 */
+    partyMemberList.forEach( info => {
+        let changeData:any = extractData(splitResultConfig.partyMemberConfig, info, false);
+        switch (changeData.etId) {
+            case configEnum.ENTRYTYPE.正式党员:
+                changeData.color = "#C62A23";
+                let partyPositions = JSON.parse(info.partyPositionsName);
+                changeData.partyPositionsName = verificationEnumTools.changeEnumValue(clientEnum.PARTYPOSITIONSICON, partyPositions);
+            break;
+            case configEnum.ENTRYTYPE.入党积极分子:
+                changeData.color = "#3549B0";
+                changeData.partyPositionsName = verificationEnumTools.changeEnumValue(configEnum.ENTRYTYPE, info.etId);
+            break;
+            case configEnum.ENTRYTYPE.预备党员:
+                changeData.color = "#E4B386";
+                changeData.partyPositionsName = verificationEnumTools.changeEnumValue(configEnum.ENTRYTYPE, info.etId);
+            break;
+        }
+
+        let time = moment(new Date()).format("YYYY");
+        let partyJoiningTime = time;
+        if (info.partyJoiningTime) partyJoiningTime = moment(info.partyJoiningTime).format("YYYY")
+        changeData.partyStanding = parseInt(time) - parseInt(partyJoiningTime) + "年";
+
+        let departmentName = JSON.parse(changeData.departmentName);
+        changeData.departmentName = verificationEnumTools.changeEnumValue(configEnum.DEDPARTMENT, departmentName);
+
+        nameList.push(changeData);
+    })
+
+    return {nameList, partyMemberCount};
+}
+
+
+/**
+ * 党员详情
+ * @param pmId 党员id
+ * @returns changeData:{返回字段参考splitResultConfig文件中的partyMemberDetailsConfig配置} 根据党员id返回党员详细信息
+ */
+ export async function partyMemberDetails(bId, pmId) {
+    let clomun = ["bId", "pmId", "etId", "name", "sex", "birthDate", "phone", "levelOfEducation", "bId", "partyPositionsName", "partyJoiningTime", "administrativePositionName", 
+    "departmentName", "askForTime", "listedAsActivistsTime", "liaison", "talkTime", "partyState"]
+    let partyMemberList = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.党员基础信息表, {pmId}, clomun);
+    let changeData:any = {};
+    
+    /**截取返回字段 */
+    switch (partyMemberList.etId) {
+        case configEnum.ENTRYTYPE.正式党员:
+            changeData = extractData(splitResultConfig.partyMemberDetailsConfig, partyMemberList, true);
+            changeData.color = "#C62A23";
+            if(partyMemberList.partyPositionsName) changeData.partyPositionsName = verificationEnumTools.changeEnumValue(clientEnum.PARTYPOSITIONSICON, JSON.parse(partyMemberList.partyPositionsName));
+        break;
+        case configEnum.ENTRYTYPE.入党积极分子:
+            changeData = extractData(splitResultConfig.activistDetailsConfig, partyMemberList, true);
+            changeData.color = "#3549B0";
+            changeData.partyPositionsName = verificationEnumTools.changeEnumValue(configEnum.ENTRYTYPE, partyMemberList.etId);
+        break;
+        case configEnum.ENTRYTYPE.预备党员:
+            changeData = extractData(splitResultConfig.prepareDetailsConfig, partyMemberList, true);
+            changeData.color = "#E4B386";
+            changeData.partyPositionsName = verificationEnumTools.changeEnumValue(configEnum.ENTRYTYPE, partyMemberList.etId);
+            changeData.branchName = verificationEnumTools.changeEnumValue(configEnum.BRANCHNAME, partyMemberList.bId);
+        break;
+    }
+    changeData.departmentName = verificationEnumTools.changeEnumValue(configEnum.DEDPARTMENT, JSON.parse(partyMemberList.departmentName));
+    changeData.sex = verificationEnumTools.changeEnumValue(configEnum.SEX, partyMemberList.sex);
+    changeData.administrativePositionName = verificationEnumTools.changeEnumValue(configEnum.ADMINISTRATIVEPOSITION, partyMemberList.administrativePositionName);
+    changeData.partyState = verificationEnumTools.changeEnumValue(configEnum.PARTYSTATE, partyMemberList.partyState);
+    changeData.levelOfEducation = verificationEnumTools.changeEnumValue(configEnum.DEGREE, partyMemberList.levelOfEducation);
+
+    changeData.study = await getStudent(bId, pmId); //学习相关数据
+
+    let time = moment(new Date()).format("YYYY");
+    let partyJoiningTime = time;
+    if (changeData.partyJoiningTime) partyJoiningTime = moment(partyMemberList.partyJoiningTime).format("YYYY")
+    changeData.partyStanding = parseInt(time) - parseInt(partyJoiningTime) + "年";
+    
+    return changeData;
+}
+
+
+/**
+ * 党员学习数据
+ * @param bId 支部
+ * @param pmId 党员
+ * @returns 
+ */
+export async function getStudent(bId, pmId) {
+    let orderParam = {"%orderDesc%": "dataTime", "%limit%": 1};
+    let monthData = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.学习强国, orderParam, ["dataTime"]);
+
+    let param = {
+        bId: {"%like%": bId}
+    }
+
+    let stTime = moment(monthData.dataTime).startOf("month").format("YYYY-MM-DD HH:mm:ss");
+    let etTime = moment(monthData.dataTime).endOf('month').format("YYYY-MM-DD HH:mm:ss");
+    if (monthData.dataTime) param["dataTime"] = {"%between%": [stTime, etTime]} //`DATE_FORMAT(dataMonth, '%Y-%m') = DATE_FORMAT(${dataMonth}, '%Y-%m')`;
+
+    let clomun = ["pmId", "partyMemberName", "bId", "dayIntegral", "dataTime"]
+    
+    let learningPowerData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.学习强国, param, clomun);
+
+    let partyMemberNameData = {};
+    learningPowerData.forEach( info => {
+        let {pmId, partyMemberName, bId, dayIntegral, dataTime} = info;
+        if (!partyMemberNameData[partyMemberName]) partyMemberNameData[partyMemberName] = [];
+        dataTime = moment(dataTime).format("YYYY-MM")
+        partyMemberNameData[partyMemberName].push({pmId, bId, dayIntegral, dataTime});
+    })
+
+    let learningPowerList = [];
+    for (let key in partyMemberNameData) {
+        let partyMemberDayData = partyMemberNameData[key];
+        let dayIntegralData = {pmId:"", name: key, bId:0, dayIntegral:0, dataTime:""};
+        partyMemberDayData.forEach( info => {
+            let {pmId, bId, dayIntegral, dataTime} = info;
+            dayIntegralData.pmId = pmId;
+            dayIntegralData.bId = bId;
+            dayIntegralData.dayIntegral += dayIntegral;
+            dayIntegralData.dataTime = dataTime;
+        })
+
+        let changeData:any = extractData(splitResultConfig.learningPowerConfig, dayIntegralData, false);
+        changeData.bId = verificationEnumTools.changeEnumValue(configEnum.BRANCHNAME, dayIntegralData.bId);
+        changeData.dataTime = moment(dayIntegralData.dataTime).format("YYYY-MM");
+        learningPowerList.push(changeData);
+    }
+
+    learningPowerList.sort( (a, b) => {
+        return b.dayIntegral - a.dayIntegral;
+    });
+
+    for ( let i = 0; i < learningPowerList.length; i++) {
+        learningPowerList[i]["ranking"] = i + 1;
+    }
+    
+    let studentData:any = [{key: "学习排名", value: 0}];
+    learningPowerList.forEach( info => {
+        if (info.pmId == pmId) {
+            studentData[0]["value"] = info.ranking;
+        }
+    })
+
+    let rateLearningData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.学习进度表, {pmId}, ["mlId", "pmId", "rateOfLearning", "learningCompleted"]);
+
+    let memberLearningData = {rateOfLearning:0};
+    for (let i = 0; i < rateLearningData.length; i++) {
+        let rateLearning = rateLearningData[i];
+        let { rateOfLearning } = rateLearning;
+        memberLearningData.rateOfLearning += rateOfLearning;
+    }
+
+    let learningHours = rateLearningData.length || 0;
+    let rateOfLearning = memberLearningData.rateOfLearning / rateLearningData.length || 0;
+    studentData.push(
+        {key:"学习课时", value: learningHours},
+        {key:"学习进度", value: Math.round(rateOfLearning)}
+    );
+
+    return studentData;
+}
+
+
+
+
+

src/biz/partyQuality.ts

+/**
+ * 党建质量指数
+ */
+
+import * as configEnum from "../config/enum";
+import { selectData } from "../middleware/databaseSuccess";
+import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
+import * as verificationEnumTools from "../util/verificationEnum";
+
+
+export async function partyQualityList(bId) {
+    let clomun = ["pqId", "primaryIndicators", "secondaryIndicators", "thirdLevelContent", "thirdLevelScore", "currentScore", "completionProgress"];
+    let partyQualityData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党建质量, {bId:{"%like%": bId}}, clomun);
+    
+    let partyQualityList = [];
+    for (let key in configEnum.PRIMARYINDICATORS) {
+        let primaryIndicatorsData = {};
+        let anyKey:any = key;
+        if (isNaN(anyKey)) {
+            const EnumValue = parseInt(configEnum.PRIMARYINDICATORS[key])
+            primaryIndicatorsData["dataList"] = {key: anyKey, list: []};
+            primaryIndicatorsData["detail"] = {};
+
+            partyQualityData.forEach( info => {
+                let schedule = "进行中";
+                let {pqId, primaryIndicators, secondaryIndicators, thirdLevelContent, thirdLevelScore, currentScore, completionProgress} = info; //一级指标、总分、三级指标得分、完成进度
+                if (completionProgress == 100) schedule = "已完成"
+                if (primaryIndicators == EnumValue) {
+                    primaryIndicatorsData["dataList"]["list"].push({
+                        primaryIndicators,
+                        thirdLevelScore,
+                        currentScore,
+                        completionProgress,
+                        schedule
+                    })
+                    let secondary = verificationEnumTools.changeEnumValue(configEnum.SECONDARYINDICATORS, secondaryIndicators);
+                    if(!primaryIndicatorsData["detail"][secondary]) primaryIndicatorsData["detail"][secondary] = {schedule, dataList: []};
+                    if (thirdLevelScore != currentScore) primaryIndicatorsData["detail"][secondary]["schedule"] = "进行中";
+                    primaryIndicatorsData["detail"][secondary]["dataList"].push({
+                        thirdLevelContent,
+                        thirdLevelScore,
+                    })
+                }
+                
+            })
+            partyQualityList.push(primaryIndicatorsData);
+        }
+    }
+
+    let partyQuality = [];
+    partyQualityList.forEach( item => {
+        let {dataList, detail} = item;
+        let {key, list} = dataList;
+        let count = list.length;
+
+        let changeDataList = {};
+        let changeData:any = {totalScore:0, completionProgress:0, currentScore:0};
+        list.forEach( info => {
+            let {thirdLevelScore, currentScore, completionProgress, schedule} = info;
+            changeData.schedule = schedule;
+            changeData.totalScore += thirdLevelScore;
+            changeData.completionProgress += completionProgress;
+            changeData.currentScore += currentScore;
+        })
+
+        let completion = changeData.completionProgress/count;
+        if (completion == 100) changeData.schedule = "已完成";
+        changeData.completionProgress = Math.round(completion)+ "%"
+
+        changeDataList["key"] = key;
+        changeDataList["list"] = changeData;
+
+        partyQuality.push({dataList:changeDataList, detail});
+
+    })
+
+    return partyQuality;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+

src/biz/partyVanguard.ts

+/**
+ * 党建先锋
+ */
+
+import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
+import { selectData } from "../middleware/databaseSuccess";
+import { extractData } from "../util/piecemeal";
+import * as splitResultConfig from "../config/splitResultConfig";
+import * as configEnum from "../config/enum";
+import * as verificationEnumTools from "../util/verificationEnum";
+import moment = require("moment");
+
+/**
+ * 获取党建先锋列表
+ * @param bId 
+ * @param honorName 
+ * @returns 
+ */
+export async function partyVanguardList(bId, honorName) {
+    let param = {
+        bId: {"%like%":bId},
+        isUse: 1,
+    };
+    if(honorName) param["honorName"] = {"%like%":honorName};
+    let clomun = ["pvId", "honorName", "honorType", "grantingRange", "grantingUnit", "grantTime"];
+    
+    let partyVanguardData = await selectData(OPERATIONALDATATYPE.查询多个, TABLENAME.党建先锋表, param, clomun);
+    
+    let partyVanguardList = [];
+    partyVanguardData.forEach( async info => {
+        let changeData:any = extractData(splitResultConfig.partyVanguardConfig, info, false);
+        changeData.honorType = verificationEnumTools.changeEnumValue(configEnum.HONORTYPE, info.honorType);
+        changeData.grantingRange = verificationEnumTools.changeEnumValue(configEnum.GRANTINGRANGE, info.grantingRange);
+        changeData.grantTime = moment(info.grantTime).format("YYYY-MM-DD");
+
+        partyVanguardList.push(changeData);
+    });
+
+    return partyVanguardList;
+}
+
+
+/**
+ * 获取党建先锋荣誉详情
+ * @param pvId 
+ * @returns 
+ */
+export async function partyVanguardDetsils(pvId) {
+    let param = {pvId};
+    let clomun = ["honorName", "honorType", "grantingRange", "grantingUnit", "grantTime"];
+
+    let partyVanguardData = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.党建先锋表, param, clomun);
+
+    partyVanguardData.honorType = verificationEnumTools.changeEnumValue(configEnum.HONORTYPE, partyVanguardData.honorType);
+    partyVanguardData.grantingRange = verificationEnumTools.changeEnumValue(configEnum.GRANTINGRANGE, partyVanguardData.grantingRange);
+    partyVanguardData.grantTime = moment(partyVanguardData.grantTime).format("YYYY-MM-DD");
+
+    return partyVanguardData;
+}
+

src/biz/user.ts

+/**
+ * 党员入口登录
+ */
+
+import { ERRORENUM } from '../config/errorEnum';
+import { BizError } from '../util/bizError';
+import * as sysTools from "../tools/system";
+import { operationalData, selectData } from '../middleware/databaseSuccess';
+import { OPERATIONALDATATYPE, TABLENAME } from '../config/dbEnum';
+const moment = require("moment");
+
+export async function login(loginId:string, pwd:string) {
+    // let loginInfo:any = await partyMemberData.getPartyMemberByLoginId(loginId, ["pmId", "loginId", "pwd", "token", "bId"]);
+    let clomun = ["pmId", "loginId", "pwd", "token", "bId"];
+    let loginInfo:any = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.党员基础信息表, {loginId}, clomun);
+    if (!loginInfo) throw new BizError(ERRORENUM.账号不存在, `${loginId}账号非党员账号`);
+    
+    // let checkPwd = sysTools.md5PwdStr(pwd);
+    // if (loginInfo.pwd != checkPwd) throw new BizError(ERRORENUM.密码错误);
+    
+    if (loginInfo.pwd != pwd) throw new BizError(ERRORENUM.密码错误);
+
+    const Token = sysTools.getToken(loginId);
+
+    let updateLogin = {
+        token: Token,
+        tokenMs: moment(new Date()).format("YYYY-MM-DD HH:mm:ss")
+    }
+
+    await operationalData(OPERATIONALDATATYPE.修改, TABLENAME.党员基础信息表, updateLogin, {loginId});
+
+    let loginUserInfo = {
+        userid: loginInfo.pmId,
+        token: Token,
+        bId: loginInfo.bId,
+    };
+
+    return loginUserInfo;
+}
+
+
+/**
+ * 修改密码
+ * 未使用
+ * @param uscc 信用代码
+ * @param pwd 原密码  md5之后的
+ * @param newPwd 新密码  未md5
+ * @param confirmPwd 确认新密码  未md5
+ * @returns {isSuccess:true}
+ */
+ export async function changePassword(loginId:string, pwd:string, newPwd:string, confirmPwd:string ) {
+    if (newPwd != confirmPwd) throw new BizError(ERRORENUM.密码不一致);
+    if (newPwd.search(/^[A-Za-z0-9]{6,18}$/) < 0) throw new BizError(ERRORENUM.密码只能由6至18位字符和数字组成);
+
+    let partyMemberInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.党员基础信息表, {loginId}, ["pmId", "loginId", "pwd"]);
+    if (!partyMemberInfo) throw new BizError(ERRORENUM.未找到数据);
+
+    /**由于pwd是md5之后的 所以这里md5一次即可 */
+    let checkPwd = sysTools.getPwdMd5(partyMemberInfo.loginId, pwd);
+    if (partyMemberInfo.pwd != checkPwd) throw new BizError(ERRORENUM.密码错误);
+
+    /**考虑到如果前端把新密码也md5 就不可以验证是不是符合规则 所以前端传的是明文
+     * 我们初始化密码的时候 有两次加密 第一次是密码md5 然后再和loginId 进行md5
+     * 于是这里也要如此操作
+     */
+     partyMemberInfo.pwd = sysTools.getPwdMd5(loginId, sysTools.md5PwdStr(newPwd));
+    await partyMemberInfo.save();
+
+    return {isSuccess:true};
+}
+
+
+
+
+
+

src/config/clientEnum.ts

+/**
+ * 党员基础信息
+ */
+
+/**党内职务icon */
+export enum PARTYPOSITIONSICON {
+    党员 = 1,
+    入党积极分子,
+    预备党员,
+    党总支书记 = 4,
+    党总支副书记,
+    党总支宣传委员,
+    党总支统战委员,
+    党总支纪检委员,
+    支部书记 = 100,
+    支部副书记,
+    纪检委员,
+    统战委员,
+    组织委员,
+    宣传委员,
+}
+
+
+/**
+ * 组织生活活动类型
+ */
+ export enum TYPE {
+    全部活动 = 1,
+    正在进行,
+    即将开展,
+    已经开展,
+}
+
+
+/**
+ * 名册录入类型
+ */
+ export enum ENTRYTYPE {
+    正式党员录入 = 1,
+    入党积极分子录入,
+    入党申请录入
+}
+
+
+
+/**
+ * 党内职务 partyPositions
+ */
+ export enum PARTYPOSITIONS {
+    支部书记 = 100,
+    支部副书记,
+    纪检委员,
+    统战委员,
+    组织委员,
+    宣传委员,
+}
\ No newline at end of file

src/config/dbEnum.ts

+
+/**
+ * 请求数据中心类型
+ */
+export enum OPERATIONALDATATYPE {
+    增加='/yfs/dataserver/mysql/table/add',
+    修改='/yfs/dataserver/mysql/table/update',
+    删除='/yfs/dataserver/mysql/table/delete',
+    查询单个='/yfs/dataserver/mysql/table/find/one',
+    查询多个='/yfs/dataserver/mysql/table/find/many',
+    分页查询='/yfs/dataserver/mysql/table/find/manytopage',
+    查询数据量='/yfs/dataserver/mysql/table/find/count',
+    多表联查='/yfs/dataserver/mysql/table/find/aggragate',
+}
+
+
+export enum TABLENAME {
+    支部表='branch',
+    后台用户表='adminUser',
+    党员基础信息表='partyMember',
+    行政职务表='administrativePosition',
+    党内职务表='partyPositions',
+    所属科室表='department',
+    支部制度表='branchSystem',
+    组织生活表='organizationalLife',
+    专题活动表='thematicActivities',
+    党建动态表='partyBuildingDynamic',
+    党费管理表='partyExpenses',
+    党建先锋表='partyVanguard',
+    党员学习表='memberLearning',
+    学习进度表='rateLearning',
+    课程类型='courseType',
+    学习强国='learningPower',
+    党建质量='partyQuality',
+}
\ No newline at end of file

src/config/eccFormParamConfig.ts

+/**
+ * 校验表单参数配置
+ * 使用场景：  验证客户端请求参数
+ *     限制：  1.使用端不同不能共用一份配置
+ *             2.需要搭配 util/verificationParam -> eccFormParam() 方法使用
+ *     说明:   notMustHave = true 时说明该字段是非必填的;不配该字段说明是必填的
+ */
+
+
+/**
+ * 使用端: 小程序端_党员入口
+ *   场景: 创建组织生活活动表单
+ *   备注: 1.0
+ */
+export const CreateActivityConfig = {
+    partyActivityType:{type:"Number", notMustHave:true},//党建活动类型
+    activityStartTime:{type:"Number", notMustHave:true},//活动开始时间
+    activityEndTime:{type:"Number", notMustHave:true},//活动结束时间
+    activityAdd:{type:"String", notMustHave:true},//活动地点
+    activityHost:{type:"[String]", notMustHave:true},//活动主持人
+    activityNoteTaker:{type:"[String]", notMustHave:true},//活动记录人
+    leavePartyMember:{type:"[String]", notMustHave:true},//请假党员
+    participatingPartyMember:{type:"[String]", notMustHave:true},//参与党员
+    participationRecord:{type:"String", notMustHave:true},//活动记录
+    branchName:{type:"[Number]", notMustHave:true}, //支部名称
+};

src/config/enum.ts

+/**
+ * 文件------------------------
+ */
+
+/**上传文件类型 */
+export enum FILETYPE {
+    word = 1,
+    pdf,
+    图片,
+    视频,
+    多类型,
+    其他
+}
+
+
+/**
+ * 党员基础信息表---------------------------
+ */
+
+/**名册录入类型 */
+export enum ENTRYTYPE {
+    正式党员 = 1,
+    入党积极分子,
+    预备党员
+}
+
+
+/**性别 */
+export enum SEX {
+    男 = 1,
+    女
+}
+
+
+/**文化程度 */
+export enum DEGREE {
+    初中 = 1,
+    高中,
+    大专,
+    本科,
+    硕士,
+    博士
+}
+
+
+/**所属支部 */
+export enum BRANCHNAME {
+    牙防所第一支部 = 1,
+    牙防所第二支部,
+    牙防所第三支部,
+    牙防所第四支部
+}
+
+
+/**行政职务 */
+export enum ADMINISTRATIVEPOSITION {
+    职员 = 1,
+    办公室主任,
+    办公室副主任,
+    财务科副科长,
+    副所长,
+    口腔种植科主任,
+    副主任护师,
+    副主任医师,
+    工会主席,
+    口腔技术室主任 = 10,
+    护理部主任,
+    护师,
+    护士,
+    技师,
+    技士,
+    康健分所主任,
+    口腔颌面外科副主任,
+    口腔修复科副主任,
+    口腔正畸科主任,
+    口腔综合科副主任 = 20,
+    人事科科长,
+    项目管理工程师,
+    牙体牙髓科副主任,
+    牙周科主任,
+    医师,
+    医务科副科长,
+    预防口腔,
+    儿童口腔科主任,
+    执行所长,
+    主管护师 = 30,
+    主管技师,
+    主治医师,
+}
+
+
+/**党内职务 */
+export enum PARTYPOSITIONS {
+    党总支书记 = 4,
+    党总支副书记,
+    党总支宣传委员,
+    党总支统战委员,
+    党总支纪检委员,
+    支部书记 = 100,
+    支部副书记,
+    纪检委员,
+    统战委员,
+    组织委员,
+    宣传委员,
+}
+
+
+/**所属科室 */
+export enum DEDPARTMENT {
+    办公室 = 1,
+    财务科,
+    放射科,
+    工会,
+    技术室,
+    颌面外科,
+    护理,
+    护理部,
+    检验科,
+    康健分所,
+    科教科,
+    口腔颌面外科,
+    口腔科,
+    口腔修复科,
+    口腔正畸科,
+    口腔综合科,
+    人事科,
+    特需,
+    信息科,
+    修复科,
+    牙体牙髓科,
+    牙周科,
+    药房,
+    医务科,
+    预防科,
+    预防口腔,
+    儿童口腔科,
+    院部,
+    种植科,
+    正畸科,
+    综合科,
+}
+
+
+/**党员状态 */
+export enum PARTYSTATE {
+    在党 = 1,
+    退党
+}
+
+
+/**
+ * 组织生活---------------------------
+ */
+
+/**主题类型 */
+export enum THEMETYPE {
+    理论学习 = 1,
+    实践学习
+}
+
+
+/**
+ * 党费管理---------------------------
+ */
+
+/**缴纳状态 */
+export enum PAYTYPE {
+    已缴纳 = 1,
+    未缴纳
+}
+
+
+/**
+ * 党建先锋---------------------------
+ */
+
+/**一级指标 */
+export enum PRIMARYINDICATORS {
+    班子队伍健全 = 1,
+    教育管理党员规范,
+    党员先锋模范作用有力,
+    党风廉政行风建设有效,
+    医院文化建设到位,
+    特色亮点显著,
+
+}
+
+
+/**二级指标 */
+export enum  SECONDARYINDICATORS {
+    "突出政治功能，确保政治站位" = 1.1,
+    "组织架构完备，配强工作力量" = 1.2,
+    "支部制度完善" = 1.3,
+    "“三会一课”、主题党日活动规范落实" = 2.1,
+    "党员发展、党籍管理、党费收缴、使用、管理规范" = 2.2,
+    "教育培训及时到位" = 2.3,
+    "日常亮身份、树形象" = 3.1,
+    "各类先进评选" = 3.2,
+    "参与行业党建、区域化党建" = 3.3,
+    "履行党风廉政建设主体责任和监督责任" = 4.1,
+    "医德医风和行风建设" = 4.2,
+    "医院文化建设" = 5.1,
+    "精神文明建设、统战和群团工作" = 5.2,
+    "培育选树先进典型，打造医疗服务品牌" = 5.3,
+    "常态化了解困难诉求，健全职工意见诉求机制" = 5.4,
+    "开展党建课题研究，刊登发表党建论文" = 6.1,
+    "社会影响大、特别典型" = 6.2,
+    "积极开展党支部品牌创建" = 6.3,
+}
+
+
+/**荣誉类型 */
+export enum HONORTYPE {
+    区级 = 1,
+    市级,
+    院级,
+    国家级,
+}
+
+
+/**授予范围 */
+export enum GRANTINGRANGE {
+    个人 = 1,
+    团体,
+    单位,
+}
+
+
+/**
+ * 党员学习---------------------------
+ */
+
+/**课程类型 */
+export enum COURSETYPE {
+    学习二十大 = 1,
+    党课,
+    四个意识,
+    四个自信,
+}
\ No newline at end of file

src/config/errorEnum.ts

+
+export enum ERRORENUM {
+    未找到数据,
+    账号不存在,
+    密码错误,
+    密码不一致,
+    密码只能由6至18位字符和数字组成,
+    不能重复修改密码,
+    表单校验失败,
+    参数错误,
+    数据无更新,
+    地址数据不完整,
+    身份验证失败,
+    非法登录,
+    非党员账号,
+    参数不符合规则,
+    该方法仅可进行数据操作,
+    数据操作失败,
+    分页请设置当前页数,
+    库中不存在对应数据,
+    暂无对应数据
+}
+
+export enum ERRORCODEENUM {
+    身份验证失败 = 401,
+    非法登录 = 402,
+    身份验证过期 = 403,
+}
+
+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/splitResultConfig.ts

+/**
+ * 拆分返回结果配置
+ * 使用场景：逻辑层中需要返回数据给客户端的地方
+ * 限制：使用端不同不能共用一份配置
+ */
+
+
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:     首页党建资讯列表
+ */
+export const partyInformationConfig = {
+    pId:{key:"pId"},
+    theme:{key:"资讯标题"},
+    branchName:{key:"支部名称"},
+    dataMonth:{key:"资讯时间"}
+};
+
+
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:     党员名称
+ * 备注:     党建名册的党员名册
+ */
+export const partyMemberConfig = {
+    pmId:{key:"pmId"},
+    name:{key:"姓名"},
+    etId:{key:"名册录入类型"},
+    partyPositionsName:{key:"党内职务"},
+    partyStanding:{key: "党龄"},
+    departmentName:{key:"所属科室"},
+    color:{key:"颜色"},
+}
+
+
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:     党员详情
+ */
+ export const partyMemberDetailsConfig = {
+    etId:{key:"名册录入类型"},
+    name:{key:"姓名"},
+    partyPositionsName:{key:"党内职务"},
+    partyStanding:{key: "党龄"},
+    departmentName:{key:"所属科室"},
+    study:{key:"学习情况"},
+    sex:{key:"性别"},
+    birthDate:{key:"出生年月", changeDate:true},
+    phone:{key:"手机号码"},
+    levelOfEducation:{key:"文化程度"},
+    partyJoiningTime:{key:"入党时间", changeDate:true},
+    administrativePositionName:{key:"行政职务"},
+    partyState:{key:"党员状态"},
+    color:{key:"颜色"},
+}
+
+
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:     入党积极分子详情
+ */
+ export const activistDetailsConfig = {
+    etId:{key:"名册录入类型"},
+    name:{key:"姓名"},
+    partyPositionsName:{key:"党内职务"},
+    departmentName:{key:"所属科室"},
+    study:{key:"学习情况"},
+    sex:{key:"性别"},
+    birthDate:{key:"出生年月", changeDate:true},
+    phone:{key:"手机号码"},
+    levelOfEducation:{key:"文化程度"},
+    askForTime:{key:"申请入党时间", changeDate:true},
+    listedAsActivistsTime:{key:"列为积极分子", changeDate:true},
+    liaison:{key:"联系人"},
+    administrativePositionName:{key:"行政职务"},
+    color:{key:"颜色"},
+}
+
+
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:     预备党员详情
+ */
+ export const prepareDetailsConfig = {
+    etId:{key:"名册录入类型"},
+    name:{key:"姓名"},
+    partyPositionsName:{key:"党内职务"},
+    departmentName:{key:"所属科室"},
+    study:{key:"学习情况"},
+    sex:{key:"性别"},
+    birthDate:{key:"出生年月", changeDate:true},
+    phone:{key:"手机号码"},
+    levelOfEducation:{key:"文化程度"},
+    branchName:{key:"所属支部"},
+    askForTime:{key:"申请入党时间", changeDate:true},
+    talkTime:{key:"谈话时间", changeDate:true},
+    administrativePositionName:{key:"行政职务"},
+    color:{key:"颜色"},
+}
+
+
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:     党费管理
+ */
+export const partyExpensesConfig = {
+    pmId:{key:"pmId"},
+    payType:{key:"缴纳状态"},
+    payTime:{key:"缴费时间", changeDate:true},
+    name:{key:"姓名"},
+    partyPositionsName:{key:"党内职务"},
+    departmentName:{key:"所属科室"},
+    partyJoiningTime:{key:"入党时间", changeDate:true},
+}
+
+
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:     党费管理
+ */
+export const expensesMenberConfig = {
+    name:{key:"姓名"},
+    partyPositionsName:{key:"党内职务"},
+    departmentName:{key:"所属科室"},
+    partyJoiningTime:{key:"入党时间", changeDate:true},
+}
+
+
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:  党建先锋   
+ */
+export const partyVanguardConfig = {
+    pvId:{key:"pvId"},
+    honorName:{key:"荣誉名称"},
+    honorType:{key:"荣誉类型"},
+    grantingRange:{key:"授予范围"},
+    grantingUnit:{key:"授予单位"},
+    grantTime:{key:"授予时间", changeDate:true}
+}
+
+
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:  组织生活  
+ */
+export const organlzationalLifeConfig = {
+    oId:{key:"oId"},
+    theme:{key:"活动标题"},
+    themeType:{key:"活动类型"},
+    dataMonth:{key:"活动月份"}
+}
+
+
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:  党建动态  
+ */
+export const partyBuildingDynamicConfig = {
+    pbId:{key:"pbId"},
+    theme:{key:"活动名称"},
+    dataMonth:{key:"数据月份"}
+}
+
+
+/**
+ * 使用端:   小程序_党员入口
+ * 场景:  本月积分排名  
+ */
+ export const learningPowerConfig = {
+    pmId:{key:"党员id"},
+    name:{key:"党员名称"},
+    bId:{key:"支部名称"},
+    dayIntegral:{key:"积分"},
+    dataTime:{key:"数据时间"}
+}
+
+
+
+
+
+
+

src/config/systemClass.ts

+/**
+ * 系统配置类
+ * 
+ */
+
+export class ServerConfig {
+    /**系统配置 */
+    port:number;
+    dbPath:string;
+    dbSign:string;
+    imgUrl:string;
+}
\ No newline at end of file

src/config/systemConfig.ts

+const path = require('path');
+import * as fs from "fs";
+import { BizError } from "../util/bizError";
+import { analysisXml } from "../util/myXML";
+import { ServerConfig } from "./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, db, imgUrl } = configInfo.config;
+            systemConfig.port = parseInt(port[0]);
+            /**数据读写服务 */
+            systemConfig.dbPath = db[0].url[0];
+            systemConfig.dbSign = db[0].sign[0];
+
+            /**图片地址 */
+            systemConfig.imgUrl = imgUrl[0];
+		}
+        
+        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}`
+}
+ 
+export function getEnum() {
+    
+}
\ No newline at end of file

src/main.ts

+import moment = require("moment");
+import { initConfig, systemConfig} from "./config/systemConfig";
+import { httpServer } from "./net/http_server";
+import { getPwdMd5, getToken, md5PwdStr } from "./tools/system";
+import { initBasicData } from "./tools/dataInit";
+import { operationalData } from "./middleware/databaseSuccess";
+import { OPERATIONALDATATYPE, TABLENAME } from "./config/dbEnum";
+
+async function lanuch() {
+    /**初始化配置解析 */
+    await initConfig();
+    /**初始化数据库 */
+    // await initDB();
+    /**初始化底表数据 */
+    await initBasicData();
+    /**创建http服务 */
+    httpServer.createServer(systemConfig.port);
+    console.log('This indicates that the server is started successfully.');
+    // await test();
+}
+
+const fs = require("fs");
+// const url = path.join(__dirname.substring(0,__dirname.indexOf("out")), "files/docx/党建资讯");
+
+async function test() {
+    let addList = [{
+        pmId: "15175689523",
+        etId: 1,
+        name: "test", 
+        sex: 1,
+        birthDate: "2017-01-01",
+        phone: "15175689523",
+        levelOfEducation: 4,
+        bId: 1,
+        partyJoiningTime: "2020-03-18",
+        administrativePositionName: 1,
+        partyPositionsName: "[]",
+        departmentName: "[]",
+        askForTime: null,
+        listedAsActivistsTime: null,
+        liaison: null,
+        talkTime: null,
+        partyState: 1,
+        isAdmin: false,
+        loginId: "15175689523",
+        pwd: "689523",
+    }]
+    let rows = await operationalData(OPERATIONALDATATYPE.增加, TABLENAME.党员基础信息表, addList, {}); //党员总数
+    console.log(rows);
+
+
+    // let time = moment(560016000000).format("YYYY-MM-DD");
+    // let p = md5PwdStr("946885");
+    // let pwd = getPwdMd5("15821946885", "bdcb05781f14e7bf275a7b51d554f045");
+    // let token = getToken("946885");
+
+    fs.readdir('./files/docx/党建资讯',(err,files)=>{
+        if (err) {
+            console.log(err);
+        } else{
+            // console.log(files); //返回的文件是个数组,可以用forEach循环输出文件名
+             files.forEach((file)=>{
+                 console.log('http://123.207.147.179:7079/docx/党建资讯/'+ file);
+             })
+        }
+    })
+
+    console.log();
+}
+
+lanuch();
+
+let a = [
+    // "36dea1f3c44ab89798d3b3f7fb14667d",
+    // "f7be11973c1671079e702ae0adb661f1",
+    // "68ab8ceeed13831c7f8c09e24cce4f55",
+    // "f18a042255cfab614fad98bd45ab35b3",
+    // "952b91f0ce058bb282320bfac470adbf",
+    // "c1addb426c051200a141132c8344288e",
+    // "42fb19781c7c4b49cc1b688ba6c44502",
+    // "8841d2865336f378e07c7c7e292ab66c",
+    // "c0b6b38cdfacae5e511b4efababe7a0b",
+    // "c35caf37f74eb90ed8c79cb87be4d57b",
+    // "5a7f12ce6a584d35cac5b76c8b4fbd5a",
+    // "ee160a40b5f85883a5c89e6cc469108f"
+]
\ No newline at end of file

src/middleware/databaseSuccess.ts

+import { BizError } from "../util/bizError";
+import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
+import { ERRORENUM } from "../config/errorEnum";
+import { post } from "../util/request";
+import { systemConfig } from "../config/systemConfig";
+
+
+/**
+ * 操作数据库 新增  修改  删除
+ * @param url url地址 根据枚举获取值
+ * @param tableName 表名
+ * @param data 数据
+ * @param param 条件
+ */
+export async function operationalData(url:string, tableName:string, data, param) {
+    let header = {table:tableName, sign:systemConfig.dbSign};
+    let queray:any = {};
+    if (url == OPERATIONALDATATYPE.增加) {
+        queray.data = data;
+    } else if (url == OPERATIONALDATATYPE.修改) {
+        queray.data = data;
+        queray.param = param;
+    } else if (url == OPERATIONALDATATYPE.删除) {
+        queray.param = param;
+    } else {
+        throw new BizError(ERRORENUM.该方法仅可进行数据操作, '使用操作数据库的方法进行查询调用');
+    }
+
+    let result:any = await post(`${systemConfig.dbPath}${url}`, queray, header );
+    if (result.code != 200) throw new BizError(ERRORENUM.数据操作失败, result.code);
+    if (!result.data || !result.success) throw new BizError(ERRORENUM.数据操作失败, JSON.stringify(result.data));
+    
+    return true;
+}
+
+
+/**
+ * 查询
+ * @param url url地址 根据枚举获取值
+ * @param tableName 表名
+ * @param param 条件
+ * @param pageNumber 分页传入的页数  非分页可不传
+ * @param pageSize 分页传入的单页大小  非分页可不传
+ */
+export async function selectData(url, tableName, param, column, pageNumber?, pageSize?) {
+    if (url != OPERATIONALDATATYPE.查询单个 && url != OPERATIONALDATATYPE.查询多个 && url != OPERATIONALDATATYPE.查询数据量 && url != OPERATIONALDATATYPE.分页查询) {
+        throw new BizError(ERRORENUM.该方法仅可进行数据操作, '该方法仅可进行查询操作');
+    }
+    let header = {table:tableName, sign:systemConfig.dbSign};
+    let queray:any = {param, column};
+    if (url == OPERATIONALDATATYPE.查询数据量) queray = {param};
+
+    if (url == OPERATIONALDATATYPE.分页查询) {
+        if (!pageNumber) throw new BizError(ERRORENUM.分页请设置当前页数, `pageNumber:${pageNumber};pageSize:${pageSize}`);
+        queray.pageNumber = pageNumber;
+        queray.pageSize = pageSize || 10;
+    }
+    
+    let result:any = await post(`${systemConfig.dbPath}${url}`, queray, header );
+    if (result.code != 200) throw new BizError(ERRORENUM.数据操作失败, result.code);
+    if (!result.data || !result.success) throw new BizError(ERRORENUM.暂无对应数据, JSON.stringify(result.data));
+    
+    return result.data.data;
+}
+
+
+/**
+ * 多表联查
+ * @param url url地址 根据枚举获取值
+ * @param tableName 表名
+ * @param includeConf {"表名":["",""] } 
+ * @param param 条件
+ * @param pageNumber 分页传入的页数  非分页可不传
+ * @param pageSize 分页传入的单页大小  非分页可不传
+ */
+export async function associationSelectData(url, tableName, includeConf, param, column, pageNumber?, pageSize?) {
+    if (url != OPERATIONALDATATYPE.多表联查) {
+        throw new BizError(ERRORENUM.该方法仅可进行数据操作, '该方法仅可进行查询操作');
+    }
+    let header = {table:tableName, sign:systemConfig.dbSign};
+    let queray:any = {param, includeConf, column};
+
+    if (url == OPERATIONALDATATYPE.分页查询) {
+        if (!pageNumber) throw new BizError(ERRORENUM.分页请设置当前页数, `pageNumber:${pageNumber};pageSize:${pageSize}`);
+        queray.pageNumber = pageNumber;
+        queray.pageSize = pageSize || 10;
+    }
+    
+    let result:any = await post(`${systemConfig.dbPath}${url}`, queray, header );
+    if (result.code != 200) throw new BizError(ERRORENUM.数据操作失败, result.code);
+    if (!result.data || !result.data.isSuccess) throw new BizError(ERRORENUM.数据操作失败, JSON.stringify(result.data));
+    
+    return result.data;
+}
+
+
+export async function getDatabaseSuccess(url, data) {
+    let result;
+    if (data) {
+        if ( data.success === undefined || data.success === true ) {
+            result = data.data;
+        }
+        else {
+            result = data;
+        }
+    }else {
+        if (data.code == 5001) {
+            throw new BizError(`${url}: code: ${data.code}, msg: 请求头中没有sign或者sign不正确`);
+        } else if (data.code == 5002) {
+            throw new BizError(`${url}: code: ${data.code}, msg: 请求头中没有table字段`);
+        } else if (data.code == 5003) {
+            throw new BizError(`${url}: code: ${data.code}, msg: 请求头中传入的table不存在`);
+        }
+        
+    }
+    return result;
+}
\ No newline at end of file

src/middleware/fromParam.ts

+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;
+            next();
+        }
+    })
+}
\ No newline at end of file

src/middleware/getUrl.ts

+/**
+ * 获取数据层接口地址
+ */
+import { systemConfig } from "../config/systemConfig";
+
+export enum urlEnum {
+    添加数据 = "/yfs/dataserver/table/add",
+    删除数据 = "/yfs/dataserver/table/delete",
+    修改单个数据 = "/yfs/dataserver/table/update/one",
+    修改多个数据 = "/yfs/dataserver/table/update/many",
+    查询单个数据 = "/yfs/dataserver/table/find/one",
+    查询多个数据 = "/yfs/dataserver/table/find/many",
+    分页查询 = "/yfs/dataserver/table/find/manytopage",
+    查询数据数量 = "/yfs/dataserver/table/find/count",
+    聚合查询 = "/yfs/dataserver/table/find/aggragate",
+}
+
+
+export function getUrl(url, urlName) {
+    return `${url}${urlName}`
+}
\ No newline at end of file

src/middleware/httpErrorHandler.ts

+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  {
+            res.success({success:false, msg:err.message, code:500});
+            next();
+        }
+    }
+} 
\ No newline at end of file

src/middleware/user.ts

+import { OPERATIONALDATATYPE, TABLENAME } from "../config/dbEnum";
+import { ERRORCODEENUM, ERRORENUM } from "../config/errorEnum";
+import { BizError } from "../util/bizError";
+import { selectData } from "./databaseSuccess";
+
+
+/**
+ * 中间件 校验小程序token
+ * @param req 
+ * @param res 
+ * @param next 
+ * @returns 
+ */
+export async function checkAppletToken(req, res, next) {
+    if (!req.headers) req.headers = {};
+
+    const reqToken = req.headers.token;
+    const userId = req.headers.userid || "";
+
+    if(!userId) return next(new BizError(ERRORCODEENUM.身份验证失败, `loginId:${userId} token:${reqToken}`));
+
+    let partyMemberInfo = await selectData(OPERATIONALDATATYPE.查询单个, TABLENAME.党员基础信息表, {loginId: userId}, ["pmId", "bId", "loginId", "token"]);
+    if (!partyMemberInfo) return next(new BizError(ERRORCODEENUM.非法登录, `loginId:${userId} token:${reqToken}`));
+
+    req.headers.userid = partyMemberInfo.pmId;
+    
+    next();
+}
\ No newline at end of file

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(express.static(path.join(__dirname, "../../img")) );
+        httpServer.use(express.static(path.join(__dirname, "../../files")) );
+        const root = path.join(__dirname, "../../public");
+        httpServer.use(express.static(root));
+        httpServer.use(fallback('index.html', { root }));
+        httpServer.use(bodyParser.json({limit:"1000kb"}));
+        httpServer.use(compression());
+        httpServer.use(watch);
+        routers.setRouter(httpServer);
+        httpServer.use(httpErrorHandler);
+        httpServer.listen(port);
+        console.log('server listen on port:'+port);
+    }
+}
\ No newline at end of file

src/routers/abi/organizationalLife.ts

+/**
+ * 公共资源路由
+ */
+
+import * as organizationalLifeBiz from '../../biz/abi/organizationalLife';
+import * as asyncHandler from 'express-async-handler';
+
+export function setRouter(httpServer) {
+    httpServer.post('/abi/activity', asyncHandler(activity));
+}
+
+
+async function activity(req, res) {
+    let result = await organizationalLifeBiz.getActivityCount();
+    res.success(result);
+}
\ No newline at end of file

src/routers/applet/base.ts

+/**
+ * 小程序端 党员入口 党建首页路由
+ */
+
+import * as baseBiz from '../../biz/base';
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+import { checkAppletToken } from '../../middleware/user';
+
+export function setRouter(httpServer) {
+    httpServer.post('/yfs/applet/partymember/home', asyncHandler(homeBase));
+    httpServer.post('/yfs/applet/partymember/activities', asyncHandler(activitiesBase));
+}
+
+
+/**
+ * 党建首页基础数据
+ * @param req 
+ * @param res 
+ */
+async function homeBase(req, res) {
+    // let branchidData = req.headers.branchid;
+    // let branchName = [];
+    // branchidData = branchidData.slice(1, branchidData.length-1);
+    // branchName = branchidData.split(',');
+    
+    let reqConf = {bId:'Number'};
+    let {bId} = eccReqParamater(reqConf, req.body);
+
+    let baseInfo = await baseBiz.homeData(bId);
+    res.success(baseInfo);
+}
+
+
+/**
+ * 党建首页党建资讯列表
+ * @param req 
+ * @param res 
+ */
+async function activitiesBase(req, res) {
+    let reqConf = {bId:'Number'};
+    let {bId} = eccReqParamater(reqConf, req.body);
+
+    let activitiesInfo = await baseBiz.activitiesData(bId);
+    res.success(activitiesInfo);
+}
+

src/routers/applet/branchSystem.ts

+/**
+ * 小程序端 党员入口 支部制度
+ */
+
+ import * as branchSystemBiz from '../../biz/branchSystem';
+ import * as asyncHandler from 'express-async-handler';
+ import { eccReqParamater } from '../../util/verificationParam';
+import { checkAppletToken } from '../../middleware/user';
+ 
+ export function setRouter(httpServer) {
+    httpServer.post('/yfs/applet/branchsystem/list', asyncHandler(getBranchSystem));
+    httpServer.post('/yfs/applet/branchsystem/detsils', asyncHandler(getBranchSystemDetsils));
+ }
+ 
+
+ /**
+  * 支部制度 制度列表
+  * @param req 
+  * @param res 
+  */
+async function getBranchSystem(req, res) {
+    let reqConf = {bId:'Number', systemTitle:'String'};
+    let {bId, systemTitle} = eccReqParamater(reqConf, req.body, ["systemTitle"]);
+
+    let result = await branchSystemBiz.branchSystemList(bId, systemTitle);
+    res.success(result);
+}
+
+
+/**
+ * 支部制度 制度细则
+ * @param req 
+ * @param res 
+ */
+async function getBranchSystemDetsils(req, res) {
+    let reqConf = {bsId: 'Number'};
+    let {bsId} = eccReqParamater(reqConf, req.body);
+
+    let result = await branchSystemBiz.branchSystemDetsils(bsId);
+    res.success(result);
+}
+

src/routers/applet/memberLearning.ts

+/**
+ * 小程序端 党员入口 党员学习
+ */
+
+import * as memberLearningBiz from '../../biz/memberLearning';
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+import { checkAppletToken } from '../../middleware/user';
+
+export function setRouter(httpServer) {
+    httpServer.post('/yfs/applet/memberlearning/list', checkAppletToken, asyncHandler(getMemberLearning));
+    httpServer.post('/yfs/applet/memberlearning/branchranking', checkAppletToken, asyncHandler(getBranchRanking));
+    httpServer.post('/yfs/applet/memberlearning/monthranking', checkAppletToken, asyncHandler(getMonthRanking));
+}
+
+
+/**  
+  * 党建先锋 视频课程列表
+  * @param req 
+  * @param res 
+  */
+async function getMemberLearning(req, res) {
+    let pmId = req.headers.userid;
+    let reqConf = {courseEntryType:'Number', courseTypeName:'Number', contentTitle:'String'};
+    let {courseEntryType, courseTypeName, contentTitle} = eccReqParamater(reqConf, req.body);
+
+    let result = await memberLearningBiz.memberLearningList(pmId, courseEntryType, courseTypeName, contentTitle);
+    res.success(result);
+}
+
+
+/**
+ * 学习强国 支部学习排行
+ * @param req 
+ * @param res 
+ */
+async function getBranchRanking(req, res) {
+  let {bId} = eccReqParamater({bId:'Number'}, req.body);
+
+  let result = await memberLearningBiz.branchRanking(bId);
+  res.success(result);
+}
+
+
+/**
+ * 学习强国 本月学习排行
+ * @param req 
+ * @param res 
+ */
+async function getMonthRanking(req, res) {
+  let result = await memberLearningBiz.monthRanking();
+  res.success(result);
+}
+
+
+
+
+
+ 
+ 
+ 
\ No newline at end of file

src/routers/applet/organizationalLife.ts

+/**
+ * 小程序端 党员入口 组织生活路由
+ */
+
+import * as organizationalLifeBiz from '../../biz/organizationalLife';
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+import { checkAppletToken } from '../../middleware/user';
+
+export function setRouter(httpServer) {
+    httpServer.post('/yfs/applet/organizationallife/list', asyncHandler(organizationalLifeList));
+    httpServer.post('/yfs/applet/organizationallife/details', asyncHandler(detailsList));
+}
+
+
+/**
+ * 组织生活列表
+ * @param req 
+ * @param res 
+ */
+async function organizationalLifeList(req, res) {
+    let reqConf = {bId:'Number', theme:'String', themeType:'Number', dataMonth:'String'};
+    let {bId, theme, themeType, dataMonth} = eccReqParamater(reqConf, req.body, ["theme","themeType","dataMonth"]);
+
+    let result = await organizationalLifeBiz.organlzationalLifeList(bId, theme, themeType, dataMonth);
+    res.success(result);
+}
+
+
+/**
+ * 组织生活详情
+ * @param req 
+ * @param res 
+ */
+async function detailsList(req, res) {
+    let reqConf = {oId: 'Number' };
+    let {oId} = eccReqParamater(reqConf, req.body);
+
+    let result = await organizationalLifeBiz.organlzationalLifeListDetsils(oId);
+    res.success(result);
+}
+

src/routers/applet/partyBuildingDynamic.ts

+/**
+ * 小程序端 党员入口 党建动态路由
+ */
+
+ import * as partyBuildingDynamicBiz from '../../biz/partyBuildingDynamic';
+ import * as asyncHandler from 'express-async-handler';
+ import { eccReqParamater } from '../../util/verificationParam';
+ import { checkAppletToken } from '../../middleware/user';
+ 
+ export function setRouter(httpServer) {
+     httpServer.post('/yfs/applet/buildingdynamic/list', asyncHandler(partyBuildingDynamicList));
+     httpServer.post('/yfs/applet/buildingdynamic/details', asyncHandler(detailsList));
+ }
+ 
+ 
+ /**
+  * 党建动态列表
+  * @param req 
+  * @param res 
+  */
+ async function partyBuildingDynamicList(req, res) {
+     let reqConf = {bId:'Number', theme:'String', activityYear:'String', activityMonth:'String'};
+     let {bId, theme, activityYear, activityMonth} = eccReqParamater(reqConf, req.body, ["theme","activityYear","activityMonth"]);
+ 
+     let result = await partyBuildingDynamicBiz.partyBuildingDynamicList(bId, theme, activityYear, activityMonth);
+     res.success(result);
+ }
+ 
+ 
+ /**
+  * 党建动态详情
+  * @param req 
+  * @param res 
+  */
+ async function detailsList(req, res) {
+     let reqConf = {pbId: 'Number' };
+     let {pbId} = eccReqParamater(reqConf, req.body);
+ 
+     let result = await partyBuildingDynamicBiz.partyBuildingDynamicDetsils(pbId);
+     res.success(result);
+ }
+ 
+ 
\ No newline at end of file

src/routers/applet/partyExpenses.ts

+/**
+ * 小程序端 党员入口 党费管理
+ */
+
+import * as partyExpensesBiz from '../../biz/partyExpenses';
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+import { checkAppletToken } from '../../middleware/user';
+ 
+export function setRouter(httpServer) {
+    httpServer.post('/yfs/applet/partymember/partyexpenses', asyncHandler(getPartyExpenses));
+    
+}
+ 
+
+/**
+  * 党费列表
+  * @param req 
+  * @param res 
+  */
+async function getPartyExpenses(req, res) {
+    let reqConf = {bId:'Number', name:'String', payType:'Number', payableYear:'String', payableMonth:'String'};
+    let {bId, name, payType, payableYear, payableMonth} = eccReqParamater(reqConf, req.body, ["name", "payType", "payableYear", "payableMonth"]);
+
+    let result = await partyExpensesBiz.partyExpensesData(bId, name, payType, payableYear, payableMonth);
+    res.success(result);
+}
+
+
+
+
+
+ 
+ 
+ 
+ 
+ 
+ 
\ No newline at end of file

src/routers/applet/partyInforMation.ts

+/**
+ * 小程序端 党员入口 党建资讯
+ */
+
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+import { checkAppletToken } from '../../middleware/user';
+ 
+export function setRouter(httpServer) {
+    
+}
+

src/routers/applet/partyMember.ts

+/**
+ * 小程序端 党员入口 党员基础信息
+ */
+
+import * as partyMemberBiz from '../../biz/partyMember';
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+import { checkAppletToken } from '../../middleware/user';
+ 
+export function setRouter(httpServer) {
+    httpServer.post('/yfs/applet/partymember/partymembername', asyncHandler(getPartyMemberName));
+    httpServer.post('/yfs/applet/partymember/detsils', asyncHandler(partyDetsils));
+}
+ 
+
+/**
+  * 党员名册
+  * @param req 
+  * @param res 
+  */
+async function getPartyMemberName(req, res) {
+    let reqConf = {bId:'Number', name:'String'};
+    let {bId, name} = eccReqParamater(reqConf, req.body);
+
+    let result = await partyMemberBiz.partyMemberNameList(bId, name);
+    res.success(result);
+}
+
+
+/**
+ * 党员详情
+ * @param req 
+ * @param res 
+ */
+async function partyDetsils(req, res) {
+    let reqConf = {bId: 'Number', pmId: 'String'};
+    let {bId, pmId} = eccReqParamater(reqConf, req.body);
+
+    let result = await partyMemberBiz.partyMemberDetails(bId, pmId);
+    res.success(result);
+}
+
+
+
+
+

src/routers/applet/partyQuality.ts

+/**
+ * 小程序端 党员入口 党建先锋
+ */
+
+import * as partyQualityBiz from '../../biz/partyQuality';
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+import { checkAppletToken } from '../../middleware/user';
+
+export function setRouter(httpServer) {
+    httpServer.post('/yfs/applet/partyquality/list', asyncHandler(getPartyQuality));
+    // httpServer.post('/yfs/applet/partyquality/detsils', asyncHandler(getPartyVanguardDetsils));
+}
+
+
+ /**  
+  * 党建先锋 荣誉列表
+  * @param req 
+  * @param res 
+  */
+async function getPartyQuality(req, res) {
+    let reqConf = {bId:'Number'};
+    let {bId} = eccReqParamater(reqConf, req.body);
+
+    let result = await partyQualityBiz.partyQualityList(bId);
+    res.success(result);
+}
+
+
+/**
+ * 党建先锋 获取荣誉详情
+ * @param req 
+ * @param res 
+ */
+// async function getPartyVanguardDetsils(req, res) {
+//     let reqConf = {pvId:'Number'};
+//     let {pvId} = eccReqParamater(reqConf, req.body);
+
+//     let result = await partyQualityBiz.partyVanguardDetsils(pvId);
+//     res.success(result);
+// }
+ 
+ 
+ 
+ 
+ 
+
+

src/routers/applet/partyVanguard.ts

+/**
+ * 小程序端 党员入口 党建先锋
+ */
+
+import * as partyVanguardBiz from '../../biz/partyVanguard';
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+import { checkAppletToken } from '../../middleware/user';
+
+export function setRouter(httpServer) {
+  httpServer.post('/yfs/applet/partyvanguard/list', asyncHandler(getPartyVanguard));
+  httpServer.post('/yfs/applet/partyvanguard/detsils', asyncHandler(getPartyVanguardDetsils));
+  // httpServer.post('/partymember/partyvanguard/createbranchpioneer', checkAppletToken, asyncHandler(createBranchPioneer));
+  // httpServer.post('/partymember/partyvanguard/createmodelparty', checkAppletToken, asyncHandler(createModelParty));
+  // httpServer.post('/partymember/partyvanguard/update', checkAppletToken, asyncHandler(updatePartyVanguard));
+  // httpServer.post('/partymember/partyvanguard/delete', checkAppletToken, asyncHandler(deletePartyVanguard));
+}
+
+
+ /**  
+  * 党建先锋 荣誉列表
+  * @param req 
+  * @param res 
+  */
+async function getPartyVanguard(req, res) {
+  let reqConf = {bId:'Number', honorName:'String'};
+  let {bId, honorName} = eccReqParamater(reqConf, req.body, ["honorName"]);
+
+  let result = await partyVanguardBiz.partyVanguardList(bId, honorName);
+  res.success(result);
+}
+
+
+/**
+ * 党建先锋 获取荣誉详情
+ * @param req 
+ * @param res 
+ */
+async function getPartyVanguardDetsils(req, res) {
+  let reqConf = {pvId:'Number'};
+  let {pvId} = eccReqParamater(reqConf, req.body);
+
+  let result = await partyVanguardBiz.partyVanguardDetsils(pvId);
+  res.success(result);
+}
+
+
+
+

src/routers/applet/user.ts

+/**
+ * 小程序端 党员入口 用户基础功能路由
+ */
+
+import * as userBiz from '../../biz/user';
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+import { checkAppletToken } from '../../middleware/user';
+
+export function setRouter(httpServer) {
+    httpServer.post('/yfs/applet/partymember/login', asyncHandler(login));
+    httpServer.post('/yfs/applet/partymember/changePwd', checkAppletToken, asyncHandler(changePwd));
+}
+
+
+/**
+ * 党员入口登录
+ * @param req 
+ * @param res 
+ */
+async function login(req, res) {
+    let reqConf = {loginId:'String', pwd:'String'};
+    let {loginId, pwd} = eccReqParamater(reqConf, req.body);
+
+    let userInfo = await userBiz.login(loginId, pwd);
+    res.success(userInfo);
+}
+
+
+/**
+ * 修改密码
+ * @param req 
+ * @param res 
+ */
+ async function changePwd(req, res) {
+    let reqConf = {confirmPwd:'String', newPwd:'String', pwd:'String' };
+    let {confirmPwd, newPwd, pwd} = eccReqParamater(reqConf, req.body);
+    const Uscc = req.headers.uscc;
+
+    let result = await userBiz.changePassword(Uscc, pwd, newPwd, confirmPwd); 
+
+    res.success(result);
+}
\ No newline at end of file

src/routers/public.ts

+/**
+ * 公共资源路由
+ */
+
+import * as asyncHandler from 'express-async-handler';
+import * as configEnum from "../config/enum";
+import * as clientConfigEnum from "../config/clientEnum";
+import moment = require('moment');
+
+export function setRouter(httpServer) {
+    httpServer.post('/public/partypositions', asyncHandler(partyPositions));
+    httpServer.post('/public/type', asyncHandler(type));
+    httpServer.post('/public/entrytype', asyncHandler(entryType));
+    httpServer.post('/public/sex', asyncHandler(sexType));
+    httpServer.post('/public/degree', asyncHandler(degreeType));
+    httpServer.post('/public/administrativeposition', asyncHandler(administrativePosition));
+    httpServer.post('/public/department', asyncHandler(department));
+    httpServer.post('/public/degreetype', asyncHandler(degreeType));
+    httpServer.post('/public/honortype', asyncHandler(honorType));
+    httpServer.post('/yfs/applet/public/themetype', asyncHandler(themeType));
+    httpServer.post('/yfs/applet/public/paytype', asyncHandler(payType));
+    httpServer.post('/yfs/applet/public/paytime', asyncHandler(getPayTime));
+    httpServer.post('/yfs/applet/public/coursetype', asyncHandler(courseType));
+    
+}
+
+
+/**
+ * 党内职务
+ * @param req 
+ * @param res 
+ */
+function partyPositions(req, res) {
+    let dataList = getEnumList(configEnum.PARTYPOSITIONS);
+    res.success(dataList);
+}
+
+
+/**
+ * 组织生活活动类型
+ * @param req  
+ * @param res 
+ */
+ function type(req, res) {
+    let dataList = getEnumList(clientConfigEnum.TYPE);
+    res.success(dataList);
+}
+
+
+/**
+ * 组织生活主题类型
+ * @param req 
+ * @param res 
+ */
+function themeType(req, res) {
+    let dataList = getEnumList(configEnum.THEMETYPE)
+    res.success(dataList);
+}
+
+
+
+/**
+ * 名册录入类型
+ * @param req  
+ * @param res 
+ */
+ function entryType(req, res) {
+    let dataList = getEnumList(clientConfigEnum.ENTRYTYPE);
+    res.success(dataList);
+}
+
+
+/**
+ * 性别类型
+ * @param req 
+ * @param res 
+ */
+function sexType(req, res) {
+    let dataList = getEnumList(configEnum.SEX);
+    res.success(dataList);
+}
+
+
+/**
+ * 文化程度类型
+ * @param req 
+ * @param res 
+ */
+function degreeType(req, res) {
+    let dataList = getEnumList(configEnum.DEGREE);
+    res.success(dataList);
+}
+
+
+/**
+ * 行政职务类型
+ * @param req 
+ * @param res 
+ */
+function administrativePosition(req, res) {
+    let dataList = getEnumList(configEnum.ADMINISTRATIVEPOSITION);
+    res.success(dataList);
+}
+
+
+/**
+ * 所属科室类型
+ * @param req 
+ * @param res 
+ */
+function department(req, res) {
+    let dataList = getEnumList(configEnum.DEDPARTMENT);
+    res.success(dataList);
+}
+
+
+/**
+ * 荣誉类型
+ * @param req 
+ * @param res 
+ */
+function honorType(req, res) {
+    let dataList = getEnumList(configEnum.HONORTYPE);
+    res.success(dataList);
+}
+
+
+/**
+ * 缴纳状态
+ * @param req 
+ * @param res 
+ */
+function payType(req, res) {
+    let dataList = getEnumList(configEnum.PAYTYPE);
+    res.success(dataList);
+}
+
+
+/**
+ * 课程类型
+ * @param req 
+ * @param res 
+ */
+function courseType(req, res) {
+    let dataList = getEnumList(configEnum.COURSETYPE);
+    res.success(dataList);
+}
+
+
+/**
+ * 下拉年份月份
+ * @param req 
+ * @param res 
+ */
+async function getPayTime(req, res) {
+    let result = await payTime();
+    
+    res.success(result);
+}
+
+
+function getEnumList(enumData) {
+    let dataList= [];
+    for (let key in enumData) {
+        let anyKey:any = key;
+        if (isNaN(anyKey)) {
+            let keyStr = key;
+            dataList.push({key:keyStr, value:enumData[key]});
+        }
+    }
+
+    return dataList;
+}
+
+
+
+/**
+ * 缴纳时间
+ */
+export function payTime() {
+    let smallYear = 2018; //数据开始年份
+    let nowYear = parseInt(moment(new Date()).format("YYYY")); //当前年份
+    let yearList = [];
+    let monthList = [];
+
+    let nowMonth = parseInt(moment(new Date()).format("MM"));
+    let yearmonth = [];
+    for(let i = 1; i <= nowMonth; i++) {
+        yearmonth.push(i);
+    }
+    monthList.push(yearmonth);
+
+    for(let i = nowYear; i >= smallYear; i--) {
+        yearList.push(i);
+        let yearmonth = [];
+        for(let m = 1; m <= 12; m++){
+            yearmonth.push(m);
+        }
+        monthList.push(yearmonth);
+    }
+
+    return {yearList, monthList};
+}
\ No newline at end of file

src/routers/router.ts

+/**
+ * 总路由入口
+ */
+
+import * as appletUserRouters from '../routers/applet/user';
+import * as appletBaseRouters from '../routers/applet/base';
+import * as appletPartyMemberRouters from '../routers/applet/partyMember';
+import * as appletBranchSystemRouters from '../routers/applet/branchSystem';
+import * as appletOrganizationalLifeRouters from '../routers/applet/organizationalLife';
+import * as appletPartyInforMationRouters from '../routers/applet/partyInforMation';
+import * as appletPartyVanguardRouters from '../routers/applet/partyVanguard';
+import * as appletPartyExpensesRouters from '../routers/applet/partyExpenses';
+import * as appletPartyQualityRouters from '../routers/applet/partyQuality';
+import * as partyBuildingDynamicRouters from '../routers/applet/partyBuildingDynamic';
+import * as memberLearningRouters from '../routers/applet/memberLearning';
+
+import * as publicRouters from '../routers/public';
+import * as abiOrganizationalLifeRouters from '../routers/abi/organizationalLife';
+
+export function setRouter(httpServer){
+    /**小程序端 党员入口 */
+    appletUserRouters.setRouter(httpServer);
+    appletBaseRouters.setRouter(httpServer);
+    appletPartyMemberRouters.setRouter(httpServer);
+    appletBranchSystemRouters.setRouter(httpServer);
+    appletOrganizationalLifeRouters.setRouter(httpServer);
+    appletPartyInforMationRouters.setRouter(httpServer);
+    appletPartyVanguardRouters.setRouter(httpServer);
+    appletPartyExpensesRouters.setRouter(httpServer);
+    appletPartyQualityRouters.setRouter(httpServer);
+    partyBuildingDynamicRouters.setRouter(httpServer);
+    memberLearningRouters.setRouter(httpServer);
+
+    /**小程序端 公共资源 */
+    publicRouters.setRouter(httpServer);
+
+    /**ABI */
+    abiOrganizationalLifeRouters.setRouter(httpServer);
+}
\ No newline at end of file

src/tools/system.ts

+/**
+ * 系统中使用的工具
+ * 包括 任务生成规则
+ * 包括 key生成规则
+ * 包括 草稿箱id生成规则
+ * 包括 密码加密规则
+ */
+
+import moment = require("moment");
+
+const md5 = require("md5");
+
+
+/**
+ * 生成任务id
+ * @param uscc 企业标识
+ * @returns 
+ */
+export function getTaskId(uscc:string) {
+    return `${uscc}${getTimeKey()}`;
+}
+
+
+/**
+ * 根据时间生成任务id
+ * @param uscc 企业标识
+ * @param timeMs 时间戳
+ * @returns 
+ */
+export function getTaskIdByTime(uscc:string, timeMs:number) {
+    return `${uscc}${new Date(timeMs).getFullYear()}${new Date(timeMs).getMonth() + 1 }`;
+}
+
+
+/**
+ * 获取当前日期的key
+ * @param timeMs 指定时间，如果不传
+ * @returns 
+ */
+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 }`);
+}
+
+
+/**
+ * 获取上一个月日期的key
+ * @param timeMs 指定时间，如果不传
+ * @returns 
+ */
+export function getLastMonthTimeKey() {
+    let time = moment().subtract(1, 'months').valueOf();
+    return parseInt(`${new Date(time).getFullYear()}${new Date(time).getMonth() + 1 }`);
+}
+
+
+/**
+ * 获取上一月的日期的key
+ * @returns 
+ */
+export function getLastTimeKey() {
+    return moment().subtract(1,'months').format('YYYYM');
+}
+
+
+/**
+ * 生成草稿箱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 loginId 统一信用代码
+ */
+export function getToken(loginId:string) {
+    return md5(`${loginId}${new Date().valueOf()}${Math.ceil(Math.random() *100)}`);
+}
+
+
+/**
+ * 校验uscc是否合法
+ * @param uscc 
+ * @returns true/false 
+ */
+export function eccUscc(uscc:string) {
+    let isSuccess = false;
+    if (uscc.search(/^[A-Za-z0-9]{16}$/) > -1) isSuccess = true;
+    else if (uscc.search(/^[A-Za-z0-9]{18}$/) > -1) isSuccess = true;
+    return isSuccess;
+}
+
+
+/**
+ * 获取绑定id
+ * @param uscc 孵化器统一信用代码
+ * @param bindUscc 被绑定的孵化器统一信用代码
+ * @returns 
+ */
+export function getBindId(uscc:string, bindUscc:string) {
+    return md5(`${uscc}${bindUscc}${Math.ceil(Math.random() *100)}`);
+} 
+
+
+/**
+ * 获取今天开始时刻的时间戳  0时0分
+ * @returns 
+ */
+export function getTodayMs() {
+    let t =`${ moment().format("YYYY-MM-DD")} 00:00:00`;
+    return new Date(t).valueOf();
+}
+
+/**
+ * 获取这个月的开始时刻的时间戳  0时0分
+ * @returns 
+ */
+export function getThisMonthMs() {
+    let t =`${ moment().format("YYYY-MM")}-01 00:00:00`;
+    return new Date(t).valueOf();
+}
+
+
+/**
+ * 获取code的id
+ * @param uscc 发送人的uscc
+ * @param todaySendCount 今日发送次数
+ * @returns ''
+ */
+export function getSMSCodeId(uscc:string, todaySendCount:number) {
+    return md5(`${uscc}${todaySendCount}${new Date().valueOf()}`);
+}
+
+
+/**
+ * 获取一个随机6位数的验证码
+ * @returns 
+ */
+export function getSMSCode() {
+    let code = ``;
+    for (let i =0; i < 6; i++) {
+        code += Math.floor(Math.random() * 10)
+    }
+    return code;
+}
\ 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 
+ * @param isAdmin 是否是管理后台
+ * @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 {
+            result[key] = data[key];
+            if (typeof result[key] == 'string' && !result[key]) result[key] = '';
+        }
+    }
+    return result;
+}

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, body) {
+            if (!error && response.statusCode == 200) {
+                resolve(body);
+            }
+            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)
+            }
+        });
+    })
+}

src/util/verificationEnum.ts

+/**
+ * 校验枚举工具
+ * 
+ */
+
+import { ERRORENUM } from "../config/errorEnum";
+import { BizError } from "./bizError";
+
+
+/**
+ * 校验value是否符合传入的枚举
+ * @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' || typeof value == 'string' ) {
+        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("_",",");
+        }
+        return str
+    }
+    let str = "";
+    value.forEach((item, index) => {
+        let subStr = enumConf[item];
+        /** 特化处理 中文引号在枚举中不适用*/
+        if (subStr == "_投资__孵化_类型") {
+            subStr = subStr.replace("__","+");
+            subStr = subStr.replace("_","“");
+            subStr = subStr.replace("_","”");
+        }
+        if (str == "经营成本过高_场地成本或人员成本_" || str == "办公空间拓展_无合适办公空间_") {
+            str = str.replace("_","(");
+            str = str.replace("_",")");
+        }
+        if (str == "迁出孵化器_仍在张江" || str == "迁出张江_仍在浦东" || str == "迁出浦东_仍在上海") {
+            str = str.replace("_",",");
+        }
+        str += subStr;
+        if (index == value.length-1) str+="";
+        else str += ","
+    });
+
+    return str;
+}
\ 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]
+ * 参数是必填
+ * 方法会校验表单中存在的多余字段
+ * todo 后续优化配置
+ * @param name 被调用的方法名
+ * @param config 校验配置
+ * @param param 需要校验的参数
+ * @returns true 无需关注返回
+ */
+
+/**
+ * 通过config校验表单参数param
+ * 包括类型 String, Number, Boolean, [Number], [Object]
+ * 参数是必填
+ * 方法会校验表单中存在的多余字段
+ * todo 后续优化配置
+ * @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.参数错误, `多余${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.参数错误, `缺失${key}字段`);
+        } else {
+            switch(type) {
+                case 'Number':
+                    if ( type.toLowerCase() != valueType )  {
+                        isError = true;
+                    } else {
+                        if ((""+param[key]).indexOf('.') > -1) {
+                            param[key] = parseInt(`${param[key] *100}`)/100;
+                        }
+                    }
+                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.地址数据不完整, `${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;
+}

tsconfig.json

+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2017",
+    "sourceMap": true,
+    "rootDir":"./src",
+    "outDir":"./out"
+  },
+  "exclude": [
+    "node_modules"
+  ]
+} 
\ No newline at end of file