接口

src/biz/csjInterface/lsdl_cdss.ts

+import { get绿色电力_充电设施发展监控 } from "../../data/analysisExcelData";
+import { getCdssfzjk } from "../../data/interface/cdssfzjk";
+import { analysisAddOrRMData, getChartData, getDataMapDecimalForN, getDropMoreData, getKeyValue, getMoreYChartData, objKeyReplace } from "../../util/tools";
+
+export async function getData(req, res) {
+    let ret:any = {};
+    let excelData:any = get绿色电力_充电设施发展监控();
+    let interfaceData:any = getCdssfzjk();
+        
+    let 充电设施发展监控DataAndUnit = objKeyReplace(interfaceData.chargingInfo);
+    ret["api6"] =  getKeyValue("充电设施发展监控", 充电设施发展监控DataAndUnit.dataMap, 充电设施发展监控DataAndUnit.unitMap, false, false );
+        
+    let 服务车次DataAndUnit = objKeyReplace(interfaceData.realTimeMonitoringInfo);
+    ret["api7"] =  getKeyValue("服务车次", 服务车次DataAndUnit.dataMap,服务车次DataAndUnit.unitMap , false, false );
+    
+    ret["api8"] = getChartData("每月服务车次", interfaceData.monthInfo, '次', false);
+
+    //excel---------------------------------
+    let 特化数据 = {};
+    for (let key in excelData.当期绿电指数) {
+        特化数据[key] = analysisAddOrRMData(excelData.当期绿电指数[key]);
+    }
+    let 当期绿电指数DataAndUnit = objKeyReplace(特化数据);
+    ret["api1"] =  getKeyValue("当期绿电指数", 当期绿电指数DataAndUnit.dataMap, 当期绿电指数DataAndUnit.unitMap, false, false );
+    
+    ret["api2"] = getMoreYChartData("同比趋势分析", checkNumber(excelData.同比趋势分析), false, {"绿电指数":"","同比增长":"%"})
+
+    ret["api3"] = getMoreYChartData("环比趋势分析", checkNumber(excelData.环比趋势分析), false, {"绿电指数":"","环比增长":"%"})
+
+    let 绿电指数折线图保留小数数据 = getDataMapDecimalForN(excelData.绿电指数折线图);
+    ret["api5"] = getChartData("绿电指数折线图", 绿电指数折线图保留小数数据, false, false );
+    ret["api5"].yMinValue = 100;
+
+    ret["api14"] = getDropMoreData(excelData.绿电指数与经济指数相关分析_2017_2020_, "绿电指数与经济指数相关分析（2017-2020）", "绿电指数与经济指数相关分析（2017-2020）");
+    ret["api15"] = getDropMoreData(excelData.上海市空气质量AQI优良率, "绿电指数与环境指数相关分析（2017-2020）", "上海市空气质量AQI优良率");
+    ret["api16"] = getDropMoreData(excelData.青浦区PM2_5月均浓度, "绿电指数与环境指数相关分析（2017-2020）", "青浦区PM2.5月均浓度");
+
+    ret["api17"] = getDropMoreData(excelData.绿电指数与经济指数相关分析均值, "绿电指数与经济指数相关分析均值", "绿电指数与经济指数相关分析均值");
+    ret["api18"] = getDropMoreData(excelData.上海市空气质量AQI优良率均值, "上海市空气质量AQI优良率均值", "上海市空气质量AQI优良率均值");
+    ret["api19"] = getDropMoreData(excelData.青浦区PM2_5月均浓度均值, "青浦区PM2.5月均浓度均值", "青浦区PM2.5月均浓度均值");    
+    
+    res.send(ret);
+}
+
+function checkNumber(同比趋势分析: any): any {
+    throw new Error("Function not implemented.");
+}

src/biz/csjInterface/lsdl_qjnygf.ts

+import { get绿色电力_清洁能源光伏接入情况 } from "../../data/analysisExcelData";
+import { getInstalledCapacity, getPowerGeneration, getQjnygfjr } from "../../data/interface/qjnygfjr";
+import { analysisAddOrRMData, getChartData, getDataMapDecimalForN, getDropMoreData, getKeyValue, getMoreYChartData, getSingleYAndMoreData, objKeyReplace } from "../../util/tools";
+
+export async function getData(req, res) {
+    let ret:any = {};
+    let excelData:any = get绿色电力_清洁能源光伏接入情况();
+    let interfaceData:any = getQjnygfjr();
+    let grossGenerationData:any = getPowerGeneration();
+    let installedCapacityData:any = getInstalledCapacity();
+    
+    let 客户总量DataAndUnit = objKeyReplace(interfaceData.customerInfo);
+    ret["api2"] =  getKeyValue("客户总量", 客户总量DataAndUnit.dataMap, 客户总量DataAndUnit.unitMap, false, false );
+    
+    let 各类污染物减排占比DataAndUnit = objKeyReplace(interfaceData.realTimeInfo);
+    ret["api3"] =  getKeyValue("各类污染物减排占比", 各类污染物减排占比DataAndUnit.dataMap, 各类污染物减排占比DataAndUnit.unitMap, true, false );
+    
+    ret["api5"] = getChartData("分布式光伏客户接入变化趋势", interfaceData.distributed, '户', false );
+
+    const 分布式光伏客户DataAndUnit = objKeyReplace(interfaceData.distributedInfo);
+    const 总发电量DataAndUnit = objKeyReplace(grossGenerationData.powerGenerationInfo);
+    const 装机容量DataAndUnit = objKeyReplace(installedCapacityData.installedCapacityInfo);
+
+    ret["api4"] = 特化清洁能源接入情况("清洁能源光伏接入情况", 分布式光伏客户DataAndUnit, 总发电量DataAndUnit, 装机容量DataAndUnit );
+
+    ret["api7"] = getSingleYAndMoreData("近12个月电量分析", interfaceData.powerAnalysisInfo, false, '万千瓦时');
+
+    //excel---------------------------
+    let 特化数据 = {};
+    for (let key in excelData.当期绿电指数) {
+        特化数据[key] = analysisAddOrRMData(excelData.当期绿电指数[key]);
+    }
+    let 当期绿电指数DataAndUnit = objKeyReplace(特化数据);
+    ret["api1"] =  getKeyValue("当期绿电指数", 当期绿电指数DataAndUnit.dataMap, 当期绿电指数DataAndUnit.unitMap, false, false );
+
+    ret["api6"] = getChartData("绿电指数折线图", excelData.绿电指数折线图, false, false );
+
+    ret["api8"] = getSingleYAndMoreData("各指数成分趋势分析", excelData.各指数成分趋势分析, false, false);
+
+    const 指标数据 = [];
+    excelData.当期指数分四象限分析指标.forEach(info => {
+        let checkInfo:any = objKeyReplace(info);
+        指标数据.push(checkInfo.dataMap.x, checkInfo.dataMap.y);
+    });
+
+    let 当期指数分四象限分析数据 = [];
+    for (let key in excelData.当期指数分四象限分析) {
+        let {x, y, name} = excelData.当期指数分四象限分析[key];
+        let info = {x:Math.floor(parseFloat(x) * 100 )/100, y:Math.floor(parseFloat(y) * 10000 )/100 , name};
+        当期指数分四象限分析数据.push(info);
+    }
+    
+    ret["api11"] = getDropMoreData(当期指数分四象限分析数据, "当期指数分四象限分析", "当期指数分四象限分析", 指标数据);
+
+    res.send(ret);
+}
+
+function 特化清洁能源接入情况(title, 分布式光伏客户DataAndUnit, 总发电量DataAndUnit, 装机容量DataAndUnit,) {
+    let result = {
+        title, 
+        subTitle : title,
+        total : 0,
+        list : []
+    };
+    let 分布式光伏客户Unit = 分布式光伏客户DataAndUnit.unitMap;
+    let 分布式光伏客户Data = 分布式光伏客户DataAndUnit.dataMap;
+    result.list.push({
+        key:"分布式光伏客户", 
+        value:分布式光伏客户Data["分布式光伏客户"], 
+        unit:分布式光伏客户Unit["分布式光伏客户"], 
+        rateName:"非居民占比", 
+        rate:分布式光伏客户Data["非居民占比"]
+    });
+
+    let 总发电量Unit = 总发电量DataAndUnit.unitMap;
+    let 总发电量Data = 总发电量DataAndUnit.dataMap;
+    result.list.push({
+        key:"总发电量", 
+        value:总发电量Data["总发电量"], 
+        unit:总发电量Unit["总发电量"], 
+        rateName:"非居民占比", 
+        rate:总发电量Data["非居民占比"]
+    });
+
+    let 装机容量Unit = 装机容量DataAndUnit.unitMap;
+    let 装机容量Data = 装机容量DataAndUnit.dataMap;
+    result.list.push({
+        key:"装机容量", 
+        value:装机容量Data["装机容量"], 
+        unit:装机容量Unit["装机容量"], 
+        rateName:"非居民占比", 
+        rate:装机容量Data["非居民占比"]
+    });
+
+    return result;
+}
\ No newline at end of file

src/biz/csjInterface/qyrh.ts

+import { getChartData, getKeyValue, getListData, getSingleYAndMoreData, getMoreYChartData, objKeyReplace }from "../../util/tools";
+import { getQyrh } from "../../data/interface/qyrh";
+import { get区域融合 } from "../../data/analysisExcelData";
+
+export function getData(req, res) {
+    let ret:any = {};
+
+    let excelData:any = get区域融合();
+    let interfaceData:any = getQyrh();
+
+    ret["api19"] = getListData("值班管理", interfaceData.dutyManagement, ["名称", "是否到岗"] , {"名称":"name", "是否到岗":"reported"});
+
+    let _码上办_实时监测DataAndUnit = objKeyReplace(interfaceData.realTimeMonitoringInfo);
+    ret["api31"] =  getKeyValue("“码上办”实时监测", _码上办_实时监测DataAndUnit.dataMap, _码上办_实时监测DataAndUnit.unitMap, true, false );
+
+    let _码上办_监测结果DataAndUnit = objKeyReplace(interfaceData.monitoringResultsInfo);
+    ret["api32"] =  getChartData("“码上办”监测结果", _码上办_监测结果DataAndUnit.dataMap, "户", false );
+
+    ret["api28"] = 特化营商环境("营商环境", "青浦区", interfaceData.供电可靠性_青浦区, interfaceData.easeOfDoingInfo, interfaceData.timelinessInfo, interfaceData.interactivityInfo);
+
+    ret["api23"] = getListData("检修计划",interfaceData.schedulingLogOverhaulSchedule, ["序号","区域","工作内容","日期"],{"序号":"serialNumber","区域":"area","工作内容":"jobContent","日期":"dateTime"});
+    ret["api24"] = getListData("故障抢修",interfaceData.schedulingLogTroubleshooting, ["序号","区域","工作内容","日期"],{"序号":"serialNumber","区域":"area","工作内容":"jobContent","日期":"dateTime"});
+    ret["api25"] = getListData("停电停役",interfaceData.schedulingLogPowerOutage, ["序号","区域","工作内容","日期"],{"序号":"serialNumber","区域":"area","工作内容":"jobContent","日期":"dateTime"});
+    ret["api26"] = getListData("设备缺陷",interfaceData.schedulingLogDeviceDefect, ["序号","区域","工作内容","日期"],{"序号":"serialNumber","区域":"area","工作内容":"jobContent","日期":"dateTime"});
+    ret["api27"] = getListData("事故异常",interfaceData.schedulingLogAccidentException, ["序号","区域","工作内容","日期"],{"序号":"serialNumber","区域":"area","工作内容":"jobContent","日期":"dateTime"});
+
+    //excel-----------------------------
+    let 一体化电网运行管理DataAndUnit = objKeyReplace(excelData.一体化电网运行管理);
+    ret["api3"] = getKeyValue("一体化电网运行管理", 一体化电网运行管理DataAndUnit.dataMap, 一体化电网运行管理DataAndUnit.unitMap, true, false );
+    ret["api3"].list.forEach(info => {
+        info.value = 特化一体化电网运行管理(info.value);
+    });
+
+    ret["api4"] = getListData("工程进度",excelData.工程进度,["工程名称","开始时间","预计完成时间","工程进度"],{"工程名称":"name","开始时间":"startTime","预计完成时间":"endTime","工程进度":"rate"});
+
+    ret["api6"] = getSingleYAndMoreData("电网作业风险事件", excelData.电网作业风险事件, false, 'false');
+
+    let 一体化新型电力系统DataAndUnit = objKeyReplace(excelData.一体化新型电力系统);
+    ret["api7"] =  getKeyValue("一体化新型电力系统", 一体化新型电力系统DataAndUnit.dataMap, 一体化新型电力系统DataAndUnit.unitMap, false, false );
+    
+    let 嘉善县DataAndUnit = objKeyReplace(excelData.嘉善县);
+    ret["api16"] =  getKeyValue("嘉善县",  嘉善县DataAndUnit.dataMap,  嘉善县DataAndUnit.unitMap, false, false );
+    let 吴江区DataAndUnit = objKeyReplace(excelData.吴江区);
+    ret["api17"] =  getKeyValue("吴江区",  吴江区DataAndUnit.dataMap,  吴江区DataAndUnit.unitMap, false, false );
+    let 青浦区DataAndUnit = objKeyReplace(excelData.青浦区);
+    ret["api18"] =  getKeyValue("青浦区",  青浦区DataAndUnit.dataMap,  青浦区DataAndUnit.unitMap, false, false );
+    let 地图链接数据 = { 
+        title: "地图链接",
+        subTitle : "地图链接",
+        total : 0,
+        list : []
+    };
+    for (let key in excelData.地图链接) {
+        地图链接数据.list.push({"key":key, "value": excelData.地图链接[key] });
+    }
+    ret["api20"] = 地图链接数据;
+
+    ret["api22"] = { title:"图片", data:{
+        "img1":"img/qyrh1.png",
+        "img2":"img/qyrh2.gif"
+    } };
+    ret["api29"] = 特化营商环境("营商环境", "嘉善县", excelData.供电可靠性_嘉善县, excelData.营商业务便利性_嘉善县, excelData.营商业务及时性_嘉善县, excelData.营商业务互动性_嘉善县);
+    ret["api30"] = 特化营商环境("营商环境", "吴江区", excelData.供电可靠性_吴江区, excelData.营商业务便利性_吴江区, excelData.营商业务及时性_吴江区, excelData.营商业务互动性_吴江区);
+    
+    let _码上办_政策提示DataAndUnit = objKeyReplace(excelData._码上办_政策提示);
+    ret["api33"] =  getKeyValue("“码上办”政策提示", _码上办_政策提示DataAndUnit.dataMap, _码上办_政策提示DataAndUnit.unitMap, false, false );
+
+    res.send(ret);
+}
+
+function 特化一体化电网运行管理(number) {
+    let checkData = new Date().valueOf() - new Date('2021-10-25 00:00:00').valueOf();
+    return Math.floor(checkData / (3600 * 1000 * 24)) + number;
+}
+
+function 特化营商环境(title, subTitle, 供电可靠性, 营商业务便利性, 营商业务及时性, 营商业务互动性) {
+    let data:any = {title, subTitle, dataList:[] };
+
+    let 营商业务便利性DataAndUnit = objKeyReplace(营商业务便利性);
+    let ysywblxData = {title:"营商业务便利性", data:[]};
+    for (let key in 营商业务便利性DataAndUnit.dataMap) {
+        
+        ysywblxData.data.push({
+            key,
+            value:营商业务便利性DataAndUnit.dataMap[key],
+            unit:营商业务便利性DataAndUnit.unitMap[key]
+        });
+    }
+    data.dataList.push(ysywblxData);
+
+
+
+    let 供电可靠性DataAndUnit = objKeyReplace(供电可靠性);
+    let gdkkxData = {title:"供电可靠性", data:[]};
+    for (let key in 供电可靠性DataAndUnit.dataMap) {
+        
+        gdkkxData.data.push({
+            key,
+            value:供电可靠性DataAndUnit.dataMap[key],
+            unit:供电可靠性DataAndUnit.unitMap[key]
+        });
+    }
+    data.dataList.push(gdkkxData);
+
+    let 营商业务及时性DataAndUnit = objKeyReplace(营商业务及时性);
+    let ysywjsxData = {title:"营商业务及时性", data:[]};
+    for (let key in 营商业务及时性DataAndUnit.dataMap) {
+        
+        ysywjsxData.data.push({
+            key,
+            value:营商业务及时性DataAndUnit.dataMap[key],
+            unit:营商业务及时性DataAndUnit.unitMap[key]
+        });
+    }
+    data.dataList.push(ysywjsxData);
+
+    let ysywhdx = {title:"营商业务互动性", data:[]};
+    for (let key in  营商业务互动性) {
+        ysywhdx.data.push({key, value:""});
+    }
+    data.dataList.push(ysywhdx);
+
+    return data;
+}

