no message

.gitignore

@@ -4,5 +4,6 @@
 /test
 /public
 /logs
+/video
 *test*
 *.log
\ No newline at end of file

serverConfig.xml

@@ -14,7 +14,7 @@
         <broken>3</broken>
         <token>09a98bc555474e058ef90b6cc6e23638</token>
     </mapView>
-    <imagePath>192.168.0.105</imagePath>
+    <imagePath>192.168.0.47</imagePath>
     <mapCenter>
         <lng>121.183574</lng>
         <lat>31.291126</lat>

src/biz/jgfwnl/data.ts

@@ -6,7 +6,8 @@ import { getHardware } from "../../data/interface/hardwareData";
 import { getCsgkData, getDetachmentRatio, getTestAnalysis, getTestTotalTime } from "../../data/interface/interfaceService";
 import { getMap } from "../../data/interface/mapInterfaceData";
 import { getOnlieCarCount } from "../../data/interface/wsData";
-
+import { getQycs, getQytlzdjs, getYdcs } from "../../data/newInterface/csfxData";
+import { getCspzfb, getJcsj, getJrsj } from "../../data/newInterface/csgkData";
 
 //云资源
 export async function getYZY(req, res) {
@@ -26,9 +27,101 @@ export async function getYZY(req, res) {
 }
 
 //测试概况
+let csfxQueue = {};
+let csfxQueueTime = "";
+export async function getCSGK(req, res) {
+    let ret:any = {};
+
+    let today = moment().format("YYYYMMDD");
+    if (today == csgkQueueTime) {
+        let 今日数据data = {"在线车辆数":`${getOnlieCarCount()}辆`};
+        csgkQueue["api2"] = getKeyValueNumberOutData("今日数据", 今日数据data);
+        res.send(csgkQueue);
+        return;
+    }
+    csgkQueueTime = today;
+  
+    let resule = await getJcsj(); //----------
+    let 基础数据Info = [];
+    resule.forEach((info, index) => {
+        let {key, value} = info;
+        let {dataNum, dataUnit} = separateDataAndUint(value);
+        基础数据Info.push({key, value:dataNum, unit:dataUnit, icon:`http://${getImageIp()}:${systemConfig.port}/csgk/${index+1}.png`});
+    });
+    ret["api1"] = ({title:"基础数据", dataList: 基础数据Info});
+
+    let 今日数据data = {"在线车辆数":`${getOnlieCarCount()}辆`};
+
+    let {今日数据, 今日测试, 今日功能测试} = await getJrsj(); //-----------
+    ret["api2"] = getKeyValueNumberOutData("今日数据", 今日数据data);
+    ret["api3"] = getKeyValueNumberOutData("今日测试", 今日测试);
+    ret["api4"] = getKeyValueNumberOutData("今日功能测试", 今日功能测试);
+        
+    let 测试牌照分布data = await getCspzfb(); //----------
+    ret["api5"] = getKeyValueNumberOutData("测试牌照分布", 测试牌照分布data);
+
+    let 路侧监控视频data = {"src": appConfig.surveillanceVideo, "type": 'application/x-mpegURL'};
+    ret["api6"] = ({title:"路侧监控视频", dataList: 路侧监控视频data});
+
+    csgkQueue = JSON.parse(JSON.stringify(ret));
+    res.send(ret);
+}
+
+//测试分析
+export async function getCSFX(req, res) {
+    let ret:any = {};
+
+    let today = moment().format("YYYYMMDD");
+    if (today == csfxQueueTime) {
+        res.send(csfxQueue);
+        return;
+    }
+    csfxQueueTime = today;
+
+    let 企业测试自动驾驶比率Info = await getQytlzdjs(); //----------
+    ret["api5"] = getListOutData("企业脱离自动驾驶比率", 企业测试自动驾驶比率Info);
+
+    let {月度测试时长数据, 月度测试时长功能数据, 月度测试里程数据, 月度测试里程功能数据} = await getYdcs(); //----------
+   
+    let 月度测试里程分布data = {测试: {unit:'km', dataInfo: 月度测试里程数据}, 功能测试: {unit:'km', dataInfo: 月度测试里程功能数据}};
+    ret["api1"] = getChartOutData("月度测试里程分布", 月度测试里程分布data);
+    
+    let 月度测试时长分布data = {测试: {unit:'h', dataInfo: 月度测试时长数据}, 功能测试: {unit:'h', dataInfo: 月度测试时长功能数据}};
+    ret["api2"] = getChartOutData("月度测试时长分布", 月度测试时长分布data);
+    
+    let {企业测试时长数据, 企业测试时长功能数据, 企业测试里程数据, 企业测试里程功能数据} = await getQycs(); //----------
+    let 企业测试里程分布data = {测试: {unit:'km', dataInfo: 企业测试里程数据}, 功能测试: {unit:'km', dataInfo: 企业测试里程功能数据}};
+    ret["api3"] = getChartOutData("企业测试里程分布", 企业测试里程分布data);
+
+    let 企业测试时长分布data = {测试: {unit:'h', dataInfo: 企业测试时长数据}, 功能测试: {unit:'h', dataInfo: 企业测试时长功能数据}};
+    ret["api4"] = getChartOutData("企业测试时长分布", 企业测试时长分布data);
+
+    csfxQueue = JSON.parse(JSON.stringify(ret));
+    res.send(ret);
+}
+
+
+//云资源
+export async function getYZYold(req, res) {
+    let ret:any = {};
+
+    let {计算云资源, 使用率, 物理资源} = await getHardware();
+
+    // let 计算云资源 = {"cpu":"3568核", "内存":"4000G", "本地磁盘":"1999G", "云磁盘总量":"848484G"};
+    // let 使用率 = {"CPU":"63.9%", "内存":"30.4%", "本地磁盘":"29.6%", "云磁盘cds ssd池":"23%", "云磁盘cds sata池":"73%", "对象存储":"73.83%"};
+    // let 物理资源 = {"物理机":"100台", "网络设备":"34台", "安全设备":"4台", "机柜":"16台"};
+    
+    ret["api1"] = getKeyValueNumberOutData("计算云资源", 计算云资源 );
+    ret["api2"] = getKeyValueNumberOutData("计算云资源使用率", 使用率 );
+    ret["api3"] = getKeyValueNumberOutData("物理资源", 物理资源 );
+
+    res.send(ret);
+}
+
+//测试概况
 let csgkQueue = {};
 let csgkQueueTime = "";
-export async function getCSGK(req, res) {
+export async function getCSGKold(req, res) {
     let ret:any = {};
 
     let today = moment().format("YYYYMMDD");
@@ -66,9 +159,7 @@ export async function getCSGK(req, res) {
 }
 
 //测试分析
-let csfxQueue = {};
-let csfxQueueTime = "";
-export async function getCSFX(req, res) {
+export async function getCSFXold(req, res) {
     let ret:any = {};
 
     let today = moment().format("YYYYMMDD");

src/biz/sjpt/data.ts

+
+//云资源
+export async function getYZY(req, res) {
+    let ret:any = {};
+
+    
+    res.send(ret);
+}
+
+//测试概况
+export async function getCSGK(req, res) {
+    let ret:any = {};
+
+    res.send(ret);
+}
+
+//测试分析
+export async function getCSFX(req, res) {
+    let ret:any = {};
+
+    
+    res.send(ret);
+}
+
+//地图数据结构
+export async function mapData(req, res) {
+    let ret:any = {};
+
+    res.send(ret);
+}
\ No newline at end of file

src/config/enum.ts

@@ -2,3 +2,12 @@ export enum INTERFACEREQUESTTYPEENUM {
     即时更新 = 1,
     定时更新
 }
+
+export enum CODEEENUM {
+    "请求成功" = 200,
+    "请求未鉴权" = 401,
+    "请求路径不存在" = 404,
+    "请求频率过高" = 503
+}
+
+

src/data/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/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:"url地址",  reqType:"post",  header:{},  body:{} },
+    // "事件接口":{ type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24,  url:"url地址",  reqType:"post",  header:{},  body:{} },
+    // "舆情督办处置接口":{ type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24,  url:"url地址",  reqType:"post",  header:{},  body:{} },
+    // "舆情接口":{ type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24,  url:"url地址",  reqType:"post",  header:{},  body:{} },
+    //新左屏
+    "鉴权url接口":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.51.50.203:8000/get_token",  reqType:"get",  header:{},  body:{apikey:"301bigscreen", key:"edd1c9f034335f136f8"}},
+    "测试企业及车辆数量接口":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.51.50.203:8000/icv-openapi/v1/static/enterpriseVehicleAmount",  reqType:"get",  header:{},  body:{token:"1v5ds654rg8ewrd14vg"}},
+    "总实时测试概况接口":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.51.50.203:8000/icv-openapi/v1/realtime/statistics/testStatusTotal",  reqType:"get",  header:{},  body:{token:"1v5ds654rg8ewrd14vg"}},
+    "今日实时测试概况接口":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.51.50.203:8000/icv-openapi/v1/realtime/statistics/todayTestStatusTotal",  reqType:"get",  header:{},  body:{token:"1v5ds654rg8ewrd14vg"}},
+    "企业历史里程及时长统计信息接口":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.51.50.203:8000/icv-openapi/v1/history/statistics/enterpriseTestStatus",  reqType:"get",  header:{},  body:{token:"1v5ds654rg8ewrd14vg"}},
+    "月度历史里程及时长统计信息接口":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.51.50.203:8000/icv-openapi/v1/history/statistics/monthlyTestStatus",  reqType:"get",  header:{},  body:{token:"1v5ds654rg8ewrd14vg"}},
+    "企业历史脱离率统计接口":{type:INTERFACEREQUESTTYPEENUM.即时更新, time:3600000*24, url:"http://10.51.50.203:8000/icv-openapi/v1/history/statistics/enterpriseExitRate",  reqType:"get",  header:{},  body:{token:"1v5ds654rg8ewrd14vg"}},
+
+};
\ No newline at end of file

src/data/newInterface/csfxData.ts

+import moment = require("moment");
+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "../cronJob";
+import { getToken } from "./tokenData";
+
+let token = getToken();
+
+//企业测试
+export async function getQycs() {
+    let startTime = moment().format("YYYY-MM") + "-01";
+    let endTime = moment().format('YYYY-MM-DD');
+    let data = await getData("企业历史里程及时长统计信息接口", {token, startTime, endTime});
+    let {enterpriseTestStatusList} = data;
+    let 企业测试时长数据 = [];
+    let 企业测试时长功能数据 = [];
+    let 企业测试里程数据 = [];
+    let 企业测试里程功能数据 = [];
+    enterpriseTestStatusList.forEach( info => {
+        let {enterpriseName, testStatistics} = info;
+        企业测试时长数据.push({key: enterpriseName, value: testStatistics.duration});
+        企业测试时长功能数据.push({key: enterpriseName, value: testStatistics.autoDuration});
+        企业测试里程数据.push({key: enterpriseName, value: testStatistics.mileage});
+        企业测试里程功能数据.push({key: enterpriseName, value: testStatistics.autoMileage});
+    })
+
+    return {企业测试时长数据, 企业测试时长功能数据, 企业测试里程数据, 企业测试里程功能数据};
+}
+
+//月度测试
+export async function getYdcs() {
+    let interfaceName = "月度历史里程及时长统计信息接口";
+    let 月度测试时长数据 = [];
+    let 月度测试时长功能数据 = [];
+    let 月度测试里程数据 = [];
+    let 月度测试里程功能数据 = [];
+
+    let 月度历史里程及时长 = await getData(interfaceName, {token});
+    let {monthlyTestStatusList} = 月度历史里程及时长;
+    monthlyTestStatusList.forEach( info => {
+        let {date, testStatistics} = info;
+        for (let i = 20; i >= 0; i--) {
+            let time = moment().subtract(i, 'months').format('YYYY-MM');
+            if (date == time) {
+                月度测试时长数据.push({key: date, value: testStatistics.duration});
+                月度测试时长功能数据.push({key: date, value: testStatistics.autoDuration});
+                月度测试里程数据.push({key: date, value: testStatistics.mileage});
+                月度测试里程功能数据.push({key: date, value: testStatistics.autoMileage});
+            }
+        }
+    })
+
+    // let startTime = moment().format("YYYY-MM") + "-01";
+    // let endTime = moment().format('YYYY-MM-DD');
+    // let monthData = await getInterfaceByInterfaceName(interfaceName, {token, startTime, endTime});
+    // let {monthlyTestStatusList} = monthData;
+    // monthlyTestStatusList.forEach( info => {
+    //     let {date, testStatistics} = info;
+    //     月度测试时长数据.push({key: date, value: testStatistics.duration});
+    //     月度测试时长功能数据.push({key: date, value: testStatistics.autoDuration});
+    //     月度测试里程数据.push({key: date, value: testStatistics.mileage});
+    //     月度测试里程功能数据.push({key: date, value: testStatistics.autoMileage});
+    // })
+    return {月度测试时长数据, 月度测试时长功能数据, 月度测试里程数据, 月度测试里程功能数据};
+}
+
+//企业脱离自动驾驶比率
+export async function getQytlzdjs() {
+    let startTime = moment().format("YYYY-MM") + "-01";
+    let endTime = moment().format('YYYY-MM-DD');
+    let data = await getData("企业历史脱离率统计接口", {token, startTime, endTime});
+    let {enterpriseExitList} = data;
+    let 企业名称data = [];
+    let 次数data = [];
+    let 里程data = [];
+    let 比率data = [];
+    enterpriseExitList.forEach( info => {
+        let {autoMileage, exitCount} = info;
+        // let ratio = Math.ceil(exitCount/autoMileage);
+        let ratio = Math.ceil((exitCount/autoMileage)*100/100);
+        if (autoMileage == 0 || exitCount == 0) ratio = 0;
+        if (ratio > 100) ratio = 100;
+        info["ratio"] = ratio;
+    })
+    
+    enterpriseExitList.sort((a, b) => {
+        return b.ratio - a.ratio;
+    })
+    let enterpriseExitListTop10 = enterpriseExitList.slice(0, 10);
+    enterpriseExitListTop10.forEach( info => {
+        let {autoMileage, enterpriseName, exitCount, ratio} = info;
+        企业名称data.push(enterpriseName);
+        次数data.push(exitCount + "次");
+        里程data.push(autoMileage + "公里");
+        比率data.push(ratio + "%")
+    });
+
+    let 企业测试自动驾驶比率 = [
+        {key:"企业名称", values: 企业名称data},
+        {key:"次数", values: 次数data},
+        {key:"里程", values: 里程data},
+        {key:"比率", values: 比率data},
+    ];
+
+    return 企业测试自动驾驶比率;
+}
+
+async function getData(interfaceName, body) {
+    let {code, data} = await getInterfaceByInterfaceName(interfaceName, body);
+    if (!code) throw new BizError(`${interfaceName} 缺少参数 code`);
+    if (code == 401) throw new BizError(`${interfaceName} 请求未鉴权`);
+    if (code == 404) throw new BizError(`${interfaceName} 请求路径不存在`);
+    if (code == 503) throw new BizError(`${interfaceName} 请求频率过高`);
+    if (!data) throw new BizError(`${interfaceName} 缺少参数 data`);
+
+    return data;
+}

src/data/newInterface/csgkData.ts

+import { BizError } from "../../util/bizError";
+import { getInterfaceByInterfaceName } from "../cronJob";
+import { getToken } from "./tokenData";
+
+let token = getToken();
+//测试牌照分布
+export async function getCspzfb() {
+    let data = await getData("测试企业及车辆数量接口", token);
+    let {enterpriseVehicleList} = data;
+
+    let cspzData = {};
+    enterpriseVehicleList.forEach (info => {
+        let {enterpriseLogo, totalVehicle} = info;
+        if(enterpriseLogo) cspzData[enterpriseLogo] = totalVehicle + "辆";
+    })
+
+    return cspzData;
+}
+
+//基础数据
+export async function getJcsj() {
+    let qyData = await getData("测试企业及车辆数量接口", token);
+    let {totalEnterprise, totalVehicle} = qyData;
+    let 测试企业数 = totalEnterprise;
+    let 企业牌照数 = totalVehicle;
+
+    let data = await getData("总实时测试概况接口", token);
+    let {autoDuration, autoMileage, duration, mileage} = data;
+
+    let result = [
+        {key: "测试企业数", value: 测试企业数 + "家"},
+        {key: "企业牌照数", value: 企业牌照数 + "个"},
+        {key: "测试总里程", value: mileage + "km"},
+        {key: "测试总时长", value: duration + "h"},
+        {key: "功能测试总里程", value: autoMileage + "km"},
+        {key: "功能测试总时长", value: autoDuration + "h"}
+    ];
+
+    return result;
+}
+
+//今日数据
+export async function getJrsj() {
+    let data = await getData("今日实时测试概况接口", token);
+    let {autoDuration, autoMileage, duration, mileage} = data;
+    let 今日数据 = {"在线车辆数": ""}
+
+    let 今日测试 = { "里程": mileage + 'km', "时长": duration + 'h'};
+
+    let 今日功能测试 = { "里程": autoMileage + 'km', "时长": autoDuration + 'h'};
+
+    return {今日数据, 今日测试, 今日功能测试};
+}
+
+async function getData(interfaceName, token) {
+    let {code, data} = await getInterfaceByInterfaceName(interfaceName, {token});
+    if (code == 401) throw new BizError(`${interfaceName} 请求未鉴权`);
+    if (code == 404) throw new BizError(`${interfaceName} 请求路径不存在`);
+    if (code == 503) throw new BizError(`${interfaceName} 请求频率过高`);
+    if (!data) throw new BizError(`${interfaceName} 缺少参数 data`);
+
+    return data;
+}
\ No newline at end of file

src/data/newInterface/tokenData.ts

+import { getInterfaceByInterfaceName } from "../cronJob";
+
+//token
+export async function getToken() {
+    let interfaceName = "鉴权url接口";
+    // let {token} = await getInterfaceByInterfaceName(interfaceName);
+    let token = "4vs5df6r4dg58d45gdes";
+    return token;
+}
\ No newline at end of file

src/main.ts

@@ -8,7 +8,7 @@ import { httpServer } from "./net/http_server";
 async function lanuch() {
     await initConfig();//初始化配置解析
     await initWSData();
-    await initData();
+    // await initData();
     await initSocketServer(systemConfig.socketPort);
     httpServer.createServer(systemConfig.port);
     console.log('This indicates that the server is started successfully.');