Skip to content

M
motorCity
Commit 50b2c849 by lixinming
Options

no message

parent 9aede30e
Showing with 1279 additions and 872 deletions
.gitignore
......@@ -6,4 +6,5 @@
/logs
/video
*test*
*.log
\ No newline at end of file
*.log
dist/嘉定汽车城用户手册.docx
package-lock.json
{
"name": "gameserver",
"name": "screen",
"version": "1.0.0",
"lockfileVersion": 1,
"requires": true,
......@@ -253,6 +253,15 @@
"resolved": "https://registry.npm.taobao.org/bytes/download/bytes-3.0.0.tgz",
"integrity": "sha1-0ygVQE1olpn4Wk6k+odV3ROpYEg="
},
"call-bind": {
"version": "1.0.2",
"resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz",
"integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==",
"requires": {
"function-bind": "^1.1.1",
"get-intrinsic": "^1.0.2"
}
},
"caseless": {
"version": "0.12.0",
"resolved": "https://registry.npm.taobao.org/caseless/download/caseless-0.12.0.tgz",
......@@ -589,6 +598,21 @@
"universalify": "^0.1.0"
}
},
"function-bind": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
"integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A=="
},
"get-intrinsic": {
"version": "1.1.3",
"resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.3.tgz",
"integrity": "sha512-QJVz1Tj7MS099PevUG5jvnt9tSkXN8K14dxQlikJuPt4uD9hHAHjLyLBiLR5zELelBdD9QNRAXZzsJx0WaDL9A==",
"requires": {
"function-bind": "^1.1.1",
"has": "^1.0.3",
"has-symbols": "^1.0.3"
}
},
"getpass": {
"version": "0.1.7",
"resolved": "https://registry.npm.taobao.org/getpass/download/getpass-0.1.7.tgz",
......@@ -616,6 +640,19 @@
"har-schema": "^2.0.0"
}
},
"has": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
"integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
"requires": {
"function-bind": "^1.1.1"
}
},
"has-symbols": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
"integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A=="
},
"http-errors": {
"version": "1.7.2",
"resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.7.2.tgz",
......@@ -976,6 +1013,11 @@
"resolved": "https://registry.npm.taobao.org/oauth-sign/download/oauth-sign-0.9.0.tgz",
"integrity": "sha1-R6ewFrqmi1+g7PPe4IqFxnmsZFU="
},
"object-inspect": {
"version": "1.12.2",
"resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.2.tgz",
"integrity": "sha512-z+cPxW0QGUp0mcqcsgQyLVRDoXFQbXOwBaqyF7VIgI4TWNQsDHrBpUQslRmIfAoYWdYzs6UlKJtB2XJpTaNSpQ=="
},
"on-finished": {
"version": "2.3.0",
"resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz",
......@@ -1047,9 +1089,12 @@
"integrity": "sha1-tYsBCsQMIsVldhbI0sLALHv0eew="
},
"qs": {
"version": "6.5.2",
"resolved": "https://registry.npm.taobao.org/qs/download/qs-6.5.2.tgz",
"integrity": "sha1-yzroBuh0BERYTvFUzo7pjUA/PjY="
"version": "6.11.0",
"resolved": "https://registry.npmjs.org/qs/-/qs-6.11.0.tgz",
"integrity": "sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==",
"requires": {
"side-channel": "^1.0.4"
}
},
"range-parser": {
"version": "1.2.1",
......@@ -1123,6 +1168,13 @@
"tough-cookie": "~2.5.0",
"tunnel-agent": "^0.6.0",
"uuid": "^3.3.2"
},
"dependencies": {
"qs": {
"version": "6.5.3",
"resolved": "https://registry.npmjs.org/qs/-/qs-6.5.3.tgz",
"integrity": "sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA=="
}
}
},
"require_optional": {
......@@ -1216,6 +1268,16 @@
"resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.1.tgz",
"integrity": "sha512-JvdAWfbXeIGaZ9cILp38HntZSFSo3mWg6xGcJJsd+d4aRMOqauag1C63dJfDw7OaMYwEbHMOxEZ1lqVRYP2OAw=="
},
"side-channel": {
"version": "1.0.4",
"resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz",
"integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==",
"requires": {
"call-bind": "^1.0.0",
"get-intrinsic": "^1.0.2",
"object-inspect": "^1.9.0"
}
},
"sift": {
"version": "7.0.1",
"resolved": "https://registry.npm.taobao.org/sift/download/sift-7.0.1.tgz",
......
package.json
......@@ -19,6 +19,7 @@
"mysql": "^2.18.1",
"node-xlsx": "^0.16.1",
"nodemailer": "^6.1.1",
"qs": "^6.11.0",
"request": "^2.88.0",
"svg-captcha": "^1.3.12",
"ws": "^5.2.2",
......@@ -32,13 +33,13 @@
"license": "ISC",
"bin": "./out/main.js",
"pkg": {
"scripts":"out/**/*.js",
"assets": [
"public/**/*",
"res/**/*",
"images/**/*",
"video/**/*"
],
"outputPath": "dist"
"scripts": "out/**/*.js",
"assets": [
"public/**/*",
"res/**/*",
"images/**/*",
"video/**/*"
],
"outputPath": "dist"
}
}
serverConfig.xml
<config>
<port>30001</port>
<socketPort>30002</socketPort>
<rightView>http://10.51.50.136:8090/sql/execute</rightView>
<controlSocketPort>30003</controlSocketPort>
<!-- <port>30004</port>
<socketPort>30005</socketPort>
<controlSocketPort>30006</controlSocketPort> -->
<dataCenterInterface>
<!-- 测试企业及车辆数量 -->
<enterpriseVehicleAmount>http://10.51.50.203:8000/icv-openapi/v1/static/enterpriseVehicleAmount</enterpriseVehicleAmount>
<!-- 总实时测试概况接口 -->
<testStatusTotal>http://10.51.50.203:8000/icv-openapi/v1/realtime/statistics/testStatusTotal</testStatusTotal>
<!-- 今日实时测试概况接口 -->
<todayTestStatusTotal>http://10.51.50.203:8000/icv-openapi/v1/realtime/statistics/todayTestStatusTotal</todayTestStatusTotal>
<!-- 企业历史里程及时长统计信息接口-->
<enterpriseTestStatus>http://10.51.50.203:8000/icv-openapi/v1/history/statistics/enterpriseTestStatus</enterpriseTestStatus>
<!-- 月度历史里程及时长统计信息接口 -->
<monthlyTestStatus>http://10.51.50.203:8000/icv-openapi/v1/history/statistics/monthlyTestStatus</monthlyTestStatus>
<!-- 企业历史脱离率统计接口 -->
<enterpriseExitRate>http://10.51.50.203:8000/icv-openapi/v1/history/statistics/enterpriseExitRate</enterpriseExitRate>
<!-- 获取小车详情 -->
<vehicleInfo>http://10.51.50.203:8000/icv-openapi/v1/vehicle/info</vehicleInfo>
<!-- 小车历史测试信息 -->
<testHistory>http://10.51.50.203:8000/icv-openapi/v1/vehicle/testHistory</testHistory>
<!-- 违规信息 -->
<vehicleAlert>http://10.51.50.203:8000/icv-openapi/v1/vehicle/alert</vehicleAlert>
<!-- 车辆监控视频 -->
<videoPlay>http://10.51.50.203:8000/icv-openapi/v1/video/play</videoPlay>
</dataCenterInterface>
<leftView>
<!-- 云资源数据 -->
<cloudResource>http://10.51.50.140:8080/api/static/PrivateCloudUsageStatics</cloudResource>
<!-- 物理资源数据 -->
<physicalResource>http://10.51.50.140:8080/api/v1/PrivateCloudCurrentUsages</physicalResource>
<!-- <cloudResource>http://192.168.0.27:8080/api/static/PrivateCloudUsageStatics</cloudResource>
<physicalResource>http://192.168.0.27:8080/api/v1/PrivateCloudCurrentUsages</physicalResource> -->
</leftView>
<!-- 地图中间数据 -->
<mapView>
<mapPort>http://10.51.48.213/nlink/v2/getAllDevicesInfo?prjid=0255e1f7515348cc87c7bb2cc6341fer</mapPort>
<online>3</online>
<broken>3</broken>
<token>09a98bc555474e058ef90b6cc6e23638</token>
</mapView>
<imagePath>192.168.0.47</imagePath>
<!-- 图片地址 这里填本机地址 -->
<imagePath>192.168.0.105</imagePath>
<!-- 地图中心点 -->
<mapCenter>
<lng>121.183574</lng>
<lat>31.291126</lat>
</mapCenter>
<!-- 地图初始比例 -->
<zoom>14</zoom>
<!-- 路测监控 -->
<surveillanceVideo>http://10.51.50.53:8278/live/13060200882000000001@31011402601318800184@34020000001320000001.m3u8?vhost=bduv0utmss4c3nzidjn.a.e-web.com.cn</surveillanceVideo>
<wsPath>ws://10.51.50.136:8090/ws/v1</wsPath>
<!-- 地图socket数据 -->
<!-- <wsPath>ws://10.51.50.136:8090/ws/v1</wsPath> -->
<wsPath>ws://10.51.50.203:8000/icv-openapi/v1/locWebSocket</wsPath>
</config>
src/biz/control.ts 0 → 100644
import { controlGetOnlieCarList } from "../data/interface/wsData";
import { Socket } from "../net/socket_server";
import { logError } from "../util/log";
let qs = require('qs');
let viewPool = {};//展示端连接池
let controlWs;
//广播消息
export function broadcastMsg(data) {
for (let userId in viewPool) {
viewPool[userId].send(JSON.stringify(data));
console.log(data);
}
}
function analysisUserUrl(req) {
let ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress || req.socket.remoteAddress || req.connection.socket.remoteAddress;
return ip;
}
export async function initControlSocketServer(port) {
Socket.createServer(port, function (wss) {
wss.on('connection', function(ws, req) {
let ip = analysisUserUrl(req);
if (req.url.indexOf('connect') == -1 ) {
//非连接
console.log("连接错误", req.url);
return;
}
let paramater = qs.parse(req.url.split('?')[1]);
if (!paramater.role || (paramater.role != "view" && paramater.role != "control") ) {
console.log("连接参数错误");
return;
} else if (paramater.role == "view" && !paramater.pageName) {
console.log("展示端无页面参数");
return;
}
let userId =`${paramater.role}${ip}`;
ws.userId = userId;
ws.userType = paramater.role;
if (paramater.role == "view") {
viewPool[userId] = ws;
console.log(`连接成功至:${paramater.pageName}页面`);
} else {
if (controlWs) console.log("重复连接");
controlWs = ws;
console.log(`控制端已连接:${userId}`);
}
//==============连接成功
ws.on('message', function(msg) {
let {type, pageName, data} = JSON.parse(msg);
if (type == 'heart') { //回应心跳包
ws.send(JSON.stringify({success:true, code:199}));
return;
}
//接收控制端消息 判断控制端还是展示端
if (ws.userType != "control") {
return;
}
//下发消息给展示端
broadcastMsg(data);
});
ws.on('close', function (data){
if ( ws._socket && ws._socket._peername && ws._socket._peername.address ) {
let userId = ws.userId;
if (ws.userType == "control") {
controlWs = null;
} else {
delete viewPool[userId];
}
console.log("close", userId);
}
});
});
});
}
//控制端获取小车列表
export async function controlGetCarList(req, res) {
//todo 最后加鉴权
let carList = controlGetOnlieCarList();
res.send({carList});
}
\ No newline at end of file
src/biz/dsj.ts 0 → 100644
//大事记
import { getListOutData } from "../cal/out";
import { get大事记 } from "../data/analysisExcelData";
export async function getData(req, res) {
let excelData:any = get大事记();
let list = getListOutData("大事记节点",excelData["大事记节点内容"]);
let result = [];
let titleConfig = {
"节点名称":"nodeName",
"标题内容":"title",
"图片名称":"titleImgUrl",
"是否有弹框":"havePop",
"弹框视频/图片内容":"popInfo",
"弹框内容":"popDes",
};
list.valueList.forEach(info => {
let onceNode = {};
info.forEach((item, index) => {
let title = titleConfig[list.titleList[index]];
if (title == "popInfo") {
let splitStrList = splitStr(item);
let {videoList, imgList} = urlSortOut(splitStrList);
onceNode["popVideoUrl"] = videoList;
onceNode["popImgUrl"] = imgList;
return
}
onceNode[title] = item;
});
onceNode["title"] = splitStr(onceNode["title"]);
onceNode["titleImgUrl"] = splitStr(onceNode["titleImgUrl"]);
onceNode["popDes"] = splitDesStr(onceNode["popDes"]);
result.push(onceNode);
});
res.send({"dsjList":result});
}
function splitStr(str) {
let splitList = str.split("\r\n");
return splitList
}
function splitDesStr(str) {
let splitList = str.split("\r\n");
let list = [];
splitList.forEach(info => {
if (info) list.push(info);
});
return list;
}
function urlSortOut(urlList) {
let videoList = [];
let imgList = [];
if (!urlList) return {videoList, imgList}
urlList.forEach(urlStr => {
if (!urlStr) return;
if (urlStr.indexOf(".mp4") >= 0) {
videoList.push(urlStr)
} else {
imgList.push(urlStr)
}
});
return {videoList, imgList}
}
\ No newline at end of file
src/biz/jgfwnl/data.ts
import moment = require("moment");
import { getChartOutData, getKeyValueNumberOutData, getListOutData } from "../../cal/out";
import { separateDataAndUint } from "../../cal/privateTools";
import { appConfig, getImageIp, systemConfig} from "../../config/serverConfig";
import { appConfig, dataCenterInterfaceConfig, getImageIp, systemConfig} from "../../config/serverConfig";
import { getHardware } from "../../data/interface/hardwareData";
import { getCsgkData, getDetachmentRatio, getTestAnalysis, 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";
import { getQycs, getQytlzdjs, getYdcs } from "../../data/newInterface/csfxData";
import { getCspzfb, getJcsj, getJrsj } from "../../data/newInterface/csgkData";
import { getQycs, getQytlzdjs, getYdcs } from "../../data/dataCenterInterface/csfxData";
import { getInterfaceData, getJrsj } from "../../data/dataCenterInterface/csgkData";
import { getInterfaceByInterfaceName } from "../../data/cronJob";
//云资源
export async function getYZY(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("计算云资源使用率", 使用率 );
......@@ -27,23 +24,14 @@ 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 {cspzData, jcsjData} = await getInterfaceData();
let 基础数据Info = [];
resule.forEach((info, index) => {
jcsjData.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`});
......@@ -52,18 +40,16 @@ export async function getCSGK(req, res) {
let 今日数据data = {"在线车辆数":`${getOnlieCarCount()}辆`};
let {今日数据, 今日测试, 今日功能测试} = await getJrsj(); //-----------
let {今日数据, 今日测试, 今日功能测试} = await getJrsj();
ret["api2"] = getKeyValueNumberOutData("今日数据", 今日数据data);
ret["api3"] = getKeyValueNumberOutData("今日测试", 今日测试);
ret["api4"] = getKeyValueNumberOutData("今日功能测试", 今日功能测试);
let 测试牌照分布data = await getCspzfb(); //----------
ret["api5"] = getKeyValueNumberOutData("测试牌照分布", 测试牌照分布data);
ret["api5"] = getKeyValueNumberOutData("测试牌照分布", cspzData);
let 路侧监控视频data = {"src": appConfig.surveillanceVideo, "type": 'application/x-mpegURL'};
ret["api6"] = ({title:"路侧监控视频", dataList: 路侧监控视频data});
csgkQueue = JSON.parse(JSON.stringify(ret));
res.send(ret);
}
......@@ -71,17 +57,10 @@ export async function getCSGK(req, res) {
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(); //----------
let 企业测试自动驾驶比率Info = await getQytlzdjs();
ret["api5"] = getListOutData("企业脱离自动驾驶比率", 企业测试自动驾驶比率Info);
let {月度测试时长数据, 月度测试时长功能数据, 月度测试里程数据, 月度测试里程功能数据} = await getYdcs(); //----------
let {月度测试时长数据, 月度测试时长功能数据, 月度测试里程数据, 月度测试里程功能数据} = await getYdcs();
let 月度测试里程分布data = {测试: {unit:'km', dataInfo: 月度测试里程数据}, 功能测试: {unit:'km', dataInfo: 月度测试里程功能数据}};
ret["api1"] = getChartOutData("月度测试里程分布", 月度测试里程分布data);
......@@ -89,38 +68,70 @@ export async function getCSFX(req, res) {
let 月度测试时长分布data = {测试: {unit:'h', dataInfo: 月度测试时长数据}, 功能测试: {unit:'h', dataInfo: 月度测试时长功能数据}};
ret["api2"] = getChartOutData("月度测试时长分布", 月度测试时长分布data);
let {企业测试时长数据, 企业测试时长功能数据, 企业测试里程数据, 企业测试里程功能数据} = await getQycs(); //----------
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) {
export async function mapData(req, res) {
//地图数据结构
let ret:any = {};
let {计算云资源, 使用率, 物理资源} = await getHardware();
let mapInfoData = await getMap();
let {cameraData, lidarData, millimeterWaveRadarData, RSUData, SIBOXData} = mapInfoData;
let 基础数据data = {
"摄像头":cameraData.length,
"激光雷达":lidarData.length,
"毫米波雷达":millimeterWaveRadarData.length,
"路侧单元":RSUData.length,
"信号灯数据采集器":SIBOXData.length
};
ret["base"] = getKeyValueNumberOutData("基础数据右", 基础数据data );
let roadData = {
"已建道路里程":2002,
"已建路口":102,
};
ret["roadBase"] = getKeyValueNumberOutData("基础数据左", roadData );
// 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["map"] = [
{
name: "camera",
value: cameraData
},
{
name: "lidar",
value: lidarData
},
// },
// {
// name: "waveRadar",
// value: millimeterWaveRadarData
// },
{
name: "RSU",
value: RSUData
},
{
name: "SIBOX",
value: SIBOXData
}
]
ret["api1"] = getKeyValueNumberOutData("计算云资源", 计算云资源 );
ret["api2"] = getKeyValueNumberOutData("计算云资源使用率", 使用率 );
ret["api3"] = getKeyValueNumberOutData("物理资源", 物理资源 );
ret["mapCenter"] = {lng: appConfig.lng, lat: appConfig.lat};
ret["zoom"] = {key: "缩放比例", value: appConfig.zoom};
res.send(ret);
}
//测试概况
let csgkQueue = {};
let csgkQueueTime = "";
/*老的 数据逻辑
export async function getCSGKold(req, res) {
let ret:any = {};
......@@ -157,7 +168,6 @@ export async function getCSGKold(req, res) {
csgkQueue = JSON.parse(JSON.stringify(ret));
res.send(ret);
}
//测试分析
export async function getCSFXold(req, res) {
let ret:any = {};
......@@ -227,51 +237,99 @@ export async function getCSFXold(req, res) {
csfxQueue = JSON.parse(JSON.stringify(ret));
res.send(ret);
}
*/
//小车详情
export async function carInfo(req, res) {
let { carId } = req.body;
export async function mapData(req, res) {
//地图数据结构
if ( !carId) {
//参数错误
}
let carInfo = await getInterfaceByInterfaceName(dataCenterInterfaceConfig.vehicleInfo, {vin:carId});
//获取
let ret:any = {};
let mapInfoData = await getMap();
let {cameraData, lidarData, millimeterWaveRadarData, RSUData, SIBOXData} = mapInfoData;
let 基础数据data = {
"摄像头":cameraData.length,
"激光雷达":lidarData.length,
// "毫米波雷达":millimeterWaveRadarData.length,
"路侧单元":RSUData.length,
"信号灯数据采集器":SIBOXData.length
};
ret["info"] = {
enterprise:carInfo.enterprise,
validityBegin:carInfo.validityBegin,
validityEnd:carInfo.validityEnd,
vehicleNo:carInfo.vehicleNo,//车牌号
vin:carInfo.vin,
vehicleType:carInfo.vehicleType,
type:"自动驾驶",
velocity:"45km/h"
}
ret["base"] = getKeyValueNumberOutData("计算云资源", 基础数据data );
let endTime = moment().format("YYYY-MM-DD hh:mm:ss");
let startTime = moment().subtract(10, 'd').format("YYYY-MM-DD hh:mm:ss");
let testData = await getInterfaceByInterfaceName(dataCenterInterfaceConfig.testHistory, {vin:carId, startTime, endTime});
ret["map"] = [
{
name: "camera",
value: cameraData
},
{
name: "lidar",
value: lidarData
},
// },
// {
// name: "waveRadar",
// value: millimeterWaveRadarData
// },
{
name: "RSU",
value: RSUData
},
{
name: "SIBOX",
value: SIBOXData
}
]
ret["mapCenter"] = {lng: appConfig.lng, lat: appConfig.lat};
let 测试里程 = [];
let 功能测试里程 = [];
ret["zoom"] = {key: "缩放比例", value: appConfig.zoom};
testData.monthlyTestStatusList.forEach(info => {
let { date, testStatistics } = info;
let key = moment(date).format("YYYY.MM");
let { autoDuration, autoMileage, duration, mileage } = testStatistics;
测试里程.push( {key, value: mileage});
功能测试里程.push( { key, value:autoMileage} );
});
let 月度测试时长分布data = {测试里程: {unit:'h', dataInfo: 测试里程}, 功能测试里程: {unit:'h', dataInfo: 功能测试里程}};
ret["lcbhqs"] = getChartOutData("里程变化趋势", 月度测试时长分布data);
//获取小车信息
let alertEndTime = moment().format("YYYY-MM-DD hh:mm:ss");
let alertStartTime = moment().subtract(1, 'd').format("YYYY-MM-DD hh:mm:ss");
let alertData = await getInterfaceByInterfaceName(dataCenterInterfaceConfig.vehicleAlert, {
vin:carId,
startTime:alertStartTime,
endTime:alertEndTime
});
let 车辆违规列表 = [];
alertData.list.forEach((item, index) => {
if (index >= 10) return
let { alertDuration, alertType, positionTime, velocity } = item;
let alertDurationStr = `${alertDuration}S`;
let alertTypeStr = alertType == 1? '违规开启自动驾驶模式' : "手动模式";
车辆违规列表.push([positionTime, alertTypeStr, alertDurationStr, `${velocity}km/h`]);
});
ret["testInfo"] = {
mileage:"422km",
duration:"21h",
allMileage:"1222km",
allDuration:"5666h"
}
ret["clwgqk"] = {
title:"车辆违规情况",
dataList:车辆违规列表
}
ret["csclsp"] = {
title:"测试车辆视频",
dataList: [
{img:"http://1safas.png", video:"http://10.51.50.53:8278/live/13060200882000000001@31011402601318800184@34020000001320000001.m3u8?vhost=bduv0utmss4c3nzidjn.a.e-web.com.cn"},
{img:"http://1sdfsd.png", video:"http://10.51.50.53:8278/live/13060200882000000001@31011402601318800184@34020000001320000001.m3u8?vhost=bduv0utmss4c3nzidjn.a.e-web.com.cn"},
{img:"http://1dsfasdf.png", video:"http://10.51.50.53:8278/live/13060200882000000001@31011402601318800184@34020000001320000001.m3u8?vhost=bduv0utmss4c3nzidjn.a.e-web.com.cn"}
]
}
res.send(ret);
}
//获取小车列表接口
export async function getCarList(req, res) {
let carList = [{}];
res.send({carList});
}
\ No newline at end of file
src/biz/sjpt/data.ts
//-----------已舍弃
//云资源
export async function getYZY(req, res) {
let ret:any = {};
......
src/config/enum.ts
......@@ -2,12 +2,3 @@ export enum INTERFACEREQUESTTYPEENUM {
即时更新 = 1,
定时更新
}
export enum CODEEENUM {
"请求成功" = 200,
"请求未鉴权" = 401,
"请求路径不存在" = 404,
"请求频率过高" = 503
}
src/config/errorEnum.ts
......@@ -4,6 +4,10 @@ export enum ERRORENUM {
export enum SYSTEMERRORENUM {
初始化配置失败 = 1,
获取第三方接口数据失败,
未按接口协议返回,
请求未鉴权 = 401,
请求路径不存在 = 404,
请求频率过高 = 503
}
let bizErrorMsgMap = {};
......@@ -12,8 +16,8 @@ for (let key in ERRORENUM) {
}
let systemErrorMsgMap = {};
for (let key in ERRORENUM) {
systemErrorMsgMap[ERRORENUM[key]] = key;
for (let key in SYSTEMERRORENUM) {
systemErrorMsgMap[SYSTEMERRORENUM[key]] = key;
}
export function getBizMsg(param) {
......
src/config/serverConfig.ts
......@@ -7,11 +7,11 @@ const os = require('os');
export let systemConfig = {
port:9999,
socketPort:''
socketPort:'',
controlSocketPort:''
};
export let appConfig = {
rightView:'',
cloudResource:'',
physicalResource:'',
mapPort:'',
......@@ -21,6 +21,26 @@ export let appConfig = {
zoom: 14,//中心点配置
surveillanceVideo: "",//监控地址
};
//数据中心接口
export let dataCenterInterfaceConfig = {
enterpriseVehicleAmount:"",//测试企业及车辆数量
testStatusTotal:"",//总实时测试概况接口
todayTestStatusTotal:"",//今日实时测试概况接口
enterpriseTestStatus:"",//企业历史里程及时长统计信息接口
monthlyTestStatus:"",//月度历史里程及时长统计信息接口
enterpriseExitRate:"",//企业历史脱离率统计接口
vehicleInfo:"",//汽车详情
testHistory:"",//小车历史测试数据
vehicleAlert:"",//车辆违规信息
videoPlay:"",//小车监控
};
//todo 地图数据
export let mapDataInterfaceConfig = {
};
let serverIp = "";
const ConfigName = "serverConfig.xml";
......@@ -34,15 +54,31 @@ export async function initConfig() {
else {
//必要配置
let integralConfig = [
"port", "socketPort", "rightView", {"leftView":["cloudResource", "physicalResource"] },
"port", "socketPort",
{
"dataCenterInterface":[
"enterpriseVehicleAmount",
"testStatusTotal",
"todayTestStatusTotal",
"enterpriseTestStatus",
"monthlyTestStatus",
"enterpriseExitRate",
"vehicleInfo",
"testHistory",
"vehicleAlert",
"videoPlay"
]}, {"leftView":["cloudResource", "physicalResource"] },
{"mapView":["mapPort", "online","broken", "token" ] }, "imagePath", {"mapCenter":["lng", "lat"]}, "zoom",
"surveillanceVideo", "wsPath"
];
checkConfig(integralConfig, configInfo.config);
let {port, socketPort, rightView, leftView, mapView, imagePath, mapCenter, zoom, surveillanceVideo, wsPath} = configInfo.config;
let {port, socketPort, dataCenterInterface, leftView, mapView, imagePath, mapCenter, zoom, surveillanceVideo, wsPath, controlSocketPort} = configInfo.config;
systemConfig.port = port[0];
systemConfig.socketPort = socketPort[0];
systemConfig.controlSocketPort = controlSocketPort[0];
//左屏
appConfig.cloudResource = leftView[0].cloudResource[0];
......@@ -52,8 +88,18 @@ export async function initConfig() {
let broken = mapView[0].broken[0];
let token = mapView[0].token[0];
appConfig.mapPort = mapView[0].mapPort[0] + "&online=" + online + "&broken=" + broken + "&token=" + token || appConfig.mapPort;
//右屏接口
appConfig.rightView = rightView[0];
//数据中心接口
dataCenterInterfaceConfig.enterpriseVehicleAmount = dataCenterInterface[0].enterpriseVehicleAmount[0];
dataCenterInterfaceConfig.testStatusTotal = dataCenterInterface[0].testStatusTotal[0];
dataCenterInterfaceConfig.todayTestStatusTotal = dataCenterInterface[0].todayTestStatusTotal[0];
dataCenterInterfaceConfig.enterpriseTestStatus = dataCenterInterface[0].enterpriseTestStatus[0];
dataCenterInterfaceConfig.monthlyTestStatus = dataCenterInterface[0].monthlyTestStatus[0];
dataCenterInterfaceConfig.enterpriseExitRate = dataCenterInterface[0].enterpriseExitRate[0];
dataCenterInterfaceConfig.vehicleInfo = dataCenterInterface[0].vehicleInfo[0];
dataCenterInterfaceConfig.testHistory = dataCenterInterface[0].testHistory[0];
dataCenterInterfaceConfig.vehicleAlert = dataCenterInterface[0].vehicleAlert[0];
dataCenterInterfaceConfig.videoPlay = dataCenterInterface[0].videoPlay[0];
//地图中心点
appConfig.lng = mapCenter[0].lng[0];
appConfig.lat = mapCenter[0].lat[0];
......
src/data/analysisExcelData.ts
import { limitEnteNameString, changeDataName } from "../util/tools";
import { planarArrBecomeKeyValueData, planarArrBecomeChartData, planarArrBecomeStringListData, planarArrBecomeListData} from "../cal/excelEnter";
import { getExcelDataBySheetName } from "../util/analysisExcel";
import { limitEnteNameString, changeDataName } from "../util/tools";
import { planarArrBecomeKeyValueData, planarArrBecomeChartData, planarArrBecomeStringListData, planarArrBecomeListData} from "../cal/excelEnter";
import { getExcelDataBySheetName } from "../util/analysisExcel";
export function get监管服务能力_云资源() {
let bolckDataList = getExcelDataBySheetName('安亭汽车城数据模板.xlsx', '监管服务能力_云资源');
......@@ -130,4 +131,27 @@
}
return result;
}
\ No newline at end of file
}
export function get大事记() {
let bolckDataList = getExcelDataBySheetName('大事记节点.xlsx', '大事记');
let result = {};
let forKeyValueList = [];
let forChartList = [];
let forStringList = [];
let forListData = ["大事记节点内容"];
for (let i = 0; i < bolckDataList.length; i++) {
let {blockData, blockTitle} = bolckDataList[i];
let changeName = changeDataName(blockTitle);
if (forKeyValueList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeKeyValueData(blockData);
if (forChartList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeChartData(blockData);
if (forStringList.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeStringListData(blockData);
if (forListData.indexOf(changeName) > -1 ) result[changeName] = planarArrBecomeListData(blockData);
}
return result;
}
\ No newline at end of file
src/data/cronJob.ts
//接口任务 定期更新
import moment = require('moment');
import * as request from 'request';
import { INTERFACEREQUESTTYPEENUM } from "../config/enum";
import { BizError } from "../util/bizError";
import { logError } from '../util/log';
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 accToken = "";//todo token
let thisTime = new Date().valueOf();
export async function getInterfaceByInterfaceName(url, body) {
let {data, code}:any = await get(url, body, {});
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;
switch (code) {
case 401: throw new BizError(`${url} 请求未鉴权`);
case 404: throw new BizError(`${url} 请求路径不存在`);
case 503: throw new BizError(`${url} 请求频率过高`);
}
thisTaskInfo.sort((a, b) => {return a.useTime - b.useTime});//耗时短的优先
if (!data) throw new BizError(`${url} 缺少返回参数 data`);
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 ? "请求地址为空" : "请求地址错误");
......@@ -143,9 +31,7 @@ function get(url:string, query?, headers?, 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});
resolve(data);
})
})
}
......
src/data/dataCenterInterface/csfxData.ts 0 → 100644
import moment = require("moment");
import { SYSTEMERRORENUM } from "../../config/errorEnum";
import { dataCenterInterfaceConfig } from "../../config/serverConfig";
import { SysError } from "../../util/bizError";
import { getInterfaceByInterfaceName } from "../cronJob";
//测试分析
//企业测试
export async function getQycs() {
const interfaceName = "企业历史里程及时长统计信息接口";
let startTime = moment().format("YYYY-MM") + "-01";
let endTime = moment().format('YYYY-MM-DD');
let data = await getInterfaceByInterfaceName( dataCenterInterfaceConfig.enterpriseTestStatus, { startTime, endTime } );
let { enterpriseTestStatusList } = data;
if ( !Array.isArray(enterpriseTestStatusList) ) throw new SysError(SYSTEMERRORENUM.未按接口协议返回, interfaceName, "enterpriseTestStatusList 不是数组", enterpriseTestStatusList);
let 企业测试时长数据 = [];
let 企业测试时长功能数据 = [];
let 企业测试里程数据 = [];
let 企业测试里程功能数据 = [];
enterpriseTestStatusList.forEach( info => {
let { enterpriseName, testStatistics } = info;
if ( !enterpriseName || !testStatistics )
企业测试时长数据.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() {
const interfaceName = "月度历史里程及时长统计信息接口";
let 月度测试时长数据 = [];
let 月度测试时长功能数据 = [];
let 月度测试里程数据 = [];
let 月度测试里程功能数据 = [];
let startTime = moment().subtract(22, 'months').format("YYYY-M");
let endTime = moment().format("YYYY-M");
let 月度历史里程及时长 = await getInterfaceByInterfaceName(dataCenterInterfaceConfig.monthlyTestStatus, { startTime, endTime });
let { monthlyTestStatusList } = 月度历史里程及时长;
if ( !Array.isArray(monthlyTestStatusList) ) throw new SysError(SYSTEMERRORENUM.未按接口协议返回, interfaceName, "monthlyTestStatusList 不是数组", monthlyTestStatusList);
//100个月
let nowTime = new Date( moment().format('YYYY-MM') ).valueOf();
monthlyTestStatusList.forEach( info => {
let { date, testStatistics } = info;
let timeMs = new Date( moment(date).add(21, 'months').format('YYYY-MM') ).valueOf();
if (timeMs < nowTime) return;
月度测试时长数据.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 getInterfaceByInterfaceName(dataCenterInterfaceConfig.enterpriseExitRate, {startTime, endTime});
let { enterpriseExitList } = data;
enterpriseExitList.sort( (a, b) => {
if ( !a.ratio ) a.ratio = Math.ceil((a.exitCount/a.autoMileage)*100/100);
if ( !b.ratio ) b.ratio = Math.ceil((b.exitCount/b.autoMileage)*100/100);
let aRatio = a.ratio;
let bRatio = b.ratio;
return bRatio - aRatio;
});
let 企业名称data = [];
let 次数data = [];
let 里程data = [];
let 比率data = [];
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 企业测试自动驾驶比率;
}
\ No newline at end of file
src/data/dataCenterInterface/csgkData.ts 0 → 100644
import { dataCenterInterfaceConfig } from "../../config/serverConfig";
import { getInterfaceByInterfaceName } from "../cronJob";
//测试概况
export async function getInterfaceData() {
//"测试企业及车辆数量接口";
let enterpriseVehicleAmountData = await getInterfaceByInterfaceName(dataCenterInterfaceConfig.enterpriseVehicleAmount, {});
let {enterpriseVehicleList, totalEnterprise, totalVehicle} = enterpriseVehicleAmountData;
//"总实时测试概况接口"
let testStatusTotalData = await getInterfaceByInterfaceName(dataCenterInterfaceConfig.testStatusTotal, {});
let {autoDuration, autoMileage, duration, mileage} = testStatusTotalData;
let jcsjData = [
{key: "测试企业数", value: totalEnterprise + "家"},
{key: "企业牌照数", value: totalVehicle + "个"},
{key: "测试总里程", value: mileage + "km"},
{key: "测试总时长", value: duration + "h"},
{key: "功能测试总里程", value: autoMileage + "km"},
{key: "功能测试总时长", value: autoDuration + "h"}
];
let cspzData = {};
enterpriseVehicleList.forEach (info => {
let {enterpriseLogo, totalVehicle} = info;
if(enterpriseLogo) cspzData[enterpriseLogo] = totalVehicle + "辆";
})
return {cspzData, jcsjData};
}
//今日数据
export async function getJrsj() {
let data = await getInterfaceByInterfaceName(dataCenterInterfaceConfig.todayTestStatusTotal, {});
let {autoDuration, autoMileage, duration, mileage} = data;
let 今日数据 = {"在线车辆数": ""}
let 今日测试 = { "里程": mileage + 'km', "时长": duration + 'h'};
let 今日功能测试 = { "里程": autoMileage + 'km', "时长": autoDuration + 'h'};
return {今日数据, 今日测试, 今日功能测试};
}
src/data/interface/interfaceService.ts
import moment = require("moment")
import { ERRORENUM, SYSTEMERRORENUM } from "../../config/errorEnum";
import { appConfig, getImageIp, systemConfig } from "../../config/serverConfig";
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 lastMonths = "";//当前月份
//月度测试数据库源数据接口
export async function getTestAnalysis() {
let testMileage = []; //测试里程
let functionTestMileage = []; //功能测试里程
let leng = 月里程数据.length;
for (let i = 1; i <= 20; i++) {
let {key, count, autoCount} = 月里程数据[leng-i];
testMileage.push({key:key, value:count});
functionTestMileage.push({key:key, value:autoCount});
}
// import moment = require("moment")
// import { ERRORENUM, SYSTEMERRORENUM } from "../../config/errorEnum";
// import { appConfig, getImageIp, systemConfig } from "../../config/serverConfig";
// 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 lastMonths = "";//当前月份
// //月度测试数据库源数据接口
// export async function getTestAnalysis() {
// let testMileage = []; //测试里程
// let functionTestMileage = []; //功能测试里程
// let leng = 月里程数据.length;
// for (let i = 1; i <= 20; i++) {
// let {key, count, autoCount} = 月里程数据[leng-i];
// testMileage.push({key:key, value:count});
// functionTestMileage.push({key:key, value:autoCount});
// }
let months = moment().format('YYYY.MM');
let startTime = moment().format("YYMM") + "01";
let endTime = moment().format('YYMMDD');
let 企业月前里程数据 = JSON.parse(JSON.stringify(企业日里程数据));
let testList = await getInterfaceData(startTime, endTime, 1);
if(!testList) throw new BizError(ERRORENUM.未找到数据, "月度测试里程");
let testCount = 0;
testList.forEach(info => {
let {timeDay, enterprise, totalMileage} = info;
if (!企业月前里程数据[enterprise]) 企业月前里程数据[enterprise] = {count:0, autoCount:0};
企业月前里程数据[enterprise].count += totalMileage;
testCount += parseInt(totalMileage);
});
let functionList = await getInterfaceData(startTime, endTime, 2);
if(!functionList) throw new BizError(ERRORENUM.未找到数据, "月度功能测试里程");
let functionCount = 0;
functionList.forEach(info => {
let {timeDay, enterprise, autoMileage} = info;
if (!企业月前里程数据[enterprise]) 企业月前里程数据[enterprise] = {count:0, autoCount:0};
企业月前里程数据[enterprise].count += autoMileage;
functionCount += parseInt(autoMileage);
});
let testMileageEnterprise = [];
let functionTestMileageEnterprise = [];
for(let key in 企业日里程数据) {
let 企业日里程数据data = 企业日里程数据[key];
let {count, autoCount} = 企业日里程数据data;
testMileageEnterprise.push({key, value: count});
functionTestMileageEnterprise.push({key, value: autoCount});
}
testMileage.push({key:months, value:testCount});
functionTestMileage.push({key:months, value:functionCount});
return {testMileage, functionTestMileage, testMileageEnterprise, functionTestMileageEnterprise};
}
//测试牌照分布
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 ) {
测试牌照分布 = result.result[0].result;
} else {
throw new SysError(SYSTEMERRORENUM.获取第三方接口数据失败, appConfig.rightView, JSON.stringify(requestParam));
}
let 测试牌照数 = 0;
测试牌照分布.forEach( item => {
let {enterprise, cnt} = item;
let imgItem = `http://${getImageIp()}:${systemConfig.port}/img/${enterprise}.png`;
let count = parseInt(cnt);
测试牌照分布data[imgItem] = count + "辆";
测试牌照数 += count;
})
let 测试企业数 = 测试牌照分布.length;
// let months = moment().format('YYYY.MM');
// let startTime = moment().format("YYMM") + "01";
// let endTime = moment().format('YYMMDD');
// let 企业月前里程数据 = JSON.parse(JSON.stringify(企业日里程数据));
// let testList = await getInterfaceData(startTime, endTime, 1);
// if(!testList) throw new BizError(ERRORENUM.未找到数据, "月度测试里程");
// let testCount = 0;
// testList.forEach(info => {
// let {timeDay, enterprise, totalMileage} = info;
// if (!企业月前里程数据[enterprise]) 企业月前里程数据[enterprise] = {count:0, autoCount:0};
// 企业月前里程数据[enterprise].count += totalMileage;
// testCount += parseInt(totalMileage);
// });
// let functionList = await getInterfaceData(startTime, endTime, 2);
// if(!functionList) throw new BizError(ERRORENUM.未找到数据, "月度功能测试里程");
// let functionCount = 0;
// functionList.forEach(info => {
// let {timeDay, enterprise, autoMileage} = info;
// if (!企业月前里程数据[enterprise]) 企业月前里程数据[enterprise] = {count:0, autoCount:0};
// 企业月前里程数据[enterprise].count += autoMileage;
// functionCount += parseInt(autoMileage);
// });
// let testMileageEnterprise = [];
// let functionTestMileageEnterprise = [];
// for(let key in 企业日里程数据) {
// let 企业日里程数据data = 企业日里程数据[key];
// let {count, autoCount} = 企业日里程数据data;
// testMileageEnterprise.push({key, value: count});
// functionTestMileageEnterprise.push({key, value: autoCount});
// }
// testMileage.push({key:months, value:testCount});
// functionTestMileage.push({key:months, value:functionCount});
// return {testMileage, functionTestMileage, testMileageEnterprise, functionTestMileageEnterprise};
// }
// //测试牌照分布
// 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 ) {
// 测试牌照分布 = result.result[0].result;
// } else {
// throw new SysError(SYSTEMERRORENUM.获取第三方接口数据失败, appConfig.rightView, JSON.stringify(requestParam));
// }
// let 测试牌照数 = 0;
// 测试牌照分布.forEach( item => {
// let {enterprise, cnt} = item;
// let imgItem = `http://${getImageIp()}:${systemConfig.port}/img/${enterprise}.png`;
// let count = parseInt(cnt);
// 测试牌照分布data[imgItem] = count + "辆";
// 测试牌照数 += count;
// })
// let 测试企业数 = 测试牌照分布.length;
return {测试牌照分布data, 测试牌照数, 测试企业数};
}
//企业脱离自动驾驶比率
/**
* autoMilegae 自动驾驶里程
* disengagement 脱离次数
*/
export async function getDetachmentRatio() {
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 && result.result) {
list = result.result;
} else {
throw new SysError(SYSTEMERRORENUM.获取第三方接口数据失败, appConfig.rightView, JSON.stringify(requestParam) );
}
let disengagementData = list[0].result || [];//次数数据
let autoMilegaeData = list[1].result || [];//里程数据
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(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 distinctMap) {
let { enterprise, disengagement, autoMileage} = distinctMap[key];
返回结果.push({"企业名称":enterprise, "里程":autoMileage + "公里", "次数":disengagement + "次"});
}
return 返回结果;
}
//初始化测试时长分布
export async function getTestDurationDistribution() {
let requestParam = {index:19, et:moment().format("YYMMDD")};
let yesterdayParam = {index:19, et:moment().subtract(1, 'days').format("YYMMDD")};
let dayBefore = {index:19, et:moment().subtract(2, 'days').format("YYMMDD")};
let result:any = await get(appConfig.rightView, requestParam);
let yesterdayResult:any = await get(appConfig.rightView, yesterdayParam);
let resultResult:any = await get(appConfig.rightView, dayBefore);
let 企业时长数据 = [];
let 月时长数据 = [];
let 总测试时长:any = {};
let 昨日总测试时长:any = {};
let 前天总测试时长:any = {};
if (result && result.success && result.result) {
月时长数据 = result.result[2].result;
企业时长数据 = result.result[1].result;
总测试时长 = result.result[0].result[0];
昨日总测试时长 = yesterdayResult.result[0].result[0];
前天总测试时长 = resultResult.result[0].result[0];
} else {
throw new SysError(SYSTEMERRORENUM.获取第三方接口数据失败, appConfig.rightView , requestParam);
}
// return {测试牌照分布data, 测试牌照数, 测试企业数};
// }
// //企业脱离自动驾驶比率
// /**
// * autoMilegae 自动驾驶里程
// * disengagement 脱离次数
// */
// export async function getDetachmentRatio() {
// 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 && result.result) {
// list = result.result;
// } else {
// throw new SysError(SYSTEMERRORENUM.获取第三方接口数据失败, appConfig.rightView, JSON.stringify(requestParam) );
// }
// let disengagementData = list[0].result || [];//次数数据
// let autoMilegaeData = list[1].result || [];//里程数据
// 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(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 distinctMap) {
// let { enterprise, disengagement, autoMileage} = distinctMap[key];
// 返回结果.push({"企业名称":enterprise, "里程":autoMileage + "公里", "次数":disengagement + "次"});
// }
// return 返回结果;
// }
// //初始化测试时长分布
// export async function getTestDurationDistribution() {
// let requestParam = {index:19, et:moment().format("YYMMDD")};
// let yesterdayParam = {index:19, et:moment().subtract(1, 'days').format("YYMMDD")};
// let dayBefore = {index:19, et:moment().subtract(2, 'days').format("YYMMDD")};
// let result:any = await get(appConfig.rightView, requestParam);
// let yesterdayResult:any = await get(appConfig.rightView, yesterdayParam);
// let resultResult:any = await get(appConfig.rightView, dayBefore);
// let 企业时长数据 = [];
// let 月时长数据 = [];
// let 总测试时长:any = {};
// let 昨日总测试时长:any = {};
// let 前天总测试时长:any = {};
// if (result && result.success && result.result) {
// 月时长数据 = result.result[2].result;
// 企业时长数据 = result.result[1].result;
// 总测试时长 = result.result[0].result[0];
// 昨日总测试时长 = yesterdayResult.result[0].result[0];
// 前天总测试时长 = resultResult.result[0].result[0];
// } else {
// throw new SysError(SYSTEMERRORENUM.获取第三方接口数据失败, appConfig.rightView , requestParam);
// }
return {企业时长数据, 月时长数据, 总测试时长, 昨日总测试时长, 前天总测试时长};
}
// return {企业时长数据, 月时长数据, 总测试时长, 昨日总测试时长, 前天总测试时长};
// }
export async function getCsgkData() {
let {总测试时长, 月时长数据, 昨日总测试时长, 前天总测试时长} = await getTestDurationDistribution();
let {测试牌照分布data, 测试牌照数, 测试企业数} = await getTestLicense();
// export async function getCsgkData() {
// let {总测试时长, 月时长数据, 昨日总测试时长, 前天总测试时长} = await getTestDurationDistribution();
// let {测试牌照分布data, 测试牌照数, 测试企业数} = await getTestLicense();
// 月时长数据.sort((a, b) => { return parseInt(b.time) - parseInt(a.time) });
// // 月时长数据.sort((a, b) => { return parseInt(b.time) - parseInt(a.time) });
let 测试总里程 = 0;
let 功能测试总里程 = 0;
for (let key in 企业日里程数据) {
测试总里程 += 企业日里程数据[key].count;
功能测试总里程 += 企业日里程数据[key].autoCount;
}
// let 测试总里程 = 0;
// let 功能测试总里程 = 0;
// for (let key in 企业日里程数据) {
// 测试总里程 += 企业日里程数据[key].count;
// 功能测试总里程 += 企业日里程数据[key].autoCount;
// }
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 thisMonthsTestTimeData = 总测试时长[0] || {autoDurationTotal:0, durationTotal:0};
// let avgAutoTime = Math.ceil( (thisMonthsTestTimeData.autoDurationTotal/new Date().getDate() )*10)/10;
// let testTime = Math.ceil( (thisMonthsTestTimeData.durationTotal/new Date().getDate() ) *10 )/10;
let testTime = Math.ceil(昨日总测试时长.durationTotal - 前天总测试时长.durationTotal);
let avgAutoTime = Math.ceil(昨日总测试时长.autoDurationTotal - 前天总测试时长.autoDurationTotal);
let 今日数据 = {"在线车辆数": ""}
let 今日测试 = { "里程": "0Km", "时长": testTime+'h'};
let 今日功能测试 = { "里程": "0Km", "时长": avgAutoTime+'h'};
if (nowDate == '01') {
//一号拿昨日数据跨月份
今日测试.里程 = monthsLastData.count+"Km";
今日功能测试.里程 = monthsLastData.autoCount+"Km";
}
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+"Km";
}
});
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+"Km";
}
});
if (今日测试.里程 == "0Km") {
今日测试.时长="0h";
今日功能测试.时长 = "0h";
}
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 {测试牌照分布data, result, 今日数据, 今日测试, 今日功能测试};
}
//月度测试时长分布
export async function getTestTotalTime() {
let {企业时长数据, 月时长数据} = await getTestDurationDistribution();
let 月度测试时长测试数据 = [];
let 月度测试时长功能测试数据 = [];
// 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 thisMonthsTestTimeData = 总测试时长[0] || {autoDurationTotal:0, durationTotal:0};
// // let avgAutoTime = Math.ceil( (thisMonthsTestTimeData.autoDurationTotal/new Date().getDate() )*10)/10;
// // let testTime = Math.ceil( (thisMonthsTestTimeData.durationTotal/new Date().getDate() ) *10 )/10;
// let testTime = Math.ceil(昨日总测试时长.durationTotal - 前天总测试时长.durationTotal);
// let avgAutoTime = Math.ceil(昨日总测试时长.autoDurationTotal - 前天总测试时长.autoDurationTotal);
// let 今日数据 = {"在线车辆数": ""}
// let 今日测试 = { "里程": "0Km", "时长": testTime+'h'};
// let 今日功能测试 = { "里程": "0Km", "时长": avgAutoTime+'h'};
// if (nowDate == '01') {
// //一号拿昨日数据跨月份
// 今日测试.里程 = monthsLastData.count+"Km";
// 今日功能测试.里程 = monthsLastData.autoCount+"Km";
// }
// 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+"Km";
// }
// });
// 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+"Km";
// }
// });
// if (今日测试.里程 == "0Km") {
// 今日测试.时长="0h";
// 今日功能测试.时长 = "0h";
// }
// 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 {测试牌照分布data, result, 今日数据, 今日测试, 今日功能测试};
// }
// //月度测试时长分布
// export async function getTestTotalTime() {
// let {企业时长数据, 月时长数据} = await getTestDurationDistribution();
// let 月度测试时长测试数据 = [];
// let 月度测试时长功能测试数据 = [];
月时长数据.sort((a, b) => { return parseInt(b.time) - parseInt(a.time) });
for (let i = 0; i < 21; i++) {
let {durationTotal, autoDurationTotal, time} = 月时长数据[i];
月度测试时长测试数据.push({key:time, value:durationTotal});
月度测试时长功能测试数据.push({key:time, value:autoDurationTotal});
}
let countMap = {};
企业时长数据.forEach(info => {
let {autoDurationTotal, durationTotal, enterprise} = info;
if ( !countMap[enterprise] ) countMap[enterprise] = {durationTotal:0, autoDurationTotal:0};
countMap[enterprise].autoDurationTotal += autoDurationTotal;
countMap[enterprise].durationTotal += durationTotal;
});
let 企业测试时长测试数据 = [];
let 企业测试时长功能测试数据 = [];
// 月时长数据.sort((a, b) => { return parseInt(b.time) - parseInt(a.time) });
// for (let i = 0; i < 21; i++) {
// let {durationTotal, autoDurationTotal, time} = 月时长数据[i];
// 月度测试时长测试数据.push({key:time, value:durationTotal});
// 月度测试时长功能测试数据.push({key:time, value:autoDurationTotal});
// }
// let countMap = {};
// 企业时长数据.forEach(info => {
// let {autoDurationTotal, durationTotal, enterprise} = info;
// if ( !countMap[enterprise] ) countMap[enterprise] = {durationTotal:0, autoDurationTotal:0};
// countMap[enterprise].autoDurationTotal += autoDurationTotal;
// countMap[enterprise].durationTotal += durationTotal;
// });
// let 企业测试时长测试数据 = [];
// let 企业测试时长功能测试数据 = [];
for (let enterprise in countMap) {
let {autoDurationTotal, durationTotal} = countMap[enterprise]
企业测试时长测试数据.push({key:enterprise, value:durationTotal});
企业测试时长功能测试数据.push({key:enterprise, value:autoDurationTotal});
}
// for (let enterprise in countMap) {
// let {autoDurationTotal, durationTotal} = countMap[enterprise]
// 企业测试时长测试数据.push({key:enterprise, value:durationTotal});
// 企业测试时长功能测试数据.push({key:enterprise, value:autoDurationTotal});
// }
let 月度测试时长data = {testTime:月度测试时长测试数据, functionTestTime:月度测试时长功能测试数据};
let 企业测试时长data = {testTimeEnterprise:企业测试时长测试数据, functionTestTimeEnterprise:企业测试时长功能测试数据};
// let 月度测试时长data = {testTime:月度测试时长测试数据, functionTestTime:月度测试时长功能测试数据};
// let 企业测试时长data = {testTimeEnterprise:企业测试时长测试数据, functionTestTimeEnterprise:企业测试时长功能测试数据};
return {月度测试时长data, 企业测试时长data};
}
//initData 在main方法中调用
export async function initData() {
await historyData();//初始化本月之前的必须数据
//设置每隔两小时检查更新
setInterval(async () => {
let months = moment().format("YYYY.MM")+'.01';
if (months != lastMonths) {
let key = moment(months).format('YYYY.MM');
let startTime = moment(lastMonths).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.未找到数据, "月度测试里程缓存数据");
// return {月度测试时长data, 企业测试时长data};
// }
// //initData 在main方法中调用
// export async function initData() {
// await historyData();//初始化本月之前的必须数据
// //设置每隔两小时检查更新
// setInterval(async () => {
// let months = moment().format("YYYY.MM")+'.01';
// if (months != lastMonths) {
// let key = moment(months).format('YYYY.MM');
// let startTime = moment(lastMonths).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.未找到数据, "月度测试里程缓存数据");
let count = 0;
list.forEach(info => {
let {timeDay, enterprise, totalMileage} = info;
let intTotalMileage = parseInt(totalMileage);
count += intTotalMileage;
// let count = 0;
// list.forEach(info => {
// let {timeDay, enterprise, totalMileage} = info;
// let intTotalMileage = parseInt(totalMileage);
// count += intTotalMileage;
if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
企业日里程数据[enterprise].count += intTotalMileage;
// if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
// 企业日里程数据[enterprise].count += intTotalMileage;
if (timeDay == lastDay) {
monthsLastData.count += intTotalMileage;
}
});
// if (timeDay == lastDay) {
// monthsLastData.count += intTotalMileage;
// }
// });
let testList = await getInterfaceData(startTime, endTime, 2);
if(!testList) throw new BizError(ERRORENUM.未找到数据, "月度功能测试里程缓存数据");
// let testList = await getInterfaceData(startTime, endTime, 2);
// if(!testList) throw new BizError(ERRORENUM.未找到数据, "月度功能测试里程缓存数据");
let testCount = 0;
testList.forEach(info => {
let {timeDay, enterprise, autoMileage} = info;
let intAutoMileage = parseInt(autoMileage);
testCount += intAutoMileage
// let testCount = 0;
// testList.forEach(info => {
// let {timeDay, enterprise, autoMileage} = info;
// let intAutoMileage = parseInt(autoMileage);
// testCount += intAutoMileage
if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
企业日里程数据[enterprise].autoCount += intAutoMileage;
if (timeDay == lastDay) {
monthsLastData.autoCount += intAutoMileage;
}
});
let addItem = {count, autoCount:testCount, key};
月里程数据.push(addItem );
// if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
// 企业日里程数据[enterprise].autoCount += intAutoMileage;
// if (timeDay == lastDay) {
// monthsLastData.autoCount += intAutoMileage;
// }
// });
// let addItem = {count, autoCount:testCount, key};
// 月里程数据.push(addItem );
lastMonths = months;
}
// lastMonths = months;
// }
}, 3600 *2 * 1000);
}
// }, 3600 *2 * 1000);
// }
//获取本月之前的数据
async function historyData() {
let lastEt = "";
// //获取本月之前的数据
// async function historyData() {
// let lastEt = "";
for (let i = 20; i > 0; i--) {
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');
// for (let i = 20; i > 0; i--) {
// 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 == 20) {
// lastEt = moment().subtract(i+1, 'months').endOf('month').format('YYMMDD');
// }
let list = await getInterfaceData(st, et, 1);
// let list = await getInterfaceData(st, et, 1);
let count = 0;
list.forEach(info => {
let {timeDay, enterprise, totalMileage} = info;
let intTotalMileage = parseInt(totalMileage);
count += intTotalMileage
// let count = 0;
// list.forEach(info => {
// let {timeDay, enterprise, totalMileage} = info;
// let intTotalMileage = parseInt(totalMileage);
// count += intTotalMileage
if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
// if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
企业日里程数据[enterprise].count += intTotalMileage;
// 企业日里程数据[enterprise].count += intTotalMileage;
if (timeDay == lastDay) {
monthsLastData.count += intTotalMileage;
}
});
// if (timeDay == lastDay) {
// monthsLastData.count += intTotalMileage;
// }
// });
let testList = await getInterfaceData(st, et, 2);
// let testList = await getInterfaceData(st, et, 2);
let testCount = 0;
testList.forEach(info => {
let {timeDay, enterprise, autoMileage} = info;
let intAutoMileage = parseInt(autoMileage);
testCount += intAutoMileage;
// let testCount = 0;
// testList.forEach(info => {
// let {timeDay, enterprise, autoMileage} = info;
// let intAutoMileage = parseInt(autoMileage);
// testCount += intAutoMileage;
if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
企业日里程数据[enterprise].autoCount +=intAutoMileage;
// if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
// 企业日里程数据[enterprise].autoCount +=intAutoMileage;
if (timeDay == lastDay) {
monthsLastData.autoCount += intAutoMileage;
}
// if (timeDay == lastDay) {
// monthsLastData.autoCount += intAutoMileage;
// }
});
月里程数据.push( {count, autoCount:testCount, key} );
console.log(`初始化 ${key} 数据`);
}
// });
// 月里程数据.push( {count, autoCount:testCount, key} );
// console.log(`初始化 ${key} 数据`);
// }
//查找21个月以外的数据
// //查找21个月以外的数据
let list = await getInterfaceData("", lastEt, 1);
list.forEach(info => {
let {time_day, enterprise, total_mileage} = info;
// let list = await getInterfaceData("", lastEt, 1);
// list.forEach(info => {
// let {time_day, enterprise, total_mileage} = info;
if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
企业日里程数据[enterprise].count += parseInt(total_mileage);
});
let testList = await getInterfaceData("", lastEt, 2);
testList.forEach(info => {
let {time_day, enterprise, auto_mileage} = info;
// if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
// 企业日里程数据[enterprise].count += parseInt(total_mileage);
// });
// let testList = await getInterfaceData("", lastEt, 2);
// testList.forEach(info => {
// let {time_day, enterprise, auto_mileage} = info;
if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
企业日里程数据[enterprise].autoCount += parseInt(auto_mileage);
});
// if (!企业日里程数据[enterprise]) 企业日里程数据[enterprise] = {count:0, autoCount:0};
// 企业日里程数据[enterprise].autoCount += parseInt(auto_mileage);
// });
console.log(`初始化 数据完成`);
// console.log(`初始化 数据完成`);
lastMonths = moment().format("YYYY.MM")+'.01';
}
//获取数据
async function getInterfaceData(st, et, index) {
const interfaceUrl = appConfig.rightView;
let body = {st, et, index};
let result:any = await get(interfaceUrl, body);
if (result && result.success) {
return result.result[0].result;
} else {
throw new SysError(SYSTEMERRORENUM.获取第三方接口数据失败, interfaceUrl, JSON.stringify(body) );
}
}
// lastMonths = moment().format("YYYY.MM")+'.01';
// }
// //获取数据
// async function getInterfaceData(st, et, index) {
// const interfaceUrl = appConfig.rightView;
// let body = {st, et, index};
// let result:any = await get(interfaceUrl, body);
// if (result && result.success) {
// return result.result[0].result;
// } else {
// throw new SysError(SYSTEMERRORENUM.获取第三方接口数据失败, interfaceUrl, JSON.stringify(body) );
// }
// }
src/data/interface/wsData.ts
......@@ -53,7 +53,8 @@ let heart = {
//ws客户端
async function createSocket() {
let ws = new WebSocket(appConfig.wsPath, {perMessageDeflate: false});
console.log(appConfig.wsPath);
let ws = new WebSocket(appConfig.wsPath);
ws.onclose = async (err) => {
console.log("连接关闭: ", err);
......@@ -84,34 +85,40 @@ export async function initWSData() {
}
//在线车辆
let dp = {};//数据池 {"id":{lastMs:最新的时间, list:[{},{},{}], index:0 } }
let dpNewDate = '';
export function stats(data) {
let dateFormat = moment().format('YYYYMMDD');
if (!dpNewDate) dpNewDate = dateFormat;
let dataType = typeof data;
if (dataType == "string") {
if (typeof data == "string") {
try{
// console.log(data);
let dataJson = JSON.parse(data);
let {vehicleid, latitude, longitude, positiontime, canRecvTime} = dataJson;
broadcastMsg({lng:longitude||0.0, lat:latitude||0.0, vehicleid});
//加入到缓存
let lastMs = positiontime || canRecvTime;
if ( lastMs ) {//数据包里有时间就缓存
checkData(dateFormat);
if ( !dp[vehicleid] ) dp[vehicleid] = {lastMs, list:[], index:0 };//初始化缓存
dp[vehicleid].list[dp[vehicleid].index] = {lng:longitude||0.0, lat:latitude||0.0, vehicleid, lastMs};
dp[vehicleid].index += 1;
if (dp[vehicleid].index > 4) dp[vehicleid].index = 0;
}
dataJson.VehicleLoc.forEach(info => {
let {vin, latitude, longitude, positiontime, vehicleId} = info;
broadcastMsg({lng:longitude||0.0, lat:latitude||0.0, vin});
//加入到缓存
let lastMs = positiontime || new Date().valueOf();
if ( lastMs ) {//数据包里有时间就缓存
checkData(dateFormat);
if ( !dp[vin] ) dp[vin] = {lastMs, list:[], index:0 };//初始化缓存
//每个小车缓存4个数据，新连接进来的时候下发缓存好的数据，看起来不会很突兀
dp[vin].list[dp[vin].index] = {lng:longitude||0.0, lat:latitude||0.0, vin, lastMs, vehicleid:vehicleId};
dp[vin].index += 1;
if (dp[vin].index >= 4) dp[vin].index = 0;
}
});
} catch(err) {
logHandle("ws 返回数据不是json --> "+ data);
}
} else {
logHandle(`ws 返回数据不符合规范 类型:${dataType} --> `+ data)
logHandle(`ws 返回数据不符合规范 类型:${typeof data} --> `+ data)
}
}
......@@ -132,7 +139,7 @@ export function getDpData() {
result.sort( (a, b) => {return a.lastMs - b.lastMs});
let initList = [];
result.forEach(info => {
let {lng, lat,vehicleid, lastMs} = info;
let {lng, lat, vehicleid, lastMs} = info;
initList.push({lng, lat, vehicleid});
});
return {initList, count:Object.keys(dp).length};
......@@ -142,23 +149,16 @@ export function getOnlieCarCount() {
return Object.keys(dp).length;
}
/* data 数据长这样
{
"accLat":0.08,
"accLong":1.542,
"acceleration":0,加速度
"altitude":-3276,海拔高度
"canRecvTime":1660285379691,//接收数据时间
"direction":0,//方向
"drivemode":0,//驾驶模式
"latitude":纬度,
"longitude":经度,
"mileage":里程,
"positiontime":时间戳,
"vehicleid":"车辆id",
"velocity":速度,
"vin":"LSJE24090MS029920"
//控制端获取在线小车列表
//最后在线时间如果大于1分钟，判定为下线，不下发到控制端的小车列表里
export function controlGetOnlieCarList() {
let ms = new Date().valueOf();
let onlineCarList = [];
for (let key in dp) {
let {lastMs, list, index} = dp[key];
if ((ms -lastMs) > 5*60*1000) continue;
let {vin, vehicleid} = list[index];
onlineCarList.push({id:vin, vehicleid});
}
return onlineCarList;
}
*/
src/data/interfaceConfig.ts
import { INTERFACEREQUESTTYPEENUM } from "../config/enum";
import { dataCenterInterfaceConfig } from "../config/serverConfig";
//配置
// "接口名称":{
// type:"1是即时更新 2是即时更新 使用 INTERFACErEQUESTTYPEENUM",
......@@ -8,18 +9,25 @@ import { INTERFACEREQUESTTYPEENUM } from "../config/enum";
// 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"}},
export const Config = {
"测试企业及车辆数量接口":{
url:dataCenterInterfaceConfig.enterpriseVehicleAmount, reqType:"get", header:{}, body:{}
},
"总实时测试概况接口":{
url:dataCenterInterfaceConfig.testStatusTotal, reqType:"get", header:{}, body:{}
},
"今日实时测试概况接口":{
url:dataCenterInterfaceConfig.todayTestStatusTotal, reqType:"get", header:{}, body:{}
},
"企业历史里程及时长统计信息接口":{
url:dataCenterInterfaceConfig.enterpriseTestStatus, reqType:"get", header:{}, body:{}
},
"月度历史里程及时长统计信息接口":{
url:dataCenterInterfaceConfig.monthlyTestStatus, reqType:"get", header:{}, body:{}
},
"企业历史脱离率统计接口":{
url:dataCenterInterfaceConfig.enterpriseExitRate, reqType:"get", header:{}, body:{}
},
};
\ No newline at end of file
src/data/newInterface/csfxData.ts deleted 100644 → 0
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 deleted 100644 → 0
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/main.ts
import { initControlSocketServer } from "./biz/control";
import { initSocketServer } from "./biz/jgfwnl/wsData";
import { initConfig, systemConfig} from "./config/serverConfig";
import { getCsgkData, initData } from "./data/interface/interfaceService";
import { initWSData } from "./data/interface/wsData";
import { httpServer } from "./net/http_server";
async function lanuch() {
await initConfig();//初始化配置解析
await initWSData();
// await initData();
await initSocketServer(systemConfig.socketPort);
await initControlSocketServer(systemConfig.controlSocketPort);
httpServer.createServer(systemConfig.port);
console.log('This indicates that the server is started successfully.');
}
function test() {
let enterpriseVehicleList = [
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGN9jCqAPEVpAAAm6sRT_IA756.jpg",
"enterpriseName": "云骥",
"totalVehicle": 1
},
{
"enterpriseLogo": null,
"enterpriseName": "临港公交",
"totalVehicle": 3
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM2lHCASyYTAAEDUVmM2m0938.png",
"enterpriseName": "上汽乘用车",
"totalVehicle": 6
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM1ch-AcgrDAAByDdvtn6k677.png",
"enterpriseName": "酷移",
"totalVehicle": 3
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM1ciyAedpJAAG2siiJo0w193.png",
"enterpriseName": "友道",
"totalVehicle": 44
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM1LK-AIsLkAAAKYhI9eR0154.png",
"enterpriseName": "临港捷运",
"totalVehicle": 1
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM1LGWATddkAAEK1eJjpVM191.png",
"enterpriseName": "依行",
"totalVehicle": 2
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-b6ALJEbAAH7eWqp0bE733.png",
"enterpriseName": "赛可",
"totalVehicle": 118
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-duARquaAAC8mHN7yqg957.png",
"enterpriseName": "小马",
"totalVehicle": 28
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-gGAcBiPAADtjwwbuqE946.png",
"enterpriseName": "百度",
"totalVehicle": 106
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-g6AJtXIAANj_AVn0wM695.png",
"enterpriseName": "商汤",
"totalVehicle": 9
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-hyAefROAABWKnMLAdo369.png",
"enterpriseName": "阿利昂斯",
"totalVehicle": 4
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-i2ANds6AADLub0EZT0345.png",
"enterpriseName": "通用中国",
"totalVehicle": 1
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-r6AL0T0AAApBxEtDUU721.png",
"enterpriseName": "上汽大通",
"totalVehicle": 2
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-myAIhJ5AAAqjEIMfFw960.png",
"enterpriseName": "丰田",
"totalVehicle": 7
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-nqALg--AAC0YqlTbOQ313.png",
"enterpriseName": "AutoX",
"totalVehicle": 81
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-pOADhIiAAFDNIhavW8152.png",
"enterpriseName": "上汽通用",
"totalVehicle": 1
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-qyAez_GAAALxjs3x4I609.png",
"enterpriseName": "中智行",
"totalVehicle": 5
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-tiAT8XYAAAiB_U3mkY795.png",
"enterpriseName": "深兰",
"totalVehicle": 1
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-uqAMfpIAAAjg9Trrt0609.png",
"enterpriseName": "吉利",
"totalVehicle": 2
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-v-ACoYtAAAdSG61mok324.png",
"enterpriseName": "滴滴",
"totalVehicle": 60
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-w-AC-UOAAA9n932Q5U842.png",
"enterpriseName": "上汽大众",
"totalVehicle": 6
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-ySAWzDmAAAsek9ZJXk572.png",
"enterpriseName": "华为",
"totalVehicle": 1
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM1LMGAXySoAAGXZUOHtgA299.png",
"enterpriseName": "图森",
"totalVehicle": 12
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-2CAWHJMAAA6TBhy5EE928.png",
"enterpriseName": "仙途",
"totalVehicle": 2
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-2yAeap1AAA6yCs-OLw861.png",
"enterpriseName": "宝马",
"totalVehicle": 2
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-32ACnKgAACRLkClP-M405.png",
"enterpriseName": "蔚来",
"totalVehicle": 1
},
{
"enterpriseLogo": "https://management.icv-sh.com:9991/data/file/download?url=group1/M00/00/00/CjMyvGM0-5OAfEi2AAD3V0bQ31A753.png",
"enterpriseName": "初速度",
"totalVehicle": 1
}
];
let urlMap = {};
enterpriseVehicleList.forEach( info => {
let {enterpriseLogo, enterpriseName} = info;
// if (enterpriseLogo) urlMap[enterpriseLogo] = enterpriseName;
console.log(`"${enterpriseLogo}":"${enterpriseName}.png"`);
});
console.log(JSON.stringify(urlMap) );
console.log();
}
lanuch();
\ No newline at end of file
src/net/socket_server.ts
......@@ -11,4 +11,4 @@ export class Socket {
callback(wss);
console.log("socketServer listen on port:"+port);
}
}
}
\ No newline at end of file
src/routers/router.ts
......@@ -8,6 +8,9 @@ import * as jgfwnl_qycsfxBiz from '../biz/jgfwnl_qycsfx';
import * as jgfwnl_clcszlBiz from '../biz/jgfwnl_clcszl';
import * as jgfwnl_RSUfslBiz from '../biz/jgfwnl_RSUfsl';
import * as jgfwnlBiz from '../biz/jgfwnl/data';
import * as controlBiz from '../biz/control';
import * as dsjBiz from '../biz/dsj';
export function setRouter(httpServer){
httpServer.get('/jgfwnl_yzy', asyncHandler(jgfwnl_yzyBiz.getData));
......@@ -28,12 +31,9 @@ export function setRouter(httpServer){
httpServer.get('/yzy', asyncHandler(jgfwnlBiz.getYZY));
httpServer.get('/csgk', asyncHandler(jgfwnlBiz.getCSGK));
httpServer.get('/csfx', asyncHandler(jgfwnlBiz.getCSFX));
httpServer.post('/yzy', asyncHandler(jgfwnlBiz.getYZY));
httpServer.post('/csgk', asyncHandler(jgfwnlBiz.getCSGK));
httpServer.post('/csfx', asyncHandler(jgfwnlBiz.getCSFX));
httpServer.get('/mapdata', asyncHandler(jgfwnlBiz.mapData));
httpServer.post('/mapdata', asyncHandler(jgfwnlBiz.mapData));
httpServer.post('/carinfo', asyncHandler(jgfwnlBiz.carInfo));
httpServer.get('/dsj', asyncHandler(dsjBiz.getData));
//控制端小车列表接口
httpServer.get('/carlist', asyncHandler(controlBiz.controlGetCarList));
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment