rt-sim-training-client/src/views/planMonitor/editTool/schedule.vue

<template>
  <div id="PlanSchedule" :style="{top: top+'px', height: height+'px'}">
    <div class="left">
      <div :id="runPlanId" />
    </div>
    <div class="right">
      <data-table
        ref="serviceTable"
        :height="height/2"
        :config="serviceNumberConfig"
        :style="{top: top-height/2+'px'}"
        @touch="scheduleTouch"
      />
      <data-table
        ref="tripTable"
        :height="height/2"
        :config="tripNumberConfig"
        :style="{top: top-height/2+'px'}"
        @touch="trainNumTouch"
      />
    </div>
  </div>
</template>

<script>
import { mapGetters } from 'vuex';
import { timeFormat } from '@/utils/date';
import { getStationListBySkinStyle, queryRunPlan } from '@/api/runplan';
import { loadMapData } from '@/utils/loaddata';
import DataTable from './menus/components/dataTable';

export default {
	name: 'PlanSchedule',
	components: {
		DataTable
	},
	props: {
		skinCode: {
			type: String,
			required: true
		},
		planConvert: {
			type: Object,
			required: true
		},
		maxWidth: {
			type: Number,
			required: true
		},
		maxHeight: {
			type: Number,
			required: true
		}
	},
	data() {
		return {
			top: 0,
			height: 0,
			heights: [100, 100],
			runPlanId: 'plan-tool',
			myChart: null,
			serviceNumberConfig: {
				data: [],
				highlightCurrentRow: true,
				handleChange: this.serviceNumberChange,
				showClose: false,
				columns: [
					{
						prop: 'serviceNumber',
						label: '表号'
					},
					{
						width: 40
					}
				]
			},
			tripNumberConfig: {
				data: [],
				highlightCurrentRow: true,
				handleChange: this.tripNumberChange,
				showClose: false,
				columns: [
					{
						prop: 'tripNumber',
						label: '车次号'
					},
					{
						width: 40
					}
				]
			},
			realData: {},
			kmRangeCoordMap: {},
			option: {
				title: {
					text: '',
					left: 'center'
				},
				grid: {
					top: '30px',
					left: '120px',
					right: '40px',
					bottom: '60px',
					containLabel: true,
					backgroundColor: 'floralwhite'
				},
				toolbox: {
					right: '30px',
					feature: {
						dataZoom: {
							yAxisIndex: 'none'
						},
						restore: {},
						saveAsImage: {}
					}
				},
				tooltip: {
					axisPointer: {
						trigger: 'item',
						type: 'cross'
					},
					formatter: this.axisTooltip,
					borderWidth: 1
				},
				xAxis: [
					{
						type: 'category',
						boundaryGap: false,
						data: [],
						axisLine: {
							onZero: false,
							lineStyle: {
								width: 2,
								color: '#d14a61'
							}
						},
						axisLabel: {
							formatter: this.xAxisLableFormat,
							textStyle: {
								color: '#333'
							}
						},
						axisPointer: {
							snap: true,
							label: {
								formatter: this.xAxisPointFormat,
								backgroundColor: 'rgb(255,0,0,0.5)',
								color: 'white'
							}
						}
					}
				],
				yAxis: {
					type: 'value',
					splitLine: {
						show: false
					},
					axisTick: {
						show: false
					},
					axisLine: {
						onZero: false,
						lineStyle: {
							width: 2,
							color: '#d14a61'
						}
					},
					axisLabel: {
						interval: 'auto',
						formatter: this.yAxisLableFormat
					},
					axisPointer: {
						xAxisIndex: 'all',
						label: {
							formatter: this.yAxisPointFormat,
							backgroundColor: 'rgb(0,100,0,0.5)',
							color: 'white'
						}
					},
					min: 0,
					max: 0
				},
				series: [],
				dataZoom: [
					{
						type: 'inside'
					},
					{
						fiterMode: 'filter',
						handleIcon: 'M10.7,11.9v-1.3H9.3v1.3c-4.9,0.3-8.8,4.4-8.8,9.4c0,5,3.9,9.1,8.8,9.4v1.3h1.3v-1.3c4.9-0.3,8.8-4.4,8.8-9.4C19.5,16.3,15.6,12.2,10.7,11.9z M13.3,24.4H6.7V23h6.6V24.4z M13.3,19.6H6.7v-1.4h6.6V19.6z',
						handleSize: '80%',
						handleStyle: {
							color: '#fff',
							shadowBlur: 3,
							shadowColor: 'rgba(0, 0, 0, 0.6)',
							shadowOffsetX: 2,
							shadowOffsetY: 2
						},
						bottom: '15px'
					}
				]
			},
			absoluteTime: 2 * 3600,
			indexKmRangeMap: {}
		};
	},
	computed: {
		...mapGetters('runPlan', [
			'stations'
		]),
		planId() {
			return this.$route.query.planId;
		}
	},
	watch: {
		maxWidth() {
			this.setPosition();
		},
		maxHeight() {
			this.setPosition();
		},
		'$store.state.runPlan.planSizeCount': function () {
			this.reSize({ width: this.$store.state.runPlan.width, height: this.$store.state.runPlan.height });
		},
		'$store.state.runPlan.selected.serviceNumber': function (val) {
			const index = this.serviceNumberConfig.data.findIndex(elem => {
				return elem.serviceNumber == val;
			});

			this.$refs.serviceTable.setCurrentRow(this.serviceNumberConfig.data[index]);
		},
		'$store.state.runPlan.selected.tripNumber': function (val) {
			const index = this.tripNumberConfig.data.findIndex(elem => {
				return elem.tripNumber == val;
			});
			this.$refs.tripTable.setCurrentRow(this.tripNumberConfig.data[index]);
		},
		'$store.state.runPlan.refreshCount': function() {
			this.loadChartPage();
		},
		$route() {
			this.loadChartPage();
		}
	},
	mounted() {
		this.loadChartPage();
	},
	beforeDestroy() {
		this.destroy();
	},
	methods: {
		serviceNumberChange(row) {
			let serviceNumber = null;
			let serviceObj = {};
			if (row) {
				serviceNumber = row.serviceNumber;
				serviceObj = this.$store.state.runPlan.editData[row.serviceNumber] || {};
			}

			this.$store.dispatch('runPlan/setSelected', { serviceNumber: serviceNumber, tripNumber: null });
			this.analyticalTripNumber(serviceObj.trainMap || {});
		},
		tripNumberChange(row) {
			const serviceNumber = this.$store.state.runPlan.selected.serviceNumber;
			let tripNumber = null;
			if (row) {
				tripNumber = row.tripNumber;
			}

			this.$store.dispatch('runPlan/setSelected', { serviceNumber: serviceNumber, tripNumber: tripNumber });
		},
		async analyticalServiceNumber(data) {
			this.serviceNumberConfig.data = Object.keys(data || {})
				.sort((a, b) => { return data[a].oldIndex - data[b].oldIndex; })
				.map(serviceNumber => { return { serviceNumber }; });
		},
		async analyticalTripNumber(data) {
			this.tripNumberConfig.data = Object.keys(data || {})
				.sort((a, b) => { return data[a].oldIndex - data[b].oldIndex; })
				.map(tripNumber => { return { tripNumber }; });
		},
		async setPosition() {
			this.$nextTick(() => {
				let top = 3;
				const width = this.maxWidth * 0.85;
				let height = this.maxHeight;

				const titleBar = document.getElementById('PlanTitleBar');
				const menuBar = document.getElementById('PlanMenuBar');
				const menuTool = document.getElementById('PlanMenuTool');
				const statusBar = document.getElementById('PlanStatusBar');

				if (titleBar) {
					top += (titleBar.offsetHeight || 0);
				}

				if (menuBar) {
					top += (menuBar.offsetHeight || 0);
				}

				if (menuTool) {
					top += (menuTool.offsetHeight || 0);
				}

				if (statusBar) {
					height -= (statusBar.offsetHeight || 0);
				}

				height = height - top;
				this.$store.dispatch('runPlan/resize', { width, height });

				if (this.top != top) {
					this.top = top;
				}

				if (this.height != height) {
					this.height = height - 20 * 2;
				}
			});
		},
		async loadChartPage() {
			try {
				this.PlanConvert = this.$theme.loadPlanConvert(this.skinCode);
				this.$store.dispatch('runPlan/clear').then(resp => {
					this.loadInitChart().then(() => {
						if (this.skinCode && this.planId) {
							this.myChart && this.myChart.showLoading();
							loadMapData(this.skinCode);
							getStationListBySkinStyle(this.skinCode).then(resp => {
								this.$store.dispatch('runPlan/setStations', resp.data).then(() => {
									queryRunPlan(this.planId).then(rest => {
										this.$store.dispatch('runPlan/setPlanData', rest.data).then(() => {
											this.analyticalServiceNumber(this.$store.state.runPlan.editData);
											this.loadChartData();
											this.myChart && this.myChart.hideLoading();
										});
									}).catch(() => {
										this.myChart && this.myChart.hideLoading();
										this.$messageBox('获取运行图数据失败');
									});
								});
							}).catch(() => {
								this.$messageBox('请求车站数据失败');
								this.$store.dispatch('runPlan/setStations', []);
								this.myChart && this.myChart.hideLoading();
							});
						}
					});
				});
			} catch (error) {
				this.$messageBox(`加载运行图数据失败`);
			}
		},
		async loadChartData() {
			try {
				const stations = this.$store.state.runPlan.stations;
				const planData = this.$store.state.runPlan.planData;

				this.viewDisabled = true;

				this.option.series = [];
				this.kmRangeCoordMap = this.PlanConvert.convertStationsToMap(stations);
				this.pushModels(this.option.series, [this.PlanConvert.initializeYaxis(stations)]);
				this.pushModels(this.option.series, this.PlanConvert.convertDataToModels(planData, stations, this.kmRangeCoordMap, { width: 0.5 }));
				await this.loadInitData();

				this.viewDisabled = false;
			} catch (error) {
				this.viewDisabled = false;
				this.$messageBox(`加在运行图数据失败：${error.message}`);
			}
		},
		async loadInitData() {
			await this.xAxisInit();
			await this.yAxisInit();
			await this.loadInitChart();
		},
		pushModels(series, models) {
			if (models && models.length) {
				models.forEach(elem => {
					if (elem) {
						series.push(elem);
					}
				});
			}

			return series;
		},
		popModels(series, models) {
			if (models && models.length) {
				models.forEach(elem => {
					const index = series.indexOf(elem);
					if (index >= 0) {
						series.split(index, 1);
					}
				});
			}

			return series;
		},
		loadInitChart() {
			return new Promise((resolve, reject) => {
				try {
					const that = this;
					// 加载echart配置
					require.config(
						{
							paths: {
								echarts: './js/dist'
							}
						}
					);
					// 按需加载所需图表，如需动态类型切换功能，别忘了同时加载相应图表
					require(
						[
							'echarts',
							'echarts/lib/chart/line'
						],
						function (ec) {
							if (that.myChart && that.myChart.isDisposed) {
								that.myChart.clear();
							}

							that.myChart = ec.init(document.getElementById(that.runPlanId));
							that.myChart.setOption(that.option);
							that.reSize({ width: that.$store.state.runPlan.width, height: that.$store.state.runPlan.height });
							that.myChart.on('click', that.mouseClick);
							resolve(true);
						}
					);
				} catch (error) {
					reject(error);
				}
			});
		},
		xAxisPointFormat(params) {
			return timeFormat(params.value);
		},
		yAxisPointFormat(params) {
			return this.PlanConvert.computedFormatYAxis(this.stations, params);
		},
		xAxisLableFormat(value, index) {
			if (value % 60 === 0) {
				return timeFormat(value);
			}
		},
		yAxisLableFormat(value, index) {
			return '';
		},
		xAxisInit() {
			const list = [];
			for (var time = 0 + this.PlanConvert.TranslationTime; time < 3600 * 24 + this.PlanConvert.TranslationTime; time++) {
				list.push(time);
			}

			const startValue = 3600 * 6;
			const offsetTime = 3600 * 1;

			this.option.xAxis[0].data = list;
			if (!this.option.dataZoom[0].startValue) {
				this.option.dataZoom[0].startValue = this.option.dataZoom[1].startValue = startValue - offsetTime;
			}

			if (!this.option.dataZoom[0].endValue) {
				this.option.dataZoom[0].endValue = this.option.dataZoom[1].endValue = startValue + offsetTime;
			}
		},
		yAxisInit() {
			if (Object.keys(this.PlanConvert).length) {
				this.option.yAxis.min = this.PlanConvert.computedYaxisMinValue(this.stations);
				this.option.yAxis.max = this.PlanConvert.computedYaxisMaxValue(this.stations);
			}
		},
		axisTooltip(param) {
			const station = this.stations[Math.floor((param.data[1] - this.PlanConvert.EdgeHeight) / this.PlanConvert.CoordMultiple)] || { name: '', kmRange: '' };
			return [
				`Point Data <hr size=1 style="margin: 3px 0">`,
				`车站名称: ${station.name}<br>`,
				`车站公里标: ${station.kmRange} km <br>`,
				`到站时间: ${timeFormat(param.data[0] + this.PlanConvert.TranslationTime)} (${param.data[0]})<br>`
			].join('');
		},
		mouseClick(params) {
			const model = {
				serviceNumber: params.seriesName
			};
			this.$store.dispatch('runPlan/setSelected', model);
		},
		reSize(opt) {
			if (this.myChart) {
				this.myChart.resize({
					width: opt.width,
					height: opt.height,
					silent: false
				});
			}
		},
		destroy() {
			if (this.myChart && this.myChart.isDisposed) {
				this.myChart.dispose();
				this.myChart = null;
			}
		},
		scheduleTouch() {

		},
		trainNumTouch() {

		}
	}
};
</script>
<style scoped rel="stylesheet/scss" lang="scss">
    @import "src/styles/mixin.scss";

    #PlanSchedule {
        z-index: 5;
        position: absolute;
        width: 100%;

        .left {
            height: 100%;
            width: 85%;
            float: left;
        }

        .right {
            height: 100%;
            width: 15%;
            float: right;
        }
    }
</style>