no message

.gitignore

+.idea
+.vscode
+/out
+/node_modules
+/test
+*test*
+*.log
+*.zip
\ No newline at end of file

package.json

+{
+  "name": "gameserver",
+  "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.9.1",
+    "lru-cache": "^4.1.5",
+    "md5": "^2.2.1",
+    "moment": "^2.24.0",
+    "mongoose": "^6.2.3",
+    "node-xlsx": "^0.16.1",
+    "nodemailer": "^6.1.1",
+    "pyfl": "^1.1.4",
+    "request": "^2.88.0",
+    "svg-captcha": "^1.3.12",
+    "xml2js": "^0.4.23"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}

serverConfig.xml

+<config>
+    <port>40029</port>
+    <imgPath>http://192.168.0.189:40028</imgPath>
+    <token>73n6124cv7rq614c572x80jma7mj3yhs</token>
+    <userName>1</userName>
+    <plantId>735608</plantId>
+    <dataCenterInterface>
+        <!-- 获取某电站数据概览 -->
+        <hqmdzsjgl>https://openapi-cn.growatt.com/v1/plant/data</hqmdzsjgl>
+        <hqmgyhddzlb>https://openapi-cn.growatt.com/v1/plant/user_plant_list</hqmgyhddzlb>
+        <hqsyyhdz>https://openapi-cn.growatt.com/v1/plant/list</hqsyyhdz>
+        <hqmdzlsfdl>https://openapi-cn.growatt.com/v1/plant/energy</hqmdzlsfdl>
+        <hqmdzjbxx>https://openapi-cn.growatt.com/v1/plant/details</hqmdzjbxx>
+        <hqmdzmytgl>https://openapi-cn.growatt.com/v1/plant/power</hqmdzmytgl>
+    </dataCenterInterface>
+</config>

src/biz/cyszhgl.ts

+
+import { cyszhglTableData } from '../data/table/cyszhglData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
+
+/*                            产业数字化管理                    */
+
+export function getData(req, res) {
+    let excelData = cyszhglTableData();
+
+    let ret:any = {};
+
+    let mqjcPackageData = onceYBarChartPackage( excelData['苗情检测'], '成熟度','');
+    ret['mqjc'] = getOnceYBarChartOut('苗情检测', mqjcPackageData);
+                    
+    let zztrpsyqsfxPackageData = onceYBarChartPackage( excelData['种子投入品使用趋势分析'], '斤','');
+    ret['zztrpsyqsfx'] = getOnceYBarChartOut('种子投入品使用趋势分析', zztrpsyqsfxPackageData);
+                    
+    let zmtrpsyqsfxPackageData = onceYBarChartPackage( excelData['种苗投入品使用趋势分析'], '斤','');
+    ret['zmtrpsyqsfx'] = getOnceYBarChartOut('种苗投入品使用趋势分析', zmtrpsyqsfxPackageData);
+                    
+    let fltrpsyqsfxPackageData = onceYBarChartPackage( excelData['肥料投入品使用趋势分析'], '斤','');
+    ret['fltrpsyqsfx'] = getOnceYBarChartOut('肥料投入品使用趋势分析', fltrpsyqsfxPackageData);
+                    
+    let nytrpsyqsfxPackageData = onceYBarChartPackage( excelData['农药投入品使用趋势分析'], '斤','');
+    ret['nytrpsyqsfx'] = getOnceYBarChartOut('农药投入品使用趋势分析', nytrpsyqsfxPackageData);
+                    
+    let scxyfxPackageData = doubleYBarCharPackage(excelData['蔬菜效益分析'], [], '吨', '万元' );
+    ret['scxyfx'] = getDoubleYBarChartOut('蔬菜效益分析', scxyfxPackageData);
+
+    let yyxyfxPackageData = doubleYBarCharPackage(excelData['渔业效益分析'], [], '吨', '万元' );
+    ret['yyxyfx'] = getDoubleYBarChartOut('渔业效益分析', yyxyfxPackageData);
+    
+    let fxlxzbPackageData = keyValuePackage(excelData['风险类型占比'].dataList);
+    ret['fxlxzb'] = getKeyValueOut('风险类型占比', fxlxzbPackageData);
+                    
+    let sfjdglPackageData = keyValuePackage(excelData['示范基地概览'].dataList);
+    ret['sfjdgl'] = getKeyValueOut('示范基地概览', sfjdglPackageData);
+                    
+    // let zzzlPackageData = keyValuePackage(excelData['种植种类'].dataList);
+    // ret['zzzl'] = getKeyValueOut('种植种类', zzzlPackageData);
+
+    // let zzfbPackageData = keyValuePackage(excelData['种植分布'].dataList);
+    // ret['zzfb'] = getKeyValueOut('种植分布', zzfbPackageData);
+    
+    let zzzlTableData = tablePackage(excelData["种植种类"].headerList[0], excelData["种植种类"].bodyList);
+    ret['zzzl'] = getTableOut( '种植种类', zzzlTableData);
+    
+    let zzfbTableData = tablePackage(excelData["种植分布"].headerList[0], excelData["种植分布"].bodyList);
+    ret['zzfb'] = getTableOut( '种植分布', zzfbTableData);
+                    
+    let sfdtrpsyjlPackageData = keyValuePackage(excelData['示范地投入品使用记录'].dataList);
+    ret['sfdtrpsyjl'] = getKeyValueOut('示范地投入品使用记录', sfdtrpsyjlPackageData);
+                    
+    let fxyjPackageData = keyValuePackage(excelData['风险预警'].dataList);
+    ret['fxyj'] = getKeyValueOut('风险预警', fxyjPackageData);
+                    
+    let cyxlphPackageData = keyValuePackage(excelData['产业销量排行'].dataList);
+    ret['cyxlph'] = getKeyValueOut('产业销量排行', cyxlphPackageData);
+                    
+    // let cpsyxxPackageData = keyValuePackage(excelData['产品溯源信息'].dataList);
+    // ret['cpsyxx'] = getKeyValueOut('产品溯源信息', cpsyxxPackageData);
+
+    let cpsyxxTableData = tablePackage(excelData["产品溯源信息"].headerList[0], excelData["产品溯源信息"].bodyList);
+    ret['cpsyxx'] = getTableOut( '产品溯源信息', cpsyxxTableData);
+                    
+    let szcyPackageData = keyValuePackage(excelData['数字产业'].dataList);
+    ret['szcy'] = getKeyValueOut('数字产业', szcyPackageData);
+
+    let yjxqgdTableData = tablePackage(excelData["预警详情工单"].headerList[0], excelData["预警详情工单"].bodyList);
+    ret['yjxqgd'] = getTableOut( '预警详情工单', yjxqgdTableData);
+                    
+                    
+    // let znggTableData = onceYBarChartPackage( excelData['智能灌溉'], '','');
+    // ret['zngg'] = getOnceYBarChartOut('智能灌溉', znggTableData);
+    // let znggTableData = tablePackage(excelData["智能灌溉"].headerList[0], excelData["智能灌溉"].bodyList);
+    // let znggTableData = {};
+    // excelData["智能灌溉"].dataList.forEach( info => {
+    //     let {ntwz, trsd, ggsj, ggjgsj, sfxygg} = info;
+    //     info["img"] =
+    //     znggTableData[ntwz] = info;
+    // })
+
+    let znggTableData = {};
+    excelData["智能灌溉"].dataList.forEach( info => {
+        let {ntwz, trsd, ggsj, ggjgsj, sfxygg, imageSrc} = info;
+        info["img"] = imageSrc || '图片地址';
+        znggTableData[ntwz] = info;
+    })
+
+    ret['zngg'] = {title:'智能灌溉', dataList:znggTableData};
+                     
+    res.send(ret);
+} 
\ No newline at end of file

src/biz/gbzscbgjdAq.ts

+
+import { gbzscbgjdAqTableData } from '../data/table/gbzscbgjdAq';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
+import { systemConfig } from "../config/serverConfig";
+
+/*                            A区                    */
+
+export function getData(req, res) {
+    let excelData = gbzscbgjdAqTableData();
+
+    let ret:any = {};
+
+    let zzzwclqkPackageData = onceYBarChartPackage(excelData['种植作物产量情况'], '', '');
+    
+    // 添加全部作物的数据汇总叶菜和根茎类数据
+    let allCropsData = excelData['叶菜类']?.dataList.concat(excelData['根茎类']?.dataList || []);
+    if (allCropsData) {
+        let allCropsPackageData = onceYBarChartPackage(allCropsData, '', '');
+        ret['全部作物'] = getOnceYBarChartOut('全部作物', allCropsPackageData);
+    }
+
+    ret['zzzwclqk'] = getOnceYBarChartOut('种植作物产量情况', zzzwclqkPackageData);
+
+                    
+    let AqjdxqPackageData = keyValuePackage(excelData['A区基地详情'].dataList);
+    ret['Aqjdxq'] = getKeyValueOut('A区基地详情', AqjdxqPackageData);
+                    
+    let jdfxPackageData = keyValuePackage(excelData['基地分析'].dataList);
+    ret['jdfx'] = getKeyValueOut('基地分析', jdfxPackageData);
+                    
+    let cpsyPackageData = keyValuePackage(excelData['产品溯源'].dataList);
+    ret['cpsy'] = getKeyValueOut('产品溯源', cpsyPackageData);
+
+    let cpfxzbPackageData = keyValuePackage(excelData['产品分销占比'].dataList);
+    ret['cpfxzb'] = getKeyValueOut('产品分销占比', cpfxzbPackageData);
+                    
+    let zzzwpzTableData = tablePackage(excelData["种植作物品种"].headerList[0], excelData["种植作物品种"].bodyList);
+    zzzwpzTableData.titleList.push("图片地址");
+
+    let zzzwpz = {dataList:[], titleList:zzzwpzTableData.titleList};
+
+    zzzwpzTableData.dataList.forEach(info => {
+        let {A} = info;
+        let imgUrl = `${systemConfig.imgPath}/${A}.png`;
+        info["F"] = imgUrl;
+        zzzwpz.dataList.push(info);
+    })
+
+    ret['zzzwpz'] = getTableOut( '种植作物品种', zzzwpz);
+                    
+                     
+    res.send(ret);
+} 
\ No newline at end of file

src/biz/gbzscbgjdBq.ts

+
+import { info } from 'console';
+import { gbzscbgjdBqTableData } from '../data/table/gbzscbgjdBq';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
+import { systemConfig } from '../config/serverConfig';
+
+/*                            B区                    */
+
+export function getData(req, res) {
+    let excelData = gbzscbgjdBqTableData();
+
+    let ret:any = {};
+
+    let zzzwclqkPackageData = onceYBarChartPackage( excelData['种植作物产量情况'], '','');
+    ret['zzzwclqk'] = getOnceYBarChartOut('种植作物产量情况', zzzwclqkPackageData);
+                    
+    let BqjdxqPackageData = keyValuePackage(excelData['B区基地详情'].dataList);
+    ret['Bqjdxq'] = getKeyValueOut('B区基地详情', BqjdxqPackageData);
+                    
+    let jdfxPackageData = keyValuePackage(excelData['基地分析'].dataList);
+    ret['jdfx'] = getKeyValueOut('基地分析', jdfxPackageData);
+                    
+    let cpsyPackageData = keyValuePackage(excelData['产品溯源'].dataList);
+    ret['cpsy'] = getKeyValueOut('产品溯源', cpsyPackageData);
+
+    let cpfxzbPackageData = keyValuePackage(excelData['产品分销占比'].dataList);
+    ret['cpfxzb'] = getKeyValueOut('产品分销占比', cpfxzbPackageData);
+                    
+    let zzzwpzTableData = tablePackage(excelData["种植作物品种"].headerList[0], excelData["种植作物品种"].bodyList);
+    zzzwpzTableData.titleList.push('图片地址');
+
+    let zzzwpz = {dataList:[],titleList:zzzwpzTableData.titleList};
+
+    zzzwpzTableData.dataList.forEach(info => {
+        let {B} = info;
+        let imgUrl = `${systemConfig.imgPath}/${B}.png`;
+        info['F'] = imgUrl;
+        zzzwpz.dataList.push(info);
+        });
+
+    ret['zzzwpz'] = getTableOut( '种植作物品种', zzzwpzTableData);
+                    
+                     
+    res.send(ret);
+} 
\ No newline at end of file

src/biz/getData.ts

+/**
+ * 左屏
+ */
+
+import { getGuangFu } from "../data/interface/dataInterface";
+import { getKeyValueOut, getOnceYBarChartOut } from "../dataPackage/out";
+
+
+let guangfuData = {
+    jbqk: [
+    ],
+    nhfx: {
+      count: [
+        {
+          key: "年用电量",
+          value: 0,
+        },
+        {
+          key: "光伏发电量",
+          value: "61312.7",
+        },
+      ],
+      charData: [
+      ],
+      dayData: [
+      ],
+    },
+    trsy: {
+      count: [
+        {
+          key: "光伏投入成本",
+          value: "123",
+        },
+        {
+          key: "运维成本",
+          value: "123",
+        },
+        {
+          key: "发电量",
+          value: "61312.7",
+        },
+        {
+          key: "发电时长",
+          value: 0,
+        },
+      ],
+      charData: [
+        {
+          key: "2016",
+          value: "518",
+        },
+        {
+          key: "2017",
+          value: "733",
+        },
+        {
+          key: "2018",
+          value: "116",
+        },
+        {
+          key: "2019",
+          value: "634",
+        },
+        {
+          key: "2020",
+          value: "116",
+        },
+        {
+          key: "2021",
+          value: "634",
+        },
+      ],
+    },
+    ztsj: [
+      {
+        key: "装机容量",
+        value: 46,
+      },
+      {
+        key: "总发电量",
+        value: "61312.7",
+      },
+      {
+        key: "实时功率",
+        value: 13.800000190734863,
+      },
+    ],
+    xyfxfd: {
+      count: [
+      ],
+      chartData: [
+      ],
+    },
+    xyfx: {
+      count: [
+        {
+          key: "今日收益",
+          value: 113.52,
+        },
+        {
+          key: "当月收益",
+          value: 2008.74,
+        },
+        {
+          key: "累计收益",
+          value: "123",
+        },
+      ],
+      chartData: {
+        "今年": [
+        ],
+        "去年": [
+        ],
+      },
+    },
+    jnjp: {
+      count: [
+        {
+          key: "二氧化碳",
+          value: "832克/千瓦时",
+        },
+        {
+          key: "氮氧化物",
+          value: "0.179克/千瓦时",
+        },
+        {
+          key: "二氧化硫",
+          value: "0.16克/千瓦时",
+        },
+        {
+          key: "电力烟尘",
+          value: "0.032克/千瓦时",
+        },
+      ],
+      chartData: [
+      ],
+    },
+  };
+/**
+ * 初始化接口数据
+ */
+export async function guangfuInit() {
+    await getGuangFu();
+    console.log();
+}
+
+
+/**
+ * 左屏
+ * @param req 
+ * @param res 
+ */
+export async function getLeft(req, res) {
+    let ret:any = {};
+
+    ret['jbqk'] = getKeyValueOut('基本情况', guangfuData.jbqk);
+
+    ret['fdglpjzfx'] = getKeyValueOut('能耗分析', guangfuData.nhfx.count);
+    ret['fdglpjzfxqst'] = getKeyValueOut('发电功率平均值分析趋势图', guangfuData.nhfx.charData);
+    ret['fdgldtgl'] = getKeyValueOut('发电功率当天分析', guangfuData.nhfx.dayData)
+    
+    ret['trsy'] = getKeyValueOut('投入使用', guangfuData.trsy.count);
+    ret['trsyqst'] = getKeyValueOut('投入使用趋势', guangfuData.trsy.charData);
+
+    res.send(ret);
+}
+
+
+/**
+ * 中间
+ * @param req 
+ * @param res 
+ */
+export async function getData(req, res) {
+    let ret:any = {};
+    
+    ret['ztsj'] = getKeyValueOut('整体数据', guangfuData.ztsj);
+
+    res.send(ret);
+}
+
+
+/**
+ * 右屏
+ * @param req 
+ * @param res 
+ */
+export async function getRight(req, res) {
+    let ret:any = {};
+    
+    ret['xyfxfd'] = getKeyValueOut('效益分析-发电量', guangfuData.xyfxfd.count);
+    ret['xyfxfdqst'] = getKeyValueOut('效益分析-发电量趋势', guangfuData.xyfxfd.chartData);
+
+    ret['xyfx'] = getKeyValueOut('效益分析', guangfuData.xyfx.count);
+     ret['xyfxqst'] = {title:"效益分析趋势", dataList:guangfuData.xyfx.chartData}
+
+    ret['jnjp'] = getKeyValueOut('节能减排', guangfuData.jnjp.count);
+    ret['jnjpqst'] = getKeyValueOut('节能减排趋势', guangfuData.jnjp.chartData);
+
+    res.send(ret);
+}
+
+
+
+
+
+
+
+
+

