no message

.gitignore

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

.vscode/launch.json

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

package.json

+{
+  "name": "screen",
+  "version": "1.0.0",
+  "description": "",
+  "main": "main.ts",
+  "dependencies": {
+    "@alicloud/sms-sdk": "^1.1.6",
+    "@types/node": "^10.12.18",
+    "compression": "^1.7.4",
+    "express": "^4.17.1",
+    "express-async-handler": "^1.1.4",
+    "express-history-api-fallback": "^2.2.1",
+    "formidable": "^1.2.1",
+    "log4js": "^6.6.1",
+    "lru-cache": "^4.1.5",
+    "md5": "^2.2.1",
+    "moment": "^2.24.0",
+    "mongoose": "^5.4.0",
+    "mysql": "^2.18.1",
+    "node-xlsx": "^0.16.1",
+    "nodemailer": "^6.1.1",
+    "pyfl": "^1.1.4",
+    "officegen": "^0.6.5",
+    "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"
+  },
+  "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>13280</port>
+    <mongodb>
+        <path>127.0.0.1</path>
+        <port>27017</port>
+        <w>1</w>
+        <!-- <dataBase>baseDB</dataBase> -->
+        <dataBase>zjzdata</dataBase>
+        <wtimeoutMS>30000</wtimeoutMS>
+    </mongodb>
+    <qcc>
+        <key>2b14555ce89346e8b96684e2e2a1c7c2</key>
+        <SecretKey>452AAE887A1CDCAB8C9D730BA8B8FBF0</SecretKey>
+    </qcc>
+    <!-- 小程序的secret 和 appid -->
+    <secret></secret>
+    <appId></appId>
+    <!-- 获取小程序的openId地址 -->
+    <getOpenIdUrl></getOpenIdUrl>
+    <!-- 短信相关配置 -->
+    <sms>
+        <sdkAppId></sdkAppId>
+        <appKey></appKey>
+        <smsSign></smsSign>
+        <!-- 修改密码的模板id -->
+        <changePwd></changePwd>
+        <!-- 填报提示 -->
+        <pointOut></pointOut>
+        <!-- 初始化账号提示 -->
+        <initPointOut></initPointOut>
+    </sms>
+    <!-- <baidumap>KI1jEpifrEQtgr7ZJ2zAOKlUw1tme7Eb</baidumap> -->
+    <!-- <baidumap>QCxLry4y9BjIDRDIsGAerkcHrnrbo55I</baidumap> 夏-->
+    <baidumap></baidumap>
+</config>

src/biz/activity.ts

+/**
+ * 企业活动
+ */
+
+import moment = require("moment");
+import { ACTIVITYTYPECLIENT } from "../config/enum";
+import { eccEnumValue } from "../util/verificationEnum";
+import { findActivityCount, findActivityList, findOnceActivity } from "../data/policy/activity";
+import { BizError } from "../util/bizError";
+import { ERRORENUM } from "../config/errorEnum";
+
+
+/**
+ * 活动列表
+ * @param type 
+ * @param state 
+ * @returns 
+ */
+export async function activityList(type:number, state:number) {
+    const FunName = "企业活动列表";
+    let param:any = {};
+    eccEnumValue(FunName, "type", ACTIVITYTYPECLIENT, type);
+
+    if (type == ACTIVITYTYPECLIENT.本周新发布) {
+        let startOfWeekMs = moment().startOf('week').valueOf(); 
+        param.createTime = {"$gt":startOfWeekMs};
+    } else {
+        param.type = type;
+    }
+
+    let now = new Date().valueOf();
+    if (state == 1) {//进行中
+        param.startTime = {"$lt":now};
+        param.endTime = {"$gt":now};
+    } else {
+        param.endTime = {"$lt":now};
+    }
+
+    let dbList = await findActivityList(param);
+    let dataList = [];
+    dbList.forEach(info => {
+        let item = {
+            img:info.img,
+            aId:info.aId,
+            title:info.title,
+            activityTime:`${moment(info.startTime).format("YYYY-MM-DD")}至${moment(info.endTime).format("YYYY-MM-DD")}`,
+            location:info.location
+        };
+        dataList.push(item);
+    });
+    return {dataList, dataCount:dataList.length};
+}
+
+/**
+ * 获取活动统计
+ * @param type 
+ * @returns 
+ */
+export async function activityStatis(type:number) {
+    let now = new Date().valueOf();
+
+    let dataList = [];
+    let thisTypeParam:any = {};
+    for (let key in ACTIVITYTYPECLIENT) {
+        let keyAny:any = key;
+        if (!isNaN(keyAny)) {
+            let itemType = parseInt(keyAny);
+
+            let param:any = {};
+            if (itemType == ACTIVITYTYPECLIENT.本周新发布) {
+                let startOfWeekMs = moment().startOf('week').valueOf(); 
+                param.createTime = {"$gt":startOfWeekMs};
+                if (type == itemType) thisTypeParam.createTime = {"$gt":startOfWeekMs};
+            } else {
+                param.type = itemType;
+                if (type == itemType) thisTypeParam.type = itemType;
+            }
+            let value = await findActivityCount(param);
+            dataList.push({
+                key:ACTIVITYTYPECLIENT[key],
+                value
+            });
+        }
+    }
+
+    thisTypeParam.startTime = {"$lt":now};
+    thisTypeParam.endTime = {"$gt":now};
+    let inProgressCount = await findActivityCount(thisTypeParam);
+
+    delete thisTypeParam.startTime;
+    thisTypeParam.endTime = {"$lt":now};
+    let endCount = await findActivityCount(thisTypeParam);
+
+    return {dataList, inProgressCount, endCount};
+}
+
+
+/**
+ * 获取活动详情
+ * @param type 
+ * @returns 
+ */
+export async function activityInfo(aId:string) {
+    let activityInfo = await findOnceActivity({aId});
+    if (!activityInfo || !activityInfo.aId) throw new BizError(ERRORENUM.活动不存在);
+
+    return {
+        dataInfo:{
+            title:activityInfo.title,
+            content:activityInfo.content,
+            createTime:moment(activityInfo.createTime).format("YYYY-MM-DD"),
+            img:activityInfo.img,
+            location:activityInfo.location,
+            startTime:moment(activityInfo.startTime).format("YYYY-MM-DD"),
+            endTime:moment(activityInfo.endTime).format("YYYY-MM-DD")
+        }
+    }
+}
+
+export async function homePageActivity() {
+    let now = new Date().valueOf();
+    let param = {
+        startTime : {"$lt":now},
+        endTime : {"$gt":now}
+    }
+    let dbList = await findActivityList(param);
+    dbList.sort((a, b) => {return b.createTime - a.createTime});
+
+    let dataList = [];
+    for (let i = 0; i < 2; i++) {
+        let info = dbList[i];
+        if (!info || !info.aId) break;
+        dataList.push({
+            img:info.img,
+            aId:info.aId,
+            title:info.title,
+            activityTime:`${moment(info.startTime).format("YYYY-MM-DD")}至${moment(info.endTime).format("YYYY-MM-DD")}`,
+            location:info.location
+        });
+    }
+
+    return {dataList};
+}
\ No newline at end of file

src/biz/dataInit.ts

+/**
+ * 初始化数据
+ */
+
+import { ACTIVITYTYPECLIENT, APPEALTYPE, ENTERPRISESIZE, INDUSTRY, NASHUIRENZIZHI, POLICYTYPE, RAS, RESEARCHTYPE, SOLUTIONTYPE, SOLVESTATE, SUBSIDYTYPE, USERTYPE } from "../config/enum";
+import { initEnterpriseBase } from "../data/enterprise/enterprise";
+import { createUser } from "../data/user";
+import { excelBecomeOfBlockData, onceSheetBecomeOfblockData } from "../util/analysisExcel";
+import * as serviceData from "../data/service/service";
+import * as visitData from "../data/service/visit";
+import { addActivity } from "../data/policy/activity";
+import { addPolicy } from "../data/policy/policy";
+import { addData } from "../data/service/policyImplementation";
+import { getPwdMd5 } from "../tools/system";
+const md5 = require("md5");
+import { gaoXinEnterpriseMap } from "./labelEnterpriseList";
+const xlsx = require('node-xlsx');
+const path = require('path');
+const fs = require('fs');
+
+export async function test111() {
+    let excelInfo = onceSheetBecomeOfblockData("目标名单.xlsx", "Sheet1");
+    let dataList = excelInfo[0]["blockData"];
+
+
+    let newList = [
+        ["序号","原文件导入名称","系统匹配企业名称","统一社会信用代码","是否高新技术企业"]
+    ];
+
+    dataList.forEach((subList, index) => {
+        if (!index) return;
+        let name = subList[2];
+        if (!name) return;
+        if (gaoXinEnterpriseMap[name]) {
+            subList.push("是");
+        }
+        newList.push(subList);
+    });
+
+
+    let data = [
+        {
+            name:"sheet1",
+            data:newList
+        }
+    ];
+    let buff = xlsx.build(data);
+    fs.writeFileSync(path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", '高新技术企业标记.xlsx' ), buff);
+
+    console.log();
+}
+
+export async function initData() {
+
+    // await createUser({userType:1, name:"李欣鸣", loginId:"18711017326", userId:"123123aac", pwd:getPwdMd5("18711017326", md5("123456")), phone:"18711017326"});
+    // await createUser({userType:1, name:"陈知行", loginId:"18120935727", userId:"123123aad", pwd:getPwdMd5("18120935727", md5("123456")), phone:"18120935727"});
+    // await upCheckEnterpriseData();
+   
+
+    
+    
+}
+
+
+async function upCheckEnterpriseData() {
+
+    let zdqy = onceSheetBecomeOfblockData('重点企业.xlsx', "Sheet1");
+    let zdqyDataList = zdqy[0].blockData;
+
+    let map = {};
+    for (let i = 1; i < zdqyDataList.length; i++) {
+        let uscc = zdqyDataList[i][0];
+        map[uscc] = 1;
+    }
+
+    let data = onceSheetBecomeOfblockData('全部企业.xlsx', '已匹配户管企业');
+    let dataList = data[0].blockData;
+    
+    let checkCount = 0;
+
+    let addList = [];
+    for (let i = 1; i < dataList.length; i++) {
+        let itemList = dataList[i];
+
+        let 原文件导入名称 = itemList[0];
+        let 系统匹配企业名称 = itemList[1];
+        let 登记状态 = itemList[2];
+        let 法定代表人 = itemList[3];
+        let 注册资本 = itemList[4];
+        let 实缴资本 = itemList[5];
+        let 成立日期 = itemList[6];
+        let 统一社会信用代码 = itemList[7];
+        let 企业地址 = itemList[8];
+        let 所属省份 = itemList[9];
+        let 所属城市 = itemList[10];
+        let 所属区县 = itemList[11];
+        let 电话 = itemList[12];
+        let 更多电话 = itemList[13];
+        let 邮箱 = itemList[14];
+        let 更多邮箱 = itemList[15];
+        let 企业机构类型 = itemList[16];
+        let 纳税人识别号 = itemList[17];
+        let 注册号 = itemList[18];
+        let 组织机构代码 = itemList[19];
+        let 参保人数 = itemList[20];
+        let 参保人数所属年报 = itemList[21];
+        let 营业期限 = itemList[22];
+        let 国标行业门类 = itemList[23];
+        let 国标行业大类 = itemList[24];
+        let 国标行业中类 = itemList[25];
+        let 国标行业小类 = itemList[26];
+        let 企查查行业门类 = itemList[27];
+        let 企查查行业大类 = itemList[28];
+        let 企查查行业中类 = itemList[29];
+        let 企查查行业小类 = itemList[30];
+        let 企业规模 = itemList[31];
+        let 曾用名 = itemList[32];
+        let 英文名 = itemList[33];
+        let 官网 = itemList[34];
+        let 通信地址 = itemList[35];
+        let 企业简介 = itemList[36];
+        let 经营范围 = itemList[37];
+        let 登记机关 = itemList[38];
+        let 纳税人资质 = itemList[39];
+        let 最新年报年份 = itemList[40];
+        let 企业经营状态 = itemList[41];
+
+        let addInfo:any = {
+            uscc:统一社会信用代码,
+            name:系统匹配企业名称
+        };
+
+        /**核对基础信息，注册时间，注册地址，经营地址等 */
+        if (成立日期 != "-") {
+            addInfo.logonTime = new Date(成立日期).valueOf();
+        }
+        addInfo.logonAddressList = [所属省份, 所属城市, 所属区县, 企业地址];
+        addInfo.logonAddress = 企业地址;
+        addInfo.mainBusiness = 经营范围;
+
+        let ras = RAS.续存;
+        if (登记状态.indexOf("注销") != -1) {
+            //企业注销  注销将企业改成迁出
+            let 等级状态数组 = 登记状态.split("(");
+            if (等级状态数组[1]) {
+                addInfo.logOffMS = new Date(等级状态数组[1].replace(")", "")).valueOf();
+            }
+            
+            ras = RAS.注销;
+        }
+
+        /** 增补字段 */
+        addInfo.RAS = ras;//登记状态
+        addInfo.legalPerson = 法定代表人;//法人
+        addInfo.zhuceziben = 注册资本;//注册资本
+        addInfo.shijiaoziben = 实缴资本;//实缴资本
+        addInfo.dianHua = 电话;//电话
+        addInfo.gengDuoDianHua = 更多电话;//更多电话
+        addInfo.mail = 邮箱;//邮箱
+        addInfo.moreMail = 更多邮箱;//更多邮箱
+        addInfo.enterpriseType = 企业机构类型;//企业（机构）类型
+        addInfo.zhuCeHao = 注册号;//注册号
+        addInfo.zuZhiJiGouDaiMa = 组织机构代码;//组织机构代码
+        addInfo.canBaoRenShu = 参保人数 == "-" || !参保人数 ? 0: parseInt(参保人数);  //参保人数
+        addInfo.canBaoRenShuNianBao = 参保人数所属年报 == "-" || !参保人数所属年报 ? 0: parseInt(参保人数所属年报);  //参保人数所属年报
+        addInfo.yingYeQiXian = 营业期限;//营业期限
+        switch (企业规模) {
+            case 'XS(微型)':  addInfo.qiYeGuiMo = ENTERPRISESIZE.微型;break;
+            case 'S(小型)':  addInfo.qiYeGuiMo = ENTERPRISESIZE.小型;break;
+            case 'M(中型)':  addInfo.qiYeGuiMo = ENTERPRISESIZE.中型;break;
+            case 'L(大型)':  addInfo.qiYeGuiMo = ENTERPRISESIZE.大型;break;
+            default:  addInfo.qiYeGuiMo = ENTERPRISESIZE.未知;break;
+        }
+        addInfo.guanWang = 官网;//官网
+        addInfo.tongXinDiZhi = 通信地址;//通信地址
+        addInfo.jianJie = 企业简介;//企业简介
+        addInfo.dengJiJiGuan = 登记机关;//登记机关
+        switch (纳税人资质) {
+            case 'XS(微型)':  addInfo.naShuiRenZiZhi = NASHUIRENZIZHI.一般纳税人;break;
+            case '增值税一般纳税人':  addInfo.naShuiRenZiZhi = NASHUIRENZIZHI.增值税一般纳税人;break;
+            case 'M(中型)':  addInfo.naShuiRenZiZhi = NASHUIRENZIZHI.小规模纳税人;break;
+            default:   addInfo.naShuiRenZiZhi = NASHUIRENZIZHI.未知;break;
+        }
+        addInfo.zuiXinNianBaoNianFen = isNaN(最新年报年份) ? 0: parseInt(最新年报年份);  //最新年报年份
+        addInfo.qccIndustry1 = 企查查行业门类;//企查查行业类别1
+        addInfo.qccIndustry2 = 企查查行业大类;//企查查行业类别2
+        addInfo.qccIndustry3 = 企查查行业中类;//企查查行业类别3
+        addInfo.qccIndustry4 = 企查查行业小类;//企查查行业类别4
+        addInfo.isFocus = map[统一社会信用代码] ? true : false;
+        addList.push(addInfo);
+    }
+
+    await initEnterpriseBase(addList);
+
+    console.log("企业数据导入成功");
+}
\ No newline at end of file

src/biz/dataOut.ts

+import { findEnterpriseListByParam } from "../data/enterprise/enterprise";
+
+const xlsx = require('node-xlsx');
+const path = require('path');
+const fs = require('fs');
+
+
+export async function dataOut() {
+    let list = await findEnterpriseListByParam({});
+
+    let dataList = [["企业名称", "统一信用代码"]];
+    list.forEach(info => {
+        let subList = [info.name, info.uscc];
+        dataList.push(subList);
+    });
+
+    let data = [
+        {
+            name:"sheet1",
+            data:dataList
+        }
+    ];
+
+    let buff = xlsx.build(data);
+    fs.writeFileSync(path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", '导出企业0630.xlsx' ), buff);
+    
+    console.log();
+
+}
+

src/biz/dataSync/getQCC.ts

+import * as request from 'request';
+import { BizError } from '../../util/bizError';
+
+
+export function getQcc(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 (body) {
+                if (body.Status == 200) return resolve(body.Result);
+                else if (body.Status == 201) return resolve({});
+            }
+            console.log(body.Message || body);
+            return resolve({});
+        });
+    })
+}
\ No newline at end of file

src/biz/labels.ts

+//标签
+
+
+
+/**
+ * 获取企业标签
+ */
+export async function getEnterpriseLabel() {
+
+}

src/biz/policy.ts

+/**
+ * 政策
+ */
+import moment = require("moment");
+import * as policyData from "../data/policy/policy";
+import * as policyImplementationData from "../data/service/policyImplementation";
+import { eccEnumValue } from "../util/verificationEnum";
+import { DEGREE, ENTERPRISELABEL, IMPLEMENT, POLICYTYPE } from "../config/enum";
+import { eccFormParam } from "../util/verificationParam";
+import { addPolicyImplementConfig } from "../config/paramConfig";
+import { successResult } from "../tools/system";
+import { AnyARecord } from "dns";
+import { findEnterpriseListByParam, findEnterpriseToPageByParam } from "../data/enterprise/enterprise";
+
+/**
+ * 企业基本信息 政策推荐
+ * @param uscc 
+ */
+export async function policyRecommend(uscc:string, degree:number) {
+    let dataList = [];
+
+    let policyList = await policyData.findData({});
+    
+    policyList.forEach(info => {
+        dataList.push({
+            pId:info.pId,
+            title:info.title,
+            endTime:moment(info.endTime).format("YYYY"),
+            matchingDegree:degree || DEGREE.高,
+            subsidy:"返税"
+        });
+    });
+
+    return {dataList};
+}
+
+
+/**
+ * 企业基本信息 政策落实
+ * @param uscc 
+ */
+export async function policyImplement(uscc:string, implement:number) {
+
+    let param:any = {uscc};
+    if (implement == IMPLEMENT.已落实) {
+        param.state = true;
+    } else if (implement == IMPLEMENT.未落实) {
+        param.state = false;
+    }
+
+    let policyList = await policyImplementationData.findData(param);
+    
+    let dataList = [];
+    policyList.forEach(info => {
+        dataList.push({
+            pId:info.pId,
+            policyName:info.policyName,
+            createTime:moment(info.implementTime).format("YYYY"),
+            desc:info.desc,
+            notes:info.notes,
+            state:info.state ? IMPLEMENT.已落实 : IMPLEMENT.未落实
+        });
+    });
+
+    return {dataList};
+}
+
+
+/**
+ * 企业基本信息 添加政策落实
+ * @param uscc 
+ */
+export async function addPolicyImplement(reqUserInfo, uscc:string, param) {
+    let FunName = "添加政策落实";
+    eccFormParam(FunName, addPolicyImplementConfig, param);
+
+    let policyInfo = await policyData.findOnceData({pId:param.pId});
+    
+    param.policyName = policyInfo.title;
+    param.createTime = new Date().valueOf();
+    param.createUser = reqUserInfo.userId;
+    param.uscc = uscc;
+
+    await policyImplementationData.addData(param);
+
+    return successResult();
+}
+
+
+/**
+ * 企业基本信息 政策统计
+ * @param uscc 
+ * @returns 
+ */
+export async function policyImplementStatis(uscc:string) {
+    let policyRecommendCount = 0;//todo
+    let policyMatchingDegree = 0;//政策匹配度
+    let policyImplementCount = await policyImplementationData.findDataCount({uscc});
+
+    return {
+        dataInfo:{
+            policyRecommendCount, policyMatchingDegree, policyImplementCount
+        }
+    };
+}
+
+
+
+
+
+
+/**
+ * 政策速递 列表
+ * @param title 
+ * @param type 
+ * @returns 
+ */
+export async function policyList(title:string, type:number) {
+    console.log(type)
+    const FunName = "政策速递=>列表";
+    eccEnumValue(FunName, "type", POLICYTYPE, type);
+
+    let parma:any = {type};
+    if (title) {
+        parma.title = {"$regex":title};
+    }
+
+    let dbList = await policyData.findData(parma);
+
+    let dataList = [];
+    dbList.forEach(info => {
+        dataList.push({
+            title:info.title,
+            pId:info.pId,
+            source:info.source,
+            createTime:moment(info.createTime).format("YYYY-MM-DD")
+        });
+    });
+
+    return {dataList, dataCount:dataList.length};
+}
+
+
+/**
+ * 政策速递 列表
+ * @param title 
+ * @param type 
+ * @returns 
+ */
+export async function policyInfo(pId:string) {
+    
+    let dbInfo = await policyData.findOnceData({pId});
+
+    let dataInfo = {
+        title:dbInfo.title,
+        content:dbInfo.content,
+        source:dbInfo.source,
+        createTime:moment(dbInfo.createTime).format("YYYY-MM-DD")
+    };
+   
+
+    return { dataInfo };
+}
+
+export async function policyMatchEnterpriseList(pId:string) {
+    
+    let enterpriseList = await findEnterpriseListByParam({labelList:{"$in":[ENTERPRISELABEL.重点企业]}});
+    let dataList = [];
+    enterpriseList.forEach(item => {
+        dataList.push({
+            key:item.name,
+            value:item.uscc
+        });
+    });
+
+    return { dataList };
+}
+
+
+
+
+/**
+ * 企业基本信息 政策落实
+ * @param uscc 
+ */
+export async function policyImplementList(year:number) {
+    let thisYearStartMs = year;
+    let thisYearEndMsMs = moment(year).add(1, "years").valueOf();
+    let param:any = {
+        implementTime:{"$gt":thisYearStartMs,"$lt":thisYearEndMsMs},
+    };
+
+    let policyList = await policyImplementationData.findData(param);
+
+    let countMap = {};
+    policyList.forEach(info => {
+        if (!countMap[info.uscc]) countMap[info.uscc] = {count:0, enterpriseName:info.enterpriseName, dataList:[]}
+        countMap[info.uscc].count += 1;
+        
+        countMap[info.uscc].dataList.push({
+            pId:info.pId,
+            policyName:info.policyName,
+        });
+    });
+
+    let dataList = Object.values(countMap);
+
+    let thisYearCount = await policyImplementationData.findDataCount(param);
+    
+    let thisYearLastMs = moment(year).subtract(1, "years").valueOf();
+    param.implementTime = {"$gt":thisYearLastMs,"$lt":thisYearStartMs};
+    let lastYearCount = await policyImplementationData.findDataCount(param);
+
+    let rate = 0;
+    if (lastYearCount) {
+        rate = Math.ceil((thisYearCount - lastYearCount)/ lastYearCount * 100)
+    }
+
+    thisYearCount = 10;
+    rate = 10;
+    // dataList = [{
+    //     count:0, enterpriseName:"测试企业名称",
+    //     dataList:[
+    //         {
+    //             pId:"test111",
+    //             policyName:"测试测试测试"
+    //         }
+    //     ]
+    // }];
+    return {dataList, thisYearCount, rate};
+}
+
+
+
+/**
+ * 企业基本信息 政策匹配企业
+ * @param uscc 
+ */
+export async function policyMatchList(year:number) {
+    let thisYearStartMs = moment(`${year}-01-01 00:00:00`).valueOf();
+    let thisYearEndMsMs = moment(`${year+1}-01-01 00:00:00`).valueOf();
+    let param:any = {
+        endTime:{"$gte":thisYearStartMs},
+        createTime:{"$lte":thisYearEndMsMs},
+    };
+
+    let policyCount = await policyData.findDataCount(param);
+    let rate = 90;
+
+    let policyList = await policyData.findData(param);
+
+    let dataList= [];
+    for (let i = 0; i < policyList.length; i++) {
+        let info = policyList[i];
+        let itemParam:any = {};
+        if (info.industry) {
+            itemParam.industry = {"$in":[info.industry]}
+        }
+        if (info.label && info.label.length) {
+            itemParam.labelList = {"$in":info.label}
+        }
+        let itemEnterpriseList = await findEnterpriseToPageByParam(itemParam, 1);
+        let matchList =[];
+        itemEnterpriseList.forEach(item => {
+            matchList.push({uscc:item.uscc, enterpriseName:item.name})
+        })
+
+        dataList.push({
+            title:info.title,
+            matchList
+        });
+    }
+
+
+    return {dataList, thisYearCount:policyCount, rate};
+}
\ No newline at end of file

src/biz/service/appeals.ts

