544 lines
13 KiB
JavaScript
544 lines
13 KiB
JavaScript
import deviceType from '@/jmap/constant/deviceType';
|
|
import Vue from 'vue';
|
|
|
|
/**
|
|
* 查询向上受影响的Devices
|
|
* @param {Object} map
|
|
* @param {Object} device
|
|
* @param {Array} effectedDeviceList
|
|
*/
|
|
function queryEffectedModels(map, device, effectedDeviceList) {
|
|
if (device && map) {
|
|
effectedDeviceList.push(device);
|
|
switch (device._type) {
|
|
// 查询ink关联项
|
|
case deviceType.Link:
|
|
// 查询Link关联的区段
|
|
if (map.sectionList && map.sectionList.length) {
|
|
map.sectionList.forEach(elem => {
|
|
if (elem.linkCode === device.code) {
|
|
queryEffectedModels(map, elem, effectedDeviceList);
|
|
}
|
|
});
|
|
}
|
|
|
|
// 查询Link关联的信号机
|
|
if (map.signalList && map.signalList.length) {
|
|
map.signalList.forEach(elem => {
|
|
if (elem.linkCode === device.code) {
|
|
effectedDeviceList.push(elem);
|
|
}
|
|
});
|
|
}
|
|
break;
|
|
// 移除区段关联项
|
|
case deviceType.Section:
|
|
// 查询物理区段关联的逻辑区段
|
|
if (map.sectionList && map.sectionList.length && device.type === '01') {
|
|
map.sectionList.forEach(elem => {
|
|
if (elem.type !== '01' && elem.parentCode === device.code) {
|
|
effectedDeviceList.push(elem);
|
|
}
|
|
});
|
|
}
|
|
|
|
// 查询区段关联车次窗
|
|
if (map.trainWindowList && map.trainWindowList.length) {
|
|
map.trainModelList.forEach(elem => {
|
|
if (elem.sectionCode == device.code) {
|
|
effectedDeviceList.push(elem);
|
|
}
|
|
});
|
|
}
|
|
|
|
// 查询区段关联的道岔
|
|
if (map.switchList && map.switchList.length) {
|
|
map.switchList.forEach(elem => {
|
|
if (elem.sectionACode === device.code ||
|
|
elem.sectionBCode === device.code ||
|
|
elem.sectionCCode === device.code) {
|
|
effectedDeviceList.push(elem);
|
|
}
|
|
});
|
|
}
|
|
|
|
// 查询区段关联的车站
|
|
if (map.stationList && map.stationList.length) {
|
|
map.stationList.forEach(elem => {
|
|
if (elem.sectionCode === device.code) {
|
|
effectedDeviceList.push(elem);
|
|
}
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
function saveMapDeviceDefaultConvert(state) {
|
|
if (state && state.map) {
|
|
const map = state.map;
|
|
const deviceMap = Vue.prototype.$jlmap.mapDevice;
|
|
// 是否集中站
|
|
if (map.stationControlList && map.stationControlList.length) {
|
|
map.stationControlList.forEach(elem => {
|
|
const station = deviceMap[elem.stationCode];
|
|
if (station) {
|
|
station.centralized = true;
|
|
}
|
|
});
|
|
}
|
|
|
|
// 设置区段关联
|
|
if (map.sectionList && map.sectionList.length) {
|
|
map.sectionList.forEach(elem => {
|
|
if (elem.type !== '03') {
|
|
const station = deviceMap[elem.parentCode];
|
|
if (station) {
|
|
elem.stationCode = station.stationCode;
|
|
}
|
|
} else {
|
|
elem.parentCode = '';
|
|
}
|
|
|
|
if (elem.type === '01') {
|
|
elem.nameShow == true;
|
|
}
|
|
});
|
|
}
|
|
|
|
// 站台轨设置
|
|
if (map.stationStandList && map.stationStandList.length && map.sectionList && map.sectionList.length) {
|
|
map.stationStandList.forEach((stand) => {
|
|
const stopPoint = deviceMap[stand.stopPointCode];
|
|
if (stopPoint) {
|
|
map.sectionList.forEach(section => {
|
|
if (section.type === '01' &&
|
|
stopPoint.linkCode === section.linkCode &&
|
|
stopPoint.offset >= section.offsetLeft &&
|
|
stopPoint.offset <= section.offsetRight) {
|
|
section.isStandTrack = true;
|
|
if (!section.standTrackName) {
|
|
section.standTrackName = section.name.replace(section.name.slice(0, 2), 'ZT');
|
|
}
|
|
if (!section.standTrackNamePosition) {
|
|
section.standTrackNamePosition = { x: 0, y: 0 };
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
// 折返轨设置
|
|
if (map.stopPointList && map.stopPointList.length && map.sectionList && map.sectionList.length) {
|
|
map.stopPointList.forEach(stopPoint => {
|
|
if (stopPoint.isTurningPoint) {
|
|
map.sectionList.forEach(section => {
|
|
if (section.type === '01' &&
|
|
stopPoint.linkCode === section.linkCode &&
|
|
stopPoint.offset >= section.offsetLeft &&
|
|
stopPoint.offset <= section.offsetRight) {
|
|
section.isReentryTrack = true;
|
|
if (!section.reentryTrackName) {
|
|
section.reentryTrackName = section.name.replace(section.name.slice(0, 2), 'ZF');
|
|
}
|
|
if (!section.reentryTrackNamePosition) {
|
|
section.reentryTrackNamePosition = { x: 0, y: 0 };
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
// 设置道岔区段
|
|
if (map.switchList && map.switchList.length && map.sectionList && map.sectionList.length) {
|
|
map.switchList.forEach(elem => {
|
|
const sectiona = deviceMap[elem.sectionACode];
|
|
if (sectiona && sectiona.type !== '03') {
|
|
sectiona.nameShow = false;
|
|
sectiona.isSwitchSection = true;
|
|
sectiona.relSwitchCode = elem.code;
|
|
}
|
|
const sectionb = deviceMap[elem.sectionBCode];
|
|
if (sectionb && sectiona.type !== '03') {
|
|
sectionb.nameShow = false;
|
|
sectionb.isSwitchSection = true;
|
|
sectionb.relSwitchCode = elem.code;
|
|
}
|
|
const sectionc = deviceMap[elem.sectionCCode];
|
|
if (sectionc && sectiona.type !== '03') {
|
|
sectionc.nameShow = false;
|
|
sectionc.isSwitchSection = true;
|
|
sectionc.relSwitchCode = elem.code;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 实训状态数据
|
|
*/
|
|
const map = {
|
|
namespaced: true,
|
|
|
|
state: {
|
|
map: null, // 地图数据
|
|
mapList: {}, // 地图数据列表
|
|
mapViewLoadedCount: 0, // 地图视图加载完成标识
|
|
mapDataLoadedCount: 0, // 地图数据加载完成标识
|
|
trainDetails: null // 列车详情显示
|
|
},
|
|
|
|
getters: {
|
|
mapList: (state) => {
|
|
return state.mapList;
|
|
},
|
|
map: (state) => {
|
|
return state.map;
|
|
},
|
|
skinStyle: (state) => {
|
|
if (state.map && state.map.skinVO) {
|
|
return state.map.skinVO.code;
|
|
}
|
|
},
|
|
name: (state) => {
|
|
if (state.map) {
|
|
return state.map.name;
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
version: (state) => {
|
|
if (state.map) {
|
|
return state.map.version;
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
linkList: (state) => {
|
|
if (state.map) {
|
|
return state.map.linkList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
switchList: (state) => {
|
|
if (state.map) {
|
|
return state.map.switchList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
signalList: (state) => {
|
|
if (state.map) {
|
|
return state.map.signalList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
sectionList: (state) => {
|
|
if (state.map) {
|
|
return state.map.sectionList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
zcList: (state) => {
|
|
if (state.map) {
|
|
return state.map.zcList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
tempSpeedLimitList: (state) => {
|
|
if (state.map) {
|
|
return state.map.tempSpeedLimitList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
lcList: (state) => {
|
|
if (state.map) {
|
|
return state.map.lcList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
resourceList: (state) => {
|
|
if (state.map) {
|
|
return state.map.resourceList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
stationList: (state) => {
|
|
if (state.map) {
|
|
return state.map.stationList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
stationStandList: (state) => {
|
|
if (state.map) {
|
|
return state.map.stationStandList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
stationControlList: (state) => {
|
|
if (state.map) {
|
|
return state.map.stationControlList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
counterList: (state) => {
|
|
if (state.map) {
|
|
return state.map.counterList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
delayShowList: (state) => {
|
|
if (state.map) {
|
|
return state.map.delayShowList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
lineList: (state) => {
|
|
if (state.map) {
|
|
return state.map.lineList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
textList: (state) => {
|
|
if (state.map) {
|
|
return state.map.textList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
trainWindowList: (state) => {
|
|
if (state.map) {
|
|
return state.map.trainWindowList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
trainList: (state) => {
|
|
if (state.map) {
|
|
return state.map.trainList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
trainModelList: (state) => {
|
|
if (state.map) {
|
|
return state.map.trainModelList;
|
|
} else {
|
|
return [];
|
|
}
|
|
},
|
|
trainDetails: (state) => {
|
|
return state.trainDetails;
|
|
},
|
|
getDeviceByCode: () => (code) => {
|
|
if (Vue.prototype.$jlmap) {
|
|
return Vue.prototype.$jlmap.getDeviceByCode(code);
|
|
}
|
|
},
|
|
|
|
// 查询区段关联的计数器
|
|
getCounterBySectionCode: (state) => (code, type) => {
|
|
let device = null;
|
|
if (Vue.prototype.$jlmap) {
|
|
var section = Vue.prototype.$jlmap.mapDevice[code];
|
|
if (section) {
|
|
state.map.counterList.forEach(counter => {
|
|
if (counter.stationCode === section.model.stationCode && type == counter.type) {
|
|
device = Vue.prototype.$jlmap.mapDevice[counter.code];
|
|
return;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
return device;
|
|
},
|
|
|
|
// 查询信号机关联的计数器
|
|
getCounterBySingalCode: (state) => (code, type) => {
|
|
let device = null;
|
|
if (Vue.prototype.$jlmap) {
|
|
var signal = Vue.prototype.$jlmap.mapDevice[code];
|
|
if (signal) {
|
|
state.map.counterList.forEach(counter => {
|
|
if (counter.stationCode === signal.model.stationCode && type == counter.type) {
|
|
device = Vue.prototype.$jlmap.mapDevice[counter.code];
|
|
return;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
return device;
|
|
},
|
|
|
|
// 查询所属车站关联的控制模式
|
|
getStationControlByStationCode: (state) => (code) => {
|
|
let device = null;
|
|
if (Vue.prototype.$jlmap && code &&
|
|
state.map &&
|
|
state.map.stationControlList && state.map.stationControlList.length) {
|
|
state.map.stationControlList.forEach(elem => {
|
|
if (elem.stationCode == code) {
|
|
device = Vue.prototype.$jlmap.mapDevice[elem.code];
|
|
}
|
|
});
|
|
}
|
|
|
|
return device;
|
|
}
|
|
},
|
|
|
|
mutations: {
|
|
setMapData: (state, map) => {
|
|
state.map = map;
|
|
},
|
|
mapRender: (state, devices) => {
|
|
Vue.prototype.$jlmap && Vue.prototype.$jlmap.render(devices);
|
|
},
|
|
setTrainDetails: (state, details) => {
|
|
state.trainDetails = details;
|
|
},
|
|
mapViewLoadedCountIncrement: (state) => {
|
|
state.mapViewLoadedCount += 1;
|
|
},
|
|
mapDataLoadedCountIncrement: (state) => {
|
|
state.mapDataLoadedCount += 1;
|
|
},
|
|
operateTrainModel: (state, { model, type }) => {
|
|
if (state.map && model) {
|
|
const list = state.map.trainModelList || [];
|
|
if (type === 'ADD') {
|
|
const index = list.indexOf(list.find(elem => { return elem.code === model.code; }));
|
|
if (index < 0) {
|
|
list.push(Object.assign({}, model));
|
|
}
|
|
} else if (type === 'UPT') {
|
|
const index = list.indexOf(list.find(elem => { return elem.code === model.code; }));
|
|
if (index >= 0) {
|
|
for (var prop in model) {
|
|
list[index][prop] = model[prop];
|
|
}
|
|
}
|
|
} else if (type === 'DEL') {
|
|
const index = list.indexOf(list.find(elem => { return elem.code === model.code; }));
|
|
if (index >= 0) {
|
|
list.splice(index, 1);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
mapClear: (state) => {
|
|
state.map = null;
|
|
Vue.prototype.$jlmap && Vue.prototype.$jlmap.clear();
|
|
}
|
|
},
|
|
|
|
actions: {
|
|
mapClear: ({ commit }) => {
|
|
commit('mapClear');
|
|
},
|
|
|
|
setMapData: ({ commit }, map) => {
|
|
commit('setMapData', map);
|
|
},
|
|
|
|
setTrainDetails: ({ commit }, message) => {
|
|
commit('setTrainDetails', message);
|
|
},
|
|
|
|
setMapDataList: ({ state }, map) => {
|
|
const skinVO = map.skinVO;
|
|
if (skinVO && skinVO.code) {
|
|
state.mapList[`mapDate_${skinVO.code}`] = map;
|
|
}
|
|
},
|
|
|
|
updateMapDevices: ({ commit }, models) => {
|
|
return new Promise((resolve) => {
|
|
if (!(models instanceof Array)) {
|
|
models = [models];
|
|
}
|
|
|
|
commit('mapRender', models);
|
|
resolve(models);
|
|
});
|
|
},
|
|
|
|
deleteMapDevices: ({ commit, state }, models) => {
|
|
return new Promise((resolve) => {
|
|
if (!(models instanceof Array)) {
|
|
models = [models];
|
|
}
|
|
|
|
// 查找向上关联需要一起删除的设备
|
|
const effectedModelList = [];
|
|
models.forEach((device) => {
|
|
queryEffectedModels(state.map, device, effectedModelList);
|
|
});
|
|
|
|
commit('mapRender', effectedModelList);
|
|
resolve(effectedModelList);
|
|
});
|
|
},
|
|
|
|
saveMapDeviceDefaultConvert({ state }) {
|
|
saveMapDeviceDefaultConvert(state);
|
|
},
|
|
|
|
mapViewLoaded: ({ commit }) => {
|
|
commit('mapViewLoadedCountIncrement');
|
|
},
|
|
|
|
mapDataLoaded: ({ commit }) => {
|
|
commit('mapDataLoadedCountIncrement');
|
|
},
|
|
|
|
clearJlmapTrainView: () => {
|
|
if (Vue.prototype.$jlmap) {
|
|
Vue.prototype.$jlmap.clearTrainView();
|
|
}
|
|
},
|
|
|
|
setTrainWindowShow: ({commit, state}, show) => {
|
|
if (state.map) {
|
|
var deviceList = [];
|
|
var trainWindowList = state.map.trainWindowList;
|
|
|
|
if (trainWindowList && trainWindowList.length) {
|
|
trainWindowList.forEach(elem => {
|
|
elem._type = deviceType.TrainWindow;
|
|
elem.trainWindowShow = show;
|
|
deviceList.push(elem);
|
|
});
|
|
}
|
|
|
|
commit('mapRender', deviceList);
|
|
}
|
|
},
|
|
|
|
operateTrainModel: ({ commit }, { model, type }) => {
|
|
commit('operateTrainModel', { model, type });
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
export default map;
|