src/biz/gfny.ts

+
+import { gfnyTableData } from '../data/table/gfnyData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
+
+/*                            光伏能源                    */
+
+export function getData(req, res) {
+    // let excelData = gfnyTableData();
+
+    let ret:any = {};
+
+    // let fdglpjzfxPackageData = onceYBarChartPackage( excelData['发电功率平均值分析'], '','');
+    // ret['fdglpjzfx'] = getOnceYBarChartOut('发电功率平均值分析', fdglpjzfxPackageData);
+                    
+    // let fdglzdzfxPackageData = onceYBarChartPackage( excelData['发电功率最大值分析'], '','');
+    // ret['fdglzdzfx'] = getOnceYBarChartOut('发电功率最大值分析', fdglzdzfxPackageData);
+                    
+    // let trsyqsPackageData = onceYBarChartPackage( excelData['投入使用趋势'], '','');
+    // ret['trsyqs'] = getOnceYBarChartOut('投入使用趋势', trsyqsPackageData);
+                    
+    // let fdlqsPackageData = onceYBarChartPackage( excelData['发电量趋势'], '','');
+    // ret['fdlqs'] = getOnceYBarChartOut('发电量趋势', fdlqsPackageData);
+                    
+    // let ljjptjPackageData = onceYBarChartPackage( excelData['累计减排统计'], '','');
+    // ret['ljjptj'] = getOnceYBarChartOut('累计减排统计', ljjptjPackageData);
+                    
+    // let jbqkPackageData = keyValuePackage(excelData['基本情况'].dataList);
+    // ret['jbqk'] = getKeyValueOut('基本情况', jbqkPackageData);
+                    
+    // let nhfxPackageData = keyValuePackage(excelData['能耗分析'].dataList);
+    // ret['nhfx'] = getKeyValueOut('能耗分析', nhfxPackageData);
+                    
+    // let trsyPackageData = keyValuePackage(excelData['投入使用'].dataList);
+    // ret['trsy'] = getKeyValueOut('投入使用', trsyPackageData);
+                    
+    // let gfnyPackageData = keyValuePackage(excelData['光伏能源'].dataList);
+    // ret['gfny'] = getKeyValueOut('光伏能源', gfnyPackageData);
+                    
+    // // let xyfxPackageData = keyValuePackage(excelData['效益分析'].dataList);
+    // // ret['xyfx'] = getKeyValueOut('效益分析', xyfxPackageData);
+                    
+    // let xyfxPackageData = keyValuePackage(excelData['效益分析'].dataList);
+    // ret['xyfx'] = getKeyValueOut('效益分析', xyfxPackageData);
+                    
+    // let jnjpPackageData = keyValuePackage(excelData['节能减排'].dataList);
+    // ret['jnjp'] = getKeyValueOut('节能减排', jnjpPackageData);
+                     
+    res.send(ret);
+} 
\ No newline at end of file

src/biz/hjszzl.ts

+
+import { systemConfig } from '../config/serverConfig';
+import { hjszzlTableData } from '../data/table/hjszzlData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, stringListPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getStringOut, getTableOut } from '../dataPackage/out';
+
+/*                            环境数字治理                    */
+
+export function getData(req, res) {
+    let excelData = hjszzlTableData();
+
+    let ret:any = {};
+
+    let qwqsPackageData = onceYBarChartPackage( excelData['气温趋势'], '','');
+    ret['qwqs'] = getOnceYBarChartOut('气温趋势', qwqsPackageData);
+                    
+    let trwlysjcPackageData = onceYBarChartPackage( excelData['土壤微量元素监测'], '','');
+    ret['trwlysjc'] = getOnceYBarChartOut('土壤微量元素监测', trwlysjcPackageData);
+                    
+    let zdqsbhPackageData = onceYBarChartPackage( excelData['浊度趋势变化'], '','');
+    ret['zdqsbh'] = getOnceYBarChartOut('浊度趋势变化', zdqsbhPackageData);
+
+    let wdbhqsPackageData = onceYBarChartPackage( excelData['温度趋势变化'], '','');
+    ret['zdqswdbhqsbh'] = getOnceYBarChartOut('温度趋势变化', wdbhqsPackageData);
+
+    let PHzqsbhPackageData = onceYBarChartPackage( excelData['PH值趋势变化'], '','');
+    ret['PHzqsbh'] = getOnceYBarChartOut('浊度趋势变化', PHzqsbhPackageData);
+
+    let NH3NqsbhPackageData = onceYBarChartPackage( excelData['NH3-N趋势变化'], '','');
+    ret['NH3Nqsbh'] = getOnceYBarChartOut('NH3-N趋势变化', NH3NqsbhPackageData);
+
+    let rjyqsbhPackageData = onceYBarChartPackage( excelData['溶解氧趋势变化'], '','');
+    ret['rjyqsbh'] = getOnceYBarChartOut('溶解氧趋势变化', rjyqsbhPackageData);
+                    
+    let chzlcxPackageData = onceYBarChartPackage( excelData['虫害治理成效'], '','');
+    ret['chzlcx'] = getOnceYBarChartOut('虫害治理成效', chzlcxPackageData);
+                    
+    let tqjcPackageData = keyValuePackage(excelData['天气检测'].dataList);
+    ret['tqjc'] = getKeyValueOut('天气检测', tqjcPackageData);
+                    
+    let trjcPackageData = keyValuePackage(excelData['土壤检测'].dataList);
+    ret['trjc'] = getKeyValueOut('土壤检测', trjcPackageData);
+                    
+    let szjcPackageData = keyValuePackage(excelData['水质检测'].dataList);
+    ret['szjc'] = getKeyValueOut('水质检测', szjcPackageData);
+                    
+    let hjjcfxPackageData = keyValuePackage(excelData['环境基础分析'].dataList);
+    ret['hjjcfx'] = getKeyValueOut('环境基础分析', hjjcfxPackageData);
+                    
+    let bhczlPackageData = stringListPackage(excelData["病害虫治理"].dataList);
+    let bhczl = [];
+    for(let i = 0; i < bhczlPackageData.length; i++) {
+        let img = `${systemConfig.imgPath}/${bhczlPackageData[i]}`;
+        bhczl.push(img);
+    }
+    ret['bhczl'] = getStringOut('病害虫治理', bhczlPackageData);
+
+    let chjcdyjPackageData = keyValuePackage(excelData['虫害检测灯预警'].dataList);
+    ret['chjcdyj'] = getKeyValueOut('虫害检测灯预警', chjcdyjPackageData);
+
+    let zlqkPackageData = keyValuePackage(excelData['治理情况'].dataList);
+    ret['zlqk'] = getKeyValueOut('治理情况', zlqkPackageData);
+                    
+    let tqjcbTableData = tablePackage(excelData["天气检测表"].headerList[0], excelData["天气检测表"].bodyList);
+    ret['tqjcb'] = getTableOut( '天气检测表', tqjcbTableData);
+                    
+    let zhxyjglPackageData = keyValuePackage(excelData['灾害性应急管理'].dataList);
+    ret['zhxyjgl'] = getKeyValueOut('灾害性应急管理', zhxyjglPackageData);
+                    
+    let qxzhlbPackageData = keyValuePackage(excelData['气象灾害列表'].dataList);
+    ret['qxzhlb'] = getKeyValueOut('气象灾害列表', qxzhlbPackageData);
+                     
+    res.send(ret);
+} 
\ No newline at end of file

src/biz/jdaqgl.ts

+
+import { jdaqglTableData } from '../data/table/jdaqglData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
+
+/*                            基地安全管理                    */
+
+export function getData(req, res) {
+    let excelData = jdaqglTableData();
+
+    let ret:any = {};
+
+    let jqtsbzxqkPackageData = onceYBarChartPackage( excelData['近七天设备在线情况'], '','');
+    ret['jqtsbzxqk'] = getOnceYBarChartOut('近七天设备在线情况', jqtsbzxqkPackageData);
+                    
+    let sblxzbPackageData = keyValuePackage(excelData['设备类型占比'].dataList);
+    ret['sblxzb'] = getKeyValueOut('设备类型占比', sblxzbPackageData);
+                    
+    let sbslPackageData = keyValuePackage(excelData['设备数量'].dataList);
+    ret['sbsl'] = getKeyValueOut('设备数量', sbslPackageData);
+                    
+    let sbztqkPackageData = keyValuePackage(excelData['设备状态情况'].dataList);
+    ret['sbztqk'] = getKeyValueOut('设备状态情况', sbztqkPackageData);
+                    
+    let xfsbPackageData = keyValuePackage(excelData['消防设备'].dataList);
+    ret['xfsb'] = getKeyValueOut('消防设备', xfsbPackageData);
+                    
+    let xfsbztPackageData = keyValuePackage(excelData['消防设备状态'].dataList);
+    ret['xfsbzt'] = getKeyValueOut('消防设备状态', xfsbztPackageData);
+                    
+    let jdaqglsjfxPackageData = keyValuePackage(excelData['基地安全管理数据分析'].dataList);
+    ret['jdaqglsjfx'] = getKeyValueOut('基地安全管理数据分析', jdaqglsjfxPackageData);
+                    
+    let zcztlbTableData = tablePackage(excelData["正常状态列表"].headerList[0], excelData["正常状态列表"].bodyList);
+    ret['zcztlb'] = getTableOut( '正常状态列表', zcztlbTableData);
+
+    let whzztlbTableData = tablePackage(excelData["维护中状态列表"].headerList[0], excelData["维护中状态列表"].bodyList);
+    ret['whzztlb'] = getTableOut( '维护中状态列表', whzztlbTableData);
+
+    let gzztlbTableData = tablePackage(excelData["故障状态列表"].headerList[0], excelData["故障状态列表"].bodyList);
+    ret['gzztlb'] = getTableOut( '故障状态列表', gzztlbTableData);
+                    
+    let tqsjPackageData = keyValuePackage(excelData['天气数据'].dataList);
+    ret['tqsj'] = getKeyValueOut('天气数据', tqsjPackageData);
+                    
+    let sbyhjcPackageData = keyValuePackage(excelData['设备运行监测'].dataList);
+    ret['sbyhjc'] = getKeyValueOut('设备运行监测', sbyhjcPackageData);
+                    
+    let jjcdPackageData = keyValuePackage(excelData['紧急程度'].dataList);
+    ret['jjcd'] = getKeyValueOut('紧急程度', jjcdPackageData);
+                    
+    let gjqsPackageData = onceYBarChartPackage( excelData['告警趋势'], '个','');
+    ret['gjqs'] = getOnceYBarChartOut('告警趋势', gjqsPackageData);
+                    
+    let yjczPackageData = keyValuePackage(excelData['预警处置'].dataList);
+    ret['yjcz'] = getKeyValueOut('预警处置', yjczPackageData);
+
+    let yjczlPackageData = keyValuePackage(excelData['预警处置率'].dataList);
+    ret['yjczl'] = getKeyValueOut('预警处置率', yjczlPackageData);
+                    
+    let zdqyjkPackageData = keyValuePackage(excelData['重点区域监控'].dataList);
+    ret['zdqyjk'] = getKeyValueOut('重点区域监控', zdqyjkPackageData);
+                    
+    let yjczbTableData = tablePackage(excelData["预警处置表"].headerList[0], excelData["预警处置表"].bodyList);
+    ret['yjczb'] = getTableOut( '预警处置表', yjczbTableData);
+                     
+    res.send(ret);
+} 
\ No newline at end of file

src/biz/jiQiRen.ts