src/biz/csjInterface/zhdy.ts

+import { getZhdy } from "../../data/interface/zhdy";
+import { getChartData, getKeyValue, getListData, getSingleYAndMoreData, getMoreYChartData, objKeyReplace }from "../../util/tools";
+
+
+export function getData(req, res) {
+    let ret:any = {};
+
+    let interfaceData:any = getZhdy();
+
+    let 基础数据DataAndUnit = objKeyReplace(interfaceData.basicInfo);
+    ret["api1"] =  getKeyValue("基础数据", 基础数据DataAndUnit.dataMap, 基础数据DataAndUnit.unitMap, 'inData', false );
+
+    res.send(ret);
+}

src/biz/csjInterface/zhdy_csqxtfz.ts

+import { get智慧电眼_城市群协同发展 } from "../../data/analysisExcelData";
+import { getArea, getCsqxtfz } from "../../data/interface/csqxtfz";
+import { getChartData, getKeyValue, getListData, getSingleYAndMoreData, getMoreYChartData, objKeyReplace, getKeyStringValue }from "../../util/tools";
+
+export function getData(req, res) {
+    let ret:any = {};
+
+    let excelData:any = get智慧电眼_城市群协同发展();
+    let interfaceData:any = getCsqxtfz();
+
+    let 基础数据DataAndUnit = objKeyReplace(interfaceData.basicInfo);
+    ret["api1"] =  getKeyValue("基础数据", 基础数据DataAndUnit.dataMap, false, false, false );
+
+    let 吴江区数据Interface:any = getArea("吴江");
+    let 吴江区数据DataAndUnit = objKeyReplace(吴江区数据Interface.dataInfo);
+    ret["api2"] =  getKeyValue("吴江区数据", 吴江区数据DataAndUnit.dataMap, 吴江区数据DataAndUnit.unitMap, false, false );
+
+    ret["api3"] = getChartData("长三角示范区一体化协同发展指数趋势",interfaceData.demonstrationInfo, false, false);
+    ret["api3"].yMaxValue = 120;
+    ret["api3"].yStepValue = 5;
+    ret["api3"].yMinValue = 80;
+
+    let 青浦区数据Interface:any = getArea("青浦");
+    let 青浦区数据DataAndUnit = objKeyReplace(青浦区数据Interface.dataInfo);
+    ret["api4"] =  getKeyValue("青浦区数据", 青浦区数据DataAndUnit.dataMap, 青浦区数据DataAndUnit.unitMap, false, false );
+
+    let 嘉善县数据Interface:any = getArea("嘉善");
+    let 嘉善县数据DataAndUnit = objKeyReplace(嘉善县数据Interface.dataInfo);
+    ret["api5"] =  getKeyValue("嘉善县数据", 嘉善县数据DataAndUnit.dataMap, 嘉善县数据DataAndUnit.unitMap, false, false );
+    
+    ret["apiarea"] = getKeyStringValue("范围数据", excelData.范围数据);
+    res.send(ret);
+}
+    
\ No newline at end of file

src/biz/csjInterface/zhdy_gsqy.ts

+import { get智慧电眼_规上企业生产运行状况 } from "../../data/analysisExcelData";
+import { getGsqyscyx, getIndustrial } from "../../data/interface/gsqyscyx";
+import { getChartData, getKeyValue, getListData, getSingleYAndMoreData, getMoreYChartData, objKeyReplace, getKeyStringValue }from "../../util/tools";
+
+    
+export function getData(req, res) {
+    let ret:any = {};
+
+    let excelData:any = get智慧电眼_规上企业生产运行状况();
+    let interfaceData:any = getGsqyscyx();
+
+    let 基础数据DataAndUnit = objKeyReplace(interfaceData.basicInfo);
+    ret["api1"] =  getKeyValue("基础数据", 基础数据DataAndUnit.dataMap, 基础数据DataAndUnit.unitMap, false, false );
+
+    let 行业生产指数Interface:any = getIndustrial("行业生产指数");
+    let 行业生产指数DataAndUnit = objKeyReplace(行业生产指数Interface.dataInfo);
+    ret["api2"] =  getKeyValue("行业生产指数", 行业生产指数DataAndUnit.dataMap, 行业生产指数DataAndUnit.unitMap, false, false );
+
+    let 规上企业行业分布概览Interface:any = getIndustrial("规上企业行业分布概览");
+    let 规上企业行业分布概览DataAndUnit:any = objKeyReplace(规上企业行业分布概览Interface.dataInfo);
+    ret["api3"] =  getKeyValue("规上企业行业分布概览", 规上企业行业分布概览DataAndUnit.dataMap, 规上企业行业分布概览DataAndUnit.unitMap, true, false );
+
+    ret["api4"] = getChartData("生产指数趋势分析", interfaceData.productionInfo, false, false );
+    ret["api4"].yMinValue = 40;
+    ret["api4"].yMaxValue = 160;
+    ret["api4"].yStepValue = 40;
+
+    ret["apiarea"] = getKeyStringValue("范围数据", excelData.范围数据);
+    res.send(ret);
+}
+    
\ No newline at end of file

src/biz/csjInterface/zhdy_hyydfb.ts

+import { get智慧电眼_行业用电分布 } from "../../data/analysisExcelData";
+import { getHyydfb } from "../../data/interface/hyydfb";
+import { getChartData, getKeyValue, getListData, getSingleYAndMoreData, getMoreYChartData, objKeyReplace, getKeyStringValue }from "../../util/tools";
+
+    
+export function getData(req, res) {
+    let ret:any = {};
+
+    let excelData:any = get智慧电眼_行业用电分布();
+    let interfaceData:any = getHyydfb();
+
+    let 基础数据DataAndUnit = objKeyReplace(interfaceData.basicInfo);
+    ret["api1"] =  getKeyValue("基础数据", 基础数据DataAndUnit.dataMap, false, false, false );
+
+    let 示范区行业用电分布DataAndUnit = objKeyReplace(interfaceData.areaIndustryElectricity);
+    ret["api2"] =  getKeyValue("示范区行业用电分布", 示范区行业用电分布DataAndUnit.dataMap, 示范区行业用电分布DataAndUnit.unitMap, true, false );
+
+    ret["api3"] =  getSingleYAndMoreData("三地各行业用电量", interfaceData.electricityInfo, false, false);
+
+    ret["api4"] = getSingleYAndMoreData("重点行业集中度年度分析（青浦）", interfaceData.concentrationAnalysis, false, false);
+    ret["api4"].yMinValue = 40;
+    ret["api4"].yMaxValue = 100;
+    ret["api4"].yStepValue = 20;
+    
+    ret["apiarea"] = getKeyStringValue("范围数据", excelData.范围数据);
+    res.send(ret);
+}
\ No newline at end of file

src/biz/csjInterface/zhdy_jjjqd.ts

+import { get智慧电眼_经济景气度 } from "../../data/analysisExcelData";
+import { getJjjqd } from "../../data/interface/jjjcd";
+import { getChartData, getKeyValue, getListData, getSingleYAndMoreData, getMoreYChartData, objKeyReplace, getKeyStringValue }from "../../util/tools";
+
+    
+export function getData(req, res) {
+    let ret:any = {};
+
+    let excelData:any = get智慧电眼_经济景气度();
+    let interfaceData:any = getJjjqd();
+
+    let 基础数据DataAndUnit = objKeyReplace(interfaceData.basicInfo);
+    ret["api1"] =  getKeyValue("基础数据", 基础数据DataAndUnit.dataMap, 基础数据DataAndUnit.unitMap, false, false );
+
+    let 重点区域景气指数_青浦_DataAndUnit = objKeyReplace(interfaceData.prosperity);
+    ret["api2"] =  getKeyValue("重点区域景气指数（青浦）", 重点区域景气指数_青浦_DataAndUnit.dataMap, 重点区域景气指数_青浦_DataAndUnit.unitMap, false, false );
+
+    let 行业景气度DataAndUnit = objKeyReplace(interfaceData.industrialInfo);
+    ret["api3"] =  getKeyValue("行业景气指数", 行业景气度DataAndUnit.dataMap, 行业景气度DataAndUnit.unitMap, false, false );
+
+    ret["api4"] = getChartData("经济景气指数趋势分析", interfaceData.economicSentimentIndex, false, false );
+    ret["api4"].yMinValue = 40;
+    ret["api4"].yMaxValue = 160;
+    ret["api4"].yStepValue = 40;
+
+    ret["apiarea"] = getKeyStringValue("范围数据", excelData.范围数据);
+    res.send(ret);
+}
+    
\ No newline at end of file

src/biz/csjInterface/zhdy_qydzxypg.ts

+import { get智慧电眼_企业贷中信用评估 } from "../../data/analysisExcelData";
+import { getindustryCredit, getQydzxypg } from "../../data/interface/qydzxypg";
+import { getChartData, getKeyValue, getListData, getSingleYAndMoreData, getMoreYChartData, objKeyReplace, getKeyStringValue }from "../../util/tools";
+
+
+export function getData(req, res) {
+    let ret:any = {};
+
+    let excelData:any = get智慧电眼_企业贷中信用评估();
+    let interfaceData:any = getQydzxypg();
+
+    let 各信用等级企业分布情况DataAndUnit = objKeyReplace(interfaceData.distributionInfo);
+    ret["api1"] =  getKeyValue("各信用等级企业分布情况", 各信用等级企业分布情况DataAndUnit.dataMap, 各信用等级企业分布情况DataAndUnit.unitMap, true, false );
+
+    ret["api2"] = getSingleYAndMoreData("每月企业信用变化趋势", interfaceData.monthlyBusinessInfo, false, '户');
+
+    let 行业信用分布对比Interface:any = getindustryCredit();
+    ret["api3"] = getSingleYAndMoreData("行业信用分布对比", 行业信用分布对比Interface.industryCreditInfo, false, '%');
+
+    let 优质信用企业DataAndUnit = objKeyReplace(interfaceData.highQuality);
+    ret["api4"] =  getKeyValue("优质信用企业", 优质信用企业DataAndUnit.dataMap, false, false, false );
+
+    let 风险企业DataAndUnit = objKeyReplace(interfaceData.venture);
+    ret["api5"] =  getKeyValue("风险企业", 风险企业DataAndUnit.dataMap, false, false, false );
+    
+    ret["apiarea"] = getKeyStringValue("范围数据", excelData.范围数据);
+
+    res.send(ret);
+}

