Merge remote-tracking branch 'origin/dev_dukang' into dev

# Conflicts:
#	src/scripts/cmdPlugin/CommandEnum.js
#	src/utils/baseUrl.js

src/api/chat.js

@@ -258,7 +258,7 @@ export function getRealDevices(group) {
 }
 
 // 获取房间真实设备连接关系
-export function getRealDevicesNew(group) {
+export function getRealDevicesInRoom(group) {
     return request({
         url: `/api/jointTraining/room/${group}/realDevice/connect`,
         method: 'get'
@@ -266,7 +266,7 @@ export function getRealDevicesNew(group) {
 }
 
 // 更新真实设备的连接关系
-export function updateRealDevicesNew(group, data) {
+export function updateRealDevices(group, data) {
     return request({
         url: `/api/jointTraining/room/${group}/realDevice`,
         method: 'put',

src/api/jointTraining.js

@@ -0,0 +1,248 @@
+import request from '@/utils/request';
+
+// 文字聊天 发送文字
+export function chatWithTextNew(data, group) {
+    return request({
+        url: `/api/v1/jointTraining/chatWithText?group=${group}`,
+        method: 'post',
+        data: {
+            message: data
+        }
+    });
+}
+
+// 生成分发二维码
+export function getJoinTrainCodeNew(data, group) {
+    return request({
+        url: `/api/v1/jointTraining/qrCode?group=${group}`,
+        method: 'post',
+        data: data
+    });
+}
+
+// 创建房间
+export function postCreateRoomNew(data) {
+    return request({
+        url: `/api/v1/jointTraining/room`,
+        method: 'post',
+        data: data
+    });
+}
+
+// 检查房间存在
+export function checkRoomExistNew(params) {
+    return request({
+        url: `/api/simulationRoom`,
+        method: 'get',
+        params
+    });
+}
+
+// 获取房间详情
+export function postRoomDetailNew(group) {
+    return request({
+        url: `/api/v1/jointTraining/room/${group}`,
+        method: 'get'
+    });
+}
+
+// 销毁房间
+export function deljointTrainRoomNew(group) {
+    return request({
+        url: `/api/v1/jointTraining/room`,
+        method: 'delete',
+        params: {
+            group: group
+        }
+    });
+}
+
+// 查询有权限房间列表
+export function getjointTrainListNew(params) {
+    return request({
+        url: `/api/v1/jointTraining/room/list`,
+        method: 'get',
+        params: params
+    });
+}
+
+// 加入房间
+export function getjointTrainingNew(group) {
+    return request({
+        url: `/api/v1/jointTraining/room/join`,
+        method: 'put',
+        params: {
+            group: group
+        }
+    });
+}
+
+// 设置人员角色
+export function putUserRolesNew(data, group) {
+    return request({
+        url: `/api/v1/jointTraining/room/user/role?group=${group}`,
+        method: 'put',
+        data: data
+    });
+}
+
+// 获取房间里的用户列表
+export function getJointTrainRoomUserListNew(group) {
+    return request({
+        url: `/api/v1/jointTraining/room/${group}/user/list`,
+        method: 'get'
+    });
+}
+
+// 离开房间接口
+export function putJointTrainingExitNew(group) {
+    return request({
+        url: `/api/v1/jointTraining/room/exit`,
+        method: 'put',
+        params: {
+            group: group
+        }
+    });
+}
+
+// 开始联合演练
+export function startJointTrainingNew(group) {
+    return request({
+        url: `/api/v1/jointTraining/room/simulation`,
+        method: 'post',
+        params: {
+            group: group
+        }
+    });
+}
+
+// 获取个人信息
+export function getUserRolesNew(group) {
+    return request({
+        url: `/api/v1/jointTraining/room/user/role`,
+        method: 'get',
+        params: {
+            group: group
+        }
+    });
+}
+
+// 返回房间
+export function putJointTrainingStateNew() {
+    return request({
+        url: `/api/v1/jointTraining/room/back`,
+        method: 'put'
+    });
+}
+
+// 踢出用户
+export function putJointTrainingUserkickedNew(userId, group) {
+    return request({
+        url: `/api/v1/jointTraining/room/user`,
+        method: 'put',
+        params: {
+            userId: userId,
+            group: group
+        }
+    });
+}
+
+// 管理员结束所有人的仿真
+export function putJointTrainingSimulationNew(group) {
+    return request({
+        url: `/api/v1/jointTraining/room/simulation/all`,
+        method: 'put',
+        params: {
+            group: group
+        }
+    });
+}
+
+// 结束仿真返回房间
+export function putJointTrainingSimulationUserNew(group) {
+    return request({
+        url: `/api/v1/jointTraining/room/simulation/user/exit`,
+        method: 'put',
+        params: {
+            group: group
+        }
+    });
+}
+
+// 进入仿真
+export function putJointTrainingSimulationEntranceNew(group) {
+    return request({
+        url: `/api/v1/jointTraining/room/simulation/user/entrance`,
+        method: 'put',
+        params: {
+            group: group
+        }
+    });
+}
+
+/**
+ * 权限获取(房间权限)
+ */
+export function getPermissionJointNew(group) {
+    return request({
+        url: '/api/v1/jointTraining/qrCode',
+        method: 'get',
+        params: {
+            group: group
+        }
+    });
+}
+
+// 添加或更新真实设备和仿真对象连接
+export function setRealDeviceNew(group, data) {
+    return request({
+        url: `/api/v1/jointTraining/room/realDevice?group=${group}`,
+        method: 'post',
+        data: data
+    });
+}
+
+// 删除真实设备和仿真对象连接
+export function delRealDeviceNew(id, group) {
+    return request({
+        url: `/api/v1/jointTraining/room/realDevice/${id}`,
+        method: 'delete',
+        params: { group: group }
+    });
+}
+
+// 获取真实设备列表
+export function getRealDevicesNew(group) {
+    return request({
+        url: `/api/v1/jointTraining/room/${group}/devices`,
+        method: 'get'
+    });
+}
+
+// 获取房间真实设备连接关系
+export function getRealDevicesInRoomNew(group) {
+    return request({
+        url: `/api/v1/jointTraining/room/${group}/realDevice/connect`,
+        method: 'get'
+    });
+}
+
+// 更新真实设备的连接关系
+export function updateRealDevicesNew(group, data) {
+    return request({
+        url: `/api/v1/jointTraining/room/${group}/realDevice`,
+        method: 'put',
+        data: data
+    });
+}
+
+// 真实设备是否被其他仿真使用
+export function realDeviceIsUsedNew(group, projectCode) {
+    return request({
+        url: `/api/v1/jointTraining/room/${group}/realDeviceUsed`,
+        method: 'get',
+        params: {
+            projectCode: projectCode
+        }
+    });
+}

src/jmapNew/theme/chengdu_01/planSchedule/schedule.vue

@@ -25,7 +25,6 @@
 <script>
 import { mapGetters } from 'vuex';
 import { timeFormat } from '@/utils/date';
-import { runDiagramGetTime } from '@/api/simulation';
 import DataTable from '../menusPlan/components/dataTable';
 import echarts from 'echarts';
 

src/layout/components/Qcode.vue

@@ -1,6 +1,7 @@
 <template>
   <el-dialog v-dialogDrag :title="$t('global.chooseRoom')" :visible.sync="dialogShow" width="30%" center>
     <el-input v-model="input" :placeholder="$t('global.inputRoomNumber')" />
+    <el-checkbox v-model="isNewMap">是否新版地图房间</el-checkbox>
     <span slot="footer" class="dialog-footer">
       <el-button @click="dialogShow = false">{{ $t('global.cancel') }}</el-button>
       <el-button v-loading="loading" :disabled="!input.length" type="primary" @click="comit">{{ $t('global.confirm') }}</el-button>
@@ -10,6 +11,7 @@
 
 <script>
 import { getPermissionJoint } from '@/api/chat';
+import { getPermissionJointNew } from '@/api/jointTraining';
 
 export default {
     name: 'Dashboard',
@@ -17,7 +19,8 @@ export default {
         return {
             input: '',
             dialogShow: false,
-            loading: false
+            loading: false,
+            isNewMap: false
         };
     },
     computed: {
@@ -35,7 +38,11 @@ export default {
         async comit() {
             try {
                 this.loading = true;
-                await getPermissionJoint(`${this.input}`);
+                if (this.isNewMap) {
+                    await getPermissionJointNew(`${this.input}`);
+                } else {
+                    await getPermissionJoint(`${this.input}`);
+                }
                 this.dialogShow = false;
             } catch (error) {
                 this.$messageBox(`${this.$t('error.scanningError')}:${error.message}`);

src/router/index.js

@@ -19,6 +19,7 @@ const DesignDisplay = () => import('@/views/display/designIndex');
 
 const TrainRoom = () => import('@/views/trainRoom/index');
 const JointTraining = () => import('@/views/jointTraining/index');
+const JointTrainingNew = () => import('@/views/newMap/jointTrainingNew/index');
 
 const Error401 = () => import('@/views/error-page/401');
 const Errpr404 = () => import('@/views/error-page/404');
@@ -544,7 +545,7 @@ export const asyncRouter = [
     },
     {
         path: '/jointTrainingNew',
-        component: JointTraining,
+        component: JointTrainingNew,
         hidden: true
     },
     {

src/store/modules/runplan.js

@@ -13,7 +13,7 @@ const runPlan = {
         width: 800, 			// 运行图canvas 容器 宽度
         height: 600, 			// 运行图canvas 容器 高度
         refreshCount: 0,			// 刷新页面重新加载
-        setInitialPlanData: {} // 运行图原始数据
+        initialPlanData: {} // 运行图原始数据
     },
     getters: {
         stations: (state) => {

src/views/demonstration/deomonList/index.vue

@@ -40,6 +40,7 @@
 
 <script>
 import { getjointTrainList, getjointTraining, putJointTrainingSimulationEntrance } from '@/api/chat';
+import { getjointTrainListNew, putJointTrainingSimulationEntranceNew, getjointTrainingNew } from '@/api/jointTraining';
 import { getSessionStorage } from '@/utils/auth';
 import { getPublishMapInfo } from '@/api/jmap/map';
 import { launchFullscreen } from '@/utils/screen';
@@ -93,7 +94,10 @@ export default {
                 this.loading = false;
                 const project = getSessionStorage('project');
                 const res = await getjointTrainList({projectCode:ProjectCode[project]});
-                this.trainingList = res.data || [];
+                const resp = await getjointTrainListNew({projectCode: ProjectCode[project]});
+                const oldMapRoomList = res.data || [];
+                const newMapRoomList = resp.data || [];
+                this.trainingList = [...oldMapRoomList, ...newMapRoomList];
                 this.$nextTick(() => {
                     var training = this.trainingList[0] || {};
                     if (training) {
@@ -115,15 +119,25 @@ export default {
         async handleJoin() {
             try {
                 this.loading = true;
-                await getjointTraining(this.group);
+                const rest = await getPublishMapInfo(this.mapId);
+                const drawWay = rest.data.drawWay;
+                if (drawWay) {
+                    await getjointTrainingNew(this.group);
+                } else {
+                    await getjointTraining(this.group);
+                }
                 if (this.state == '02') {
                     launchFullscreen();
-                    await putJointTrainingSimulationEntrance(this.group);
+                    const query = { lineCode: rest.data.lineCode, mapId: this.mapId, group: this.group, drawWay: drawWay };
-                    const rest = await getPublishMapInfo(this.mapId);
+                    if (drawWay) {
-                    const query = { lineCode: rest.data.lineCode, mapId: this.mapId, group: this.group };
+                        await putJointTrainingSimulationEntranceNew(this.group);
-                    this.$router.push({ path: `/jointTraining`, query: query });
+                        this.$router.push({ path: `/jointTrainingNew`, query: query });
+                    } else {
+                        await putJointTrainingSimulationEntrance(this.group);
+                        this.$router.push({ path: `/jointTraining`, query: query });
+                    }
                 } else if (this.state == '01') {
-                    const query = { group: this.group };
+                    const query = { group: this.group, drawWay: drawWay };
                     this.$router.push({ path: `/trainroom`, query: query });
                 }
             } catch (e) {

src/views/demonstration/deomonTopic/index.vue

@@ -19,6 +19,7 @@
 
 <script>
 import { getjointTraining, putJointTrainingSimulationEntrance } from '@/api/chat';
+import { getjointTrainingNew, putJointTrainingSimulationEntranceNew} from '@/api/jointTraining';
 import { getPublishMapInfo } from '@/api/jmap/map';
 import { launchFullscreen } from '@/utils/screen';
 
@@ -59,18 +60,27 @@ export default {
         async handleJoin() {
             try {
                 this.loading = true;
+                const rest = await getPublishMapInfo(this.mapId);
+                const drawWay = rest.data.drawWay;
                 if (this.state == '02') {
                     launchFullscreen();
-                    await putJointTrainingSimulationEntrance(this.group);
+                    if (drawWay) {
-                    const rest = await getPublishMapInfo(this.mapId);
+                        await putJointTrainingSimulationEntranceNew(this.group);
-                    const query = { lineCode: rest.data.lineCode, mapId: this.mapId, group: this.group };
+                    } else {
+                        await putJointTrainingSimulationEntrance(this.group);
+                    }
+                    const query = { lineCode: rest.data.lineCode, mapId: this.mapId, group: this.group, drawWay: drawWay };
                     this.$router.push({ path: `/jointTraining`, query: query });
                 } else if (this.state == '01') {
-                    const query = { group: this.group };
+                    const query = { group: this.group, drawWay: drawWay };
                     this.$router.push({ path: `/trainroom`, query: query });
                 }
                 this.dialogShow = false;
-                await getjointTraining(this.group);
+                if (rest.drawWay) {
+                    await getjointTrainingNew(this.group);
+                } else {
+                    await getjointTraining(this.group);
+                }
             } catch (e) {
                 console.error(e);
             } finally {

src/views/demonstration/detail/index.vue

@@ -28,7 +28,8 @@ import { getPublishMapInfo } from '@/api/jmap/map';
 import { getGoodsTryUse } from '@/api/management/goods';
 import { PermissionType } from '@/scripts/ConstDic';
 import { launchFullscreen } from '@/utils/screen';
-import { postCreateRoom, getjointTraining, checkRoomExist } from '@/api/chat';
+import { postCreateRoom, getjointTraining } from '@/api/chat';
+import { postCreateRoomNew, getjointTrainingNew, checkRoomExistNew } from '@/api/jointTraining';
 import { UrlConfig } from '@/router/index';
 import { simulationNotify, schedulingNotify, createSimulationNew } from '@/api/simulation';
 import LimitList from '@/views/components/limits/index';
@@ -158,7 +159,7 @@ export default {
         async getJointTrainingList() {
             try {
                 if (this.mapId) {
-                    const res = await checkRoomExist({ mapId: this.mapId });
+                    const res = await checkRoomExistNew({mapId: this.mapId});
                     this.jointGroup = res.data;
                     this.jointShow = false;
                     if (res.data) {
@@ -171,7 +172,11 @@ export default {
         },
         async joinRoom() {
             this.disabled = true;
-            await getjointTraining(this.jointGroup);
+            if (this.drawWay) {
+                await getjointTrainingNew(this.jointGroup);
+            } else {
+                await getjointTraining(this.jointGroup);
+            }
             this.$store.dispatch('socket/setInRoom', true);
             const query = { lineCode: this.courseModel.lineCode, group: this.jointGroup, drawWay: this.drawWay};
             this.$router.push({ path: `/trainroom`, query: query });
@@ -183,7 +188,12 @@ export default {
                     mapId: Number(this.mapId),
                     prdType: this.courseModel.prdType
                 };
-                const res = await postCreateRoom(param);
+                let res = '';
+                if (this.drawWay) {
+                    res = postCreateRoomNew(param);
+                } else {
+                    res = await postCreateRoom(param);
+                }
                 if (res && res.code == 200) {
                     const query = { lineCode: this.courseModel.lineCode, group: res.data, drawWay: this.drawWay };
                     this.$router.push({ path: `/trainroom`, query: query });

src/views/ibp/ibpsystem/index.vue

@@ -13,6 +13,7 @@ import { parser } from '@/ibp/utils/parser';
 import { mapGetters } from 'vuex';
 import { exitFullscreen } from '@/utils/screen';
 import { putJointTrainingSimulationUser } from '@/api/chat';
+import { putJointTrainingSimulationUserNew} from '@/api/jointTraining';
 import { handlerIbpEvent } from '@/api/simulation';
 import { IbpOperation } from '@/scripts/ConstDic';
 import { getIbpInfoByStation } from '@/api/ibp';
@@ -59,6 +60,9 @@ export default {
         ]),
         ibpId() {
             return ['ibp', (Math.random().toFixed(5)) * 100000].join('_');
+        },
+        drawWay() {
+            return this.$route.query.drawWay;
         }
     },
     watch: {
@@ -237,10 +241,17 @@ export default {
         back() {
             this.group = this.$route.query.group;
             this.$store.dispatch('training/over').then(() => {
-                putJointTrainingSimulationUser(this.group).then(() => {
+                if (this.drawWay) {
-                    this.$router.replace({ path: `/trainroom`, query: { group: this.group, lineCode:this.$route.query.lineCode } });
+                    putJointTrainingSimulationUserNew(this.group).then(() => {
-                    exitFullscreen();
+                        this.$router.replace({ path: `/trainroom`, query: { group: this.group, lineCode:this.$route.query.lineCode, drawWay: this.drawWay } });
-                });
+                        exitFullscreen();
+                    });
+                } else {
+                    putJointTrainingSimulationUser(this.group).then(() => {
+                        this.$router.replace({ path: `/trainroom`, query: { group: this.group, lineCode:this.$route.query.lineCode } });
+                        exitFullscreen();
+                    });
+                }
             });
         },
         ibpDestroy() {

src/views/iscs/iscsSystem/config/canvas/iscsCanvas.vue

@@ -1,7 +1,6 @@
 <template>
   <div style="width: 100%; height: 100%;">
     <div :id="iscsId" v-loading="loading" :style="{ width: widthCanvas +'px', height: canvasHeight +'px' }" class="iscs-canvas" />
-    <!-- <el-button v-if="showBackButton" class="iscs-button" type="primary" @click="back">{{ $t('global.back') }}</el-button> -->
   </div>
 </template>
 
@@ -12,7 +11,6 @@ import { parser } from '@/iscs/utils/parser';
 import iscsData from '@/iscs/constant/iscsData';
 import { mapGetters } from 'vuex';
 import { exitFullscreen } from '@/utils/screen';
-import { putJointTrainingSimulationUser } from '@/api/chat';
 import { handlerIscsEvent } from '@/api/simulation';
 import { IscsOperation } from '@/scripts/ConstDic';
 
@@ -176,15 +174,6 @@ export default {
                 // this.$iscs && this.$iscs.resize({ width: this.width, height: this.height });
             });
         },
-        back() {
-            this.group = this.$route.query.group;
-            this.$store.dispatch('training/over').then(() => {
-                putJointTrainingSimulationUser(this.group).then(() => {
-                    this.$router.replace({ path: `/trainroom`, query: { group: this.group, lineCode:this.$route.query.lineCode } });
-                    exitFullscreen();
-                });
-            });
-        },
         iscsDestroy() {
             if (this.$iscs) {
                 this.$iscs.dispose();

src/views/iscsSystem/index.vue

@@ -13,6 +13,7 @@ import iscsData from '@/iscs/constant/iscsData';
 import { mapGetters } from 'vuex';
 import { exitFullscreen } from '@/utils/screen';
 import { putJointTrainingSimulationUser } from '@/api/chat';
+import { putJointTrainingSimulationUserNew} from '@/api/jointTraining';
 import { handlerIscsEvent } from '@/api/simulation';
 import { IscsOperation } from '@/scripts/ConstDic';
 
@@ -57,6 +58,9 @@ export default {
         iscsId() {
             return ['iscs', (Math.random().toFixed(5)) * 100000].join('_');
         },
+        drawWay() {
+            return this.$route.query.drawWay;
+        },
         width() {
             return this.$store.state.config.width;
         },
@@ -171,10 +175,17 @@ export default {
         back() {
             this.group = this.$route.query.group;
             this.$store.dispatch('training/over').then(() => {
-                putJointTrainingSimulationUser(this.group).then(() => {
+                if (this.drawWay) {
-                    this.$router.replace({ path: `/trainroom`, query: { group: this.group, lineCode:this.$route.query.lineCode } });
+                    putJointTrainingSimulationUserNew(this.group).then(() => {
-                    exitFullscreen();
+                        this.$router.replace({ path: `/trainroom`, query: { group: this.group, lineCode:this.$route.query.lineCode, drawWay: this.drawWay } });
-                });
+                        exitFullscreen();
+                    });
+                } else {
+                    putJointTrainingSimulationUser(this.group).then(() => {
+                        this.$router.replace({ path: `/trainroom`, query: { group: this.group, lineCode:this.$route.query.lineCode } });
+                        exitFullscreen();
+                    });
+                }
             });
         },
         iscsDestroy() {

src/views/jointTraining/menuDraft/realDevice.vue

@@ -83,7 +83,7 @@
 </template>
 
 <script>
-import { getRealDevicesNew, updateRealDevicesNew, realDeviceIsUsed } from '@/api/chat';
+import { getRealDevicesInRoom, updateRealDevices, realDeviceIsUsed } from '@/api/chat';
 import { hasDoorStationList } from '@/api/jmap/map';
 import {getAllDeviceInProject} from '@/api/project';
 import { mapGetters } from 'vuex';
@@ -179,7 +179,7 @@ export default {
             this.projectCode = getSessionStorage('project').toUpperCase();
             this.getDoorList(this.$route.query.mapId, this.stationList);
             getAllDeviceInProject({projectCode: this.projectCode, group:this.$route.query.group}).then(resp => {
-                getRealDevicesNew(this.$route.query.group).then(res => {
+                getRealDevicesInRoom(this.$route.query.group).then(res => {
                     resp.data.forEach((it, index) => {
                         this.options.push({
                             deviceCode: '',
@@ -235,7 +235,7 @@ export default {
                     paramsList.push(item);
                 }
             });
-            updateRealDevicesNew(this.$route.query.group, paramsList).then(res => {
+            updateRealDevices(this.$route.query.group, paramsList).then(res => {
                 this.$message.success(this.$t('tip.updateRealDeviceConnectionSuccess'));
                 this.doClose();
             }).catch(() => {

src/views/newMap/displayNew/demon/runPlanView.vue

@@ -1,110 +1,79 @@
 <template>
-    <el-dialog
+  <el-dialog
-        v-dialogDrag
+    v-dialogDrag
-        v-dialogLoading="dialogLoading"
+    v-dialogLoading="dialogLoading"
-        :title="title"
+    :title="title"
-        :visible.sync="dialogShow"
+    :visible.sync="dialogShow"
-        width="100%"
+    width="100%"
-        :before-close="doClose"
+    :before-close="doClose"
-        :close-on-click-modal="false"
+    :close-on-click-modal="false"
-        :modal="false"
+    :modal="false"
-        fullscreen
+    fullscreen
-    >
+  >
-        <div :id="runPlanId" v-loading="loading" />
+    <div :id="runPlanId" v-loading="loading" />
-    </el-dialog>
+  </el-dialog>
 </template>
 
 <script>
-    import { mapGetters } from 'vuex';
+import { mapGetters } from 'vuex';
-    import { getPublishMapInfo } from '@/api/jmap/map';
+import { getPublishMapInfo } from '@/api/jmap/map';
-    import { timeFormat } from '@/utils/date';
+import { timeFormat } from '@/utils/date';
-    import echarts from 'echarts';
+import echarts from 'echarts';
-    import {toTimeStamp, formatDuring} from '@/utils/date';
+import {toTimeStamp, formatDuring} from '@/utils/date';
 
-    // 运行图预览
+// 运行图预览
-    export default {
+export default {
-        name: 'RunPlanView',
+    name: 'RunPlanView',
-        props: {
+    props: {
-            group: {
+        group: {
-                type: String,
+            type: String,
-                required: true
+            required: true
-            }
+        }
-        },
+    },
-        data() {
+    data() {
-            return {
+        return {
-                dialogShow: false,
+            dialogShow: false,
-                loading: true,
+            loading: true,
-                runPlanId: 'run-plan-view',
+            runPlanId: 'run-plan-view',
-                myChart: null,
+            myChart: null,
-                PlanConvert: {},
+            PlanConvert: {},
-                series: [],
+            series: [],
-                option: {
+            option: {
-                    title: {
+                title: {
-                        text: '',
+                    text: '',
-                        left: 'center'
+                    left: 'center'
+                },
+                grid: {
+                    top: '30px',
+                    left: '120px',
+                    right: '40px',
+                    bottom: '80px',
+                    containLabel: true,
+                    backgroundColor: 'floralwhite'
+                },
+                toolbox: {
+                    // right: '20px',
+                    // feature: {
+                    //     dataZoom: {
+                    //         yAxisIndex: 'none'
+                    //     },
+                    //     restore: {},
+                    //     saveAsImage: {}
+                    // }
+                },
+                tooltip: {
+                    axisPointer: {
+                        trigger: 'item',
+                        type: 'cross'
                     },
-                    grid: {
+                    formatter: this.axisTooltip,
-                        top: '30px',
+                    borderWidth: 1
-                        left: '120px',
+                },
-                        right: '40px',
+                xAxis: [
-                        bottom: '80px',
+                    {
-                        containLabel: true,
+                        type: 'category',
-                        backgroundColor: 'floralwhite'
+                        boundaryGap: false,
-                    },
+                        data: [],
-                    toolbox: {
-                        // right: '20px',
-                        // 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: {
@@ -113,255 +82,286 @@
                             }
                         },
                         axisLabel: {
-                            interval: 'auto',
+                            formatter: this.xAxisLableFormat,
-                            formatter: this.yAxisLableFormat
+                            textStyle: {
-                        },
+                                color: '#333'
-                        axisPointer: {
-                            xAxisIndex: 'all',
-                            label: {
-                                formatter: this.yAxisPointFormat,
-                                backgroundColor: 'rgb(0,100,0,0.5)',
-                                color: 'white'
                             }
                         },
-                        min: 0,
+                        axisPointer: {
-                        max: 0
+                            snap: true,
-                    },
+                            label: {
-                    // graphic: {
+                                formatter: this.xAxisPointFormat,
-                    // 	type: 'line',
+                                backgroundColor: 'rgb(255,0,0,0.5)',
-                    // 	progressive: true
+                                color: 'white'
-                    // },
+                            }
-                    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: '25px'
                         }
-                    ]
-                },
-                absoluteTime: 2 * 3600,
-                indexKmRangeMap: {},
-                runPlanData: {},
-                dialogLoading: false,
-                initialPlanData: []
-            };
-        },
-        computed: {
-            ...mapGetters('runPlan', [
-                'stations'
-            ]),
-            title() {
-                return this.$t('display.runPlan.previewRunDiagram');
-            }
-        },
-        watch: {
-            '$store.state.runPlan.planLoadedCount': async function () {
-                try {
-                    await this.loadChartPage();
-                    if (this.dialogShow) {
-                        await this.loadInitData(this.series);
                     }
-                } catch (e) {
+                ],
-                    console.error(e);
+                yAxis: {
-                } finally {
+                    type: 'value',
-                    this.loading = false;
+                    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
+                },
+                // graphic: {
+                // 	type: 'line',
+                // 	progressive: true
+                // },
+                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: '25px'
+                    }
+                ]
+            },
+            absoluteTime: 2 * 3600,
+            indexKmRangeMap: {},
+            runPlanData: {},
+            dialogLoading: false,
+            initialPlanData: []
+        };
+    },
+    computed: {
+        ...mapGetters('runPlan', [
+            'stations'
+        ]),
+        title() {
+            return this.$t('display.runPlan.previewRunDiagram');
+        }
+    },
+    watch: {
+        '$store.state.runPlan.planLoadedCount': async function () {
+            try {
+                await this.loadChartPage();
+                if (this.dialogShow) {
+                    await this.loadInitData(this.series);
                 }
-            },
+            } catch (e) {
-            '$store.state.runPlan.planUpdateCount': function () {
+                console.error(e);
-                this.updateRunPlanData(this.$store.state.runPlan.updateData);
+            } finally {
-            },
+                this.loading = false;
-            '$store.state.app.windowSizeCount': function() {
-                this.reSize({ width: this.$store.state.app.width, height: this.$store.state.app.height - 55 });
             }
         },
-        mounted() {
+        '$store.state.runPlan.planUpdateCount': function () {
-            getPublishMapInfo(this.$route.query.mapId).then(res=>{
+            this.updateRunPlanData(this.$store.state.runPlan.updateData);
-                this.PlanConvert = this.$theme.loadPlanConvert(res.data.lineCode);
+        },
-                this.initialPlanData = this.$store.state.runPlan.planData;
+        '$store.state.app.windowSizeCount': function() {
-                this.loadChartPage();
+            this.reSize({ width: this.$store.state.app.width, height: this.$store.state.app.height - 55 });
+        }
+    },
+    mounted() {
+        getPublishMapInfo(this.$route.query.mapId).then(res=>{
+            this.PlanConvert = this.$theme.loadPlanConvert(res.data.lineCode);
+            this.initialPlanData = this.$store.state.runPlan.planData;
+            this.loadChartPage();
+        });
+    },
+    beforeDestroy() {
+        if (this.myChart && this.myChart.isDisposed) {
+            this.myChart.dispose();
+            this.myChart = null;
+        }
+    },
+    methods: {
+        async  doShow() {
+            try {
+                this.dialogLoading = true;
+                this.dialogShow = true;
+                this.loadInitData(this.series);
+            } catch (e) {
+                console.error(e);
+            } finally {
+                this.dialogLoading = false;
+            }
+        },
+        async doClose() {
+            this.dialogShow = false;
+        },
+        async loadChartPage() {
+            const stations = this.$store.state.runPlan.stations;
+            const planData = this.$store.state.runPlan.planData;
+            this.series = [];
+            this.kmRangeCoordMap = this.PlanConvert.convertStationsToMap(stations);
+            this.pushModels(this.series, [this.PlanConvert.initializeYaxis(stations)]);
+            this.pushModels(this.series, this.PlanConvert.convertDataToModels(planData, stations, this.kmRangeCoordMap, { width: 1, color: '#000' }));
+        },
+        async loadInitData(series) {
+            this.myChart && this.myChart.showLoading();
+            await this.xAxisInit();
+            await this.yAxisInit();
+            await this.loadInitChart(series);
+            this.myChart && this.myChart.hideLoading();
+        },
+        loadInitChart(series) {
+            return new Promise((resolve, reject) => {
+                try {
+                    if (this.myChart && this.myChart.isDisposed) {
+                        this.myChart.clear();
+                    }
+                    let startValue = 3600 + this.PlanConvert.TranslationTime;
+                    const offsetTime = 3600;
+                    const initTime = toTimeStamp(formatDuring(this.$store.state.training.initTime));
+                    startValue = initTime - this.PlanConvert.TranslationTime;
+                    this.option.dataZoom[0].startValue = this.option.dataZoom[1].startValue = startValue - offsetTime;
+                    this.option.dataZoom[0].endValue = this.option.dataZoom[1].endValue = startValue + offsetTime;
+                    this.option.series = series;
+                    this.myChart = echarts.init(document.getElementById(this.runPlanId));
+                    if (this.myChart) {
+                        this.myChart.setOption(this.option);
+                        this.reSize({ width: document.documentElement.clientWidth - 10, height: document.documentElement.clientHeight - 55 });
+                        this.myChart.on('click', this.mouseClick);
+                    }
+                    resolve(true);
+                } catch (error) {
+                    reject(error);
+                }
             });
         },
-        beforeDestroy() {
+        updateRunPlanData(data) {
-            if (this.myChart && this.myChart.isDisposed) {
+            const stations = this.$store.state.runPlan.stations;
-                this.myChart.dispose();
+            const planData = this.$store.state.runPlan.planData;
-                this.myChart = null;
+            const initialPlanData = this.$store.state.runPlan.initialPlanData;
-            }
+            if (data[0] && initialPlanData[data[0].serviceNumber]) {
-        },
+                Object.keys(initialPlanData[data[0].serviceNumber].trainMap).forEach(item => {
-        methods: {
+                    if (initialPlanData[data[0].serviceNumber].trainMap[item + ''].tripNumber == data[0].tripNumber) {
-            async  doShow() {
+                        data[0].directionCode = initialPlanData[data[0].serviceNumber].trainMap[item + ''].directionCode;
-                try {
-                    this.dialogLoading = true;
-                    this.dialogShow = true;
-                    this.loadInitData(this.series);
-                } catch (e) {
-                    console.error(e);
-                } finally {
-                    this.dialogLoading = false;
-                }
-            },
-            async doClose() {
-                this.dialogShow = false;
-            },
-            async loadChartPage() {
-                const stations = this.$store.state.runPlan.stations;
-                const planData = this.$store.state.runPlan.planData;
-                this.series = [];
-                this.kmRangeCoordMap = this.PlanConvert.convertStationsToMap(stations);
-                this.pushModels(this.series, [this.PlanConvert.initializeYaxis(stations)]);
-                this.pushModels(this.series, this.PlanConvert.convertDataToModels(planData, stations, this.kmRangeCoordMap, { width: 1, color: '#000' }));
-            },
-            async loadInitData(series) {
-                this.myChart && this.myChart.showLoading();
-                await this.xAxisInit();
-                await this.yAxisInit();
-                await this.loadInitChart(series);
-                this.myChart && this.myChart.hideLoading();
-            },
-            loadInitChart(series) {
-                return new Promise((resolve, reject) => {
-                    try {
-                        if (this.myChart && this.myChart.isDisposed) {
-                            this.myChart.clear();
-                        }
-                        let startValue = 3600 + this.PlanConvert.TranslationTime;
-                        const offsetTime = 3600;
-                        const initTime = toTimeStamp(formatDuring(this.$store.state.training.initTime));
-                        startValue = initTime - this.PlanConvert.TranslationTime;
-                        this.option.dataZoom[0].startValue = this.option.dataZoom[1].startValue = startValue - offsetTime;
-                        this.option.dataZoom[0].endValue = this.option.dataZoom[1].endValue = startValue + offsetTime;
-                        this.option.series = series;
-                        this.myChart = echarts.init(document.getElementById(this.runPlanId));
-                        if (this.myChart) {
-                            this.myChart.setOption(this.option);
-                            this.reSize({ width: document.documentElement.clientWidth -10, height: document.documentElement.clientHeight - 55 });
-                            this.myChart.on('click', this.mouseClick);
-                        }
-                        resolve(true);
-                    } catch (error) {
-                        reject(error);
                     }
                 });
-            },
+            }
-            updateRunPlanData(data) {
+            if (data[0]) {
-                const stations = this.$store.state.runPlan.stations;
+                data[0].secondTime = data[0].second;
-                const planData = this.$store.state.runPlan.planData;
+            }
-                const initialPlanData = this.$store.state.runPlan.initialPlanData;
+            this.series = this.PlanConvert.updateDataToModels(data, stations, this.kmRangeCoordMap,
-                if (data[0] && initialPlanData[data[0].serviceNumber]) {
+                planData, this.series, { color: '#FF00DE', width: 0.5 }
-                    Object.keys(initialPlanData[data[0].serviceNumber].trainMap).forEach(item => {
+            );
-                        if (initialPlanData[data[0].serviceNumber].trainMap[item+''].tripNumber == data[0].tripNumber) {
+            this.myChart && this.myChart.setOption({ series: this.series });
-                            data[0].directionCode =  initialPlanData[data[0].serviceNumber].trainMap[item + ''].directionCode;
+        },
-                        }
+        pushModels(series, models) {
-                    });
+            if (models && models.length) {
-                }
+                models.forEach(elem => {
-                if (data[0]) {
+                    if (elem) {
-                    data[0].secondTime = data[0].second;
+                        series.push(elem);
-                }
+                    }
-                this.series = this.PlanConvert.updateDataToModels(data, stations, this.kmRangeCoordMap,
-                    planData, this.series, { color: '#FF00DE', width: 0.5 }
-                );
-                this.myChart && this.myChart.setOption({ series: this.series });
-            },
-            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;
-            },
-            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 = this.PlanConvert.TranslationTime; time < 3600 * 24 + this.PlanConvert.TranslationTime; time++) {
-                    list.push(time);
-                }
-                this.option.xAxis[0].data = list;
-            },
-            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">`,
-                    `${this.$t('display.runPlan.stationName')}: ${station.name}<br>`,
-                    `${this.$t('display.runPlan.stationMark')}: ${station.kmRange} km <br>`,
-                    `${this.$t('display.runPlan.arrivalTime')}: ${timeFormat(param.data[0] + this.PlanConvert.TranslationTime)} (${param.data[0]})<br>`
-                ].join('');
-            },
-            settingExac(data) {
-                this.absoluteTime = Math.abs(parseInt(data.endValue) - parseInt(data.startValue)) / 1000;
-                this.myChart && this.myChart.setOption({
-                    xAxis: this.option.xAxis,
-                    yAxis: this.option.yAxis
                 });
+            }
 
-                this.myChart && this.myChart.dispatchAction({
+            return series;
-                    type: 'dataZoom',
+        },
-                    dataZoomIndex: [0, 1],
+        popModels(series, models) {
-                    startValue: parseInt(data.startValue / 1000),
+            if (models && models.length) {
-                    endValue: parseInt(data.endValue / 1000)
+                models.forEach(elem => {
+                    const index = series.indexOf(elem);
+                    if (index >= 0) {
+                        series.split(index, 1);
+                    }
                 });
-            },
+            }
-            run(start) {
+
-                this.myChart && this.myChart.dispatchAction({
+            return series;
-                    type: 'dataZoom',
+        },
-                    dataZoomIndex: [0, 1],
+        xAxisPointFormat(params) {
-                    startValue: parseInt(start - this.absoluteTime / 2),
+            return timeFormat(params.value);
-                    endValue: parseInt(start + this.absoluteTime / 2)
+        },
-                });
+        yAxisPointFormat(params) {
-                this.loadInitData(this.series);
+            return this.PlanConvert.computedFormatYAxis(this.stations, params);
-            },
+        },
-            reSize(opt) {
+        xAxisLableFormat(value, index) {
-                if (this.myChart) {
+            if (value % 60 === 0) {
-                    this.myChart.resize({ width: opt.width, height: opt.height, silent: false });
+                return timeFormat(value);
-                }
+            }
+        },
+        yAxisLableFormat(value, index) {
+            return '';
+        },
+        xAxisInit() {
+            const list = [];
+            for (var time = this.PlanConvert.TranslationTime; time < 3600 * 24 + this.PlanConvert.TranslationTime; time++) {
+                list.push(time);
+            }
+            this.option.xAxis[0].data = list;
+        },
+        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">`,
+                `${this.$t('display.runPlan.stationName')}: ${station.name}<br>`,
+                `${this.$t('display.runPlan.stationMark')}: ${station.kmRange} km <br>`,
+                `${this.$t('display.runPlan.arrivalTime')}: ${timeFormat(param.data[0] + this.PlanConvert.TranslationTime)} (${param.data[0]})<br>`
+            ].join('');
+        },
+        settingExac(data) {
+            this.absoluteTime = Math.abs(parseInt(data.endValue) - parseInt(data.startValue)) / 1000;
+            this.myChart && this.myChart.setOption({
+                xAxis: this.option.xAxis,
+                yAxis: this.option.yAxis
+            });
+
+            this.myChart && this.myChart.dispatchAction({
+                type: 'dataZoom',
+                dataZoomIndex: [0, 1],
+                startValue: parseInt(data.startValue / 1000),
+                endValue: parseInt(data.endValue / 1000)
+            });
+        },
+        run(start) {
+            this.myChart && this.myChart.dispatchAction({
+                type: 'dataZoom',
+                dataZoomIndex: [0, 1],
+                startValue: parseInt(start - this.absoluteTime / 2),
+                endValue: parseInt(start + this.absoluteTime / 2)
+            });
+            this.loadInitData(this.series);
+        },
+        reSize(opt) {
+            if (this.myChart) {
+                this.myChart.resize({ width: opt.width, height: opt.height, silent: false });
             }
         }
-    };
+    }
+};
 </script>
 <style scoped rel="stylesheet/scss" lang="scss">
     /deep/ {

src/views/newMap/displayNew/menuScript.vue

@@ -20,7 +20,7 @@
 <script>
 import SetTime from './demon/setTime';
 import { Notification } from 'element-ui';
-import { ranAsPlan, runDiagramOver, runDiagramGetTime } from '@/api/simulation';
+import { ranAsPlan, runDiagramOver } from '@/api/simulation';
 // import { timeFormat } from '@/utils/date';
 import { EventBus } from '@/scripts/event-bus';
 
@@ -152,10 +152,7 @@ export default {
             });
         },
         async loadSystemTime() {
-            // const rest = await runDiagramGetTime(this.group);
+
-            // if (rest && rest.code == 200) {
-            //     this.$store.dispatch('training/setInitTime', +new Date(`${new Date().getFullYear()} ${timeFormat(rest.data)}`));
-            // }
         }
     }
 };

src/views/newMap/jointTrainingNew/index.vue

@@ -26,23 +26,24 @@
 </template>
 
 <script>
-import MapSystemDraft from '@/views/mapsystem/index';
+import MapSystemDraft from '@/views/newMap/mapsystemNew/index';
 import MenuDemonJoint from './menuDemon';
 import MenuDemonSchema from './menuSchema';
-import JoinFaultChoose from '@/views/display/demon/faultChoose';
+import JoinFaultChoose from '@/views/newMap/displayNew/demon/faultChoose';
-import JoinRunPlanLoad from '@/views/display/demon/runPlanLoad';
+import JoinRunPlanLoad from '@/views/newMap/displayNew/demon/runPlanLoad';
-import JoinRunPlanView from '@/views/display/demon/runPlanView';
+import JoinRunPlanView from '@/views/newMap/displayNew/demon/runPlanView';
-import menuSystemTime from '@/views/display/menuSystemTime';
+import menuSystemTime from '@/views/newMap/displayNew/menuSystemTime';
 import IbpPlate from '@/views/ibp/ibpsystem/index';
 import { mapGetters } from 'vuex';
 import { OperateMode, TrainingMode } from '@/scripts/ConstDic';
 import { checkLoginLine } from '@/api/login';
-import { loadMapDataById } from '@/utils/loaddata';
+import { loadNewMapDataByGroup } from '@/utils/loaddata';
-import { getUserRoles, deljointTrainRoom } from '@/api/chat';
+import { getUserRolesNew, deljointTrainRoomNew} from '@/api/jointTraining';
-import { runDiagramOver, getSimulationInfo } from '@/api/simulation';
+import { clearSimulation, getSimulationInfoNew } from '@/api/simulation';
 import Jl3dDrive from '@/views/jlmap3d/drive/jl3ddrive';
 import { EventBus } from '@/scripts/event-bus';
 import ibpData from '@/ibp/constant/ibpData';
+import { timeFormat } from '@/utils/date';
 import { Message } from 'element-ui';
 
 export default {
@@ -122,8 +123,8 @@ export default {
                 showClose: false,
                 callback: async (action) => {
                     await this.$store.dispatch('training/over');
-                    await runDiagramOver(this.group);
+                    await clearSimulation(this.group);
-                    await deljointTrainRoom(this.group);
+                    await deljointTrainRoomNew(this.group);
                     this.$router.go(-1);
                 }
             });
@@ -276,14 +277,25 @@ export default {
             }
         },
         async loadSimulationInfo() {
-            const resp = await getSimulationInfo(this.group);
+            const resp = await getSimulationInfoNew(this.group);
             if (resp && resp.code == 200) {
                 this.$store.dispatch('scriptRecord/updateSimulationPause', resp.data.pause);
                 this.questId = Number(resp.data.questId) || 0;
+                this.$store.dispatch('training/setInitTime', +new Date(`${new Date().getFullYear()} ${timeFormat(resp.data.systemTime)}`));
+                if (resp.data.planRunning) {
+                    this.$store.dispatch('training/simulationStart');
+                } else {
+                    this.$store.dispatch('training/over');
+                }
+                if (this.isDemon) {
+                    this.$refs.menuDemon.initPlannedDriving(resp.data.planRunning);
+                } else if (this.isScript) {
+                    this.$refs.menuScript.initPlannedDriving(resp.data.planRunning);
+                }
             }
         },
         async getUserRole() {
-            const res = await getUserRoles(this.group);
+            const res = await getUserRolesNew(this.group);
             const data = res.data || {};
             this.userRole = data.userRole;
             this.deviceCode = data.deviceCode;
@@ -304,18 +316,18 @@ export default {
                 // 01 现地 02 行调 '' 观众
                 const resp = await this.getUserRole();
                 if (resp && resp.code == 200) {
-                    // Admin 管理员 Instructor 教员 Dispatcher 行调 Attendant 车站 Audience 观众 Driver 司机 Repair 通号 IBP:IBP盘
+                    // Admin 管理员 Instructor 教员 Dispatcher 行调 STATION_SUPERVISOR 车站 Audience 观众 Driver 司机 MAINTAINER 通号 IBP:IBP盘
                     this.userRole = resp.data.userRole;
                     switch (this.userRole) {
-                    case 'Admin': this.$store.dispatch('training/setPrdType', '02'); this.$store.dispatch('training/setRoles', 'Admin'); this.hideIbp(); break;
+                    case 'ADMIN': this.$store.dispatch('training/setPrdType', '02'); this.$store.dispatch('training/setRoles', 'ADMIN'); this.hideIbp(); break;
-                    case 'Instructor': this.$store.dispatch('training/setPrdType', '02'); this.$store.dispatch('training/setRoles', 'Instructor'); this.hideIbp(); break;
+                    case 'INSTRUCTOR': this.$store.dispatch('training/setPrdType', '02'); this.$store.dispatch('training/setRoles', 'INSTRUCTOR'); this.hideIbp(); break;
-                    case 'Dispatcher': this.$store.dispatch('training/setPrdType', '02'); this.$store.dispatch('training/setRoles', 'Dispatcher'); this.hideIbp(); break;
+                    case 'DISPATCHER': this.$store.dispatch('training/setPrdType', '02'); this.$store.dispatch('training/setRoles', 'DISPATCHER'); this.hideIbp(); break;
-                    case 'Attendant': this.$store.dispatch('training/setPrdType', '01'); this.$store.dispatch('training/setRoles', 'Attendant'); this.hideIbp(); break;
+                    case 'STATION_SUPERVISOR': this.$store.dispatch('training/setPrdType', '01'); this.$store.dispatch('training/setRoles', 'STATION_SUPERVISOR'); this.hideIbp(); break;
-                    case 'Audience': this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'Audience'); this.hideIbp(); break;
+                    case 'AUDIENCE': this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'AUDIENCE'); this.hideIbp(); break;
-                    case 'Driver': this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'Driver'); this.hideIbp(); break;
+                    case 'DRIVER': this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'DRIVER'); this.hideIbp(); break;
-                    case 'Repair': this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'Repair'); this.hideIbp(); break;
+                    case 'MAINTAINER': this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'MAINTAINER'); this.hideIbp(); break;
                     case 'IBP': this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'IBP'); this.showIbp(resp.data.deviceCode); break;
-                    case 'BigScreen': this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'BigScreen'); this.hideIbp(); break;
+                    case 'BIGSCREEN': this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'BIGSCREEN'); this.hideIbp(); break;
                     }
                 }
                 await this.getTrainDetail();
@@ -325,7 +337,7 @@ export default {
         },
         async getTrainDetail() {
             try {
-                await loadMapDataById(this.mapId);
+                await loadNewMapDataByGroup(this.group);
                 await this.$store.dispatch('training/setMapDefaultState');
             } catch (error) {
                 this.$messageBox(this.$t('error.getMapDataFailed'));

src/views/newMap/jointTrainingNew/menuDemon.vue

@@ -8,7 +8,7 @@
           <el-button type="success" :disabled="isDisable" @click="selectBeginTime">{{ $t('joinTraining.drivingByPlan') }}</el-button>
           <el-button type="danger" :disabled="!isDisable" @click="end">{{ $t('joinTraining.exitPlan') }}</el-button>
         </template>
-        <el-button v-if="!isBigScreen" type="primary" @click="back">{{ $t('global.back') }}</el-button>
+        <el-button type="primary" @click="back">{{ $t('global.back') }}</el-button>
       </el-button-group>
     </div>
     <qr-code ref="qrCode" />
@@ -19,11 +19,10 @@
 
 <script>
 import QrCode from '@/components/QrCode';
-import SetTime from '@/views/display/demon/setTime';
+import SetTime from '@/views/newMap/displayNew/demon/setTime';
-import { runDiagramIsStart, ranAsPlan, runDiagramOver, runDiagramGetTime } from '@/api/simulation';
+import { ranAsPlan, clearSimulation } from '@/api/simulation';
 import { exitFullscreen } from '@/utils/screen';
-import { putJointTrainingSimulationUser } from '@/api/chat';
+import { putJointTrainingSimulationUserNew} from '@/api/jointTraining';
-import { timeFormat } from '@/utils/date';
 import { EventBus } from '@/scripts/event-bus';
 import { getSessionStorage } from '@/utils/auth';
 import RealDevice from './menuDraft/realDevice';
@@ -78,16 +77,13 @@ export default {
             return this.$route.query.lineCode;
         },
         isSpeaking() {
-            return this.userRole != 'Driver' && this.userRole != '';
+            return this.userRole != 'DRIVER' && this.userRole != '';
         },
         isDriver() {
-            return this.userRole == 'Driver';
+            return this.userRole == 'DRIVER';
         },
         isAdmin() {
-            return this.userRole == 'Admin';
+            return this.userRole == 'ADMIN';
-        },
-        isBigScreen() {
-            return this.userRole == 'BigScreen';
         },
         isProject() {
             return getSessionStorage('project').endsWith('gzb');
@@ -127,14 +123,14 @@ export default {
     methods: {
         async initLoadPage() {
             try {
-                const resp = await runDiagramIsStart(this.group);
+                // const resp = await runDiagramIsStart(this.group);
-                if (resp && resp.data) {
+                // if (resp && resp.data) {
-                    this.isDisable = true;
+                //     this.isDisable = true;
-                    this.$store.dispatch('training/simulationStart');
+                //     this.$store.dispatch('training/simulationStart');
-                } else {
+                // } else {
-                    this.isDisable = false;
+                //     this.isDisable = false;
-                    this.$store.dispatch('training/over');
+                //     this.$store.dispatch('training/over');
-                }
+                // }
 
             } catch (error) {
                 console.log(error);
@@ -222,45 +218,45 @@ export default {
                 }
             });
         },
-        // 设置用户角色  Admin 管理员 Instructor 教员 Dispatcher 行调 Attendant 车站 Audience 观众 Driver 司机 Repair 通号
+        // 设置用户角色  Admin 管理员 Instructor 教员 Dispatcher 行调 Attendant 车站 Audience 观众 Driver 司机 MAINTAINER 通号
         addrolesList(list) {
             list.forEach(item => {
                 if (this.userId == item.id) {
                     switch (item.userRole) {
-                    case 'Instructor':
+                    case 'INSTRUCTOR':
-                        this.$store.dispatch('training/setPrdType', '02'); this.$store.dispatch('training/setRoles', 'Instructor');
+                        this.$store.dispatch('training/setPrdType', '02'); this.$store.dispatch('training/setRoles', 'INSTRUCTOR');
                         this.$emit('getUserRole');
                         break;
-                    case 'Dispatcher':
+                    case 'DISPATCHER':
-                        this.$store.dispatch('training/setPrdType', '02'); this.$store.dispatch('training/setRoles', 'Dispatcher');
+                        this.$store.dispatch('training/setPrdType', '02'); this.$store.dispatch('training/setRoles', 'DISPATCHER');
                         this.$emit('getUserRole');
                         break;
-                    case 'Attendant':
+                    case 'STATION_SUPERVISOR':
                         if (!item['deviceCode']) {
-                            this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'Attendant');
+                            this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'STATION_SUPERVISOR');
                             break;
                         }
-                        this.$store.dispatch('training/setPrdType', '01'); this.$store.dispatch('training/setRoles', 'Attendant');
+                        this.$store.dispatch('training/setPrdType', '01'); this.$store.dispatch('training/setRoles', 'STATION_SUPERVISOR');
                         this.$emit('getUserRole');
                         break;
-                    case 'Driver':
+                    case 'DRIVER':
-                        this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'Driver');
+                        this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'DRIVER');
                         this.$emit('getUserRole');
                         break;
-                    case 'Repair':
+                    case 'MAINTAINER':
-                        this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'Repair');
+                        this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'MAINTAINER');
                         this.$emit('getUserRole');
                         break;
                     case 'IBP':
                         this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'IBP');
                         this.$emit('getUserRole');
                         break;
-                    case 'BigScreen':
+                    case 'BIGSCREEN':
-                        this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'BigScreen');
+                        this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'BIGSCREEN');
                         this.$emit('getUserRole');
                         break;
                     default:
-                        this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'Audience');
+                        this.$store.dispatch('training/setPrdType', ''); this.$store.dispatch('training/setRoles', 'AUDIENCE');
                         this.$emit('getUserRole');
                         break;
                     }
@@ -275,14 +271,16 @@ export default {
                 this.$refs.chat.getChathistory();
             }
         },
+        initPlannedDriving(isDisable) {
+            this.isDisable = isDisable;
+        },
         selectBeginTime() {
             this.$refs.setTime.doShow();
         },
         start(model) {
             this.isDisable = true;
             const data = {
-                time: model.initTime,
+                time: model.initTime
-                loadNumber:this.trainList.length
             };
             ranAsPlan(data, this.group).then(res => {
                 this.$store.dispatch('training/simulationStart').then(() => {
@@ -316,7 +314,7 @@ export default {
         end() {
             this.isDisable = false;
             EventBus.$emit('trainView');
-            runDiagramOver(this.group).catch(() => {
+            clearSimulation(this.group).catch(() => {
                 this.$store.dispatch('training/over').then(() => {
                     this.isDisable = true;
                     this.$messageBox(this.$t('error.endSimulationFailed'));
@@ -325,8 +323,8 @@ export default {
         },
         back() {
             this.$store.dispatch('training/over').then(() => {
-                putJointTrainingSimulationUser(this.group).then(() => {
+                putJointTrainingSimulationUserNew(this.group).then(() => {
-                    this.$router.replace({ path: `/trainroom`, query: { lineCode: this.lineCode, group: this.group } });
+                    this.$router.replace({ path: `/trainroom`, query: { lineCode: this.lineCode, group: this.group, drawWay: true } });
                     exitFullscreen();
                 });
             });

src/views/newMap/jointTrainingNew/menuDraft/operateMenu.vue

@@ -8,7 +8,7 @@
 <script>
 import PopMenu from '@/components/PopMenu';
 import ChooseRole from './chooseRole';
-import { putUserRoles } from '@/api/chat';
+import { putUserRolesNew} from '@/api/jointTraining';
 import { DeviceMenu } from '@/scripts/ConstDic';
 
 export default {
@@ -105,12 +105,12 @@ export default {
                 const params = [{
                     id: obj.id,
                     nickName: obj.name,
-                    userRole: 'Driver',
+                    userRole: 'DRIVER',
                     stationCode: '',
                     trainCode: this.selected._code
                 }];
 
-                await putUserRoles(params, this.group);
+                await putUserRolesNew(params, this.group);
             }
         },
         async cancelDriver() {
@@ -119,12 +119,12 @@ export default {
                 const params = [{
                     id: data.id,
                     nickName: data.name,
-                    userRole: 'Driver',
+                    userRole: 'DRIVER',
                     stationCode: '',
                     trainCode: ''
                 }];
 
-                await putUserRoles(params, this.group);
+                await putUserRolesNew(params, this.group);
             }
         },
         refresh() {

src/views/newMap/jointTrainingNew/menuDraft/realDevice.vue

@@ -83,7 +83,7 @@
 </template>
 
 <script>
-import { getRealDevicesNew, updateRealDevicesNew, realDeviceIsUsed } from '@/api/chat';
+import { getRealDevicesInRoomNew, updateRealDevicesNew} from '@/api/jointTraining';
 import { hasDoorStationList } from '@/api/jmap/map';
 import {getAllDeviceInProject} from '@/api/project';
 import { mapGetters } from 'vuex';
@@ -179,7 +179,7 @@ export default {
             this.projectCode = getSessionStorage('project').toUpperCase();
             this.getDoorList(this.$route.query.mapId, this.stationList);
             getAllDeviceInProject({projectCode: this.projectCode, group:this.$route.query.group}).then(resp => {
-                getRealDevicesNew(this.$route.query.group).then(res => {
+                getRealDevicesInRoomNew(this.$route.query.group).then(res => {
                     resp.data.forEach((it, index) => {
                         this.options.push({
                             deviceCode: '',

src/views/newMap/jointTrainingNew/menuSchema.vue

@@ -1,7 +1,7 @@
 <template>
   <div class="schema" :style="{top: offset+'px'}">
     <el-select
-      v-if="userRole == 'Instructor' || userRole == 'Admin'"
+      v-if="userRole == 'INSTRUCTOR' || userRole == 'ADMIN'"
       v-model="swch"
       size="small"
       :placeholder="this.$t('rules.productTypeInput')"
@@ -14,17 +14,17 @@
       <template>
         <el-button v-if="runing" size="small" :disabled="viewDisabled" @click="viewRunPlan">{{ $t('joinTraining.runGraphPreview') }}</el-button>
       </template>
-      <template v-if="userRole == 'Admin'">
+      <template v-if="userRole == 'ADMIN'">
         <el-button v-if="!runing" size="small" type="warning" :disabled="viewDisabled" @click="loadRunPlan">
           {{ $t('joinTraining.runGraphLoading') }}</el-button>
       </template>
-      <template v-if="userRole == 'Instructor' || userRole == 'Admin'">
+      <template v-if="userRole == 'INSTRUCTOR' || userRole == 'ADMIN'">
         <el-button v-if="mode==OperateMode.FAULT" size="small" type="danger" @click="setFault">{{ $t('joinTraining.faultSetting') }}</el-button>
       </template>
     </el-button-group>
 
     <el-radio-group
-      v-if="userRole == 'Instructor' || userRole == 'Admin'"
+      v-if="userRole == 'INSTRUCTOR' || userRole == 'ADMIN'"
       v-model="mode"
       size="small"
       @change="changeOperateMode(mode)"
@@ -39,7 +39,7 @@ import { mapGetters } from 'vuex';
 import { OperateMode } from '@/scripts/ConstDic';
 // import { getStationList } from '@/api/runplan';
 import { getByGroupStationList } from '@/api/jmap/map';
-import { getEveryDayRunPlanData } from '@/api/simulation';
+import { getEveryDayRunPlanNew } from '@/api/simulation';
 
 export default {
     name: 'MenuDemonSchema',
@@ -109,8 +109,9 @@ export default {
                     // getStationList(opt.mapId).then(response => {
                         const stations = response.data;
                         this.$store.dispatch('runPlan/setStations', stations).then(() => {
-                            getEveryDayRunPlanData(this.group).then(resp => {
+                            getEveryDayRunPlanNew(this.group).then(resp => {
                                 this.$store.dispatch('runPlan/setPlanData', resp.data);
+                                this.$store.dispatch('runPlan/setInitialPlanData', resp.data);
                                 this.viewDisabled = false;
                             }).catch(error => {
                                 this.$store.dispatch('runPlan/setPlanData', []);
@@ -130,6 +131,9 @@ export default {
         switchMode(swch) {
             this.$store.dispatch('training/setPrdType', swch);
         },
+        initPlannedDriving(isDisable) {
+            this.isDisable = isDisable;
+        },
         changeOperateMode(handle) {
             this.$store.dispatch('training/changeOperateMode', { mode: handle });
         },

src/views/trainRoom/content-menu.vue

@@ -8,6 +8,7 @@
 import PopMenu from '@/components/PopMenu';
 import { DeviceMenu } from '@/scripts/ConstDic';
 import { putJointTrainingUserkicked } from '@/api/chat';
+import { putJointTrainingUserkickedNew} from '@/api/jointTraining';
 
 export default {
     components: {
@@ -33,6 +34,9 @@ export default {
         },
         position() {
             return this.$store.state.menuOperation.menuPosition;
+        },
+        drawWay() {
+            return this.$route.query.drawWay;
         }
     },
     watch: {
@@ -69,7 +73,11 @@ export default {
         },
         async kicked() {
             try {
-                await putJointTrainingUserkicked(this.clickUserId, this.$route.query.group);
+                if (this.drawWay) {
+                    await putJointTrainingUserkickedNew(this.clickUserId, this.$route.query.group);
+                } else {
+                    await putJointTrainingUserkicked(this.clickUserId, this.$route.query.group);
+                }
             } catch (error) {
                 console.error(error);
             }

src/views/trainRoom/e-chat.vue

@@ -34,6 +34,7 @@
 
 <script>
 import { chatWithText } from '@/api/chat';
+import { chatWithTextNew } from '@/api/jointTraining';
 
 export default {
     props: {
@@ -68,6 +69,9 @@ export default {
         },
         userId() {
             return this.$store.state.user ? this.$store.state.user.id : '';
+        },
+        drawWay() {
+            return this.$route.query.drawWay;
         }
     },
     watch: {
@@ -88,7 +92,11 @@ export default {
         async handleSendText() {
             try {
                 if (this.text.trim()) {
-                    await chatWithText(this.text, this.group);
+                    if (this.drawWay) {
+                        await chatWithTextNew(this.text, this.group);
+                    } else {
+                        await chatWithText(this.text, this.group);
+                    }
                     this.text = '';
                     this.disabled = true;
                 }

src/views/trainRoom/e-role.vue

@@ -24,11 +24,12 @@
               @change="handleUpdUser(node, index)"
             />
             <el-select
-              v-if="roleType == 'Attendant'"
+              v-if="roleType.toUpperCase() == 'ATTENDANT' || roleType.toUpperCase() === 'STATION_SUPERVISOR'"
               v-model="node.deviceCode"
               :placeholder="$t('global.choose')"
               size="mini"
               :disabled="isDisable"
+              s
               @change="handleUpdUser(node, index)"
             >
               <el-option
@@ -80,7 +81,7 @@ export default {
     },
     computed: {
         hasDevice() {
-            return ['Attendant', 'IBP'].includes(this.roleType);
+            return ['ATTENDANT', 'IBP', 'STATION_SUPERVISOR'].includes(this.roleType.toUpperCase());
         },
         isDisable() {
             return this.userId != this.room.creatorId;

src/views/trainRoom/e-roles.vue

@@ -113,6 +113,7 @@ import eDevice from './e-device';
 import AddPerson from './add-person';
 import QrCode from '@/components/QrCode';
 import { getJoinTrainCode, startJointTraining, deljointTrainRoom, putJointTrainingExit, putJointTrainingSimulation, putUserRoles, setRealDevice, delRealDevice } from '@/api/chat';
+import { getJoinTrainCodeNew, startJointTrainingNew, deljointTrainRoomNew, putUserRolesNew, putJointTrainingExitNew, putJointTrainingSimulationNew, setRealDeviceNew, delRealDeviceNew } from '@/api/jointTraining';
 import { getPlcGateway } from '@/api/simulation';
 import { getSessionStorage } from '@/utils/auth';
 
@@ -171,6 +172,9 @@ export default {
         group() {
             return this.$route.query.group;
         },
+        drawWay() {
+            return this.$route.query.drawWay;
+        },
         userId() {
             return this.$store.state.user ? this.$store.state.user.id : '';
         },
@@ -195,25 +199,25 @@ export default {
             });
         },
         dispatcherList() {
-            return this.members.filter(elem => { return [elem.userRole].includes('Dispatcher'); });
+            return this.members.filter(elem => { return [elem.userRole.toUpperCase()].includes('DISPATCHER'); });
         },
         attendantList() {
-            return this.members.filter(elem => { return [elem.userRole].includes('Attendant'); });
+            return this.members.filter(elem => { return [elem.userRole.toUpperCase()].includes('ATTENDANT') || [elem.userRole.toUpperCase()].includes('STATION_SUPERVISOR'); });
         },
         instructorList() {
-            return this.members.filter(elem => { return [elem.userRole].includes('Instructor'); });
+            return this.members.filter(elem => { return [elem.userRole.toUpperCase()].includes('INSTRUCTOR'); });
         },
         repairList() {
-            return this.members.filter(elem => { return [elem.userRole].includes('Repair'); });
+            return this.members.filter(elem => { return [elem.userRole.toUpperCase()].includes('REPAIR') || [elem.userRole.toUpperCase()].includes('MAINTAINER'); });
         },
         driverList() {
-            return this.members.filter(elem => { return [elem.userRole].includes('Driver'); });
+            return this.members.filter(elem => { return [elem.userRole.toUpperCase()].includes('DRIVER'); });
         },
         ibpList() {
-            return this.members.filter(elem => { return [elem.userRole].includes('IBP'); });
+            return this.members.filter(elem => { return [elem.userRole.toUpperCase()].includes('IBP'); });
         },
         audienceList() {
-            return this.members.filter(elem => { return [elem.userRole].includes('Audience'); });
+            return this.members.filter(elem => { return [elem.userRole.toUpperCase()].includes('AUDIENCE'); });
         }
     },
     async mounted() {
@@ -235,19 +239,30 @@ export default {
                 this.$message.info(this.$t('error.theDeviceTypeAlreadyExists'));
                 return;
             }
-
+            if (this.drawWay) {
-            await setRealDevice(this.group, roomDeviceVo);
+                await setRealDeviceNew(this.group, roomDeviceVo);
+            } else {
+                await setRealDevice(this.group, roomDeviceVo);
+            }
         },
         async handleUpdDevice({deviceType, device}) {
             try {
-                await setRealDevice(this.group, device);
+                if (this.drawWay) {
+                    await setRealDeviceNew(this.group, device);
+                } else {
+                    await setRealDevice(this.group, device);
+                }
             } catch (e) {
                 this.$messageBox(this.$t('error.connectToRealDeviceFailed'));
             }
         },
         async handleDelDevice({deviceType, device}) {
             try {
-                await delRealDevice(device.id, this.group);
+                if (this.drawWay) {
+                    await delRealDeviceNew(device.id, this.group);
+                } else {
+                    await delRealDevice(device.id, this.group);
+                }
             } catch (e) {
                 this.$messageBox(this.$t('error.deleteRealDeviceFailed'));
             }
@@ -262,8 +277,12 @@ export default {
                 userRole: 'Audience',
                 deviceCode: ''
             }];
-
+            if (this.drawWay) {
-            await putUserRoles(params, this.group);
+                params[0].userRole = 'AUDIENCE';
+                await putUserRolesNew(params, this.group);
+            } else {
+                await putUserRoles(params, this.group);
+            }
         },
         async handleUpdUser({roleType, user, deviceList}) {
             let deviceCode = '';
@@ -282,8 +301,17 @@ export default {
                 deviceCode: deviceCode,
                 ibpPart: user.ibpPart
             }];
-
+            if (this.drawWay) {
-            await putUserRoles(params, this.group);
+                params[0].userRole = roleType.toUpperCase();
+                if (roleType === 'Attendant') {
+                    params[0].userRole = 'STATION_SUPERVISOR';
+                } else if (roleType === 'Repair') {
+                    params[0].userRole = 'MAINTAINER';
+                }
+                await putUserRolesNew(params, this.group);
+            } else {
+                await putUserRoles(params, this.group);
+            }
 
             this.stationList.forEach(item => {
                 item.disabled = false;
@@ -295,10 +323,22 @@ export default {
             });
         },
         async handleDispatchUser({roleType, userList}) {
-            const list = userList.map(elem => { return { id: elem.id, nickName: elem.nickName, userRole: roleType }; });
+            if (userList.length) {
-            if (list.length) {
                 try {
-                    await putUserRoles(list, this.group);
+                    let list = [];
+                    if (this.drawWay) {
+                        if (roleType === 'Attendant') {
+                            list = userList.map(elem => { return { id: elem.id, nickName: elem.nickName, userRole: 'STATION_SUPERVISOR' }; });
+                        } else if (roleType === 'Repair') {
+                            list = userList.map(elem => { return { id: elem.id, nickName: elem.nickName, userRole: 'MAINTAINER'}; });
+                        } else {
+                            list = userList.map(elem => { return { id: elem.id, nickName: elem.nickName, userRole: roleType.toUpperCase() }; });
+                        }
+                        await putUserRolesNew(list, this.group);
+                    } else {
+                        list = userList.map(elem => { return { id: elem.id, nickName: elem.nickName, userRole: roleType }; });
+                        await putUserRoles(list, this.group);
+                    }
                     list.forEach(item => {
                         this.treeData.forEach(nor => {
                             if (item.id == nor.id) {
@@ -315,7 +355,12 @@ export default {
         },
         async handlePostQrcode() {
             this.disabled = true;
-            const res = await getJoinTrainCode({}, this.group);
+            let res = '';
+            if (this.drawWay) {
+                res = await getJoinTrainCodeNew({}, this.group);
+            } else {
+                res = await getJoinTrainCode({}, this.group);
+            }
             if (res.code == '200') {
                 const param = {
                     url: res.data,
@@ -339,7 +384,11 @@ export default {
             this.disabled = true;
             if (this.attendantList.findIndex(item => { return !item.deviceCode; }) < 0) {
                 try {
-                    await startJointTraining(this.group);
+                    if (this.drawWay) {
+                        await startJointTrainingNew(this.group);
+                    } else {
+                        await startJointTraining(this.group);
+                    }
                 } catch (error) {
                     this.$emit('message', {type:'error', message: this.$t('error.startedComprehensiveDrillFailure')});
                     this.disabled = false;
@@ -352,7 +401,12 @@ export default {
         async handleStop() {
             try {
                 this.disabled = true;
-                const res = await putJointTrainingSimulation(this.group);
+                let res = '';
+                if (this.drawWay) {
+                    res = await putJointTrainingSimulationNew(this.group);
+                } else {
+                    res = await putJointTrainingSimulation(this.group);
+                }
                 this.mapId = res.data.mapId;
             } catch (e) {
                 console.error(e);
@@ -368,7 +422,11 @@ export default {
                 type: 'warning'
             }).then(async () => {
                 try {
-                    await deljointTrainRoom(this.group);
+                    if (this.drawWay) {
+                        await deljointTrainRoomNew(this.group);
+                    } else {
+                        await deljointTrainRoom(this.group);
+                    }
                 } catch (error) {
                     this.$emit('message', {type:'error', message: this.$t('error.destroyedRoomFailed')});
                 } finally {
@@ -381,7 +439,11 @@ export default {
         async handleBack() {
             try {
                 this.disabled = true;
-                await putJointTrainingExit(this.group);
+                if (this.drawWay) {
+                    await putJointTrainingExitNew(this.group);
+                } else {
+                    await putJointTrainingExit(this.group);
+                }
                 this.$emit('clearSubscribe');
                 this.$router.go(-1);
             } catch (error) {

src/views/trainRoom/index.vue

@@ -47,6 +47,7 @@ import eMembers from './e-members';
 import eChat from './e-chat';
 import eRoles from './e-roles';
 import { postRoomDetail, getJointTrainRoomUserList, getRealDevices, putJointTrainingSimulationEntrance, getjointTraining } from '@/api/chat';
+import { postRoomDetailNew, getJointTrainRoomUserListNew, putJointTrainingSimulationEntranceNew, getjointTrainingNew, getRealDevicesNew} from '@/api/jointTraining';
 import { getPublishMapInfo, hasDoorStationList } from '@/api/jmap/map';
 import { launchFullscreen } from '@/utils/screen';
 import { getStationList } from '@/api/runplan';
@@ -87,6 +88,9 @@ export default {
         group() {
             return this.$route.query.group;
         },
+        drawWay() {
+            return this.$route.query.drawWay;
+        },
         userId() {
             return this.$store.state.user ? this.$store.state.user.id : '';
         }
@@ -95,7 +99,7 @@ export default {
         members: {
             deep: true,
             handler() {
-                this.room.permissionRest = this.members.filter(elem => ['Audience'].includes(elem.userRole)).length;
+                this.room.permissionRest = this.members.filter(elem => ['AUDIENCE'].includes(elem.userRole.toUpperCase())).length;
             }
         },
         // 用户信息
@@ -125,8 +129,10 @@ export default {
     methods: {
         async loadInit() {
             await this.subscribe();
-            if (!this.$store.state.socket.setInRoom) {
+            if (!this.$store.state.socket.setInRoom && !this.drawWay) {
                 await getjointTraining(this.group);
+            } else if (!this.$store.state.socket.setInRoom && this.drawWay) {
+                await getjointTrainingNew(this.group);
             }
             await this.getRoomInfo();
             await this.getUserList();
@@ -139,7 +145,12 @@ export default {
             }, 5000 * 60);
         },
         async getRoomInfo() {
-            const resp = await postRoomDetail(this.group);
+            let resp = '';
+            if (this.drawWay) {
+                resp = await postRoomDetailNew(this.group);
+            } else {
+                resp = await postRoomDetail(this.group);
+            }
             this.room = {
                 permissionRest: 0,
                 totalNum: Number(resp.data.permissionNum) + Number(resp.data.audiencePermissionNum),
@@ -147,7 +158,12 @@ export default {
             };
         },
         async getStandList() {
-            const resp = await getRealDevices(this.group);
+            let resp = '';
+            if (this.drawWay) {
+                resp = await getRealDevicesNew(this.group);
+            } else {
+                resp = await getRealDevices(this.group);
+            }
             this.standList = resp.data || [];
         },
         async getStaionList(mapId) {
@@ -171,7 +187,12 @@ export default {
             });
         },
         async getUserList() {
-            const res = await getJointTrainRoomUserList(this.group);
+            let res = '';
+            if (this.drawWay) {
+                res = await getJointTrainRoomUserListNew(this.group);
+            } else {
+                res = await getJointTrainRoomUserList(this.group);
+            }
             this.members = (res.data || []).map(elem => { return this.transformUser(elem); });
         },
         async dispatchUsers(users) {
@@ -244,7 +265,7 @@ export default {
 
                     if (!old.inSimulation && user.inSimulation) {
                         this.$store.dispatch('socket/setChatContent', {...message, roomTip: `${user.nickName}进入仿真`});
-                        if (this.userId == user.id) {
+                        if (this.userId == user.id && user.userRole.toUpperCase() !== 'ADMIN') {
                             await this.jumpInSimulation();
                         }
                     }
@@ -255,10 +276,15 @@ export default {
         },
         async jumpInSimulation() {
             const room = this.room;
-            await putJointTrainingSimulationEntrance(room.group);
+            if (this.drawWay) {
+                await putJointTrainingSimulationEntranceNew(room.group);
+            } else {
+                await putJointTrainingSimulationEntrance(room.group);
+            }
             const rest = await getPublishMapInfo(room.mapId);
             const query = { lineCode: rest.data.lineCode, mapId: room.mapId, group: room.group, roomId: room.id };
             if (this.$route.query.drawWay) {
+                query.drawWay = this.$route.query.drawWay;
                 this.$router.replace({ path: `/jointTrainingNew`, query: query});
             } else {
                 this.$router.replace({ path: `/jointTraining`, query: query });