+/**
+ * 机器人
+ */
+
+import { jiQiRenTableData } from "../data/table/tableData";
+import { keyValuePackage, onceYBarChartPackage, tablePackage } from "../dataPackage/inFrontOut";
+import { getKeyValueOut, getOnceYBarChartOut, getTableOut } from "../dataPackage/out";
+
+
+/**
+ * 左屏
+ * @param req 
+ * @param res 
+ */
+export async function getLeft(req, res) {
+    let ret:any = {};
+    let data = jiQiRenTableData();
+
+
+    ret['jqrlxzb'] = getKeyValueOut('机器人类型占比', data["机器人类型占比"].dataList);
+    ret['yxzt'] = getKeyValueOut('运行状态', data["运行状态"].dataList);
+
+    let yxqsfx = onceYBarChartPackage(data["运行趋势分析"], '');
+    ret['yxqsfx'] = getOnceYBarChartOut('运行趋势分析', yxqsfx);
+
+    let yxjl = tablePackage(data["运行记录"].headerList[0], data["运行记录"].bodyList);
+    ret['yxjl'] = getTableOut('运行记录', yxjl);
+
+    let qybj = onceYBarChartPackage(data["区域布局"], '');
+    ret['qybj'] = getOnceYBarChartOut('区域布局', qybj);
+
+    res.send(ret);
+}
+
+
+
+/**
+ * 右屏
+ * @param req 
+ * @param res 
+ */
+export async function getRight(req, res) {
+    let ret:any = {};
+    let data = jiQiRenTableData();
+
+    let xjsblx = onceYBarChartPackage(data["巡检设备类型"], '');
+    ret['xjsblx'] = getOnceYBarChartOut('巡检设备类型', xjsblx);
+
+    let xjqs = onceYBarChartPackage(data["巡检趋势"], '');
+    ret['xjqs'] = getOnceYBarChartOut('巡检趋势', xjqs);
+
+    let xjjl =  tablePackage(data["巡检记录"].headerList[0], data["巡检记录"].bodyList);
+    ret['xjjl'] = getTableOut('巡检记录', xjjl);
+
+    let znjqrcl = onceYBarChartPackage(data["智能机器人产量"], '');
+    ret['znjqrcl'] = getOnceYBarChartOut('智能机器人产量', znjqrcl);
+
+    res.send(ret);
+}
+
+
+export async function getTop(req, res) {
+    let ret:any = {};
+    let data = jiQiRenTableData();
+
+    let jcxx = keyValuePackage(data["顶部指标"].dataList);
+    ret['jcxx'] = getKeyValueOut('顶部指标', jcxx);
+
+    res.send(ret);
+}
\ No newline at end of file

src/biz/nyjqr.ts

+
+import { nyjqrTableData } from '../data/table/nyjqrData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
+
+/*                            农业机器人                    */
+
+export function getData(req, res) {
+    let excelData = nyjqrTableData();
+
+    let ret:any = {};
+
+    let ysqsfxPackageData = onceYBarChartPackage( excelData['运势趋势分析'], '时长','');
+    ret['ysqsfx'] = getOnceYBarChartOut('运势趋势分析', ysqsfxPackageData);
+                    
+    let qyfbPackageData = onceYBarChartPackage( excelData['区域分布'], '','台套');
+    ret['qyfb'] = getOnceYBarChartOut('区域分布', qyfbPackageData);
+                    
+    let nyjqrsjPackageData = keyValuePackage(excelData['农业机器人数据'].dataList);
+    ret['nyjqrsj'] = getKeyValueOut('农业机器人数据', nyjqrsjPackageData);
+                    
+    let jqrlxzbPackageData = keyValuePackage(excelData['机器人类型占比'].dataList);
+    ret['jqrlxzb'] = getKeyValueOut('机器人类型占比', jqrlxzbPackageData);
+                    
+    let yhztPackageData = keyValuePackage(excelData['运行状态'].dataList);
+    ret['yhzt'] = getKeyValueOut('运行状态', yhztPackageData);
+                    
+    let yhjlTableData = tablePackage(excelData["运行记录"].headerList[0], excelData["运行记录"].bodyList);
+    ret['yhjl'] = getTableOut( '运行记录', yhjlTableData);
+                    
+    let jqrsjfxPackageData = keyValuePackage(excelData['机器人数据分析'].dataList);
+    ret['jqrsjfx'] = getKeyValueOut('机器人数据分析', jqrsjfxPackageData);
+                    
+    let znxjPackageData = keyValuePackage(excelData['智能巡检'].dataList);
+    ret['znxj'] = getKeyValueOut('智能巡检', znxjPackageData);
+                    
+    let xjsblxPackageData = onceYBarChartPackage( excelData['巡检设备类型'], '次数','');
+    ret['xjsblx'] = getOnceYBarChartOut('巡检设备类型', xjsblxPackageData);
+                    
+    let xjwcqkPackageData = keyValuePackage(excelData['巡检完成情况'].dataList);
+    ret['xjwcqk'] = getKeyValueOut('巡检完成情况', xjwcqkPackageData);
+                    
+    let xjqsPackageData = onceYBarChartPackage( excelData['巡检趋势'], '次数','');
+    ret['xjqs'] = getOnceYBarChartOut('巡检趋势', xjqsPackageData);
+                    
+    let xjjlTableData = tablePackage(excelData["巡检记录"].headerList[0], excelData["巡检记录"].bodyList);
+    ret['xjjl'] = getTableOut( '巡检记录', xjjlTableData);
+                    
+    let znjqrclPackageData = keyValuePackage(excelData['智能机器人产量'].dataList);
+    ret['znjqrcl'] = getKeyValueOut('智能机器人产量', znjqrclPackageData);
+                    
+    let jbnclqsPackageData = onceYBarChartPackage( excelData['近半年产量趋势'], '','月');
+    ret['jbnclqs'] = getOnceYBarChartOut('近半年产量趋势', jbnclqsPackageData);
+                     
+    res.send(ret);
+} 
\ No newline at end of file

src/biz/sdt1hgfb.ts

+
+import { sdt1hgfbTableData } from '../data/table/sdt1hgfbData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
+
+/*                            水稻田1号光伏板                    */
+
+export function getData(req, res) {
+    // let excelData = sdt1hgfbTableData();
+
+    let ret:any = {};
+
+    // let gfsjtjqstPackageData = onceYBarChartPackage( excelData['光伏数据统计趋势图'], '万/kwh','月');
+    // ret['gfsjtjqst'] = getOnceYBarChartOut('光伏数据统计趋势图', gfsjtjqstPackageData);
+                    
+    // let gfbPackageData = keyValuePackage(excelData['光伏板'].dataList);
+    // ret['gfb'] = getKeyValueOut('光伏板', gfbPackageData);
+                    
+    // let djPackageData = keyValuePackage(excelData['电机'].dataList);
+    // ret['dj'] = getKeyValueOut('电机', djPackageData);
+                    
+    // let gfsjtjPackageData = keyValuePackage(excelData['光伏数据统计'].dataList);
+    // ret['gfsjtj'] = getKeyValueOut('光伏数据统计', gfsjtjPackageData);
+                    
+    // let gfssxxTableData = tablePackage(excelData["光伏实时信息"].headerList[0], excelData["光伏实时信息"].bodyList);
+    // ret['gfssxx'] = getTableOut( '光伏实时信息', gfssxxTableData);
+                    
+    // let ycysjPackageData = onceYBarChartPackage( excelData['预测与实际'], '万/kWh','');
+    // ret['ycysj'] = getOnceYBarChartOut('预测与实际', ycysjPackageData);
+                     
+    res.send(ret);
+} 
\ No newline at end of file

src/biz/yzdqxdnyzl.ts

+
+import { yzdqxdnyzlTableData } from '../data/table/yzdqxdnyzlData';
+import { doubleYBarCharPackage, keyValuePackage, onceYBarChartPackage, rankPackage, tablePackage } from '../dataPackage/inFrontOut';
+import { getDoubleYBarChartOut, getKeyValueOut, getOnceYBarChartOut, getTableOut } from '../dataPackage/out';
+
+/*                            “一轴多区”现代农业走廊                    */
+
+export function getData(req, res) {
+    let excelData = yzdqxdnyzlTableData();
+
+    let ret:any = {};
+                    
+    let szylylPackageData = keyValuePackage(excelData['水资源利用率'].dataList);
+    ret['szylyl'] = getKeyValueOut('水资源利用率', szylylPackageData);
+                    
+    let zrzyPackageData = keyValuePackage(excelData['自然资源'].dataList);
+    ret['zrzy'] = getKeyValueOut('自然资源', zrzyPackageData);
+                    
+    let qyqkPackageData = keyValuePackage(excelData['企业情况'].dataList);
+    ret['qyqk'] = getKeyValueOut('企业情况', qyqkPackageData);
+                    
+    let cyjgPackageData = keyValuePackage(excelData['产业结构'].dataList);
+    ret['cyjg'] = getKeyValueOut('产业结构', cyjgPackageData);
+                    
+    let cyztjgPackageData = keyValuePackage(excelData['产业主体结构'].dataList);
+    ret['cyztjg'] = getKeyValueOut('产业主体结构', cyztjgPackageData);
+                    
+    let zdxmjsPackageData = keyValuePackage(excelData['重点项目建设'].dataList);
+    ret['zdxmjs'] = getKeyValueOut('重点项目建设', zdxmjsPackageData);
+
+    let xmfxPackageData = keyValuePackage(excelData['项目分析'].dataList);
+    ret['xmfx'] = getKeyValueOut('项目分析', xmfxPackageData);
+                    
+    let zjfwPackageData = keyValuePackage(excelData['专家服务'].dataList);
+    ret['zjfw'] = getKeyValueOut('专家服务', zjfwPackageData);
+                    
+    let cxjsjcsjPackageData = keyValuePackage(excelData['创新技术基础数据'].dataList);
+    ret['cxjsjcsj'] = getKeyValueOut('创新技术基础数据', cxjsjcsjPackageData);
+
+    let yjjsyjqkPackageData = keyValuePackage(excelData['引进技术基础数据'].dataList);
+    ret['yjjsyjqk'] = getKeyValueOut('引进技术基础数据', yjjsyjqkPackageData);
+
+    let jsyjqkPackageData = keyValuePackage(excelData['技术创新引进情况'].dataList);
+    ret['jsyjqk'] = getKeyValueOut('技术创新引进情况', jsyjqkPackageData);
+
+    let jscxqsPackageData = onceYBarChartPackage( excelData['创新技术创新趋势'], '','');
+    ret['jscxqs'] = getOnceYBarChartOut('创新技术创新趋势', jscxqsPackageData);
+    
+    let yjjscxqsPackageData = onceYBarChartPackage( excelData['引进技术创新趋势'], '','');
+    ret['yjjscxqs'] = getOnceYBarChartOut('引进技术创新趋势', yjjscxqsPackageData);
+                    
+    let jyglqkqstPackageData = keyValuePackage( excelData['经营管理情况趋势图'].dataList);
+    ret['jyglqkqst'] = getKeyValueOut('经营管理情况趋势图', jyglqkqstPackageData);
+
+    let jyglqkPackageData = keyValuePackage(excelData['经营管理情况'].dataList);
+    ret['jyglqk'] = getKeyValueOut('经营管理情况', jyglqkPackageData);
+                    
+    let zyyglxPackageData = keyValuePackage(excelData['专业员工类型'].dataList);
+    ret['zyyglx'] = getKeyValueOut('专业员工类型', zyyglxPackageData);
+                    
+    let ztsjfbPackageData = keyValuePackage(excelData['总体数据分布'].dataList);
+    ret['ztsjfb'] = getKeyValueOut('总体数据分布', ztsjfbPackageData);
+                     
+    res.send(ret);
+} 
\ No newline at end of file

src/config/enum.ts

+/**-----------------------------接口枚举------------------------------- */
+/**
+ * 接口更新类型
+ */
+export enum INTERFACEREQUESTTYPEENUM {
+    即时更新 = 1,
+    定时更新
+}
+
+export enum TYPEENUM {
+    string = 1,
+    number,
+    object,
+    array,
+    boolean,
+}
+
+
+
+/**上传文件类型 */
+export enum FILETYPE {
+    word = 1,
+    pdf,
+    图片,
+    视频,
+    多类型
+}
+
+
+
+
+
+
+

src/config/errorEnum.ts

+export enum ERRORENUM {
+    未找到数据,
+    数据操作失败,
+    暂无对应数据,
+    文件不存在,
+    参数错误,
+    地址数据不完整,
+    请完善信息,
+    接口数据获取失败
+}
+
+
+export enum SYSTEMERRORENUM {
+    参数错误 = 1,
+    您的登录已失效,
+    您的账户没有访问权限,
+    请求参数错误,
+    文件解析失败,
+    文件写入失败,
+    获取企业微信access_token失败,
+    获取企业微信用户信息失败,
+    请先绑定用户,
+    TOKEN失效,
+    该微信用户已绑定过账号,
+    存在TOKEN并没有绑定角色,
+    初始化配置失败,
+    暂无对应数据
+}
+
+
+export enum INTERFACEERRORENUM {
+    "系统错误" = 10001,
+    "电站不存在" = 10002,
+    "电站ID为空" = 10003,
+    "时间格式不正确" = 10004,
+    "没有权限访问" = 10011,
+    "访问频率限制5分钟/次" = 10012,
+    "页数超过100" = 10013,
+    "页数不能大于250页" = 10014,
+}
+
+
+let bizErrorMsgMap = {};
+for (let key in ERRORENUM) {
+    bizErrorMsgMap[ERRORENUM[key]] = key;
+}
+
+let systemErrorMsgMap = {};
+for (let key in SYSTEMERRORENUM) {
+    systemErrorMsgMap[SYSTEMERRORENUM[key]] = key;
+}
+
+export function getBizMsg(param) {
+    return bizErrorMsgMap[param];
+}
+
+export function getSysMsg(param) {
+    return systemErrorMsgMap[param];
+}
\ No newline at end of file

src/config/interfaceConfig.ts

+import { INTERFACEREQUESTTYPEENUM } from "./enum";
+import { dataCenterInterfaceConfig } from "./serverConfig";
+//配置
+// "接口名称":{
+//     type:"1是即时更新 2是即时更新 使用 INTERFACErEQUESTTYPEENUM", 
+//     time:"更新频率毫秒 例如1小时这里就是 3600000", 
+//     url:"url地址", 
+//     reqType:"get还是post get = get post = post", 
+//     header:{}, 
+//     body:{} 
+// }
+
+
+const token = "73n6124cv7rq614c572x80jma7mj3yhsCAHMZC001";
+
+export const Config = {
+    "获取某电站数据概览":{type:INTERFACEREQUESTTYPEENUM.即时更新,  time:3600000*12, url:dataCenterInterfaceConfig.hqmdzsjgl,  reqType:"get",  header:{token},  body:{}},
+};

src/config/serverConfig.ts