src/biz/csjInterface/zhdy_sqjjhl.ts

+import { get智慧电眼_商圈经济活力 } from "../../data/analysisExcelData";
+import { getSqjjhl } from "../../data/interface/sqjjhl";
+import { getChartData, getKeyValue, getListData, getSingleYAndMoreData, getMoreYChartData, objKeyReplace, getDecimalForN, getKeyStringValue }from "../../util/tools";
+
+
+export function getData(req, res) {
+    let ret:any = {};
+
+    let excelData:any = get智慧电眼_商圈经济活力();
+    let interfaceData:any = getSqjjhl();
+
+    let 基础数据DataAndUnit = objKeyReplace(interfaceData.basicInfo);
+    ret["api1"] =  getKeyValue("基础数据", 基础数据DataAndUnit.dataMap, 基础数据DataAndUnit.unitMap, false, false );
+
+    ret["api2"] = getSingleYAndMoreData("进博会核心区消费类型分析", checkNumber(interfaceData.CIIEConsumption), false, false);
+    ret["api3"] = getSingleYAndMoreData("进博会核心区节假日活力指数分析", checkNumber(interfaceData.CIIEHoliday), false, false);
+    
+    ret["api4"] = getMoreYChartData("青浦重点商圈经济活力指数", interfaceData.qingPuKeyBusiness, false, false);
+    ret["api5"] = getSingleYAndMoreData("青浦重点商圈经济活力变化趋势", interfaceData.qingPuEconomicVitalityTrendData, false, false);
+
+    ret["api6"] = getSingleYAndMoreData("赵巷区消费类型分析", checkNumber(interfaceData.zhaoXiangConsumption), false, false);
+    ret["api7"] = getSingleYAndMoreData("赵巷区节假日活力指数分析", checkNumber(interfaceData.zhaoXiangDistrictHoliday), false, false);
+    ret["api8"] = getSingleYAndMoreData("青浦新城消费类型分析", checkNumber(interfaceData.qingPuNewTownConsumption), false, false);
+    ret["api9"] = getSingleYAndMoreData("青浦新城节假日活力指数分析", checkNumber(interfaceData.qingPuNewTownHoliday), false, false);
+    ret["api10"] = getSingleYAndMoreData("朱家角古镇消费类型分析", checkNumber(interfaceData.zhuJiaJiaoConsumption), false, false);
+    ret["api11"] = getSingleYAndMoreData("朱家角古镇节假日活力指数分析", checkNumber(interfaceData.zhuJiaJiaoHoliday), false, false);
+
+    ret["apiarea"] = getKeyStringValue("范围数据", excelData.范围数据);
+
+    res.send(ret);
+}
+ 
+
+//特化  小数保留两位
+function checkNumber(data) {
+    let result = {};
+
+    for (let key in data) {
+        result[key] = {};
+        let info = data[key];
+        for (let subKey in info) {
+            let value = info[subKey] ? getDecimalForN(parseFloat(info[subKey]), 2) : 0;
+            result[key][subKey] = value;
+        }
+    }
+
+    return result;
+}
\ No newline at end of file

src/biz/csjInterface/zhdy_yskkqy.ts

+import { get智慧电眼_疑似空壳企业监测 } from "../../data/analysisExcelData";
+import { getYskkqyjc } from "../../data/interface/yskkqyjc";
+import { getChartData, getKeyValue, getListData, getSingleYAndMoreData, getMoreYChartData, objKeyReplace, getKeyStringValue }from "../../util/tools";
+
+
+export function getData(req, res) {
+    let ret:any = {};
+
+    let excelData:any = get智慧电眼_疑似空壳企业监测();
+    let interfaceData:any = getYskkqyjc();
+
+    let 基础数据DataAndUnit = objKeyReplace(interfaceData.basicInfo);
+    ret["api1"] =  getKeyValue("基础数据", 基础数据DataAndUnit.dataMap, 基础数据DataAndUnit.unitMap, false, false );
+
+    let 不同容量疑似空壳企业分布DataAndUnit = objKeyReplace(interfaceData.enterpriseDistribution);
+    ret["api2"] =  getKeyValue("不同容量疑似空壳企业分布", 不同容量疑似空壳企业分布DataAndUnit.dataMap, 不同容量疑似空壳企业分布DataAndUnit.unitMap, false, false );
+
+
+    let 非房地产 = {};
+    let 房地产占比 = {"非房地产":0, "房地产":0};
+    let 分离数据 = objKeyReplace(interfaceData.industrialInfo);
+    for (let key in 分离数据.dataMap) {
+        let value = 分离数据.dataMap[key];
+        if (key != "房地产") {
+            非房地产[key] = `${value}${分离数据.unitMap[key] || '' }`;
+            房地产占比["非房地产"] +=  value;
+        } else {
+            房地产占比["房地产"] += value;
+        }
+    }
+
+    ret["api3"] = getChartData("非房地产", 非房地产, '户', false );
+
+    ret["api4"] = getChartData("疑似空壳企业数变化趋势", interfaceData.changesNumberInfo, '户', false );
+
+    ret["api5"] = getChartData("疑似空壳企业空壳率变化趋势", interfaceData.changesTrendShellInfo, '%', false );
+
+    ret["api6"] = getKeyValue("行业疑似空壳企业分布", 房地产占比, "户", false, false);
+
+    ret["apiarea"] = getKeyStringValue("范围数据", excelData.范围数据);
+    
+    res.send(ret);
+}

src/biz/csjInterface/zhdy_zdwrqy.ts

+import { get智慧电眼_重点污染企业生产 } from "../../data/analysisExcelData";
+import { getZdwrqysc } from "../../data/interface/zdwrqysc";
+import { getChartData, getKeyValue, getListData, getSingleYAndMoreData, getMoreYChartData, objKeyReplace, analysisAddOrRMData, getKeyStringValue }from "../../util/tools";
+
+    
+export function getData(req, res) {
+    let ret:any = {};
+
+    let excelData:any = get智慧电眼_重点污染企业生产();
+    let interfaceData:any = getZdwrqysc();
+    //重点污染企业撒点数据
+    let pollutingCompaniesScatter = [
+        {
+            townName:"朱家角镇",
+            latitudeAndLogitude: [
+                {
+                    latitude: 31.156845,
+                    longitude: 121.133586,
+                    elevation: 1.49
+                },
+                {
+                    latitude: 31.150417,
+                    longitude: 121.106133,
+                    elevation: 0.79
+                }
+            ],
+            details: "朱家角镇，重点污染企业1家，污染企业生产指数均值1.49，其中上海朱家角污水处理工程建设有限公司污染企业指数高达1.49"
+        }
+    ]
+
+    let 污染企业数据ataAndUnit = objKeyReplace(interfaceData.pollutingInfo);
+    ret["api1"] =  getKeyValue("污染企业数据", 污染企业数据ataAndUnit.dataMap, 污染企业数据ataAndUnit.unitMap, false, false );
+
+    ret["api3"] = getMoreYChartData("各污染类型企业生产指数对比", interfaceData.pollutionTypeInfo, false, {"污染企业数":"户"})
+
+    ret["api4"] = getMoreYChartData("各行业类型污染企业生产指数对比", interfaceData.industryTypeInfo, false, {"污染企业数":"户"})
+
+    let 污染类型DataAndUnit = objKeyReplace(interfaceData.pollutingTypeInfo);
+    ret["api5"] =  getKeyValue("污染类型", 污染类型DataAndUnit.dataMap, 污染类型DataAndUnit.unitMap, false, false );
+
+    let 污染企业TOP10DataAndUnit = objKeyReplace(interfaceData.pollutingTop10);
+    ret["api6"] =  getKeyValue("污染企业TOP10排名", 污染企业TOP10DataAndUnit.dataMap, 污染企业TOP10DataAndUnit.unitMap, false, false );
+
+
+    let 污染企业生产数据DataAndUnit = objKeyReplace(interfaceData.productionInfo);
+    ret["api7"] =  getKeyValue("污染企业生产数据", 污染企业生产数据DataAndUnit.dataMap, 污染企业生产数据DataAndUnit.unitMap, false, false );
+
+    // let 重点污染企业撒点数据DataAndUnit = interfaceData.pollutingCompaniesScatter;
+    ret["api8"] = {title: "重点污染企业撒点数据", dataList: pollutingCompaniesScatter};
+
+    ret["apiarea"] = getKeyStringValue("范围数据", excelData.范围数据);
+    
+    res.send(ret);
+}
+    
\ No newline at end of file

src/biz/csjInterface/zhdy_zzkzl.ts

+import { get智慧电眼_住宅空置率 } from "../../data/analysisExcelData";
+import { getZzkzl } from "../../data/interface/zzkzl";
+import { getChartData, getKeyValue, getListData, getSingleYAndMoreData, getMoreYChartData, objKeyReplace, analysisAddOrRMData, getKeyStringValue }from "../../util/tools";
+
+
+export function getData(req, res) {
+    let ret:any = {};
+
+    let excelData:any = get智慧电眼_住宅空置率();
+    let interfaceData:any = getZzkzl();
+
+    let 空置户特化数据 = {};
+    for (let key in interfaceData.vacantHouseholdInfo) {
+        空置户特化数据[key] = analysisAddOrRMData(interfaceData.vacantHouseholdInfo[key]);
+    }
+    let 空置户数据DataAndUnit = objKeyReplace(空置户特化数据);
+    ret["api1"] =  getKeyValue("空置户数据", 空置户数据DataAndUnit.dataMap, 空置户数据DataAndUnit.unitMap, false, false );
+
+    let 住房空置率特化基础数据 = {};
+    for (let key in interfaceData.housingVacancyRateInfo) {
+        住房空置率特化基础数据[key] = analysisAddOrRMData(interfaceData.housingVacancyRateInfo[key]);
+    }
+    let 住房空置率数据DataAndUnit = objKeyReplace(住房空置率特化基础数据);
+    ret["api2"] =  getKeyValue("住房空置率数据", 住房空置率数据DataAndUnit.dataMap, 住房空置率数据DataAndUnit.unitMap, false, false );
+
+    let 空置用户电量特化基础数据 = {};
+    for (let key in interfaceData.IdleUserPowerInfo) {
+        空置用户电量特化基础数据[key] = analysisAddOrRMData(interfaceData.IdleUserPowerInfo[key]);
+    }
+    let 空置用户电量数据DataAndUnit = objKeyReplace(空置用户电量特化基础数据 );
+    ret["api3"] =  getKeyValue("空置用户电量数据", 空置用户电量数据DataAndUnit.dataMap, 空置用户电量数据DataAndUnit.unitMap, false, false );
+
+    ret["api4"] = getChartData("青浦区住房空置率趋势", interfaceData.qingPuDistrictHousing, '%', false );
+
+    ret["api5"] = getMoreYChartData("重点区域住房空置率", interfaceData.housingVacancyInfo, false, {"用户数":"户","空置率":"%"});
+    ret["api6"] = getMoreYChartData("典型小区住房空置率", interfaceData.residentialVacancyRateInfo, false, {"用户数":"户","空置率":"%"});
+    ret["api7"] = getMoreYChartData("重点区域空置户趋势", interfaceData.vacantHouseholds, false, {"空置率趋势":"%"});
+    ret["api8"] = getMoreYChartData("典型小区空置户趋势", interfaceData.typicalResidential, false, {"空置率趋势":"%"});
+
+    ret["apiarea"] = getKeyStringValue("范围数据", excelData.范围数据);
+    res.send(ret);
+}
+    

src/config/enum.ts

 export enum ERRORENUM {
     参数错误=`参数错误`,
 }
+
+export enum INTERFACEREQUESTTYPEENUM {
+    即时更新 = 1,
+    定时更新
+}
\ No newline at end of file

src/config/startConfig.ts

+const fs = require('fs');
+const path = require('path');
+export let ywptServerUrl = "";//长三角服务器地址
+
+// export function initConfigTxt() {
+//     let buff = fs.readFileSync( path.join(__dirname.substring(0,__dirname.indexOf("out")), "res", 'config.txt' ) );
+//     let dataStr = buff.toString();
+//     try {
+//         let config = JSON.parse(dataStr);
+//         ywptServerUrl = config["长三角接口"];
+//         return true;
+//     } catch(err) {
+//         console.log("配置解析错误 启动失败 请检查 res下的config.txt文件");
+//         return false;
+//     }
+// }
\ No newline at end of file

src/data/interface/cdssfzjk.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getCdssfzjk() {
+    let interfaceName = "绿色电力充电设施发展监控";
+    let {chargingFacilities, realTimeMonitoring, monthlyService} = await getInterfaceByInterfaceName(interfaceName);
+    // let chargingFacilities;
+    // let realTimeMonitoring;
+    // let monthlyService;
+
+    if (!chargingFacilities) throw new BizError(`${interfaceName} 缺少参数 chargingFacilities` );
+    if (!realTimeMonitoring) throw new BizError(`${interfaceName} 缺少参数 realTimeMonitoring` );
+    if (!monthlyService) throw new BizError(`${interfaceName} 缺少参数 monthlyService` );
+
+    //充电设施发展监控
+    let {chargingStationNumber, chargingPileNumber, prioritiesInTheSite} = chargingFacilities;
+    let chargingInfo = [
+        {name:"充电站数(国网自建)", value:chargingStationNumber + "座"},
+        {name:"充电桩数(国网自建)", value:chargingPileNumber + "座"},
+        {name:"国网在建数", value:prioritiesInTheSite + "座"}
+    ];
+
+    //服务车次
+    let {theTotalChargeOn, totalCharge, chargeAmount} = realTimeMonitoring;
+    let realTimeMonitoringInfo = [
+        {name:"总充电车次", value:theTotalChargeOn + "次"},
+        {name:"总充电总量", value:totalCharge + "万千瓦时"},
+        {name:"充电金额", value:chargeAmount + "万元"}
+    ]
+
+    //每月服务车次
+    let monthInfo = {};
+    monthlyService.forEach( info => {
+        let {dateTime, frequency} = info;
+        monthInfo[dateTime] = frequency + "次";
+    })
+
+    return {chargingInfo, realTimeMonitoringInfo, monthInfo}
+}
\ No newline at end of file

