rt-sim-training-client/src/store/modules/map.js

import deviceType from '@/jmap/constant/deviceType';
import { parser } from '@/jmap/utils/parser';
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 saveMapDeviceDefaultRelations(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 sectionp = deviceMap[sectiona.parentCode || sectionb.parentCode || sectionc.parentCode];
				if (sectionp) {
					sectionp.relSwitchCode = elem.code;
				}
			});
		}
	}
}

/**
 * 实训状态数据
 */
const map = {
	namespaced: true,

	state: {
		map: null, 				// 地图数据
		mapDevice: {},			// 解析后的地图数据
		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: (state) => (code) => {
			return state.mapDevice[code];
		},

		// 查询区段关联的计数器
		getCounterBySectionCode: (state) => (code, type) => {
			let device = null;
			var section = state.mapDevice[code];
			if (section) {
				state.map.counterList.forEach(counter => {
					if (counter.stationCode === section.model.stationCode && type == counter.type) {
						device = state.mapDevice[counter.code];
						return;
					}
				});
			}

			return device;
		},

		// 查询信号机关联的计数器
		getCounterBySingalCode: (state) => (code, type) => {
			let device = null;
			var signal = state.mapDevice[code];
			if (signal) {
				state.map.counterList.forEach(counter => {
					if (counter.stationCode === signal.model.stationCode && type == counter.type) {
						device = state.mapDevice[counter.code];
						return;
					}
				});
			}
			return device;
		},

		// 查询所属车站关联的控制模式
		getStationControlByStationCode: (state) => (code) => {
			let device = null;
			if (code &&
				state.map &&
				state.map.stationControlList && state.map.stationControlList.length) {
				state.map.stationControlList.forEach(elem => {
					if (elem.stationCode == code) {
						device = state.mapDevice[elem.code];
					}
				});
			}

			return device;
		}
	},

	mutations: {
		setMapData: (state, map) => {
			if (map && map.skinVO) {
				state.map = map;
				state.mapDevice = parser(map, map.skinVO.code);
			} else {
				state.mapDevice = {};
			}
		},
		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;
			state.mapDevice = {};
			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);
				});

				effectedModelList.forEach(elem => { elem['_dispose'] = true; });
				commit('mapRender', effectedModelList);
				resolve(effectedModelList);
			});
		},

		saveMapDeviceDefaultRelations({ state }) {
			saveMapDeviceDefaultRelations(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;