+const path = require('path');
+import * as fs from "fs";
+import { BizError, SysError } from "../util/bizError";
+import { analysisXml } from "../util/myXML";
+import { ServerConfig } from "./systemClass";
+import { SYSTEMERRORENUM } from "./errorEnum";
+
+export let systemConfig = new ServerConfig;
+
+const ConfigName = "serverConfig.xml";
+
+export let dataCenterInterfaceConfig = {
+    hqmdzsjgl:"", //获取某电站数据概览
+    // hqsyyhdz: "", //获取所有用户电站列表
+    hqmgyhddzlb: "", //获取某个用户的电站列表
+    hqmdzlsfdl: "", //获取某电站历史发电量
+    hqmdzmytgl: "", //获取某电站某一天功率数据
+    hqmdzjbxx: "", //获取某电站基本信息
+}
+
+
+
+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) console.log("xml中无配置加载");
+		else {
+            //必要配置
+            let integralConfig = ["port", "token", "userName", "plantId", 
+                {"dataCenterInterface":["hqmdzsjgl", "hqsyyhdz", "hqmgyhddzlb", "hqmdzlsfdl", "hqmdzmytgl", "hqmdzjbxx"]}
+            ];
+            
+            checkConfig(integralConfig, configInfo.config);
+
+			let {port, imgPath, token, userName, plantId, dataCenterInterface} = configInfo.config;
+
+			systemConfig.port = parseInt(port[0]);
+            systemConfig.imgPath = imgPath[0];
+			systemConfig.token = token[0];
+			systemConfig.userName = userName[0];
+            systemConfig.plantId = parseInt(plantId[0]);
+            //API数据接口
+            dataCenterInterfaceConfig.hqmdzsjgl = dataCenterInterface[0].hqmdzsjgl[0];
+            // dataCenterInterfaceConfig.hqsyyhdz = dataCenterInterface[0].hqsyyhdz[0];
+            dataCenterInterfaceConfig.hqmgyhddzlb = dataCenterInterface[0].hqmgyhddzlb[0];
+            dataCenterInterfaceConfig.hqmdzlsfdl = dataCenterInterface[0].hqmdzlsfdl[0];
+            dataCenterInterfaceConfig.hqmdzmytgl = dataCenterInterface[0].hqmdzmytgl[0];
+            dataCenterInterfaceConfig.hqmdzjbxx = dataCenterInterface[0].hqmdzjbxx[0];
+            // console.log(dataCenterInterfaceConfig.hqmdzsjgl);
+		}
+
+    } catch(err) {
+        throw new BizError("服务器配置解析错误 请检查根目录下 serverConfig.xml 文件是否正确");
+    }
+}
+ 
+
+function checkConfig(config, configData) {
+    config.forEach(item => {
+        if (typeof item == "object") {
+            for (let key in item) {
+                if (!configData[key] || !configData[key][0]) {
+                    throw new SysError(SYSTEMERRORENUM.初始化配置失败, `serverConfig.xml中 缺少 ${key}`);
+                }
+                item[key].forEach( subItem => {
+                    if (!configData[key][0][subItem] || !configData[key][0][subItem][0]) {
+                        throw new SysError(SYSTEMERRORENUM.初始化配置失败, `serverConfig.xml中 ${key}缺少 ${subItem}`);
+                    }
+                });
+
+            }
+        } else {
+            if (!configData[item] || !configData[item][0]) {
+                throw new SysError(SYSTEMERRORENUM.初始化配置失败, `serverConfig.xml中 缺少 ${item}`);
+            }
+        }
+    });
+}
+

src/config/systemClass.ts

+/**
+ * 系统配置类
+ */
+
+export class ServerConfig {
+    port:number;
+    imgPath:string;
+    token:string;
+    userName:string;
+    plantId:number;
+}
+
+

src/data/interface/cronJob.ts

+//接口任务 定期更新
+import * as request from 'request';
+import { INTERFACEREQUESTTYPEENUM } from "../../config/enum";
+import { BizError } from "../../util/bizError";
+import { Config } from './interfaceConfig';
+const http = require('http');
+
+//初始化接口数据
+export async function initInterfaceData() {
+    const InitTaskSuccess = await taskUpdate();
+    // if (!InitTaskSuccess) throw new BizError("服务器启动失败: 初始化定时接口数据时出现问题 请检查目标服务器或本地请求配置");
+    const InitRealTimeSuccess = await initRealTime();
+    // if (!InitRealTimeSuccess) throw new BizError("服务器启动失败: 初始化实时接口数据时出现问题 请检查目标服务器或本地请求配置");
+    console.log("初始化接口数据成功");
+    setInterval(() => {
+        taskUpdate();
+    }, 10000);
+}
+
+//异常接口 不更新数据
+let errorInterfaceInfo = {};
+
+//定时接口 数据更新情况
+let updateInfo = {
+    "接口名称":{lastTime:0, updateUseTime:0},//使用时间是毫秒
+};
+
+//定时接口 缓存数据
+let dataQueue = {};
+
+async function taskUpdate() {
+    let thisTaskInfo = [];//此次任务
+    let defaultUseTime =  60000;
+
+    let thisTime = new Date().valueOf();
+
+    let initSuccess = true;
+
+    for (let interfaceName in Config) {
+        const LastReqError = errorInterfaceInfo[interfaceName];
+        if (LastReqError) {
+            console.log(`${interfaceName} 请求时出现过 ${LastReqError} 异常 保险起见此次更新不再请求`);
+            continue;
+        }
+
+        const ThisConfig = Config[interfaceName];
+        if (ThisConfig.type == INTERFACEREQUESTTYPEENUM.即时更新) continue;
+
+        let lastTaskInfo = updateInfo[interfaceName];
+        if ( !lastTaskInfo ) thisTaskInfo.push({name:defaultUseTime, useTime:defaultUseTime});
+        else if ( lastTaskInfo && (thisTime - lastTaskInfo) > ThisConfig.time ) {
+            thisTaskInfo.push({name:defaultUseTime, useTime:lastTaskInfo.updateUseTime});
+        }
+        defaultUseTime += 1;
+    }
+    thisTaskInfo.sort((a, b) => {return a.useTime - b.useTime});//耗时短的优先
+
+    for (let i = 0; i < thisTaskInfo.length; i++) { //更新数据
+        let {name} = thisTaskInfo[i];
+        const ThisConfig = Config[name];
+        const StartTime = new Date().valueOf();
+        
+        let reqRes;
+        switch(ThisConfig.reqType) {
+            case "get": reqRes = await get(ThisConfig.url, ThisConfig.body, ThisConfig.header); break;
+            case "post": reqRes = await post(ThisConfig.url, ThisConfig.body, ThisConfig.header); break;
+            case "postForm": reqRes = await postForm(ThisConfig.url, ThisConfig.body); break;
+        }
+        const UseTime = new Date().valueOf() - StartTime;
+        if (reqRes.success) {
+            if (!updateInfo[name]) updateInfo[name] = {lastTime:thisTime, updateUseTime:UseTime};
+            else {
+                updateInfo[name].lastTime = thisTime;
+                updateInfo[name].updateUseTime = UseTime;
+            }
+            if (dataQueue[name]) delete dataQueue[name];
+            dataQueue[name] = JSON.stringify(reqRes.body);//放入缓存
+        } else {
+            let errorMsg = reqRes.message;
+            if (reqRes.message && reqRes.message.code == "ESOCKETTIMEDOUT") errorMsg = "超时";
+            console.log(`接口 ${name} 请求失败 失败原因${errorMsg}`);
+            if (["404", "503"].indexOf(errorMsg) > -1) { //下次不再请求
+                errorInterfaceInfo[name] = errorMsg;
+            }
+            initSuccess = false;
+        }
+    }
+    return initSuccess;
+}
+
+
+//即时数据缓存 当请求失败时会用到这里的数据
+let realTimeDataQueue = {};
+
+//即时数据初始化
+async function initRealTime() {
+    let initSuccess = true;
+    for (let interfaceName in Config) {
+        const ThisConfig = Config[interfaceName];
+        if (ThisConfig.type == INTERFACEREQUESTTYPEENUM.定时更新) continue;
+        let reqRes;
+        switch(ThisConfig.reqType) {
+            case "get": reqRes = await get(ThisConfig.url, ThisConfig.body, ThisConfig.header); break;
+            case "post": reqRes = await post(ThisConfig.url, ThisConfig.body, ThisConfig.header); break;
+            case "postForm": reqRes = await postForm(ThisConfig.url, ThisConfig.body); break;
+        }
+        if (!reqRes.success) {
+            console.log(`${interfaceName} 接口请求失败 请求地址为 ${ThisConfig.url} 失败原因 ${reqRes.message}`);
+            initSuccess = false;
+        }
+        realTimeDataQueue[interfaceName] = reqRes.data;
+    }
+    return initSuccess;
+}
+
+export async function getInterfaceByInterfaceName(name, body?, header?) {
+    const ThisConfig = Config[name];
+    let data:any;
+    if (ThisConfig.type == INTERFACEREQUESTTYPEENUM.即时更新) {
+        let reqRes;
+        let reqBody = Object.assign( ThisConfig.body|| {},  body || {});
+        let reqHeader = Object.assign( ThisConfig.header|| {},  header || {});
+        switch(ThisConfig.reqType) {
+            case "get": reqRes = await get(ThisConfig.url, reqBody, reqHeader); break;
+            case "post": reqRes = await post(ThisConfig.url, reqBody, reqHeader); break;
+            case "getParmiss": reqRes = await getParmiss(ThisConfig.url, reqBody, reqHeader); break;
+            case "postParmiss": reqRes = await postParmiss(ThisConfig.url, reqBody, reqHeader); break;
+            case "postForm": reqRes = await postForm(ThisConfig.url, reqBody ); break;
+            case "postPHP": reqRes = await postPHP(ThisConfig.url, reqBody, reqHeader); break;
+        }
+        if (reqRes.success) {
+            data = reqRes.data;
+        } else {
+           data = realTimeDataQueue[name];
+        }
+        
+    } else data = dataQueue[name];
+    return data;
+}
+
+
+function get(url:string, query?, headers?, timeOut?) {
+    timeOut = timeOut || 5000;
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    return new Promise((resolve, reject)=>{
+        let paramater:any = { url, json:true, timeout:timeOut };
+        if (query) paramater.qs = query;
+        if (headers) paramater.headers = headers;
+        request.get(paramater, function (err, res, data) {
+           const success = !err && res && res.statusCode == 200;
+           let message = err || res.statusCode || "";
+           resolve({success, message, data});
+        })
+    })
+}
+
+
+function post(url, body, headers) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    let header = {"content-type": "application/json"};  
+    return new Promise((resolve, reject)=>{
+        request({
+            url: url,
+            method: "POST",
+            json: true,
+            headers: Object.assign(header, headers),
+            body: body
+        }, function(error, response, data) {
+            if (!error && response.statusCode == 0) {
+                resolve(data);
+            }
+            else {
+                reject(error || `${url} => ${JSON.stringify(data)}`)
+            }
+        });
+    })
+}
+
+
+function postForm(url, body) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    return new Promise((resolve, reject)=>{
+        request({
+            url: url,
+            method: "POST",
+            json: true,
+            form:body
+        }, function(err, res, data) {
+            const success = !err && res && res.statusCode == 200;
+            let message = err || res.statusCode || "";
+            resolve({success, message, data});
+        });
+    })
+}
+
+
+
+function postParmiss(url, reqBody, headers) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    return new Promise((resolve, reject)=>{
+        request({
+            url: url,
+            method: "POST",
+            json: true,
+            form: reqBody
+        }, function(error, response, body) {
+            resolve(body);
+        });
+    })
+}
+
+
+function getParmiss(url, query?, headers?) {
+    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 resolve(err);
+            if (r && r.statusCode != 200) return resolve( { error: 'httpError:'+r.statusCode })
+            resolve(body);
+        });
+    })
+}
+
+
+
+function postPHP(url, body, headers) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    let header = {"content-type": "application/json"};  
+    return new Promise((resolve, reject)=>{
+        request({
+            url: url,
+            method: "POST",
+            json: true,
+            headers: Object.assign(header, headers),
+            body: body
+        }, function(error, response, body) {
+            resolve(body);
+        });
+    })
+}

src/data/interface/dataInterface.ts