src/data/interface/cronJob.ts

+//接口任务 定期更新
+import * as request from 'request';
+import { INTERFACEREQUESTTYPEENUM } from "../../config/enum";
+import { BizError } from "../../util/bizError";
+import { Config } from './interfaceConfig';
+
+//初始化接口数据
+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 "postForm": reqRes = await postForm(ThisConfig.url, reqBody ); 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(err, res, data) {
+            const success = !err && res && res.statusCode == 200;
+            let message = err || res.statusCode || "";
+            resolve({success, message, 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});
+        });
+    })
+}

src/data/interface/csqxtfz.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getCsqxtfz() {
+    let interfaceName = "城市群协同发展";
+    let {basicData, wujiangDistriceData, qinpuDistriceData, jiashanDistriceData, demonstrationAreaIndexTrend} = await getInterfaceByInterfaceName(interfaceName);
+    // let basicData;
+    // let demonstrationAreaIndexTrend;
+
+    if(!basicData) throw new BizError(`${interfaceName} 缺少参数 basicData`);
+    if(!demonstrationAreaIndexTrend) throw new BizError(`${interfaceName} 缺少参数 demonstrationAreaIndexTrend`);
+
+    let {regionalIndex, economic, nonAgriculturalIndustries, resourcesEndowment} = basicData;
+    let basicInfo = [
+        {区域协同发展指数: regionalIndex},
+        {经济协同发展: economic},
+        {非农产业协同发展: nonAgriculturalIndustries},
+        {资源禀赋协同发展: resourcesEndowment}
+    ];
+
+    //长三角示范区一体化协同发展指数趋势
+    let demonstrationInfo = {};
+    demonstrationAreaIndexTrend.forEach( info => {
+        let {month, value} = info;
+        demonstrationInfo[month] = value;
+    })
+
+    return {basicInfo, demonstrationInfo}
+}
+
+export async function getArea(area) {
+    let interfaceName = "城市群协同发展";
+    let {basicData, wujiangDistriceData, qinpuDistriceData, jiashanDistriceData, demonstrationAreaIndexTrend} = await getInterfaceByInterfaceName(interfaceName);
+    // let wujiangDistriceData;
+    // let qinpuDistriceData;
+    // let jiashanDistriceData;
+
+    if(!wujiangDistriceData) throw new BizError(`${interfaceName} 缺少参数 wujiangDistriceData`);
+    if(!qinpuDistriceData) throw new BizError(`${interfaceName} 缺少参数 qinpuDistriceData`);
+    if(!jiashanDistriceData) throw new BizError(`${interfaceName} 缺少参数 jiashanDistriceData`);
+
+    let deJurePopulation;
+    let ardeJurePopulationea;
+    let GDP;
+    let totalElectricityConsumption;
+    let maximumSocialLload;
+    let cumulativeInstallationCapacity;
+
+    if(area == "吴江") {
+        deJurePopulation = wujiangDistriceData.deJurePopulation;
+        ardeJurePopulationea = wujiangDistriceData.ardeJurePopulationea;
+        GDP = wujiangDistriceData.GDP;
+        totalElectricityConsumption = wujiangDistriceData.totalElectricityConsumption;
+        maximumSocialLload = wujiangDistriceData.maximumSocialLload;
+        cumulativeInstallationCapacity = wujiangDistriceData.cumulativeInstallationCapacity;
+    } else if(area == "青浦") {
+        deJurePopulation = qinpuDistriceData.deJurePopulation;
+        ardeJurePopulationea = qinpuDistriceData.ardeJurePopulationea;
+        GDP = qinpuDistriceData.GDP;
+        totalElectricityConsumption = qinpuDistriceData.totalElectricityConsumption;
+        maximumSocialLload = qinpuDistriceData.maximumSocialLload;
+        cumulativeInstallationCapacity = qinpuDistriceData.cumulativeInstallationCapacity;
+    } else if(area == "嘉善") {
+        deJurePopulation = jiashanDistriceData.deJurePopulation;
+        ardeJurePopulationea = jiashanDistriceData.ardeJurePopulationea;
+        GDP = jiashanDistriceData.GDP;
+        totalElectricityConsumption = jiashanDistriceData.totalElectricityConsumption;
+        maximumSocialLload = jiashanDistriceData.maximumSocialLload;
+        cumulativeInstallationCapacity = jiashanDistriceData.cumulativeInstallationCapacity;
+    }
+
+    let dataInfo = [
+        {常住人口: deJurePopulation},
+        {面积: ardeJurePopulationea},
+        {GDP: GDP},
+        {全社会用电量: totalElectricityConsumption},
+        {全社会最大负荷: maximumSocialLload},
+        {累计装接容量: cumulativeInstallationCapacity}
+    ];
+
+    return {dataInfo}
+}

src/data/interface/gsqyscyx.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getGsqyscyx() {
+    let interfaceName = "规上企业生产运行状况";
+    let {basicData, industryProductionIndex, industrialDistribution, productionIndexTrend} = await getInterfaceByInterfaceName(interfaceName);
+    // let basicData;
+    // let productionIndexTrend;
+
+    if(!basicData) throw new BizError(`${interfaceName} 缺少参数 basicData`);
+    if(!productionIndexTrend) throw new BizError(`${interfaceName} 缺少参数 demonstrationAreaIndexTrend`);
+
+    let {productionIndex} = basicData;
+    let basicInfo = [
+        {青浦区生产指数: productionIndex}
+    ];
+
+    //生产指数趋势分析
+    let productionInfo = {};
+    productionIndexTrend.forEach( info => {
+        let {year, productionIndices} = info;
+        productionInfo[year] = productionIndices;
+    })
+
+    return {basicInfo, productionInfo}
+}
+
+export async function getIndustrial(name) {
+    let interfaceName = "规上企业生产运行状况";
+    let {basicData, industryProductionIndex, industrialDistribution, productionIndexTrend} = await getInterfaceByInterfaceName(interfaceName);
+    // let industryProductionIndex;
+    // let industrialDistribution;
+
+    if(!industryProductionIndex) throw new BizError(`${interfaceName} 缺少参数 demonstrationAreaIndexTrend`);
+    if(!industrialDistribution) throw new BizError(`${interfaceName} 缺少参数 demonstrationAreaIndexTrend`);
+    
+    let industrial, wholesaleAndRetail, leasingAndBusinessService, transportationAndWarehousingAndPostalServices, publicServiceAndManagementOrganization;
+    if(name == "行业生产指数") {
+        industrial = industryProductionIndex.industrial;
+        wholesaleAndRetail = industryProductionIndex.wholesaleAndRetail;
+        leasingAndBusinessService = industryProductionIndex.leasingAndBusinessService;
+        transportationAndWarehousingAndPostalServices = industryProductionIndex.transportationAndWarehousingAndPostalServices;
+        publicServiceAndManagementOrganization = industryProductionIndex.publicServiceAndManagementOrganization;
+    } else if (name == "规上企业行业分布概览") {
+        industrial = industrialDistribution.industrial;
+        wholesaleAndRetail = industrialDistribution.wholesaleAndRetail;
+        leasingAndBusinessService = industrialDistribution.leasingAndBusinessService;
+        transportationAndWarehousingAndPostalServices = industrialDistribution.transportationAndWarehousingAndPostalServices;
+        publicServiceAndManagementOrganization = industrialDistribution.publicServiceAndManagementOrganization;
+    }
+
+    let dataInfo = [
+        {"工业": industrial},
+        {"批发和商务服务业": wholesaleAndRetail},
+        {"租赁和商务服务业": leasingAndBusinessService},
+        {"交通、运输仓储和邮政业": transportationAndWarehousingAndPostalServices},
+        {"公共服务及管理组织": publicServiceAndManagementOrganization}
+    ];
+
+    return {dataInfo};
+}
\ No newline at end of file

src/data/interface/hyydfb.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getHyydfb() {
+    let interfaceName = "行业用电分布";
+    let {basicData, demonstrationAreaIndustryElectricity, concentrationAnalysisOfKeyIndustries, electricityConsumptionByIndustry} = await getInterfaceByInterfaceName(interfaceName);
+    // let basicData;
+    // let demonstrationAreaIndustryElectricity;
+    // let concentrationAnalysisOfKeyIndustries;
+    // let electricityConsumptionByIndustry;
+
+    if (!basicData) throw new BizError(`${interfaceName} 缺少参数 chargingFacilities` );
+
+    let basicInfo = [
+        {示范区行业用电分布: basicData.demonstrationAreaIndustryElectricity}
+    ];
+
+    //示范区行业用电分布
+    let {industrial, publicServiceAndManagementOrganization, realEstate, wholesaleAndRetail, informationTechnologyServices, transportationAndWarehousingAndPostalServices,
+        constructionIndustry, accommodationAndCatering, fisheries, leasingAndBusinessService, financialIndustry} = demonstrationAreaIndustryElectricity;
+    
+    let areaIndustryElectricity = [
+        {'工业': industrial},
+        {'公共服务及管理组织': publicServiceAndManagementOrganization},
+        {'房地产业': realEstate},
+        {'批发和零售业': wholesaleAndRetail},
+        {'信息传输、软件和信息技术服务业': informationTechnologyServices},
+        {'交通运输、仓储和邮政服务': transportationAndWarehousingAndPostalServices},
+        {'建筑业': constructionIndustry},
+        {'住宿和餐饮业': accommodationAndCatering},
+        {'农、林、牧、渔业': fisheries},
+        {'租赁和商务服务业': leasingAndBusinessService},
+        {'金融业': financialIndustry},
+    ]
+
+    //重点行业集中度年度分析（青浦）
+    let concentrationAnalysis;
+    let ly;
+    let xxjs;
+    let xdwl;
+    concentrationAnalysisOfKeyIndustries.forEach( info => {
+        let {keyIndustries, concentrationAnalysis} = info;
+        if (keyIndustries == "旅游") {
+            ly = concentrationAnalysis;
+        } else if(keyIndustries == "信息技术") {
+            xxjs = concentrationAnalysis;
+        } else if(keyIndustries == "现代物流") {
+            xdwl = concentrationAnalysis;
+        }
+    })
+
+    concentrationAnalysis = {旅游: ly, 信息技术: xxjs, 现代物流: xdwl};
+
+    //三地各行业用电量
+    let electricityInfo;
+    let qingPuAreaData = {};
+    let wuJiangAreaData = {};
+    let jiaShanCountyData = {};
+    electricityConsumptionByIndustry.forEach( info => {
+        let {industryName, qingPuArea, wuJiangArea, jiaShanCounty} = info;
+        qingPuAreaData[industryName] = qingPuArea;
+        wuJiangAreaData[industryName] = wuJiangArea;
+        jiaShanCountyData[industryName] = jiaShanCounty;
+    })
+    electricityInfo = {青浦区: qingPuAreaData, 吴江区: wuJiangAreaData, 嘉善县: jiaShanCountyData};
+
+    
+    
+
+    return {basicInfo, areaIndustryElectricity, concentrationAnalysis, electricityInfo};
+}

src/data/interface/interfaceConfig.ts

+import {INTERFACEREQUESTTYPEENUM} from "../../config/enum";
+
+//配置
+// "接口名称":{
+//     type:"1是即时更新 2是即时更新 使用 INTERFACErEQUESTTYPEENUM", 
+//     time:"更新频率毫秒 例如1小时这里就是 3600000", 
+//     url:"url地址", 
+//     reqType:"get还是post get = get post = post", 
+//     header:{}, 
+//     body:{} 
+// }
+export const Config = {
+    "绿色电力充电设施发展监控":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.131.170.184:17008/gesecp-server/gesecp/foreign/chargeFacilityDevelopmentMonitoring",  reqType:"post",  header:{},  body:{}},
+    "绿色电力清洁能源光伏接入情况":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.131.170.184:17008/gesecp-server/gesecp/foreign/cleanEnergyDevelopmentMonitoring",  reqType:"post",  header:{},  body:{}},
+    "区域融合":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.131.170.184:17008/gesecp-server/gesecp/foreign/regionalFusion",  reqType:"post",  header:{},  body:{}},
+    "智慧电眼首页":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.131.170.184:17008/gesecp-server/gesecp/foreign/homepage",  reqType:"post",  header:{},  body:{}},
+    "城市群协同发展":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.131.170.184:17008/gesecp-server/gesecp/foreign/coordinatedDevelopment",  reqType:"post",  header:{},  body:{}},
+    "规上企业生产运行状况":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.131.170.184:17008/gesecp-server/gesecp/foreign/productionOperation",  reqType:"post",  header:{},  body:{}},
+    "经济景气度":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.131.170.184:17008/gesecp-server/gesecp/foreign/economicProsperity",  reqType:"post",  header:{},  body:{}},
+    "企业贷中信用评估":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.131.170.184:17008/gesecp-server/gesecp/foreign/corporateLoanCreditEvaluation",  reqType:"post",  header:{},  body:{}},
+    "商圈经济活力":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.131.170.184:17008/gesecp-server/gesecp/foreign/businessDistrictEconomicVitality",  reqType:"post",  header:{},  body:{}},
+    "行业用电分布":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.131.170.184:17008/gesecp-server/gesecp/foreign/industryPowerDistribution",  reqType:"post",  header:{},  body:{}},
+    "疑似空壳企业监测":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.131.170.184:17008/gesecp-server/gesecp/foreign/suspectedShellEnterprises",  reqType:"post",  header:{},  body:{}},
+    "重点污染企业生产":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.131.170.184:17008/gesecp-server/gesecp/foreign/keyPollutingEnterprises",  reqType:"post",  header:{},  body:{}},
+    "住宅空置率":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.131.170.184:17008/gesecp-server/gesecp/foreign/residentialVacancyRate",  reqType:"post",  header:{},  body:{}},
+}
\ No newline at end of file

