no message

serverConfig.xml

 <config>
-    <port>30003</port>
-    <sockentPort>30002</sockentPort>
+    <portConfig>30001</portConfig>
+    <socketPortConfig>30002</socketPortConfig>
     <rightView>http://10.51.50.136:8090/sql/execute</rightView>
     <leftView>
         <cloudResource>http://10.51.50.140:8080/api/static/PrivateCloudUsageStatics</cloudResource>

src/biz/jgfwnl/data.ts

 import { getChartOutData, getKeyValueNumberOutData, getListOutData } from "../../cal/out";
 import { separateDataAndUint } from "../../cal/privateTools";
 import { getHardware } from "../../data/interface/hardwareData";
-import { getCsgkBasicData, getDetachmentRatio, getTestAnalysis, getTestLicense, getTestTotalTime } from "../../data/interface/interfaceService";
+import { getCsgkData, getDetachmentRatio, getTestAnalysis, getTestTotalTime } from "../../data/interface/interfaceService";
 import { getMap } from "../../data/interface/mapInterfaceData";
+import { getOnlieCarCount } from "../../data/interface/wsData";
 
 
 //云资源
@@ -27,56 +28,22 @@ export async function getYZY(req, res) {
 export async function getCSGK(req, res) {
     let ret:any = {};
 
-    let 基础数据data = [
-        {key:"测试企业数", value:"128家", icon: "http://192.168.0.117:30001/csgk/1.png"},
-        {key:"企业牌照数", value:"1456个", icon:"http://192.168.0.117:30001/csgk/2.png"},
-        {key:"测试总里程", value:"1876km", icon:"http://192.168.0.117:30001/csgk/3.png"},
-        {key:"测试总时长", value:"462h", icon:"http://192.168.0.117:30001/csgk/4.png"},
-        {key:"功能测试总里程", value:"3105km", icon:"http://192.168.0.117:30001/csgk/5.png"},
-        {key:"功能测试总时长", value:"5635h", icon:"http://192.168.0.117:30001/csgk/6.png"},
-    ];
-    
-    let 测试概况基础数据 = await getCsgkBasicData();
-    let 基础数据 = [];
-    for (let key in 测试概况基础数据) {
-        let index = 1;
-        基础数据.push({key, value: 测试概况基础数据[key], icon: `http://192.168.0.117:30001/csgk/${index}.png`});
-        index++;
-    }
+    let {测试牌照分布data, result, 今日数据, 今日测试, 今日功能测试} = await getCsgkData();
 
     let 基础数据Info = [];
-    基础数据.forEach(info => {
-        let {key, value, icon} = info;
+    result.forEach((info, index) => {
+        let {key, value} = info;
         let {dataNum, dataUnit} = separateDataAndUint(value);
-        基础数据Info.push({key, value:dataNum, icon, unit:dataUnit});
-    })
+        基础数据Info.push({key, value:dataNum, unit:dataUnit, icon:`http://192.168.0.117:30001/csgk/${index+1}.png`});
+    });
     
     ret["api1"] = ({title:"基础数据", dataList: 基础数据Info});
 
-    let 今日数据data = {"在线车辆数":"5625辆"};
+    let 今日数据data = {"在线车辆数":`${getOnlieCarCount()}辆`};
     ret["api2"] = getKeyValueNumberOutData("今日数据", 今日数据data);
+    ret["api3"] = getKeyValueNumberOutData("今日测试", 今日测试);
+    ret["api4"] = getKeyValueNumberOutData("今日功能测试", 今日功能测试);
         
-    let 今日测试data = {"里程":"4118km", "时长":"184.2h"};
-    ret["api3"] = getKeyValueNumberOutData("今日测试", 今日测试data);
-
-    let 今日功能测试data = {"里程":"1478km", "时长":"421.3h"};
-    ret["api4"] = getKeyValueNumberOutData("今日功能测试", 今日功能测试data);
-
-    // let 测试牌照分布data = {"http://192.168.0.117:30001/img/AutoX.png":"61辆", "http://192.168.0.117:30001/img/阿利昂斯.png":"45辆", 
-    //     "http://192.168.0.117:30001/img/百度.png":"31辆", "http://192.168.0.117:30001/img/宝马.png":"47辆", 
-    //     "http://192.168.0.117:30001/img/初速度.png":"65辆", "http://192.168.0.117:30001/img/滴滴.png":"71辆", 
-    //     "http://192.168.0.117:30001/img/丰田.png":"18辆", "http://192.168.0.117:30001/img/华为.png":"23辆", 
-    //     "http://192.168.0.117:30001/img/吉利汽车.png":"33辆", "http://192.168.0.117:30001/img/商汤.png":"16辆", 
-    //     "http://192.168.0.117:30001/img/上汽大通.png":"22辆", "http://192.168.0.117:30001/img/上汽大众.png":"69辆", 
-    //     "http://192.168.0.117:30001/img/上汽红岩.png":"11辆", "http://192.168.0.117:30001/img/上汽赛可.png":"36辆", 
-    //     "http://192.168.0.117:30001/img/上汽通用.png":"16辆", "http://192.168.0.117:30001/img/上汽通用车.png":"73辆", 
-    //     "http://192.168.0.117:30001/img/深兰.png":"51辆", "http://192.168.0.117:30001/img/通用中国.png":"56辆", 
-    //     "http://192.168.0.117:30001/img/图森未来.png":"33辆", "http://192.168.0.117:30001/img/蔚来.png":"67辆", 
-    //     "http://192.168.0.117:30001/img/仙途智能.png":"19辆", "http://192.168.0.117:30001/img/小马智行.png":"46辆", 
-    //     "http://192.168.0.117:30001/img/依行科技.png":"30辆", "http://192.168.0.117:30001/img/中车.png":"71辆", 
-    //     "http://192.168.0.117:30001/img/中智行.png":"21辆"};
-        
-    let  测试牌照分布data = await getTestLicense();
     ret["api5"] = getKeyValueNumberOutData("测试牌照分布", 测试牌照分布data);
 
     let 路侧监控视频data = {"src":"http://10.51.50.53:8278/live/13060200882000000001@31011402601318800184@34020000001320000001.m3u8?vhost=bduv0utmss4c3nzidjn.a.e-web.com.cn", "type": 'application/x-mpegURL'};

src/config/serverConfig.ts

@@ -4,8 +4,8 @@ import { BizError, SysError } from "../util/bizError";
 import { analysisXml } from "../util/myXML";
 import { SYSTEMERRORENUM } from "./errorEnum";
 
-export let port = Number(process.env.PORT) || Number(process.argv[3]) || 30003;
-export let sockentPort;
+export let port;
+export let socketPort;
 
 export let dbConfig;
 export let appConfig = {
@@ -25,9 +25,9 @@ export async function initConfig() {
         let configInfo:any = await analysisXml(configStr);
 		if (!configInfo || !configInfo.config) console.log("xml中无配置加载");
 		else {
-			let {port, sockentPort, rightView, leftView, mapView} = configInfo.config;
-            if ( !getConf(port)) throw new SysError(SYSTEMERRORENUM.初始化配置失败, 'serverConfig.xml中 缺少 port');
-            if ( !getConf(sockentPort)) throw new SysError(SYSTEMERRORENUM.初始化配置失败, 'serverConfig.xml中 缺少 sockentPort');
+			let {portConfig, socketPortConfig, rightView, leftView, mapView} = configInfo.config;
+            if ( !getConf(portConfig)) throw new SysError(SYSTEMERRORENUM.初始化配置失败, 'serverConfig.xml中 缺少 port');
+            if ( !getConf(socketPortConfig)) throw new SysError(SYSTEMERRORENUM.初始化配置失败, 'serverConfig.xml中 缺少 sockentPort');
             if ( !getConf(rightView)) throw new SysError(SYSTEMERRORENUM.初始化配置失败, 'serverConfig.xml中 缺少 rightView');
             if ( !getConf(leftView) || !getConf(leftView[0].cloudResource) || !getConf(leftView[0].physicalResource)  ) {
                 throw new SysError(SYSTEMERRORENUM.初始化配置失败, 'serverConfig.xml中 缺少 leftView 或 physicalResource || cloudResource');
@@ -36,6 +36,8 @@ export async function initConfig() {
                 throw new SysError(SYSTEMERRORENUM.初始化配置失败, 'serverConfig.xml中 缺少 mapView 或 online || broken || token');
             }
 
+            port = portConfig[0];
+            socketPort = socketPortConfig[0];
             //左屏
             appConfig.cloudResource = leftView[0].cloudResource[0];
             appConfig.physicalResource = leftView[0].physicalResource[0];

src/data/interface/interfaceService.ts

@@ -5,11 +5,9 @@ import { BizError, SysError } from "../../util/bizError";
 import { get } from "../../util/request";
 // {key:"2021.01", count:"31km", autoCount:"45km"}, {key:"2021.02", count:"42km", autoCount:"75km"}, {key:"2020.02", count:"42km", autoCount:"75km"}, {key:"2022.08", count:"42km", autoCount:"75km"}
 let 月里程数据:any = [];//20个月的数据 格式 [{key:"日期 格式是 2021.01", count:"测试里程", autoCount:"功能测试里程"}]
+let monthsLastData = {count:0, autoCount:0};
 let 企业日里程数据 = {}; //缓存截至这个月1日前的数据 格式  {"企业名称":{count:"测试里程", autoCount:"功能测试里程"} }
-let 总测试时长;
-let 企业时长数据;
-let 月时长数据;
-let lastMonths = "";
+let lastMonths = "";//当前月份
 
 //月度测试数据库源数据接口
 export async function getTestAnalysis() {
@@ -65,9 +63,10 @@ export async function getTestAnalysis() {
 }
 
 //测试牌照分布
-export async function getTestLicense() {
+async function getTestLicense() {
     let 测试牌照分布 = [];
     let 测试牌照分布data = {};
+
     let requestParam = { index:18 };
     let result:any = await get(appConfig.rightView, requestParam);
     if (result && result.success && result.result[0] && result.result[0].result ) {
@@ -76,13 +75,20 @@ export async function getTestLicense() {
         throw new SysError(SYSTEMERRORENUM.获取第三方接口数据失败, appConfig.rightView, JSON.stringify(requestParam));
     }
 
+    let 测试牌照数 = 0;
+
     测试牌照分布.forEach( item => {
         let {enterprise, cnt} = item;
         let imgItem = `http://192.168.0.117:30001/img/${enterprise}.png`;
         测试牌照分布data[imgItem] = cnt;
+        测试牌照数 += cnt;
     })
 
-    return 测试牌照分布data;
+
+    let 测试企业数 = 测试牌照分布.length;
+    
+
+    return {测试牌照分布data, 测试牌照数, 测试企业数};
 }
 
 //企业脱离自动驾驶比率
@@ -91,235 +97,159 @@ export async function getTestLicense() {
  * disengagement 脱离次数
  */
 export async function getDetachmentRatio() {
-    let 企业脱离自动驾驶比率data = [];
     let requestParam = { st:moment().format("YYMM") + "01", et:moment().format("YYMMDD"), index:14};
     let result:any = await get(appConfig.rightView, requestParam);
     let list = [];
-    if (result && result.success) {
+    if (result && result.success && result.result) {
         list = result.result;
     } else {
         throw new SysError(SYSTEMERRORENUM.获取第三方接口数据失败, appConfig.rightView, JSON.stringify(requestParam) );
     }
 
-    let disengagementInfo = [];
-    let autoMileageInfo = [];
+    let disengagementData = list[0].result || [];//次数数据
+    let autoMilegaeData = list[1].result || [];//里程数据
 
-    let disengagementData = list[0].result;
-    let autoMilegaeData = list[1].result;
-    disengagementData.forEach( disengagementItem => {
-        let {enterprise, vin, disengagement} = disengagementItem;
-        if (!disengagementInfo[enterprise]) disengagementInfo[enterprise] = {count: 0};
-        disengagementInfo[enterprise].count += disengagement;
+    let distinctMap = {};
+
+    disengagementData.forEach(info => {
+        let {enterprise, vin, disengagement} = info;
+        if (!distinctMap[enterprise]) distinctMap[enterprise] = { enterprise, disengagement:0, autoMileage:0 };
+        distinctMap[enterprise].disengagement += disengagement;
     });
 
-    autoMilegaeData.forEach( autoMilegaeItem => {
-        let {enterprise, vin, autoMileage} = autoMilegaeItem;
-        if (!autoMileageInfo[enterprise]) autoMileageInfo[enterprise] = {autoMileageCount: 0};
-        autoMileageInfo[enterprise].autoMileageCount += autoMileage;
+    autoMilegaeData.forEach(info => {
+        let {enterprise, vin, autoMileage} = info;
+        if (!distinctMap[enterprise]) distinctMap[enterprise] = { enterprise, disengagement:0, autoMileage:0 };
+        distinctMap[enterprise].autoMileage += autoMileage;
     });
 
-    let 企业脱离自动驾驶比率;
-    for (let key in disengagementInfo) {
-        let {count} = disengagementInfo[key];
-        企业脱离自动驾驶比率 = {"企业名称":key, "次数":count, "里程":0}
-        企业脱离自动驾驶比率data.push(企业脱离自动驾驶比率);
-    }
+    let 返回结果 = [];
 
-    企业脱离自动驾驶比率data.forEach( enterprise => {
-        let {企业名称, 次数, 里程} = enterprise;
-        for (let key in autoMileageInfo) {
-            let {autoMileageCount} = autoMileageInfo[key];
-            if (企业名称 == key) {
-                enterprise.里程 = autoMileageCount;
+    for (let key in distinctMap) {
+        let { enterprise, disengagement, autoMileage} = distinctMap[key];
+        返回结果.push({"企业名称":enterprise, "里程":autoMileage, "次数":disengagement });
     }
-        }
-        
-        // 企业脱离自动驾驶比率data.push(企业脱离自动驾驶比率);
-    })
 
-    return 企业脱离自动驾驶比率data;
+    return 返回结果;
 }
 
 //初始化测试时长分布
 export async function getTestDurationDistribution() {
-    let index = 19;
-    let et = "";
-    let 时长数据:any = await get(appConfig.rightView, {index, et});
-    if (时长数据 && 时长数据.success) {
-        总测试时长 = 时长数据.result[0].result; //[{durationTotal: 测试时长, autoDurationTotal:测试总时长}]
-        企业时长数据 = 时长数据.result[1].result; //[{durationTotal: 测试时长, autoDurationTotal:测试总时长, time: 日期, enterprise: 企业}]
-        月时长数据 = 时长数据.result[2].result; //[{durationTotal: 测试时长, autoDurationTotal:测试总时长, time: 日期}]
+    let requestParam = {index:19, et:moment().format("YYMMDD")};
+    let result:any = await get(appConfig.rightView, requestParam);
+    let 企业时长数据 = [];
+    let 月时长数据 = [];
+    let 总测试时长:any = {};
+    if (result && result.success && result.result) {
+        月时长数据 = result.result[2].result;
+        企业时长数据 = result.result[1].result;
+        总测试时长 = result.result[0].result[0]
     } else {
-        //报错
-        console.log();
-        企业时长数据 = [];
-        月时长数据 = [];
+        throw new SysError(SYSTEMERRORENUM.获取第三方接口数据失败, appConfig.rightView , requestParam);
     }
    
-    return {企业时长数据, 月时长数据};
+    return {企业时长数据, 月时长数据, 总测试时长};
 }
 
-//测试概况基础数据
-export async function getCsgkBasicData() {
-    await getTestDurationDistribution();
-    let 测试企业数 = 0;
-    let 企业牌照数 = 0;
+
+export async function getCsgkData() {
+    let {总测试时长} = await getTestDurationDistribution();
+    let {测试牌照分布data, 测试牌照数, 测试企业数} = await getTestLicense();
+
     let 测试总里程 = 0;
-    let 测试总时长 = 0;
     let 功能测试总里程 = 0;
-    let 功能测试总时长 = 0;
-    
-    let index = 18;
-    let 测试牌照分布result:any = await get(appConfig.rightView, {index});
-    let 测试牌照分布;
-    if (测试牌照分布result && 测试牌照分布result.success) {
-        测试牌照分布 = 测试牌照分布result.result[0].result;
+    for (let key in 企业日里程数据) {
+        测试总里程 += 企业日里程数据[key].count;
+        功能测试总里程 += 企业日里程数据[key].autoCount;
     }
-    测试牌照分布.forEach(item => {
-        企业牌照数 += item.cnt;
-    })
     
-    总测试时长.forEach( item => {
-        测试总时长 = item.durationTotal;
-        功能测试总时长 = parseInt(item.autoDurationTotal);
-    })
+    let startTime = moment().format("YYMM") + "01";
+    let endTime = moment().format('YYMMDD');
+    let nowDate = moment().format('DD');
+    let lastDate = moment().subtract(1, 'days').format('DD');
 
-    let 企业日里程result:any = await get(appConfig.rightView, {st:"", et:"", index:1});
-    let 企业日里程;
-    if (企业日里程result && 企业日里程result.success) {
-        企业日里程 = 企业日里程result.result[0].result;
-    }
-    企业日里程.forEach(item => {
-        测试总里程 += parseInt(item.totalMileage);
-    })
+    let 今日数据 = {"在线车辆数": ""}
 
-    let 企业日驾驶里程result:any = await get(appConfig.rightView, {st:"", et:"", index:2});
-    let 企业日驾驶里程;
-    if (企业日驾驶里程result && 企业日驾驶里程result.success) {
-        企业日驾驶里程 = 企业日驾驶里程result.result[0].result;
-    }
-    企业日驾驶里程.forEach(item => {
-        功能测试总里程 += parseInt(item.autoMileage);
-    })
+    let 今日测试 = { "里程": 0, "时长": ""};
 
-    let 测试概况data = {
-        "测试企业数": 测试牌照分布.length + "家",
-        "企业牌照数": 企业牌照数 + "个",
-        "测试总里程": 测试总里程 + "km",
-        "测试总时长": 测试总时长 + "h",
-        "功能测试总里程": 功能测试总里程 + "km",
-        "功能测试总时长": 功能测试总时长 + "h"
-    };
-
-    return 测试概况data;
-}
+    let 今日功能测试 = { "里程": 0, "时长": ""}
+    if (nowDate == '01') {
+        //一号拿昨日数据跨月份
+        今日测试.里程 = monthsLastData.count;
+        今日功能测试.里程 = monthsLastData.autoCount;
+    }
 
-//测试概况今日数据
-export async function getCsgkDayData() {
-    let 今日数据;
-    let 今日测试;
-    let 今日功能测试;
-    await getTestDurationDistribution();
-    let whereTime = moment().format("DD");
-    let st = moment().format("YYMM") + "01";
-    let et = moment().format("YYMMDD");
-    let 今日测试里程list = await getInterfaceData("", "", 1);
-    if(!今日测试里程list) throw new BizError(ERRORENUM.未找到数据, "今日测试里程");
-    let 测试里程 = 0;
-    今日测试里程list.forEach(info => {
-        let {timeDay, enterprise, totalMileage} = info;
-        if (timeDay == whereTime) {
-            测试里程 += parseInt(totalMileage);
+    let testList = await getInterfaceData(startTime, endTime, 1);
+    if(!testList) throw new BizError(ERRORENUM.未找到数据, "月度测试里程");
+    testList.forEach( info => {
+        let { timeDay, totalMileage } = info;
+        let intTotalMileage = parseInt(totalMileage);
+        测试总里程 += intTotalMileage;
+        if (nowDate != '01' && timeDay == lastDate) {
+            今日测试.里程 = intTotalMileage;
         }
     });
 
-    let 今日功能测试里程list = await getInterfaceData("", "", 2);
-    if(!今日功能测试里程list) throw new BizError(ERRORENUM.未找到数据, "今日功能测试里程");
-    let 功能测试里程 = 0;
-    今日功能测试里程list.forEach(info => {
-        let {timeDay, enterprise, autoMileage} = info;
-        if (timeDay == whereTime) {
-            功能测试里程 += parseInt(autoMileage);
+    let functionList = await getInterfaceData(startTime, endTime, 2);
+    if(!functionList) throw new BizError(ERRORENUM.未找到数据, "月度功能测试里程");
+    functionList.forEach( info => {
+        let { timeDay, autoMileage } = info;
+        let intAutoMileage = parseInt(autoMileage);
+        功能测试总里程 += intAutoMileage;
+
+        if (nowDate != '01' && timeDay == lastDate) {
+            今日功能测试.里程 = intAutoMileage;
         }
     });
-    今日数据 = {
-        "在线车辆数": ""
-    }
 
-    今日测试 = {
-        "里程": 测试里程,
-        "时长": ""
-    }
+    let result = [
+        {key:"测试企业数", value: 测试企业数 + "家"},
+        {key:"企业牌照数", value: 测试牌照数 + "个"},
+        {key:"测试总里程", value: 测试总里程 + "km"},
+        {key:"测试总时长", value: Math.ceil(总测试时长.durationTotal )+ "h"},
+        {key:"功能测试总里程", value: 功能测试总里程 + "km"},
+        {key:"功能测试总时长", value: Math.ceil(总测试时长.autoDurationTotal) + "h"}
+    ];
 
-    今日功能测试 = {
-        "里程": 功能测试里程,
-        "时长": ""
-    }
-    return {今日数据, 今日测试, 今日功能测试};
+    return {测试牌照分布data, result, 今日数据, 今日测试, 今日功能测试};
 }
+//======
 
 //月度测试时长分布
 export async function getTestTotalTime() {
     let {企业时长数据, 月时长数据} = await getTestDurationDistribution();
-    let 月度测试时长data;
-    let 企业测试时长data;
 
-    let testTime = []; //测试时长
-    let functionTestTime = []; //功能测试时长
+    let 月度测试时长测试数据 = [];
+    let 月度测试时长功能测试数据 = [];
     
-    let testTimeEnterprise = []; //企业测试时长
-    let functionTestTimeEnterprise = []; //企业功能测试时长
+    月时长数据.sort((a, b) => { return parseInt(b.time) - parseInt(a.time) });
 
-    let months = moment().format('YYYY.MM');
-    let times = moment().format("YYMM");
-    let testCount = 0;
-    let functionCount = 0;
-    月时长数据.forEach(info => {
-        let {time, durationTotal, autoDurationTotal} = info;
-        if(time == times) {
-            testCount += parseInt(durationTotal);
-            functionCount += parseInt(autoDurationTotal);
+    for (let i = 0; i < 21; i++) {
+        let {durationTotal, autoDurationTotal, time} = 月时长数据[i];
+        月度测试时长测试数据.push({key:time, value:durationTotal});
+        月度测试时长功能测试数据.push({key:time, value:autoDurationTotal});
     }
-    });
 
-    testTime.push({key:months, value:testCount});
-    functionTestTime.push({key:months, value:functionCount});
-    
-    let {newDateArr, whereDateArr} = getPreMonthDay(20);
-    for (let i = 0; i < newDateArr.length; i++) {
-        let months = whereDateArr[i];
-        let newTime = newDateArr[i];
-        月时长数据.forEach(item => {
-            let {time, durationTotal, autoDurationTotal} = item;
-            if (months == time) {
-                testTime.push({key:newTime, value:durationTotal});
-                functionTestTime.push({key:newTime, value:autoDurationTotal});
-            }
-        })
-    }
-
-    let testEnterpriseCount = 0;
-    let functionTestEnterpriseCount = 0;
-    let addTest = {};
-    let addFunction = {};
+    let countMap = {};
     企业时长数据.forEach(info => {
-        let {time, durationTotal, autoDurationTotal, enterprise} = info;
-        testEnterpriseCount += parseInt(durationTotal);
-        addTest[enterprise] = testEnterpriseCount;
-        functionTestEnterpriseCount += parseInt(autoDurationTotal);
-        addFunction[enterprise] = functionTestEnterpriseCount;
-    })
+        let {autoDurationTotal, durationTotal, enterprise} = info;
+        if ( !countMap[enterprise] ) countMap[enterprise] = {durationTotal:0, autoDurationTotal:0};
+        countMap[enterprise].autoDurationTotal += autoDurationTotal;
+        countMap[enterprise].durationTotal += durationTotal;
+    });
 
-    for(let key in addTest) {
-        testTimeEnterprise.push({key, value: addTest[key]});
-    }
+    let 企业测试时长测试数据 = []; 
+    let 企业测试时长功能测试数据 = []; 
     
-    for(let key in addFunction) {
-        functionTestTimeEnterprise.push({key, value: addFunction[key]});
+    for (let enterprise in countMap) {
+        let {autoDurationTotal, durationTotal} = countMap[enterprise]
+        企业测试时长测试数据.push({key:enterprise, value:durationTotal});
+        企业测试时长功能测试数据.push({key:enterprise, value:autoDurationTotal});
     }
 
-    月度测试时长data = {testTime, functionTestTime};
-    企业测试时长data = {testTimeEnterprise, functionTestTimeEnterprise};
+    let 月度测试时长data = {testTime:月度测试时长测试数据, functionTestTime:月度测试时长功能测试数据};
+    let 企业测试时长data = {testTimeEnterprise:企业测试时长测试数据, functionTestTimeEnterprise:企业测试时长功能测试数据};
+
     
     return {月度测试时长data, 企业测试时长data};
 }
@@ -333,7 +263,9 @@ export async function initData() {
         if (months != lastMonths) {
             let key = moment(months).format('YYYY.MM');
             let startTime = moment(lastMonths).format('YYMM') + '01';
-            let endTime = moment(months).format('YYMM') + '01';
+            let endTime = moment(lastMonths).endOf('month').format('YYMMDD');
+            let lastDay = moment(lastMonths).endOf('month').format('DD');
+            monthsLastData = {count:0, autoCount:0};
             //更新缓存
             let list = await getInterfaceData(startTime, endTime, 1);
             if(!list) throw new BizError(ERRORENUM.未找到数据, "月度测试里程缓存数据");
@@ -341,10 +273,15 @@ export async function initData() {
             let count = 0;
             list.forEach(info => {
                 let {timeDay, enterprise, totalMileage} = info;
-                count += parseInt(totalMileage);
+                let intTotalMileage = parseInt(totalMileage);
+                count += intTotalMileage;
     
                 if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
-                企业日里程数据[enterprise].count += parseInt(totalMileage);
+                企业日里程数据[enterprise].count += intTotalMileage;
+
+                if (timeDay == lastDay) {
+                    monthsLastData.count += intTotalMileage;
+                }
             });
             
     
@@ -354,10 +291,15 @@ export async function initData() {
             let testCount = 0;
             testList.forEach(info => {
                 let {timeDay, enterprise, autoMileage} = info;
-                testCount += parseInt(autoMileage);
+                let intAutoMileage = parseInt(autoMileage);
+                testCount += intAutoMileage
     
                 if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
-                企业日里程数据[enterprise].autoCount += parseInt(autoMileage);
+                企业日里程数据[enterprise].autoCount += intAutoMileage;
+
+                if (timeDay == lastDay) {
+                    monthsLastData.autoCount += intAutoMileage;
+                }
             });
             let addItem = {count, autoCount:testCount, key};
             月里程数据.push(addItem );
@@ -376,18 +318,28 @@ async function historyData() {
         let st = moment().subtract(i, 'months').format('YYMM') + '01';
         let key = moment().subtract(i, 'months').format('YYYY.MM');
         let et = moment().subtract(i, 'months').endOf('month').format('YYMMDD');
+        let lastDay = moment().subtract(i, 'months').endOf('month').format('DD');
+
+        if (i == 20) {
+            lastEt = moment().subtract(i+1, 'months').endOf('month').format('YYMMDD');
+        }
 
-        if (i == 21) lastEt = moment().subtract(i+1, 'months').endOf('month').format('YYMMDD');
 
         let list = await getInterfaceData(st, et, 1);
 
         let count = 0;
         list.forEach(info => {
             let {timeDay, enterprise, totalMileage} = info;
-            count += parseInt(totalMileage);
+            let intTotalMileage = parseInt(totalMileage);
+            count += intTotalMileage
 
             if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
-            企业日里程数据[enterprise].count += parseInt(totalMileage);
+
+            企业日里程数据[enterprise].count += intTotalMileage;
+
+            if (timeDay == lastDay) {
+                monthsLastData.count += intTotalMileage;
+            }
         });
         
 
@@ -396,10 +348,15 @@ async function historyData() {
         let testCount = 0;
         testList.forEach(info => {
             let {timeDay, enterprise, autoMileage} = info;
-            testCount += parseInt(autoMileage);
+            let intAutoMileage = parseInt(autoMileage);
+            testCount += intAutoMileage;
 
             if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
-            企业日里程数据[enterprise].autoCount += parseInt(autoMileage);
+            企业日里程数据[enterprise].autoCount +=intAutoMileage;
+
+            if (timeDay == lastDay) {
+                monthsLastData.autoCount += intAutoMileage;
+            }
 
         });
         月里程数据.push( {count, autoCount:testCount, key} );

src/data/interface/wsData.ts

 import * as WebSocket from "ws"
-
-//在线车辆
-let vehicleList:any = [];
+import { sendMsg } from "../../biz/jgfwnl/wsData";
 
 //连接锁
 let lockReconnect = false;
@@ -97,19 +95,18 @@ export async function initWSData() {
     await createSocket();
 }
 
+//在线车辆
+let distinctMap = {};//{id:1}
+
 export function stats(data) {
-    let count = 0;
-    vehicleList.push(data);
-    //记录车辆
-    let map = new Map();
-    for(let item of vehicleList) {
-        if (!map.has(item.vehicleid)) {
-            map.set(item.vehicleid, item);
-            count++;
-        }
-    }
-    // let vehicleQueue = [...map.values()];
-    return count;
+    let {vehicleid, latitude, longitude} = data;
+    distinctMap[vehicleid] = 1;
+
+    sendMsg({lng:longitude, lat:latitude, vehicleid});
+}
+
+export function getOnlieCarCount() {
+    return Object.keys(distinctMap).length;
 }
 
 /*  data 数据长这样

src/main.ts

 
 import { initSocketServer } from "./biz/jgfwnl/wsData";
-import { initConfig, port, sockentPort } from "./config/serverConfig";
+import { initConfig, port, socketPort } from "./config/serverConfig";
 import { initData } from "./data/interface/interfaceService";
 import { httpServer } from "./net/http_server";
 
 async function lanuch() {
     await initConfig();//初始化配置解析
     httpServer.createServer(port);
-    await initSocketServer(sockentPort);
+    await initSocketServer(socketPort);
     await initData();
     console.log('This indicates that the server is started successfully.');
 }

src/util/bizError.ts

@@ -30,7 +30,8 @@ export class SysError extends Error {
                 reqErrorMsg = msg;
                 logErrorMsg = msg;
             } else {
-                logErrorMsg += ` | ${msgs[i]} `;
+                if (typeof msgs[i] == 'object') logErrorMsg += ` | ${JSON.stringify(msgs[i])} `;
+                else logErrorMsg += ` | ${msgs[i]} `;
             }
         }