+import moment = require("moment");
+import { dataCenterInterfaceConfig, systemConfig } from "../../config/serverConfig";
+import { get } from "../../util/request";
+import { BizError } from "../../util/bizError";
+import { guangfuTableData } from "../table/tableData";
+
+
+/**
+ * 光伏
+ * @returns 
+ */
+export async function getGuangFu() {
+    let result = {
+        jbqk:[], //基本情况
+        nhfx:{count:[], charData:[], dayData:[]}, //能耗分析 
+        trsy:{count:[], charData:[]}, //投入使用
+        ztsj:[], //整体数据
+        xyfxfd:{count:[], chartData:[]}, //效益分析-发电
+        xyfx:{count:[], chartData:{}}, //效益分析
+        jnjp:{count:[], chartData:[]} //节能减排
+    };
+
+    // let userquery = {user_name:systemConfig.userName};
+    let header = {token:systemConfig.token};
+    let hqmdzsjgl:any = await get(dataCenterInterfaceConfig.hqmdzsjgl, {plant_id:systemConfig.plantId}, header);
+    if (!hqmdzsjgl.body) console.log("接口请求失败-获取某电站数据概览：hqmdzsjgl");
+
+    let nowTime = new Date().valueOf();
+
+    /**基本情况 */
+    let jbqkData = {
+        安全运行天数:0,
+        组件总功率:0,//todo
+        设备总数:0//todo
+    };
+
+    let hqmdzjbxx:any = await get(dataCenterInterfaceConfig.hqmdzjbxx, {plant_id:systemConfig.plantId}, header);
+    if (!hqmdzjbxx.body) console.log("接口请求失败-获取某电站基本信息：hqmdzjbxx");
+    let jzmqts = 0;
+    if (hqmdzjbxx.body) {
+        let createDate = new Date(hqmdzjbxx.body.create_date).valueOf();
+        console.log(moment(nowTime).format("YYYY-MM-DD"))
+        console.log(moment(createDate).format("YYYY-MM-DD"))
+        jzmqts = (nowTime - createDate) / (1000 * 60 * 60 * 24); //当前时间-建站日期=当前安全运行天数
+        jbqkData.安全运行天数 = Math.ceil(jzmqts) || 0;
+        for (let key in jbqkData) {
+            result.jbqk.push( {key, value:jbqkData[key]} );
+        }
+    }
+    
+
+    /**能耗分析 */
+    let nhfxData = {
+        "年用电量":0,
+        "光伏发电量":0
+    }
+
+    if (hqmdzsjgl.body) nhfxData.光伏发电量 = hqmdzsjgl.body.total_energy || 0;
+    
+    let nowYearAgo = moment(nowTime).format("YYYY-MM-DD");
+    let sixYearAgo = moment().subtract(6, 'years');
+    let startYear = moment(sixYearAgo).format("YYYY");
+
+    let nhfxquery = {
+        plant_id:systemConfig.plantId,
+        start_date:`${startYear}-01-01`,
+        end_date:nowYearAgo,
+        time_unit:"year",
+    }
+    let pjzData:any = await get(dataCenterInterfaceConfig.hqmdzlsfdl, nhfxquery, header);
+    if (!pjzData.body) console.log("接口请求失败-获取某电站历史发电量：hqmdzlsfdl");
+    let nowYear = moment(nowTime).format("YYYY");
+    //平均值
+    if (pjzData.body) {
+        pjzData.body.energys.forEach( info => {
+            let {date, energy} = info;
+            let value = Math.round((energy/365)*100)/100;
+            result.nhfx.charData.push({key:date, value});
+        
+            if (date == nowYear) nhfxData.年用电量 = energy;
+        })
+    }
+   
+
+    //当天功率
+    let query = {
+        plant_id:systemConfig.plantId,
+        date:nowYearAgo,
+    }
+    let hqmdzmytglData:any = await get(dataCenterInterfaceConfig.hqmdzmytgl, query, {token:systemConfig.token});
+    if (!hqmdzmytglData.body) console.log("接口请求失败-获取某电站某一天功率数据：hqmdzmytgl");
+    let dayData = {};
+    if (hqmdzmytglData.body) {
+        hqmdzmytglData.body.powers.forEach( info => {
+            let {time, power} = info;
+            let dayTime = moment(time).format("HH:00");
+            if (!dayData[dayTime]) dayData[dayTime] = 0;
+            if (power) dayData[dayTime] += power;
+            
+        })
+    }
+    
+    for(let key in dayData) {
+        result.nhfx.dayData.push({key, value:dayData[key]});
+    }
+    result.nhfx.dayData.sort((a, b) => {
+        return a.key - b.key
+    })
+    
+    //汇总数据
+    for (let key in nhfxData) {
+        result.nhfx.count.push( {key, value:nhfxData[key]} );
+    }
+
+    /**投入使用 */
+    let excelData = guangfuTableData();
+
+    let trsyCount = {
+        发电量:0,
+        发电时长:0
+    }
+    if (hqmdzsjgl.body) trsyCount.发电量 = hqmdzsjgl.body.total_energy;
+    trsyCount.发电时长 = jzmqts * 24; //当前安全运行天数，天换算成小时
+    
+    for (let key in trsyCount) {
+        excelData["投入使用"].dataList.push({key, value:trsyCount[key]});
+    }
+    result.trsy.count = excelData["投入使用"].dataList;
+    result.trsy.charData = excelData["投入使用趋势"].dataList;
+
+    /**整体数据 */
+    let ssData = {
+        装机容量:0,
+        总发电量:0,
+        实时功率:0
+    };
+
+    if (hqmdzsjgl.body) {
+        ssData.装机容量 = hqmdzsjgl.body.peak_power_actual;
+        ssData.总发电量 = hqmdzsjgl.body.total_energy;
+        ssData.实时功率 = hqmdzsjgl.body.current_power;
+    }
+    
+    for (let key  in ssData) {
+        result.ztsj.push({key, value:ssData[key]});
+    }
+
+    /**效益分析-发电 */
+    let xyfxfdData = {
+        今日发电:0,
+        日功率:0,
+        当前功率:0,
+        等效小时数:0
+    }
+    if (hqmdzmytglData.body) {
+        hqmdzmytglData.body.powers.forEach( info => {
+            xyfxfdData.日功率 += info.power;
+        })
+    }
+    
+    if (hqmdzsjgl.body) {
+        xyfxfdData.今日发电 = hqmdzsjgl.body.today_energy;
+        xyfxfdData.当前功率 = hqmdzsjgl.body.current_power;
+    }
+
+    let xyfxdayAgo = moment().subtract(7, 'days');
+    let xyfxnowTime = moment(xyfxdayAgo).format("YYYY-MM-DD");
+    let xyfxendTime = moment(new Date()).format("YYYY-MM-DD");
+
+    let hqmdzlsfdlQuery = {
+        plant_id:systemConfig.plantId,
+        start_date:xyfxnowTime,
+        end_date:xyfxendTime,
+        time_unit: "day",
+    }
+    /** todo 接口调用频率限制---------------------------------------------------------------------------------------- */
+    // let hqmdzlsfdlData:any = await get(dataCenterInterfaceConfig.hqmdzlsfdl, hqmdzlsfdlQuery, {token:systemConfig.token});
+    // if (!hqmdzlsfdlData) throw new BizError('数据未返回');
+    // hqmdzlsfdlData.body.energys.forEach( info => {
+    //     let {date, energy} = info;
+    //     result.xyfxfd.chartData.push({key:date, value:energy});
+    // })
+
+    // for (let key in xyfxfdData) {
+    //     result.xyfxfd.count.push( {key, value:xyfxfdData[key]} );
+    // }
+    /** todo 接口调用频率限制---------------------------------------------------------------------------------------- */
+
+    /**效益分析 */
+    let xyfxData = {
+        今日收益:0,
+        当月收益:0,
+        累计收益:0
+    };
+
+    let price = 0;
+    let ljsy = 0;
+    excelData["效益分析"].dataList.forEach( info => {
+        if (info.key == "电价") price = info.value; //今日电价
+        if (info.key == "累计收益") ljsy = info.value;
+    })
+
+    if (hqmdzsjgl.body) {
+        xyfxData.今日收益 = hqmdzsjgl.body.today_energy * price;
+        xyfxData.当月收益 = hqmdzsjgl.body.monthly_energy * price;
+    }
+    xyfxData.累计收益 = ljsy;
+
+    for (let key in xyfxData) {
+        result.xyfx.count.push({key, value:xyfxData[key]});
+    }
+
+    // 今年
+    let thisYear = [];
+    /** todo 接口调用频率限制---------------------------------------------------------------------------------------- */
+    // hqmdzlsfdlData.body.energys.forEach( info => {
+    //     let {date, energy} = info;
+    //     let thisPrice = energy * price;
+    //     thisYear.push({key:date, value:thisPrice});
+    // });
+    /** todo 接口调用频率限制---------------------------------------------------------------------------------------- */
+    result.xyfx.chartData["今年"] = thisYear;
+
+    //去年
+    /** todo 接口调用频率限制---------------------------------------------------------------------------------------- */
+    // let yearAgo = moment().subtract(1, 'years');
+    // let dayAgo = moment().subtract(7, 'days');
+    // let startDate = `${yearAgo}-${moment(dayAgo).format("-MM-DD")}`;
+    // let endDate = `${yearAgo}-${moment(nowTime).format("MM-DD")}`;
+    // let xyfxquery = {
+    //     plant_id:systemConfig.plantId,
+    //     start_date:startDate,
+    //     end_date:endDate,
+    //     time_unit:"year",
+    // }
+    // let hqmdzlsfdl:any = await get(dataCenterInterfaceConfig.hqmdzlsfdl, xyfxquery, header);
+    // if (!hqmdzlsfdl) throw new BizError('数据未返回');
+    let lastyear = [];
+    // hqmdzlsfdl.body.energys.forEach( info => {
+    //     let {date, energy} = info;
+    //     let thisPrice = energy * price; 
+    //     lastyear.push({key:date, value:thisPrice});
+    // });
+    result.xyfx.chartData["去年"] = lastyear;
+    /** todo 接口调用频率限制---------------------------------------------------------------------------------------- */
+
+    /**节能减排 */
+    result.jnjp.count = excelData["节能减排"].dataList;
+
+
+
+    return result;
+}
+
+
+
+

src/data/interface/interfaceConfig.ts

+import { INTERFACEREQUESTTYPEENUM } from "../../config/enum";
+import { dataCenterInterfaceConfig } from "../../config/serverConfig";
+//配置
+// "接口名称":{
+//     type:"1是即时更新 2是即时更新 使用 INTERFACErEQUESTTYPEENUM", 
+//     time:"更新频率毫秒 例如1小时这里就是 3600000", 
+//     url:"url地址", 
+//     reqType:"get还是post get = get post = post", 
+//     header:{}, 
+//     body:{} 
+// }
+
+const token = "73n6124cv7rq614c572x80jma7mj3yhsCAHMZC001";
+
+export const Config = {
+    "获取某电站数据概览":{type:INTERFACEREQUESTTYPEENUM.即时更新,  time:3600000*12, url:dataCenterInterfaceConfig.hqmdzsjgl,  reqType:"get",  header:{token},  body:{}},
+};

src/data/table/cyszhglData.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function cyszhglTableData() {
+    
+    let blockDataList = onceSheetBecomeOfblockData('zjny.xlsx', '产业数字化管理');
+
+    let keyValueOrTitleList = ["智能灌溉","风险类型占比","示范基地概览","示范地投入品使用记录","风险预警","产业销量排行","数字产业"];//适配 饼图 键值以及需要多个key的
+    let barChartList = ["苗情检测","种子投入品使用趋势分析","种苗投入品使用趋势分析","肥料投入品使用趋势分析","农药投入品使用趋势分析","蔬菜效益分析","渔业效益分析"]; //适配 柱状图 折线图 
+    let stringList = [];
+    let decollatePlanarList =["预警详情工单","种植种类", "种植分布","产品溯源信息"];//适配 表格
+    let titltListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+
+        
+}
\ No newline at end of file

src/data/table/gbzscbgjdAq.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function gbzscbgjdAqTableData() {
+    
+    let blockDataList = onceSheetBecomeOfblockData('zjny.xlsx', '高标准蔬菜保供基地A区');
+
+    let keyValueOrTitleList = ["A区基地详情","基地分析","产品溯源","产品分销占比"];//适配 饼图 键值以及需要多个key的
+    let barChartList = ["种植作物产量情况"]; //适配 柱状图 折线图 
+    let stringList = [];
+    let decollatePlanarList = ["种植作物品种"];//适配 表格
+    let titltListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+
+        
+}
\ No newline at end of file

src/data/table/gbzscbgjdBq.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function gbzscbgjdBqTableData() {
+    
+    let blockDataList = onceSheetBecomeOfblockData('zjny.xlsx', '高标准蔬菜保供基地B区');
+
+    let keyValueOrTitleList = ["B区基地详情","基地分析","产品溯源","产品分销占比"];//适配 饼图 键值以及需要多个key的
+    let barChartList = ["种植作物产量情况"]; //适配 柱状图 折线图 
+    let stringList = [];
+    let decollatePlanarList =["种植作物品种"];//适配 表格
+    let titltListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+
+        
+}
\ No newline at end of file

src/data/table/gfnyData.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function gfnyTableData() {
+    
+    // let blockDataList = onceSheetBecomeOfblockData('zjnt.xlsx', '光伏能源');
+
+    // let keyValueOrTitleList = ["基本情况","能耗分析","投入使用","光伏能源","效益分析","效益分析","节能减排"];//适配 饼图 键值以及需要多个key的
+    // let barChartList = ["发电功率平均值分析","发电功率最大值分析","投入使用趋势","发电量趋势","累计减排统计"]; //适配 柱状图 折线图 
+    // let stringList = [];
+    // let decollatePlanarList =[];//适配 表格
+    // let titltListConfig = {};
+
+    // let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    // return result;
+
+        
+}
\ No newline at end of file

src/data/table/hjszzlData.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function hjszzlTableData() {
+    
+    let blockDataList = onceSheetBecomeOfblockData('zjny.xlsx', '环境数字治理');
+
+    let keyValueOrTitleList = ["天气检测","土壤检测","水质检测","环境基础分析","治理情况","灾害性应急管理", "病害虫治理", "虫害检测灯预警", "气象灾害列表"];//适配 饼图 键值以及需要多个key的
+    let barChartList = ["气温趋势","土壤微量元素监测","浊度趋势变化","温度趋势变化","PH值趋势变化","NH3-N趋势变化","溶解氧趋势变化","虫害治理成效"]; //适配 柱状图 折线图 //
+    let stringList = [];
+    let decollatePlanarList =["天气检测表"];//适配 表格
+    let titltListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+
+        
+}
\ No newline at end of file

src/data/table/jdaqglData.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function jdaqglTableData() {
+    
+    let blockDataList = onceSheetBecomeOfblockData('zjny.xlsx', '基地安全管理');
+
+    let keyValueOrTitleList = ["设备类型占比","设备数量","设备状态情况","消防设备","消防设备状态","基地安全管理数据分析","天气数据","设备运行监测","紧急程度","预警处置","预警处置率","重点区域监控"];//适配 饼图 键值以及需要多个key的
+    let barChartList = ["近七天设备在线情况","告警趋势"]; //适配 柱状图 折线图 
+    let stringList = [];
+    let decollatePlanarList =["正常状态列表","维护中状态列表","故障状态列表","预警处置表"];//适配 表格
+    let titltListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+
+        
+}
\ No newline at end of file

src/data/table/jkspData.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function jkspTableData() {
+    
+    let blockDataList = onceSheetBecomeOfblockData('zjny.xlsx', '监控视频');
+
+    let keyValueOrTitleList = ["监控视频"];//适配 饼图 键值以及需要多个key的
+    let barChartList = []; //适配 柱状图 折线图 
+    let stringList = [];
+    let decollatePlanarList =[];//适配 表格
+    let titltListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+
+        
+}
\ No newline at end of file

src/data/table/nyjqrData.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function nyjqrTableData() {
+    
+    let blockDataList = onceSheetBecomeOfblockData('zjny.xlsx', '农业机器人');
+
+    let keyValueOrTitleList = ["机器人类型占比","机器人资源","运行状态","农业机器人数据","智能巡检","巡检完成情况","智能机器人产量","机器人类型占比","机器人数据分析"];//适配 饼图 键值以及需要多个key的
+    let barChartList = ["运势趋势分析","区域分布","巡检设备类型","巡检趋势","近半年产量趋势"]; //适配 柱状图 折线图 
+    let stringList = [];
+    let decollatePlanarList =["运行记录","巡检记录"];//适配 表格
+    let titltListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+
+        
+}
\ No newline at end of file

src/data/table/sdt1hgfbData.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function sdt1hgfbTableData() {
+    
+    let blockDataList = onceSheetBecomeOfblockData('zjny.xlsx', '水稻田1号光伏板');
+
+    let keyValueOrTitleList = ["光伏板","电机","光伏数据统计"];//适配 饼图 键值以及需要多个key的
+    let barChartList = ["光伏数据统计","预测与实际"]; //适配 柱状图 折线图 
+    let stringList = [];
+    let decollatePlanarList =["光伏实时信息"];//适配 表格
+    let titltListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+
+        
+}
\ No newline at end of file

src/data/table/tableData.ts