src/data/interface/jjjcd.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getJjjqd() {
+    let interfaceName = "经济景气度";
+    let {basicData, prosperityIndexOfKeyRegions, industrialDistribution, economicSentimentIndex} = await getInterfaceByInterfaceName(interfaceName);
+    // let basicData;
+    // let prosperityIndexOfKeyRegions;
+    // let industrialDistribution;
+    // let economicSentimentIndex;
+
+    if (!basicData) throw new BizError(`${interfaceName} 缺少参数 basicData` );
+    if (!prosperityIndexOfKeyRegions) throw new BizError(`${interfaceName} 缺少参数 prosperityIndexOfKeyRegions` );
+    if (!industrialDistribution) throw new BizError(`${interfaceName} 缺少参数 industrialDistribution` );
+    if (!economicSentimentIndex) throw new BizError(`${interfaceName} 缺少参数 economicSentimentIndex` );
+
+    let {demonstrationAreaEconomicProsperity, wujiangDistrict, qingpuDistrict, jiashanCounty} = basicData;
+    let basicInfo = [
+        {示范区经济景气指数: demonstrationAreaEconomicProsperity},
+        {吴江区: wujiangDistrict},
+        {青浦区: qingpuDistrict},
+        {嘉善县: jiashanCounty}
+    ];
+
+    //重点区域景气指数（青浦）
+    let prosperity = {};
+    prosperityIndexOfKeyRegions.forEach( info => {
+        let {areaName, prosperityIndex} = info;
+        prosperity[areaName] = prosperityIndex;
+    })
+
+    //行业景气指数
+    let {informationTechnologyServices, leasingAndBusinessService, wholesaleAndRetail, realEstate, constructionIndustry, transportationAndWarehousingAndPostalServices, 
+        industrial, accommodationAndCatering, publicServiceAndManagementOrganization, fisheries, financialIndustry} = industrialDistribution;
+    
+    let industrialInfo = [
+        {'信息技术服务业': informationTechnologyServices},
+        {'租赁和商务服务业': leasingAndBusinessService},
+        {'批发和零售业': wholesaleAndRetail},
+        {'房地产业': realEstate},
+        {'建筑业': constructionIndustry},
+        {'交通运输、仓储和邮政服务': transportationAndWarehousingAndPostalServices},
+        {'工业': industrial},
+        {'住宿和餐饮业': accommodationAndCatering},
+        {'公共服务及管理组织': publicServiceAndManagementOrganization},
+        {'农、林、牧、渔业': fisheries},
+        {'金融业': financialIndustry}
+    ];
+
+    //经济景气指数趋势分析
+    let economicInfo = {};
+    economicSentimentIndex.forEach( info => {
+        let {year, trend} = info;
+        economicInfo[year] = trend;
+    })
+
+    return {basicInfo, prosperity, industrialInfo, economicInfo};
+}
\ No newline at end of file

src/data/interface/qjnygfjr.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getQjnygfjr() {
+    let interfaceName = "绿色电力清洁能源光伏接入";
+    let {totalCustomer, realTimeMonitoring, distributedPvCustomerTrends, distributedPhotovoltaicCustomer, totalGeneratingCapacity, theInstalledCapacity, powerAnalysis} = await getInterfaceByInterfaceName(interfaceName);
+    // let totalCustomer;
+    // let realTimeMonitoring;
+    // let distributedPvCustomerTrends;
+    // let distributedPhotovoltaicCustomer;
+    // let powerAnalysis;
+
+    if (!totalCustomer) throw new BizError(`${interfaceName} 缺少参数 totalCustomer` );
+    if (!realTimeMonitoring) throw new BizError(`${interfaceName} 缺少参数 realTimeMonitoring` );
+    if (!distributedPvCustomerTrends) throw new BizError(`${interfaceName} 缺少参数 distributedPvCustomerTrends` );
+    if (!distributedPhotovoltaicCustomer) throw new BizError(`${interfaceName} 缺少参数 distributedPhotovoltaicCustomer` );
+    if (!powerAnalysis) throw new BizError(`${interfaceName} 缺少参数 powerAnalysis` );
+
+    let {residentCustomer, nonResidentCustomer} = totalCustomer;
+    //客户总量
+    let customerInfo = [
+        {居民客户: residentCustomer},
+        {非居民客户: nonResidentCustomer}
+    ];
+
+    //各类污染物减排占比
+    let {NO2, CO2, SO2} = realTimeMonitoring;
+    let realTimeInfo = [
+        {NO2: NO2 + "吨"},
+        {CO2: CO2 + "吨"},
+        {SO2: SO2 + "吨"}
+    ];
+
+    //分布式光伏客户接入变化趋势
+    let distributed = {};
+    distributedPvCustomerTrends.forEach( info => {
+        let {year, value} = info;
+        distributed[year] = value + "户";
+    })
+
+    let {distributedPvCustomer, proportionOfNonResidents} = distributedPhotovoltaicCustomer;
+    //分布式光伏客户
+    let distributedInfo = [
+        {分布式光伏客户:distributedPvCustomer + "户"},
+        {非居民占比:proportionOfNonResidents + "%"}
+    ];
+
+    //近12个月电量分析
+    let powerAnalysisInfo;
+    let powerGenerationData = {};
+    let theInternetChargeData = {};
+    powerAnalysis.forEach( info => {
+        let {month, powerGeneration, theInternetCharge} = info;
+        powerGenerationData[month] = powerGeneration + "万kwh";
+        theInternetChargeData[month] = theInternetCharge + "万kwh";
+    })
+    powerAnalysisInfo = {发电量: powerGenerationData, 上网电量: theInternetChargeData};
+
+    return {customerInfo, realTimeInfo, distributed, distributedInfo, powerAnalysisInfo};
+}
+
+export async function getPowerGeneration() {
+    let interfaceName = "绿色电力清洁能源光伏接入";
+    let {totalCustomer, realTimeMonitoring, distributedPvCustomerTrends, distributedPhotovoltaicCustomer, totalGeneratingCapacity, theInstalledCapacity, powerAnalysis} = await getInterfaceByInterfaceName(interfaceName);
+    // let totalGeneratingCapacity;
+
+    if (!totalGeneratingCapacity) throw new BizError(`${interfaceName} 缺少参数 totalGeneratingCapacity` );
+
+    //总发点量
+    let {grossGeneration, proportionOfNonResidents} = totalGeneratingCapacity;
+    let powerGenerationInfo = [
+        {总发电量:grossGeneration + "亿千瓦时"},
+        {非居民占比:proportionOfNonResidents + "%"}
+    ];
+
+    return {powerGenerationInfo};
+}
+
+export async function getInstalledCapacity() {
+    let interfaceName = "绿色电力清洁能源光伏接入";
+    let {totalCustomer, realTimeMonitoring, distributedPvCustomerTrends, distributedPhotovoltaicCustomer, totalGeneratingCapacity, theInstalledCapacity, powerAnalysis} = await getInterfaceByInterfaceName(interfaceName);
+    // let theInstalledCapacity;
+
+    if (!theInstalledCapacity) throw new BizError(`${interfaceName} 缺少参数 theInstalledCapacity` );
+
+    //装机容量
+    let {installedCapacity, proportionOfNonResidents} = theInstalledCapacity;
+    let installedCapacityInfo = [
+        {装机容量:installedCapacity + "万千伏安"},
+        {非居民占比:proportionOfNonResidents + "%"}
+    ];
+
+    return {installedCapacityInfo};
+}
\ No newline at end of file

src/data/interface/qydzxypg.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getQydzxypg() {
+    let interfaceName = "企业贷中信用评估";
+    let {distributionOfEachCreditRating, highQualityCreditEnterprise, ventureEnterprise, monthlyBusinessCreditChanges, industryCreditDistribution} = await getInterfaceByInterfaceName(interfaceName);
+    // let distributionOfEachCreditRating;
+    // let highQualityCreditEnterprise;
+    // let ventureEnterprise;
+    // let monthlyBusinessCreditChanges;
+
+    if (!distributionOfEachCreditRating) throw new BizError(`${interfaceName} 缺少参数 distributionOfEachCreditRating` );
+    if (!highQualityCreditEnterprise) throw new BizError(`${interfaceName} 缺少参数 highQualityCreditEnterprise` );
+    if (!ventureEnterprise) throw new BizError(`${interfaceName} 缺少参数 ventureEnterprise` );
+    if (!monthlyBusinessCreditChanges) throw new BizError(`${interfaceName} 缺少参数 monthlyBusinessCreditChanges` );
+
+    //各信用等级企业分布情况
+    let {excellentCredit, goodCredit, generalCredit, poorCredit} = distributionOfEachCreditRating;
+    let distributionInfo = [
+        {信用极好: excellentCredit + "户"},
+        {信用良好: goodCredit + "户"},
+        {信用一般: generalCredit + "户"},
+        {信用差: poorCredit + "户"}
+    ];
+
+    //优质信用企业
+    let highQuality = {};
+    highQualityCreditEnterprise.forEach( info => {
+        let {companyName, value} = info;
+        highQuality[companyName] = value;
+    })
+
+    //风险企业
+    let venture = {};
+    ventureEnterprise.forEach( info => {
+        let {companyName, value} = info;
+        venture[companyName] = value;
+    })
+
+    //每月企业信用变化趋势
+    let monthlyBusinessInfo;
+    let excellentCreditData = {};
+    let goodCreditData = {};
+    let generalCreditData = {};
+    let poorCreditData = {};
+    monthlyBusinessCreditChanges.forEach( info => {
+        let {month, excellentCredit, goodCredit, generalCredit, poorCredit} = info;
+        let monthly = month.charAt(month.length - 1) + "月";
+        excellentCreditData[monthly] = excellentCredit;
+        goodCreditData[monthly] = goodCredit;
+        generalCreditData[monthly] = generalCredit;
+        poorCreditData[monthly] = poorCredit;
+    })
+    monthlyBusinessInfo = {信用极好: excellentCreditData, 信用良好: goodCreditData, 信用一般: generalCreditData, 信用差: poorCreditData}
+
+    return {distributionInfo, highQuality, venture, monthlyBusinessInfo};
+}
+
+export async function getindustryCredit() {
+    let interfaceName = "企业贷中信用评估";
+    let {distributionOfEachCreditRating, highQualityCreditEnterprise, ventureEnterprise, monthlyBusinessCreditChanges, industryCreditDistribution} = await getInterfaceByInterfaceName(interfaceName);
+    // let industryCreditDistribution;
+
+    if (!industryCreditDistribution) throw new BizError(`${interfaceName} 缺少参数 industryCreditDistribution` );
+
+    //行业信用分布对比
+    let industryCreditInfo;
+    let excellentCreditData = {};
+    let goodCreditData = {};
+    let generalCreditData = {};
+    let poorCreditData = {};
+    industryCreditDistribution.forEach( info => {
+        let {industryName, excellentCredit, goodCredit, generalCredit, poorCredit} = info;
+        excellentCreditData[industryName] = excellentCredit;
+        goodCreditData[industryName] = goodCredit;
+        generalCreditData[industryName] = generalCredit;
+        poorCreditData[industryName] = poorCredit;
+    })
+    industryCreditInfo = {信用极好: excellentCreditData, 信用良好: goodCreditData, 信用一般: generalCreditData, 信用差: poorCreditData}
+
+    return {industryCreditInfo};
+}