+/**
+ * 企业述求
+ */
+
+import { APPEALTYPE, SERVICESTATE, SOLVESTATE, SOLVESTATECLIENT } from "../../config/enum";
+import { ERRORENUM } from "../../config/errorEnum";
+import { AddAppealsConfig } from "../../config/paramConfig";
+import { findEnterpriseByUscc } from "../../data/enterprise/enterprise";
+import { getRandomId, successResult } from "../../tools/system";
+import { BizError } from "../../util/bizError";
+import { changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { eccFormParam } from "../../util/verificationParam";
+import * as appealsData from "../../data/service/appeals";
+import moment = require("moment");
+
+//------------------------------------------------------------------企业页面 的 企业述求
+
+/**
+ * 企业页面 => 企业述求 => 列表 success
+ * @param reqUser
+ * @param param 
+ * @returns 
+ */
+export async function enterpriseAppealList(reqUser, uscc:string) {
+    let enterpriseInfo = await findEnterpriseByUscc(uscc);
+    if (!enterpriseInfo || !enterpriseInfo.uscc) throw new BizError(ERRORENUM.企业不存在);
+
+    let dataList = [];
+    let appealList = await appealsData.selectDataByParam({uscc});
+    appealList.forEach(info => {
+        dataList.push({
+            createTime:moment(info.createTime).format("YYYY-MM-DD HH:mm:SS"),//创建时间
+            appealType:changeEnumValue(APPEALTYPE, info.appealType),//诉求类型  APPEALTYPE
+            appeal:info.appeal,
+            state:changeEnumValue(SOLVESTATECLIENT, info.state) || "未解决"
+        });
+    });
+
+    return {dataList};
+}
+
+/**
+ * 企业页面 => 企业述求 => 添加  success
+ * @param reqUser
+ * @param param 
+ * @returns 
+ */
+export async function addEnterpriseAppeals(reqUser, param) {
+    const FunName = "企业页面=>添加企业述求"
+    eccFormParam(FunName, AddAppealsConfig, param);
+    eccEnumValue(FunName, "appealType", APPEALTYPE, param.appealType);
+    let enterpriseInfo = await findEnterpriseByUscc(param.uscc);
+    if (!enterpriseInfo || !enterpriseInfo.uscc) throw new BizError(ERRORENUM.企业不存在);
+
+    param.appId = getRandomId(param.uscc);
+    param.enterpriseName = enterpriseInfo.name;
+    param.createUserId = reqUser.userId;
+    param.createTime = new Date().valueOf();
+    param.state = SOLVESTATE.未解决;
+
+    await appealsData.createData(param);
+
+    return successResult();
+}
+
+
+//------------------------------------------------------------------首页 的 企业述求
+
+
+/**
+ * 企业述求 => 述求类型列表 success
+ * @param type 
+ * @returns 
+ */
+export async function appealTypeList(type:number) {
+    let param:any = {state:SOLVESTATE.已解决};//已解决参数
+    let oParam:any = {state:SOLVESTATE.未解决};//未解决参数
+    let statisList = [];
+    let solveCount = await appealsData.selectCountByParam(param);
+    let unresolvedCount = await appealsData.selectCountByParam(oParam);
+    if (type == 2) {//已解决
+        statisList = await appealsData.typeStatis(param);
+    } else {
+        statisList = await appealsData.typeStatis(oParam);
+    }
+    let dataList = [];
+    statisList.forEach(info => {
+        dataList.push({
+            key:changeEnumValue(APPEALTYPE, info._id),
+            value:info._id,
+            count:info.count
+        });
+    });
+
+    let countInfo = {solveCount, unresolvedCount};
+
+    return {dataList, countInfo};
+}
+
+/**
+ * 企业述求 => 述求列表 success
+ * @param type 
+ * @returns 
+ */
+export async function appealList(type:number, appealType:number) {
+    const FunName = "述求列表子列表";
+    eccEnumValue(FunName, "appealType", APPEALTYPE, appealType)
+    
+    let param:any = {appealType};
+    param.state = type;
+    
+    let statisList = await appealsData.selectDataByParam(param);
+    let dataList = [];
+    statisList.forEach(info => {
+        let {uscc, enterpriseName} = info;
+        dataList.push({
+            uscc, enterpriseName
+        });
+    });
+
+    return {dataList};
+}
+
+
+/**
+ * 企业述求 => 添加述求
+ * @param reqUser
+ * @param param 
+ * @returns 
+ */
+export async function addAppeals(reqUser, param) {
+    const FunName = "企业述求=>添加企业述求"
+    eccFormParam(FunName, AddAppealsConfig, param);
+    eccEnumValue(FunName, "appealType", APPEALTYPE, param.appealType);
+    let enterpriseInfo = await findEnterpriseByUscc(param.uscc);
+    if (!enterpriseInfo || !enterpriseInfo.uscc) throw new BizError(ERRORENUM.企业不存在);
+
+    param.appId = getRandomId(param.uscc);
+    param.enterpriseName = enterpriseInfo.name;
+    param.createUserId = reqUser.userId;
+    param.createTime = new Date().valueOf();
+
+    await appealsData.createData(param);
+
+    return successResult();
+}
+
+
+/**
+ * 企业述求下拉框
+ * 用于给所有企业服务/领导走访 用的 下拉框
+ * @param param 
+ * @returns 
+ */
+export async function appealsSelect(uscc) {
+    let appealList = await appealsData.selectDataByParam({uscc, state:SERVICESTATE.未解决});
+    let dataList = [];
+    appealList.forEach(info => {
+        dataList.push({
+            key:changeEnumValue(APPEALTYPE, info.appealType),
+            value:info.appId
+        });
+    });
+
+    return {dataList};
+}
\ No newline at end of file

src/biz/service/visit.ts

+/**
+ * 企业服务 主要逻辑
+ */
+import moment = require("moment");
+moment.updateLocale('en', {
+    week: {
+        dow: 0, // 0代表周日，1代表周一，以此类推
+        doy: 6  // 一年的第一天被认为是第6周的第一天（这通常与ISO周数系统对齐，但不是必需的）
+    }
+});
+import { AddSerivceResolveDynamicsConfig, AddVisitConfig } from "../../config/paramConfig";
+import * as visitData from "../../data/service/visit";
+import * as dynamicData from "../../data/service/dynamic";
+import * as enterpriseData from "../../data/enterprise/enterprise";
+import { getRandomId, successResult } from "../../tools/system";
+import { eccFormParam } from "../../util/verificationParam";
+import { changeEnumManyValue, changeEnumValue, eccEnumValue } from "../../util/verificationEnum";
+import { APPEALTYPE, ENTERPRISELABEL, INDUSTRY, REQUESTKEYWORDS, RESEARCHTYPE, SERVERLOGTYPE, SERVICESTATE, SOLUTIONTYPE, SOLVESTATE, SOLVESTATECLIENT, SUBINDUSTRY } from "../../config/enum";
+import { findUserInfoByUserId, findUserMap } from "../../data/user";
+import { findEnterpriseByUscc } from "../../data/enterprise/enterprise";
+import { BizError } from "../../util/bizError";
+import { ERRORENUM } from "../../config/errorEnum";
+import * as appealsData from "../../data/service/appeals";
+
+
+/**================================================================ 企业信息 下的 企业服务 ========================================= */
+
+
+/**
+ * 企业页面 => 企业服务 => 企业服务 => 添加领导走访 success
+ * @param reqUser 
+ * @param param 
+ */
+export async function addVisit(reqUser,  param) {
+    const FunName = "企业服务=>添加走访";
+    eccFormParam(FunName, AddVisitConfig, param);
+    // eccEnumValue(FunName, "researchType", RESEARCHTYPE, param.researchType);
+    // eccEnumValue(FunName, "solutionType", SOLUTIONTYPE, param.solutionType);
+
+    let enterpriseInfo = await enterpriseData.findEnterpriseByUscc(param.uscc);
+    if (!enterpriseInfo || !enterpriseInfo.uscc) throw new BizError(ERRORENUM.企业不存在);
+
+    param.name = enterpriseInfo.name;//关联企业名称
+    param.vId = getRandomId(param.uscc);
+    param.promoterId = reqUser.userId;
+    param.createTime = new Date().valueOf();
+
+    let appealInfo = await appealsData.findData({appId:param.appealType})
+    param.appealTypeEnumId = appealInfo.appealType;
+
+    await visitData.createData(param);
+
+    if (param.state == SERVICESTATE.已解决) {
+        appealInfo.state = SERVICESTATE.已解决;
+        await appealInfo.save();
+    }
+
+    return successResult();
+}
+
+/**
+ * 企业页面 => 企业服务 => 企业服务 => 领导走访 => 添加跟踪记录 success
+ * @param reqUser
+ * @param param 
+ * @returns 
+ */
+export async function addVisitResolveDynamics(reqUser, uscc:string, vId:string, param) {
+    const FunName = "企业服务=>添加跟踪记录"
+    eccFormParam(FunName, AddSerivceResolveDynamicsConfig, param);
+
+    let enterpriseInfo = await findEnterpriseByUscc(uscc);
+
+    param.uscc = uscc;
+    param.vId = vId;
+    param.rId = getRandomId(uscc);
+    param.enterpriseName = enterpriseInfo.name;
+    param.createUserId = reqUser.userId;
+
+    await dynamicData.createData(param);
+
+    let visitInfo = await visitData.selectData({vId});
+
+    if (param.resolutionStatus == visitInfo.state) {
+        visitInfo.state = param.resolutionStatus;
+        await visitInfo.save();
+
+        let appealInfo = await appealsData.findData({appId:visitInfo.appealType})
+        appealInfo.state =  param.resolutionStatus;
+        await appealInfo.save();
+    }
+
+    return successResult();
+}
+
+
+/**
+ * 企业页面 => 企业服务 => 企业服务 => 领导走访 => 修改跟踪记录 success
+ * @param reqUser
+ * @param param 
+ * @returns 
+ */
+export async function updateVisitResolveDynamics(reqUser, rId:string, param) {
+    const FunName = "企业服务=>修改跟踪记录"
+    eccFormParam(FunName, AddSerivceResolveDynamicsConfig, param);
+
+    let dynamicInfo:any = await dynamicData.findData({rId});
+    if (param.tracking) dynamicInfo.tracking = param.tracking;
+    if (param.trackingTime) dynamicInfo.trackingTime = param.trackingTime;
+    if (param.trackingDesc) dynamicInfo.trackingDesc = param.trackingDesc;
+    if (param.resolutionStatus) dynamicInfo.resolutionStatus = param.resolutionStatus;
+
+    await dynamicInfo.save();
+
+    let visitInfo = await visitData.selectData({vId:dynamicInfo.vId});
+    visitInfo.state = param.resolutionStatus;
+    await visitInfo.save();
+
+    let appealInfo = await appealsData.findData({appId:visitInfo.appealType})
+    appealInfo.state =  param.resolutionStatus;
+    await appealInfo.save();
+
+    return successResult();
+}
+
+
+
+/**
+ * 企业服务 服务记录 领导走访
+ * @param appealType 
+ * @param uscc 
+ * @returns 
+ */
+export async function ladelVisitLog(reqUserInfo, state, appealType, uscc:number) {
+    let dataList = [];
+    // eccEnumValue("企业服务 领导走访", "state", SERVICESTATE, state );
+    let param:any= {uscc};
+    if (appealType && appealType.length) {
+        param.appealTypeEnumId = {"$in":appealType};
+    }
+    if (state) {
+        param.state = state;
+    }
+    let dbList = await visitData.findData(param);
+    let userMap = await findUserMap();
+
+    let dynamicList = await dynamicData.selectDataByParam({uscc, vId:{"$ne":null}});
+
+    let dynamicMap = {};
+    dynamicList.forEach(info => {
+        let {vId,  rId, tracking, trackingDesc, trackingTime} = info;
+        if (!dynamicMap[vId]) dynamicMap[vId] = [];
+        dynamicMap[vId].push({
+            rId, 
+            tracking,
+            trackingDesc,
+            trackingTime:moment(trackingTime).format("YYYY-MM-DD HH:mm:SS")
+        });
+    });
+
+
+    //述求map
+    // let appealsList = await appealsData.selectDataByParam({uscc});
+    // let appealsMap = {};
+    // appealsList.forEach(info => {
+    //     appealsMap[info.appId] = info.appealType;
+    // });
+
+    dbList.forEach(info => {
+
+        dataList.push({
+            vId:info.vId,
+            researchTime:moment(info.researchTime).format("YYYY/MM/DD HH:mm:SS"),
+            // leaderId:info.leaderId,
+            leaderName:info.leaderName,
+            desc:info.desc,
+            // researchType:changeEnumValue(RESEARCHTYPE, info.researchType),
+            // appealType:changeEnumValue(APPEALTYPE, info.appealType),
+            researchType:info.researchType,
+            appealType:info.appealTypeEnumId,
+            appeal:info.appeal,
+            solutionType:info.solutionType, //changeEnumValue(SOLUTIONTYPE, info.solutionType),
+            state:info.state, //changeEnumValue(SOLVESTATE, info.state),
+            requestKeywords:changeEnumManyValue(REQUESTKEYWORDS, info.requestKeywords || []), //changeEnumManyValue(REQUESTKEYWORDS, info.requestKeywords),
+            dynamicList:dynamicMap[info.vId] || []
+        });
+    });
+
+    return {dataList}
+}
+
+
+/**
+ * 企业服务 领导走访列表 success
+ * @param appealType 
+ * @param uscc 
+ * @returns 
+ */
+export async function enterpriseLadelVisitLog(reqUser, type:number, page:number) {
+    eccEnumValue("领导走访列表", "type", SERVERLOGTYPE, type);
+    
+    let param:any= {};
+   
+    let startMs = 0;
+    switch(type) {
+        case SERVERLOGTYPE.近三天:
+            startMs = moment().subtract(3, 'day').valueOf();
+        break;
+        case SERVERLOGTYPE.近七天: 
+            startMs = moment().subtract(7, 'day').valueOf();
+        break;
+        case SERVERLOGTYPE.近一个月:
+            startMs = moment().subtract(1, 'month').valueOf();    
+        break;
+        case SERVERLOGTYPE.近一年:
+            startMs = moment().subtract(1, 'year').valueOf();    
+        break;
+    }
+    param.researchTime = {"$gt":startMs};
+
+
+    let userInfo = await findUserInfoByUserId(reqUser.userId);
+    let foolowMap = {};
+    userInfo.followEnterprise.forEach(uscc=> {
+        foolowMap[uscc] = 1;
+    });
+
+    let dbList = await visitData.findDataToPage(param, page);
+
+    let dataList = [];
+    for (let i= 0; i < dbList.length; i++) {
+        let visitInfo = dbList[i];
+        let info = await findEnterpriseByUscc(visitInfo.uscc);
+
+       //标签
+        let labelList = [ {key:changeEnumValue(SUBINDUSTRY, info.privateSubIndustry), value:info.privateSubIndustry, state:true} ];
+        if (info.labelList) {
+            info.labelList.forEach(item => {
+                labelList.push({key:changeEnumValue(ENTERPRISELABEL, item), value:item, state:true});
+            })
+        }
+    
+        dataList.push({
+            uscc:info.uscc,
+            name:info.name,
+            labelList,
+            logonTime:moment(info.logonTime).format("YYYY/MM/DD"),
+            createTime:moment(info.createTime).format("YYYY/MM/DD"),
+            inZJ:"张江域内企业",
+            isFoolow:foolowMap[info.uscc]? true : false
+        });
+
+    }
+
+    return {dataList}
+}
+

src/biz/service/visitPlan.ts

+/**
+ * 走访安排
+ */
+
+import moment = require("moment");
+import * as visitPlanData from "../../data/service/visitPlan";
+import * as visitData from "../../data/service/visit";
+import * as enterpriseData from "../../data/enterprise/enterprise";
+import { findUserMap } from "../../data/user";
+import { eccFormParam } from "../../util/verificationParam";
+import { AddArrangeVisitsConfig } from "../../config/paramConfig";
+import { getRandomId, successResult } from "../../tools/system";
+import { BizError } from "../../util/bizError";
+import { ERRORENUM } from "../../config/errorEnum";
+
+/**
+ * 个人走访安排页 走访安排列表
+ * @param userInfo 
+ * @param dayMs 
+ * @returns 
+ */
+export async function visitCalendarList(userInfo) {
+    //获取本周开始时间到结束时间
+    let startTime = moment().startOf('week').valueOf();
+    let endTime =  moment().endOf('week').valueOf();
+
+    let param = {accompany:{"$in":[userInfo.userId]}, visitTime:{"$gt":startTime, "$lt":endTime}};
+    let visitPlanList = await visitPlanData.findData(param);
+
+    let userMap = await findUserMap();
+
+    let visitMap = {};
+    for (let i = 0; i < visitPlanList.length; i++) {
+        let info = visitPlanList[i];
+
+        let enterpriseItem = await enterpriseData.findEnterpriseByUscc(info.uscc);
+        if (!enterpriseItem || !enterpriseItem.uscc) continue;
+
+        let key = moment(info.visitTime).format("YYYY-MM-DD");
+        let accompany = "";
+        info.accompany.forEach(uId => {
+            accompany += `${userMap[uId]},`
+        });
+        accompany += `${userMap[userInfo.userId]}`;
+
+        if (!visitMap[key]) visitMap[key] = [];
+
+        visitMap[key].push({
+            enterpriseName:enterpriseItem.name,
+            accompany,
+            time:moment(info.visitTime).format("MM-DD-HH-mm")
+        });
+    }
+    let dataList = [];
+    for (let i = 0; i < 7; i++) {
+        let dayStr = moment(startTime).add(i, 'd').format("YYYY-MM-DD");
+        dataList.push({
+            key:dayStr,
+            haveTask:visitMap[dayStr] ? true : false,//是否有红点提示
+            visitList:visitMap[dayStr] || []
+        });
+    }
+
+    return {dataList};
+}
+
+
+/**
+ * 走访安排统计
+ * @param userInfo 
+ * @param year 
+ * @returns 
+ */
+export async function visitPlanStats(userInfo, year:number) {
+    let startYear = moment(`${year}-01-01 00:00:00`).valueOf();
+    let endYear = moment(`${year}-01-01 00:00:00`).add(1, 'y').valueOf();;
+    let lastYear = moment(`${year}-01-01 00:00:00`).subtract(1, 'y').valueOf();
+
+    let param = {
+        visitTime:{"$gt":startYear, "$lt":endYear}, attendee:userInfo.userId
+    };
+    let checkYearPlanCount = await visitPlanData.findDataCount(param);
+    param = {
+        visitTime:{"$gt":lastYear, "$lt":startYear}, attendee:userInfo.userId
+    };
+    let checkLastYearPlanCount = await visitPlanData.findDataCount(param);
+
+    let visitParam = {researchTime:{"$gt":startYear, "$lt":endYear}, accompany:{"$in":userInfo.userId}};
+    let checkYearVisitCount = await visitData.findDataCount(visitParam);
+
+    let yToy = 0;
+    if (checkLastYearPlanCount && checkYearPlanCount) {
+        yToy = ((checkYearPlanCount - checkLastYearPlanCount) / checkLastYearPlanCount * 1000)/100
+    }
+    let dataInfo = {
+        planCount:checkYearPlanCount,
+        yToy,
+        visitCount:checkYearVisitCount,
+        reate:98
+    };
+
+    return {dataInfo};
+}
+
+
+/**
+ * 走访安排 添加
+ * @param userInfo 
+ * @param param 
+ * @returns 
+ */
+export async function addArrangeVisitPlan(userInfo, param) {
+    const FunName = "走访安排=>添加"
+    eccFormParam(FunName, AddArrangeVisitsConfig, param);
+
+    param.attendee = userInfo.userId;//发起人id
+    param.promoterId = userInfo.userId;//发起人名称
+    param.vpId = getRandomId(userInfo.userId);
+    param.createTime = new Date().valueOf();
+
+    let enterpriseInfo = await enterpriseData.findEnterpriseByUscc(param.uscc);
+    if (!enterpriseInfo || !enterpriseInfo.uscc) throw new BizError(ERRORENUM.企业不存在);
+
+    await visitPlanData.createData(param);
+
+    return successResult();
+}
+
+
+
+/**
+ * 走访安排  走访安排列表
+ * @param appealType 
+ * @param uscc 
+ * @returns 
+ */
+export async function userVisitPlanLog(reqUser) {
+    let startTime = moment().startOf('week').valueOf();
+    let endTime = startTime + (3600*1000*24 * 7);
+
+    let startMs = moment().startOf("year").valueOf();
+
+    let param:any= {
+        researchTime:{"$gt":startMs},
+        "$or":[
+            {accompany:{"$in":reqUser.userId}},
+            {attendee:reqUser.userId}
+        ]
+    };
+    let dbList = await visitData.findData(param);
+    let userMap = await findUserMap();
+
+    let visitMap = {};
+    dbList.forEach(info => {
+        let key = moment(info.visitorsTime).format("YYYY-MM-DD");
+        let accompany = "";
+        info.accompany.forEach(uId => {
+            accompany += `${userMap[uId]},`
+        });
+        accompany += `${userMap[reqUser.userId]}`;
+
+        if (!visitMap[key]) visitMap[key] = [];
+
+        visitMap[key].push({
+            enterpriseName:info.name,
+            accompany,
+            time:moment(info.visitTime).format("MM-DD-HH-mm")
+        });
+    })
+
+    let dataList = [];
+    for (let i = 0; i < 7; i++) {
+        let dayStr = moment(startTime + (i * 3600*1000
+            *24) ).format("YYYY-MM-DD");
+        dataList.push({
+            key:dayStr,
+            haveTask:visitMap[dayStr] ? true : false,//是否有红点提示
+            visitList:visitMap[dayStr] || []
+        });
+    }
+
+    return {dataList};
+}
\ No newline at end of file

src/biz/user.ts

+/**
+ * 用户
+ */
+
+import { RAS, SOLVESTATE, STATE, USERTYPE } from "../config/enum";
+import { ERRORENUM } from "../config/errorEnum";
+import { findEnterpriseCountByParam, statisIndustryEnterprise } from "../data/enterprise/enterprise";
+import * as visitData from "../data/service/visit";
+import * as visitPlanData from "../data/service/visitPlan"
+import { findUserInfoByLoginId, findUserInfoByUserId } from "../data/user";
+import { getPwdMd5, getToken, successResult } from "../tools/system";
+import { BizError } from "../util/bizError";
+
+
+/**
+ * 企业管家登录
+ * @param loginId 
+ * @param pwd 
+ * @returns 
+ */
+export async function userLogin(loginId:string, pwd:string) {
+    let userInfo:any = await findUserInfoByLoginId(loginId);
+    if (!userInfo || !userInfo.userId) throw new BizError(ERRORENUM.账号不存在, loginId);
+
+    let checkPwd = getPwdMd5(loginId, pwd); 
+    if (userInfo.pwd != checkPwd) throw new BizError(ERRORENUM.密码错误);
+
+    let token = getToken(loginId);
+    
+    let resultUserInfo = {
+        loginId:userInfo.loginId,
+        name: userInfo.name,
+        userId:userInfo.userId,
+        token:token,
+    };
+
+    userInfo.token = token;
+    userInfo.tokenMs = new Date().valueOf();
+
+    await userInfo.save();
+    
+    return {dataInfo:resultUserInfo};
+}
+
+
+
+/**
+ * 企业管家登出
+ * @param userInfo 
+ */
+export async function userLogout(reqUserInfo) {
+    let userInfo = await findUserInfoByUserId(reqUserInfo.userId);
+
+    userInfo.token = getToken(userInfo.loginId);
+    userInfo.tokenMs = new Date().valueOf();
+
+    await userInfo.save();
+
+    return successResult(); 
+}
+
+
+/**
+ * 管理后台用户登录
+ */
+export async function adminUserLogin(loginId:string, pwd:string) {
+    let userInfo:any = await findUserInfoByLoginId(loginId);
+    if (!userInfo || !userInfo.userId) throw new BizError(ERRORENUM.账号不存在, loginId);
+
+    let checkPwd = getPwdMd5(loginId, pwd); 
+    if (userInfo.pwd != checkPwd) throw new BizError(ERRORENUM.密码错误);
+
+    let token = getToken(loginId);
+    
+    let resultUserInfo = {
+        loginId:userInfo.loginId,
+        name: userInfo.name,
+        userId:userInfo.userId,
+        token:token,
+    };
+
+    userInfo.adminToken = token;
+    userInfo.adminTokenMs = new Date().valueOf();
+
+    await userInfo.save();
+    
+    return {dataInfo:resultUserInfo};
+}
+
+/**
+ * 管理后台用户登出
+ */
+export async function adminUserLogout(reqUserInfo) {
+    let userInfo = await findUserInfoByUserId(reqUserInfo.userId);
+
+    userInfo.adminToken = getToken(userInfo.loginId);
+    userInfo.adminTokenMs = new Date().valueOf();
+
+    await userInfo.save();
+
+    return successResult(); 
+}
+
+
+
+
+/**
+ * 首页
+ * @param userInfo 
+ * @returns 
+ */
+export async function homePage(userInfo) {
+    let param = {
+        visitTime:{"$gt":new Date().valueOf()},//待解决
+    };
+    let visitCount = await visitPlanData.findDataCount(param);
+
+    let enterpriseCount = await findEnterpriseCountByParam({});
+    let industryCount = await statisIndustryEnterprise();
+
+    return {dataInfo:{visitCount, enterpriseCount, industryCount}};
+}
+
+
+/**
+ * 首页 顶部
+ * @param userInfo 
+ * @returns 
+ */
+export async function homePageTop(userInfo) {
+   
+    let title = "张江镇";
+    if (userInfo.userType == USERTYPE.管家) title+"企业管家";
+    else  title+"领导";
+
+    return {dataInfo:{
+        name:userInfo.name,
+        title
+    }};
+}
+

src/config/enum.ts

+/**
+ * 行业领域
+ */
+export enum INDUSTRY{
+    生物医药 = 1,
+    医疗科技 = 2,
+    软件和信息服务业,
+    人工智能,
+    集成电路,
+    新材料,
+    制造业,
+    汽车产业,
+    航空航天,
+    文化创意,
+    物流及仓储,
+    综合,
+    其他 = 14
+}
+
+export enum SUBINDUSTRY {
+    生物医药 = 1,
+    医疗科技 = 2,
+    软件和信息服务业,
+    人工智能,
+    集成电路,
+    新材料,
+    制造业,
+    汽车产业,
+    航空航天,
+    文化创意,
+    物流及仓储,
+    综合,
+    其他 = 14,
+    医药商业 = 101,
+    医疗服务,
+    医疗器械制造,
+    其他生物医药,
+    轻工制造 = 701,
+    发电设备制造,
+    电网设备制造,
+    船舶制造,
+    化学制造,
+    环保设备制造,
+    橡胶制品制造,
+    通用设备制造,
+    专用设备制造,
+    橡胶和塑料制品业,
+    建筑材料制造,
+    其他制造,
+    汽车服务 = 1301,
+    道路运输,
+    水上运输,
+    其他交通运输,
+    农林牧渔业,
+    环境保护服务,
+    专业服务业,
+    建筑工程,
+    能源,
+    科学研究和技术服务业,
+    金融业,
+    综合其他,
+    店铺 = 1401,
+    药房,
+    棋牌室,
+    宾馆酒店,
+    饭店,
+    学校,
+    人力资源,
+    养老院,
+    物业管理,
+    房地产开发租赁销售,
+    医疗机构,
+    其他服务业,
+    修理厂,
+    食品加工,
+    公共事业,
+}
+/**
+ * 制造业
+ */
+export enum MANUFACTURING {
+    轻工制造 = 701,
+    发电设备制造,
+    电网设备制造,
+    船舶制造,
+    化学制造,
+    环保设备制造,
+    橡胶制品制造,
+    通用设备制造,
+    专用设备制造,
+    橡胶和塑料制品业,
+    建筑材料制造,
+    其他制造
+} 
+
+export enum MEDICALSUB {
+    医药商业 = 101,
+    医疗服务,
+    医疗器械制造,
+    其他生物医药
+}
+
+export enum OTHERINDUSTRY{
+    店铺 = 1401,
+    药房,
+    棋牌室,
+    宾馆酒店,
+    饭店,
+    学校,
+    人力资源,
+    养老院,
+    物业管理,
+    房地产开发租赁销售,
+    医疗机构,
+    其他服务业,
+    修理厂,
+    食品加工,
+    公共事业,
+}
+
+export enum COMPREHENSIVE {
+    汽车服务 = 1301,
+    道路运输,
+    水上运输,
+    其他交通运输,
+    农林牧渔业,
+    环境保护服务,
+    专业服务业,
+    建筑工程,
+    能源,
+    科学研究和技术服务业,
+    金融业,
+    综合其他
+}
+
+/**
+ * 解决状态
+ */
+export enum SOLVESTATE {
+    未解决 = 1,
+    已解决
+}
+
+/**
+ * 解决状态
+ */
+export enum SOLVESTATECLIENT {
+    未解决 = 1,
+    已解决
+}
+
+/**
+ * 述求类型
+ */
+export enum APPEALTYPE {
+    场地需求 = 1,
+    政策申请需求,
+    融资需求,
+    人才需求,
+    财政补贴需求
+}
+
+
+/**
+ * 活动
+ */
+export enum ACTIVITYTYPECLIENT {
+    本周新发布 = 0,
+    // 本周新发布 = 1,
+    重大活动 =1,
+    交流活动,
+    公益活动
+}
+
+
+/**
+ * 活动
+ */
+export enum ACTIVITYTYPESTATISCLIENT {
+    全部 = 0,
+    本周新发布,
+    重大活动,
+    交流活动,
+    公益活动
+}
+
+
+/**
+ * 政策类型
+ */
+export enum POLICYTYPE {
+    // 小微企业 = 1,
+    // 产业补助,
+    // 人才引进,
+    // 税收补贴,
+    // 政策减免
+    人才政策 = 1,
+    戴帽政策,
+    产业政策
+}
+
+/**
+ * 补贴类型
+ */
+export enum SUBSIDYTYPE {
+    财政支持 = 1, 
+}
+
+/**
+ * 状态
+ */
+export enum STATE {
+    否 = 0,
+    是
+}
+
+export enum RAS {
+    续存 = 1,
+    注销 = 2
+}
+
+/**
+ * 企业变化统计类型
+ */
+export enum ENTERPRISECHANGETYPE {
+    新增 = 1,
+    注销 = 2
+}
+
+/**
+ *调研类型
+ */
+export enum RESEARCHTYPE {
+    实地走访 = 1
+}
+
+/**
+ * 解决方式
+ */
+export enum SOLUTIONTYPE {
+    线上解决 = 1,
+    帮助申报,
+    线下解决,
+    企业管家跟踪
+} 
+
+/**
+ * 关键词
+ */
+export enum REQUESTKEYWORDS {
+    团队扩张 = 1,
+    团队缩减,
+    急需融资,
+    有投资意愿,
+    场地出租,
+    新得融资,
+    外地投资
+}
+
+
+
+export enum USERTYPE {
+    管家 = 1,
+    领导
+}
+
+/**
+ * 纳税人资质
+ */
+export enum NASHUIRENZIZHI {
+    未知 = 0,
+    小规模纳税人,
+    一般纳税人,
+    增值税一般纳税人
+}
+
+export enum ENTERPRISESIZE {
+    未知 = 0,
+    大型,
+    中型,
+    小型,
+    微型
+}
+
+
+/**
+ * 日常服务状态
+ */
+export enum SERVICESTATE {
+    未解决 = 1,
+    已解决
+}
+
+export enum ENTERPRISECATEGORY {
+    有限责任公司 = 1,
+    股份有限公司,
+    个人独资企业,
+    合伙企业,
+    全民所有制企业,
+    集体所有制企业,
+    私营企业,
+    股份制企业,
+    联营企业,
+    外商投资企业,
+    农民专业合作社,
+    港澳台投资企业
+} 
+
+export enum DEGREE {
+    高 = 1,
+    中 = 2,
+    低
+}
+
+export enum IMPLEMENT {
+    未落实 = 1,
+    已落实
+}
+
+export enum IMPLEMENTCLIENT {
+    全部 = 0,
+    未落实 = 1,
+    已落实
+}
+
+
+/**
+ * 标签 企业属性
+ */
+export enum ENTERPRISELABEL {
+    重点企业 = 1,
+    科技创新,
+    专精特新,
+    科技小巨人,
+    小微企业,
+    融资企业,
+    科技型中小企业,
+    高新技术,
+    对外投资,
+    外资企业,
+    企业研发机构,
+    户管企业,
+    规上企业,
+    投促重点,
+    已注销,
+    科技小巨人培育
+}
+
+export enum SERVERLOGTYPE {
+    近一年 = 1,
+    近一个月,
+    近七天,
+    近三天,
+}
+
+export enum ACTIVITYSTATUS {
+    路演活动 = 1,
+    会议活动,
+    企业家座谈会,
+    商会活动,
+    重大活动
+}
+
+export enum OPERATIONTYPE {
+    税收 = 1,
+    财政收入,
+    固定资产投入
+}
+
+
+export enum ENTERPRISETYPE {
+    民营企业 = 1,
+    国有企业,
+    港澳台投资企业,
+    外商投资企业,
+    企事业单位,
+    事业单位,
+    社会组织,
+    机关单位,
+    民办非企业单位,
+    其他,
+}
+
+
+export enum WARNTYPE {
+    经营风险 = 1,
+    法律诉讼,
+    其他风险
+}

src/config/errorEnum.ts

+
+export enum ERRORENUM {
+    未找到数据,
+    参数错误,
+    企业不存在,
+    已关注,
+    已取消,
+    活动不存在,
+    账号不存在,
+    密码错误,
+    地址数据不完整,
+    请完善信息,
+    非法登录,
+    身份验证过期,
+    身份验证失败,
+    文件上传失败,
+    只能上传png或jpg图片,
+    政策不存在,
+    政策落实不存在,
+    本年度数据已存在
+}
+
+
+export enum ERRORCODEENUM {
+    身份验证失败 = 401,
+    非法登录 = 402,
+    身份验证过期 = 403,
+    code无效 = 40029,
+    频繁操作请稍后再试 = 45011,
+    高风险等级用户 = 40226,
+    系统繁忙 = 40227
+}
+
+let bizErrorMsgMap = {};
+for (let key in ERRORENUM) {
+    bizErrorMsgMap[ERRORENUM[key]] = key;
+}
+
+export function getBizMsg(param) {
+    return bizErrorMsgMap[param];
+}
\ No newline at end of file

src/config/serverConfig.ts

+const path = require('path');
+import * as fs from "fs";
+import { BizError } from "../util/bizError";
+import { analysisXml } from "../util/myXML";
+import { ServerConfig } from "../config/systemClass";
+const os = require('os');
+
+export let systemConfig =  new ServerConfig;
+
+const ConfigName = "serverConfig.xml";
+export async function initConfig() {
+    try {
+        let buff = fs.readFileSync(path.join(__dirname.substring(0,__dirname.indexOf("out")), ConfigName));
+        let configStr = buff.toString();
+        let configInfo:any = await analysisXml(configStr);
+		if (!configInfo || !configInfo.config) throw new BizError('xml中无配置');
+		else {
+            
+            let {port, mongodb, secret, getOpenIdUrl, appId, qcc } = configInfo.config;
+            systemConfig.port = parseInt(port[0]);
+
+            systemConfig.secret = secret[0];
+            systemConfig.getOpenIdUrl = getOpenIdUrl[0];
+            systemConfig.appId = appId[0];
+
+            const MongoPath = mongodb[0].path[0];
+            const MongoPort = mongodb[0].port[0];
+            const MongoW = mongodb[0].w[0];
+            const MongoDataBase = mongodb[0].dataBase[0];
+            const MongoWtimeoutMS = mongodb[0].wtimeoutMS[0];
+            systemConfig.mongodbStr = analysisMongoConnectStr( MongoPath, MongoPort, MongoDataBase, MongoW, MongoWtimeoutMS);
+
+            systemConfig.qccKey  = qcc[0].key[0];
+            systemConfig.qccSecretKey  = qcc[0].SecretKey[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}`
+}
\ No newline at end of file

src/config/systemClass.ts

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

src/data/enterprise/businessdata.ts

+/**
+ * 企业经营数据 数据层
+ * 
+ */
+
+import {Schema} from 'mongoose';
+import { baseDB } from '../../db/mongo/dbInit';
+
+const enterpriseBusinesSchema = new Schema({
+    year:{type:Number, index:true},//年度
+    // quarter:{type:Number, index:true},//季度
+    uscc:{type:String, index:true},//关联企业
+    name:{type:String, index:true},//企业名称
+    industry:[Number],//领域 冗余
+    BI:{type:Number, default:0},//营业收入
+    RD:{type:Number, default:0},//研发投入
+    TXP:{type:Number, default:0},//纳税
+    // tax:{type:Number, default:0},//税收
+    // revenue:{type:Number, default:0},//财政收入
+    // FAI:{type:Number, default:0},//固定资产投入
+    startTimeMs:Number,//开始时间
+    endTimeMs:Number,//结束时间
+    createTime:Number,//填写时间
+    
+});
+
+var enterpriseBusinesModel;
+export function initModel(){
+    enterpriseBusinesModel = baseDB.model('enterpriseBusiness', enterpriseBusinesSchema);
+    enterpriseBusinesModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await enterpriseBusinesModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+/**
+ * 添加多个数据
+ * @param addList 
+ */
+export async function addManyBusinessData(addList) {
+    await enterpriseBusinesModel.insertMany(addList);
+}
+
+export async function findOnceBusinessDataByParam(param) {
+    return await enterpriseBusinesModel.selectOnceData(param);
+}
+
+export async function deleteOnceBusinessDataByParam(param) {
+    return await enterpriseBusinesModel.deleteOne(param);
+}
+
+
+/**
+ * 获取特定企业某年度的经营数据
+ * @param uscc 企业统一信用代码
+ * @param year 年度
+ */
+export async function findBusinessDataByParam(param) {
+    return await enterpriseBusinesModel.find(param);
+}
+
+export async function findEnterpriseBusinessToPageByParam(param, pageNumber) {
+    return await enterpriseBusinesModel.find(param).skip((pageNumber-1)*10).limit(10);
+}
+
+export async function findEnterpriseBusinessCountByParam(param) {
+    return await enterpriseBusinesModel.find(param).countDocuments()
+}
+
+export async function statisBusinessDataByParam(param) {
+    let statisList = await enterpriseBusinesModel.aggregate([
+        {"$match":param},
+        {"$group":{
+            _id:"year", 
+            BICount:{"$sum":"$BI"}, 
+            RDCount:{"$sum":"$RD"}, 
+            TXPCount:{"$sum":"$TXP"}
+        }}
+    ]);
+
+    let statisInfo = statisList[0];
+    return {
+        BICount:statisInfo.BICount || 0,
+        RDCount:statisInfo.RDCount || 0, 
+        TXPCount:statisInfo.TXPCount || 0
+    }
+}
\ No newline at end of file

src/data/enterprise/enterprise.ts

+/**
+ * 企业信息表
+ * draftLock 草稿锁 当任务提交的时候，将此字段改为true
+ */
+
+import {Schema} from 'mongoose';
+import { baseDB } from '../../db/mongo/dbInit';
+import { RAS } from '../../config/enum';
+
+/**
+ * 创始团队  
+ */
+const initialTeamSchema = new Schema({
+    type:Number,//创始团队人才类型
+    memberName:String,//成员姓名
+    memberSex:Number,//成员性别
+    memberAge:Number,//成员年龄  出生年月时间戳
+    memberDEGREE:Number,//成员最高学历
+    memberSchool:String,//毕业学校
+    des:String,//履历描述
+},{_id:false});
+
+/**
+ * 企业资质
+ */
+const qualificationSchema = new Schema({
+    isHighTech:Boolean,
+    highTechMs:Number,//高新技术
+    isZjtx:Boolean,
+    zjtxMs:Number,//专精特新
+    isXjrpy:Boolean,
+    xjrpyMs:Number,//小巨人培育
+    isXjr:Boolean,
+    xjrMs:Number,//小巨人
+    beOnTheMarket:[Number],//上市情况
+    isBeOnTheMarket:{type:Boolean, default:false}//是否上市
+}, {_id:false});
+
+/**
+ * 专利
+ */
+const intellectualPropertySchema = new Schema({
+    alienPatent:Number,//海外专利
+    classIPatent:Number,//一类专利
+    secondClassPatent:Number,//二类专利
+}, {_id:false});
+
+/**
+ * 主要人员
+ */
+const employeesSchema = new Schema({
+    job:String,//职务
+    name:String,//姓名
+}, {_id:false});
+
+/**
+ * 行业领域
+ */
+const industrySchema = new Schema({
+    industryCode:String,//行业门类code
+    industry:String,//行业门类描述
+    subIndustryCode:String,//行业大类code
+    subIndustry:String,//行业大类描述
+    middleCategoryCode:String,//行业中类code
+    middleCategory:String,//行业中类描述
+    smallCategoryCode:String,//行业小类code
+    smallCategory:String,//行业小类描述
+}, {_id:false});
+
+/**
+ * 股权结构
+ */
+const ownershipSchema = new Schema({
+    name:String, //名称
+    finalBenefitPercent:Number, //最终受益股份
+    stockPercent:Number, //持股比例
+    stockType:String, //投资人类型
+    realCapi:Number, //实缴出资额
+    paidUpCapitalUnit:String, //实缴出资额单位
+    capiDate:Number, //实缴时间
+    subscribedCapital:Number, //认缴出资额数额
+    subscribedCapitalUnit:String, //认缴出资额单位
+    shoudDate:Number, //认缴出资时间
+}, {_id:false});
+
+/**
+ * 科创分
+ */
+const stemSchema = new Schema({
+    industry:String, //一级行业
+    subIndustry:String, //二级行业
+    industryRanking:Number, //行业位置，百分比（在同行中处于前多少）
+    score:Number, //分数
+},{_id:false});
+
+
+
+/**
+ * 标签
+ */
+const enterpriseLabelSchema = new Schema({
+    labelId:String,
+    state:{type:Boolean, default:true},//状态 false表示标签失效
+},{_id:false});
+
+const enterpriseSchema = new Schema({
+    uscc:{type:String, index: true},//统一信用代码
+    name:{type:String, index: true},//企业名称
+    isFocus:{type:Boolean, default: false},//是否重点企业
+    // enterpriseCategory:{type:Number},//企业（机构）类型 弃用
+    logonTime:Number,//注册时间
+    settledTime:Number,//入驻时间
+    timeOfImmigration:Number,//迁入时间
+    privateIndustry:Number,//领域 （清洗后）
+    privateSubIndustry:Number,//子领域 （清洗后）
+    qccindustry1:String,//企查查行业类别1
+    qccIndustry2:String,//企查查行业类别2
+    qccIndustry3:String,//企查查行业类别3
+    qccIndustry4:String,//企查查行业类别4
+    RAS:{type:Number, index:true},//登记状态
+    logOffMS:{type:Number},//注销时间
+    legalPerson:String,//法人
+    shijiaoziben:{type:String, default:'-'},//实缴资本
+    zhuceziben:{type:String, default:'-'},//注册资本
+    dianHua:String,//电话
+    gengDuoDianHua:{type:String},//更多电话
+    mail:{type:String, default:'-'},//邮箱
+    moreMail:{type:String, default:'-'},//更多邮箱
+    enterpriseType:{type:Number, index:true},//企业（机构）类型
+    zhuCeHao:String,//注册号 
+    zuZhiJiGouDaiMa:String,//组织机构代码
+    canBaoRenShu:Number,//参保人数
+    canBaoRenShuNianBao:Number,//参保人数所属年报
+    yingYeQiXian:String,//营业期限
+    qiYeGuiMo:{type:Number, index:true},//企业规模
+    guanWang:String,//官网
+    tongXinDiZhi:String,//通信地址
+    jianJie:String,//企业简介
+    dengJiJiGuan:String,//登记机关
+    naShuiRenZiZhi:Number,//纳税人资质
+    zuiXinNianBaoNianFen:Number,//最新年报年份
+    isNaturalPersonHolding:{type:Boolean, default:true},//是否自然人控股企业
+    mainBusiness:{type:String, default:""},//主营业务
+    logonAddress:{type:[String], default:[]},//注册地址
+    operatingAddress:{type:[String], default:[]},//经营地址
+    inZJ:{type:Boolean, default:true},//是否在张江 默认=true
+
+    inZJTime:{type:Number},//入驻张江时间
+    inZJPark:String,//入驻园区
+    leasedArea:Number,//租赁面积（平方米）
+
+    contacts:String,//联系人
+    contactsPhone:String,//联系人手机号
+
+    //经纬度
+    lng:String,//经度
+    lat:String,//纬度
+    //系统
+    createTime:Number,//录入时间
+    createUserId:String,//创建人 关联
+    //子表
+    initialTeam:{type:[initialTeamSchema], default:[]},//创始团队  无使用场景
+    labels:{type:[enterpriseLabelSchema], default:[]},//标签系统 弃用
+    qualification:{type:qualificationSchema},//企业资质  资质证书
+    intellectualProperty:{type:intellectualPropertySchema},//专利  无使用场景
+    labelList:{type:[Number], default:[]},//标签列表 参考枚举标签
+    ownership:{type:[ownershipSchema], default:[]},//股权结构
+    industry:{type:industrySchema},//行业信息分类
+    employees:{type:[employeesSchema], default:[]},//主要人员
+    stem:{type:stemSchema, default:{}}//科创分
+    
+});
+
+var enterpriseModel;
+export function initModel(){
+    enterpriseModel = baseDB.model('enterprise', enterpriseSchema);
+    enterpriseModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await enterpriseModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+
+/**
+ * 创建新的企业数据
+ * @param param 添加的字段对象
+ */
+export async function createEnterpriseBase(param) {
+    param.createTime = new Date().valueOf();
+    await enterpriseModel.create(param);
+}
+
+
+/**
+ * 创建新的企业数据
+ * @param param 添加的字段对象
+ */
+export async function initEnterpriseBase(list) {
+    await enterpriseModel.insertMany(list);
+}
+
+
+
+/**
+ */
+export async function findEnterpriseListByParam(param) {
+    return await enterpriseModel.find(param);
+}
+
+export async function findEnterpriseToPageByParam(param, skipCount) {
+    return await enterpriseModel.find(param).skip((skipCount-1)*10).limit(10);
+}
+
+
+/**
+ */
+export async function findEnterpriseCountByParam(param) {
+    return await enterpriseModel.find(param).countDocuments();
+}
+
+
+/**
+ * 通过企业统一信用代码获取企业信息
+ * 支持.save方法保存对象修改
+ * @param uscc 企业统一信用代码
+ * @returns {}
+ */
+export async function findEnterpriseByUscc(uscc:string) {
+    return await enterpriseModel.selectOnceData({uscc});
+}
+
+export async function findEnterpriseByName(name:string) {
+    return await enterpriseModel.selectOnceData({name});
+}
+
+export async function statisIndustryEnterprise() {
+    let statisList = await enterpriseModel.aggregate([
+        {"$match":{RAS:RAS.续存}},
+        {"$group":{_id:"$privateIndustry", count:{"$sum":1} }}
+    ]);
+    return statisList.length;
+}
+
+export async function statisCanBaoEnterprise() {
+    let statisList = await enterpriseModel.aggregate([
+        {"$match":{RAS:RAS.续存}},
+        {"$group":{_id:"1", count:{"$sum":"$canBaoRenShu"} }}
+    ]);
+    return statisList[0].count;
+}
+
+export async function statisIndustryTypeEnterprise() {
+    let statisList = await enterpriseModel.aggregate([
+        {"$match":{RAS:RAS.续存}},
+        {"$group":{_id:"$privateIndustry", count:{"$sum":1} }}
+    ]);
+    return statisList;
+}
\ No newline at end of file

src/data/label.ts

+/**
+ * 标签系统
+ */
+
+
+import {Schema} from 'mongoose';
+import { baseDB } from '../db/mongo/dbInit';
+
+
+const labelSchema = new Schema({
+    id:{type:String, index:true},//标识
+    labelName:String,
+    ctMs:Number,//创建时间
+    labelType:Number,//标签类型 LABELTYPE 系统标签不可以删除
+    state:{type:Boolean, default:true}//是否停用 false表示已停用
+});
+
+
+var labelModel;
+export function initModel(){
+    labelModel = baseDB.model('label', labelSchema);
+    labelModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await labelModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+export async function createLabel(labelType:number, name:string, id:string) {
+    let addInfo = { id, labelType, labelName:name, ctMs:new Date().valueOf(), state:false, isDelete:false };
+    return await labelModel.create(addInfo);
+}
+
+export async function findOnceLabel(id:string) {
+    return await labelModel.selectOnceData({id});
+}
+
+export async function selectLabelList(param) {
+    return await labelModel.find(param);
+}
+
+export async function selectLabelListToPage(param, skipNumber) {
+    return await labelModel.find(param).skip(skipNumber).limit(10);
+}
+
+export async function selectLabelCount(param) {
+    return await labelModel.find(param).countDocuments();
+}
+
+export async function addSystemLabel(labels) {
+    await labelModel.insertMany(labels);
+}
+
+export async function delLabel(id) {
+    return await labelModel.deleteOne({id});
+}
+
+
+/**
+ * 获取标签名称与标签类型map
+ * @returns 
+ */
+export async function getEffectiveLabelMap() {
+    let list = await labelModel.find({state:true});
+    let map = {};
+    list.forEach( info => {
+        let {id, labelName, labelType} = info;
+        map[id] = {labelName, labelType};
+    });
+    return map;
+}
+
+
+/**
+ * 获取标签名称与状态map
+ * @returns 
+ */
+export async function getLabelNamMap() {
+    let list = await labelModel.find({});
+    let nameMap = {};
+    list.forEach(info => {
+        let {id, labelName, state} = info;
+        nameMap[id] = {labelName, state};
+    });
+
+    return nameMap;
+}
\ No newline at end of file

src/data/log/enterpriseLabelLog.ts

+/**
+ * 企业标签
+ */
+
+
+import {Schema} from 'mongoose';
+import { baseDB } from '../../db/mongo/dbInit';
+
+
+const enterpriseLabelLogSchema = new Schema({
+    uscc:{type:String, index:true},//企业
+    labelId:String,//标签id
+    road:Number,//途径
+    createTime:Number,//创建时间
+    desc:String//描述
+});
+
+
+var enterpriseLabelLogModel;
+export function initModel(){
+    enterpriseLabelLogModel = baseDB.model('enterpriseLabelLog', enterpriseLabelLogSchema);
+    enterpriseLabelLogModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await enterpriseLabelLogModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+
+export async function addManyLabelLog(addList:object) {
+    await enterpriseLabelLogModel.insertMany(addList);
+}
+
+export async function addOnceLabelLog(uscc:string, labelId:string, road:number, desc:string) {
+    await enterpriseLabelLogModel.create({uscc, labelId, road, desc, ct:new Date().valueOf() });
+}
+
+export async function findLabelLogByParam(param) {
+    return await enterpriseLabelLogModel.find(param);
+}
\ No newline at end of file

src/data/log/enterpriseLog.ts

+/**
+ * 企业变化 数据层
+ * 
+ */
+
+import {Schema} from 'mongoose';
+import { baseDB } from '../../db/mongo/dbInit';
+
+const enterpriseChangeSchema = new Schema({
+    year:{type:Number, index:true},//年度
+    month:{type:Number},//月度
+    type:{type:Number},//类型 参考枚举 ENTERPRISECHANGETYPE
+    count:{type:Number},
+    createTime:{type:Number},//添加时间
+});
+
+var enterpriseChangeModel;
+export function initModel(){
+    enterpriseChangeModel = baseDB.model('enterpriseChange', enterpriseChangeSchema);
+    enterpriseChangeModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await enterpriseChangeModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+
+export async function findDataByParam(param) {
+    return await enterpriseChangeModel.find(param);
+}
+

src/data/overallOperation.ts

+/**
+ * 标签系统
+ */
+
+
+import {Schema} from 'mongoose';
+import { baseDB } from '../db/mongo/dbInit';
+
+
+const overallOperationSchema = new Schema({
+    id:{type:String, index:true},//标识
+    year:{type:Number},
+    operationType:{type:Number},//类型 枚举 OPERATIONTYPE
+    count:Number,
+    1:{type:Number},//1月
+    2:{type:Number},//2月
+    3:{type:Number},//3月
+    4:{type:Number},//4月
+    5:{type:Number},//5月
+    6:{type:Number},//6月
+    7:{type:Number},//7月
+    8:{type:Number},//8月
+    9:{type:Number},//9月
+    10:{type:Number},//10月
+    11:{type:Number},//11月
+    12:{type:Number},//12月
+    ct:Number
+});
+
+
+var overallOperationModel;
+export function initModel(){
+    overallOperationModel = baseDB.model('overalloperation', overallOperationSchema);
+    overallOperationModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await overallOperationModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+export async function findData(param) {
+    return await overallOperationModel.selectOnceData(param);
+}
+
+export async function createData(param) {
+    await overallOperationModel.create(param);
+}
+
+
+export async function selectCountByParam(param) {
+    return await overallOperationModel.find(param).countDocuments();
+}
+
+
+export async function selectDataByParam(param) {
+    return await overallOperationModel.find(param);
+}
+
+export async function typeStatis(param) {
+    let statsList = await overallOperationModel.aggregate([
+        {"$match":param},
+        {"$group":{_id:"$appealType", count:{"$sum":1}} }
+    ]);
+    return statsList;
+}

src/data/policy/activity.ts

+/**
+ * 企业活动
+ */
+import {Schema} from 'mongoose';
+import { baseDB } from '../../db/mongo/dbInit';
+
+const activitySchema = new Schema({
+    aId:{type:String, index: true},//政策id
+    title:String,//标题
+    content:String,//内容
+    type:Number,//类型
+    startTime:{type:Number, index: true},//开始时间
+    endTime:{type:Number, index: true},//结束时间
+    location:String,//位置
+    img:String,//图片
+    releaseTime:Number,//发布时间
+    createTime:Number,//创建时间
+    createUser:String,//创建人
+});
+
+var activityModel;
+export function initModel(){
+    activityModel = baseDB.model('activity', activitySchema);
+    activityModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await activityModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+
+export async function findActivityList(param) {
+    return await activityModel.find(param);
+}
+
+export async function findActivityListPage(param, page) {
+    return await activityModel.find(param).skip((page-1)*10).limit(10);;
+}
+
+export async function findActivityCount(param) {
+    return await activityModel.find(param).countDocuments();
+}
+
+export async function findOnceActivity(param) {
+    return await activityModel.selectOnceData(param)
+}
+
+export async function addActivity(param) {
+    return await activityModel.create(param);
+}
+
+export async function deleteOneActivity(param) {
+    return await activityModel.deleteOne(param);
+}

src/data/policy/policy.ts

+/**
+ * 政策
+ */
+import {Schema} from 'mongoose';
+import { baseDB } from '../../db/mongo/dbInit';
+
+const policySchema = new Schema({
+    pId:{type:String, index: true},//政策id
+    title:{type:String, index:true},//标题
+    content:String,//内容
+    source:String,//来源
+    type:{type:Number},//类型 POLICYTYPE
+    subsidyType:Number,//补贴类型
+    createTime:{type:Number, index:true},//创建时间
+    endTime:{type:Number, index:true},//失效时间
+    industry:{type:Number, index:true},
+    label:{type:[Number], default:[]},//关联标签
+});
+
+var policyModel;
+export function initModel(){
+    policyModel = baseDB.model('policy', policySchema);
+    policyModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await policyModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+
+export async function findData(param) {
+    return await policyModel.find(param);
+}
+
+export async function findDataToPage(param, page) {
+    return await policyModel.find(param).skip((page-1)*10).limit(10);
+}
+
+export async function findDataCount(param) {
+    return await policyModel.find(param).countDocuments();
+}
+
+export async function findOnceData(param) {
+    return await policyModel.selectOnceData(param);
+}
+
+export async function addPolicy(param) {
+    return await policyModel.create(param);
+}
+
+export async function deleteOnePolicy(param) {
+    return await policyModel.deleteOne(param);
+}
+
+
+export async function typeStatis(param) {
+    let statsList = await policyModel.aggregate([
+        {"$match":param},
+        {"$group":{_id:"$type", count:{"$sum":1}} }
+    ]);
+    return statsList;
+}

src/data/service/appeals.ts

+/**
+ * 述求
+ */
+
+import { Schema } from 'mongoose';
+import { baseDB } from '../../db/mongo/dbInit';
+
+
+const appealsSchema = new Schema({
+    appId:{type:String},//id
+    uscc:{type:String, index: true},//关联企业
+    enterpriseName:{type:String},//关联企业企业名称
+    createTime:Number,//创建时间
+    createUserId:String,//创建人
+    appealType:{type:Number, index: true},//诉求类型  APPEALTYPE
+    appeal:{type:String},//诉求描述
+    state:{type:Number, index: true, default:1},//解决状态
+});
+
+var appealsModel;
+export function initModel(){
+    appealsModel = baseDB.model('appeals', appealsSchema);
+    appealsModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await appealsModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+export async function findData(param) {
+    return await appealsModel.selectOnceData(param);
+}
+
+export async function createData(param) {
+    param.createTime = new Date().valueOf();
+    await appealsModel.create(param);
+}
+
+
+export async function selectCountByParam(param) {
+    return await appealsModel.find(param).countDocuments();
+}
+
+
+export async function selectDataByParam(param) {
+    return await appealsModel.find(param);
+}
+
+export async function typeStatis(param) {
+    let statsList = await appealsModel.aggregate([
+        {"$match":param},
+        {"$group":{_id:"$appealType", count:{"$sum":1}} }
+    ]);
+    return statsList;
+}

src/data/service/dynamic.ts

+/**
+ * 跟踪
+ */
+
+import { Schema } from 'mongoose';
+import { baseDB } from '../../db/mongo/dbInit';
+
+
+const resolveDynamicsSchema = new Schema({
+    rId:{type:String},//id
+    uscc:{type:String, index: true},//关联企业
+    sId:{type:String, index:true},//服务id
+    vId:{type:String, index:true},//服务id
+    enterpriseName:{type:String},//关联企业企业名称
+    tracking:{type:String},//跟踪人id
+    trackingTime:{type:Number},//跟踪时间
+    trackingDesc:String,//跟踪进度
+    resolutionStatus:{type:Number},//解决情况
+    createTime:Number,//创建时间
+    createUserId:String,//创建人
+});
+
+var resolveDynamicsModel;
+export function initModel(){
+    resolveDynamicsModel = baseDB.model('resolvedynamics', resolveDynamicsSchema);
+    resolveDynamicsModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await resolveDynamicsModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+export async function findData(param) {
+    return await resolveDynamicsModel.selectOnceData(param);
+}
+
+export async function createData(param) {
+    param.createTime = new Date().valueOf();
+    await resolveDynamicsModel.create(param);
+}
+
+
+export async function selectCountByParam(param) {
+    return await resolveDynamicsModel.find(param).countDocuments();
+}
+
+
+export async function selectDataByParam(param) {
+    return await resolveDynamicsModel.find(param);
+}
+

src/data/service/policyImplementation.ts

+/**
+ * 政策落实
+ */
+
+import { Schema } from 'mongoose';
+import { baseDB } from '../../db/mongo/dbInit';
+
+
+const policyImplementationSchema = new Schema({
+    piId:{type:String},
+    uscc:{type:String, index: true},//关联企业
+    enterpriseName:String,//企业名称
+    pId:{type:String, index: true},//关联政策
+    policyName:String,//政策名称
+    implement:Number,//落实类型
+    state:{type:Number},//落实状态
+    desc:String,//具体描述
+    notes:String,//备注
+    implementTime:Number,//落实时间
+    createTime:Number,//创建时间
+    createUser:String,
+    type:Number//政策类型
+});
+
+var policyImplementationModel;
+export function initModel(){
+    policyImplementationModel = baseDB.model('policyImplementation', policyImplementationSchema);
+    policyImplementationModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await policyImplementationModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+export async function findOneData(param) {
+    return await policyImplementationModel.selectOnceData(param);
+}
+
+export async function findData(param) {
+    return await policyImplementationModel.find(param);
+}
+
+export async function findDataCount(param) {
+    return await policyImplementationModel.find(param).countDocuments();
+}
+
+export async function addData(param) {
+    return await policyImplementationModel.create(param);
+}
+
+export async function findDataToPage(param, pageNumber) {
+    return await policyImplementationModel.find(param).skip((pageNumber-1)*10).limit(10);
+}
+
+
+export async function deleteOne(param) {
+    return await policyImplementationModel.deleteOne(param);
+}
\ No newline at end of file

src/data/service/service.ts

+/**
+ * 企业服务表
+ */
+
+import { Schema } from 'mongoose';
+import { baseDB } from '../../db/mongo/dbInit';
+import { SOLVESTATECLIENT } from '../../config/enum';
+
+
+const serviceSchema = new Schema({
+    sId:{type:String, index:true},//服务id
+    uscc:{type:String, index: true},//关联企业
+    name:{type:String, index: true},//关联企业名称
+    researchTime:{type:Number},//调研时间
+    leaderName:{type:String},//出席领导
+    accompany:{type:[String], default:[]},//陪同人员
+    contacts:String,//联系人
+    contactsPhone:String,//联系人电话
+    content:String,//洽谈内容
+    follow:{type:String},//跟进人 
+    followContent:String,//跟进内容
+    researchType:Number, //调研类型 RESEARCHTYPE 
+    appealType:{type:String, index:true, default:SOLVESTATECLIENT.未解决},//诉求类型  关联企业述求的id
+    appealTypeEnumId:{type:Number},//诉求类型  关联枚举
+    appeal:{type:String},//诉求描述
+    solutionType:{type:Number},//解决方式  SOLUTIONTYPE
+    state:{type:Number, index: true},//解决状态
+    desc:String,//解决的备注
+    requestKeywords:[Number],//关键词
+
+    createTime:Number,//创建时间
+    processingTime:{type:Number, default:0},//处理时间 
+    endTime:{type:Number, default:0},//结束时间
+    promoterId:{type:String},//发起人（添加人）
+});
+
+var serviceModel;
+export function initModel(){
+    serviceModel = baseDB.model('service', serviceSchema);
+    serviceModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await serviceModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+
+export async function createData(param) {
+    param.createTime = new Date().valueOf();
+    await serviceModel.create(param);
+}
+
+
+export async function selectCountByParam(param) {
+    return await serviceModel.find(param).countDocuments();
+}
+
+export async function selectDataByParam(param) {
+    return await serviceModel.find(param);
+}
+
+export async function selectDataByParamToPage(param, pageNumber) {
+    return await serviceModel.find(param).skip((pageNumber-1)*10).limit(10);;;
+}
+
+export async function selectData(param) {
+    return await serviceModel.selectOnceData(param);
+}
\ No newline at end of file

src/data/service/visit.ts

+/**
+ * 走访
+ */
+
+import { Schema } from 'mongoose';
+import { baseDB } from '../../db/mongo/dbInit';
+import { SOLVESTATECLIENT, STATE } from '../../config/enum';
+
+
+const visitSchema = new Schema({
+    vId:{type:String, index:true},//走访id
+    uscc:{type:String, index: true},//关联企业
+    name:{type:String, index: true},//关联企业名称
+    researchTime:{type:Number},//调研时间
+    leaderName:{type:String},//出席领导
+    accompany:{type:[String], default:[]},//陪同人员
+    contacts:String,//联系人
+    contactsPhone:String,//联系人电话
+    content:String,//洽谈内容
+    follow:{type:String},//跟进人 
+    followContent:String,//跟进内容
+    researchType:Number, //调研类型 RESEARCHTYPE 
+    appealType:{type:String, index: true},//诉求类型  关联企业述求的id
+    appealTypeEnumId:{type:Number},//诉求类型  关联枚举
+    appeal:{type:String},//诉求描述
+    solutionType:{type:Number},//解决方式  SOLUTIONTYPE
+    state:{type:Number, index:true, default:SOLVESTATECLIENT.未解决},//解决状态
+    desc:String,//解决的备注
+    requestKeywords:[Number],//关键词
+
+    createTime:Number,//创建时间
+    processingTime:{type:Number, default:0},//处理时间 
+    endTime:{type:Number, default:0},//结束时间
+    promoterId:{type:String},//发起人（添加人）
+});
+
+var visitModel;
+export function initModel(){
+    visitModel = baseDB.model('visit', visitSchema);
+    visitModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await visitModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+export async function createData(param) {
+    let addInfo = Object.assign({createTime:new Date().valueOf()}, param);
+    await visitModel.create(addInfo);
+}
+
+export async function findData(param) {
+    return await visitModel.find(param);
+}
+
+export async function findDataToPage(param, pageNumber) {
+    return await visitModel.find(param).skip((pageNumber-1)*10).limit(10);
+}
+
+export async function selectData(param) {
+    return await visitModel.selectOnceData(param);
+}
+
+export async function findDataCount(param) {
+    return await visitModel.find(param).countDocuments();
+}
+
+export async function typeStatis(param) {
+    let statsList = await visitModel.aggregate([
+        {"$match":param},
+        {"$group":{_id:"$appealType", count:{"$sum":1}} }
+    ]);
+    return statsList;
+}
+
+export async function selectCountByParam(param) {
+    return await visitModel.find(param).countDocuments();
+}
+
+export async function statisYearCount(param) {
+    let statisList = await visitModel.aggregate([
+        {"$match":param},
+        {
+            $group: {
+              _id: {
+                year: { $year: { $toDate: "$researchTime" } },  // 提取年份
+                month: { $month: { $toDate:"$researchTime" } } // 提取月份
+              },
+              count: { $sum: 1 }  // 计算每月的记录数
+            }
+          },
+        {
+            $sort: { "_id.year": 1, "_id.month": 1 } // 按年月排序
+        }
+    ]);
+    return statisList
+}

src/data/service/visitPlan.ts

+/**
+ * 走访安排 走访计划
+ */
+
+import { Schema } from 'mongoose';
+import { baseDB } from '../../db/mongo/dbInit';
+
+
+const visitSchema = new Schema({
+    vpId:{type:String, index:true},//走访计划id
+    uscc:{type:String, index: true},//关联企业
+    name:{type:String},//关联企业名称
+    visitTime:{type:Number},//走访时间
+    attendee:String,//走访人员 谁创建的就是谁
+    accompany:{type:[String], default:[]},//陪同人员
+    desc:String,//备注
+    promoterId:{type:String},//发起人（添加人）
+    createTime:Number,//创建时间
+});
+
+var visitPlanModel;
+export function initModel(){
+    visitPlanModel = baseDB.model('visitplan', visitSchema);
+    visitPlanModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await visitPlanModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+export async function createData(param) {
+    let addInfo = Object.assign({createTime:new Date().valueOf()}, param);
+    await visitPlanModel.create(addInfo);
+}
+
+export async function findData(param) {
+    return await visitPlanModel.find(param);
+}
+
+export async function findDataToPage(param, pageNumber) {
+    return await visitPlanModel.find(param).skip((pageNumber-1)*10).limit(10);
+}
+
+export async function selectData(param) {
+    return await visitPlanModel.selectOnceData(param);
+}
+
+export async function findDataCount(param) {
+    return await visitPlanModel.find(param).countDocuments();
+}
+
+
+

src/data/user.ts

+/**
+ * 用户表
+ */
+import { Schema } from 'mongoose';
+import { baseDB } from '../db/mongo/dbInit';
+
+const userSchema = new Schema({
+    name:String,//名称
+    loginId: {type:String, index:true},//登录账号
+    userId:{type:String, index:true},
+    pwd:String,//密码
+    phone:String,//登录手机号
+    token:String,
+    tokenMs:Number,
+    adminToken:String,
+    adminTokenMs:Number,
+    userType:Number,//用户类型
+    followEnterprise:{type:[String], default:[]} //关注企业
+});
+
+var userModel;
+export function initModel(){
+    userModel = baseDB.model('user', userSchema);
+    userModel.selectOnceData = async function (paramater:object) {
+        let selectInfo = await userModel.findOne(paramater).exec();
+        if (selectInfo) {
+            if (!selectInfo.runSave) {
+                selectInfo.runSave = selectInfo.save;
+                selectInfo.save = save.bind(selectInfo)
+            }
+        }
+        return selectInfo;
+    }
+}
+export async function save(throwError=false) {
+    if (!this.isModified()) return;
+    await this.runSave({validateBeforeSave:false}).catch(err=>{
+        console.log(err);
+    });
+}
+
+export async function findUserInfoByLoginId(loginId:string) {
+    return await userModel.selectOnceData({loginId});
+}
+
+export async function findUserInfoByUserId(userId:string) {
+    return await userModel.selectOnceData({userId});
+}
+
+export async function findUserMap() {
+    let map = {};
+    let userList = await userModel.find({});
+    userList.forEach(info => {
+        map[info.userId] = info.name;
+    });
+    return map;
+}
+
+
+export async function createUser(addInfo) {
+    await userModel.create(addInfo);
+}
+export async function createManyUser(addList) {
+    await userModel.insertMany(addList);
+}
+
+export async function findUserFollowEnterpriseMap(userId:string) {
+    let map = {};
+    let userItem = await userModel.findOne({userId});
+    userItem.followEnterprise.forEach(enterpriseId => {
+        map[enterpriseId] = 1;
+    });
+    return map;
+}
+
+export async function findUserByParam(param) {
+    let userList = await userModel.find(param);
+    return userList;
+}

src/db/mongo/dbConnect.ts

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

src/db/mongo/dbInit.ts

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

src/db/mongo/tableInit.ts

+import * as businessdataModel  from "../../data/enterprise/businessdata";
+import * as enterpriseModel  from "../../data/enterprise/enterprise";
+import * as labelModel  from "../../data/label";
+import * as enterpriseLabelLogModel  from "../../data/log/enterpriseLabelLog";
+import * as enterpriseLogModel  from "../../data/log/enterpriseLog";
+import * as activityModel  from "../../data/policy/activity";
+import * as policyModel  from "../../data/policy/policy";
+import * as policyImplementationModel  from "../../data/service/policyImplementation";
+import * as serviceModel  from "../../data/service/service";
+import * as visitModel  from "../../data/service/visit";
+import * as userModel  from "../../data/user";
+import * as dynamicModel  from "../../data/service/dynamic";
+import * as appealsModel  from "../../data/service/appeals";
+import * as visitPlanModel  from "../../data/service/visitPlan";
+import * as overallOperationModel  from "../../data/overallOperation"
+
+ 
+
+export async function initTable() {
+    enterpriseModel.initModel();
+    enterpriseLogModel.initModel();
+    activityModel.initModel();
+    policyModel.initModel();
+    policyImplementationModel.initModel();
+    serviceModel.initModel();
+    visitModel.initModel();
+    userModel.initModel();
+    businessdataModel.initModel();
+    labelModel.initModel();
+    enterpriseLabelLogModel.initModel();
+    dynamicModel.initModel();
+    appealsModel.initModel();
+    visitPlanModel.initModel();
+    overallOperationModel.initModel();
+}
\ No newline at end of file

src/main.ts

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

src/middleware/fromParam.ts

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

src/middleware/httpErrorHandler.ts

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

src/middleware/user.ts

+import { ERRORENUM } from "../config/errorEnum";
+import { findEnterpriseByUscc } from "../data/enterprise/enterprise";
+import { findUserInfoByLoginId, findUserInfoByUserId } from "../data/user";
+
+import { BizError } from "../util/bizError";
+
+
+/**
+ * 中间件
+ * @param req 
+ * @param res 
+ * @param next 
+ * @returns 
+ */
+export async function checkToken(req, res, next) {   
+    if (!req.headers) req.headers = {};
+
+    const reqToken = req.headers.token;
+    const userId = req.headers.userid || "";
+
+    if (!userId) return next(new BizError(ERRORENUM.身份验证失败, `userId:${userId} token:${reqToken}`));
+
+    let userInfo = await findUserInfoByUserId(userId);
+    if (!userInfo) return next(new BizError(ERRORENUM.非法登录, `userId:${userId} token:${reqToken}`));
+    
+    if (userInfo.token != reqToken ) return next(new BizError(ERRORENUM.身份验证过期, `userId:${userId} token:${reqToken}`));
+
+    req.userInfo = {
+        userId:userInfo.userId,
+        name:userInfo.name,
+        userType:userInfo.userType
+    }
+
+    next();
+}
+
+
+/**
+ * 中间件
+ * @param req 
+ * @param res 
+ * @param next 
+ * @returns 
+ */
+export async function checkAdminToken(req, res, next) {   
+    if (!req.headers) req.headers = {};
+
+    const reqToken = req.headers.token;
+    const userId = req.headers.userid || "";
+
+    if (!userId) return next(new BizError(ERRORENUM.身份验证失败, `userId:${userId} token:${reqToken}`));
+
+    let userInfo = await findUserInfoByUserId(userId);
+    if (!userInfo) return next(new BizError(ERRORENUM.非法登录, `userId:${userId} token:${reqToken}`));
+    
+    if (userInfo.adminToken != reqToken ) return next(new BizError(ERRORENUM.身份验证过期, `userId:${userId} token:${reqToken}`));
+
+    req.userInfo = {
+        userId:userInfo.userId,
+        name:userInfo.name,
+        userType:userInfo.userType
+    }
+
+    next();
+}

src/middleware/watch.ts

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

src/net/http_server.ts

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

src/routers/admin/user.ts

+import * as asyncHandler from 'express-async-handler';
+import * as userBiz from '../../biz/user';
+import { eccReqParamater } from '../../util/verificationParam';
+import { checkAdminToken, checkToken } from '../../middleware/user';
+
+export function setRouter(httpServer) {
+    httpServer.post('/zj/admin/user/login', asyncHandler(admin_login));//登录
+    httpServer.post('/zj/admin/user/logout', checkAdminToken, asyncHandler(admin_logout));//登出
+}
+
+
+/**
+ * 登录
+ * @param req 
+ * @param res 
+ */
+async function admin_login(req, res) {
+    let reqConf = {loginId:'String', pwd:'String'};
+    let { loginId, pwd } = eccReqParamater(reqConf, req.body);
+
+    let result = await userBiz.adminUserLogin(loginId, pwd);
+    
+    res.success(result);
+}
+
+/**
+ * 登出
+ * @param req 
+ * @param res 
+ */
+async function admin_logout(req, res) {
+    let userInfo = req.userInfo;
+
+    let result = await userBiz.adminUserLogout(userInfo);
+    
+    res.success(result);
+}

src/routers/enterpriseButler/activity.ts

+/**
+ * 企业活动
+ */
+
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+import { activityInfo, activityList, activityStatis } from '../../biz/activity';
+import { checkToken } from '../../middleware/user';
+
+
+export function setRouter(httpServer) {
+    httpServer.post('/zj/xcx/enterprisemanage/activity/list', checkToken, asyncHandler(activity_list));//企业活动列表
+    httpServer.post('/zj/xcx/enterprisemanage/activity/statis', checkToken, asyncHandler(activity_statis));//企业活动 统计
+    httpServer.post('/zj/xcx/enterprisemanage/activity/info', checkToken, asyncHandler(activity_info));//企业活动 详情
+}
+
+async function activity_list(req, res) {
+    let reqConf = {type:'Number', state:'Number' };
+    let { type, state } = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await activityList(type, state);
+    res.success(result);
+}
+
+
+async function activity_statis(req, res) {
+    let reqConf = {type:'Number'};
+    let { type } = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await activityStatis(type);
+    res.success(result);
+}
+
+
+async function activity_info(req, res) {
+    let reqConf = {aId:'String'};
+    let { aId } = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await activityInfo(aId);
+    res.success(result);
+}
\ No newline at end of file

src/routers/enterpriseButler/archives.ts

+/**
+ * 一企一档
+ */
+
+
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+import * as enterpriseBiz from '../../biz/enterprise';
+import { addPolicyImplement, policyImplement, policyImplementStatis, policyRecommend } from '../../biz/policy';
+import { checkToken } from '../../middleware/user';
+
+
+export function setRouter(httpServer) {
+    //一企一档
+    httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/list', checkToken, asyncHandler(enterprise_list));//企业列表
+    httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/attention', checkToken, asyncHandler(enterprise_follow));//企业列表中的 关注
+    httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/outattention', checkToken, asyncHandler(enterprise_out_follow));//企业列表中的 取消关注
+
+    //一企一档  =>  企业信息
+    httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/info', checkToken, asyncHandler(enterprise_base_info));//企业信息 显示
+    httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/feedback', checkToken, asyncHandler(enterprise_info_show));//企业信息 回显
+    httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/update', checkToken, asyncHandler(enterprise_update));//企业信息 修改
+    //一企一档  =>  企业信息  =>  经营数据
+    httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/business/update', checkToken, asyncHandler(update_enterprise_business));//修改 经营数据
+    httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/business/del', checkToken, asyncHandler(delete_enterprise_business));//删除 经营数据
+    httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/business/add', checkToken, asyncHandler(add_enterprise_business));//添加 经营数据
+
+
+    // httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/servicelog/arrangeuserlist', asyncHandler());//服务记录 安排走访中的用户下拉
+    //一企一档 政策匹配
+    httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/policiesmix/statis', checkToken, asyncHandler(enterprise_policiesmix_staits));//政策匹配统计
+    httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/policiesmix/recommend', checkToken, asyncHandler(enterprise_policiesmix_recommend));//政策匹配 推荐
+    httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/policiesmix/implement', checkToken, asyncHandler(enterprise_policiesmix_implement));//政策匹配 落实
+    httpServer.post('/zj/xcx/enterprisemanage/archives/enterprise/policiesmix/implement/add', checkToken, asyncHandler(enterprise_policiesmix_implement_add));//政策匹配 添加落实
+   
+    //风险
+    httpServer.post('/zj/xcx/enterprisemanage/archives/warn/list', checkToken, asyncHandler(enterprise_warn_list));//风险列表
+}
+
+
+async function enterprise_warn_list(req, res) {
+    let reqConf = { uscc:"String", typeList:"[Number]"};
+    let { uscc, typeList } = eccReqParamater(reqConf, req.body, ["typeList"]);
+
+    let userInfo = req.userInfo;
+    let result = await enterpriseBiz.enterpriseWarnList(uscc, typeList);
+    res.success(result);
+}
+
+async function enterprise_list(req, res) {
+    let reqConf = {selectStr:'String', labelIdList:'[Number]', page:"Number", industryList:'[Number]', isFoolow:"Boolean" };
+    let { selectStr, labelIdList, page, industryList , isFoolow } = eccReqParamater(reqConf, req.body, ["industryList", "labelIdList"]);
+
+    let userInfo = req.userInfo;
+    let result = await enterpriseBiz.enterpriseList(userInfo, selectStr, labelIdList, industryList, isFoolow, page);
+    res.success(result);
+}
+
+async function enterprise_base_info(req, res) {
+    let reqConf = {uscc:'String' };
+    let { uscc } = eccReqParamater(reqConf, req.body);
+
+    let result = await enterpriseBiz.enterpriseBaseInfo(uscc);
+    res.success(result);
+}
+
+async function enterprise_info_show(req, res) {
+    let reqConf = {uscc:'String' };
+    let { uscc } = eccReqParamater(reqConf, req.body);
+
+    let result = await enterpriseBiz.enterpriseInfo(uscc);
+    res.success(result);
+}
+
+async function enterprise_update(req, res) {
+    let reqConf = {uscc:'String', param:'Object'};
+    let { uscc, param} = eccReqParamater(reqConf, req.body);
+
+    let result = await enterpriseBiz.enterpriseUpdate(uscc, param);
+    res.success(result);
+}
+
+async function delete_enterprise_business(req, res) {
+    let reqConf = {uscc:'String', year:"Number"};
+    let { uscc , year} = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await enterpriseBiz.deleteEnterpriseBusinessData(uscc, year);
+    res.success(result);
+}
+
+async function add_enterprise_business(req, res) {
+    let reqConf = {uscc:'String', param:"Object"};
+    let { uscc , param} = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await enterpriseBiz.addEnterpriseBusinessData(uscc, param);
+    res.success(result);
+}
+
+
+async function update_enterprise_business(req, res) {
+    let reqConf = {uscc:'String', year:"Number", param:"Object"};
+    let { uscc , year, param} = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await enterpriseBiz.updateEnterpriseBusinessData(uscc, year, param);
+    res.success(result);
+}
+
+async function enterprise_follow(req, res) {
+    let reqConf = {uscc:'String'};
+    let { uscc } = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await enterpriseBiz.addEnterpriseFollow(userInfo, uscc);
+    res.success(result);
+}
+
+async function enterprise_out_follow(req, res) {
+    let reqConf = {uscc:'String'};
+    let { uscc } = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await enterpriseBiz.delEnterpriseFollow(userInfo, uscc);
+    res.success(result);
+}
+
+
+
+async function enterprise_policiesmix_recommend(req, res) {
+    let userInfo = req.userInfo;
+    let reqConf = {uscc:'String', degree:'Numbe'};
+    let { uscc, degree} = eccReqParamater(reqConf, req.body, ["degree"]);
+
+    let result = await policyRecommend(uscc, degree);
+    res.success(result);
+}
+
+async function enterprise_policiesmix_implement(req, res) {
+    let userInfo = req.userInfo;
+    let reqConf = {uscc:'String', implement:"Number"};
+    let { uscc, implement } = eccReqParamater(reqConf, req.body, ["implement"]);
+
+    let result = await policyImplement(uscc, implement);
+    res.success(result);
+}
+
+async function enterprise_policiesmix_implement_add(req, res) {
+    let userInfo = req.userInfo;
+    let reqConf = {uscc:'String', param:"Object"};
+    let { uscc, param } = eccReqParamater(reqConf, req.body, ["implement"]);
+
+    let result = await addPolicyImplement(userInfo, uscc, param);
+    res.success(result);
+}
+
+async function enterprise_policiesmix_staits(req, res) {
+    let userInfo = req.userInfo;
+    let reqConf = {uscc:'String'};
+    let { uscc } = eccReqParamater(reqConf, req.body);
+
+    let result = await policyImplementStatis(uscc);
+    res.success(result);
+}
+

src/routers/enterpriseButler/establish.ts

+/**
+ * 建档
+ */
+
+import * as asyncHandler from 'express-async-handler';
+import { createBase, createOperate, createService } from '../../biz/enterprise';
+import { eccReqParamater } from '../../util/verificationParam';
+import { checkToken } from '../../middleware/user';
+
+
+export function setRouter(httpServer) {
+    httpServer.post('/zj/xcx/enterprisemanage/establish/create/base', checkToken, asyncHandler(add_base));//基础信息
+    httpServer.post('/zj/xcx/enterprisemanage/establish/create/operate', checkToken, asyncHandler(add_operate));//经营情况
+    httpServer.post('/zj/xcx/enterprisemanage/establish/create/service', checkToken, asyncHandler(add_service));//服务记录
+}
+
+
+async function add_base(req, res) {
+    let reqConf = {param: 'Object' };
+    let { param } = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await createBase(userInfo, param);
+    res.success(result);
+}
+
+
+
+async function add_operate(req, res) {
+    // let reqConf = {paramList: '[Object]', uscc:"String" };
+    // let { paramList, uscc } = eccReqParamater(reqConf, req.body);
+
+    // let userInfo = req.userInfo;
+    // let result = await createOperate(userInfo, uscc, paramList);
+    // res.success(result);
+    let reqConf = {param: 'Object', uscc:"String" };
+    let { param, uscc } = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await createOperate(userInfo, uscc, param);
+    res.success(result);
+}
+
+
+async function add_service(req, res) {
+    let reqConf = {param: 'Object', uscc:"String" };
+    let { param, uscc } = eccReqParamater(reqConf, req.body);
+    
+    let userInfo = req.userInfo;
+    let result = await createService(userInfo,uscc, param);
+    res.success(result);
+}

src/routers/enterpriseButler/home.ts

+/**
+ * 首页
+ */
+
+import * as asyncHandler from 'express-async-handler';
+import { homePage, homePageTop } from '../../biz/user';
+import { enterpriseChange, enterpriseOperate } from '../../biz/enterprise';
+import { homePageActivity } from '../../biz/activity';
+import { checkToken } from '../../middleware/user';
+import * as enterpriseBiz from '../../biz/enterprise';
+import { eccReqParamater } from '../../util/verificationParam';
+
+
+export function setRouter(httpServer) {
+    httpServer.post('/zj/xcx/enterprisemanage/home/top',checkToken, asyncHandler(home_top));//统计 企业总数 产业领域 
+    httpServer.post('/zj/xcx/enterprisemanage/home/statis',checkToken, asyncHandler(home_statis));//统计 企业总数 产业领域 
+    httpServer.post('/zj/xcx/enterprisemanage/home/enterprisechange',checkToken, asyncHandler(enterprise_changes));//统计 企业变化
+    httpServer.post('/zj/xcx/enterprisemanage/home/operate',checkToken, asyncHandler(enterprise_operate));//经营情况
+    httpServer.post('/zj/xcx/enterprisemanage/home/activity',checkToken, asyncHandler(enterprise_activity));//企业活动
+
+    httpServer.post('/zj/xcx/enterprise/select', checkToken, asyncHandler(enterprise_select_list));//企业名称下拉框
+    httpServer.post('/zj/xcx/user/select', checkToken, asyncHandler(user_select_list));//用户名称下拉框
+}
+
+
+
+/**
+ * 首页 统计
+ */
+async function home_statis(req, res) {
+    let userInfo = req.userInfo;
+
+    let result = await homePage(userInfo);
+    
+    res.success(result);
+}
+
+
+/**
+ * 首页 顶部
+ */
+async function home_top(req, res) {
+    let userInfo = req.userInfo;
+
+    let result = await homePageTop(userInfo);
+    
+    res.success(result);
+}
+
+/**
+ * 首页 企业变化
+ */
+async function enterprise_changes(req, res) {
+    let userInfo = req.userInfo;
+
+    let result = await enterpriseChange();
+    
+    res.success(result);
+}
+
+/**
+ * 首页 经营情况
+ */
+async function enterprise_operate(req, res) {
+    let userInfo = req.userInfo;
+
+    let result = await enterpriseOperate();
+    
+    res.success(result);
+}
+
+
+/**
+ * 首页 经营情况
+ */
+async function enterprise_activity(req, res) {
+    let userInfo = req.userInfo;
+
+    let result = await homePageActivity();
+    
+    res.success(result);
+}
+
+/**
+ * 企业名称下拉框
+ * @param req 
+ * @param res 
+ */
+async function enterprise_select_list(req, res) {
+    let reqConf = {name:'String'};
+    let { name } = eccReqParamater(reqConf, req.body);
+    let userInfo = req.userInfo;
+
+    let result = await enterpriseBiz.enterpriseNameSelectList(name);
+    
+    res.success(result);
+}
+
+async function user_select_list(req, res) {
+    let reqConf = {name:'String'};
+    let { name } = eccReqParamater(reqConf, req.body, ["name"]);
+    let userInfo = req.userInfo;
+
+    let result = await enterpriseBiz.userNameSelectList(name);
+    
+    res.success(result);
+}
+
+

src/routers/enterpriseButler/policy.ts

+/**
+ * 政策
+ */
+
+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+import { policyImplementList, policyInfo, policyList, policyMatchEnterpriseList, policyMatchList } from '../../biz/policy';
+import { checkToken } from '../../middleware/user';
+
+export function setRouter(httpServer) {
+    httpServer.post('/zj/xcx/enterprisemanage/policy/recommend/list', checkToken, asyncHandler(policy_list));//政策速递 政策列表
+    httpServer.post('/zj/xcx/enterprisemanage/policy/recommend/info', checkToken, asyncHandler(policy_info));//政策速递 详情
+    httpServer.post('/zj/xcx/enterprisemanage/policy/recommend/enterprise/list', checkToken, asyncHandler(policy_info_enterprise_list));//政策速递 匹配列表
+    
+    httpServer.post('/zj/xcx/enterprisemanage/policy/implement/list', checkToken, asyncHandler(policy_implement_list));//政策落实列表
+    httpServer.post('/zj/xcx/enterprisemanage/policy/match/list', checkToken, asyncHandler(policy_match_list));//政策落实列表
+}
+
+
+
+async function policy_list(req, res) {
+    let reqConf = {title:'String', type:'Number' };
+    let { title, type } = eccReqParamater(reqConf, req.body, ["title"]);
+
+    let userInfo = req.userInfo;
+    let result = await policyList(title, type);
+    res.success(result);
+}
+
+async function policy_info(req, res) {
+    let reqConf = {pId:'String' };
+    let { pId } = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await policyInfo(pId);
+    res.success(result);
+}
+
+async function policy_info_enterprise_list(req, res) {
+    let reqConf = {pId:'String' };
+    let { pId } = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await policyMatchEnterpriseList(pId);
+    res.success(result);
+}
+
+
+async function policy_implement_list(req, res) {
+    let reqConf = {year:'Number' };
+    let { year } = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await policyImplementList(year);
+    res.success(result);
+}
+
+async function policy_match_list(req, res) {
+    let reqConf = {year:'Number' };
+    let { year } = eccReqParamater(reqConf, req.body);
+
+    let userInfo = req.userInfo;
+    let result = await policyMatchList(year);
+    res.success(result);
+}
\ No newline at end of file

src/routers/enterpriseButler/user.ts

+import * as asyncHandler from 'express-async-handler';
+import { eccReqParamater } from '../../util/verificationParam';
+import * as userBiz from '../../biz/user';
+
+export function setRouter(httpServer) {
+    httpServer.post('/zj/xcx/user/enterprisebutler/login', asyncHandler(enterprise_butler_login));//登录
+    httpServer.post('/zj/xcx/user/enterprisebutler/logout', asyncHandler(enterprise_butler_logout));//登录
+    httpServer.post('/zj/xcx/user/leader/login', asyncHandler(leader_login));//登录
+    httpServer.post('/zj/xcx/user/leader/logout', asyncHandler(leader_logout));//登出
+}
+
+/**
+ * 企业管家登录
+ * @param req 
+ * @param res 
+ */
+async function enterprise_butler_login(req, res) {
+    let reqConf = {loginId:'String', pwd:'String'};
+    let { loginId, pwd } = eccReqParamater(reqConf, req.body);
+
+    let result = await userBiz.userLogin(loginId, pwd);
+    
+    res.success(result);
+}
+
+/**
+ * 企业管家登出
+ * @param req 
+ * @param res 
+ */
+async function enterprise_butler_logout(req, res) {
+    let userInfo = req.userInfo;
+
+    let result = await userBiz.userLogout(userInfo);
+    
+    res.success(result);
+}
+
+/**
+ * 领导登录
+ * @param req 
+ * @param res 
+ */
+async function leader_login(req, res) {
+    let reqConf = {loginId:'String', pwd:'String'};
+    let { loginId, pwd } = eccReqParamater(reqConf, req.body);
+
+    let result = await userBiz.userLogin(loginId, pwd);
+    
+    res.success(result);
+}
+
+/**
+ * 领导登出
+ * @param req 
+ * @param res 
+ */
+async function leader_logout(req, res) {
+    let userInfo = req.userInfo;
+
+    let result = await userBiz.userLogout(userInfo);
+    
+    res.success(result);
+}

src/routers/public.ts

+/**
+ * 公共资源路由
+ */
+import * as asyncHandler from 'express-async-handler';
+import * as enumConfig from '../config/enum';
+
+const config = {
+    "/zj/xcx/public/industry":enumConfig.INDUSTRY,//行业领域
+    "/zj/xcx/public/appealtype":enumConfig.APPEALTYPE,//述求类型
+    "/zj/xcx/public/activitytype":enumConfig.ACTIVITYTYPECLIENT,//活动类型
+    "/zj/xcx/public/policytype":enumConfig.POLICYTYPE,//政策类型
+    "/zj/xcx/public/researchtype":enumConfig.RESEARCHTYPE,//调研类型
+    "/zj/xcx/public/solutiontype":enumConfig.SOLUTIONTYPE,//解决方式
+    "/zj/xcx/public/requestkeywords":enumConfig.REQUESTKEYWORDS,//关键词
+    "/zj/xcx/public/solvestate":enumConfig.SOLVESTATECLIENT,//解决状态
+    "/zj/xcx/public/servicestate":enumConfig.SERVICESTATE,//日常服务状态
+    "/zj/xcx/public/enterprisecategory":enumConfig.ENTERPRISECATEGORY,//企业类型
+    "/zj/xcx/public/degree":enumConfig.DEGREE,//企业类型
+    "/zj/xcx/public/implement":enumConfig.IMPLEMENT,
+    "/zj/xcx/public/enterpriselabel":enumConfig.ENTERPRISELABEL,
+    "/zj/xcx/public/servicelogtype":enumConfig.SERVERLOGTYPE,
+    "/zj/xcx/public/warntype":enumConfig.WARNTYPE,
+    
+
+    "/zj/admin/public/industry":enumConfig.INDUSTRY,//行业领域
+    "/zj/admin/public/appealtype":enumConfig.APPEALTYPE,//述求类型
+    "/zj/admin/public/activitytype":enumConfig.ACTIVITYTYPECLIENT,//活动类型
+    "/zj/admin/public/policytype":enumConfig.POLICYTYPE,//政策类型
+    "/zj/admin/public/researchtype":enumConfig.RESEARCHTYPE,//调研类型
+    "/zj/admin/public/solutiontype":enumConfig.SOLUTIONTYPE,//解决方式
+    "/zj/admin/public/requestkeywords":enumConfig.REQUESTKEYWORDS,//关键词
+    "/zj/admin/public/solvestate":enumConfig.SOLVESTATECLIENT,//解决状态
+    "/zj/admin/public/servicestate":enumConfig.SERVICESTATE,//日常服务状态
+    "/zj/admin/public/enterprisecategory":enumConfig.ENTERPRISECATEGORY,//企业类型
+    "/zj/admin/public/degree":enumConfig.DEGREE,//企业类型
+    "/zj/admin/public/implement":enumConfig.IMPLEMENT,
+    "/zj/admin/public/enterpriselabel":enumConfig.ENTERPRISELABEL,
+    "/zj/admin/public/activitystatus":enumConfig.ACTIVITYSTATUS,
+    "/zj/admin/public/activitystatistype":enumConfig.ACTIVITYTYPESTATISCLIENT,
+    "/zj/admin/public/implementclient":enumConfig.IMPLEMENTCLIENT,
+}
+
+export function setRouter(httpServer) {
+    for (let modelKey in config) {
+        httpServer.post(modelKey, asyncHandler(getEnumItf(config[modelKey])));
+    }
+}
+
+
+/**
+ * 
+ * @param req 
+ * @param res 
+ */
+function getEnumItf(enumCof) {
+    return async function (req, res) {
+        let dataList = [];
+        for (let key in enumCof) {
+            let anyKey:any = key;
+            if (isNaN(anyKey)) {
+                dataList.push({key, value:enumCof[key]});
+            }
+        }
+        res.success({dataList});
+    }
+   
+}
\ No newline at end of file

src/routers/router.ts

+/**
+ * 总路由入口
+ */
+
+import * as publicRouters from './public';
+import * as activityRouters from './enterpriseButler/activity';
+import * as archivesRouters from './enterpriseButler/archives';
+import * as establishRouters from './enterpriseButler/establish';
+import * as homeRouters from './enterpriseButler/home';
+import * as policyRouters from './enterpriseButler/policy';
+import * as serviceRouters from './enterpriseButler/service';
+import * as userRouters from './enterpriseButler/user';
+import * as adminUserRouters from './admin/user';
+import * as adminRouters from './admin/admin';
+
+
+export function setRouter(httpServer){
+    /**下拉框等公用 路由 */
+    publicRouters.setRouter(httpServer);
+    /**小程序端 孵化器入口路由 */
+    activityRouters.setRouter(httpServer);
+    archivesRouters.setRouter(httpServer);
+    establishRouters.setRouter(httpServer);
+    homeRouters.setRouter(httpServer);
+    policyRouters.setRouter(httpServer);
+    serviceRouters.setRouter(httpServer);
+    userRouters.setRouter(httpServer);
+    adminUserRouters.setRouter(httpServer);
+    adminRouters.setRouter(httpServer);
+}
\ No newline at end of file

src/tools/system.ts

+/**
+ * 系统中使用的工具
+ * 包括 草稿箱id生成规则
+ * 包括 密码加密规则
+ */
+
+import moment = require("moment");
+const md5 = require("md5");
+
+
+/**
+ * 生成任务草稿箱Id
+ * @param uscc 
+ * @returns 
+ */
+export function getDraftId(uscc:string) {
+    return md5(`${uscc}${new Date().valueOf()}${Math.ceil(Math.random()*1000)}`);
+}
+
+
+
+/**
+ * 密码加密
+ * @param uscc 信用代码
+ * @param pwd 密码
+ * @returns md5后的密码
+ */
+export function getPwdMd5(uscc:string, pwd:string) {
+    return md5(uscc+pwd);
+}
+
+
+/**
+ * md5加密
+ * @param pwd 
+ * @returns pwd 加密后密码
+ */
+export function md5PwdStr(pwd:string) {
+    return md5(pwd);
+}
+
+
+/**
+ * 获取token
+ * @param uscc 统一信用代码
+ */
+export function getToken(uscc:string) {
+    return md5(`${uscc}${new Date().valueOf()}${Math.ceil(Math.random() *100)}`);
+}
+
+
+/**
+ * 校验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;
+}
+
+
+/**
+ * 生成融资id
+ * @param uscc 
+ * @returns 
+ */
+export function getFinancingId(uscc) {
+    return md5(`${uscc}${new Date().valueOf()}${Math.ceil(Math.random() * 1000)}`);
+}
+
+
+/**
+ * 生成创始团队成员id
+ * @param uscc 
+ * @param name 
+ * @returns 
+ */
+export function getInitialTeamMemberId(uscc:string, name:string) {
+    return md5(`${uscc}${name}${Math.ceil(Math.ceil(Math.random() * 1000000))}`);
+}
+
+
+/**
+ * 生成 资讯id
+ * @returns 
+ */
+export function getInformationId() {
+    return md5(`${Math.ceil(Math.ceil(Math.random() * 1000000))}${new Date().valueOf() }${Math.ceil(Math.ceil(Math.random() * 1000000))}`);
+}
+
+
+/**
+ * 获取上一个季度 年和季度
+ * @returns declarationYear：数据填报年   declarationQuarter：数据填报季度
+ */
+export function getLastQuarter() {
+    let thisYear = new Date().getFullYear();
+    let thisQuarter = moment().quarter();//当月填报季度
+    if ( (thisQuarter - 1) < 1 ) {
+        thisYear = moment().subtract(1, 'years').year();
+        thisQuarter = 4;
+    } else thisQuarter = thisQuarter - 1;
+    return {year:thisYear, quarter:thisQuarter};
+}
+
+
+export function getI18nRegisterId(uscc:string) {
+    return md5(`${uscc}${new Date().valueOf() }${Math.ceil(Math.ceil(Math.random() * 1000000))}`);
+}
+
+
+export function getPolicyBGImgId() {
+    return `bgImg_${md5(`bgImg${new Date().valueOf()}${Math.ceil(Math.ceil(Math.random() * 1000000))}`)}`
+}
+
+/**
+ * 获取随机id
+ * @param uscc 
+ */
+export function getRandomId(uscc:string) {
+    return md5(`${uscc}${new Date().valueOf() }${Math.ceil(Math.ceil(Math.random() * 1000000))}`);
+}
+
+export function changeAddToString(address) {
+    if (!address) return "";
+    let str = "";
+    address.forEach((item, index) => {
+        if (index == 0 && item == "上海市") return;
+        str += item;
+    });
+    return str;
+}
+
+
+export function getLabelId() {
+    return `${md5(`label${new Date().valueOf()}${Math.ceil(Math.ceil(Math.random() * 10000))}${Math.ceil(Math.ceil(Math.random() * 10000))}`)}`
+}
+
+export function successResult() {
+    return {success:true}
+}
+
+export function changeAddressListToStr(addressList) {
+    let str = "";
+    addressList.forEach(item => {
+        str += item
+    });
+    return str;
+}
\ No newline at end of file

src/tools/taskTool.ts

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

src/util/analysisExcel.ts

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