+/**
+ * 
+ */
+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+
+export function guangfuTableData() {
+    let blockDataList = onceSheetBecomeOfblockData('光伏.xlsx', 'Sheet1');
+
+    let keyValueOrTitleList = ['投入使用', '投入使用趋势', '效益分析', '节能减排']; //适配 饼图 键值以及需要多个Key的
+    let barChartList = []; //适配 柱状图 折线图
+    let stringList = [];
+    let decollatePlanarList = []; //适配 表格
+    let titleListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titleListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+}
+
+
+
+export function jiQiRenTableData() {
+    let blockDataList = onceSheetBecomeOfblockData('机器人.xlsx', 'Sheet1');
+
+    let keyValueOrTitleList = ['机器人类型占比', '运行状态', '顶部指标']; //适配 饼图 键值以及需要多个Key的
+    let barChartList = ['巡检设备类型', '巡检趋势', '运行趋势分析', '区域布局', '智能机器人产量']; //适配 柱状图 折线图
+    let stringList = [];
+    let decollatePlanarList = ['运行记录', '巡检记录']; //适配 表格
+    let titleListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titleListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+}
+
+
+
+

src/data/table/yzdqxdnyzlData.ts

+
+import { planarArrDecollateForIndex, planarArrDeconstruct, planarArrForObjectList } from "../../dataPackage/planaryArrayAnalysis";
+import { onceSheetBecomeOfblockData } from "../../util/analysisExcel";
+
+function packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList) {
+    let result = {};
+
+    for (let i = 0; i < blockDataList.length; i++) {
+        let {blockData, blockTitle} = blockDataList[i];
+        if (keyValueOrTitleList.indexOf(blockTitle) > -1) {
+            let titleList = titltListConfig[blockTitle] || [];
+            result[blockTitle] = planarArrForObjectList(blockData, 0, titleList);
+        }
+        else if (barChartList.indexOf(blockTitle) > -1) {
+            result[blockTitle] = planarArrDeconstruct(blockData);
+        }
+        else if (stringList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrForObjectList(blockData);
+        else if (decollatePlanarList.indexOf(blockTitle) > -1) result[blockTitle] = planarArrDecollateForIndex(blockData);
+    }
+
+    return result;
+}
+
+export function yzdqxdnyzlTableData() {
+    
+    let blockDataList = onceSheetBecomeOfblockData('zjny.xlsx', '现代农业走廊');
+
+    let keyValueOrTitleList = ["水资源利用率","自然资源","企业情况","产业结构","产业主体结构","重点项目建设","专家服务","技术创新引进情况","引进技术基础数据","创新技术基础数据",
+        "经营管理情况","经营管理情况趋势图","专业员工类型","总体数据分布","项目分析"];//适配 饼图 键值以及需要多个key的
+    let barChartList = ["创新技术创新趋势","引进技术创新趋势"]; //适配 柱状图 折线图 
+    let stringList = [];
+    let decollatePlanarList =[];//适配 表格
+    let titltListConfig = {};
+
+    let result = packageDataProcess(blockDataList, titltListConfig, keyValueOrTitleList, barChartList, stringList, decollatePlanarList);
+    return result;
+
+        
+}
\ No newline at end of file

src/dataPackage/inBackOut.ts

+//打包完数据之后的处理
+
+/**
+ * recombinationObject 重组对象 在打包完数据后使用 必须是keyvalue之后
+ * @param data [{key:key1, value:value1, unit:unit1 }, {key:key2, value:value2, unit:unit2}]
+ * @param check {"key2":[{key:"key1", name:""}] }
+ * @returns [{key:key1, value:value1, key2:key2, value2:value2}]
+ */
+ export function recombinationObject(data, checkInfo) {
+    let dataMap = {};
+    data.forEach(info => {
+        let { key } = info;
+        dataMap[key] = info;
+    });
+    let removeKeyMap = {};
+
+    for (let checkKey in checkInfo) {
+        let checkList = checkInfo[checkKey];
+        checkList.forEach(item => {
+            let {key, name} = item;
+
+            removeKeyMap[key] = 1;
+            let onceCheck = dataMap[key];
+           
+            dataMap[checkKey][name] = onceCheck.value;
+            dataMap[checkKey][`${name}Unit`] = onceCheck.unit;
+        });
+    }
+
+
+    let dataList = [];
+    data.forEach(info => {
+        let { key } = info;
+        if (removeKeyMap[key]) return;
+        dataList.push(dataMap[key]);
+    });
+
+    return dataList;
+}

src/dataPackage/interfaceAnalysis.ts

+/**
+ * changeObjectToList  将对象形式的数据转换为keyvalue的数组  对象中的键名称将作为key  传入mapping时 使用对应的change作为key的值
+ * @param data 数据{key1:value1, key2:value2, key3:value3...}
+ * @param reflect 对应关系 [{key:"key1",change:"名称1"},{key:"key2", change:"名称2"},{key:"key3", change:"名称3"}]
+ * @returns [{key:"名称1", value:value1}, {key:"名称2", value:value2}, {key:key3, value:value3}]
+ */
+export function changeObjectToList(data, reflect?) {
+    let keyList = [];
+    if (!reflect || !reflect.length) {
+        for (let key in data) {
+            keyList.push({key, change:key});
+        }
+    }
+
+    let dataList = [];
+    keyList.forEach(info => {
+        let {key, change} = info;
+        let value = data[key];
+        if (value) dataList.push({ key:change, value:`${value}`});
+    });
+
+   return dataList;
+}
+
+
+/**
+ * changeObjectKey  按mapping的对应关系修改 data中的key  如果对应关系中找不到，则会使用原来的key
+ * @param data {key1:value1, key2:value2, key3:value3...}
+ * @param reflect {"key1":"名称1", "key2":"名称2", "key3":"名称3"}
+ * @returns {"名称1":value1, "名称2":value2, "名称3":value3}
+ */
+export function changeObjectKey(data, reflect) {
+    let result = {};
+    for (let key in data) {
+        let changeKey = reflect[key] || key;
+        result[changeKey] = `${data[key]}`;
+    }
+
+    return result;
+}
+
+/**
+ * changeListObjectToListByReflect  将data中的object的key替换成 reflect对应的值
+ * @param data [{key1:value1, key2:value2...}, {key1:value1, key2:value2...}, {key1:value1, key2:value2...}]
+ * @param reflect 映射 不传就不会替换 {"key1":"名称1", "key2":"名称2", "key3":"名称3"}
+ * @returns  [{"名称1":value1, "名称2":value2...}, {"名称1":value1, "名称2":value2...}, {"名称1":value1, "名称2":value2...}]
+ */
+export function changeListObjectToListByReflect(data, reflect?) {
+    let dataList = [];
+    if (!reflect) return dataList;
+
+    data.forEach(item => {
+        let changeInfo = {};
+        for (let key in item) {
+            let newKey = reflect[key] || key;
+            changeInfo[newKey] = `${item[key]}`;
+        }
+        dataList.push(changeInfo);
+    });
+
+    return dataList;
+}
+
+
+
+/**
+ * getDesignativByReflect 获取data中指定的的key
+ * @param data  [{key1:value1, key2:value2, key3:value3...}, {key1:value1, key2:value2, key3:value3...}, {key1:value1, key2:value2, key3:value3...}] 或者 {key1:value1, key2:value2, key3:value3...}
+ * @param reflect List 映射 必须参数 ["key1", "key2"]  为key的名称 
+ * @returns [{key1:value1, key2:value2, ...}, {key1:value1, key2:value2, ...}, {key1:value1, key2:value2, ...}]
+ */
+export function getDesignativByReflect(data, reflect) {
+    if (typeof data != "object") return data;
+    let type = Array.isArray(data) ? "array" : "object";
+
+    if ((type == "array" && !reflect.length) || (type == "object" && !Object.keys(reflect) ) ) return data;
+    let reflectMap = {};
+    reflect.forEach(keyName => {reflectMap[keyName] = 1});
+
+    if (type=="array") {
+        let dataList = [];
+        data.forEach(item => {
+            let once = {};
+            for (let key in item) {
+                if (!reflectMap[key]) continue;
+                once[key] = item[key];
+            }
+            dataList.push(once);
+        });
+
+        return dataList;
+    } else {
+        let dataInfo = {};
+        for(let key in reflectMap) {
+            if (data[key]) dataInfo[key] = data[key];
+        }
+        return dataInfo;
+    }
+}
+
+/**
+ * designativListKeyAddUnit为集合中指定的key添加单位
+ * @param data [{key1:value1, key2:value2, key3:value3...}, {key1:value1, key2:value2, key3:value3...}, {key1:value1, key2:value2, key3:value3...}]
+ * @param reflect {key1:"%", key2:"个"}
+ * @returns [{key1:"value1%", ke2:"value2个", keys:"value3"}]
+ */
+export function designativListKeyAddUnit(data, reflect) {
+    let dataList = [];
+    data.forEach(item => {
+        let onceData = {};
+        for (let key in item) {
+            let unit = reflect[key] || '';
+            onceData[key] = `${item[key]}${unit}`
+        }
+        dataList.push(onceData);
+    });
+    return dataList;
+}
\ No newline at end of file

src/dataPackage/out.ts

+import { separateDataAndUint, unifiedMaxAndMinValueAndStep } from "./tool";
+//数据出口封装 只做封装 少量的数据校验
+
+/**
+ * getStringOut  获取文字列表返回结果
+ * @param title  数据标题
+ * @param data 数据体 格式:["txt...", "str..."]
+ * @returns {title, dataList:[string...]}
+ */
+export function getStringOut(title, data) {
+    let dataList = [];
+    data.forEach( (str) => {
+        dataList.push(str);
+    });
+    return { title, dataList};
+}
+
+/**
+ * getOnceYBarChartOut  获取单y轴柱状图
+ * @param title 数据标题 
+ * @param data  数据体  格式： {xUnit:x轴单位, yUnit:y单位, dataInfo:{"图表名称":[{key:"数据key", value:"数据值", unit:"单位" }, {key:"数据key", value:"数据值", unit:"单位" } ]    }   }
+ * @returns {title:标题, xUnit:x轴单位, yUnit:y轴单位, yMinValue:最小值, yMaxValue:最大值, yStepValue:间隔, 
+ * chartList:[{thisChartTitle:数据名称, total:总数, unit:单位, dataList:[{name:y轴名称, value:值, unit:单位}] } ]}
+ * 入参data里面的dataInfo中的unit可以为空 会读取yUnit 所以入参优先度 yUnit > unit  默认值都是空字符串
+ */
+export function getOnceYBarChartOut(title, data, stepCount?) {
+    let chartList = [];
+    let {xUnit, yUnit, dataInfo} = data;
+
+    let thisYUnit = yUnit ||"";
+
+    let min = new Date().valueOf();
+    let max = 0;
+    for (let dataName in dataInfo) {
+        let onceChartList = dataInfo[dataName];
+
+        let dataList = [];
+        let total = 0;
+
+        onceChartList.forEach(item => {
+            let {key, value, unit} = item;
+            min = Math.min(value, min);
+            max = Math.max(value, max);
+            total += value;
+            dataList.push({name:key, value, unit: unit || thisYUnit});
+        });
+
+        chartList.push({thisChartTitle:dataName, total, unit:thisYUnit, dataList});
+    }
+    
+    let {maxNumber, minNumber, stepNumber} = unifiedMaxAndMinValueAndStep(max, min, stepCount);
+
+    return {title, xUnit, yUnit:thisYUnit, yMinValue:minNumber, yMaxValue:maxNumber, yStepValue:stepNumber, chartList};
+}
+
+/**
+ * getDoubleYBarChartOut  获取双y轴柱状图
+ * @param title 数据标题 
+ * @param data 数据体 格式：{xUnit:x轴单位, leftYUnit:左边y单位, rightYUnit:右边y单位 dataInfo:{"图表名称":{from:"left", subList:[{key:"数据key", value:"数据值", unit:"单位" }, {key:"数据key", value:"数据值", unit:"单位" } ]}    }   }
+ * @returns {title:标题, xUnit:x轴单位, leftYUnit:左边单位, rightYUnit:右边单位, leftYMinValue:左边最小值, leftYMaxValue:左边最大值, leftYStepValue:左边间隔,
+ * rightYMinValue:右边最小值, rightYMaxValue:右边最大值, rightYStepValue:右边间隔,
+ * dataList:[{subTitle:数据名称, total:总数, unit:单位, subDataList:[{name:y轴名称, value:值, unit:单位}] }] }
+ * 入参data里面的dataInfo中的unit可以为空 会读取yUnit 所以入参优先度 yUnit > unit  默认值都是空字符串
+ */
+export function getDoubleYBarChartOut(title, data, stepCountInfo?) {
+    stepCountInfo = stepCountInfo || {left:5, right:5};
+    let dataList = [];
+    let {xUnit, leftYUnit, rightYUnit, dataInfo} = data;
+
+    let thisLeftYUnit = leftYUnit || "";
+    let thisRightYUnit = rightYUnit || "";
+
+    let leftMin = new Date().valueOf();
+    let leftMax = 0;
+    let rightMin = new Date().valueOf();
+    let rightMax = 0;
+
+    for (let dataName in dataInfo) {
+        let {subList, from} = dataInfo[dataName];
+
+        let subDataList = [];
+        let total = 0;
+
+        let thisDataUnit = from == "left" ? thisLeftYUnit : thisRightYUnit;
+
+        subList.forEach(item => {
+            let {key, value, unit} = item;
+
+            if (from == "left") {
+                leftMin = Math.min(value, leftMin);
+                leftMax = Math.max(value, leftMax);
+            } else {
+                rightMin = Math.min(value, rightMin);
+                rightMax = Math.max(value, rightMax);
+            }
+            
+            total += value;
+            subDataList.push({name:key, value, unit:unit || thisDataUnit});
+        });
+        
+        dataList.push({subTitle:dataName, total, unit:thisDataUnit, subDataList});
+    }
+    
+    let leftInfo = unifiedMaxAndMinValueAndStep(leftMax, leftMin,stepCountInfo.left);
+    let rightInfo = unifiedMaxAndMinValueAndStep(rightMax, rightMin,stepCountInfo.right);
+
+    return {title, xUnit, leftYUnit:thisLeftYUnit, rightYUnit:thisRightYUnit, leftYMinValue:leftInfo.minNumber, leftYMaxValue:leftInfo.maxNumber, leftYStepValue:leftInfo.stepNumber,
+    rightYMinValue:rightInfo.minNumber, rightYMaxValue:rightInfo.maxNumber, rightYStepValue:rightInfo.stepNumber, dataList}
+}
+
+/**
+ * getTableOut  获取列表返回
+ * @param title 数据标题
+ * @param data 数据体 格式：{titleList:[], dataList:[{a,b,c},{a,b,c},{a,b,c}] }
+ * @returns {title:数据标题, total:数据总条数, titleList:[表头...], valueList:[[a,b,c,d...],[a,b,c,d...]] }
+ * 解出来的对象的key是需要有顺序的，所以进这里之前要把值a-z排好序，按显示要求排序，
+ */
+export function getTableOut(title, data) {
+    
+    let {titleList, dataList} = data;
+
+    let valueList = [];
+
+    dataList.forEach(info => {
+        let subList = [];
+        for (let key in info) {
+            subList.push(info[key]);
+        } 
+        valueList.push(subList);
+    });
+    return { title, total:dataList.length, titleList, valueList };
+}
+
+
+/**
+ * getKeyValueOut 获取键值的返回结果
+ * @param title 数据标题
+ * @param data 数据体 [{key:"", value:"", unit:""}]
+ * @returns {title:数据标题, dataList:[], total:数据值总数, count:数据总条数 }
+ */
+export function getKeyValueOut(title, data) {
+    let dataList = [];
+
+    let total = 0;
+    data.forEach(info => {
+        let {key, value, unit} = info;
+        let typeChangeValue;
+        if (!isNaN(value)) {
+            typeChangeValue = parseFloat(value); 
+            total+= typeChangeValue;
+        } else typeChangeValue = value;
+        dataList.push({name:key, value:typeChangeValue, unit});
+    });
+
+    return {title, total, count:dataList.length, dataList};
+}
+
+/**
+ * getObjectListOut 获取对象数组结果
+ * @param title 数据标题
+ * @param data 数据体 [{value:"", value:"", unit:""}]
+ * @returns {title:数据标题, dataList:[{name:"", value:"", key1:"", key2:""}] }
+ */
+export function getObjectListOut(title, data) {
+    //todo 没有特殊逻辑
+    return {title, dataList:data};
+}
+
+
+/**
+ * getRankOut 获取排名结果
+ * @param title 数据标题
+ * @param data 数据体 {unit, max, dataInfo:[{key, value, details}, {}, {}, {}] }
+ * @returns  {title:数据标题, max, unit dataList:[{name, value, unit, rankNumber}] }
+ */
+export function getRankOut(title, data) {
+    let {unit, max, dataInfo} = data;
+    
+    let dataList = [];
+    dataInfo.forEach((info, index) => {
+        let {key, value} = info;
+        let rankNumber = index + 1;
+        dataList.push({name:key, value, details:info.details, rankNumber});
+    });
+
+
+    return { title, unit, max, dataList };
+}
+
+
+/**
+ * getRadarChartOut 获取雷达图
+ * @param title 数据标题
+ * @param data 数据体  [{key, value, max, unit}]
+ * @returns {title:数据标题, dataList:[{name:"指标名称", max:"最大值", value:"当前值", unit:"单位"}]}
+ */
+export function getRadarChartOut(title, data) {
+    let dataList = [];
+    data.forEach(info => {
+        dataList.push({
+            name:info.key,
+            value:info.value, 
+            max:info.max,
+            unit:info.unit
+        });
+    });
+    return {title, dataList};
+}
+
+/**
+ * getMapOut 地图数据
+ * @param title 数据标题
+ * @param data 数据体 [{name:数据名称, x:x坐标, y:坐标, coordinate:[经度, 纬度], unit:单位,  value:值, details:"补充"}]
+ * @returns {title:数据标题, dataList:[{name:数据名称, x:x坐标, y:坐标, coordinate:[经度, 纬度], unit:单位,  value:值, details:"补充"} ]  }
+ */
+export function getMapOut(title, data) {
+    //todo 无特殊逻辑
+    return {title, dataList:data};
+}
+
+/**
+ * getScatterFigureOutData  获取撒点图的返回结果
+ * @param title 标题
+ * @param data 数据 格式 [{x, y, name}, {x, y, name}, {x, y, name}, {x, y, name}]
+ * @returns { title:标题, xMax:x轴最大值, xMin:x最小值, yMax:y最大值, yMin:y最小值, dataList:[{name:点的名称, value:[x坐标, y坐标]} ] };
+ */
+export function getScatterFigureOutData(title, data) {
+    let dataList = [];
+    let xMaxNumber = 0;
+    let xMinNumber = new Date().valueOf();
+    let yMaxNumber = 0;
+    let yMinNumber = new Date().valueOf();
+
+    data.forEach(item => {
+        let { x, y, name } = item;
+        let xCoordinateInfo = separateDataAndUint(x);
+        let yCoordinateInfo = separateDataAndUint(y);
+
+        const XNumber = xCoordinateInfo.dataNum;
+        const YNumber = yCoordinateInfo.dataNum;
+
+        yMaxNumber = Math.max(YNumber, yMaxNumber);
+        yMinNumber = Math.min(YNumber, yMinNumber);
+        xMaxNumber = Math.max(XNumber, xMaxNumber);
+        xMinNumber = Math.min(XNumber, xMinNumber);
+
+        let value = [XNumber, YNumber];
+        dataList.push({ value, name:name || "" });
+
+    });
+
+    let xMaxMinInfo = unifiedMaxAndMinValueAndStep(xMaxNumber, xMinNumber);
+    let yMaxMinInfo = unifiedMaxAndMinValueAndStep(yMaxNumber, yMinNumber);
+
+    return { title, xMax:xMaxMinInfo.maxNumber, xMin:xMaxMinInfo.minNumber, yMax:yMaxMinInfo.maxNumber, yMin:yMaxMinInfo.minNumber, dataList };
+}

src/dataPackage/planaryArrayAnalysis.ts

+import { BizError } from "../util/bizError";
+import pyfl from 'pyfl';
+//disintegrate 分解二维数据源数据
+
+
+/**
+ * planarArrForObjectList  解析二维数组
+ * @param planarArr 二维数组 例子:[[title1, title2, title3, title4],[value1, value2, value3, value4],[value5, value6, value7, value8]]
+ * @param titleIndex  标题集合所在第一层数组的下标 
+ * @param titleList 自定义标题列表 不传则会取每个title的中文首字母作为key
+ * @returns {"dataList":[{title1:value1, title2:value2, title3:value3, title4:value4}, {title1:value5, title2:value6, title3:value7, title4:value8}], titleList:[]}
+ */
+export function planarArrForObjectList(planarArr, titleIndex = 0, titleList = []) {
+    let dataTitleList = [];
+    let dataMaxLength = 0;
+    for (let i = titleIndex; i< planarArr.length; i++) {
+        let subList = planarArr[i];
+        if (i == titleIndex) {
+            dataTitleList = subList;
+            continue;
+        }
+        dataMaxLength = Math.max(subList.length, dataMaxLength);
+    }
+
+    let useTitleList = !titleList.length ? changeChineseTitleIntoEnglish(dataTitleList) : titleList;
+    if (dataMaxLength == 2 && !titleList.length) useTitleList = ["key", "value"];
+    
+    if (dataTitleList.length < dataMaxLength ) throw new BizError(`解析时数据异常 数据长度：${dataMaxLength} 大于 标题长度${dataTitleList}`);
+    if (titleList.length && titleList.length < dataMaxLength) throw new BizError(`解析时数据异常 传入标题长度${titleList.length} 数据最大长度${dataMaxLength}`);
+
+    let dataList = [];
+    for (let i = (titleIndex + 1); i< planarArr.length; i++) {
+        let subList = planarArr[i];
+        let addInfo:any = {};
+        subList.forEach((item, index) => {
+            let key = useTitleList[index];
+            let value = item;
+            addInfo[key] = value;
+        });
+        dataList.push(addInfo);
+    }
+
+    return {dataList, titleList:useTitleList };
+}
+
+function changeChineseTitleIntoEnglish(titles) {
+    let result = [];
+    titles.forEach(chineseStr => {
+        result.push(pyfl(chineseStr).toLowerCase());
+    });
+    return result;
+}
+
+/**
+ * planarArrDeconstruct 解构二维数组 
+ * 第一列是名称 
+ * @param planarArr 二维数组 例：[[name, 1月, 2月, 3月],[数据1, 1月数据, 2月数据,3月数据 ],[数据2, 1月数据, 2月数据,3月数据]]
+ * @param titleIndex 标题集合所在第一层数组的下标
+ * @returns [{"name":"", data:[{key:"1月", value:"1月数据"}, {key:"2月", value:"2月数据"} ]}];
+ */
+export function planarArrDeconstruct(planarArr, titleIndex = 0) {
+    let dataInfo = []
+    let titleList = [];
+    for (let i = titleIndex; i < planarArr.length; i++) {
+        let subList = planarArr[i];
+        if (titleIndex == i){
+            titleList = subList;
+        } else {
+            let thisDataName = "";
+            let thisDataList = [];
+            subList.forEach((item, index) => {
+                if (!index) {
+                    thisDataName = item;
+                    return;
+                }
+                let key = titleList[index];
+                thisDataList.push({key, value:item});
+            });
+            dataInfo.push({name:thisDataName, data:thisDataList});
+        }
+    }
+
+    return dataInfo;
+}
+
+/**
+ * planarArrDecollateForIndex 拆解二维数组
+ * @param planarArr 二维数组
+ * @param decollateIndex 拆解开始的下标
+ * @returns {headerList:decollateIndex下标之前的集合(包括decollateIndex), bodyList:decollateIndex下标之后的集合(不包括decollateIndex)}
+ */
+export function planarArrDecollateForIndex(planarArr, decollateIndex = 0) {
+    let headerList = planarArr.slice(decollateIndex, decollateIndex + 1);
+    let bodyList = planarArr.slice(decollateIndex + 1, planarArr.length);
+    return {headerList, bodyList};    
+}
+
+

src/dataPackage/public.ts

+//excel 和 接口都可以使用的格式化数据的方法
+
+/**
+ * objBecomeOfList  对象变成数组  value不限制类型
+ * @param obj 对象 {"key1":"value1", "key2":"value2"}
+ * @param keyName 指定key的名称 默认 name
+ * @param valueName 指定value的名称  默认 data
+ * @returns [{name:"key1", "data":"value1"}, ...]
+ */
+export function objBecomeOfList(obj, keyName="name", valueName="data") {
+    let result = [];
+    for (let key in obj) {
+        let once:any = {};
+        once[keyName] = key;
+        once[valueName] = obj[key];
+        result.push(once);
+    }
+    return result;
+}
+
+/**
+ * objChangeKey  obj改变key
+ * @param obj {"key1":"value1", "key2":"value2"}
+ * @param checkKeyInfo {"key1":"eKey1", "key2":"eKey2"}
+ * @returns  
+ */
+export function objChangeKey(obj, checkKeyInfo) {
+    let result = {};
+    for (let key in obj) {
+        let newKey = checkKeyInfo[key] || key;
+        result[newKey] = obj[key];
+    }
+    return result;
+}
+
+
+/**
+ * objListChangeKey  objList 改变key
+ * @param objList 
+ * @param checkKeyInfo 
+ * @returns 
+ */
+export function objListChangeKey(objList, checkKeyInfo) {
+    return 
+}
\ No newline at end of file

src/dataPackage/tool.ts

+/**
+ * separateDataAndUint 截取字符串中的单位
+ * @param str 待处理字符串
+ * @returns {dataNumber:数据, dataUnit:单位}
+ */
+ export function separateDataAndUint(str) {
+    str = `${str}`;
+    if (!str) return {dataNum:0, dataUnit:""};
+    let dataNum = parseFloat(str.replace(/[\u4E00-\u9FA5a-zA-Z]+/,""));
+    let dataUnit = str.replace(/^(-)?\d+(\.\d+)?/, "");
+    return {dataNum, dataUnit};
+}
+
+/**
+ * unifiedMaxAndMinValueAndStep 求最大最小值以及间隙 
+ * @param max 最大
+ * @param min 最小
+ * @param count 分多少份 默认5
+ * @returns {maxNumber:向上留值最大, minNumber:向下留值最小, stepNumber:间隔};
+ */
+ export function unifiedMaxAndMinValueAndStep(max, min, count=5) {
+    let maxNumber = Math.ceil(max);
+    let minNumber = Math.floor(min);
+
+    function getNumberInLength(length) {
+        let lengthCount = 1;
+        for (let i = 1; i < length; i++) {
+            lengthCount = lengthCount * 10;
+        }
+        return lengthCount;
+    }
+
+    let maxNumberLength = getNumberInLength(`${maxNumber}`.length);
+    let minNumberLength = getNumberInLength(`${minNumber}`.length);
+    
+    if (maxNumber <= 10 && maxNumber > 0) maxNumber = 10;
+    else maxNumber = Math.ceil(maxNumber / maxNumberLength) * maxNumberLength;
+    minNumber =  Math.floor(minNumber / minNumberLength) * minNumberLength;
+    
+    let stepNumber = Math.ceil((maxNumber - minNumber) / count);
+
+    return {maxNumber, minNumber, stepNumber};
+}
+

src/main.ts

+
+import { initInterfaceData } from "./data/interface/cronJob";
+import { httpServer } from "./net/http_server";
+import { initConfig, systemConfig } from "./config/serverConfig";
+
+async function lanuch() {
+    test();
+    await initConfig();
+    // initInterfaceData();
+    httpServer.createServer( systemConfig.port );
+
+    console.log('This indicates that the server is started successfully.');
+}
+
+function test() {
+}
+
+lanuch();

src/middleware/checkToken.ts

+
+export async function checkToken(req, res, next) { 
+    next();
+}
\ No newline at end of file

src/middleware/encryptionReturn.ts

+export async function encryptionReturn(req, res, next) {
+    res.on('end', function(){
+        console.log(res.body);
+    });
+
+    let resSend = res.send;
+    res.send = (obj)=>{
+        changeNumber(obj);
+        //递归修改number型
+        resSend.call(res, obj);
+    };
+    
+    next();
+}
+
+function changeNumber(obj) {
+    if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+            let arrItem = obj[i];
+            if (typeof arrItem == "number") {
+                obj[i] = getSameLenNumber(arrItem);
+            }
+            else if (typeof arrItem == "object") {
+                changeNumber(arrItem);
+            }
+        }
+    }
+    else {
+        for (let key in obj) {
+            let objItem = obj[key];
+            if (typeof objItem == "number") {
+                if (key == "x" || key == "y") continue;
+                
+                obj[key] = getSameLenNumber(objItem);
+            }
+            else if (typeof objItem == "object") {
+                changeNumber(objItem);
+            }
+        }
+    }
+}
+
+function getSameLenNumber(num) {
+    let numStr = String(num);
+    //疑似年份的不做加密
+    if (numStr.length == 4 && (numStr.indexOf("19") == 0 || numStr.indexOf("20") == 0)) return num;
+    let str = "";
+    for (let i = 0; i < numStr.length; i++) {
+        if (numStr[i] == '.') str += numStr[i];
+        else str += "6";
+    }
+
+    return Number(str);
+}
\ No newline at end of file