src/data/interface/qyrh.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getQyrh() {
+    let interfaceName = "区域融合";
+    let {dutyManagement, realTimeMonitoring, monitoringResults, easeOfDoingBusiness, businessTimeliness, businessInteractivity, schedulingLogOverhaulSchedule, 
+        schedulingLogTroubleshooting, schedulingLogPowerOutage, schedulingLogDeviceDefect, schedulingLogAccidentException} = await getInterfaceByInterfaceName(interfaceName);
+    // let dutyManagement;
+    // let realTimeMonitoring;
+    // let monitoringResults;
+    // let easeOfDoingBusiness;
+    // let businessTimeliness;
+    // let businessInteractivity;
+    // let schedulingLogOverhaulSchedule;
+    // let schedulingLogTroubleshooting;
+    // let schedulingLogPowerOutage;
+    // let schedulingLogDeviceDefect;
+    // let schedulingLogAccidentException;
+
+    if (!dutyManagement) throw new BizError(`${interfaceName} 缺少参数 dutyManagement` );
+    if (!realTimeMonitoring) throw new BizError(`${interfaceName} 缺少参数 realTimeMonitoring` );
+    if (!monitoringResults) throw new BizError(`${interfaceName} 缺少参数 monitoringResults` );
+    if (!easeOfDoingBusiness) throw new BizError(`${interfaceName} 缺少参数 easeOfDoingBusiness` );
+    if (!businessTimeliness) throw new BizError(`${interfaceName} 缺少参数 businessTimeliness` );
+    if (!businessInteractivity) throw new BizError(`${interfaceName} 缺少参数 businessInteractivity` );
+    if (!schedulingLogOverhaulSchedule) throw new BizError(`${interfaceName} 缺少参数 schedulingLogOverhaulSchedule` );
+    if (!schedulingLogTroubleshooting) throw new BizError(`${interfaceName} 缺少参数 schedulingLogTroubleshooting` );
+    if (!schedulingLogPowerOutage) throw new BizError(`${interfaceName} 缺少参数schedulingLogPowerOutage` );
+    if (!schedulingLogDeviceDefect) throw new BizError(`${interfaceName} 缺少参数 schedulingLogDeviceDefect` );
+    if (!schedulingLogAccidentException) throw new BizError(`${interfaceName} 缺少参数 schedulingLogAccidentException` );
+
+    let {redCode, blackCode, blueCode, redBlueCode} = realTimeMonitoring;
+    //码上办实时监测
+    let realTimeMonitoringInfo = [
+        {红码: redCode + "个"},
+        {黑码: blackCode + "个"},
+        {蓝码: blueCode + "个"},
+        {红蓝码: redBlueCode + "个"}
+    ];
+
+    //码上办监测结果
+    let {uneconomicalElectricity, electricalTestAre, excessCapacity, reactiveCompensation} = monitoringResults;
+    let monitoringResultsInfo = [
+        {电费不经济: uneconomicalElectricity},
+        {电试超期: electricalTestAre},
+        {超荣: excessCapacity},
+        {无功补偿: reactiveCompensation}
+    ];
+
+    //营商业务便利性-青浦区
+    let {businessLineApplication, onlinePayment, doElectricityCut, reductionOfApplicationMaterials} = easeOfDoingBusiness;
+    let easeOfDoingInfo = [
+        {业务线上申请: businessLineApplication + "次"},
+        {线上缴费: onlinePayment + "万次"},
+        {办点环节缩减至: doElectricityCut + "个"},
+        {申请材料缩减至: reductionOfApplicationMaterials + "项"}
+    ];
+
+    //营商业务及时性-青浦区
+    let {highElectricityAverageLength, LowElectricityAverageLength} = businessTimeliness;
+    let timelinessInfo = [
+        {高压办电平均时长: highElectricityAverageLength + "天"},
+        {低压办电平均时长: LowElectricityAverageLength + "天"}
+    ];
+
+    //营商业务互动性-青浦区
+    let {value, ItsChineseOnline, FreeNetPhoneDo, BusinessHall} = businessInteractivity;
+    let interactivityInfo = [
+        {95598: value},
+        {网上国网: ItsChineseOnline},
+        {一网通办: FreeNetPhoneDo},
+        {营业厅: BusinessHall}
+    ];
+
+    //调度日志-检修计划
+    let titleList = ["序号", "区域", "工作内容", "日期"];
+    let overhaulSchedule = {titleList, dataList:schedulingLogOverhaulSchedule};
+
+    //调度日志-故障抢修
+    let troubleshooting = {titleList, dataList:schedulingLogTroubleshooting};
+
+    //调度日志-停电停役
+    let powerOutage = {titleList, dataList:schedulingLogPowerOutage};
+
+    //调度日志-设备缺陷
+    let deviceDefect = {titleList, dataList: schedulingLogDeviceDefect};
+
+    //调度日志-事故异常
+    let accidentException = {titleList, dataList:schedulingLogAccidentException};
+
+    return {dutyManagement, realTimeMonitoringInfo, monitoringResultsInfo, easeOfDoingInfo, timelinessInfo, interactivityInfo, 
+        schedulingLogOverhaulSchedule, schedulingLogTroubleshooting, schedulingLogPowerOutage, schedulingLogDeviceDefect, schedulingLogAccidentException};
+}
\ No newline at end of file

src/data/interface/sqjjhl.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getSqjjhl() {
+    let interfaceName = "商圈经济活力";
+    let {basicData, CIIEHolidayVitalityIndex, zhaoXiangDistrictHolidayVitalityIndex, qingPuNewTownHolidayVitalityIndex, zhuJiaJiaoHolidayVitalityIndex,
+        qingPuKeyBusinessDistrictIndex, CIIEConsumptionTypeAnalysis, zhaoXiangConsumptionTypeAnalysis, zhuJiaJiaoConsumptionTypeAnalysis, 
+        qingPuNewTownConsumptionTypeAnalysis, qingPuEconomicVitalityTrend} = await getInterfaceByInterfaceName(interfaceName);
+    // let basicData;
+    // let CIIEHolidayVitalityIndex;
+    // let zhaoXiangDistrictHolidayVitalityIndex;
+    // let qingPuNewTownHolidayVitalityIndex;
+    // let zhuJiaJiaoHolidayVitalityIndex;
+    // let qingPuKeyBusinessDistrictIndex;
+    // let CIIEConsumptionTypeAnalysis;
+    // let zhaoXiangConsumptionTypeAnalysis;
+    // let zhuJiaJiaoConsumptionTypeAnalysis;
+    // let qingPuNewTownConsumptionTypeAnalysis;
+    // let qingPuEconomicVitalityTrend;
+
+    if (!basicData) throw new BizError(`${interfaceName} 缺少参数 basicData` );
+    if (!CIIEHolidayVitalityIndex) throw new BizError(`${interfaceName} 缺少参数 CIIEHolidayVitalityIndex` );
+    if (!zhaoXiangDistrictHolidayVitalityIndex) throw new BizError(`${interfaceName} 缺少参数 zhaoXiangDistrictHolidayVitalityIndex` );
+    if (!qingPuNewTownHolidayVitalityIndex) throw new BizError(`${interfaceName} 缺少参数 qingPuNewTownHolidayVitalityIndex` );
+    if (!zhuJiaJiaoHolidayVitalityIndex) throw new BizError(`${interfaceName} 缺少参数 zhuJiaJiaoHolidayVitalityIndex` );
+    if (!qingPuKeyBusinessDistrictIndex) throw new BizError(`${interfaceName} 缺少参数 qingPuKeyBusinessDistrictIndex` );
+    if (!CIIEConsumptionTypeAnalysis) throw new BizError(`${interfaceName} 缺少参数 CIIEConsumptionTypeAnalysis` );
+    if (!zhaoXiangConsumptionTypeAnalysis) throw new BizError(`${interfaceName} 缺少参数 zhaoXiangConsumptionTypeAnalysis` );
+    if (!zhuJiaJiaoConsumptionTypeAnalysis) throw new BizError(`${interfaceName} 缺少参数 zhuJiaJiaoConsumptionTypeAnalysis` );
+    if (!qingPuNewTownConsumptionTypeAnalysis) throw new BizError(`${interfaceName} 缺少参数 qingPuNewTownConsumptionTypeAnalysis` );
+    if (!qingPuEconomicVitalityTrend) throw new BizError(`${interfaceName} 缺少参数 qingPuEconomicVitalityTrend` );
+
+    let {overallEconomicVitalityIndex} = basicData;
+    let basicInfo = [
+        {总体经济活力指数: overallEconomicVitalityIndex}
+    ];
+
+    //进博会核心区节假日活力指数分析
+    let CIIEHoliday = getHolidayVitalityIndex(CIIEHolidayVitalityIndex);
+
+    //赵巷区节假日活力指数分析
+    let zhaoXiangDistrictHoliday= getHolidayVitalityIndex(zhaoXiangDistrictHolidayVitalityIndex);
+
+    //青浦新城节假日活力指数分析
+    let qingPuNewTownHoliday = getHolidayVitalityIndex(qingPuNewTownHolidayVitalityIndex);
+
+    //朱家角古镇节假日活力指数分析
+    let zhuJiaJiaoHoliday = getHolidayVitalityIndex(zhuJiaJiaoHolidayVitalityIndex);
+
+    //青浦重点商圈经济活力指数
+    let qingPuKeyBusiness= getKeyBusinessDistrictIndex(qingPuKeyBusinessDistrictIndex);
+
+    //进博会核心区消费类型分析
+    let CIIEConsumption = getMonthData(CIIEConsumptionTypeAnalysis);
+
+    //赵巷区消费类型分析
+    let zhaoXiangConsumption = getMonthData(zhaoXiangConsumptionTypeAnalysis);
+
+    //朱家角古镇区消费类型分析
+    let zhuJiaJiaoConsumption = getMonthData(zhuJiaJiaoConsumptionTypeAnalysis);
+
+    //青浦新城消费类型分析
+    let qingPuNewTownConsumption = getMonthData(qingPuNewTownConsumptionTypeAnalysis);
+
+    //青浦重点商圈经济活力变化趋势
+    let qingPuEconomicVitalityTrendData;
+    let qingPuNewTownData = {};
+    let CIIECoreAreaData = {};
+    let zhaoXiangCommercialBusinessData = {};
+    let zhuJiaJiaoAncientTownData = {};
+    qingPuEconomicVitalityTrend.forEach( info => {
+        let {month, qingPuNewTown, CIIECoreArea, zhaoXiangCommercialBusiness, zhuJiaJiaoAncientTown} = info;
+        qingPuNewTownData[month] = qingPuNewTown;
+        CIIECoreAreaData[month] = CIIECoreArea;
+        zhuJiaJiaoAncientTownData[month] = zhuJiaJiaoAncientTown;
+        zhaoXiangCommercialBusinessData[month] = zhaoXiangCommercialBusiness;
+    })
+    qingPuEconomicVitalityTrendData = {青浦新城: qingPuNewTownData, 赵巷商业商务: CIIECoreAreaData, 朱家角古镇: zhaoXiangCommercialBusinessData, 进博会核心区: zhuJiaJiaoAncientTownData};
+
+    return {basicInfo, CIIEHoliday, zhaoXiangDistrictHoliday, qingPuNewTownHoliday, zhuJiaJiaoHoliday, 
+        qingPuKeyBusiness, CIIEConsumption, zhaoXiangConsumption, zhuJiaJiaoConsumption, qingPuNewTownConsumption, qingPuEconomicVitalityTrendData};
+}
+
+//获取节假日活力指数分析
+function getHolidayVitalityIndex(dataList) {
+    let dataInfo;
+    let eatData = {};
+    let liveData = {};
+    let gameData = {};
+    let entertainmentData = {};
+    let shoppingData = {};
+    dataList.forEach( info => {
+        let {holidayName, eat, live, game, entertainment, shopping} = info;
+        eatData[holidayName] = eat;
+        liveData[holidayName] = live;
+        gameData[holidayName] = game;
+        entertainmentData[holidayName] = entertainment;
+        shoppingData[holidayName] = shopping;
+    })
+    dataInfo = {吃: eatData, 住: liveData, 游: gameData, 娱: entertainmentData, 购: shoppingData};
+
+    return dataInfo;
+}
+
+//获取商圈经济活力指数
+function getKeyBusinessDistrictIndex(dataList) {
+    let dataInfo;
+    let currYearData = {}; //当年
+    let lastYearData = {}; //去年
+    let yoyGrowthData = {}; //同比
+    dataList.forEach( info => {
+        let {businessName, currYear, lastYear, yoyGrowth} = info;
+        currYearData[info.businessName] = currYear;
+        lastYearData[businessName] = lastYear;
+        yoyGrowthData[businessName] = yoyGrowth;
+    })
+    dataInfo = {'2021年': lastYearData, '2022年': currYearData, '2022年同比增长': yoyGrowthData};
+
+    return dataInfo;
+}
+
+function getMonthData(dataList) {
+    let dataInfo;
+    let eatData = {};
+    let liveData = {};
+    let gameData = {};
+    let entertainmentData = {};
+    let shoppingData = {};
+    dataList.forEach( info => {
+        let {month, eat, live, game, entertainment, shopping} = info;
+        eatData[month] = eat;
+        liveData[month] = live;
+        gameData[month] = game;
+        entertainmentData[month] = entertainment;
+        shoppingData[month] = shopping;
+    })
+    dataInfo = {吃: eatData, 住: liveData, 游: gameData, 娱: entertainmentData, 购: shoppingData};
+
+    return dataInfo;
+}
\ No newline at end of file