src/middleware/fromParam.ts

+var formidable = require("formidable");
+
+export async function parseFormParam(req, res, next) {
+        var form = new formidable.IncomingForm();
+        form.parse(req, (err, fields, files)=>{
+            if (err) {
+               next(err)
+            }
+            else {
+                req.fields = fields;
+                req.files = files;
+                next();
+            }
+        })
+    }
\ No newline at end of file

src/net/http_server.ts

+import express = require('express');
+import bodyParser = require('body-parser');
+import sign = require('../middleware/sign');
+import routers = require('../routers/router');
+import compression = require('compression');
+import * as fallback from 'express-history-api-fallback';
+import * as path from "path";
+
+
+export class httpServer {
+   static createServer(port:number) {
+    var httpServer = express();
+    
+    httpServer.all('*',function (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');
+      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');
+      if(req.method === 'OPTIONS'){
+          res.statusCode = 200;
+          res.end();
+        }else{
+            next();
+        }
+    });
+
+    httpServer.use(express.static('public') );
+    httpServer.use(express.static('img') );
+
+    httpServer.use(bodyParser.json({limit:"10kb"}));
+    httpServer.use(compression())
+    routers.setRouter(httpServer);
+
+    const root = path.join(__dirname, "../../public/")
+    httpServer.use(express.static(root))
+    httpServer.use(fallback('index.html', { root }))
+    console.log('web listen on port:'+port);
+    
+    
+    httpServer.listen(port);
+    console.log('server listen on port:'+port);
+    
+    return httpServer;
+  }
+}