src/data/interface/yskkqyjc.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getYskkqyjc() {
+    let interfaceName = "疑似空壳企业监测";
+    let {basicData, enterpriseDistributionDifferentCapacities, industrialDistribution, changesNumberShellCompanies, changesTrendShellCompanies} = await getInterfaceByInterfaceName(interfaceName);
+    // let basicData;
+    // let enterpriseDistributionDifferentCapacities;
+    // let industrialDistribution;
+    // let changesNumberShellCompanies;
+    // let changesTrendShellCompanies;
+
+    if (!basicData) throw new BizError(`${interfaceName} 缺少参数 basicData` );
+    if (!enterpriseDistributionDifferentCapacities) throw new BizError(`${interfaceName} 缺少参数 enterpriseDistributionDifferentCapacities` );
+    if (!industrialDistribution) throw new BizError(`${interfaceName} 缺少参数 industrialDistribution` );
+    if (!changesNumberShellCompanies) throw new BizError(`${interfaceName} 缺少参数 changesNumberShellCompanies` );
+    if (!changesTrendShellCompanies) throw new BizError(`${interfaceName} 缺少参数 changesTrendShellCompanies` );
+    
+    let {numberOfShellEnterprises, suspectedShellRate} = basicData;
+    let basicInfo = [
+        {疑似空壳企业数: numberOfShellEnterprises},
+        {疑似空壳率: suspectedShellRate}
+    ];
+
+    //不同容量疑似空壳企业分布
+    let {within100, mithin315, more315} = enterpriseDistributionDifferentCapacities;
+    let enterpriseDistribution = [
+        {'0-100kvA': within100},
+        {'101-315kvA': mithin315},
+        {'315kvA以上': more315}
+    ];
+
+    //行业疑似空壳企业分布
+    let {fisheries, industrial, transportationAndWarehousingAndPostalServices, informationTechnologyServices, wholesaleAndRetail, realEstate, 
+        leasingAndBusinessService, publicServiceAndManagementOrganization, constructionIndustry} = industrialDistribution;
+    
+    let industrialInfo = [
+        {'农、林、牧、渔业': fisheries},
+        {'工业': industrial},
+        {'交通运输、仓储和邮政服务': transportationAndWarehousingAndPostalServices},
+        {'信息技术服务业': informationTechnologyServices},
+        {'批发和零售业': wholesaleAndRetail},
+        {'房地产业': realEstate},
+        {'租赁和商务服务业': leasingAndBusinessService},
+        {'公共服务及管理组织': publicServiceAndManagementOrganization},
+        {'金融业': constructionIndustry}
+    ];
+    
+    //疑似空壳企业数变化趋势
+    let changesNumberInfo = {};
+    changesNumberShellCompanies.forEach( info => {
+        let {year, numberOfShellCompanies} = info;
+        changesNumberInfo[year] =  numberOfShellCompanies;
+    })
+
+    //疑似空壳企业空壳率变化趋势
+    let changesTrendShellInfo = {};
+    changesTrendShellCompanies.forEach( info => {
+        let {year, changeTrend} = info;
+        changesTrendShellInfo[year] = changeTrend;
+    })
+
+
+    return {basicInfo, enterpriseDistribution, industrialInfo, changesNumberInfo, changesTrendShellInfo};
+}
\ No newline at end of file

src/data/interface/zdwrqysc.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getZdwrqysc() {
+    let interfaceName = "重点污染企业生产";
+    let {pollutingEnterprises, productionByPollutingEnterprises, pollutingType, pollutingEnterprisesTOP10, comparisonOfPollutionTypesIndex, industryTypePollutantEnterprise, pollutingCompaniesScatter} = await getInterfaceByInterfaceName(interfaceName);
+    // let pollutingEnterprises;
+    // let productionByPollutingEnterprises;
+    // let pollutingType;
+    // let pollutingEnterprisesTOP10;
+    // let comparisonOfPollutionTypesIndex;
+    // let industryTypePollutantEnterprise;
+
+    if (!pollutingEnterprises) throw new BizError(`${interfaceName} 缺少参数 pollutingEnterprises` );
+    if (!productionByPollutingEnterprises) throw new BizError(`${interfaceName} 缺少参数 productionByPollutingEnterprises` );
+    if (!pollutingType) throw new BizError(`${interfaceName} 缺少参数 pollutingType` );
+    if (!pollutingEnterprisesTOP10) throw new BizError(`${interfaceName} 缺少参数 pollutingEnterprisesTOP10` );
+    if (!comparisonOfPollutionTypesIndex) throw new BizError(`${interfaceName} 缺少参数 comparisonOfPollutionTypesIndex` );
+    if (!industryTypePollutantEnterprise) throw new BizError(`${interfaceName} 缺少参数 industryTypePollutantEnterprise` );
+    if (!pollutingCompaniesScatter) throw new BizError(`${interfaceName} 缺少参数 pollutingCompaniesScatter` );
+
+    //污染企业数据
+    let pollutingInfo = [
+        {污染企业总数: pollutingEnterprises.numPollutingEnterprises}
+    ];
+
+    //污染企业生产数据
+    let productionInfo = [
+        {污染企业生产指数: productionByPollutingEnterprises.pollutingEnterprisesIndex}
+    ];
+
+    //污染类型
+    let {waterPollution, hazardousWaste, airPollution, soilPollution, otherHighlights} = pollutingType;
+    let pollutingTypeInfo = [
+        {水污染: waterPollution},
+        {危险污染: hazardousWaste},
+        {大气污染: airPollution},
+        {土壤污染: soilPollution},
+        {其他重点: otherHighlights}
+    ];
+
+    //污染企业TOP10
+    let pollutingTop10 = {};
+    pollutingEnterprisesTOP10.forEach( info => {
+        let {companyName, value} = info;
+        pollutingTop10[companyName] = value;
+    })
+
+    //各污染类型企业生产指数对比
+    let pollutionTypeInfo;
+    let numberOfPollutingCompaniesData = {};
+    let productionIndexData = {};
+    comparisonOfPollutionTypesIndex.forEach( info => {
+        let {pollutionType, numberOfPollutingCompanies, productionIndex} = info;
+        numberOfPollutingCompaniesData[pollutionType] = numberOfPollutingCompanies;
+        productionIndexData[pollutionType] = productionIndex;
+    })
+    pollutionTypeInfo = {污染企业数: numberOfPollutingCompaniesData, 生产指数: productionIndexData};
+
+    //各行业类型污染企业生产指数对比
+    let industryTypeInfo;
+    let numberOfPollutingData = {};
+    let productionData = {};
+    industryTypePollutantEnterprise.forEach( info => {
+        let {industryType, numberOfPollutingCompanies, productionIndex} = info;
+        numberOfPollutingData[industryType] = numberOfPollutingCompanies;
+        productionData[industryType] = productionIndex;
+    })
+    industryTypeInfo = {污染企业数: numberOfPollutingData, 生产指数: productionData};
+
+    return {pollutingInfo, productionInfo, pollutingTypeInfo, pollutionTypeInfo, industryTypeInfo, pollutingCompaniesScatter}
+}
\ No newline at end of file

src/data/interface/zhdy.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getZhdy() {
+    let interfaceName = "智慧电眼首页";
+    let {basicData} = await getInterfaceByInterfaceName(interfaceName);
+    // let basicData;
+    
+    if (!basicData) throw new BizError(`${interfaceName} 缺少参数 basicData` );
+    let {economicSentimentIndex, suspectedShellCompanyRate, coordinatedDevelopmentOfCityClusters, pollutingEnterpriseProductionIndex} = basicData;
+    let basicInfo = [
+        {经济景气指数: economicSentimentIndex},
+        {疑似空壳企业率: suspectedShellCompanyRate + "%"},
+        {城市协同发展指数: coordinatedDevelopmentOfCityClusters},
+        {污染企业生产指数: pollutingEnterpriseProductionIndex}
+    ];
+
+    return basicInfo;
+}

src/data/interface/zzkzl.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "./cronJob";
+
+export async function getZzkzl() {
+    let interfaceName = "住宅空置率";
+    let {vacantHouseholdData, housingVacancyRateData, IdleUserPowerData, qingPuDistrictHousingVacancyRateTrend, housingVacancyRateInKeyAreas,
+        typicalResidentialVacancyRate, vacantHouseholdsInKeyAreas, typicalResidentialVacancyTrends} = await getInterfaceByInterfaceName(interfaceName);
+    // let vacantHouseholdData;
+    // let housingVacancyRateData;
+    // let IdleUserPowerData;
+    // let qingPuDistrictHousingVacancyRateTrend;
+    // let housingVacancyRateInKeyAreas;
+    // let typicalResidentialVacancyRate;
+    // let vacantHouseholdsInKeyAreas;
+    // let typicalResidentialVacancyTrends;
+
+    if (!vacantHouseholdData) throw new BizError(`${interfaceName} 缺少参数 vacantHouseholdData` );
+    if (!housingVacancyRateData) throw new BizError(`${interfaceName} 缺少参数 housingVacancyRateData` );
+    if (!IdleUserPowerData) throw new BizError(`${interfaceName} 缺少参数 IdleUserPowerData` );
+    if (!qingPuDistrictHousingVacancyRateTrend) throw new BizError(`${interfaceName} 缺少参数 qingPuDistrictHousingVacancyRateTrend` );
+    if (!housingVacancyRateInKeyAreas) throw new BizError(`${interfaceName} 缺少参数 housingVacancyRateInKeyAreas` );
+    if (!typicalResidentialVacancyRate) throw new BizError(`${interfaceName} 缺少参数 typicalResidentialVacancyRate` );
+    if (!vacantHouseholdsInKeyAreas) throw new BizError(`${interfaceName} 缺少参数 vacantHouseholdsInKeyAreas` );
+    if (!typicalResidentialVacancyTrends) throw new BizError(`${interfaceName} 缺少参数 typicalResidentialVacancyTrends` );
+
+    //空置户数据
+    let {numberOfVacantHouseholds, chainRatio, yoy} = vacantHouseholdData;
+    let vacantHouseholdInfo = [
+        {空置户数量: numberOfVacantHouseholds},
+        {环比: chainRatio},
+        {同比: yoy}
+    ];
+
+    //青浦区住房空置率趋势
+    let qingPuDistrictHousing = {};
+    qingPuDistrictHousingVacancyRateTrend.forEach( info => {
+        let {month, quantity} = info;
+        qingPuDistrictHousing[month] = quantity;
+    });
+
+    //重点区域住房空置率
+    let housingVacancyInfo;
+    let userNumData = {};
+    let vacancyRateData = {};
+    housingVacancyRateInKeyAreas.forEach( info => {
+        let {keyAreaName, userNum, vacancyRate} = info;
+        userNumData[keyAreaName] = userNum;
+        vacancyRateData[keyAreaName] = vacancyRate;
+    })
+    housingVacancyInfo = {用户数: userNumData, 空置率: vacancyRateData};
+    
+
+    return {vacantHouseholdInfo, qingPuDistrictHousing, housingVacancyInfo};
+}
+
+export async function getHousingVacancyRate() {
+    let interfaceName = "住宅空置率";
+    let zzkzlData = await getInterfaceByInterfaceName(interfaceName);
+    // let zzkzlData;
+
+    if (!zzkzlData.housingVacancyRateData) throw new BizError(`${interfaceName} 缺少参数 housingVacancyRateData` );
+    
+    //住房空置率数据
+    let {housingVacancyRate, chainRatio, yoy} = zzkzlData.housingVacancyRateData;
+    let housingVacancyRateInfo = [
+        {住房空置率: housingVacancyRate},
+        {环比: chainRatio},
+        {同比: yoy}
+    ];
+
+    return {housingVacancyRateInfo};
+}
+
+export async function getIdleUserPower() {
+    let interfaceName = "住宅空置率";
+    // let zzkzlData = await getInterfaceByInterfaceName(interfaceName);
+    let zzkzlData;
+
+    if (!zzkzlData.IdleUserPowerData) throw new BizError(`${interfaceName} 缺少参数 IdleUserPowerData` );
+    
+    //空置用户电量数据
+    let {averagePowerConsumptionOfVacantUsers, chainRatio, yoy} = zzkzlData.IdleUserPowerData;
+    let IdleUserPowerInfo = [
+        {空置用户平均电量: averagePowerConsumptionOfVacantUsers},
+        {环比: chainRatio},
+        {同比: yoy}
+    ];
+
+    return {IdleUserPowerInfo};
+}
+
+export async function getResidentialVacancyRate() {
+    let interfaceName = "住宅空置率";
+    let zzkzlData = await getInterfaceByInterfaceName(interfaceName);
+    // let zzkzlData;
+
+    if (!zzkzlData.typicalResidentialVacancyRate) throw new BizError(`${interfaceName} 缺少参数 typicalResidentialVacancyRate` );
+    
+    //典型小区住房空置率
+    let residentialVacancyRate = zzkzlData.typicalResidentialVacancyRate;
+    
+    let residentialVacancyRateInfo;
+    let userNumData = {};
+    let vacancyRateData = {};
+    residentialVacancyRate.forEach( info => {
+        let {keyAreaName, userNum, vacancyRate} = info;
+        userNumData[keyAreaName] = userNum;
+        vacancyRateData[keyAreaName] = vacancyRate;
+    })
+    residentialVacancyRateInfo = {用户数: userNumData, 空置率: vacancyRateData};
+
+    return {residentialVacancyRateInfo};
+}
+
+export async function getVacantHouseholdsInKeyAreas() {
+    let interfaceName = "住宅空置率";
+    let zzkzlData = await getInterfaceByInterfaceName(interfaceName);
+    // let zzkzlData;
+
+    if (!zzkzlData.vacantHouseholdsInKeyAreas) throw new BizError(`${interfaceName} 缺少参数 vacantHouseholdsInKeyAreas` );
+
+    //重点区域空置户趋势
+    let vacantHouseholdsData = zzkzlData.vacantHouseholdsInKeyAreas;
+    let vacantHouseholds = {};
+    vacantHouseholdsData.forEach( info => {
+        let {month, quantity} = info;
+        vacantHouseholds[month] = quantity;
+    });
+
+    return {vacantHouseholds}
+}
+
+export async function getTypicalResidentialVacancyTrends() {
+    let interfaceName = "住宅空置率";
+    let zzkzlData = await getInterfaceByInterfaceName(interfaceName);
+    // let zzkzlData;
+
+    if (!zzkzlData.typicalResidentialVacancyTrends) throw new BizError(`${interfaceName} 缺少参数 typicalResidentialVacancyTrends` );
+
+    //典型小区空置户趋势
+    let typicalResidential = zzkzlData.typicalResidentialVacancyTrends;
+    let typicalResidentialVacancyTrends = {};
+    typicalResidential.forEach( info => {
+        let {month, quantity} = info;
+        typicalResidentialVacancyTrends[month] = quantity;
+    });
+
+    return {typicalResidential};
+}
\ No newline at end of file