src/routers/router.ts

+
+import * as asyncHandler from 'express-async-handler'
+
+import * as leftBiz from '../biz/getData';
+import * as jiQiRenBiz from '../biz/jiQiRen';
+        
+import * as cyszhglBiz from '../biz/cyszhgl';
+        
+import * as gfnyBiz from '../biz/gfny';
+        
+import * as sdt1hgfbBiz from '../biz/sdt1hgfb';
+
+import * as yzdqxdnyzlBiz from '../biz/yzdqxdnyzl';
+        
+import * as hjszzlBiz from '../biz/hjszzl';
+        
+import * as nyjqrBiz from '../biz/nyjqr';
+        
+import * as jdaqglBiz from '../biz/jdaqgl';
+        
+import * as gbzscbgjdAqBiz from '../biz/gbzscbgjdAq';
+
+import * as gbzscbgjdBqBiz from '../biz/gbzscbgjdBq';
+        
+export function setRouter(httpServer){
+    /**竖屏 */
+    httpServer.get('/left', asyncHandler(leftBiz.getLeft));
+    httpServer.get('/data', asyncHandler(leftBiz.getData));
+    httpServer.get('/right', asyncHandler(leftBiz.getRight));
+
+    //机器人
+    httpServer.get('/jiqiren/left', asyncHandler(jiQiRenBiz.getLeft));
+    httpServer.get('/jiqiren/top', asyncHandler(jiQiRenBiz.getTop));
+    httpServer.get('/jiqiren/right', asyncHandler(jiQiRenBiz.getRight));
+
+    //======post
+        
+    httpServer.post('/cyszhgl', asyncHandler(cyszhglBiz.getData));
+        
+    httpServer.post('/gfny', asyncHandler(gfnyBiz.getData));
+        
+    httpServer.post('/sdt1hgfb', asyncHandler(sdt1hgfbBiz.getData));
+
+    httpServer.post('/yzdqxdnyzl', asyncHandler(yzdqxdnyzlBiz.getData));
+        
+    httpServer.post('/hjszzl', asyncHandler(hjszzlBiz.getData));
+        
+    httpServer.post('/nyjqr', asyncHandler(nyjqrBiz.getData));
+        
+    httpServer.post('/jdaqgl', asyncHandler(jdaqglBiz.getData));
+        
+    httpServer.post('/gbzscbgjdAq', asyncHandler(gbzscbgjdAqBiz.getData));
+
+    httpServer.post('/gbzscbgjdBq', asyncHandler(gbzscbgjdBqBiz.getData));
+            
+    //======get
+    
+    httpServer.get('/cyszhgl', asyncHandler(cyszhglBiz.getData));
+        
+    httpServer.get('/gfny', asyncHandler(gfnyBiz.getData));
+        
+    httpServer.get('/sdt1hgfb', asyncHandler(sdt1hgfbBiz.getData));
+
+    httpServer.get('/yzdqxdnyzl', asyncHandler(yzdqxdnyzlBiz.getData));
+        
+    httpServer.get('/hjszzl', asyncHandler(hjszzlBiz.getData));
+        
+    httpServer.get('/nyjqr', asyncHandler(nyjqrBiz.getData));
+        
+    httpServer.get('/jdaqgl', asyncHandler(jdaqglBiz.getData));
+        
+    httpServer.get('/gbzscbgjdAq', asyncHandler(gbzscbgjdAqBiz.getData));
+
+    httpServer.get('/gbzscbgjdBq', asyncHandler(gbzscbgjdBqBiz.getData));
+    
+        
+}
+    
\ 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 ));
+    let thisBlockData = getBlockData(sheetMap[sheetName]);
+    return thisBlockData;
+}
+
+/**
+ * excelBecomeOfBlockData 将excel所有的sheet解析成数据块
+ * @param fileName 文件名称
+ * @returns {"sheetName1":[ {blockData:数据块(二维数组), blockTitle:"数据标题"}], ...}
+ */
+export function excelBecomeOfBlockData(fileName) {
+    let {sheetMap} = getExcel( path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", fileName ));
+    let result = {};
+    for (let sheetName in sheetMap) {
+        result[sheetName] = getBlockData(sheetMap[sheetName]);
+    }
+    return result;
+}
+
+/**
+ *  planaryArrayBecomeOfBlockData  将符合excel规则的sheet二维数组转为 数据块
+ * @param dataList excel解出来的数据
+ * @returns thisBlockData 返回数据块集合 格式：blockList = [ {blockData:数据块(二维数组), blockTitle:"数据标题"}]
+ */
+export function planaryArrayBecomeOfBlockData(planaryArray) {
+    return getBlockData(planaryArray);;
+}
+
+
+//===
+
+/**
+ * getBlockData 数据分块 
+ * @param dataList  解析出来的excel二维数组
+ * @returns 返回数据块集合 格式：blockList = [ {blockData:数据块(二维数组), blockTitle:"数据标题"}]
+ */
+function getBlockData(dataList) {
+    let blockList = [];
+    for (let i = 0; i < 999; i++) {
+        let {blockData, blockTitle, notItem, delDataList} = checkBlock(dataList);
+        if (notItem) break;
+        dataList = delDataList;
+        if (blockTitle) blockList.push({blockData, blockTitle});
+    }
+    return blockList;
+}
+
+function getListFristNotNullItemIndex(list) { //获取起始坐标
+    if (!list.length) return null;
+    for (let i = 0; i < list.length; i++) {
+        if (list[i]) return i;
+    }
+}
+
+
+function getListFirstNullItemIndex(startX, list) { //获取第一个为空的坐标
+    if (!list.length) return null;
+    let checkItem = false;
+    let firstItemIndex = 0;
+    for (let i = startX; i <= list.length; i++) {
+        let item = list[i];
+        if (!checkItem && item) checkItem = true;
+        
+        if (checkItem && !item) {
+            firstItemIndex = i;
+            break;
+        }
+    }
+    return firstItemIndex;
+}
+function listRegionIsNull(list, startX, endX) { //指定区间内数据是否未空
+    let isNull = true;
+    if ( !list.length ) return isNull;
+
+    for (let i = startX; i < endX; i++) {
+        let item = list[i];
+        if (item) {
+            isNull = false;
+            break;
+        }
+    }
+    return isNull;
+}
+
+function thisListNotItem(list) {
+    for (let i = 0; i < list.length; i++) {
+        if (list[i]) return false;
+    }
+    return true
+}
+
+function checkBlock(dataList) {
+    //纵向有效起始点
+    let startY = 0;
+    let startX = 0;
+    let isNotBlockTitle = false; //没有块标题
+    let isLook = false;
+    let endX = 0;//x轴最长结束下标 【包括下标】
+    
+
+    let blockTitle = ''; //标题块名称
+
+    let notItem = true;
+
+    for (let i = 0; i < dataList.length; i++) {
+        let childList = dataList[i] || [];
+
+        if (!thisListNotItem(childList)) {
+            
+            if ( !isLook ) {
+                let thisRoowStartX = getListFristNotNullItemIndex(childList);
+                let thisRoowLastItem = childList[thisRoowStartX + 1];
+                let LastList = dataList[i+1] || [];
+                // let lastRoowStartX = getListFristNotNullItemIndex(LastList);
+                let lastRoowHaveItem = LastList[thisRoowStartX];
+                if ( thisRoowLastItem || (LastList.length && lastRoowHaveItem)  ) {
+                    
+                    if (lastRoowHaveItem && thisRoowLastItem ) {
+                        isNotBlockTitle = true; //不存在标题块
+                        blockTitle = `${thisRoowStartX}_${i}`;
+                        startY = i;
+                        startX = thisRoowStartX;
+                    }
+                    else {
+                        blockTitle = dataList[i][thisRoowStartX];
+                        dataList[i][thisRoowStartX] = null;
+
+                        if ( thisRoowLastItem ) { // 同行存在元素 标题在y轴上
+                            startY = i;
+                            startX = thisRoowStartX + 1;
+                        } else {  // 同行存在元素 标题在x轴上
+                            startY = i + 1;
+                            startX = thisRoowStartX;
+                        }
+                    }
+                    
+                    isLook = true;
+                } else { //只有标题 无内容
+                    console.log(dataList[i][thisRoowStartX]);
+                    dataList[i][thisRoowStartX] = null;
+                }
+                
+            } else {
+                //测量最大连续长度
+                let firstNullX = getListFirstNullItemIndex(startX, childList);
+                if (firstNullX) endX = Math.max(endX, firstNullX-1);
+                break;
+            }
+            notItem = false;
+        }
+    }
+    let endY = 0;//y轴连续下标 【包括下标】
+
+    let yInfoStart = false;
+    let yInfoEnd = false;
+
+    for (let y = startY; y < dataList.length; y++) {
+        //纵向找连续性
+        let thisRoow = dataList[y];
+        let regionIsNull = listRegionIsNull(thisRoow, startX, endX);
+        if (!regionIsNull) {
+            endY = y;
+            if (!yInfoStart) yInfoStart = true;
+        }
+        if (yInfoStart && regionIsNull) yInfoEnd = true;
+        if (yInfoEnd) break;
+    }
+    
+    let blockData = [];
+    for (let y = startY; y <= endY; y++) {
+        let onceList = [];
+        for (let x = startX; x <= endX; x++) {
+            onceList.push(dataList[y][x]);
+            dataList[y][x] = null;
+        }
+        blockData.push(onceList);
+    }
+
+    return {blockData, blockTitle, delDataList:dataList,notItem};
+}
+
+
+
+//获取单个excel文件的数据
+function getExcel(filePath) {
+    const workSheetsFromFile = xlsx.parse(filePath);
+    let sheetMap = {};
+    let sheetList = [];
+
+    for (let i = 0; i < workSheetsFromFile.length; i++) {
+        let sheetInfo = workSheetsFromFile[i];
+        sheetMap[sheetInfo.name] = sheetInfo.data;
+        sheetList.push(sheetInfo);
+    }
+
+    return {sheetMap, sheetList}  
+}
\ No newline at end of file

src/util/bizError.ts

+import { getBizMsg, getSysMsg } from "../config/errorEnum";
+import { logError } from "./log";
+
+export class BizError extends Error {
+    constructor(...msgs) {
+        let reqErrorMsg = '';
+        let logErrorMsg = '';
+        for (let i = 0; i <msgs.length; i++) {
+            if (!i) {
+                let msg = getBizMsg(msgs[i]);
+                reqErrorMsg = msg;
+                logErrorMsg = msg;
+            } else {
+                logErrorMsg += ` | ${msgs[i]} `;
+            }
+        }
+
+        logError(logErrorMsg);
+        super(reqErrorMsg);
+    }
+}
+
+export class SysError extends Error {
+    constructor(...msgs) {
+        let reqErrorMsg = '';
+        let logErrorMsg = '';
+        for (let i = 0; i <msgs.length; i++) {
+            if (!i) {
+                let msg= getSysMsg(msgs[i]);
+                reqErrorMsg = msg;
+                logErrorMsg = msg;
+            } else {
+                if (typeof msgs[i] == 'object') logErrorMsg += ` | ${JSON.stringify(msgs[i])} `;
+                else logErrorMsg += ` | ${msgs[i]} `;
+            }
+        }
+
+        logError(logErrorMsg);
+        super(reqErrorMsg);
+    }
+}
\ No newline at end of file

src/util/log.ts

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

src/util/myXML.ts

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

src/util/request.ts

+import * as request from 'request';
+import { BizError } from './bizError';
+
+export function get(url:string, query?, headers?, timeOut?) {
+    timeOut = timeOut || 5000;
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    return new Promise((resolve, reject)=>{
+        let paramater:any = { url, json:true, timeout:timeOut };
+        if (query) paramater.qs = query;
+        if (headers) paramater.headers = headers;
+        request.get(paramater, function (err, res, body) {
+           const success = !err && res && res == 200;
+           let message = err || res.statusCode || "";
+           resolve({success, message, body});
+        })
+    })
+}
+
+
+export function post(url, body, headers) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    let header = {"content-type": "application/json"};  
+    return new Promise((resolve, reject)=>{
+        request({
+            url: url,
+            method: "POST",
+            json: true,
+            headers: Object.assign(header, headers),
+            body: body
+        }, function(err, res, body) {
+            const success = !err && res && res == 200;
+            let message = err || res.statusCode || "";
+            resolve({success, message, body});
+        });
+    })
+}
+
+export function postForm(url, body) {
+    if (!url || (url.search(/http:/) && url.search(/https:/)) ) throw new BizError(!url ? "请求地址为空" : "请求地址错误");
+    return new Promise((resolve, reject)=>{
+        request({
+            url: url,
+            method: "POST",
+            json: true,
+            form:body
+        }, function(err, res, body) {
+            const success = !err && res && res == 200;
+            let message = err || res.statusCode || "";
+            resolve({success, message, body});
+        });
+    })
+}

src/util/tools.ts

+
+//对象判空
+export function objectKeyIsNull(obj, ...keyNames) {
+    let isNull = false;
+    for (let i = 0; i < keyNames.length; i++) {
+        let keyStr = keyNames[i];
+        let moreKeyList = keyStr.split(".");
+        let lastObj;
+        for (let j = 0; j < moreKeyList.length; j++) {
+            lastObj = obj[moreKeyList[j]];
+            if (!lastObj) {
+                isNull = true;
+                break;
+            }
+        }
+        if (isNull) break;
+    }
+    return isNull;
+}
+

tsconfig.json

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