src/main.ts

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

src/middleware/checkToken.ts

-import httppackage = require('httppackage');
+// import httppackage = require('httppackage');
 
 export async function checkToken(req, res, next) {
-    let checkSuccess = httppackage();
-    if (checkSuccess) next();
+    // let checkSuccess = httppackage();
+    // if (checkSuccess) next();
 }
\ No newline at end of file

src/routers/router.ts

@@ -19,46 +19,93 @@ import * as zhnyPageBiz from '../biz/zhnyPage';
 import * as lsdl_cdssPageBiz from '../biz/lsdl_cdssPage';
 import * as lsdl_qjnygfPageBiz from '../biz/lsdl_qjnygfPage';
 
+//interface
+import * as lsdl_qjnygfBiz from '../biz/csjInterface/lsdl_qjnygf';
+import * as lsdl_cdssBiz from '../biz/csjInterface/lsdl_cdss';
+import * as qyrhBiz from '../biz/csjInterface/qyrh';
+import * as zhdy_csqxtfzBiz from '../biz/csjInterface/zhdy_csqxtfz';
+import * as zhdy_gsqyBiz from '../biz/csjInterface/zhdy_gsqy';
+import * as zhdy_hyydfbBiz from '../biz/csjInterface/zhdy_hyydfb';
+import * as zhdy_jjjqdBiz from '../biz/csjInterface/zhdy_jjjqd';
+import * as zhdy_qydzxypgBiz from '../biz/csjInterface/zhdy_qydzxypg';
+import * as zhdy_sqjjhlBiz from '../biz/csjInterface/zhdy_sqjjhl';
+import * as zhdy_yskkqyBiz from '../biz/csjInterface/zhdy_yskkqy';
+import * as zhdy_zdwrqyBiz from '../biz/csjInterface/zhdy_zdwrqy';
+import * as zhdy_zzkkzlBiz from '../biz/csjInterface/zhdy_zzkzl';
+import * as interfaceZhdyBiz from '../biz/csjInterface/zhdy';
+
 import * as sjlyBiz from '../biz/sjly'
 import { checkToken } from '../middleware/checkToken';
 
 export function setRouter(httpServer){
         
-    httpServer.get('/zhdy',checkToken, asyncHandler(zhdyBiz.getData));
-    httpServer.get('/zhdyMsgbox1',checkToken, asyncHandler(zhdyMsgbox1Biz.getData));
-    httpServer.get('/zhdyMsgbox2',checkToken, asyncHandler(zhdyMsgbox2Biz.getData));
-    httpServer.get('/zhdyMsgbox3',checkToken, asyncHandler(zhdyMsgbox3Biz.getData));
-    httpServer.get('/zhdyMsgbox4',checkToken, asyncHandler(zhdyMsgbox4Biz.getData));
-    httpServer.get('/zhdyMsgbox5',checkToken, asyncHandler(zhdyMsgbox5Biz.getData));
-    httpServer.get('/zhdyMsgbox6',checkToken, asyncHandler(zhdyMsgbox6Biz.getData));
-    httpServer.get('/zhdyMsgbox7',checkToken, asyncHandler(zhdyMsgbox7Biz.getData));
-    httpServer.get('/zhdyMsgbox8',checkToken, asyncHandler(zhdyMsgbox8Biz.getData));
-    httpServer.get('/zhdyMsgbox9',checkToken, asyncHandler(zhdyMsgbox9Biz.getData));
-    httpServer.get('/ptjcnlPage',checkToken, asyncHandler(ptjcnlPageBiz.getData));
-    httpServer.get('/sfqztgkPage',checkToken, asyncHandler(sfqztgkPageBiz.getData));
-    httpServer.get('/qyehPage',checkToken, asyncHandler(qyehPageBiz.getData));
-    httpServer.get('/qyehxlfzlPage',checkToken, asyncHandler(qyehPageBiz.get线路负载率));
-    httpServer.get('/zhnyPage',checkToken, asyncHandler(zhnyPageBiz.getData));
-    httpServer.get('/lsdl_cdssPage',checkToken, asyncHandler(lsdl_cdssPageBiz.getData));
-    httpServer.get('/lsdl_qjnygfPage',checkToken, asyncHandler(lsdl_qjnygfPageBiz.getData));
-    httpServer.get('/sjly',checkToken, asyncHandler(sjlyBiz.getData));
+    // httpServer.get('/zhdy', asyncHandler(zhdyBiz.getData));
+    // httpServer.get('/zhdyMsgbox1', asyncHandler(zhdyMsgbox1Biz.getData));
+    // httpServer.get('/zhdyMsgbox2', asyncHandler(zhdyMsgbox2Biz.getData));
+    // httpServer.get('/zhdyMsgbox3', asyncHandler(zhdyMsgbox3Biz.getData));
+    // httpServer.get('/zhdyMsgbox4', asyncHandler(zhdyMsgbox4Biz.getData));
+    // httpServer.get('/zhdyMsgbox5', asyncHandler(zhdyMsgbox5Biz.getData));
+    // httpServer.get('/zhdyMsgbox6', asyncHandler(zhdyMsgbox6Biz.getData));
+    // httpServer.get('/zhdyMsgbox7', asyncHandler(zhdyMsgbox7Biz.getData));
+    // httpServer.get('/zhdyMsgbox8', asyncHandler(zhdyMsgbox8Biz.getData));
+    // httpServer.get('/zhdyMsgbox9', asyncHandler(zhdyMsgbox9Biz.getData));
+    httpServer.get('/ptjcnlPage', asyncHandler(ptjcnlPageBiz.getData));
+    // httpServer.get('/sfqztgkPage', asyncHandler(sfqztgkPageBiz.getData));
+    // httpServer.get('/qyehPage', asyncHandler(qyehPageBiz.getData));
+    httpServer.get('/qyehxlfzlPage', asyncHandler(qyehPageBiz.get线路负载率));
+    // httpServer.get('/zhnyPage', asyncHandler(zhnyPageBiz.getData));
+    // httpServer.get('/lsdl_cdssPage', asyncHandler(lsdl_cdssPageBiz.getData));
+    // httpServer.get('/lsdl_qjnygfPage', asyncHandler(lsdl_qjnygfPageBiz.getData));
+    httpServer.get('/sjly', asyncHandler(sjlyBiz.getData));
+        
+    httpServer.post('/sjly', asyncHandler(sjlyBiz.getData));   
+    // httpServer.post('/lsdl_cdssPage', asyncHandler(lsdl_cdssPageBiz.getData));
+    // httpServer.post('/lsdl_qjnygfPage', asyncHandler(lsdl_qjnygfPageBiz.getData));
+    httpServer.post('/ptjcnlPage', asyncHandler(ptjcnlPageBiz.getData));
+    // httpServer.post('/sfqztgkPage', asyncHandler(sfqztgkPageBiz.getData));
+    // httpServer.post('/qyehPage', asyncHandler(qyehPageBiz.getData));
+    httpServer.post('/qyehxlfzlPage', asyncHandler(qyehPageBiz.get线路负载率));
+    // httpServer.post('/zhnyPage', asyncHandler(zhnyPageBiz.getData));    
+    // httpServer.post('/zhdy', asyncHandler(zhdyBiz.getData));
+    // httpServer.post('/zhdyMsgbox1', asyncHandler(zhdyMsgbox1Biz.getData));
+    // httpServer.post('/zhdyMsgbox2', asyncHandler(zhdyMsgbox2Biz.getData));
+    // httpServer.post('/zhdyMsgbox3', asyncHandler(zhdyMsgbox3Biz.getData));
+    // httpServer.post('/zhdyMsgbox4', asyncHandler(zhdyMsgbox4Biz.getData));
+    // httpServer.post('/zhdyMsgbox5', asyncHandler(zhdyMsgbox5Biz.getData));
+    // httpServer.post('/zhdyMsgbox6', asyncHandler(zhdyMsgbox6Biz.getData));
+    // httpServer.post('/zhdyMsgbox7', asyncHandler(zhdyMsgbox7Biz.getData));
+    // httpServer.post('/zhdyMsgbox8', asyncHandler(zhdyMsgbox8Biz.getData));
+    // httpServer.post('/zhdyMsgbox9', asyncHandler(zhdyMsgbox9Biz.getData));
+
+
+
+    //interface -------
+    httpServer.get('/lsdl_qjnygfPage', asyncHandler(lsdl_qjnygfBiz.getData));
+    httpServer.get('/lsdl_cdssPage', asyncHandler(lsdl_cdssBiz.getData));
+    httpServer.get('/qyehPage', asyncHandler(qyrhBiz.getData));
+    httpServer.get('/zhdyMsgbox1', asyncHandler(zhdy_csqxtfzBiz.getData));
+    httpServer.get('/zhdyMsgbox2', asyncHandler(zhdy_gsqyBiz.getData));
+    httpServer.get('/zhdyMsgbox8', asyncHandler(zhdy_hyydfbBiz.getData));
+    httpServer.get('/zhdyMsgbox3', asyncHandler(zhdy_jjjqdBiz.getData));
+    httpServer.get('/zhdyMsgbox5', asyncHandler(zhdy_qydzxypgBiz.getData));
+    httpServer.get('/zhdyMsgbox6', asyncHandler(zhdy_sqjjhlBiz.getData));
+    httpServer.get('/zhdyMsgbox4', asyncHandler(zhdy_yskkqyBiz.getData));
+    httpServer.get('/zhdyMsgbox7', asyncHandler(zhdy_zdwrqyBiz.getData));
+    httpServer.get('/zhdyMsgbox9', asyncHandler(zhdy_zzkkzlBiz.getData));
+    httpServer.get('/zhdy', asyncHandler(interfaceZhdyBiz.getData));
+    
+    httpServer.post('/lsdl_qjnygfPage', asyncHandler(lsdl_qjnygfBiz.getData));
+    httpServer.post('/lsdl_cdssPage', asyncHandler(lsdl_cdssBiz.getData));
+    httpServer.post('/qyehPage', asyncHandler(qyrhBiz.getData));
+    httpServer.post('/zhdyMsgbox1', asyncHandler(zhdy_csqxtfzBiz.getData));
+    httpServer.post('/zhdyMsgbox2', asyncHandler(zhdy_gsqyBiz.getData));
+    httpServer.post('/zhdyMsgbox8', asyncHandler(zhdy_hyydfbBiz.getData));
+    httpServer.post('/zhdyMsgbox3', asyncHandler(zhdy_jjjqdBiz.getData));
+    httpServer.post('/zhdyMsgbox5', asyncHandler(zhdy_qydzxypgBiz.getData));
+    httpServer.post('/zhdyMsgbox6', asyncHandler(zhdy_sqjjhlBiz.getData));
+    httpServer.post('/zhdyMsgbox4', asyncHandler(zhdy_yskkqyBiz.getData));
+    httpServer.post('/zhdyMsgbox7', asyncHandler(zhdy_zdwrqyBiz.getData));
+    httpServer.post('/zhdyMsgbox9', asyncHandler(zhdy_zzkkzlBiz.getData));
+    httpServer.post('/zhdy', asyncHandler(interfaceZhdyBiz.getData));
 
-    httpServer.post('/sjly',checkToken, asyncHandler(sjlyBiz.getData));   
-    httpServer.post('/lsdl_cdssPage',checkToken, asyncHandler(lsdl_cdssPageBiz.getData));
-    httpServer.post('/lsdl_qjnygfPage',checkToken, asyncHandler(lsdl_qjnygfPageBiz.getData));
-    httpServer.post('/ptjcnlPage',checkToken, asyncHandler(ptjcnlPageBiz.getData));
-    httpServer.post('/sfqztgkPage',checkToken, asyncHandler(sfqztgkPageBiz.getData));
-    httpServer.post('/qyehPage',checkToken, asyncHandler(qyehPageBiz.getData));
-    httpServer.post('/qyehxlfzlPage',checkToken, asyncHandler(qyehPageBiz.get线路负载率));
-    httpServer.post('/zhnyPage',checkToken, asyncHandler(zhnyPageBiz.getData));    
-    httpServer.post('/zhdy',checkToken, asyncHandler(zhdyBiz.getData));
-    httpServer.post('/zhdyMsgbox1',checkToken, asyncHandler(zhdyMsgbox1Biz.getData));
-    httpServer.post('/zhdyMsgbox2',checkToken, asyncHandler(zhdyMsgbox2Biz.getData));
-    httpServer.post('/zhdyMsgbox3',checkToken, asyncHandler(zhdyMsgbox3Biz.getData));
-    httpServer.post('/zhdyMsgbox4',checkToken, asyncHandler(zhdyMsgbox4Biz.getData));
-    httpServer.post('/zhdyMsgbox5',checkToken, asyncHandler(zhdyMsgbox5Biz.getData));
-    httpServer.post('/zhdyMsgbox6',checkToken, asyncHandler(zhdyMsgbox6Biz.getData));
-    httpServer.post('/zhdyMsgbox7',checkToken, asyncHandler(zhdyMsgbox7Biz.getData));
-    httpServer.post('/zhdyMsgbox8',checkToken, asyncHandler(zhdyMsgbox8Biz.getData));
-    httpServer.post('/zhdyMsgbox9',checkToken, asyncHandler(zhdyMsgbox9Biz.getData));
 }
\ No newline at end of file