Merge remote-tracking branch 'origin/develop'

commit 1b0ddc2740
Author: joylink_zhaoerwei <Bob_Engineer@163.com>
Date:   Mon May 27 17:39:39 2024 +0800

    Squashed commit of the following:

    commit cef55a4c6b
    Author: joylink_zhaoerwei <Bob_Engineer@163.com>
    Date:   Mon May 27 17:09:01 2024 +0800

        三维url调整

    commit 869c86b94d
    Author: joylink_zhaoerwei <Bob_Engineer@163.com>
    Date:   Mon May 27 16:57:01 2024 +0800

        更改三维地址

    commit dc2165733e
    Author: joylink_zhaoerwei <Bob_Engineer@163.com>
    Date:   Mon May 27 16:33:48 2024 +0800

        场景添加三维场景，实训中可根据url打开三维场景（待测试）

commit 7d774db362
Merge: b66515eba 0c5bba7c0
Author: joylink_fanyuhong <18706759286@163.com>
Date:   Tue May 21 16:48:35 2024 +0800

    Merge remote-tracking branch 'origin/develop' into local-test

commit 0c5bba7c0f
Author: joylink_fanyuhong <18706759286@163.com>
Date:   Tue May 21 16:47:37 2024 +0800

    传输信号机调整

commit ef9165faa4
Author: joylink_fanyuhong <18706759286@163.com>
Date:   Thu May 16 15:43:56 2024 +0800

    third

commit ae74123f18
Author: joylink_fanyuhong <18706759286@163.com>
Date:   Wed May 8 09:17:37 2024 +0800

    成都工学院第三方登录调整

commit b1baeaabcd
Author: joylink_fanyuhong <18706759286@163.com>
Date:   Tue May 7 15:46:29 2024 +0800

    成都工业学院第三方登录调整

commit b66515ebad
Merge: 5cf57c4d2 91a8410dc
Author: joylink_fanyuhong <18706759286@163.com>
Date:   Wed Apr 24 11:01:32 2024 +0800

    Merge remote-tracking branch 'origin/develop' into local-test

commit 91a8410dc2
Author: joylink_fanyuhong <18706759286@163.com>
Date:   Wed Apr 24 10:58:02 2024 +0800

    道岔名称背景颜色更换透明色

commit 5cf57c4d2f
Merge: 5ca4f2be8 c97def5fc
Author: joylink_fanyuhong <18706759286@163.com>
Date:   Mon Apr 22 17:16:40 2024 +0800

    Merge remote-tracking branch 'origin/develop' into local-test

commit 5ca4f2be8d
Merge: 66a376298 31376bc22
Author: joylink_fanyuhong <18706759286@163.com>
Date:   Mon Apr 22 16:10:23 2024 +0800

    Merge remote-tracking branch 'origin/develop' into local-test

commit 66a3762987
Merge: 9dab09e4d 5be2cea1c
Author: joylink_fanyuhong <18706759286@163.com>
Date:   Mon Apr 22 15:53:54 2024 +0800

    Merge remote-tracking branch 'origin/develop' into local-test

commit 9dab09e4d0
Merge: b8f90509e dda44c870
Author: joylink_fanyuhong <18706759286@163.com>
Date:   Mon Apr 22 09:33:42 2024 +0800

    Merge remote-tracking branch 'origin/develop' into local-test

commit b8f90509eb
Merge: 26d9cc892 5548806ea
Author: joylink_fanyuhong <18706759286@163.com>
Date:   Sun Apr 21 17:51:33 2024 +0800

    Merge remote-tracking branch 'origin/develop' into local-test

commit 26d9cc892f
Merge: ce8d3f453 3fc31777a
Author: joylink_fanyuhong <18706759286@163.com>
Date:   Fri Apr 19 22:27:07 2024 +0800

    Merge remote-tracking branch 'origin/develop' into local-test

commit ce8d3f4531
Author: fan <fanyuhong@joylink.club>
Date:   Fri Apr 19 22:25:43 2024 +0800

    iscs退出仿真调整&iscs绘制地图调整

commit 98662ec177
Author: fan <fanyuhong@joylink.club>
Date:   Fri Apr 19 18:25:09 2024 +0800

    实时广播问题调整&注释iscs信号系统&stationNav换成车站名称&iscs点击修改mode

.env.sai

@@ -0,0 +1,9 @@
+# just a flag
+NODE_ENV = 'production'
+VUE_APP_PRO = 'common'
+
+# base api
+# VUE_APP_BASE_API = 'http://160.20.60.15:9000'
+# VUE_APP_VOICE_API = 'http://160.20.60.15/oss/joylink'
+# VUE_APP_UPLOAD_API = 'http://160.20.60.15'
+# VUE_APP_BASE_SITE='http://160.20.60.15'

.gitea/workflows/CICD_local_test.yaml

@@ -0,0 +1,52 @@
+---
+name: local-test分支构建发布到本地服务器
+run-name: ${{ gitea.actor }} is testing out Gitea Actions
+on:
+  push:
+    branches:
+      - local-test
+jobs:
+  Build-Publish:
+    runs-on: joylink-local233
+    steps:
+      - name: 检出代码
+        uses: https://gitea.joylink.club/actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: 设置node环境
+        uses: https://gitea.joylink.club/actions/local-setup-node@v0.1.1
+        with:
+          version: v14.21.3
+          cache: yarn
+          cache-dependency-path: yarn.lock
+      - name: 安装yarn,并build
+        run: |
+          node -v
+          npm config set registry https://registry.npmmirror.com
+          npm install --global yarn
+          yarn config set registry https://registry.npmmirror.com
+          yarn
+          yarn run buildas local-test
+          tar czvf ./dist-local-test.tar.gz ./dist
+      - name: 打包发送到服务器
+        uses: https://gitea.joylink.club/appleboy/scp-action@v0.1.7
+        with:
+          host: ${{ secrets.LOCAL_233_SSH_HOST }}
+          username: ${{ secrets.LOCAL_233_SSH_USER }}
+          password: ${{ secrets.LOCAL_233_SSH_PASSWORD }}
+          port: ${{ secrets.LOCAL_233_SSH_PORT }}
+          source: ./dist-local-test.tar.gz
+          target: /home/minio/oss/rt-sim-training-client
+          overwrite: true
+      - name: SSH连接并解压发布
+        uses: https://gitea.joylink.club/appleboy/ssh-action@v1.0.3
+        with:
+          host: ${{ secrets.LOCAL_233_SSH_HOST }}
+          port: ${{ secrets.LOCAL_233_SSH_PORT }}
+          username: ${{ secrets.LOCAL_233_SSH_USER }}
+          password: ${{ secrets.LOCAL_233_SSH_PASSWORD }}
+          script: |
+            cd /home/minio/oss/rt-sim-training-client
+            rm -rf /usr/local/joylink/client/cbtc
+            mkdir -p /usr/local/joylink/client
+            tar xz --strip 2 -C /usr/local/joylink/client -f dist-local-test.tar.gz

.gitea/workflows/CICD_master.yaml

@@ -0,0 +1,52 @@
+name: master分支构建发布到公网服务器
+run-name: ${{ gitea.actor }} is testing out Gitea Actions
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  Build-Publish:
+    runs-on: joylink-local233
+    steps:
+      - name: 检出代码
+        uses: https://gitea.joylink.club/actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: 设置node环境
+        uses: https://gitea.joylink.club/actions/local-setup-node@v0.1.1
+        with:
+          version: 'v14.21.3'
+          cache: 'yarn'
+          cache-dependency-path: 'yarn.lock'
+      - name: 安装yarn,并build
+        run: |
+          node -v
+          npm config set registry https://registry.npmmirror.com
+          npm install --global yarn
+          yarn config set registry https://registry.npmmirror.com
+          yarn
+          yarn run build
+          tar czvf ./dist-master.tar.gz ./dist
+      - name: 打包发送到服务器
+        uses: https://gitea.joylink.club/appleboy/scp-action@v0.1.7
+        with:
+          host: ${{ secrets.PUB1_DOMAIN_SSH_HOST }}
+          port: ${{ secrets.PUB1_DOMAIN_SSH_PORT }}
+          username: ${{ secrets.PUB1_DOMAIN_SSH_USER }}
+          password: ${{ secrets.PUB1_DOMAIN_SSH_PASSWORD }}
+          source: ./dist-master.tar.gz
+          target: /mnt/data/published/rt-sim-training-client
+          overwrite: true
+      - name: SSH连接并解压发布
+        uses: https://gitea.joylink.club/appleboy/ssh-action@v1.0.3
+        with:
+          host: ${{ secrets.PUB1_DOMAIN_SSH_HOST }}
+          port: ${{ secrets.PUB1_DOMAIN_SSH_PORT }}
+          username: ${{ secrets.PUB1_DOMAIN_SSH_USER }}
+          password: ${{ secrets.PUB1_DOMAIN_SSH_PASSWORD }}
+          script: |
+            cd /mnt/data/published/rt-sim-training-client
+            rm -rf /usr/local/joylink/client/cbtc
+            mkdir -p /usr/local/joylink/client
+            tar xz --strip 2 -C /usr/local/joylink/client -f dist-master.tar.gz

.gitignore

@@ -4,7 +4,6 @@ dist/
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
-package-lock.json
 tests/**/coverage/
 src/utils/baseUrl.js*
 

README.md

@@ -4,3 +4,6 @@ English | [简体中文](./README-zh.md)
 
 
 Copyright (c) 2018-present Joylink
+### 项目环境
+- "node": "<=14.21.3";
+- "webpack": ">=4 < 4.29";

package.json

@@ -6,7 +6,7 @@
   "license": "MIT",
   "scripts": {
     "start": "vue-cli-service serve --open",
-    "dev": "node --max_old_space_size=4096 node_modules/@vue/cli-service/bin/vue-cli-service.js serve",
+    "dev": "node --max_old_space_size=4096 node_modules/@vue/cli-service/bin/vue-cli-service.js serve --open",
     "build": "vue-cli-service build --mode production",
     "test": "vue-cli-service build --mode staging",
     "local": "vue-cli-service build --mode",
@@ -18,6 +18,9 @@
     "svgo": "svgo -f src/icons/svg --config=src/icons/svgo.yml"
   },
   "dependencies": {
+    "@stomp/stompjs": "^5.4.4",
+    "@wangeditor/editor": "^5.1.23",
+    "@wangeditor/editor-for-vue": "^1.0.2",
     "axios": "^0.18.0",
     "dayjs": "^1.11.5",
     "echarts": "^4.7.0",
@@ -43,9 +46,11 @@
     "vue-i18n": "^8.12.0",
     "vue-quill-editor": "^3.0.6",
     "vue-router": "^3.1.6",
+    "vue-video-player": "^5.0.1",
     "vuedraggable": "^2.24.3",
     "vuex": "^3.1.0",
     "wangeditor": "^4.6.17",
+    "ws": "^8.13.0",
     "xlsx": "^0.14.2",
     "zrender": "^4.0.4"
   },

src/App.vue

@@ -1,10 +1,14 @@
 <template>
   <div id="app">
-    <router-view />
-    <deomon-topic ref="deomonTopic" />
-    <img v-show="loading" :src="loadingImg" class="AppAll">
+    <router-view v-if="loadingComponent" />
+    <deomon-list ref="deomonList" @enterQcode="qcodeEntry" />
+    <qcode ref="qcode" />
+    <div v-show="loading" class="AppAll">
+      <img v-if="project === 'login' || project === 'design'" :src="jlFavicon" class="CompanyIcon">
+      <img :src="loadingImg" style="width: 100%; height: 100%;">
+    </div>
     <div
-      v-if="!$store.state.user.baseUrl"
+      v-if="!$store.state.user.baseUrl && needLoading"
       v-loading="!$store.state.user.baseUrl"
       element-loading-text="拼命加载中"
       element-loading-background="rgba(0, 0, 0, 0)"
@@ -18,18 +22,23 @@
 
 <script>
 import { getToken, getUserIdKey } from '@/utils/auth';
-import { getSessionStorage } from '@/utils/auth';
-import { loginInfo, ProjectIcon } from '@/scripts/ProjectConfig';
-import DeomonTopic from '@/views/demonstration/deomonTopic';
+import { getSessionStorage, setSessionStorage } from '@/utils/auth';
 import WindowResizeHandler from '@/mixin/WindowResizeHandler';
 import LoadingImg from '@/assets/loading.gif';
 import AppLoading from '@/assets/appLoading.png';
 import { openIndexedDB } from '@/utils/indexedDb';
+import Favicon from '@/assets/icon/favicon.png';
+import DeomonList from '@/views/demonstration/deomonList/index';
+import Qcode from '@/layout/components/Qcode.vue';
+import {removeToken} from './utils/auth';
+import { getFrontProjectConfigByLogin} from '@/api/projectConfig';
+import { handlerUrl } from '@/utils/baseUrl';
 
 export default {
     name: 'App',
     components: {
-        DeomonTopic
+        DeomonList,
+        Qcode
     },
     mixins: [
         WindowResizeHandler
@@ -38,28 +47,27 @@ export default {
         return {
             loadingImg: LoadingImg,
             appLoading: AppLoading,
-            loading: false
+            loading: false,
+            jlFavicon: Favicon,
+            project: '',
+            loadingComponent: false
         };
     },
+    computed: {
+        needLoading() {
+            return this.$route.path !== '/authorization';
+        }
+    },
     watch: {
-        '$store.state.socket.simulationInvite': function (val) {
-            if (val.creator) {
-                this.subscribeMessage(val);
-            }
-        },
-        '$store.state.socket.roomInvite': function (val) {
-            if (val.creator) {
-                this.subscribeMessage(val);
-            }
-        },
         '$store.state.socket.beLogoutCount': async function(val) {
             if (this.$store.state.socket.loggedOutMsg.token === getToken()) {
                 this.$store.dispatch('disconnect').then(()=>{
                     this.$alert(this.$t('tip.logoutTips'), this.$t('tip.hint'), {
                         confirmButtonText: this.$t('tip.confirm'),
                         callback: action => {
+                            removeToken();
                             this.$store.dispatch('exit').then(resp => {
-                                this.$router.push({path: loginInfo[getSessionStorage('project')].loginPath});
+                                this.$router.push({path: `/login?project=${this.$store.state.projectConfig.markKey}`});
                             });
                         }
                     });
@@ -72,17 +80,25 @@ export default {
         },
         '$store.state.app.animationsCloseCount': function(val) {
             this.loading = false;
-        }
-    },
-    created() {
-        const project = getSessionStorage('project');
-        if (project) {
-            document.querySelector("link[rel*='icon']").href = loginInfo[project].linkIcon || ProjectIcon[project];
+        },
+        '$route': function(val) {
+            if (val.path == '/display/demon' && val.query.client == 'diagramEdit') { // 运行图编制
+                this.loading = false;
+            }
+            if (this.$route.query.project || this.$route.path === '/login' || this.$route.path === '/') {
+                setSessionStorage('project', this.$route.query.project || 'login');
+            }
+            this.project = getSessionStorage('project');
+            if (this.project !== this.$store.state.projectConfig.markKey) {
+                this.initFrontProjectConfig();
+            }
+        },
+        '$store.state.projectConfig.markKey': function(val) {
+            if (val) { this.loadingComponent = true; }
         }
     },
     mounted() {
         this.prohibitSystemContextMenu();
-
         window.addEventListener('beforeunload', async e => {
             if (!this.$route.query.noPreLogout) {
                 await this.$store.dispatch('preLogout');
@@ -92,7 +108,7 @@ export default {
             if (this.$route.path.includes('trainingDesign') || this.$route.path.includes('trainingPreview')) {
                 if (e.key == getUserIdKey('nextNew')) {
                     const operate = JSON.parse(e.newValue);
-                    this.$store.dispatch('training/nextNew', operate);
+                    this.$store.dispatch('trainingNew/next', operate);
                 }
             }
 
@@ -105,6 +121,28 @@ export default {
         this.$store.dispatch('subscribe_un', {});
     },
     methods: {
+        initFrontProjectConfig() {
+            getFrontProjectConfigByLogin(this.project).then(resp => {
+                const urlData = handlerUrl();
+                const { baseApiUrl, baseSite, ossUrl, loginProLogo, browserTitle} = resp.data.viewSetting;
+                this.$store.dispatch('setBaseUrl', baseApiUrl || urlData.BASE_API);
+                this.$store.dispatch('setBaseSite', baseSite || urlData.BASE_SITE);
+                this.$store.dispatch('setOssUrl', ossUrl || urlData.OSS_URL);
+                this.$store.dispatch('projectConfig/setMarkKey', resp.data.markKey);
+                this.$store.dispatch('projectConfig/setProjectCode', resp.data.project);
+                this.$store.dispatch('projectConfig/setViewSetting', resp.data.viewSetting);
+                document.title = browserTitle;
+                if (loginProLogo) {
+                    document.querySelector("link[rel*='icon']").href = (ossUrl || urlData.OSS_URL) + '/logo/' + loginProLogo;
+                }
+            }).catch(e => this.$message.error('获取配置数据失败！'));
+        },
+        quickEntry() {
+            this.$refs.deomonList.doShow();
+        },
+        qcodeEntry() {
+            this.$refs.qcode.doShow();
+        },
         resizeHandler() {
             this.$store.dispatch('app/resize', { width: this._clientWidth, height: this._clientHeight });
         },
@@ -112,22 +150,13 @@ export default {
             window.document.oncontextmenu = function () {
                 return false;
             };
-        },
-        subscribeMessage(res) {
-            if (this.$refs.deomonTopic && !window.location.href.includes('trainroom')) {
-                if (!(getSessionStorage('project').includes('design'))) {
-                    this.$refs.deomonTopic.doShow(res);
-                }
-                this.$store.dispatch('socket/setSimulationInvite');
-                this.$store.dispatch('socket/setRoomInvite');
-            }
         }
     }
 };
 
 </script>
 <style lang="scss" scoped>
-.AppAll{position: absolute;top: 0;left: 0;width: 100%;height: 100%;z-index: 2003}
+.AppAll{position: absolute;top: 0;left: 0;width: 100%;height: 100%;z-index: 3003}
 	.centerImg {
 		position: absolute;
 		left:50%;
@@ -137,4 +166,12 @@ export default {
 		margin-left: -240px;
 		margin-top: -228px;
 	}
+	.CompanyIcon{
+		position: absolute;
+		z-index: 3000;
+		left: 50%;
+		margin-left: -60px;
+		width: 120px;
+		top: 30px;
+	}
 </style>

src/api/authorityTransfer.js

@@ -0,0 +1,53 @@
+
+import request from '@/utils/request';
+
+/** 创建权限分发*/
+export function createDistribute(data) {
+    return request({
+        url: `/api/v3/permission/distribute/create`,
+        method: 'post',
+        data
+    });
+}
+
+/** 分页获取权限分发列表*/
+export function getDistributeList(data) {
+    return request({
+        url: `/api/v3/permission/distribute/paging`,
+        method: 'post',
+        data
+    });
+}
+
+// /** 设置权限分发立即失效*/
+// export function setDistributeInvalidate(pdId) {
+//     return request({
+//         url: `/api/v2/permission/distribute/${pdId}/invalidate`,
+//         method: 'put'
+//     });
+// }
+
+/** 获取权限分发明细*/
+export function getDistributeDetail(disId) {
+    return request({
+        url: `/api/v3/permission/distribute/list/distribute/${disId}`,
+        method: 'get'
+    });
+}
+
+/** 从权限分发，直接分发给指定主体*/
+export function setDistributeToSubject(pdId, subjectType, subjectId) {
+    return request({
+        url: `/api/v3/permission/distribute/${pdId}/to/${subjectType}/${subjectId}`,
+        method: 'post'
+    });
+}
+
+/** 生成分发二维码*/
+export function getDistributeQrCode(pdId) {
+    return request({
+        url: `/api/v3/permission/distribute/${pdId}/qrCode`,
+        method: 'get'
+    });
+}
+

src/api/contest.js

@@ -0,0 +1,416 @@
+import request from '@/utils/request';
+
+/**
+ * 获取竞赛试卷分页列表
+ * @param {Object} params
+ * @param {String} params.name 试卷名称
+ */
+export function getPaperList(params) {
+    return request({
+        url: '/api/exercise/race/paper/page',
+        method: 'GET',
+        params
+    });
+}
+
+/**
+ * 创建试卷
+ * @param {Object} data
+ * @param {String} data.name 试卷名称
+ * @param {String} data.desc 基础描述
+ * @param {Number} data.seasonId 所属赛季id
+ * @param {Boolean} data.supportCopy 是否支持拷贝
+ */
+export function createPaper(data) {
+    return request({
+        url: '/api/exercise/race/paper',
+        method: 'POST',
+        data
+    });
+}
+
+/** 修改试卷
+ * @param {Object} data  同创建试卷
+ * @param {Number} id 试卷id
+ */
+export function editPaper(id, data) {
+    return request({
+        url: `/api/exercise/race/paper/${id}`,
+        method: 'POST',
+        data
+    });
+}
+
+/** 删除指定试卷
+ * @param {Number} id 任务id
+ */
+export function deletePaper(id) {
+    return request({
+        url: `/api/exercise/race/paper/${id}`,
+        method: 'DELETE'
+    });
+}
+
+/**
+ * 获取竞赛试卷菜单
+ * @param {Object} params
+ * @param {String} params.group 分组ZZ=中职;GZ=高职
+ */
+export function getPaperMenu(params) {
+    return request({
+        url: '/api/exercise/race/paper/menu',
+        method: 'GET',
+        params
+    });
+}
+
+/** 模块修改任务设置
+ * @param {Object} data
+ * @param {Array} data.modules 所有模块
+ * @param {Number} data.modules[i].module_name 模块名字
+ * @param {Number} data.modules[i].duration 考试总时间
+ * @param {Number} data.modules[i].group 任务分组
+ * @param {Number} data.modules[i].group.taskIds 此分组中的任务id
+ * @param {Number} data.modules[i].group.name 此组的名字
+ * @param {Number} data.modules[i].group.group 此分组的子分组
+ */
+export function paperModuleTaskSetting(paperId, data) {
+    return request({
+        url: `/api/exercise/race/paper/${paperId}/config`,
+        method: 'POST',
+        data
+    });
+}
+
+/** 查看试卷明细
+ * @param {Number} id 模块id
+ */
+export function getPaperDetail(id) {
+    return request({
+        url: `/api/exercise/race/paper/${id}`,
+        method: 'GET'
+    });
+}
+
+/** 试卷拷贝
+ * @param {Number} id 模块id
+ */
+export function copyPaper(id) {
+    console.log(id);
+    return request({
+        url: `/api/exercise/race/paper/${id}/copy`,
+        method: 'PUT'
+    });
+}
+
+/** 查看所有任务数据 */
+export function getTaskTreeDatas() {
+    return request({
+        url: '/api/exercise/race/task/tree',
+        method: 'GET'
+    });
+}
+
+/**
+ * 创建任务
+ * @param {Object} data
+ * @param {String} data.name 任务名称
+ * @param {String} data.desc 基础描述
+ * @param {String} data.content 考核内容
+ * @param {String} data.standards 评价标准
+ * @param {Number} data.parentId 如果是子任务，需要父任务的id
+ */
+export function createTask(data) {
+    return request({
+        url: '/api/exercise/race/task',
+        method: 'POST',
+        data
+    });
+}
+
+/** 修改指定任务
+ * @param {Object} data  同创建任务
+ * @param {Number} id 任务id
+ */
+export function editTask(id, data) {
+    return request({
+        url: `/api/exercise/race/task/${id}`,
+        method: 'POST',
+        data
+    });
+}
+
+/** 删除指定任务
+ * @param {Number} id 任务id
+ */
+export function deleteTask(id) {
+    return request({
+        url: `/api/exercise/race/task/${id}`,
+        method: 'DELETE'
+    });
+}
+
+/** 查看任务详情
+ * @param {Number} id 任务id
+ */
+export function getTaskDetail(id) {
+    return request({
+        url: `/api/exercise/race/task/${id}`,
+        method: 'GET'
+    });
+}
+
+/** 查看指定子任务
+ * @param {Number} id 任务id
+ */
+export function getchildrenTaskDatas(id) {
+    return request({
+        url: `/api/exercise/race/task/${id}/children`,
+        method: 'GET'
+    });
+}
+
+/** 任务绑定
+ * @param {Array} data
+ * @param {Number} taskId 任务id
+ * @param {Number} data[i].bindId 绑定id，根据bindtype来区分对应的id
+ * @param {String} data[i].bindType rule =0评分规则;scene=1场景
+ * @param {Number} data[i].status 0=绑定 ；1=解绑
+ */
+export function bindTask(taskId, data) {
+    return request({
+        url: `/api/exercise/race/task/${taskId}/bind`,
+        method: 'POST',
+        data
+    });
+}
+/** 竞赛赛季添加
+ * @param {Object} data
+ * @param {Number} data.group 分组 1-高职 2中职
+ * @param {String} data.term 赛季
+ * @param {String} data.code 编号
+ */
+export function addContestSeason(data) {
+    return request({
+        url: '/api/exercise/race/season',
+        method: 'post',
+        data
+    });
+}
+/** 竞赛赛季分页查询
+ * @param {Object} params
+ * @param {Number} params.group 分组 1-高职 2中职
+ * @param {String} params.term 赛季
+ * @param {String} params.code 编号
+ */
+export function queryContestSeasonPaged(params) {
+    return request({
+        url: '/api/exercise/race/season/page',
+        method: 'get',
+        params
+    });
+}
+/** 竞赛赛季修改
+ * @param {Object} data
+ * @param {Number} id 赛季id
+ * @param {String} data.group 分组 ZZ=中职；GZ=高职
+ * @param {String} data.term 赛季
+ * @param {String} data.code 编号
+ */
+export function updateContestSeason(id, data) {
+    return request({
+        url: `/api/exercise/race/season/${id}`,
+        method: 'post',
+        data
+    });
+}
+/** 竞赛赛季删除
+ * @param {Number} id 赛季id
+ */
+export function deleteContestSeason(id) {
+    return request({
+        url: `/api/exercise/race/season/${id}`,
+        method: 'delete'
+    });
+}
+/** 竞赛评分创建基本信息
+ * @param {Object} data
+ * @param {String} data.name 名称
+ */
+export function createContextScore(data) {
+    return request({
+        url: '/api/exercise/race/score',
+        method: 'post',
+        data
+    });
+}
+/** 竞赛评分列表分页
+ * @param {Object} params
+ * @param {String} params.name 名称
+ */
+export function queryContextScorePaged(params) {
+    return request({
+        url: '/api/exercise/race/score/page',
+        method: 'get',
+        params
+    });
+}
+/** 竞赛评分删除
+ * @param {Number} id 评分id
+ */
+export function deleteContextScore(id) {
+    return request({
+        url: `/api/exercise/race/score/${id}`,
+        method: 'delete'
+    });
+}
+/** 竞赛评分修改评分详情内容
+ * @param {Number} id 评分id
+ * @param {Object} data
+ * @param {Array [object]} data.units 评分单元
+ * @param {String} data.units[0].text 文字描述
+ * @param {Number} data.units[0].sceneStepId 场景步骤ID
+ * @param {Number} data.units[0].score 分值
+ * @param {String} data.units[0].worker 作业程序
+ * @param {String} data.units[0].criteria 评分标准
+ */
+export function updateContextScoreDetail(id, data) {
+    return request({
+        url: `/api/exercise/race/score/edit/rule/${id}`,
+        method: 'post',
+        data
+    });
+}
+/** 竞赛评分详情
+ * @param {Number} id 评分id
+ */
+export function getContextScoreDetail(id) {
+    return request({
+        url: `/api/exercise/race/score/${id}`,
+        method: 'get'
+    });
+}
+/** 竞赛场景分页查询
+ *  @param {Object} params
+ * @param {String} params.type  竞赛类型 local=场景;link=3D
+ */
+export function queryContestSencePaged(params) {
+    return request({
+        url: '/api/exercise/race/scene/page',
+        method: 'get',
+        params
+    });
+}
+/** 竞赛场景删除
+ * @param {Number} id 场景id
+ */
+export function deleteContestSence(id) {
+    return request({
+        url: `/api/exercise/race/scene/${id}`,
+        method: 'delete'
+    });
+}
+/** 竞赛场景详情
+ * @param {Number} id 场景id
+ */
+export function getContextSenceDetail(id) {
+    return request({
+        url: `/api/exercise/race/scene/${id}`,
+        method: 'get'
+    });
+}
+/** 实训场景发布到大赛场景
+ * @param {Object} data
+ *  @param {Number} data.traningPublishId 草稿实训场景id
+ *  @param {String} data.name 大赛场景名称
+ */
+export function publishContextSence(data) {
+    return request({
+        url: `/api/exercise/race/scene/publish/training`,
+        method: 'post',
+        data
+    });
+}
+
+/** 场景视频保存
+ * @param {Object} data
+ *  @param {String} data.name 场景名称
+ *  @param {String} data.type Video=视频
+ *  @param {Object} data.scene 大赛场景
+ *  @param {String} data.scene.url 地址
+ *  @param {String} data.scene.fileName 文件名
+ */
+export function saveSceneVideo(data) {
+    return request({
+        url: `/api/exercise/race/scene/custom/edit`,
+        method: 'post',
+        data
+    });
+}
+
+/** 场景视频编辑 */
+export function editSceneVideo(sceneId, data) {
+    return request({
+        url: `/api/exercise/race/scene/custom/${sceneId}/edit`,
+        method: 'post',
+        data
+    });
+}
+
+/** 竞赛试卷测试模块任务集合
+ * 	@param {String} paperId 试卷id
+ * 	@param {String} moduleId 模块id
+ */
+export function getTaskTree(paperId, moduleId) {
+    return request({
+        url: `/api/exercise/race/paper/${paperId}/module/${moduleId}/task`,
+        method: 'get'
+    });
+}
+
+/** 竞赛开始训练
+ * 	@param {String} paperId 试卷id
+ * 	@param {String} moduleId 模块id
+ */
+export function beginContestExercise(paperId, moduleId) {
+    return request({
+        url: `/api/race/${paperId}/${moduleId}`,
+        method: 'POST'
+    });
+}
+
+/** 竞赛完成训练 */
+export function finishContestExercise() {
+    return request({
+        url: '/api/race/finish',
+        method: 'PUT'
+    });
+}
+
+/** 竞赛赛季html内容编辑
+* 	@param {String} id 赛季id
+* 	@param {String} data.htmlContent 内容
+*/
+export function editSeasonContent(id, data) {
+    return request({
+        url: `/api/exercise/race/season/${id}/html`,
+        method: 'post',
+        data
+    });
+}
+/** 竞赛赛季html内容获取
+ * @param {String} id 赛季id
+*/
+export function getSeasonContent(id) {
+    return request({
+        url: `/api/exercise/race/season/${id}/html`,
+        method: 'get'
+    });
+}
+
+export function getTheoryList() {
+    return request({
+        url: '/api/exercise/race/paper/questions',
+        method: 'get'
+    });
+}

src/api/disStation.js

@@ -24,10 +24,17 @@ export function deleteDisStation(mapId, code) {
     });
 }
 // 获取调度台逻辑数据
-export function getDisStationList(mapId, data) {
+export function getDisStationListPaged(mapId, data) {
     return request({
         url: `/api/draftMap/${mapId}/disStation/page`,
         method: 'post',
         data
     });
 }
+/** 查询调度台列表 */
+export function getDisStationList(mapId) {
+    return request({
+        url: `api/draftMap/${mapId}/disStation/list`,
+        method: 'get'
+    });
+}

src/api/functionManage.js

@@ -0,0 +1,26 @@
+import request from '@/utils/request';
+
+// 分页查询权限功能的基本信息
+export function getAbilityPage(data) {
+    return request({
+        url: `/api/v2/permission/system/ability/page`,
+        method: 'post',
+        data
+    });
+}
+
+// 自动生成
+export function autoCreate() {
+    return request({
+        url: `/api/v2/permission/system/ability/autoCreate`,
+        method: 'get'
+    });
+}
+
+// 获取所有功能
+export function getAllAbility() {
+    return request({
+        url: `/api/v2/permission/system/ability/list`,
+        method: 'get'
+    });
+}

src/api/jlmap3d/assets3d.js

@@ -4,10 +4,8 @@ const publicPath = process.env.VUE_APP_PRO == 'local' ? '' : '/cbtc';
 
 export const JL3D_LOCAL_STATIC = publicPath+"/static";
 const BASE_UPLOAD_API = store.state.user.uploadUrl;
-export const BASE_ASSET_API = store.state.user.resourcesUrl;
-// console.log(JL3D_LOCAL_STATIC);
-// console.log(BASE_UPLOAD_API);
-// console.log(BASE_ASSET_API);
+// export const BASE_ASSET_API = store.state.user.resourcesUrl;
+export const BASE_ASSET_API = store.state.user.ossUrl;
 
 export function getUploadModelUrl() {
 	return (BASE_UPLOAD_API+"/api/upload/MODEL?appId=00001&appSecret=joylink00001");

src/api/jlmap3d/load3ddata.js

@@ -2,85 +2,85 @@ import request from '@/utils/request';
 
 /** 根据皮肤获取地图版本信息*/
 export function getPublishMapVersion(id) {
-	return request({
-		url: `/api/map/${id}/version`,
-		method: 'get'
-	});
+    return request({
+        url: `/api/map/${id}/version`,
+        method: 'get'
+    });
 }
 
 /** 根据皮肤获取发布地图详细内容*/
 export function getPublishMapDetail(id) {
-	const datad = request({
-		url: `/api/map/${id}/graphData`,
-		method: 'get'
-	});
-	return datad.then();
+    const datad = request({
+        url: `/api/map/${id}/graphData`,
+        method: 'get'
+    });
+    return datad.then();
 }
 
 /** 根据地图id获取地图信息*/
 export function getPublishMapInfo(mapId) {
-	return request({
-		url: `/api/map/${mapId}`,
-		method: 'get'
-	});
+    return request({
+        url: `/api/map/${mapId}`,
+        method: 'get'
+    });
 }
 
 /** 获取草稿地图详细内容*/
 export function getMapDetail(id) {
-	return request({
-		url: `/api/mapBuild/${id}/mapDataDetail`,
-		method: 'get'
-	});
+    return request({
+        url: `/api/mapBuild/${id}/mapDataDetail`,
+        method: 'get'
+    });
 }
 
 /** 创建地图3d数据*/
 export function set3dMapData(data) {
-	return request({
-		url: `/api/mapBuild/3dMapData`,
-		method: 'post',
-		data: data
-	});
+    return request({
+        url: `/api/mapBuild/3dMapData`,
+        method: 'post',
+        data: data
+    });
 }
 
 /** 通过地图id获取地图3d数据*/
 export function get3dMapData(mapId) {
-	return request({
-		url: `/api/mapBuild/3dMapData/${mapId}`,
-		method: 'get'
-	});
+    return request({
+        url: `/api/mapBuild/3dMapData/${mapId}`,
+        method: 'get'
+    });
 }
 
 /** 更新地图3d数据*/
 export function update3dMapData(data) {
-	return request({
-		url: `/api/mapBuild/3dMapData/${data.id}`,
-		method: 'put',
-		data: data
-	});
+    return request({
+        url: `/api/mapBuild/3dMapData/${data.id}`,
+        method: 'put',
+        data: data
+    });
 }
 
 /** 获取模型资源列表*/
 export function loadmap3dModel() {
-	return request({
-		url: `/api/map3dModel/all`,
-		method: 'get'
-	});
+    return request({
+        url: `/api/map3dModel/all`,
+        method: 'get'
+    });
 }
 export function getPublish3dMapDetail(id) {
-	const datad = request({
-		url: `/api/map/${id}/3dMapData`,
-		method: 'get'
-	});
-	return datad.then();
+    const datad = request({
+        url: `/api/map/${id}/3dMapData`,
+        method: 'get'
+    });
+    return datad.then();
 }
 
 /** 录制托管*/
-export function tuoguan3ddrive(group,data) {
-	return request({
-		url: `/api/scriptSimulation/${group}/trust`,
-		method: 'put',
-		data: data
-	});
+export function tuoguan3ddrive(group, data) {
+    return request({
+        url: `/api/scriptSimulation/${group}/trust`,
+        method: 'put',
+        data: data
+    });
 }
 
 /** 三维设备故障钩锁操作*/
@@ -101,33 +101,33 @@ export function saveStationManagerData(data) {
     });
 }
 // 更新数据
-export function updateStationManagerData(id,data) {
-	return request({
-		url: `/api/pfp/${id}`,
-		method: 'put',
-		data: data
-	});
+export function updateStationManagerData(id, data) {
+    return request({
+        url: `/api/pfp/${id}`,
+        method: 'put',
+        data: data
+    });
 }
 // 查询数据列表
 export function getStationManagerDataList() {
-	const datad = request({
-		url: `/api/pfp/list`,
-		method: 'get'
-	});
-	return datad.then();
+    const datad = request({
+        url: `/api/pfp/list`,
+        method: 'get'
+    });
+    return datad.then();
 }
 // 查询数据
 export function getStationManagerData(id) {
-	const datad = request({
-		url: `/api/pfp/${id}`,
-		method: 'get'
-	});
-	return datad.then();
+    const datad = request({
+        url: `/api/pfp/${id}`,
+        method: 'get'
+    });
+    return datad.then();
 }
 // 删除数据
 export function deleteStationManagerData(id) {
-	return request({
-		url: `/api/pfp/${id}`,
-		method: 'delete',
-	});
+    return request({
+        url: `/api/pfp/${id}`,
+        method: 'delete'
+    });
 }

src/api/jmap/map.js

@@ -285,3 +285,47 @@ export function allSimulationCheck() {
         method: 'get'
     });
 }
+/** 根据地图查询仿真成员 */
+export function querySimulationMemberByMapId(id) {
+    return request({
+        url: `/api/map/${id}/memberMap`,
+        method: 'get'
+    });
+}
+
+/** 根据地图查询车站(含车辆段停车场) */
+export function querySimulationStationsByMapId(id) {
+    return request({
+        url: `/api/map/${id}/stations`,
+        method: 'get'
+    });
+}
+/** 根据用户查询地图列表 */
+export function queryMapListByUser() {
+    return request({
+        url: `/api/map/list/online/ofUser`,
+        method: 'get'
+    });
+}
+/** 根据mapId获取客户端信息数据 */
+export function getClientDataById(mapId) {
+    return request({
+        url: `/api/map/${mapId}/mapClientMap`,
+        method: 'get'
+    });
+}
+/** 发布地图根据id生成实训 */
+export function generateTrainingData(data) {
+    return request({
+        url: `/api/v2/training/rule/generate/mapId`,
+        method: 'post',
+        data: data
+    });
+}
+/** 根据mapId获取列车信息 */
+export function getTrainListByMapId(mapId) {
+    return request({
+        url: `/api/map/${mapId}/trains`,
+        method: 'get'
+    });
+}

src/api/jmap/training.js

@@ -190,18 +190,28 @@ export function publishTrainingDelete(data) {
         data
     });
 }
-/** 根据mapId查所有的已发布单操实训的基础信息 */
-export function getPublishSingleList(mapId) {
+/** 查全部组织已发布实训的基础信息 */
+export function getAllPublishTrainingList(params) {
     return request({
-        url: `/api/v2/training/published/${mapId}/singles`,
-        method: 'get'
+        url: `/api/v2/training/published/list`,
+        method: 'get',
+        params
     });
 }
-/** 根据mapId查所有的已发布场景实训的基础信息 */
-export function getPublishScenesList(mapId) {
+/** 查询组织已发布实训的基础信息 */
+export function getPublishTrainingListInOrg(data) {
     return request({
-        url: `/api/v2/training/published/${mapId}/scenes`,
-        method: 'get'
+        url: `/api/v2/training/published/infos`,
+        method: 'post',
+        data
+    });
+}
+/** 查询组织已发布的实训列表 */
+export function getManageTrainingListInOrg(data) {
+    return request({
+        url: `/api/v2/training/published/manage/infos`,
+        method: 'post',
+        data
     });
 }
 /** 根据实训id查该已发布实训的所有信息 */
@@ -234,10 +244,11 @@ export function startTraining(group, params) {
     });
 }
 /** 结束实训 */
-export function endTraining(group) {
+export function endTraining(group, data) {
     return request({
         url: `/api/training2Simulation/${group}/finish`,
-        method: 'put'
+        method: 'put',
+        data
     });
 }
 /** 实训完成步骤 */
@@ -254,3 +265,11 @@ export function loadTrainingBg(group, trainingId) {
         method: 'post'
     });
 }
+/** 预备开始场景 */
+export function prepareScene(group, params) {
+    return request({
+        url:`/api/training2Simulation/${group}/prepare/start`,
+        method: 'post',
+        params
+    });
+}

src/api/login.js

@@ -93,3 +93,33 @@ export function getLoginInfo(token) {
         }
     });
 }
+
+/**
+ * 获取用户所属组织列表
+ */
+export function getOrgList() {
+    return request({
+        url: '/api/orgProject/list',
+        method: 'get'
+    });
+}
+
+/**
+ * 登入组织
+ */
+export function selectOrgnization(orgId) {
+    return request({
+        url: `/api/orgProject/signIn/${orgId}`,
+        method: 'put'
+    });
+}
+
+/**
+ * 获取用户已经加入的仿真
+ */
+export function getSimulationJoined() {
+    return request({
+        url: '/simulation/joined/by/me',
+        method: 'get'
+    });
+}

src/api/management/exam.js

@@ -95,7 +95,7 @@ export function updateExamRule(data) {
     return request({
         url: `/api/exam/update/rules`,
         method: 'put',
-        data:data
+        data: data
     });
 }
 /** 检查并更新【规则数据异常】状态 */
@@ -106,9 +106,251 @@ export function checkAndUpdateAbnormal(mapId) {
     });
 }
 /** 重新生成考试规则 */
-export function regenerateRule (mapId) {
+export function regenerateRule(mapId) {
     return request({
         url: `/api/exam/regenerateRules/${mapId}`,
         method: 'put'
     });
 }
+
+/**
+ * ============================================================================
+ * ============================================================================
+ * ============================= 以下为新版试卷的接口 ============================
+ * ============================================================================
+ * ============================================================================
+ */
+
+/**
+ * LIST -
+ * 根据试卷蓝图名称简介分页查找某个组织的试卷蓝图
+ * @param {Object} data
+ * @param {Number} data.orgId 组织ID
+ * @param {String} data.name 试卷蓝图名称
+ * @param {String} data.profile 试卷蓝图简介
+ * @param {Number} data.findState 状态: (All(1)-所有,Editing(2)-正在编辑的,CanUse(3)-可以用于生成试卷的,Locked(4)-封存,Used(5)-已经被使用过)
+ * @param {Number} data.orderBy 排序依据: (1--创建时间 2--更新时间 3--名称；默认值为1)
+ */
+export function getPapaerListOfOrg({ orgId, ...data }) {
+    return request({
+        url: `/api/v2/paper/composition/find/page/for/${orgId}`,
+        method: 'POST',
+        data
+    });
+}
+
+export function getAllPapaerListOfOrg({ ...data }) {
+    // 全部组织
+    return request({
+        url: `/api/v2/paper/composition/manage/paging`,
+        method: 'POST',
+        data
+    });
+}
+
+/**
+ * 创建试卷蓝图
+ * @param {Object} data
+ * @param {Number} data.orgId 组织ID
+ * @param {String} data.name 试卷蓝图名称
+ * @param {String} data.profile 简介
+ * @param {String} data.startTime 启用起始时间
+ * @param {String} data.endTime 启用截止时间
+ * @param {Number} data.validDuration 考试时长
+ * @param {String} data.passScore 及格分
+ * @param {String} data.fullScore 满分
+ * @param {Object} data.ruleList 规则列表
+ * @param {Object} data.ruleList.id 规则id
+ * @param {Object} data.ruleList.pcId 试卷蓝图ID
+ * @param {Object} data.ruleList.type 试题类型
+ * @param {Object} data.ruleList.subtype 规则类型
+ * @param {Object} data.ruleList.tags 标签
+ * @param {Object} data.ruleList.amount 数量
+ * @param {Object} data.ruleList.score 每题分值
+ */
+export function createPaper(data) {
+    return request({
+        url: `/api/v2/paper/composition/${data.orgId}`,
+        method: 'POST',
+        data
+    });
+}
+
+/** 修改试卷蓝图基本信息
+ * @param {Object} data
+ * @param {Number} data.id 试卷蓝图ID
+ * @param {Number} data.orgId 组织ID
+ * @param {String} data.name 试卷蓝图名称
+ * @param {String} data.profile 简介
+ * @param {String} data.startTime 启用起始时间
+ * @param {String} data.endTime 启用截止时间
+ * @param {Number} data.validDuration 考试时长
+ * @param {String} data.passScore 及格分
+ * @param {String} data.fullScore 满分
+ * @param {Object} data.ruleList 规则列表
+ * @param {Object} data.ruleList.id 规则id
+ * @param {Object} data.ruleList.pcId 试卷蓝图ID
+ * @param {Object} data.ruleList.type 试题类型
+ * @param {Object} data.ruleList.subtype 规则类型
+ * @param {Object} data.ruleList.tags 标签
+ * @param {Object} data.ruleList.amount 数量
+ * @param {Object} data.ruleList.score 每题分值
+ */
+export function editPaper(data) {
+    return request({
+        url: `/api/v2/paper/composition`,
+        method: 'PUT',
+        data
+    });
+}
+
+/** 获取试卷完整的蓝图，包括规则
+ * @param {Number} pcId 试卷蓝图ID
+ */
+export function getPaperDetail(pcId) {
+    return request({
+        url: `/api/v2/paper/composition/${pcId}`,
+        method: 'GET'
+    });
+}
+
+/** 查询组织下各类型题的数量
+ * @param {Object} data
+ * @param {Number} data.orgId
+ * @param {Number} data.subtype
+ * @param {Array<String>} data.tags
+ */
+export function getQuestionAmount(data) {
+    return request({
+        url: `/api/v2/paper/question/count`,
+        method: 'POST',
+        data
+    });
+}
+
+/** 试卷蓝图封存
+ * @param {Number} pcId 试卷蓝图Id
+ */
+export function lockPaper(pcId) {
+    return request({
+        url: `/api/v2/paper/composition/${pcId}/lock`,
+        method: 'PUT'
+    });
+}
+
+/** 试卷蓝图
+ * @param {Number} pcId 试卷蓝图Id
+ */
+export function invalidPaper(pcId) {
+    return request({
+        url: `/api/v2/paper/composition/${pcId}/invalid`,
+        method: 'PUT'
+    });
+}
+
+/** 试卷蓝图删除
+ * @param {Number} pcId 试卷蓝图Id
+ */
+export function deletePaper(pcId) {
+    return request({
+        url: `/api/v2/paper/composition/${pcId}`,
+        method: 'DELETE'
+    });
+}
+
+/** 根据试卷蓝图生成用户的试卷
+ * @param {Number} pcId 试卷蓝图Id
+ */
+export function generateExam(pcId) {
+    return request({
+        url: `/api/v2/paper/${pcId}`,
+        method: 'POST'
+    });
+}
+
+/** 删除用户试卷 */
+// export function deleteUserExam(param) {
+//     return request({
+//         url: `/api/v2/paper/user/${puId}`,
+//         method: 'DELETE'
+//     });
+// }
+
+/** 获取用户试卷完整信息
+ * @param {Number} puId 用户试卷Id
+ */
+export function getUserExamInfo(puId) {
+    return request({
+        url: `/api/v2/paper/user/${puId}`,
+        method: 'GET'
+    });
+}
+
+/** 加载用户试卷试题 */
+export function loadQuestion({ type, questionId, puId }) {
+    return request({
+        url: `/api/v2/paper/user/question/${type}/${questionId}/${puId}`,
+        method: 'GET'
+    });
+}
+
+/** 提交答案
+ * @param {Object} data
+ * @param {Number} data.puId 用户试卷id
+ * @param {Number} data.pqId 用户试卷试题id
+ * @param {Number} data.type 试题类型
+ * @param {Number} data.subType 试题子类型
+ * @param {Number} data.answer 答案(理论题)
+ * @param {Boolean} data.trainingSuccess 是否完成(实训题)
+ */
+export function submitAnswer(data) {
+    return request({
+        url: `/api/v2/paper/user/question/answer`,
+        method: 'POST',
+        data
+    });
+}
+
+/** 交卷
+ * @param {Number} puId 用户试卷id
+ */
+export function submitPaper(puId) {
+    return request({
+        url: `/api/v2/paper/user/${puId}/submit`,
+        method: 'POST'
+    });
+}
+
+/**
+ * 根据mapId查询蓝图的基本信息
+ */
+export function queryPaperList(data) {
+    return request({
+        url: `/api/v2/paper/composition/find/list`,
+        method: 'POST',
+        data
+    });
+}
+/**
+*	获取标签分类
+ * @param {Number} ordId 组织id
+ * @param {Number} groupType 1-理论题 2-实训题
+ * @param {Number} subType 1-选择题 2-多选题 3-判断题 4-单操 5-场景
+*/
+export function queryTagList(data) {
+    return request({
+        url: `/api/v2/paper/question/label`,
+        method: 'POST',
+        data
+    });
+}
+/**
+ * 获取试卷创建者list
+ */
+export function queryPaperCreatorList(data) {
+    return request({
+        url: `/api/v2/paper/composition/list/creatorInfo`,
+		method: 'POST',
+		data
+    })
+}

src/api/management/fileManage.js

@@ -0,0 +1,45 @@
+import request from '@/utils/request.js'
+
+/** 获取文件列表 */
+export function getFileList(params) {
+	return request({
+		url: `/api/minio/file/list`,
+		method: 'get',
+		params,
+	})
+}
+
+/** 检查资源是否已存在 */
+export function checkIsExist(params) {
+	return request({
+		url: `/api/minio/checkIsExist`,
+		method: 'get',
+		params,
+	})
+}
+
+/** 保存文件 */
+export function saveFileInfo(data) {
+	return request({
+		url: `/api/minio/file/save`,
+		method: 'post',
+		data,
+	})
+}
+
+/** 更新文件标题 */
+export function updateFileTitle(data) {
+	return request({
+		url: `/api/minio/file/update`,
+		method: 'put',
+		data,
+	})
+}
+
+/** 删除文件 */
+export function deleteFile(id) {
+	return request({
+		url: `api/minio/file/del/${id}`,
+		method: 'delete',
+	})
+}

src/api/management/user.js

@@ -17,6 +17,32 @@ export function getUserList(params) {
     });
 }
 
+/** 查询所有用户列表*/
+export function getManageUserList(params) {
+    return request({
+        url: `/api/manage/user/list`,
+        method: 'get',
+        params: params
+    });
+}
+
+/** 根据用户查询用户角色列表*/
+export function getUserRolesList(uid) {
+    return request({
+        url: `/api/manage/${uid}/roles`,
+        method: 'get'
+    });
+}
+
+/** 绑定用户角色*/
+export function getBindUserRoles(data) {
+    return request({
+        url: `/api/manage/bind/org`,
+        method: 'post',
+        data
+    });
+}
+
 /** 模糊查询用户 昵称、名称、手机号*/
 export function getDimUserList(params) {
     return request({
@@ -269,3 +295,39 @@ export function sendEmailVfcode(params) {
         params
     });
 }
+
+/** 新注册接口 */
+export function registerUserNew(data) {
+    return request({
+        url: `/api/userinfo/register2`,
+        method: 'post',
+        data
+    });
+}
+
+// 手机号是否已经注册
+export function isExistMobile(params) {
+    return request({
+        url: `/api/userinfo/isExist/mobile`,
+        method: 'get',
+        params
+    });
+}
+
+// 手机号是否已经注册
+export function isExistEmail(params) {
+    return request({
+        url: `/api/userinfo/isExist/email`,
+        method: 'get',
+        params
+    });
+}
+
+// 成工院第三方登录
+export function cgyThirdLogin(data) {
+    return request({
+        url: '/api/login/cgy/third',
+        method: 'post',
+        data
+    });
+}

src/api/management/userexam.js

@@ -1,19 +1,19 @@
-import request from '@/utils/request';
+import request from '@/utils/request'
 
 /** 获取用户试题列表*/
 export function generateExamList(examId) {
     return request({
         url: `/api/userExam/${examId}/generate`,
-        method: 'get'
-    });
+        method: 'get',
+    })
 }
 
 /** 刷新考题列表*/
 export function refreshExamList(userExamId) {
     return request({
         url: `/api/userExam/${userExamId}`,
-        method: 'get'
-    });
+        method: 'get',
+    })
 }
 
 /** 提交一个考题*/
@@ -21,17 +21,16 @@ export function finishOneExamQuestion(data) {
     return request({
         url: '/api/userExam/finish',
         method: 'put',
-        data: data
-    });
+        data: data,
+    })
 }
 
 /** 考试完成提交*/
 export function submitExam(examId) {
     return request({
         url: `/api/userExam/${examId}/submit`,
-        method: 'put'
-    });
-
+        method: 'put',
+    })
 }
 
 /** 获取用户考试列表*/
@@ -39,40 +38,41 @@ export function getPublishExam(data) {
     return request({
         url: `/api/userExam/list`,
         method: 'get',
-        params: data
-    });
+        params: data,
+    })
 }
 
 /** 删除用户考试*/
 export function delPublishExam(id) {
     return request({
         url: `/api/userExam/${id}`,
-        method: 'delete'
-    });
+        method: 'delete',
+    })
 }
 
 export function updateExam(data) {
     return request({
         url: `/api/userExam/${data.id}`,
         method: 'put',
-        data: data
-    });
+        data: data,
+    })
 }
 /** 获取班级考试成绩列表 */
-export function getClassGradeList(examId, params) {
+export function getClassGradeList(params) {
     return request({
-        url: `/api/userExam/paged/orgUser/${params.orgId}/${examId}`,
+        url: `/api/v2/paper/user/page`,
         method: 'get',
-        params
-    });
+        params,
+    })
 }
 
 /** 查询组织学生单次考试成绩曲线 */
 export function getClassGradeStatistic(orgId, examId) {
     return request({
-        url: `/api/userExam/curve/${orgId}/${examId}`,
-        method: 'get'
-    });
+        url: `/api/v2/paper/user/curve`,
+        params: { pcId: examId, orgId },
+        method: 'get',
+    })
 }
 
 /** 查询组织学生单次考试成绩曲线 */
@@ -80,29 +80,29 @@ export function getStuGradeStatistic(userId) {
     return request({
         url: `/api/userExam/curve/${userId}`,
         method: 'get',
-    });
+    })
 }
 
 /** 个人仿真数据统计 */
 export function getSimulationTimeChart(mapId) {
     return request({
         url: `/api/stats/simulation/${mapId}/stats`,
-        method: 'get'
-    });
+        method: 'get',
+    })
 }
 
-// 课程内实训数据统计
-export function getLessonTimeChart(id) {
-	return request({
-		url: `/api/stats/lesson/${id}/stats`,
-		method: 'get'
-	});
-}
+// // 课程内实训数据统计
+// export function getLessonTimeChart(id) {
+//     return request({
+//         url: `/api/stats/lesson/${id}/stats`,
+//         method: 'get',
+//     })
+// }
 
 // 课程列表
 export function getLessonList() {
     return request({
         url: '/api/stats/lesson/list',
-        method: 'get'
-    });
+        method: 'get',
+    })
 }

src/api/newChat.js

@@ -0,0 +1,221 @@
+
+import request from '@/utils/request';
+
+/**
+ * 获取群列表
+ * @param {String} groupId 房间号
+ * @returns
+ */
+export function getGroupList(groupId) {
+    return request({
+        url: `/api/simulation/${groupId}/conversation/group/list`,
+        method: 'get'
+    });
+}
+
+/**
+ * 创建群
+ * @param {String} groupId 房间号
+ * @param {String} data
+ * @param {String} data.name 群组名称
+ * @param {String} data.imageUrl 群组头像
+ * @param {Array} data.memberIds 角色id列表
+ * @returns
+ */
+export function createGroup(groupId, data) {
+    return request({
+        url: `/simulation/${groupId}/operate/Conversation_Group_Create`,
+        method: 'post',
+        data
+    });
+}
+
+/**
+ * 修改群组名称
+ * @param {String} groupId 房间号
+ * @param {Object} data
+ * @param {String} data.id 群组id
+ * @param {String} data.name 群组名称
+ * @returns
+ */
+export function updateGroupName(groupId, data) {
+    return request({
+        url: `/simulation/${groupId}/operate/Conversation_Group_Update_Name`,
+        method: 'post',
+        data
+    });
+}
+
+/**
+ * 修改群组群主
+ * @param {String} groupId 房间号
+ * @param {Object} data
+ * @param {Number} data.id 群组id
+ * @param {String} data.memberId 角色id
+ * @returns
+ */
+export function updateGroupLeader(groupId, data) {
+    return request({
+        url: `/simulation/${groupId}/operate/Conversation_Group_Update_Leader`,
+        method: 'post',
+        data
+    });
+}
+
+/**
+ * 邀请人员入群
+ * @param {String} groupId 房间号
+ * @param {Object} data
+ * @param {Number} data.id 群组id
+ * @param {Array} data.memberIds 角色id列表
+ * @returns
+ */
+export function inviteMemberToGroup(groupId, data) {
+    return request({
+        url: `/simulation/${groupId}/operate/Conversation_Group_Invite_Member`,
+        method: 'post',
+        data
+    });
+}
+
+/**
+ * 移除群内人员
+ * @param {String} groupId 房间号
+ * @param {Object} data
+ * @param {Number} data.id 群组id
+ * @param {Array} data.memberIds 角色id列表
+ * @returns
+ */
+export function removeMemberFromGroup(groupId, data) {
+    return request({
+        url: `/simulation/${groupId}/operate/Conversation_Group_Remove_Member`,
+        method: 'post',
+        data
+    });
+}
+
+/**
+ * 退出群组
+ * @param {String} groupId 房间号
+ * @param {Object} data
+ * @param {Number} data.id 群组id
+ * @returns
+ */
+export function exitGroup(groupId, data) {
+    return request({
+        url: `/simulation/${groupId}/operate/Conversation_Group_Exit`,
+        method: 'post',
+        data
+    });
+}
+
+/**
+ * 解散群组
+ * @param {String} groupId 房间号
+ * @param {Object} data
+ * @param {Number} data.id 群组id
+ * @returns
+ */
+export function dissolveGroup(groupId, data) {
+    return request({
+        url: `/simulation/${groupId}/operate/Conversation_Group_Dissolve`,
+        method: 'post',
+        data
+    });
+}
+
+/**
+ * 发送语音信息
+ * @param {String} groupId 房间号
+ * @param {Object} data
+ * @param {Number} data.id 群组id
+ * @param {String} data.audioPath 文件地址
+ * @param {String} data.content 语音内容
+ * @returns
+ */
+export function sendAudio(groupId, data) {
+    return request({
+        url: `/simulation/${groupId}/operate/Conversation_Group_Audio_Chat`,
+        method: 'post',
+        data
+    });
+}
+
+/**
+ * 发送文字信息
+ * @param {String} groupId 房间号
+ * @param {Object} data
+ * @param {Number} data.id 群组id
+ * @param {String} data.content 文字内容
+ * @returns
+ */
+export function sendText(groupId, data) {
+    return request({
+        url: `/simulation/${groupId}/operate/Conversation_Group_Text_Chat`,
+        method: 'post',
+        data
+    });
+}
+
+/**
+ * 发送BASE64信息
+ * @param {String} groupId 房间号
+ * @param {Object} data
+ * @param {Number} data.id 群组id
+ * @param {String} data.fileBase64Str 文件base64码
+ * @returns
+ */
+export function sendBase64(groupId, data) {
+    return request({
+        url: `/simulation/${groupId}/operate/Conversation_Group_Audio_Base64`,
+        method: 'post',
+        data
+    });
+}
+
+/**
+ * 设置群消息已读
+ * @param {String} groupId 房间号
+ * @param {Object} data
+ * @param {Number} data.id 群组id
+ * @returns
+ */
+export function setGroupReadMessage(groupId, data) {
+    return request({
+        url: `/simulation/${groupId}/operate/Conversation_Group_Read_Message`,
+        method: 'post',
+        data
+    });
+}
+
+/**
+ * 发送私聊文字信息
+ * @param {String} groupId 房间号
+ * @param {Object} data
+ * @param {Number} data.memberId 角色id
+ * @param {String} data.content 文字内容
+ * @returns
+ */
+export function sendPrivateText(groupId, data) {
+    return request({
+        url: `/simulation/${groupId}/operate/Conversation_Group_Private_Text_Chat`,
+        method: 'post',
+        data
+    });
+}
+
+/**
+ * 发送私聊BASE64信息
+ * @param {String} groupId 房间号
+ * @param {Object} data
+ * @param {Number} data.memberId 角色id
+ * @param {String} data.fileBase64Str 文件base64码
+ * @returns
+ */
+export function sendPrivateBase64(groupId, data) {
+    return request({
+        url: `/simulation/${groupId}/operate/Conversation_Group_Private_Audio_Base64`,
+        method: 'post',
+        data
+    });
+}

src/api/permissionManage.js

@@ -0,0 +1,28 @@
+import request from '@/utils/request';
+
+// 创建权限
+export function createPermission(data) {
+    return request({
+        url: `/api/v2/permission/create`,
+        method: 'post',
+        data
+    });
+}
+
+// 权限修改
+export function updatePermission(data) {
+    return request({
+        url: `/api/v2/permission/update`,
+        method: 'put',
+        data
+    });
+}
+
+// 分页获取权限
+export function getPermissionPage(data) {
+    return request({
+        url: `/api/v2/permission/find/page`,
+        method: 'post',
+        data
+    });
+}

src/api/project.js

@@ -61,10 +61,10 @@ export function setLwConfig(id, data) {
         data: data
     });
 }
-/** 查询所有的某类型设备 */
-export function getDevicesByType(type) {
+/** 查询某个项目下的所有的某类型设备 */
+export function getDevicesByType(project, type) {
     return request({
-        url: `/api/device/${type}/all`,
+        url: `/api/device/${project}/${type}/all`,
         method: 'get'
     });
 }
@@ -144,3 +144,10 @@ export function setDeviceConfig(data) {
         data: data
     });
 }
+/** 获取所有项目 */
+export function getAllProject() {
+    return request({
+        url: `/api/project/all `,
+        method: 'get'
+    });
+}

src/api/projectConfig.js

@@ -0,0 +1,187 @@
+import request from '@/utils/request';
+
+/** 后端项目配置分页 */
+export function getBackProjectConfigByPage(params) {
+    return request({
+        url: `/api/project/page`,
+        method: 'get',
+        params
+    });
+}
+
+/** 全量后端项目配置 */
+export function getAllBackProjectConfig() {
+    return request({
+        url: `/api/project/all`,
+        method: 'get'
+    });
+}
+
+/** 主键获取后端项目配置 */
+export function getBackProjectConfigById(id) {
+    return request({
+        url: `/api/project/${id}`,
+        method: 'get'
+    });
+}
+
+/** 通过code获取后端项目配置 */
+export function getBackProjectConfigByCode(code) {
+    return request({
+        url: `/api/project/code/${code}`,
+        method: 'get'
+    });
+}
+
+/** 删除后端项目配置 */
+export function deleteBackProjectConfig(id) {
+    return request({
+        url: `/api/project/del/${id}`,
+        method: 'delete'
+    });
+}
+
+/** 更新后端项目配置 */
+export function updateBackProjectConfig(data) {
+    return request({
+        url: `/api/project/update`,
+        method: 'put',
+        data
+    });
+}
+
+/** 保存后端项目配置 */
+export function saveBackProjectConfig(data) {
+    return request({
+        url: `/api/project/save`,
+        method: 'POST',
+        data
+    });
+}
+
+/** 获取后端项目列表，关联时使用 */
+export function getBackProjectConfigList(id) {
+    return request({
+        url: `/api/project/simple`,
+        method: 'get'
+    });
+}
+
+/** 前端项目配置分页 */
+export function getFrontProjectConfigByPage(params) {
+    return request({
+        url: `/api/project/viewSetting/page`,
+        method: 'get',
+        params
+    });
+}
+
+/** 全量前端项目配置 */
+export function getAllFrontProjectConfig() {
+    return request({
+        url: `/api/project/viewSetting/all`,
+        method: 'get'
+    });
+}
+
+/** 获取前端项目配置 */
+export function getFrontProjectConfigById(id) {
+    return request({
+        url: `/api/project/viewSetting/${id}`,
+        method: 'get'
+    });
+}
+
+/** 删除前端项目配置 */
+export function deleteFrontProjectConfig(id) {
+    return request({
+        url: `/api/project/viewSetting/del/${id}`,
+        method: 'delete'
+    });
+}
+
+/** 更新前端项目配置 */
+export function updateFrontProjectConfig(data) {
+    return request({
+        url: `/api/project/viewSetting/update`,
+        method: 'put',
+        data
+    });
+}
+
+/** 保存前端项目配置 */
+export function saveFrontProjectConfig(data) {
+    return request({
+        url: `/api/project/viewSetting/save`,
+        method: 'POST',
+        data
+    });
+}
+
+/** 登录时根据前端标识获取配置 */
+export function getFrontProjectConfigByLogin(markKey) {
+    return request({
+        url: `/api/project/viewSetting/project/${markKey}`,
+        method: 'get'
+    });
+}
+
+/** 登录时获取全量前端配置 */
+export function getAllFrontProjectConfigByLogin(markKey) {
+    return request({
+        url: `/api/project/viewSetting/simple/all`,
+        method: 'get'
+    });
+}
+
+/** 检查项目code */
+export function checkBackProjectExist(params) {
+    return request({
+        url: `/api/project/check/code`,
+        method: 'get',
+        params
+    });
+}
+
+/** 检查项目markKey */
+export function checkFrontProjectExist(params) {
+    return request({
+        url: `/api/project/check/markKey`,
+        method: 'get',
+        params
+    });
+}
+//
+export function getUploadUrl(params) {
+    return request({
+        url: `/api/minio/preSignedUrl`,
+        method: 'get',
+        params
+    });
+}
+
+/** 设置默认组织 */
+export function setDefaultOrg(data) {
+    return request({
+        url: `/api/project/setDefaultOrg`,
+        method: 'put',
+        data
+    });
+}
+
+/** 创建默认组织 */
+export function createDefaultOrg(id, data) {
+    return request({
+        url: `/api/project/${id}/createDefaultOrg`,
+        method: 'POST',
+        data
+    });
+}
+
+/** 登录项目组织列表 */
+export function getOrgList(id) {
+    return request({
+        url: `/api/project/${id}/orgList`,
+        method: 'get'
+    });
+}

src/api/questionBank.js

@@ -1,18 +1,45 @@
 import request from '@/utils/request';
 
+// 查询理论试题(全部组织)
+export function listAllQuestionPage(params) {
+    return request({
+        url: `/api/question/paging`,
+        method: 'get',
+        params
+    });
+}
+
 // 分页查询理论试题
 export function listQuestionPage(params) {
     return request({
-        url: `/api/questionBank/questions/paging`,
+        // url: `/api/questionBank/questions/paging`,
+        url: `/api/question/org/paging`,
         method: 'get',
         params
     });
 }
 
+// 查询所有理论试题
+export function listQuestionAll() {
+    return request({
+        url: `/api/question/org`,
+        method: 'get'
+    });
+}
+
+// 标签列表
+export function getLabelList() {
+    return request({
+        url: `/api/question/org/label`,
+        method: 'get'
+    });
+}
+
 // 创建题目
 export function createQuestion(data) {
     return request({
-        url: `/api/questionBank/questions`,
+        // url: `/api/questionBank/questions`,
+        url: `/api/question/org`,
         method: 'post',
         data
     });
@@ -21,25 +48,55 @@ export function createQuestion(data) {
 // 删除题目
 export function deleteQuestion(questionId) {
     return request({
-        url: `/api/questionBank/questions/${questionId}`,
-        method: 'delete'
+        // url: `/api/questionBank/questions/${questionId}`,
+        url: `/api/question/org`,
+        method: 'delete',
+        data: [questionId]
     });
 }
 
 // 更新题目
 export function updateOption(data) {
     return request({
-        url: `/api/questionBank/questions/${data.id}`,
+        // url: `/api/questionBank/questions/${data.id}`,
+        url: `/api/question/org/${data.id}`,
         method: 'put',
         data
     });
 }
 
 // 获取题目信息
-export function getQuestionInfo(questionId) {
+export function getQuestionInfo(questionId, params) {
     return request({
-        url: `/api/questionBank/questions/${questionId}`,
-        method: 'get'
+        // url: `/api/questionBank/questions/${questionId}`,
+        url: `/api/question/org/${questionId}`,
+        method: 'get',
+        params
     });
 }
 
+// 题库批量导入
+export function importQuestion(data) {
+    return request({
+        url: `/api/question/org/import`,
+        method: 'post',
+        data
+    });
+}
+
+// 预览答题
+export function testAnswer(questionId, data) {
+    return request({
+        url: `/api/question/org/test/answer/${questionId}`,
+        method: 'post',
+        data
+    });
+}
+
+// 清空题库
+export function clearBank() {
+    return request({
+        url: `/api/question/org/clear`,
+        method: 'get'
+    });
+}

src/api/race.js

@@ -15,3 +15,20 @@ export function selectQuestionTypeNum(companyId) {
         method: 'get'
     });
 }
+
+/** 加载场景 */
+export function loadRace(simulationId, sceneId) {
+    return request({
+        url: `/api/race/${simulationId}/load/${sceneId}`,
+        method: 'put'
+    });
+
+}
+/** 完成任务 */
+export function overTask(taskId, data) {
+    return request({
+        url: `/api/race/${taskId}/finish`,
+        method: 'put',
+        data
+    });
+}

src/api/record.js

@@ -0,0 +1,10 @@
+import request from '@/utils/request';
+
+/** 查询用户使用记录统计 */
+export function queryUserSimulationRecord(params, userId) {
+    return request({
+        url: `/api/record/stats/list/criteria/${userId}`,
+        method: 'get',
+        params
+    });
+}

src/api/rtSimulation.js

@@ -6,29 +6,15 @@ export function createSimulation(data) {
         method: 'post'
     });
 }
-/** 根据仿真group获取仿真基础信息 */
+/** 根据仿真group获取仿真基础信息 废弃 */
 export function getSimulationInfoByGroup(groupId) {
     return request({
         url: `/common/simulation/${groupId}`,
         method: 'get'
     });
 }
-/** 根据仿真group获取仿真地图数据 */
-export function getMapDataByGroup(groupId) {
-    return request({
-        url: `/rtSimulation/${groupId}/mapData`,
-        method: 'get'
-    });
-}
-/** 仿真发送指令 */
-export function sendSimulationCommand(group, memberId, type, data) {
-    return request({
-        url: `/common/simulation/${group}/member/${memberId}/operate/${type}`,
-        method: 'post',
-        data
-    });
-}
-/** 获取仿真成员列表 */
+
+/** 获取仿真成员列表 废弃 */
 export function getMemberListCommon(group, role) {
 
     if (!role) {
@@ -39,14 +25,14 @@ export function getMemberListCommon(group, role) {
         method: 'get'
     });
 }
-/** 获取仿真用户列表 */
+/** 获取仿真用户列表 废弃 */
 export function getUserListCommon(group) {
     return request({
         url: `/common/simulation/${group}/users`,
         method: 'get'
     });
 }
-/** 销毁仿真 */
+/** 销毁仿真 废弃 */
 export function destroySimulation(group) {
     return request({
         url: `/common/simulation/${group}/destroy`,
@@ -56,11 +42,11 @@ export function destroySimulation(group) {
 /** 初始化仿真 */
 export function initSimulation(group) {
     return request({
-        url: `/common/simulation/${group}/init`,
+        url: `/simulation/new/${group}/reset`,
         method: 'put'
     });
 }
-/** 设置故障 */
+/** 设置故障 废弃 */
 export function setSimulationFault(group, data) {
     return request({
         url: `/common/simulation/${group}/fault`,
@@ -68,7 +54,7 @@ export function setSimulationFault(group, data) {
         data
     });
 }
-/** 取消故障 */
+/** 取消故障 废弃 */
 export function cancelSimulationFault(group, deviceId, faultType) {
     return request({
         url: `/common/simulation/${group}/device/${deviceId}/fault/${faultType}`,
@@ -78,28 +64,28 @@ export function cancelSimulationFault(group, deviceId, faultType) {
 /** 仿真运行倍速 */
 export function timesSpeedPlayback(group, speed) {
     return request({
-        url: `/common/simulation/${group}/updateSpeed/${speed}`,
+        url: `/simulation/${group}/updateSpeed/${speed}`,
         method: 'put'
     });
 }
 /** 仿真暂停 */
 export function simulationPause(group) {
     return request({
-        url: `/common/simulation/${group}/pause`,
+        url: `/simulation/${group}/pause`,
         method: 'put'
     });
 }
 /** 仿真开始 */
 export function simulationStart(group) {
     return request({
-        url: `/common/simulation/${group}/start`,
+        url: `/simulation/${group}/start`,
         method: 'put'
     });
 }
 /** 获取存在的仿真列表 */
 export function getExistSimulationList(params) {
     return request({
-        url: `/common/simulation/list`,
+        url: `/simulation/list`,
         method: 'get',
         params
     });
@@ -107,7 +93,15 @@ export function getExistSimulationList(params) {
 /** 获取仿真用户信息 */
 export function getSimulationUserInfo(id) {
     return request({
-        url: `/common/simulation/${id}/users`,
+        url: `/simulation/${id}/users`,
         method: 'get'
     });
 }
+/** 监管仿真 */
+export function getSuperviseSimulation(params) {
+    return request({
+        url: `/simulation/supervise`,
+        method: 'get',
+        params
+    });
+}

src/api/simulation.js

@@ -47,39 +47,39 @@ export function examNotifyNew({ examId }) {
     });
 }
 /** 获取用户实训列表*/
-export function getSimulationList(data) {
-    return request({
-        url: `/api/stats/simulation`,
-        method: 'get',
-        params: data
-    });
-}
+// export function getSimulationList(data) {
+//     return request({
+//         url: `/api/stats/simulation`,
+//         method: 'get',
+//         params: data
+//     });
+// }
 
-/** 添加用户仿真数据*/
-export function postSimulationStats(data) {
-    return request({
-        url: `/api/stats/simulation`,
-        method: 'post',
-        data: data
-    });
-}
+// /** 添加用户仿真数据*/
+// export function postSimulationStats(data) {
+//     return request({
+//         url: `/api/stats/simulation`,
+//         method: 'post',
+//         data: data
+//     });
+// }
 
-/** 更新用户仿真数据*/
-export function putSimulationStats(data) {
-    return request({
-        url: `/api/stats/${data.id}`,
-        method: 'put',
-        data: data
-    });
-}
+// /** 更新用户仿真数据*/
+// export function putSimulationStats(data) {
+//     return request({
+//         url: `/api/stats/${data.id}`,
+//         method: 'put',
+//         data: data
+//     });
+// }
 
 /** 删除用户仿真数据*/
-export function deleteSimulationStats(statsId) {
-    return request({
-        url: `/api/stats/${statsId}`,
-        method: 'delete'
-    });
-}
+// export function deleteSimulationStats(statsId) {
+//     return request({
+//         url: `/api/stats/${statsId}`,
+//         method: 'delete'
+//     });
+// }
 
 /** 录制脚本仿真(新版)*/
 export function scriptRecordNotifyNew(scriptId) {
@@ -228,22 +228,22 @@ export function handlerIbpEvent(group, button, stationCode, buttonCode) {
     });
 }
 
-/** 处理ibp盘事件(按下) */
-
-export function handleIbpPress(group, stationCode, buttonCode) {
-    return request({
-        url: `/simulation/${group}/ibp/press/${stationCode}/${buttonCode}`,
-        method: 'put'
-    });
-}
-/** 处理ibp盘事件(松开) */
-
-export function handleIbpRelease(group, stationCode, buttonCode) {
-    return request({
-        url: `/simulation/${group}/ibp/release/${stationCode}/${buttonCode}`,
-        method: 'put'
-    });
-}
+// /** 处理ibp盘事件(按下) */
+//
+// export function handleIbpPress(group, stationCode, buttonCode) {
+//     return request({
+//         url: `/simulation/${group}/ibp/press/${stationCode}/${buttonCode}`,
+//         method: 'put'
+//     });
+// }
+// /** 处理ibp盘事件(松开) */
+//
+// export function handleIbpRelease(group, stationCode, buttonCode) {
+//     return request({
+//         url: `/simulation/${group}/ibp/release/${stationCode}/${buttonCode}`,
+//         method: 'put'
+//     });
+// }
 
 /** 预览脚本仿真（新版）*/
 export function scriptDraftRecordNotifyNew(scriptId) {
@@ -296,7 +296,7 @@ export function modifySystemTime(data, group) {
 /** 新版地图按计划行车 */
 export function ranAsPlan(data, group) {
     return request({
-        url: `/simulation/${group}/ranAsPlan`,
+        url: `/simulation/new/${group}/runAsPlan`,
         method: 'post',
         data: data
     });
@@ -349,6 +349,15 @@ export function simulationLoadRunPlan(group, templateId) {
         method: 'put'
     });
 }
+
+/** 仿真里加载草稿运行图 */
+export function simulationLoadDraftRunPlan(group, draftRunPlanId) {
+    return request({
+        url:`/simulation/${group}/load/draftRunPlan/${draftRunPlanId} `,
+        method: 'put'
+    });
+}
+
 /** 根据车次号获取列车信息 */
 export function getTrainDetailBytripNumber(group, params) {
     return request({
@@ -506,10 +515,10 @@ export function getStandListByRunLineOrTrainCode(group, params) {
         params
     });
 }
-/** 上饶列车控制 */
-export function srTrainControl(group, params) {
+/** 沙盘列车控制 */
+export function sandTableTrainControl(group, params) {
     return request({
-        url: `/api/sr/${group}/control`,
+        url: `/api/sandTable/${group}/control`,
         method: 'put',
         params
     });
@@ -537,3 +546,64 @@ export function queryPaTimedList(group, params) {
         params
     });
 }
+/** 创建仿真 */
+export function createSimulation(id) {
+    return request({
+        url: `/simulation/new/mapFunction/${id}`,
+        method: 'post'
+    });
+}
+
+/** 根据地图ID和功能ID获取仿真GroupId */
+export function getGroupByMapAndFunction(mapId, functionId) {
+    return request({
+        url: `/simulation/new/map/${mapId}/function/${functionId}`,
+        method: 'get'
+    });
+}
+/** 由系统管理员和教员销毁仿真 */
+export function destroySimulationByAdmin(group) {
+    return request({
+        url: `/simulation/${group}/destroy`,
+        method: 'delete'
+    });
+}
+
+/** 非仿真创建者退出仿真 */
+export function exitSimulation(group) {
+    return request({
+        url: `/simulation/${group}/exit`,
+        method: 'put'
+    });
+}
+/** 仿真监管那里进入仿真 */
+export function enterSimulationByTeacher(group) {
+    return request({
+        url: `/simulation/${group}/monitor`,
+        method: 'post'
+    });
+}
+/** 切换角色后触发消息 */
+export function getUnreceivedMessages(simulationId, memberId) {
+    return request({
+        url: `/simulation/${simulationId}/${memberId}/unreceivedMessages`,
+        method: 'get'
+    });
+}
+
+/** 控制叶佳供货的小车 */
+export function controlYjTrain(simulationId, right) {
+    return request({
+        url: `/api/realDevice/${simulationId}/train`,
+        method: 'put',
+        params: { right }
+    });
+}
+/** 创建仿真（不通过功能id） */
+export function createSimulationNoFunction(mapId, data) {
+    return request({
+        url: `/simulation/new/${mapId}`,
+        method: 'post',
+        data
+    });
+}

src/api/thirdAccountConfig.js

@@ -0,0 +1,27 @@
+import request from '@/utils/request';
+
+/** 删除第三方配置 */
+export function deleteThirdAccountConfig(id) {
+    return request({
+        url: `/api/thirdAccountConfig/${id}`,
+        method: 'delete'
+    });
+}
+
+/** 分页查询所有配置 */
+export function queryThirdAccountConfig(params) {
+    return request({
+        url: `/api/thirdAccountConfig/paged`,
+        method: 'get',
+        params
+    });
+}
+
+/** 新增或更新第三方配置 */
+export function updateThirdAccountConfig(data) {
+    return request({
+        url: `/api/thirdAccountConfig`,
+        method: 'post',
+        data
+    });
+}

src/api/trainingManage.js

@@ -32,6 +32,21 @@ export function updateTraining(data) {
         data
     });
 }
+/** 更新发布实训信息（标签， 描述， 标题） */
+export function updateTrainingInfo(data) {
+    return request({
+        url: `/api/v2/training/published/update`,
+        method: 'put',
+        data
+    });
+}
+/** 已发布实训转为草稿 */
+export function saveAsTrainingDraft(trainingId) {
+    return request({
+        url: `/api/v2/training/published/${trainingId}/saveAsDraft`,
+        method: 'post'
+    });
+}
 /** 查询步骤列表 */
 export function getTrainingStepList(trainingId) {
     return request({
@@ -41,7 +56,6 @@ export function getTrainingStepList(trainingId) {
 }
 /** 修改实训所有步骤 */
 export function updateTrainingStep(group, trainingId, data) {
-    console.log(group, trainingId, '*******');
     return request({
         url: `/api/v2/draft/training/${group}/${trainingId}/step/update`,
         method: 'put',
@@ -152,10 +166,33 @@ export function getTrainingGradeRules(trainingId) {
         method: 'get'
     });
 }
-/** 清空步骤 */
-export function clearTrainingStep(trainingId) {
+/** 清空重置实训 */
+export function clearDesignTraining(trainingId, group) {
     return request({
-        url: `/api/v2/draft/training/${trainingId}/step/clear`,
+        url: `/api/v2/draft/training/${group}/reset/${trainingId}`,
         method: 'delete'
     });
 }
+/** 导出实训数据 */
+export function exportTrainingData(data) {
+    return request({
+        url: `/api/v2/training/published/export`,
+        method: 'post',
+        data
+    });
+}
+/** 导入实训数据 */
+export function importTrainingData(data) {
+    return request({
+        url: `/api/v2/training/published/import`,
+        method: 'post',
+        data
+    });
+}
+/** 实训跳转到当前步骤*/
+export function jumpToTraining(group, stepId) {
+    return request({
+        url: `/api/training2Simulation/${group}/jumpTo/${stepId}`,
+        method: 'put'
+    });
+}

src/api/trainingPlatform.js

@@ -75,4 +75,129 @@ export function getSubSystemByProjectCode() {
         method: 'get'
     });
 }
+/** 创建地图系统 */
+export function createMapFunction(data) {
+    return request({
+        url: `/api/mapFunction`,
+        method: 'post',
+        data
+    });
+}
+/** 列表查询地图系统 */
+export function queryMapFunctionList(params) {
+    return request({
+        url: `/api/mapFunction/list`,
+        method: 'get',
+        params
+    });
+}
+/** 更新地图系统 */
+export function updateMapFunction(data) {
+    return request({
+        url: `/api/mapFunction/${data.id}`,
+        method: 'put',
+        data
+    });
+}
+/** 删除地图系统 */
+export function deleteMapFunction(id) {
+    return request({
+        url: `/api/mapFunction/${id}`,
+        method: 'delete'
+    });
+}
+/** 分页查询地图系统 */
+export function queryMapFunctionPaged(params) {
+    return request({
+        url: `/api/mapFunction/paged`,
+        method: 'get',
+        params
+    });
+}
+/** 生成地图子系统 */
+export function generateMapFunctionNew(mapId, data) {
+    return request({
+        url: `/api/mapFunction/${mapId}/generate`,
+        method: 'post',
+        data
+    });
+}
 
+/** 根据id查询地图系统 */
+export function getMapFunctioById(id) {
+    return request({
+        url: `/api/mapFunction/${id}`,
+        method: 'get'
+    });
+}
+
+/** 一键删除地图下所有线路功能 */
+export function deleteAllMapFunction(mapId) {
+    return request({
+        url: `/api/mapFunction/batch/${mapId}`,
+        method: 'delete'
+    });
+}
+/** 新增分组 */
+export function updateMapFunctionSubset(data) {
+    return request({
+        url: `/api/mapFunction/group`,
+        method: 'put',
+        data
+    });
+}
+/** 根据模板生成地图功能 */
+export function generateMapFunctionByTemplate(data) {
+    return request({
+        url: `/api/mapFunction/generate/from/template`,
+        method: 'post',
+        data
+    });
+}
+/** 创建模板线路功能 */
+export function createTemplateMapFunction(data) {
+    return request({
+        url: `/api/mapFunction/template`,
+        method: 'post',
+        data
+    });
+}
+/** 修改模板线路功能 */
+export function updateTemplateMapFunction(data) {
+    return request({
+        url: `/api/mapFunction/template/${data.id}`,
+        method: 'put',
+        data
+    });
+}
+/** 删除模板线路功能 */
+export function deleteTemplateMapFunction(id) {
+    return request({
+        url: `/api/mapFunction/template/${id}`,
+        method: 'delete'
+    });
+}
+/** 查询模板线路功能列表 */
+export function queryTemplateMapFunctionList(params) {
+    return request({
+        url: `/api/mapFunction/template/list`,
+        method: 'get',
+        params
+    });
+}
+/** 分页查询模板线路功能列表 */
+export function queryTemplateMapFunPaged(params) {
+    return request({
+        url: `/api/mapFunction/template/paged`,
+        method: 'get',
+        params
+    });
+}
+/** 线路功能覆盖生成（主要用于客户端重新生成后线路功能里客户端重新匹配） */
+export function generateMapFun(data) {
+    return request({
+        url: `/api/mapFunction/generate/mapIds`,
+        method: 'post',
+        data
+    });
+}

src/api/userRulesManage.js

@@ -0,0 +1,35 @@
+
+import request from '@/utils/request';
+
+/** 设置权限失效或有效*/
+export function setPermissonInValid(subjectId) {
+    return request({
+        url: `/api/v2/permission/subject/inValid/${subjectId}`,
+        method: 'get'
+    });
+}
+
+/** 用户权限列表*/
+export function listPermision(params) {
+    return request({
+        url: `/api/v2/permission/subject/page`,
+        method: 'get',
+        params: params
+    });
+}
+
+/** 查看用户分发的下级所有用户权限*/
+export function getPermissonInDistribute(subjectId) {
+    return request({
+        url: `/api/v2/permission/subject/distribute/${subjectId}`,
+        method: 'get'
+    });
+}
+
+/** 查看当前mapId 下用户的所有权限及功能*/
+export function getMapIdPermisson(mapId) {
+    return request({
+        url: `/api/v2/permission/subject/permission/${mapId}`,
+        method: 'get'
+    });
+}

src/components/PopMenu/item.vue

@@ -1,6 +1,6 @@
 <template>
   <div class="container">
-    <li v-if="option.children && option.children.length" class="menu-item" :class="popClass" @mouseenter="enter($vnode.key)" @mouseleave="leave">
+    <li v-if="option.children && option.children.length && checkVisible(option)" class="menu-item" :class="popClass" @mouseenter="enter($vnode.key)" @mouseleave="leave">
       <div ref="flexBox" class="flex-box">
         <el-button type="text" class="item" :disabled="checkDisabled(option)">
           <el-link v-if="option.tipsType" :type="option.tipsType" :underline="false">{{ option.label }}</el-link>
@@ -11,7 +11,7 @@
       <ul v-if="isPopup" ref="popup" class="menu" :style="{display: isShow? 'block': 'table', marginLeft: marginLeft+'px'}">
         <div class="menu-pop pop-menu">
           <div v-show="isShow" class="arrow  el-icon-arrow-down" />
-          <pop-menu-item v-for="(el, i) in option.children" :key="i" :option="el" :pop-class="popClass" :allowedColor="allowedColor" :disabledColor="disabledColor" @close="close" />
+          <pop-menu-item v-for="(el, i) in option.children" :key="i" :option="el" :pop-class="popClass" :allowed-color="allowedColor" :disabled-color="disabledColor" @close="close" />
           <div v-show="isShow" class="arrow  el-icon-arrow-up" />
         </div>
       </ul>
@@ -52,14 +52,14 @@ export default {
             type: Boolean,
             default: false
         },
-		disabledColor: {
-			type: String,
-			default: '#000',
-		},
-		allowedColor: {
-			type: String,
-			default: '#ccc'
-		}
+        disabledColor: {
+            type: String,
+            default: '#000'
+        },
+        allowedColor: {
+            type: String,
+            default: '#ccc'
+        }
     },
     data() {
         return {

src/components/QueryListPage/QueryForm.vue

@@ -303,7 +303,9 @@ export default {
     methods: {
         // 获取默认查询参数
         initQueryModel() {
-            this.formModel = localStore.get(this.$route.path) || this.formModel;
+            if (!this.queryForm.notRecord) {
+                this.formModel = localStore.get(this.$route.path) || this.formModel;
+            }
             this.buildForm();
             if (typeof this.queryForm.initLoadCallback === 'function') {
                 this.queryForm.initLoadCallback(this.formModel);
@@ -350,7 +352,6 @@ export default {
             // 构建查询表单对象、显示的查询对象
             const queryObject = {};
             const model = {};
-            // debugger;
             for (const item in this.queryForm.queryObject) {
                 if (this.queryForm.queryObject.show === false) {
                     continue;

src/components/QueryListPage/QueryListPage.vue

@@ -93,7 +93,7 @@
             :sort-by="column.sortBy"
           >
             <template slot-scope="scope">
-              <div v-html="scope.row[column.prop]" />
+              <div style="white-space: pre-wrap;" v-html="scope.row[column.prop]" />
             </template>
           </el-table-column>
           <el-table-column
@@ -332,7 +332,6 @@ export default {
     methods: {
         handleEdit(row, column, index) {
             this.$set(row, 'isEdit', true);
-            // console.log(this.$refs);
             // if (this.$refs.customerInput.length) {
             //     this.$refs.customerInput[index].$el.querySelector('input').focus();
             // }

src/components/QuillEditor/index.vue

@@ -77,7 +77,7 @@ export default {
                             size: 3,
                             action: `${this.$store.state.user.uploadUrl}/api/upload/PICTURE?appId=00001&appSecret=joylink00001`,
                             response: (res) => {
-                                return `${this.$store.state.user.resourcesUrl}${res.data}`;
+                                return `${this.$store.state.user.ossUrl}${res.data}`;
                             },
                             error: () => { that.$message.error('图片上传失败，请检查网络状态'); },
                             sizeError: () => { that.$message.error('图片上传失败，图片大小限制3MB'); } // 图片超过大小的回调

src/components/VCode/index.vue

@@ -0,0 +1,835 @@
+<template>
+  <!-- 本体部分 -->
+  <div
+    :class="['vue-puzzle-vcode', { show_: show }]"
+    @mousedown="onCloseMouseDown"
+    @mouseup="onCloseMouseUp"
+    @touchstart="onCloseMouseDown"
+    @touchend="onCloseMouseUp"
+  >
+    <div
+      class="vue-auth-box_"
+      @mousedown.stop
+      @touchstart.stop
+    >
+      <div
+        class="auth-body_"
+        :style="`height: ${canvasHeight}px`"
+      >
+        <!-- 主图，有缺口 -->
+        <canvas
+          ref="canvas1"
+          :width="canvasWidth"
+          :height="canvasHeight"
+          :style="`width:${canvasWidth}px;height:${canvasHeight}px`"
+        />
+        <!-- 成功后显示的完整图 -->
+        <canvas
+          ref="canvas3"
+          :class="['auth-canvas3_', { show: isSuccess }]"
+          :width="canvasWidth"
+          :height="canvasHeight"
+          :style="`width:${canvasWidth}px;height:${canvasHeight}px`"
+        />
+        <!-- 小图 -->
+        <canvas
+          ref="canvas2"
+          :width="puzzleBaseSize"
+          class="auth-canvas2_"
+          :height="canvasHeight"
+          :style="
+            `width:${puzzleBaseSize}px;height:${canvasHeight}px;transform:translateX(${styleWidth -
+              sliderBaseSize -
+              (puzzleBaseSize - sliderBaseSize) *
+              ((styleWidth - sliderBaseSize) /
+              (canvasWidth - sliderBaseSize))}px)`
+          "
+        />
+        <div :class="['loading-box_', { hide_: !loading }]">
+          <div class="loading-gif_">
+            <span />
+            <span />
+            <span />
+            <span />
+            <span />
+          </div>
+        </div>
+        <div :class="['info-box_', { show: infoBoxShow }, { fail: infoBoxFail }]">
+          {{ infoText }}
+        </div>
+        <div
+          :class="['flash_', { show: isSuccess }]"
+          :style="
+            `transform: translateX(${
+              isSuccess
+                ? `${canvasWidth + canvasHeight * 0.578}px`
+                : `-${canvasHeight * 0.578}px`
+            }) skew(-30deg, 0);`
+          "
+        />
+        <img
+          class="reset_"
+          :src="resetSvg"
+          @click="reset"
+        >
+      </div>
+      <div class="auth-control_">
+        <div
+          class="range-box"
+          :style="`height:${sliderBaseSize}px`"
+        >
+          <div class="range-text">{{ sliderText }}</div>
+          <div
+            ref="range-slider"
+            class="range-slider"
+            :style="`width:${styleWidth}px`"
+          >
+            <div
+              :class="['range-btn', { isDown: mouseDown }]"
+              :style="`width:${sliderBaseSize}px`"
+              @mousedown="onRangeMouseDown($event)"
+              @touchstart="onRangeMouseDown($event)"
+            >
+              <div />
+              <div />
+              <div />
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+<script>
+import resetSvg from '@/assets/reset.png';
+export default {
+    props: {
+        canvasWidth: { type: Number, default: 310 }, // 主canvas的宽
+        canvasHeight: { type: Number, default: 160 }, // 主canvas的高
+        // 是否出现，由父级控制
+        show: { type: Boolean, default: false },
+        puzzleScale: { type: Number, default: 1 }, // 拼图块的大小缩放比例
+        sliderSize: { type: Number, default: 50 }, // 滑块的大小
+        range: { type: Number, default: 10 }, // 允许的偏差值
+        // 所有的背景图片
+        imgs: {
+            type: Array,
+            default() {
+                return [];
+            }
+        },
+        successText: {
+            type: String,
+            default: '验证通过！'
+        },
+        failText: {
+            type: String,
+            default: '验证失败，请重试'
+        },
+        sliderText: {
+            type: String,
+            default: '拖动滑块完成拼图'
+        }
+    },
+    data() {
+        return {
+            mouseDown: false, // 鼠标是否在按钮上按下
+            startWidth: 50, // 鼠标点下去时父级的width
+            startX: 0, // 鼠标按下时的X
+            newX: 0, // 鼠标当前的偏移X
+            pinX: 0, // 拼图的起始X
+            pinY: 0, // 拼图的起始Y
+            loading: false, // 是否正在加在中，主要是等图片onload
+            isCanSlide: false, // 是否可以拉动滑动条
+            error: false, // 图片加在失败会出现这个，提示用户手动刷新
+            infoBoxShow: false, // 提示信息是否出现
+            infoText: '', // 提示等信息
+            infoBoxFail: false, // 是否验证失败
+            timer1: null, // setTimout1
+            closeDown: false, // 为了解决Mac上的click BUG
+            isSuccess: false, // 验证成功
+            imgIndex: -1, // 用于自定义图片时不会随机到重复的图片
+            isSubmting: false, // 是否正在判定，主要用于判定中不能点击重置按钮
+            resetSvg
+        };
+    },
+    /** 计算属性 **/
+    computed: {
+    // styleWidth是底部用户操作的滑块的父级，就是轨道在鼠标的作用下应该具有的宽度
+        styleWidth() {
+            const w = this.startWidth + this.newX - this.startX;
+            return w < this.sliderBaseSize
+                ? this.sliderBaseSize
+                : w > this.canvasWidth
+                    ? this.canvasWidth
+                    : w;
+        },
+        // 图中拼图块的60 * 用户设定的缩放比例计算之后的值 0.2~2
+        puzzleBaseSize() {
+            return Math.round(
+                Math.max(Math.min(this.puzzleScale, 2), 0.2) * 52.5 + 6
+            );
+        },
+        // 处理一下sliderSize，弄成整数，以免计算有偏差
+        sliderBaseSize() {
+            return Math.max(
+                Math.min(
+                    Math.round(this.sliderSize),
+                    Math.round(this.canvasWidth * 0.5)
+                ),
+                10
+            );
+        }
+    },
+    /** 监听 **/
+    watch: {
+        show(newV) {
+            // 每次出现都应该重新初始化
+            if (newV) {
+                // document.body.classList.add('vue-puzzle-overflow');
+                this.reset();
+            } else {
+                this.isSubmting = false;
+                this.isSuccess = false;
+                this.infoBoxShow = false;
+                // document.body.classList.remove('vue-puzzle-overflow');
+            }
+        }
+    },
+    /** 生命周期 **/
+    mounted() {
+        // document.body.appendChild(this.$el);
+        document.addEventListener('mousemove', this.onRangeMouseMove, false);
+        document.addEventListener('mouseup', this.onRangeMouseUp, false);
+        document.addEventListener('touchmove', this.onRangeMouseMove, {
+            passive: false
+        });
+        document.addEventListener('touchend', this.onRangeMouseUp, false);
+        if (this.show) {
+            document.body.classList.add('vue-puzzle-overflow');
+            this.reset();
+        }
+    },
+    beforeDestroy() {
+        clearTimeout(this.timer1);
+        // document.body.removeChild(this.$el);
+        document.removeEventListener('mousemove', this.onRangeMouseMove, false);
+        document.removeEventListener('mouseup', this.onRangeMouseUp, false);
+        document.removeEventListener('touchmove', this.onRangeMouseMove, {
+            passive: false
+        });
+        document.removeEventListener('touchend', this.onRangeMouseUp, false);
+    },
+    /** 方法 **/
+    methods: {
+    // 关闭
+        onClose() {
+            if (!this.mouseDown && !this.isSubmting) {
+                clearTimeout(this.timer1);
+                this.$emit('close');
+            }
+        },
+        onCloseMouseDown() {
+            this.closeDown = true;
+        },
+        onCloseMouseUp() {
+            if (this.closeDown) {
+                this.onClose();
+            }
+            this.closeDown = false;
+        },
+        // 鼠标按下准备拖动
+        onRangeMouseDown(e) {
+            if (this.isCanSlide) {
+                this.mouseDown = true;
+                this.startWidth = this.$refs['range-slider'].clientWidth;
+                this.newX = e.clientX || e.changedTouches[0].clientX;
+                this.startX = e.clientX || e.changedTouches[0].clientX;
+            }
+        },
+        // 鼠标移动
+        onRangeMouseMove(e) {
+            if (this.mouseDown) {
+                e.preventDefault();
+                this.newX = e.clientX || e.changedTouches[0].clientX;
+            }
+        },
+        // 鼠标抬起
+        onRangeMouseUp() {
+            if (this.mouseDown) {
+                this.mouseDown = false;
+                this.submit();
+            }
+        },
+        /**
+     * 开始进行
+     * @param withCanvas 是否强制使用canvas随机作图
+     */
+        init(withCanvas) {
+            // 防止重复加载导致的渲染错误
+            if (this.loading && !withCanvas) {
+                return;
+            }
+            this.loading = true;
+            this.isCanSlide = false;
+            const c = this.$refs.canvas1;
+            const c2 = this.$refs.canvas2;
+            const c3 = this.$refs.canvas3;
+            const ctx = c.getContext('2d');
+            const ctx2 = c2.getContext('2d');
+            const ctx3 = c3.getContext('2d');
+            const isFirefox = navigator.userAgent.indexOf('Firefox') >= 0 && navigator.userAgent.indexOf('Windows') >= 0; // 是windows版火狐
+            const img = document.createElement('img');
+            ctx.fillStyle = 'rgba(255,255,255,1)';
+            ctx3.fillStyle = 'rgba(255,255,255,1)';
+            ctx.clearRect(0, 0, this.canvasWidth, this.canvasHeight);
+            ctx2.clearRect(0, 0, this.canvasWidth, this.canvasHeight);
+            // 取一个随机坐标，作为拼图块的位置
+            this.pinX = this.getRandom(this.puzzleBaseSize, this.canvasWidth - this.puzzleBaseSize - 20); // 留20的边距
+            this.pinY = this.getRandom(20, this.canvasHeight - this.puzzleBaseSize - 20); // 主图高度 - 拼图块自身高度 - 20边距
+            img.crossOrigin = 'anonymous'; // 匿名，想要获取跨域的图片
+            img.onload = () => {
+                const [x, y, w, h] = this.makeImgSize(img);
+                ctx.save();
+                // 先画小图
+                this.paintBrick(ctx);
+                ctx.closePath();
+                if (!isFirefox) {
+                    ctx.shadowOffsetX = 0;
+                    ctx.shadowOffsetY = 0;
+                    ctx.shadowColor = '#000';
+                    ctx.shadowBlur = 3;
+                    ctx.fill();
+                    ctx.clip();
+                } else {
+                    ctx.clip();
+                    ctx.save();
+                    ctx.shadowOffsetX = 0;
+                    ctx.shadowOffsetY = 0;
+                    ctx.shadowColor = '#000';
+                    ctx.shadowBlur = 3;
+                    ctx.fill();
+                    ctx.restore();
+                }
+                ctx.drawImage(img, x, y, w, h);
+                ctx3.fillRect(0, 0, this.canvasWidth, this.canvasHeight);
+                ctx3.drawImage(img, x, y, w, h);
+                // 设置小图的内阴影
+                ctx.globalCompositeOperation = 'source-atop';
+                this.paintBrick(ctx);
+                ctx.arc(
+                    this.pinX + Math.ceil(this.puzzleBaseSize / 2),
+                    this.pinY + Math.ceil(this.puzzleBaseSize / 2),
+                    this.puzzleBaseSize * 1.2,
+                    0,
+                    Math.PI * 2,
+                    true
+                );
+                ctx.closePath();
+                ctx.shadowColor = 'rgba(255, 255, 255, .8)';
+                ctx.shadowOffsetX = -1;
+                ctx.shadowOffsetY = -1;
+                ctx.shadowBlur = Math.min(Math.ceil(8 * this.puzzleScale), 12);
+                ctx.fillStyle = '#ffffaa';
+                ctx.fill();
+                // 将小图赋值给ctx2
+                const imgData = ctx.getImageData(
+                    this.pinX - 3, // 为了阴影 是从-3px开始截取，判定的时候要+3px
+                    this.pinY - 20,
+                    this.pinX + this.puzzleBaseSize + 5,
+                    this.pinY + this.puzzleBaseSize + 5
+                );
+                ctx2.putImageData(imgData, 0, this.pinY - 20);
+
+                // ctx2.drawImage(c, this.pinX - 3,this.pinY - 20,this.pinX + this.puzzleBaseSize + 5,this.pinY + this.puzzleBaseSize + 5,
+                // 0, this.pinY - 20, this.pinX + this.puzzleBaseSize + 5, this.pinY + this.puzzleBaseSize + 5);
+                // 清理
+                ctx.restore();
+                ctx.clearRect(0, 0, this.canvasWidth, this.canvasHeight);
+                // 画缺口
+                ctx.save();
+                this.paintBrick(ctx);
+                ctx.globalAlpha = 0.8;
+                ctx.fillStyle = '#ffffff';
+                ctx.fill();
+                ctx.restore();
+                // 画缺口的内阴影
+                ctx.save();
+                ctx.globalCompositeOperation = 'source-atop';
+                this.paintBrick(ctx);
+                ctx.arc(
+                    this.pinX + Math.ceil(this.puzzleBaseSize / 2),
+                    this.pinY + Math.ceil(this.puzzleBaseSize / 2),
+                    this.puzzleBaseSize * 1.2,
+                    0,
+                    Math.PI * 2,
+                    true
+                );
+                ctx.shadowColor = '#000';
+                ctx.shadowOffsetX = 2;
+                ctx.shadowOffsetY = 2;
+                ctx.shadowBlur = 16;
+                ctx.fill();
+                ctx.restore();
+                // 画整体背景图
+                ctx.save();
+                ctx.globalCompositeOperation = 'destination-over';
+                ctx.drawImage(img, x, y, w, h);
+                ctx.restore();
+                this.loading = false;
+                this.isCanSlide = true;
+            };
+            img.onerror = () => {
+                this.init(true); // 如果图片加载错误就重新来，并强制用canvas随机作图
+            };
+            if (!withCanvas && this.imgs && this.imgs.length) {
+                let randomNum = this.getRandom(0, this.imgs.length - 1);
+                if (randomNum === this.imgIndex) {
+                    if (randomNum === this.imgs.length - 1) {
+                        randomNum = 0;
+                    } else {
+                        randomNum++;
+                    }
+                }
+                this.imgIndex = randomNum;
+                img.src = this.imgs[randomNum];
+            } else {
+                img.src = this.makeImgWithCanvas();
+            }
+        },
+        // 工具 - 范围随机数
+        getRandom(min, max) {
+            return Math.ceil(Math.random() * (max - min) + min);
+        },
+        // 工具 - 设置图片尺寸cover方式贴合canvas尺寸 w/h
+        makeImgSize(img) {
+            const imgScale = img.width / img.height;
+            const canvasScale = this.canvasWidth / this.canvasHeight;
+            let x = 0;
+            let y = 0;
+            let w = 0;
+            let h = 0;
+            if (imgScale > canvasScale) {
+                h = this.canvasHeight;
+                w = imgScale * h;
+                y = 0;
+                x = (this.canvasWidth - w) / 2;
+            } else {
+                w = this.canvasWidth;
+                h = w / imgScale;
+                x = 0;
+                y = (this.canvasHeight - h) / 2;
+            }
+            return [x, y, w, h];
+        },
+        // 绘制拼图块的路径
+        paintBrick(ctx) {
+            const moveL = Math.ceil(15 * this.puzzleScale); // 直线移动的基础距离
+            ctx.beginPath();
+            ctx.moveTo(this.pinX, this.pinY);
+            ctx.lineTo(this.pinX + moveL, this.pinY);
+            ctx.arcTo(
+                this.pinX + moveL,
+                this.pinY - moveL / 2,
+                this.pinX + moveL + moveL / 2,
+                this.pinY - moveL / 2,
+                moveL / 2
+            );
+            ctx.arcTo(
+                this.pinX + moveL + moveL,
+                this.pinY - moveL / 2,
+                this.pinX + moveL + moveL,
+                this.pinY,
+                moveL / 2
+            );
+            ctx.lineTo(this.pinX + moveL + moveL + moveL, this.pinY);
+            ctx.lineTo(this.pinX + moveL + moveL + moveL, this.pinY + moveL);
+            ctx.arcTo(
+                this.pinX + moveL + moveL + moveL + moveL / 2,
+                this.pinY + moveL,
+                this.pinX + moveL + moveL + moveL + moveL / 2,
+                this.pinY + moveL + moveL / 2,
+                moveL / 2
+            );
+            ctx.arcTo(
+                this.pinX + moveL + moveL + moveL + moveL / 2,
+                this.pinY + moveL + moveL,
+                this.pinX + moveL + moveL + moveL,
+                this.pinY + moveL + moveL,
+                moveL / 2
+            );
+            ctx.lineTo(
+                this.pinX + moveL + moveL + moveL,
+                this.pinY + moveL + moveL + moveL
+            );
+            ctx.lineTo(this.pinX, this.pinY + moveL + moveL + moveL);
+            ctx.lineTo(this.pinX, this.pinY + moveL + moveL);
+            ctx.arcTo(
+                this.pinX + moveL / 2,
+                this.pinY + moveL + moveL,
+                this.pinX + moveL / 2,
+                this.pinY + moveL + moveL / 2,
+                moveL / 2
+            );
+            ctx.arcTo(
+                this.pinX + moveL / 2,
+                this.pinY + moveL,
+                this.pinX,
+                this.pinY + moveL,
+                moveL / 2
+            );
+            ctx.lineTo(this.pinX, this.pinY);
+        },
+        // 用canvas随机生成图片
+        makeImgWithCanvas() {
+            const canvas = document.createElement('canvas');
+            const ctx = canvas.getContext('2d');
+            canvas.width = this.canvasWidth;
+            canvas.height = this.canvasHeight;
+            ctx.fillStyle = `rgb(${this.getRandom(100, 255)},${this.getRandom(
+                100,
+                255
+            )},${this.getRandom(100, 255)})`;
+            ctx.fillRect(0, 0, this.canvasWidth, this.canvasHeight);
+            // 随机画10个图形
+            for (let i = 0; i < 12; i++) {
+                ctx.fillStyle = `rgb(${this.getRandom(100, 255)},${this.getRandom(
+                    100,
+                    255
+                )},${this.getRandom(100, 255)})`;
+                ctx.strokeStyle = `rgb(${this.getRandom(100, 255)},${this.getRandom(
+                    100,
+                    255
+                )},${this.getRandom(100, 255)})`;
+                if (this.getRandom(0, 2) > 1) {
+                    // 矩形
+                    ctx.save();
+                    ctx.rotate((this.getRandom(-90, 90) * Math.PI) / 180);
+                    ctx.fillRect(
+                        this.getRandom(-20, canvas.width - 20),
+                        this.getRandom(-20, canvas.height - 20),
+                        this.getRandom(10, canvas.width / 2 + 10),
+                        this.getRandom(10, canvas.height / 2 + 10)
+                    );
+                    ctx.restore();
+                } else {
+                    // 圆
+                    ctx.beginPath();
+                    const ran = this.getRandom(-Math.PI, Math.PI);
+                    ctx.arc(
+                        this.getRandom(0, canvas.width),
+                        this.getRandom(0, canvas.height),
+                        this.getRandom(10, canvas.height / 2 + 10),
+                        ran,
+                        ran + Math.PI * 1.5
+                    );
+                    ctx.closePath();
+                    ctx.fill();
+                }
+            }
+            return canvas.toDataURL('image/png');
+        },
+        // 开始判定
+        submit() {
+            this.isSubmting = true;
+            // 偏差 x = puzzle的起始X - (用户真滑动的距离) + (puzzle的宽度 - 滑块的宽度) * （用户真滑动的距离/canvas总宽度）
+            // 最后+ 的是补上slider和滑块宽度不一致造成的缝隙
+            const x = Math.abs(
+                this.pinX -
+          (this.styleWidth - this.sliderBaseSize) +
+          (this.puzzleBaseSize - this.sliderBaseSize) *
+            ((this.styleWidth - this.sliderBaseSize) /
+              (this.canvasWidth - this.sliderBaseSize)) -
+          3
+            );
+            if (x < this.range) {
+                // 成功
+                this.infoText = this.successText;
+                this.infoBoxFail = false;
+                this.infoBoxShow = true;
+                this.isCanSlide = false;
+                this.isSuccess = true;
+                // 成功后准备关闭
+                clearTimeout(this.timer1);
+                this.timer1 = setTimeout(() => {
+                    // 成功的回调
+                    this.isSubmting = false;
+                    this.$emit('success', x);
+                }, 800);
+            } else {
+                // 失败
+                this.infoText = this.failText;
+                this.infoBoxFail = true;
+                this.infoBoxShow = true;
+                this.isCanSlide = false;
+                // 失败的回调
+                this.$emit('fail', x);
+                // 800ms后重置
+                clearTimeout(this.timer1);
+                this.timer1 = setTimeout(() => {
+                    this.isSubmting = false;
+                    this.reset();
+                }, 800);
+            }
+        },
+        // 重置 - 重新设置初始状态
+        resetState() {
+            this.infoBoxFail = false;
+            this.infoBoxShow = false;
+            this.isCanSlide = false;
+            this.isSuccess = false;
+            this.startWidth = this.sliderBaseSize; // 鼠标点下去时父级的width
+            this.startX = 0; // 鼠标按下时的X
+            this.newX = 0; // 鼠标当前的偏移X
+        },
+        // 重置
+        reset() {
+            if (this.isSubmting) {
+                return;
+            }
+            this.resetState();
+            this.init();
+        }
+    }
+};
+</script>
+<style lang="scss">
+.vue-puzzle-vcode {
+  position: absolute;
+  top: 0;
+  left: 0;
+  bottom: 0;
+  right: 0;
+  background-color: rgba(0, 0, 0, 0.3);
+  z-index: 999;
+  opacity: 0;
+  pointer-events: none;
+  transition: opacity 200ms;
+  &.show_ {
+    opacity: 1;
+    pointer-events: auto;
+  }
+}
+.vue-auth-box_ {
+  position: absolute;
+  top: 47%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  padding: 20px;
+  background: #fff;
+  user-select: none;
+  border-radius: 3px;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.3);
+  .auth-body_ {
+    position: relative;
+    overflow: hidden;
+    border-radius: 3px;
+    .loading-box_ {
+      position: absolute;
+      top: 0;
+      left: 0;
+      bottom: 0;
+      right: 0;
+      background-color: rgba(0, 0, 0, 0.8);
+      z-index: 20;
+      opacity: 1;
+      transition: opacity 200ms;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      &.hide_ {
+        opacity: 0;
+        pointer-events: none;
+        .loading-gif_ {
+          span {
+            animation-play-state: paused;
+          }
+        }
+      }
+      .loading-gif_ {
+        flex: none;
+        height: 5px;
+        line-height: 0;
+        @keyframes load {
+          0% {
+            opacity: 1;
+            transform: scale(1.3);
+          }
+          100% {
+            opacity: 0.2;
+            transform: scale(0.3);
+          }
+        }
+        span {
+          display: inline-block;
+          width: 5px;
+          height: 100%;
+          margin-left: 2px;
+          border-radius: 50%;
+          background-color: #888;
+          animation: load 1.04s ease infinite;
+          &:nth-child(1) {
+            margin-left: 0;
+          }
+          &:nth-child(2) {
+            animation-delay: 0.13s;
+          }
+          &:nth-child(3) {
+            animation-delay: 0.26s;
+          }
+          &:nth-child(4) {
+            animation-delay: 0.39s;
+          }
+          &:nth-child(5) {
+            animation-delay: 0.52s;
+          }
+        }
+      }
+    }
+    .info-box_ {
+      position: absolute;
+      bottom: 0;
+      left: 0;
+      width: 100%;
+      height: 24px;
+      line-height: 24px;
+      text-align: center;
+      overflow: hidden;
+      font-size: 13px;
+      background-color: #83ce3f;
+      opacity: 0;
+      transform: translateY(24px);
+      transition: all 200ms;
+      color: #fff;
+      z-index: 10;
+      &.show {
+        opacity: 0.95;
+        transform: translateY(0);
+      }
+      &.fail {
+        background-color: #ce594b;
+      }
+    }
+    .auth-canvas2_ {
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: 60px;
+      height: 100%;
+      z-index: 2;
+    }
+    .auth-canvas3_ {
+      position: absolute;
+      top: 0;
+      left: 0;
+      opacity: 0;
+      transition: opacity 600ms;
+      z-index: 3;
+      &.show {
+        opacity: 1;
+      }
+    }
+    .flash_ {
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: 30px;
+      height: 100%;
+      background-color: rgba(255, 255, 255, 0.1);
+      z-index: 3;
+      &.show {
+        transition: transform 600ms;
+      }
+    }
+    .reset_ {
+      position: absolute;
+      top: 2px;
+      right: 2px;
+      width: 35px;
+      height: auto;
+      z-index: 12;
+      cursor: pointer;
+      transition: transform 200ms;
+      transform: rotate(0deg);
+      &:hover {
+        transform: rotate(-90deg);
+      }
+    }
+  }
+  .auth-control_ {
+    .range-box {
+      position: relative;
+      width: 100%;
+      background-color: #eef1f8;
+      margin-top: 20px;
+      border-radius: 3px;
+      box-shadow: 0 0 8px rgba(240, 240, 240, 0.6) inset;
+      .range-text {
+        position: absolute;
+        top: 50%;
+        left: 50%;
+        transform: translate(-50%, -50%);
+        font-size: 14px;
+        color: #b7bcd1;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        text-align: center;
+        width: 100%;
+      }
+      .range-slider {
+        position: absolute;
+        height: 100%;
+        width: 50px;
+        background-color: rgba(106, 160, 255, 0.8);
+        border-radius: 3px;
+        .range-btn {
+          position: absolute;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          right: 0;
+          width: 50px;
+          height: 100%;
+          background-color: #fff;
+          border-radius: 3px;
+          box-shadow: 0 0 4px #ccc;
+          cursor: pointer;
+          & > div {
+            width: 0;
+            height: 40%;
+            transition: all 200ms;
+            &:nth-child(2) {
+              margin: 0 4px;
+            }
+            border: solid 1px #6aa0ff;
+          }
+          &:hover,
+          &.isDown {
+            & > div:first-child {
+              border: solid 4px transparent;
+              height: 0;
+              border-right-color: #6aa0ff;
+            }
+            & > div:nth-child(2) {
+              border-width: 3px;
+              height: 0;
+              border-radius: 3px;
+              margin: 0 6px;
+              border-right-color: #6aa0ff;
+            }
+            & > div:nth-child(3) {
+              border: solid 4px transparent;
+              height: 0;
+              border-left-color: #6aa0ff;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+.vue-puzzle-overflow {
+  overflow: hidden !important;
+}
+</style>

src/directive/verticalDrag/index.js

@@ -0,0 +1,8 @@
+import Vue from 'vue';
+import install from './verticalDrag';
+
+const verticalDrag = function(Vue) {
+    Vue.directive('verticalDrag', install);
+};
+
+Vue.use(verticalDrag);

src/directive/verticalDrag/verticalDrag.js

@@ -0,0 +1,101 @@
+/* 垂直拖拽 */
+export default {
+    bind(el) {
+        const dialogHeaderEl = el.querySelector('.verticalDrag__header');
+        const dialogFooterEl = el.querySelector('.verticalDrag__footer');
+        const dragDom = el;
+        dialogHeaderEl.style.cursor = 'move';
+        dialogFooterEl.style.cursor = 'move';
+        const vD = 5;
+
+        /** 获取原有属性 ie dom元素.currentStyle 火狐谷歌 window.getComputedStyle(dom元素, null);*/
+        const sty = dragDom.currentStyle || window.getComputedStyle(dragDom, null);
+
+        dialogHeaderEl.onmousedown = (e) => {
+            e.stopPropagation();
+            /**  鼠标按下，计算当前元素距离可视区的距离*/
+            const disY = e.clientY;
+            const oY = dialogHeaderEl.offsetHeight;
+            const bY = dragDom.offsetHeight;
+
+            /**  获取到的值带px 正则匹配替换*/
+            let styT;
+
+            /**  注意在ie中 第一次获取到的值为组件自带50% 移动之后赋值为px*/
+            if (sty.top.includes('%')) {
+                styT = +document.body.clientHeight * (+sty.top.replace(/\%/g, '') / 100);
+            } else {
+                styT = +sty.top.replace(/\px/g, '');
+            }
+
+            document.onmousemove = function (e) {
+                e.preventDefault();
+                e.stopPropagation();
+                let cY = e.clientY;
+                if (cY < oY + vD) {
+                    cY = oY + vD;
+                }
+                if (cY > document.body.clientHeight - bY - vD) {
+                    cY = document.body.clientHeight - bY - vD;
+                }
+                /** 通过事件委托，计算移动的距离*/
+                const t = cY - disY;
+
+                /** 移动当前元素*/
+                dragDom.style.top = `${t + styT}px`;
+
+                /** 将此时的位置传出去*/
+                // binding.value({ x: e.pageX, y: e.pageY });
+            };
+
+            document.onmouseup = function () {
+                e.stopPropagation();
+                document.onmousemove = null;
+                document.onmouseup = null;
+            };
+        };
+        dialogFooterEl.onmousedown = (e) => {
+            e.stopPropagation();
+            /**  鼠标按下，计算当前元素距离可视区的距离*/
+            const disY = e.clientY;
+            const oY = dialogFooterEl.offsetHeight;
+            const bY = dragDom.offsetHeight;
+
+            /**  获取到的值带px 正则匹配替换*/
+            let styT;
+
+            /**  注意在ie中 第一次获取到的值为组件自带50% 移动之后赋值为px*/
+            if (sty.top.includes('%')) {
+                styT = +document.body.clientHeight * (+sty.top.replace(/\%/g, '') / 100);
+            } else {
+                styT = +sty.top.replace(/\px/g, '');
+            }
+
+            document.onmousemove = function (e) {
+                e.preventDefault();
+                e.stopPropagation();
+                let cY = e.clientY;
+                if (cY < bY + vD) {
+                    cY = bY + vD;
+                }
+                if (cY > document.body.clientHeight - oY - vD) {
+                    cY = document.body.clientHeight - oY - vD;
+                }
+                /** 通过事件委托，计算移动的距离*/
+                const t = cY - disY;
+
+                /** 移动当前元素*/
+                dragDom.style.top = `${t + styT}px`;
+
+                /** 将此时的位置传出去*/
+                // binding.value({ x: e.pageX, y: e.pageY });
+            };
+
+            document.onmouseup = function () {
+                e.stopPropagation();
+                document.onmousemove = null;
+                document.onmouseup = null;
+            };
+        };
+    }
+};

src/i18n/langs/en/index.js

@@ -29,6 +29,7 @@ import systemGenerate from './systemGenerate';
 import login from './login';
 import designPlatform from './designPlatform';
 import trainingManage from './trainingManage';
+import newRouter from './newRouter';
 
 export default {
     enLocale,
@@ -61,5 +62,6 @@ export default {
     systemGenerate,
     login,
     designPlatform,
-    trainingManage
+    trainingManage,
+    newRouter
 };

src/i18n/langs/en/login.js

@@ -18,5 +18,7 @@ export default {
     getLoginQrCode: 'Failed to get login qr code, please refresh and try again',
     language: 'Language',
     clickSwitchLanguage: 'Click switch language',
-    accountName: 'Account name'
+    accountName: 'Account name',
+    registerAccount: 'Register account',
+    forgetPassword: 'Forget password?'
 };

src/i18n/langs/en/newRouter.js

@@ -0,0 +1,54 @@
+export default {
+    simulation: 'simulation',
+    multiplayerSimulation: 'Many simulation',
+    regulationSimulation: 'Regulation of the simulation',
+    teachingManagement: 'teaching management',
+    classroom: 'classroom management',
+    student: 'student management',
+    theory: 'The theory of management',
+    training: 'Practical teaching management',
+    exam: 'examination management',
+    lineDesign: 'track design',
+    case: 'case',
+    SystemManagement: 'System management',
+    SystemDataManagement: 'System data management',
+    dataDictionary: 'Data dictionary',
+    SystemAccountManagement: 'System Account Management',
+    ThirdPartyAccounts: 'Configuring Third-Party Accounts',
+    OnlineInformationManagement: 'Online information management',
+    loginUser: 'Online users',
+    cacheDataManage: 'Cache data management',
+    simulationManage: 'simulation management',
+    companyUserManage: 'Organization User Management',
+    companyManage: 'Company manage',
+    lineDataManage: 'Line data management',
+    lineTypeManage: 'Line type management',
+    linePacketManage: 'Line packet management',
+    teachingDataManage: 'Teaching data management',
+    theoryData: 'Theoretical topic data management',
+    trainingDataManage: 'Training data management',
+    examData: 'Examination data management',
+    userTrainingDataManage: 'User training data management',
+    userExamData: 'User test data management',
+    projectDataManage: 'Project data management',
+    projectManage: 'Project Manage',
+    projectConfig: 'Project client configuration',
+    projectDeviceManage: 'Project equipment management',
+    permissionDataManage: 'Permission Data Management',
+    permissionManage: 'Permission',
+    authorityTransferManage: 'Privilege distribution management',
+    userRulesManage: 'User Rights Statistics',
+    contestDataManage:'Contest data management',
+    contestSubjectManage:'contest subject management',
+    contestTaskManage:'contest task management',
+    contestSceneManage:'contest scene management',
+    contestTaskScoreManage:'contest task score management',
+    contestSeasonManage:'contest season management',
+    fileManage: 'File Manage',
+    frontResourceManage: 'Front-End Resource Management',
+    iscsPrerecordManage: 'ISCS Advance record management',
+    XRVTI: 'Xi\'an Railway Vocational & Technical Institute',
+    GEMVC: 'Guizhou Equipment Manufacturing Vocational College',
+    JVCOEAI: 'Jiangsu Vocational College Of Electronics And Information',
+    functionManage: 'function management'
+};

src/i18n/langs/en/orderAuthor.js

@@ -117,5 +117,8 @@ export default {
     distributionAttribution: 'Distribution attribution',
     goodsAmount:'Goods Amount',
     operate:'operate',
-    orderNotPay:'order not pay'
+    orderNotPay:'order not pay',
+    updateTime: 'update time',
+    oneClickSync: 'one click sync',
+    ability: 'ability'
 };

src/i18n/langs/en/router.js

@@ -11,7 +11,7 @@ export default {
     newDesignEditorList: 'Editor List',
     newDesignDraftEditorList: 'Draft Editor List',
     uploadPdf: 'Upload Pdf',
-    fileManage:'File Manage',
+    fileManage: 'File Manage',
 
     designhomePage: 'Public map',
     designUserPage: 'Personal map',
@@ -63,7 +63,7 @@ export default {
     dataDictionary: 'Data dictionary',
     dataDictionaryDetails: 'Data dictionary details',
     userManage: 'user management',
-    loginUserManage:'login user Manage',
+    loginUserManage: 'login user Manage',
     cacheManage: 'cache management',
     userTrainingManage: 'User training management',
     userExamManage: 'User examination management',
@@ -86,23 +86,27 @@ export default {
     studentManage: 'Student manage',
     examDetail: 'Exam detail',
     raceManage: 'Race manage',
-    practiceManage:'Practice manage',
+    practiceManage: 'Practice manage',
     bankManage: 'Bank manage',
-    sceneManage:'Scene manage',
+    sceneManage: 'Scene manage',
     companyManage: 'Company manage',
     authorApply: 'Grant application',
     AuthorList: 'Authorization code list',
-    questionsRuleManage: 'Question rule  manage',
+    questionsRuleManage: 'Question rule manage',
     preTheoryData: 'Pre Theory Data',
     boardManage: 'Message Board Manage',
-    publishIBPManage:'publish IBP Manage',
-    publishISCSManage:'publish ISCS Manage',
+    publishIBPManage: 'publish IBP Manage',
+    publishISCSManage: 'publish ISCS Manage',
     publishTrainingManage: 'publish Training Manage',
     voiceTraining: 'Voice Training',
     mapGroup: 'Map Group',
-    drawingMange:'Drawing Mange',
+    drawingMange: 'Drawing Mange',
     projectServer: 'Project Server',
     audioResourcesManage: 'Audio Resources Manage',
     iscsDeviceManage: 'ISCS Device Manage',
-    iscsResourcesManage: 'ISCS Resources Manage'
+    iscsResourcesManage: 'ISCS Resources Manage',
+    projectManage: 'Project Manage',
+    frontProjectConfigManage: 'Front Project Config Manage',
+    training: 'Training',
+    theory: 'Theory'
 };

src/i18n/langs/zh/index.js

@@ -29,6 +29,7 @@ import systemGenerate from './systemGenerate';
 import login from './login';
 import designPlatform from './designPlatform';
 import trainingManage from './trainingManage';
+import newRouter from './newRouter';
 
 export default {
     cnLocale,
@@ -61,5 +62,6 @@ export default {
     systemGenerate,
     login,
     designPlatform,
-    trainingManage
+    trainingManage,
+    newRouter
 };

src/i18n/langs/zh/login.js

@@ -18,5 +18,7 @@ export default {
     getLoginQrCode: '获取登录二维码失败，请刷新重试',
     language: '语言',
     clickSwitchLanguage: '点击切换语言',
-    accountName: '账户名'
+    accountName: '账户名',
+    registerAccount: '注册账号',
+    forgetPassword: '忘记密码？'
 };

src/i18n/langs/zh/menu.js

@@ -51,7 +51,7 @@ export default {
     menuSignal: {
         routeSelect: '进路选排',
         routeCancel: '进路取消',
-        signalBlock: '信号封闭',
+        signalBlock: '信号封锁',
         signalDeblock: '信号解封',
         signalReopen: '信号重开',
         guideRouteHandle: '引导进路办理',
@@ -129,7 +129,7 @@ export default {
         confirmRunToFrontStation: '确认运行至前方站'
     },
     passiveDialog: {
-        alarmDetailInformation: '级告警详细信息',
+        alarmDetailInformation: '级报警详细信息',
         lineName: '线路名称',
         unitName: '单位名称',
         moduleName: '模块名称',

src/i18n/langs/zh/newRouter.js

@@ -0,0 +1,54 @@
+export default {
+    simulation: '仿真',
+    multiplayerSimulation: '多人仿真',
+    regulationSimulation: '监管仿真',
+    teachingManagement: '教学管理',
+    classroom: '班级管理',
+    student: '学生管理',
+    theory: '理论题目管理',
+    training: '实训教学管理',
+    exam: '考试管理',
+    lineDesign: '线路设计',
+    case: '案例管理',
+    SystemManagement: '系统管理',
+    SystemDataManagement: '系统数据管理',
+    dataDictionary: '数据字典',
+    SystemAccountManagement: '系统账户管理',
+    ThirdPartyAccounts: '第三方账户配置',
+    OnlineInformationManagement: '在线信息管理',
+    loginUser: '在线用户',
+    cacheDataManage: '缓存数据管理',
+    simulationManage: '仿真管理',
+    companyUserManage: '组织用户管理',
+    companyManage: '组织管理',
+    lineDataManage: '线路数据管理',
+    lineTypeManage: '线路类型管理',
+    linePacketManage: '线路分组管理',
+    teachingDataManage: '教学数据管理',
+    theoryData: '理论题数据管理',
+    trainingDataManage: '实训数据管理',
+    examData: '考试数据管理',
+    userTrainingDataManage: '用户实训数据管理',
+    userExamData: '用户考试数据管理',
+    projectDataManage: '项目数据管理',
+    projectManage: '项目管理',
+    projectConfig: '项目客户端配置',
+    projectDeviceManage: '项目设备管理',
+    permissionDataManage: '权限数据管理',
+    permissionManage: '权限管理',
+    authorityTransferManage: '权限分发管理',
+    userRulesManage: '用户权限管理',
+    contestDataManage:'竞赛数据管理',
+    contestSubjectManage:'竞赛题目管理',
+    contestTaskManage:'竞赛任务管理',
+    contestSceneManage:'竞赛场景管理',
+    contestTaskScoreManage:'竞赛任务评分管理',
+    contestSeasonManage:'竞赛赛季管理',
+    fileManage: '文件管理',
+    frontResourceManage: '前端资源管理',
+    iscsPrerecordManage: 'ISCS预录管理',
+    XRVTI: '西安铁路职业技术学院',
+    GEMVC: '贵州装备制造职业学院',
+    JVCOEAI: '江苏电子信息职业学院',
+    functionManage: '功能管理'
+};

src/i18n/langs/zh/orderAuthor.js

@@ -116,5 +116,8 @@ export default {
     distributionAttribution: '分发归属',
     goodsAmount:'商品个数',
     operate:'操作',
-    orderNotPay:'该订单未支付'
+    orderNotPay:'该订单未支付',
+    updateTime: '更新时间',
+    oneClickSync: '一键同步',
+    ability: '功能'
 };

src/i18n/langs/zh/publish.js

@@ -105,7 +105,7 @@ export default {
     selectScope: '请选择范围',
     questionNumbers: '题数',
     allNumberTipOne: '此类型有',
-    allNumberTipTwo: '道题',
+    allNumberTipTwo: '题',
     scorePerQuestion: '每题分值',
     inputQuestionNumber: '请输入题数',
     inputQuestionNumberError: '输入的题数大于0',

src/i18n/langs/zh/router.js

@@ -8,7 +8,7 @@ export default {
     newDesignEditorList: '图文列表',
     newDesignDraftEditorList: '文章草稿',
     uploadPdf: 'PDF上传',
-    fileManage:'文件管理',
+    fileManage: '文件管理',
 
     mapManage: '地图管理',
     skinManage: '皮肤管理',
@@ -62,7 +62,7 @@ export default {
     dataDictionary: '数据字典',
     dataDictionaryDetails: '数据字典明细',
     userManage: '用户管理',
-    loginUserManage:'在线用户管理',
+    loginUserManage: '在线用户管理',
     cacheManage: '缓存管理',
     userTrainingManage: '用户实训统计',
     userExamManage: '用户考试统计',
@@ -91,22 +91,26 @@ export default {
     raceManage: '竞赛管理',
     recaList: '报名列表',
     bankManage: '题库列表',
-    practiceManage:'实操列表',
-    sceneManage:'场景列表',
+    practiceManage: '实操列表',
+    sceneManage: '场景列表',
     companyManage: '组织管理',
     authorApply: '授权申请',
     AuthorList: '授权列表',
     questionsRuleManage: '出题规则管理',
     preTheoryData: '理论导入预处理',
     boardManage: '留言板管理',
-    publishIBPManage:'发布IBP盘管理',
-    publishISCSManage:'发布ISCS管理',
+    publishIBPManage: '发布IBP盘管理',
+    publishISCSManage: '发布ISCS管理',
     publishTrainingManage: '发布实训管理',
     voiceTraining: '语音训练',
     mapGroup: '地图分组',
-    drawingMange:'图纸管理',
+    drawingMange: '图纸管理',
     projectServer: '项目域名',
     audioResourcesManage: '音频资源管理',
     iscsDeviceManage: 'ISCS设备管理',
-    iscsResourcesManage: 'ISCS资源管理'
+    iscsResourcesManage: 'ISCS资源管理',
+    projectManage: '项目管理',
+    frontProjectConfigManage: '前端项目配置管理',
+    training: '实训',
+    theory: '理论'
 };

src/iscs/constant/deviceStyle.js

@@ -9,7 +9,15 @@ const mapDeviceStyle = {
     '09': 'xian_02',
     '10': 'xian_01', // 西安一号线
     '11': 'xian_01', // 西安三号线
-    '12': 'ningbo_03' // 宁波三号线
+    '12': 'ningbo_03', // 宁波三号线
+    '13': 'race_01', // 2020国赛线路
+    '14':'nanjing_02', // 南京二号线
+    '15': 'datie_01', // 大铁线路一
+    '16': 'datie_02', // 大铁线路二
+    '17':'datie_tky', // 铁科院大铁线路
+    '18':'datie_jd1a',
+    '19': 'datie_ksk', // 大铁 卡斯柯
+    '20': 'ningbo_01'
 };
 
 export function selectLineCode(code) {

src/jlmap3d/config/SetScene.js

@@ -5,7 +5,6 @@ export function SetScene(project) {
   // var cubeTextureLoader = new THREE.CubeTextureLoader();
 
   var bgTexture;
-  // console.log(project);
   if(project == "login" || project == undefined){
     bgTexture = new THREE.TextureLoader().load(JL3D_LOCAL_STATIC+"/background/other.jpg");
   }else if(project == "heb"){

src/jlmap3d/edit/action/pathaction.js

@@ -48,7 +48,6 @@ export function Pathaction(){
 
 			document.onmousedown = function(event){
         jlmap3dedit.selectswitch = false;
-        console.log(event.button);
 
         //辅助线段
 
@@ -60,7 +59,6 @@ export function Pathaction(){
 
           lineswitch = null;
 
-          console.log(linenew);
 
           if(linenew){
 
@@ -74,7 +72,6 @@ export function Pathaction(){
 
             point1 = mouserray(event,jlmap3dedit);
 
-            console.log("new");
             if(point1){
               linenew = addline(point1,1,jlmap3dedit.splineHelperObjects,jlmap3dedit.scene);
               jlmap3dedit.mapdata.path.push(linenew);
@@ -104,7 +101,6 @@ export function Pathaction(){
                     jlmap3dedit.mapdata.sectionlist.sections.datalist[i].rail.push(linenew.geometry.vertices[n]);
                   }
                   jlmap3dedit.mapdata.sectionlist.sections.datalist[i].railline = linenew;
-                  console.log(jlmap3dedit.mapdata.sectionlist.sections.datalist[i].rail);
                   i = jlmap3dedit.mapdata.sectionlist.sections.modellist.length;
                 }
               }
@@ -177,7 +173,6 @@ export function Pathaction(){
 
       document.onmousedown = function(event){
 
-        console.log(event.button);
 
         //辅助线段
 
@@ -189,7 +184,6 @@ export function Pathaction(){
 
           lineswitch = null;
 
-          console.log(linenew);
 
           if(linenew){
 
@@ -233,8 +227,6 @@ export function Pathaction(){
                   for(let n=0;n<linenew.geometry.vertices.length;n++){
                     jlmap3dedit.mapdata.sectionlist.sections.datalist[i].rail.push(linenew.geometry.vertices[n]);
                   }
-                  console.log(jlmap3dedit.mapdata.sectionlist.sections.datalist[i]);
-                  console.log(jlmap3dedit.mapdata.sectionlist.sections.datalist[i].rail);
                 }
               }
             }
@@ -289,7 +281,6 @@ export function Pathaction(){
   }
   //点击事件
   this.raycaster = function(data){
-    console.log();
     if(scope.on == true){
 
       //定义光线
@@ -300,13 +291,11 @@ export function Pathaction(){
       mouse.y = -(event.clientY / window.innerHeight) * 2 + 1;
 
       raycaster.setFromCamera( mouse, data.camera );
-      console.log(data.splineHelperObjects);
       let intersects1;
 
       intersects1 = raycaster.intersectObjects( data.splineHelperObjects);
 
       if(intersects1[0]){
-        console.log(intersects1[0]);
         return intersects1[0].object;
       }
 
@@ -329,9 +318,7 @@ export function Pathaction(){
       mouse.y = -(mousep.clientY / window.innerHeight) * 2 + 1;
 
       raycaster.setFromCamera( mouse, jlmap3dedit.camera );
-      console.log(jlmap3dedit.assetloader.modellist[3].mesh);
       var intersects = raycaster.intersectObjects(jlmap3dedit.assetloader.modellist[3].mesh.children);
-      console.log(intersects);
       if(intersects[0]){
         resultpoint = intersects[0].point;
         return resultpoint;

src/jlmap3d/edit/action/sectionaction.js

@@ -79,13 +79,9 @@ export function Sectionaction(){
 
     raycaster.setFromCamera( mouse, data.camera );
     let intersects1;
-    // console.log(modellist);
     for(let i=0;i<modellist.length;i++){
       intersects1 = raycaster.intersectObject(modellist[i],true);
-      // console.log(intersects1);
       if(intersects1[0]){
-        // console.log(intersects1[0].object.code);
-        // console.log(modellist[i].code);
         if(intersects1[0].object.code == modellist[i].code){
 
           return modellist[i];
@@ -97,20 +93,17 @@ export function Sectionaction(){
   }
 
   this.changemodel = function(jlmap3dedit,changedata){
-    console.log(changedata);
     let scene = jlmap3dedit.scene;
     let assetloader = jlmap3dedit.assetloader;
     let isnewmodel = true;
     //判断是否是未加载模型
     for(let i=0;i<assetloader.modellist.length;i++){
-      console.log(assetloader.modellist[i].assetUrl);
 
       if(changedata.assetUrl == assetloader.modellist[i].assetUrl){
         isnewmodel = false;
         i = assetloader.modellist.length;
       }
     }
-    console.log(isnewmodel);
 
     jlmap3dedit.assetloader.loadnewsection(changedata,jlmap3dedit);
 
@@ -118,25 +111,19 @@ export function Sectionaction(){
 
     // for(let i=0;i<jlmap3dedit.mapdata.signallist.list.length;i++){
     //   if(jlmap3dedit.selectmodel.code == jlmap3dedit.mapdata.signallist.list[i].mesh.code){
-    //       console.log("change");
     //     let num = i;
     //
     //     //判断是否修改模型
-    //     console.log(changedata.id );
-    //     console.log(jlmap3dedit.mapdata.signallist.list[i].mesh.name);
     //     if(changedata.id != jlmap3dedit.mapdata.signallist.list[i].mesh.name){
     //
     //       if(isnewmodel == true){
-    //         console.log("new");
     //         return jlmap3dedit.assetloader.loadnewasset(jlmap3dedit,changedata,num);
     //
     //       }else{
-    //         console.log("old");
     //         return jlmap3dedit.assetloader.loadoldasset(jlmap3dedit,changedata,num);
     //
     //       }
     //     }else{
-    //       console.log("same");
     //       return jlmap3dedit.selectmodel;
     //     }
     //

src/jlmap3d/edit/action/signalaction.js

@@ -50,7 +50,6 @@ export function Signalaction(){
       for(let i=0;i<data.mapdata.signallist.list.length;i++){
         intersects1 = raycaster.intersectObjects( data.mapdata.signallist.list[i].mesh.children);
         if(intersects1[0]){
-          console.log(intersects1[0].object);
           if(intersects1[0].object.parent.code == data.mapdata.signallist.list[i].mesh.code){
             return data.mapdata.signallist.list[i].mesh;
           }
@@ -62,11 +61,9 @@ export function Signalaction(){
   }
 
   this.changemodel = function(jlmap3dedit,changedata){
-    console.log(changedata);
     let isnewmodel = true;
     //判断是否是未加载模型
     for(let i=0;i<jlmap3dedit.assetloader.modellist.length;i++){
-      console.log(jlmap3dedit.assetloader.modellist[i].assetUrl);
 
       if(changedata.assetUrl == jlmap3dedit.assetloader.modellist[i].assetUrl){
         isnewmodel = false;
@@ -77,25 +74,19 @@ export function Signalaction(){
     let scene = jlmap3dedit.scene;
     for(let i=0;i<jlmap3dedit.mapdata.signallist.list.length;i++){
       if(jlmap3dedit.selectmodel.code == jlmap3dedit.mapdata.signallist.list[i].mesh.code){
-          console.log("change");
         let num = i;
 
         //判断是否修改模型
-        console.log(changedata.id );
-        console.log(jlmap3dedit.mapdata.signallist.list[i].mesh.name);
         if(changedata.id != jlmap3dedit.mapdata.signallist.list[i].mesh.name){
 
           if(isnewmodel == true){
-            console.log("new");
             return jlmap3dedit.assetloader.loadnewasset(jlmap3dedit,changedata,num);
 
           }else{
-            console.log("old");
             return jlmap3dedit.assetloader.loadoldasset(jlmap3dedit,changedata,num);
 
           }
         }else{
-          console.log("same");
           return jlmap3dedit.selectmodel;
         }
 

src/jlmap3d/edit/action/stationaction.js

@@ -48,15 +48,11 @@ export function Stationaction(){
 
       raycaster.setFromCamera( mouse, data.camera );
       let intersects1;
-        console.log( data.mapdata.stationstandlist);
       for(let i=0;i<data.mapdata.stationstandlist.group.children.length;i++){
 
         intersects1 = raycaster.intersectObjects( data.mapdata.stationstandlist.group.children[i].children);
 
         if(intersects1[0]){
-          console.log(data.mapdata.stationstandlist.group);
-          console.log(intersects1[0]);
-          console.log(data.mapdata.stationstandlist.group.children[i]);
           if(intersects1[0].object.parent.code ==  data.mapdata.stationstandlist.group.children[i].code){
             return data.mapdata.stationstandlist.group.children[i];
           }

src/jlmap3d/edit/action/switchaction.js

@@ -55,7 +55,6 @@ export function Switchaction(){
         if(intersects1[0]){
 
           if(intersects1[0].object.code == data.mapdata.sectionlist.switchs.modellist[i].code){
-            //console.log(intersects1[0].object.name);
             return  data.mapdata.sectionlist.switchs.modellist[i];
           }
         }

src/jlmap3d/edit/action/trainaction.js

@@ -55,8 +55,6 @@ export function Trainaction(){
         if(intersects1[0]){
 
           if(intersects1[0].object.name == data.mapdata.trainlisttest.list[i].name){
-            //console.log(intersects1[0].object.name);
-            console.log(data.mapdata.trainlisttest.list[i]);
             return data.mapdata.trainlisttest.list[i];
           }
         }

src/jlmap3d/edit/connect/initDataSave.js

@@ -1,7 +1,6 @@
 //import request from '@/utils/request';
 
 export function initDataSave(data) {
-  console.log(data);
     let postmap = {
         id:data.mapdata.id,
         mapId:data.mapdata.mapId,
@@ -24,7 +23,6 @@ export function initDataSave(data) {
     }else{
 
       let models = data.assetManager;
-      console.log(data.assetManager);
       postmap.assets = JSON.stringify(models);
 
 
@@ -113,7 +111,6 @@ export function initDataSave(data) {
       postmap.signals = JSON.stringify(signals);
       //车站
       let stands = [];
-      console.log(data.mapdata.stationstandlist);
       if(data.mapdata.stationstandlist){
         for(let i=0;i<data.mapdata.stationstandlist.list.length;i++){
           let station = {

src/jlmap3d/edit/connect/specilDataSave.js

@@ -1,6 +1,5 @@
 //import request from '@/utils/request';
 export function specilDataSave(data) {
-  console.log(data);
     let postmap = {
         id:data.mapdata.id,
         mapId:data.mapdata.mapId,
@@ -55,7 +54,6 @@ export function specilDataSave(data) {
 
 
       let models = data.assetManager;
-      console.log(data.assetManager);
       postmap.assets = JSON.stringify(models);
 
 

src/jlmap3d/edit/connect/testgetmodels.js

@@ -23,13 +23,11 @@ export function testgetmodels(data) {
     }else{
 
       let models = data.assetManager;
-      console.log(data.assetManager);
       postmap.assets = JSON.stringify(models);
 
 
       //section隧道
       let sections = [];
-      // console.log(data.mapdata.sectionlist.sections.datalist);
       for(let i in data.mapdata.sectionlist.sections.datalist){
         let section = {
           // uuid:data.mapdata.sectionlist.sections.modellist[i].uuid,
@@ -47,7 +45,6 @@ export function testgetmodels(data) {
         }
         let nowmesh =  data.mapdata.sectionlist.sectiongroup.getObjectByProperty("code",section.code);
         section.railpoint = nowmesh.railpoint;
-        // console.log(nowmesh.railpoint);
         // if(data.mapdata.sectionlist.sections.datalist[i].rsection){
         //   section.rsection = data.mapdata.sectionlist.sections.datalist[i].rsection;
         // }

src/jlmap3d/edit/jl3dEditorLoader.js

@@ -27,7 +27,6 @@ export function jl3dEditorLoader(mapid,scope){
   get3dMapData(editmapid).then(data => {
 
     if(data.data ){
-      console.log(data);
       if(data.data.assets){
         // initData(editmapid,data.data.id);
         loadData(editmapid,data.data);
@@ -40,26 +39,22 @@ export function jl3dEditorLoader(mapid,scope){
 
       set3dMapData(params).then(data => {
         if(data.code == "200"){
-          //console.log("创建三维数据成功");
-          // console.log(data);
           initData(editmapid,data.data.id);
 
         }
       }).catch(error => {
-        console.log(error);
+        console.error(error);
       });
     }
 
   }).catch(error => {
-    console.log(error);
+    console.error(error);
   });
 
   function initData(mapid,data3did){
 
     getMapDetail(mapid).then(data => {
-      console.log(data);
       let mapdata = data.data;
-      //console.log(data3did);
       jlmap3ddata.id = data3did;
       jlmap3ddata.mapId = mapid;
 
@@ -71,11 +66,9 @@ export function jl3dEditorLoader(mapid,scope){
         jlmap3ddata.switchlist = new rSwitchList();
         assetloader.assetinit(scene)
         .then(function(data){
-          //console.log(data);
           return   jlmap3ddata.sectionlist.initpromise(jlmap3ddata,assetloader,mapdata.sectionList,mapdata.switchList,scene);
         })
         .then(function(data){
-          //console.log(data);
           return   jlmap3ddata.signallist.initpromise(jlmap3ddata,mapdata.signalList,scene,assetloader);
         })
         .then(function(data){
@@ -83,7 +76,6 @@ export function jl3dEditorLoader(mapid,scope){
         })
 
         .then(function(data){
-          //console.log(data);
           loadingInstance.close();
         });
       }else{
@@ -100,15 +92,12 @@ export function jl3dEditorLoader(mapid,scope){
         jlmap3ddata.raillist.setrail();
         assetloader.assetinit(scene)
         .then(function(data){
-          //console.log(data);
           return  jlmap3ddata.stationstandlist.initpromise(jlmap3ddata,mapdata.stationList,mapdata.stationStandList,scene,assetloader);
         })
         .then(function(data){
-          //console.log(data);
           return   jlmap3ddata.sectionlist.initpromise(jlmap3ddata,assetloader,mapdata.sectionList,mapdata.switchList,scene);
         })
         .then(function(data){
-          //console.log(data);
           return   jlmap3ddata.signallist.initpromise(jlmap3ddata,mapdata.signalList,scene,assetloader);
         })
         .then(function(data){
@@ -116,7 +105,6 @@ export function jl3dEditorLoader(mapid,scope){
         })
 
         .then(function(data){
-          //console.log(data);
           loadingInstance.close();
         });
       }
@@ -151,12 +139,10 @@ export function jl3dEditorLoader(mapid,scope){
         assetloader.setModelListOver(jlmap3dasset.sceneAssetList,5,jlmap3dasset.others);
         assetloader.assetPromiseOver(scene)
         .then(function(data){
-          //console.log(data);
           // return jlmap3ddata.sectionlist.initpromise(jlmap3ddata,assetloader,mapdata.sectionList,mapdata.switchList,scene);
           return jlmap3ddata.sectionlist.loadpromise(jlmap3ddata,assetloader,sectiondata.section,mapdata.sectionList,mapdata.switchList,scene);
         })
         .then(function(data){
-          //console.log(data);
           // return   jlmap3ddata.signallist.initpromise(jlmap3ddata,mapdata.signalList,scene,assetloader);
           return jlmap3ddata.signallist.loadpromise(signaldata,scene,assetloader,mapdata.signalList);
         })
@@ -165,7 +151,6 @@ export function jl3dEditorLoader(mapid,scope){
           return jlmap3ddata.switchlist.loadpromise(jlmap3ddata,switchdata,scene,assetloader);
         })
         .then(function(data){
-          //console.log(data);
           loadingInstance.close();
         });
       }else{
@@ -179,7 +164,6 @@ export function jl3dEditorLoader(mapid,scope){
         jlmap3ddata.switchlist = new SwitchList();
 
         jlmap3ddata.raillist = new RailList();
-        console.log(netdata);
         let sectiondata = JSON.parse(netdata.sections);
         let switchdata = JSON.parse(netdata.switchs);
         let signaldata = JSON.parse(netdata.signals);
@@ -196,12 +180,10 @@ export function jl3dEditorLoader(mapid,scope){
             return jlmap3ddata.stationstandlist.loadpromise(jlmap3ddata,standsdata,mapdata.stationStandList,scene,assetloader);
           })
           .then(function(data){
-            //console.log(data);
             // return jlmap3ddata.sectionlist.initpromise(jlmap3ddata,assetloader,mapdata.sectionList,mapdata.switchList,scene);
             return jlmap3ddata.sectionlist.loadpromise(jlmap3ddata,assetloader,sectiondata.section,scene);
           })
           .then(function(data){
-            //console.log(data);
             // return   jlmap3ddata.signallist.initpromise(jlmap3ddata,mapdata.signalList,scene,assetloader);
             return jlmap3ddata.signallist.loadpromise(signaldata,scene,assetloader,mapdata.signalList);
           })
@@ -210,7 +192,6 @@ export function jl3dEditorLoader(mapid,scope){
             return jlmap3ddata.switchlist.loadpromise(jlmap3ddata,switchdata,scene,assetloader);
           })
           .then(function(data){
-            //console.log(data);
             loadingInstance.close();
           });
         }else{
@@ -222,12 +203,10 @@ export function jl3dEditorLoader(mapid,scope){
             return jlmap3ddata.stationstandlist.loadpromise(jlmap3ddata,standsdata,mapdata,scene,assetloader,jlmap3dasset.others);
           })
           .then(function(data){
-            //console.log(data);
             // return jlmap3ddata.sectionlist.initpromise(jlmap3ddata,assetloader,mapdata.sectionList,mapdata.switchList,scene);
             return jlmap3ddata.sectionlist.loadpromise(jlmap3ddata,assetloader,sectiondata.section,mapdata.sectionList,mapdata.switchList,scene);
           })
           .then(function(data){
-            //console.log(data);
             // return   jlmap3ddata.signallist.initpromise(jlmap3ddata,mapdata.signalList,scene,assetloader);
             return jlmap3ddata.signallist.loadpromise(signaldata,scene,assetloader,mapdata.signalList);
           })
@@ -236,7 +215,6 @@ export function jl3dEditorLoader(mapid,scope){
             return jlmap3ddata.switchlist.loadpromise(jlmap3ddata,switchdata,scene,assetloader);
           })
           .then(function(data){
-            //console.log(data);
             loadingInstance.close();
           });
         }

src/jlmap3d/edit/jlmap3dedit.js

@@ -29,7 +29,6 @@ import { jl3dEditorLoader } from '@/jlmap3d/edit/jl3dEditorLoader';
 import { Actionmanage } from '@/jlmap3d/edit/actionmanage';
 
 export function JLmap3dEdit(dom, data, mapid) {
-  console.log(data);
 
   var scope = this;
 
@@ -144,7 +143,6 @@ export function JLmap3dEdit(dom, data, mapid) {
   };
 
   this.eventon = function(){
-    //console.log("on");
     //raycaster交互模型点击事件
     document.getElementById("testdraw").addEventListener( "mousedown", onselect, false );
     //窗口自适应
@@ -154,7 +152,6 @@ export function JLmap3dEdit(dom, data, mapid) {
   };
 
   this.eventoff = function(){
-    //console.log("off");
     //raycaster交互模型点击事件
     document.getElementById("testdraw").removeEventListener( "mousedown", onselect, false );
     //窗口自适应
@@ -163,7 +160,6 @@ export function JLmap3dEdit(dom, data, mapid) {
 
   this.exportsection = function(){
     let exporter = new THREE.OBJExporter();
-    console.log(scope.mapdata);
     // let exportmodels = scope.mapdata.stationstandlist.group;
     let exportmodels = scope.mapdata.sectionlist.sectiongroup;
     // let exportmodels = scope.mapdata.stationstandlist.group;
@@ -184,7 +180,6 @@ export function JLmap3dEdit(dom, data, mapid) {
 
   this.exportsection = function(){
     let exporter = new THREE.OBJExporter();
-    console.log(scope.mapdata);
     // let exportmodels = scope.mapdata.stationstandlist.group;
     let exportSectionModel = scope.mapdata.sectionlist.sectiongroup;
     objDownload("section",exporter.parse( exportSectionModel ));
@@ -226,10 +221,6 @@ export function JLmap3dEdit(dom, data, mapid) {
   }
 
   this.actiommode = function(changedata){
-    console.log(changedata);
-    console.log(scope.editmode);
-    // console.log(scope.actionmode);
-    // console.log(changedata);
     if(changedata == "trackreplace"){
       scope.editmode = "trackedit";
       scope.eventon();
@@ -274,7 +265,6 @@ export function JLmap3dEdit(dom, data, mapid) {
     // if(scope.editmode == "pathedit"){
     //
     //   if(scope.actionmode == "drawrail"){
-    //     //console.log("drawrail");
     //     scope.selectmodel = scope.action.pathaction.drawline(scope);
     //   }
     //
@@ -305,27 +295,14 @@ export function JLmap3dEdit(dom, data, mapid) {
     for(let i=0,leni=scope.mapdata.stationstandlist.list.length;i<leni;i++){
       if(changeStation.code == scope.mapdata.stationstandlist.list[i].code){
         let changeData = scope.mapdata.stationstandlist.list[i];
-          console.log(changeData);
         let topStandTrack = scope.mapdata.sectionlist.sections.datalist[changeData.stands[0].section];
         let downStandTrack = scope.mapdata.sectionlist.sections.datalist[changeData.stands[changeData.stands.length-1].section];
 
-        console.log(scope.mapdata.sectionlist.sections);
-        console.log(topStandTrack.mesh.railpoint[0].x);
-        console.log(topStandTrack.mesh.railpoint[2].x);
-        console.log(downStandTrack.mesh.railpoint[0].x);
-        console.log(downStandTrack.mesh.railpoint[2].x);
-
         let rightpos = topStandTrack.leftStopPercent*(topStandTrack.mesh.railpoint[2].x -topStandTrack.mesh.railpoint[0].x)+topStandTrack.mesh.railpoint[0].x;
         let leftpos = downStandTrack.rightStopPercent*(downStandTrack.mesh.railpoint[2].x -downStandTrack.mesh.railpoint[0].x)+downStandTrack.mesh.railpoint[0].x;
 
         let rightX = changeData.mesh.position.x-63.4 - rightpos;
         let leftX = changeData.mesh.position.x+63.4 - leftpos;
-        console.log("----------------------------");
-        console.log(rightpos);
-        console.log(leftpos);
-        console.log("----------------------------");
-        console.log(rightX);
-        console.log(leftX);
         topStandTrack.mesh.position.x = topStandTrack.mesh.position.z + rightX;
         downStandTrack.mesh.position.x = downStandTrack.mesh.position.x + leftX;
         //
@@ -367,9 +344,6 @@ export function JLmap3dEdit(dom, data, mapid) {
           plane2.rotation.y = Math.PI/2;
           let leftpos = scope.mapdata.sectionlist.sections.datalist[k].leftStopPercent*(scope.mapdata.sectionlist.sections.datalist[k].railpoint[2].x -scope.mapdata.sectionlist.sections.datalist[k].railpoint[0].x)+scope.mapdata.sectionlist.sections.datalist[k].railpoint[0].x;
           let rightpos = scope.mapdata.sectionlist.sections.datalist[k].rightStopPercent*(scope.mapdata.sectionlist.sections.datalist[k].railpoint[2].x -scope.mapdata.sectionlist.sections.datalist[k].railpoint[0].x)+scope.mapdata.sectionlist.sections.datalist[k].railpoint[0].x;
-          // console.log("==========");
-          // console.log(scope.mapdata.sectionlist.sections.datalist[k].leftStopPercent);
-          // console.log(scope.mapdata.sectionlist.sections.datalist[k].rightStopPercent);
           plane1.position.set(leftpos,scope.mapdata.sectionlist.sections.datalist[k].railpoint[1].y,scope.mapdata.sectionlist.sections.datalist[k].railpoint[1].z);
           plane2.position.set(rightpos,scope.mapdata.sectionlist.sections.datalist[k].railpoint[1].y,scope.mapdata.sectionlist.sections.datalist[k].railpoint[1].z);
           stationStopGroup.add(plane1);
@@ -393,8 +367,6 @@ export function JLmap3dEdit(dom, data, mapid) {
 
   //自动匹配轨道信号灯道岔
   this.autoss = function(){
-    console.log("autoss");
-    // console.log(scope.mapdata);
     scope.mapdata.signallist.resetsignal(scope.mapdata);
     scope.mapdata.switchlist.resetswitch(scope.mapdata);
     //old
@@ -494,8 +466,6 @@ export function JLmap3dEdit(dom, data, mapid) {
     newpointlist.push(new THREE.Vector3(alignmentModel.railpoint[1].x,alignmentModel.railpoint[0].y,alignmentModel.railpoint[0].z+0.001));
     newpointlist.push(new THREE.Vector3(alignmentModel.railpoint[2].x,alignmentModel.railpoint[0].y,alignmentModel.railpoint[0].z));
 
-    // console.log(oldobject);
-
     let newSection = reCreatSection(newpointlist,oldobject);
     newSection.meshtype = "section";
     scope.mapdata.sectionlist.sections.datalist[alignmentCode].mesh = newSection;
@@ -569,8 +539,6 @@ export function JLmap3dEdit(dom, data, mapid) {
 
   //三维交互点击事件函数
   function onselect(event) {
-    //console.log("select");
-    //console.log("select");
     if(scope.selectswitch == true){
 
       scope.transcontrol.detach();
@@ -593,7 +561,6 @@ export function JLmap3dEdit(dom, data, mapid) {
       }
 
       if(scope.editmode == "stationedit"){
-          console.log("stat!!!!!!!!!!!!");
         scope.selectmodel = scope.action.stationaction.raycaster(scope);
       }
 
@@ -607,11 +574,9 @@ export function JLmap3dEdit(dom, data, mapid) {
 
       if(scope.editmode == "pathedit"){
         scope.selectmodel = scope.action.pathaction.raycaster(scope);
-        //console.log(scope.selectmodel);
       }
 
       if(scope.selectmodel != null){
-        //console.log(scope.selectmodel.rotation);
         if(scalControls.scalon){
 
         }else{

src/jlmap3d/edit/railwayModel/rSectionList.js

@@ -36,7 +36,6 @@ export function rSectionList() {
         if(sectiondata[i].type == "01" || sectiondata[i].type == "03"){
           //初始化区段对象数据
           let newsection = new SectionModel(sectiondata[i]);
-          // console.log(sectiondata[i]);
           newsection.name = sectiondata[i].name;
           newsection.code = sectiondata[i].code;
           newsection.index = i;
@@ -49,7 +48,6 @@ export function rSectionList() {
           newsection.points = sectiondata[i].points;
           newsection.pointslength = sectiondata[i].points.length-1;
           newsection.railpoint = [];
-          // console.log(sectiondata[i].points.length);
           newsection.standTrack = sectiondata[i].standTrack;
 
           newsection.endbuild = false;
@@ -74,7 +72,6 @@ export function rSectionList() {
         let acode = switchdata[i].sectionACode;
         let bcode = switchdata[i].sectionBCode;
         let ccode = switchdata[i].sectionCCode;
-        // console.log(switchdata[i]);
 
 
         let aposx = (scope.sections.datalist[acode].points[0].x + scope.sections.datalist[acode].points[scope.sections.datalist[acode].pointslength].x)/2;
@@ -83,7 +80,6 @@ export function rSectionList() {
         let aposy = (scope.sections.datalist[acode].points[0].y + scope.sections.datalist[acode].points[scope.sections.datalist[acode].pointslength].y)/2;
         let cposy = (scope.sections.datalist[ccode].points[0].y + scope.sections.datalist[ccode].points[scope.sections.datalist[ccode].pointslength].y)/2;
 
-        // console.log("----------------");
         if(aposx > cposx){
           if(aposy < cposy){
             //  ——A
@@ -157,8 +153,6 @@ export function rSectionList() {
         y:0,
         z:0
       });
-      console.log(scope.sections.datalist);
-      console.log("START BUILD !!!!!!!!!!!!!!!!!");
       buildsectionall(scope.sections.datalist["T1"]);
       resolve("loadersection");
     });
@@ -246,12 +240,7 @@ export function rSectionList() {
       y:0,
       z:position.z
     };
-    // console.log(origin+"******************************");
-    // console.log(start);
-    // console.log(origin);
     if(scope.sections.datalist[start].standTrack == true && start != origin){
-      // console.log(start+"到达");
-      // console.log("++++++++++++++++++++++++");
       return ;
     }else if(scope.sections.datalist[start].rsection == undefined){
       return ;
@@ -420,11 +409,7 @@ export function rSectionList() {
         ];
       }
 
-      // console.log(data.ctype);
       if(type == "cross"){
-        // console.log(data.ctype);
-        // console.log(scope.sections.datalist[data.code].points.length);
-        // console.log(scope.sections.datalist[data.code]);
         if(data.ctype == "1"||data.ctype == "2" ){
 
 
@@ -769,16 +754,13 @@ export function rSectionList() {
         let acode = switch2d[i].sectionACode;
         let bcode = switch2d[i].sectionBCode;
         let ccode = switch2d[i].sectionCCode;
-        // console.log(switchdata[i]);
 
-        // console.log(scope.sections.datalist[acode]);
         let aposx = (scope.sections.datalist[acode].points[0].x + scope.sections.datalist[acode].points[scope.sections.datalist[acode].pointslength].x)/2;
         let cposx = (scope.sections.datalist[ccode].points[0].x + scope.sections.datalist[ccode].points[scope.sections.datalist[ccode].pointslength].x)/2;
 
         let aposy = (scope.sections.datalist[acode].points[0].y + scope.sections.datalist[acode].points[scope.sections.datalist[acode].pointslength].y)/2;
         let cposy = (scope.sections.datalist[ccode].points[0].y + scope.sections.datalist[ccode].points[scope.sections.datalist[ccode].pointslength].y)/2;
 
-        // console.log("----------------");
         if(aposx > cposx){
           if(aposy < cposy){
             //  ——A

src/jlmap3d/edit/railwayModel/rSignalList.js

@@ -13,7 +13,6 @@ export function rSignalList() {
   this.initpromise = function(jlmap3ddata,data,scene,assetloader,netdata){
     return new Promise(function(resolve, reject){
       scope.group.name = "signal";
-      // console.log(data);
       //遍历信号数据
       let netsignal = null;
       let haddata = false;
@@ -32,7 +31,6 @@ export function rSignalList() {
         if(data[i].virtual == false){
           let newsignal = new SignalModel(data[i]);
           if(haddata == false){
-                  // console.log(data[i])
             let newmesh = assetloader.modellist[num].mesh.clone(true);
 
             newmesh.name = data[i].name;
@@ -154,7 +152,6 @@ export function rSignalList() {
             if(data[n].virtual == false){
               let newsignal = new SignalModel(signaldata[i]);
 
-              // console.log(signaldata[i]);
               let newmesh = assetloader.modellist[num].mesh.clone(true);
               newmesh.sectionCode = data[n].sectionCode;
               newmesh.sectionOffset = data[n].sectionOffset;
@@ -191,7 +188,6 @@ export function rSignalList() {
     });
   };
   this.resetsignal = function(jlmap3ddata){
-    // console.log(jlmap3ddata.linksgroup);
     let sectiondata = jlmap3ddata.sectionlist.sectiongroup.children;
     for(let i=0;i<scope.group.children.length;i++){
       let signaldata = scope.group.children[i];
@@ -200,7 +196,6 @@ export function rSignalList() {
         if(sectiondata[j].code == signaldata.sectionCode){
           let section = sectiondata[j];
           let posx = null;
-          // console.log(section);
 
           posx = section.railpoint[0].x + signaldata.sectionOffset;
 

src/jlmap3d/edit/railwayModel/rSwitchList.js

@@ -14,11 +14,9 @@ export function rSwitchList() {
   };
 
   this.initpromise = function(jlmap3ddata,data,scene,assetloader,netdata){
-    // console.log(jlmap3ddata);
     return new Promise(function(resolve, reject){
       scene.add( scope.switchgroup );
       let sectiondata = jlmap3ddata.sectionlist.sections.datalist;
-      // console.log(sectiondata);
       let num;
       for(let j=0;j<assetloader.modellist.length;j++){
         if(assetloader.modellist[j].deviceType == "autoswitch"){
@@ -58,7 +56,6 @@ export function rSwitchList() {
     return new Promise(function(resolve, reject){
       scene.add( scope.switchgroup );
       // let sectiondata = jlmap3ddata.sectionlist.sections.datalist;
-      // console.log(sectiondata);
       let num;
       for(let j=0;j<assetloader.modellist.length;j++){
         if(assetloader.modellist[j].type == "switch"){
@@ -70,7 +67,6 @@ export function rSwitchList() {
         }
       };
       for(let i=0,leni = switchdata.length;i<leni;i++){
-        // console.log(switchdata[i]);
         let newswitch = {
           code:switchdata[i].code,
           name:switchdata[i].name,
@@ -79,7 +75,6 @@ export function rSwitchList() {
           pc:switchdata[i].pc
         };
 
-        // console.log(newswitch.pa);
         let autoswitch = assetloader.modellist[num].mesh.clone(true);
         autoswitch.code = switchdata[i].code;
         for(let j=0;j<autoswitch.children.length;j++){
@@ -101,7 +96,6 @@ export function rSwitchList() {
   }
 
   this.resetswitch = function(data){
-    // console.log("reset");
     let sectiondata = data.sectionlist.sectiongroup;
     for(let i=0;i<scope.switchs.datalist.length;i++){
 

src/jlmap3d/edit/testEditorModel/RailList.js

@@ -61,12 +61,7 @@ export function RailList(){
         x:circle1.position.x,
         z:circle1.position.z
       }];
-      // console.log(i);
-      // console.log(section[i].mesh);
-      // console.log(mapdata.sectionlist.sections.datalist[i].rail);
-      // console.log("=======================");
     }
-    // console.log(n);
     // for(let i=0;i<mapdata.switchlist.switchgroup.children.length;i++){
     //   var geometry = new THREE.CircleBufferGeometry( 1, 16 );
     //   var material = new THREE.MeshBasicMaterial( { color: 0xff00ff } );

src/jlmap3d/edit/testEditorModel/SectionList.js

@@ -36,7 +36,6 @@ export function SectionList() {
         if(sectiondata[i].type == "01" || sectiondata[i].type == "03"){
           //初始化区段对象数据
           let newsection = new SectionModel(sectiondata[i]);
-          // console.log(sectiondata[i]);
           newsection.name = sectiondata[i].name;
           newsection.code = sectiondata[i].code;
           newsection.index = i;
@@ -49,7 +48,6 @@ export function SectionList() {
           newsection.points = sectiondata[i].points;
           newsection.pointslength = sectiondata[i].points.length-1;
           newsection.railpoint = [];
-          // console.log(sectiondata[i].points.length);
           newsection.standTrack = sectiondata[i].standTrack;
 
           newsection.endbuild = false;
@@ -97,7 +95,6 @@ export function SectionList() {
         let acode = switchdata[i].sectionACode;
         let bcode = switchdata[i].sectionBCode;
         let ccode = switchdata[i].sectionCCode;
-        // console.log(switchdata[i]);
 
 
         let aposx = (scope.sections.datalist[acode].points[0].x + scope.sections.datalist[acode].points[scope.sections.datalist[acode].pointslength].x)/2;
@@ -106,7 +103,6 @@ export function SectionList() {
         let aposy = (scope.sections.datalist[acode].points[0].y + scope.sections.datalist[acode].points[scope.sections.datalist[acode].pointslength].y)/2;
         let cposy = (scope.sections.datalist[ccode].points[0].y + scope.sections.datalist[ccode].points[scope.sections.datalist[ccode].pointslength].y)/2;
 
-        // console.log("----------------");
         if(aposx > cposx){
           if(aposy < cposy){
             //  ——A
@@ -175,7 +171,6 @@ export function SectionList() {
           reals:[],
           posx:null,
         };
-        // console.log(stationlist[i]);
 
         // realstopsection.stands.push();
         for(let n=0,lenn = stationlist[i].stands.length;n<lenn;n++){
@@ -384,7 +379,6 @@ export function SectionList() {
       }
       //根据站台区段创建站台位置 120停车点距离
       for(let j=0,lenj=stations.length;j<lenj;j++){
-        // console.log(j);
         let direction1 = scope.sections.datalist[stations[j].stands[0].section];
         let direction2 = scope.sections.datalist[stations[j].stands[1].section];
 
@@ -404,7 +398,6 @@ export function SectionList() {
       }
 
       // scope.sections.datalist[stations[0].stands[0].section].endbuild = true;
-      console.log("START BUILD !!!!!!!!!!!!!!!!!");
       buildsectionall(scope.sections.datalist[stations[0].stands[0].section]);
       resolve("loadersection");
     });
@@ -492,12 +485,7 @@ export function SectionList() {
       y:0,
       z:position.z
     };
-    // console.log(origin+"******************************");
-    // console.log(start);
-    // console.log(origin);
     if(scope.sections.datalist[start].standTrack == true && start != origin){
-      // console.log(start+"到达");
-      // console.log("++++++++++++++++++++++++");
       return ;
     }else if(scope.sections.datalist[start].rsection == undefined){
       return ;
@@ -666,11 +654,7 @@ export function SectionList() {
         ];
       }
 
-      // console.log(data.ctype);
       if(type == "cross"){
-        // console.log(data.ctype);
-        // console.log(scope.sections.datalist[data.code].points.length);
-        // console.log(scope.sections.datalist[data.code]);
         if(data.ctype == "1"||data.ctype == "2" ){
 
 
@@ -1015,16 +999,13 @@ export function SectionList() {
         let acode = switch2d[i].sectionACode;
         let bcode = switch2d[i].sectionBCode;
         let ccode = switch2d[i].sectionCCode;
-        // console.log(switchdata[i]);
 
-        // console.log(scope.sections.datalist[acode]);
         let aposx = (scope.sections.datalist[acode].points[0].x + scope.sections.datalist[acode].points[scope.sections.datalist[acode].pointslength].x)/2;
         let cposx = (scope.sections.datalist[ccode].points[0].x + scope.sections.datalist[ccode].points[scope.sections.datalist[ccode].pointslength].x)/2;
 
         let aposy = (scope.sections.datalist[acode].points[0].y + scope.sections.datalist[acode].points[scope.sections.datalist[acode].pointslength].y)/2;
         let cposy = (scope.sections.datalist[ccode].points[0].y + scope.sections.datalist[ccode].points[scope.sections.datalist[ccode].pointslength].y)/2;
 
-        // console.log("----------------");
         if(aposx > cposx){
           if(aposy < cposy){
             //  ——A

src/jlmap3d/edit/testEditorModel/SignalList.js

@@ -13,7 +13,6 @@ export function SignalList() {
   this.initpromise = function(jlmap3ddata,data,scene,assetloader,netdata){
     return new Promise(function(resolve, reject){
       scope.group.name = "signal";
-      // console.log(data);
       //遍历信号数据
       let netsignal = null;
       let haddata = false;
@@ -32,7 +31,6 @@ export function SignalList() {
         if(data[i].virtual == false){
           let newsignal = new SignalModel(data[i]);
           if(haddata == false){
-                  // console.log(data[i])
             let newmesh = assetloader.modellist[num].mesh.clone(true);
 
             newmesh.name = data[i].name;
@@ -154,7 +152,6 @@ export function SignalList() {
             if(data[n].virtual == false){
               let newsignal = new SignalModel(signaldata[i]);
 
-              // console.log(signaldata[i]);
               let newmesh = assetloader.modellist[num].mesh.clone(true);
               newmesh.sectionCode = data[n].sectionCode;
               newmesh.sectionOffset = data[n].sectionOffset;
@@ -191,7 +188,6 @@ export function SignalList() {
     });
   };
   this.resetsignal = function(jlmap3ddata){
-    // console.log(jlmap3ddata.linksgroup);
     let sectiondata = jlmap3ddata.sectionlist.sectiongroup.children;
     for(let i=0;i<scope.group.children.length;i++){
       let signaldata = scope.group.children[i];
@@ -200,7 +196,6 @@ export function SignalList() {
         if(sectiondata[j].code == signaldata.sectionCode){
           let section = sectiondata[j];
           let posx = null;
-          // console.log(section);
 
           posx = section.railpoint[0].x + signaldata.sectionOffset;
 

src/jlmap3d/edit/testEditorModel/StationStandList.js

@@ -83,18 +83,14 @@ export function StationStandList() {
         }
 
       }
-      console.log(scope.list);
       resolve("loadedstation");
     });
   }
   this.loadpromise = function(jlmap3ddata,standsdata,jlmapdata,scene,assetloader,otherStation){
     return new Promise(function(resolve, reject){
-      // console.log(jlmap3ddata);
       let jlmapstationdata = jlmapdata.stationList;
       let jlmapstanddata = jlmapdata.stationStandList;
       // jlmapstationdata.splice(0,1);
-        console.log(standsdata);
-        console.log(jlmapstationdata);
       // for(let i=0;i<jlmapstationdata.length;i++){// || jlmapstationdata[i].subheadDisplay == false
       //   if(jlmapstationdata[i].visible == false){
       //     jlmapstationdata.splice(i,1);
@@ -103,30 +99,19 @@ export function StationStandList() {
       //     standsdata[i].code = jlmapstationdata[i].code;
       //     standsdata[i].name = jlmapstationdata[i].name;
       //   }
-      //   // console.log(jlmapstationdata[i].subheadDisplay);
       // }
 
-      // console.log(jlmapstationdata);
-      console.log(standsdata);
       //
-      // console.log(jlmapstationdata);
       //
-      // console.log(standsdata);
-      // console.log(jlmapstationdata);
       for(let i=0;i<jlmapstationdata.length;i++){
         if(jlmapstationdata[i].visible == false || jlmapstationdata[i].depot == true){
           jlmapstationdata.splice(i,1);
           i--;
         }else{
-          // console.log(jlmapstationdata[i]);
-          // console.log(standsdata[i]);
           standsdata[i].code = jlmapstationdata[i].code;
           standsdata[i].name = jlmapstationdata[i].name;
         }
       }
-      // console.log(otherStation);
-      // console.log(standsdata);
-      // console.log(assetloader.modellist);
       let stations = jlmap3ddata.stationstandlist.list;
       let num;
       let num2;
@@ -154,9 +139,6 @@ export function StationStandList() {
           num3 = j;
         }
       }
-      // console.log("+++++++++++++");
-      // console.log(jlmapstanddata);
-      // console.log(standsdata);
       for(let i=0;i<standsdata.length;i++){
         let newstationstand = new StationStandModel(standsdata[i]);
         let newstationmesh;
@@ -186,7 +168,6 @@ export function StationStandList() {
               newstationstand.name = standsdata[i].name;
               newstationstand.inside = standsdata[i].inside;
 
-              // console.log(standsdata[i]);
               newstationmesh.code = standsdata[i].code;
               newstationmesh.name = standsdata[i].name;
               newstationmesh.meshtype = "station";
@@ -211,13 +192,11 @@ export function StationStandList() {
             }else{
               newstationmesh = assetloader.modellist[num2].mesh.clone(true);
             }
-            // console.log(jlmapstanddata[j]);
 
             newstationstand.code = standsdata[i].code;
             newstationstand.name = standsdata[i].name;
             newstationstand.inside = standsdata[i].inside;
 
-            // console.log(standsdata[i]);
             newstationmesh.code = standsdata[i].code;
             newstationmesh.name = standsdata[i].name;
             newstationmesh.meshtype = "station";
@@ -232,11 +211,9 @@ export function StationStandList() {
             scope.list.push(newstationstand);
           }else{
             newstationmesh = assetloader.modellist[num3].mesh.clone(true);
-            // console.log(jlmapstanddata[j]);
             newstationstand.code = standsdata[i].code;
             newstationstand.name = standsdata[i].name;
             newstationstand.inside = standsdata[i].inside;
-            // console.log(standsdata[i]);
             newstationmesh.code = standsdata[i].code;
             newstationmesh.name = standsdata[i].name;
             newstationmesh.position.x = standsdata[i].position.x;

src/jlmap3d/edit/testEditorModel/SwitchList.js

@@ -14,11 +14,9 @@ export function SwitchList() {
   };
 
   this.initpromise = function(jlmap3ddata,data,scene,assetloader,netdata){
-    // console.log(jlmap3ddata);
     return new Promise(function(resolve, reject){
       scene.add( scope.switchgroup );
       let sectiondata = jlmap3ddata.sectionlist.sections.datalist;
-      // console.log(sectiondata);
       let num;
       for(let j=0;j<assetloader.modellist.length;j++){
         if(assetloader.modellist[j].deviceType == "autoswitch"){
@@ -58,7 +56,6 @@ export function SwitchList() {
     return new Promise(function(resolve, reject){
       scene.add( scope.switchgroup );
       // let sectiondata = jlmap3ddata.sectionlist.sections.datalist;
-      // console.log(sectiondata);
       let num;
       for(let j=0;j<assetloader.modellist.length;j++){
         if(assetloader.modellist[j].type == "switch"){
@@ -70,7 +67,6 @@ export function SwitchList() {
         }
       };
       for(let i=0,leni = switchdata.length;i<leni;i++){
-        // console.log(switchdata[i]);
         let newswitch = {
           code:switchdata[i].code,
           name:switchdata[i].name,
@@ -79,7 +75,6 @@ export function SwitchList() {
           pc:switchdata[i].pc
         };
 
-        // console.log(newswitch.pa);
         let autoswitch = assetloader.modellist[num].mesh.clone(true);
         autoswitch.code = switchdata[i].code;
         for(let j=0;j<autoswitch.children.length;j++){
@@ -101,7 +96,6 @@ export function SwitchList() {
   }
 
   this.resetswitch = function(data){
-    // console.log("reset");
     let sectiondata = data.sectionlist.sectiongroup;
     for(let i=0;i<scope.switchs.datalist.length;i++){
 

src/jlmap3d/edit/testEditorModel/TrainList.js

@@ -76,7 +76,6 @@ let onProgress = function ( xhr ) {
   if ( xhr.lengthComputable ) {
 
     let percentComplete = xhr.loaded / xhr.total * 100;
-    //console.log( Math.round( percentComplete, 2 ) + '% downloaded' );
 
   }
 

src/jlmap3d/edit/utils/SetObj.js

@@ -46,7 +46,6 @@ export function SetObj(data,scope) {
     if(data.sectionList[i].type == "01"){
 
       if(data.sectionList[i].points.length>=3){
-        console.log(data.sectionList[i]);
 
         for(let j=1;j<data.sectionList[i].points.length;j++){
           point1 = data.sectionList[i].points[j-1];
@@ -203,7 +202,5 @@ export function SetObj(data,scope) {
     group.add(object);
   }
 
-  console.log("setobj");
   scope.exportmodel = group;
-  console.log(group);
 }

src/jlmap3d/edit/utils/drawhelp.js

@@ -15,17 +15,12 @@
 
 			var intersects4 = raycaster4.intersectObjects( helppoints[i] );
 
-			//// //console.log(raycaster1);
 			if(intersects1[0] != undefined){
-				 // // //console.log("intersects1");
-				// // //console.log(intersects1[0]);
 				intersects1[0].name = "1";
 				mindistance = intersects1[0].distance;
 				result = intersects1[0];
 			}
 			if(intersects2[0] != undefined){
-				 // // //console.log("intersects2");
-				 // // //console.log(mindistance);
 				intersects2[0].name = "2";
 				if(mindistance == undefined){
 					mindistance = intersects2[0].distance;
@@ -38,8 +33,6 @@
 
 			}
 			if(intersects3[0] != undefined){
-				 // // //console.log("intersects3");
-				 // // //console.log(mindistance);
 				intersects3[0].name = "3";
 				if(mindistance == undefined){
 					mindistance = intersects3[0].distance;
@@ -50,8 +43,6 @@
 				}
 			}
 			if(intersects4[0] != undefined){
-				 // // //console.log("intersects4");
-				 // // //console.log(mindistance);
 				intersects4[0].name = "4";
 				if(mindistance == undefined){
 					mindistance = intersects4[0].distance;

src/jlmap3d/jl3ddevice/component/moveanimate.js

@@ -485,7 +485,6 @@ export function Moveanimate(main){
             }
 
           }else{
-            // console.log(scope.animatelist[k].connectmodel);
             if(scope.nowmodelname != scope.playlist[scope.playorder][i].connectmodel.name){
               scope.nowmodelname = scope.playlist[scope.playorder][i].connectmodel.name;
               main.animationmsgshowon(scope.playlist[scope.playorder][i].connectmodel);

src/jlmap3d/jl3ddevice/component/textconfig.js

@@ -10,7 +10,6 @@ export function Textconfig(){
     if(scope.devicelist.length>0){
       scope.devicelist = [];
     }
-    console.log(selectmodel.deviceType);
     if(selectmodel.deviceType == "DeviceSwitch"){
       initSwitchText(selectmodel);
     }
@@ -92,9 +91,6 @@ export function Textconfig(){
       }
 
 
-      // if(part.text == null){
-      //   console.log(selectmodel.children[i].name);
-      // }
       if(part.text){
         scope.devicelist.push(part);
       }
@@ -192,9 +188,6 @@ export function Textconfig(){
         part.msg = "用于机内外电缆连接，方便更换转辙机。";
         selectmodel.children[i].text = "二十位插接件";
       }
-      // if(part.text == null){
-      //   console.log(selectmodel.children[i].name);
-      // }
       if(part.text){
         scope.devicelist.push(part);
       }

src/jlmap3d/jl3ddevice/jl3ddeviceNew.js

@@ -143,11 +143,8 @@ export function Jl3ddeviceNew(dom,group,token,skinCode) {
 				stationList.push(mapnetdata.stationList[i]);
 			}
 		}
-		// console.log(mapnetdata.stationList);
 		for(let k in psdVoiceStationList){
 			for(let i=0,leni=stationList.length;i<leni;i++){
-				// console.log("---------------");
-				// console.log("---------------");
 				if(psdVoiceStationList[k].stationCode == stationList[i].code){
 					psdVoiceStationList[k].nowStationName = stationList[i].name;
 
@@ -294,7 +291,6 @@ export function Jl3ddeviceNew(dom,group,token,skinCode) {
 			for (let i = 0; i < scope.mixers.length; i++) {
 				if (scope.mixers[i]) {
 					if(	scope.mixers[i].staticType){
-						// console.log(scope.mixers[i].time);
 						if(scope.mixers[i]._actions[0].time<stopTime){
 							scope.mixers[i].update(delta);
 						}else{
@@ -343,11 +339,7 @@ export function Jl3ddeviceNew(dom,group,token,skinCode) {
 				scope.raycasterstatus = false;
 				scope.nowobject = null;
 				updatemenulist();
-				if(data._type == "Station"){
 
-					console.log(data);
-				}
-				
 				if (data._type == "Switch") {
 					// scope.modelmanager.switchmodel.locateType = data.body.locateType;
 					scope.modelmanager.switchmodel.code = data.code;
@@ -493,8 +485,6 @@ export function Jl3ddeviceNew(dom,group,token,skinCode) {
 	this.changeAnimate = function(type){
 		//
 
-		console.log(type);
-		// console.log(scope.modelmanager.staticswitchmodel);
 
 		// scope.modelmanager.staticswitchmodel.action["2kai"].reset();
 		// scope.modelmanager.staticswitchmodel.action["5jiasuo"].reset();
@@ -520,7 +510,6 @@ export function Jl3ddeviceNew(dom,group,token,skinCode) {
 			stopTime = 3.33;
 			scope.modelmanager.staticswitchmodel.action.play();
 
-			console.log(scope.mixers);
 		}
 		if(type == "action2"){
 			scope.camera.position.x = -7.23;
@@ -584,8 +573,6 @@ export function Jl3ddeviceNew(dom,group,token,skinCode) {
 			scope.camera.position.y = 22.56;
 			scope.camera.position.z = -1.348;
 			scope.controls.target = new THREE.Vector3(-2.15,10,-1.348);
-			// console.log(scope.camera.position);
-			// console.log(scope.controls.target);
 			scope.modelmanager.staticswitchmodel.action.reset();
 			scope.modelmanager.staticswitchmodel.action.time = 23.36;
 			stopTime = 26.66;

src/jlmap3d/jl3ddevice/loader.js

@@ -93,7 +93,6 @@ export function ModelManager(){
       Promise.all(initlist).then((result) => {
         resolve("success");             //['成功了', 'success']
       }).catch((error) => {
-        //console.log(error);
       });
 
     });

src/jlmap3d/jl3ddrive/jl3ddrive.js

@@ -156,7 +156,6 @@ export function JLmapDriving(dom,data,mapId,storemod,translation,routegroup,proj
 	getPublishMapDetail(mapId).then(data => {
     let mapnetdata = data.data;
     getPublish3dMapDetail(mapId).then(netdata => {
-			// console.log(netdata);
       let assetsdata = JSON.parse(netdata.data.sections);
 
         scope.datatype = "new";
@@ -271,7 +270,6 @@ export function JLmapDriving(dom,data,mapId,storemod,translation,routegroup,proj
 	};
 
 	updatemmi.updatedrivingcode = function(code) {
-		// console.log(trainlisttest);
 		drivingcode = code;
 		trainlisttest.group.children[0].children[0].add(controls3.getObject());
 		controls3.getObject().position.x = 10;
@@ -313,7 +311,6 @@ export function JLmapDriving(dom,data,mapId,storemod,translation,routegroup,proj
 		if(driverWebWorker){
 			driverWebWorker.terminate();
 		}
-		// console.log(scope);
 		// scope = null;
 	};
 
@@ -386,7 +383,6 @@ export function JLmapDriving(dom,data,mapId,storemod,translation,routegroup,proj
 		realsectionlist = loadrealsectionlist;
 		rails = loadrails;
 
-		console.log(trainlisttest);
 		trainlisttest.group.children[0].getObjectByName("C6").add(cameracctv);
 	}
 
@@ -401,7 +397,6 @@ export function JLmapDriving(dom,data,mapId,storemod,translation,routegroup,proj
 	};
 
 	this.eventoff = function() {
-		// console.log("off");
 		// raycaster交互模型点击事件
 		document.getElementById('jlsimulation').removeEventListener( 'mousedown', onselect, false );
 		// 窗口自适应
@@ -420,7 +415,6 @@ export function JLmapDriving(dom,data,mapId,storemod,translation,routegroup,proj
 			camera.position.z = mesh.children[0].position.z;
 			// controls.target = new THREE.Vector3(mesh.position.x,0,mesh.children[0].position.z);
 		}
-		// console.log(mesh);
 		if (type == 'station') {
 			camera.position.x = mesh.position.x;
 			camera.position.y = mesh.position.y+800;
@@ -493,7 +487,6 @@ export function JLmapDriving(dom,data,mapId,storemod,translation,routegroup,proj
 			}
 
 			if (scope.raycasterswitch == 'section') {
-				// console.log(sectionlist.sections.modellist);
 				let intersects = raycaster.intersectObjects( sectionlist.sections.modellist, true);
 				if (intersects[0]) {
 

src/jlmap3d/jl3ddrive/moveupdate/DrivingConnectNew.js

@@ -81,7 +81,6 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 		}
 
 		if(data.type == "DeviceCtrl_3D"){
-			// console.log(data);
 			if (data.body.type== 'SIGNAL' && signallist) {
 				signalupdate(data.body);
 				return;
@@ -201,8 +200,6 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 
 	}
 	this.updatamap = function(newsectionlist,newlinklist,newsignallist,newstationstandlist,newtrainlisttest,newrealsectionlist,newrails,newtdt, materiallist, nowaction, scene) {
-		// console.log(mapdata);
-		// console.log(newtrainlisttest);
 		trainmodel = newtrainlisttest.group.children[0];
 		trainlisttest = newtrainlisttest;
 		sectionlist = newsectionlist;
@@ -222,7 +219,6 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 
 	this.socketon = function(topic) {
 		try {
-			// console.log("teststomp");
 			// scope.teststomp.subscribe(topic, callback, header);
 		} catch (error) {
 			console.error('websocket订阅失败');
@@ -255,13 +251,11 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 
 	// 仿真socket接口回调函数
 	function callback(Response) {
-		// console.log(Response);
 		// 对象化数据
 
 		let data = JSON.parse(Response.body);
 			// stats.update();
 		// 遍历后台数据
-		// console.log(data);
 
 		if(data.type == "Train_Position"){
 			nowTrainRun(data.body);
@@ -306,7 +300,6 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 	}
 
 	function DeviceDestroy(data){
-		// console.log(data);
 		for(let i=0,leni=data.length;i<leni;i++){
 
 			if(data[i].type == "SIGNAL"){
@@ -359,10 +352,6 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 		}
 
 		function otherTrainUpdate(data,updateTrainModel){
-			// console.log(data);
-			// if(data.code = "336"){
-			// 	console.log(data);
-			// }
 			if(rails.sectionrail[data.section]){
 				if(data.section != updateTrainModel.nowsection){
 					updateTrainModel.nowsection = data.section;
@@ -418,7 +407,6 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 						// if(updateTrainModel.children[1].rotalist.length > 0 || updateTrainModel.children[2].rotalist.length > 0 || updateTrainModel.children[3].rotalist.length > 0 || updateTrainModel.children[4].rotalist.length > 0|| updateTrainModel.children[5].rotalist.length > 0){
 
 							for(let rs = 1;rs<updateTrainModel.children.length;rs++){
-									//console.log(rs);
 									if(updateTrainModel.children[rs].rotalist[0]){
 
 										let offsetz = parseFloat(updateTrainModel.children[rs].rotalist[0].posr.z) + parseFloat(updateTrainModel.children[rs].position.z);
@@ -441,13 +429,11 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 												xh = updateTrainModel.children[rs].rotalist.length;
 											}
 										}
-										//console.log(trainmodel.children[rs].rotalist.length);
 
 									}
 
 
 							}
-							// console.log(trainmodel.rotalist);
 						// }
 
 					}else{
@@ -493,7 +479,6 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 
 						// if(updateTrainModel.children[1].rotalist.length > 0 || updateTrainModel.children[2].rotalist.length > 0 || updateTrainModel.children[3].rotalist.length > 0 || updateTrainModel.children[4].rotalist.length > 0|| updateTrainModel.children[5].rotalist.length > 0){
 							for(let rs = 1;rs<updateTrainModel.children.length;rs++){
-								//console.log(rs);
 								if(updateTrainModel.children[rs].rotalist[0]){
 									let offsetz = parseFloat(updateTrainModel.children[rs].rotalist[0].posr.z) - parseFloat(updateTrainModel.children[rs].matrixWorld.elements[14]);
 
@@ -658,7 +643,6 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 						if(trainmodel.children[1].rotalist.length > 0 || trainmodel.children[2].rotalist.length > 0 || trainmodel.children[3].rotalist.length > 0 || trainmodel.children[4].rotalist.length > 0|| trainmodel.children[5].rotalist.length > 0){
 
 							for(let rs = 1;rs<trainmodel.children.length;rs++){
-									//console.log(rs);
 									if(trainmodel.children[rs].rotalist[0]){
 
 										let offsetz = parseFloat(trainmodel.children[rs].rotalist[0].posr.z) + parseFloat(trainmodel.children[rs].position.z);
@@ -685,13 +669,10 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 												xh = trainmodel.children[rs].rotalist.length;
 											}
 										}
-										//console.log(trainmodel.children[rs].rotalist.length);
-
 									}
 
 
 							}
-							// console.log(trainmodel.rotalist);
 						}
 
 					}else{
@@ -768,7 +749,6 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 
 						if(trainmodel.children[1].rotalist.length > 0 || trainmodel.children[2].rotalist.length > 0 || trainmodel.children[3].rotalist.length > 0 || trainmodel.children[4].rotalist.length > 0|| trainmodel.children[5].rotalist.length > 0){
 							for(let rs = 1;rs<trainmodel.children.length;rs++){
-								//console.log(rs);
 								if(trainmodel.children[rs].rotalist[0]){
 									let offsetz = parseFloat(trainmodel.children[rs].rotalist[0].posr.z) - parseFloat(trainmodel.children[rs].matrixWorld.elements[14]);
 									trainmodel.children[rs].position.z += offsetz;
@@ -794,7 +774,6 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 											xh = trainmodel.children[rs].rotalist.length;
 										}
 									}
-									//console.log(trainmodel.children[rs].rotalist.length);
 								}
 							}
 						}
@@ -817,10 +796,6 @@ export function Jl3dDrivingNew(mixers,updatemmi,sound,translation,routegroup,dri
 
 
 		function traindoorupdate(data){
-			// console.log(data);
-			// console.log("direct:"+trainmodel.right);
-			// console.log(trainmodel.openleft);
-			// console.log(trainmodel.openright);
 			if(trainmodel.code == data.trainCode){
 				if(trainmodel.right == "0"){
 					if(data.code == "2"){

src/jlmap3d/jl3ddrive/moveupdate/UpdateTrain.js

@@ -4,11 +4,9 @@ export function UpdateTrain(camera,traindata,control){
     if(traindata != undefined && traindata.group.children[0]){//traindata.group.children[0].dispose == false
 
       if(traindata.group.children[0].progress != null){
-          // console.log(traindata.group);
           let trainmodel = traindata.group.children[0];
           if(trainmodel.speeds > 0 && trainmodel.speeds){
             let speed = null;
-            // console.log(traindata.group.children[0].progress);
             if(traindata.group.children[0].progress >=0&&traindata.group.children[0].progress<=1){
 
               let movecurve = trainmodel.curve;
@@ -44,7 +42,6 @@ export function UpdateTrain(camera,traindata,control){
 
                   if(trainmodel.children[1].rotalist.length > 0 || trainmodel.children[2].rotalist.length > 0 || trainmodel.children[3].rotalist.length > 0 || trainmodel.children[4].rotalist.length > 0|| trainmodel.children[5].rotalist.length > 0){
                     for(let rs = 1;rs<6;rs++){
-                      //console.log(rs);
                       if(trainmodel.children[rs].rotalist[0]){
                         let offsetz = parseFloat(trainmodel.children[rs].matrixWorld.elements[14]) - parseFloat(trainmodel.children[rs].rotalist[0].posr.z);
 
@@ -66,7 +63,6 @@ export function UpdateTrain(camera,traindata,control){
                             xh = trainmodel.children[rs].rotalist.length;
                           }
                         }
-                        //console.log(trainmodel.children[rs].rotalist.length);
                       }
                     }
                   }
@@ -103,7 +99,6 @@ export function UpdateTrain(camera,traindata,control){
                   if(trainmodel.children[1].rotalist.length > 0 || trainmodel.children[2].rotalist.length > 0 || trainmodel.children[3].rotalist.length > 0 || trainmodel.children[4].rotalist.length > 0|| trainmodel.children[5].rotalist.length > 0){
 
                     for(let rs = 1;rs<6;rs++){
-                        //console.log(rs);
                         if(trainmodel.children[rs].rotalist[0]){
 
                           let offsetz = parseFloat(trainmodel.children[rs].rotalist[0].posr.z) - parseFloat(trainmodel.children[rs].matrixWorld.elements[14]);
@@ -126,13 +121,10 @@ export function UpdateTrain(camera,traindata,control){
                               xh = trainmodel.children[rs].rotalist.length;
                             }
                           }
-                          //console.log(trainmodel.children[rs].rotalist.length);
-
                         }
 
 
                     }
-                    // console.log(trainmodel.rotalist);
                   }
                   trainmodel.progress += trainmodel.speeds;
                 }
@@ -152,9 +144,6 @@ export function UpdateTrain(camera,traindata,control){
                 trainmodel.nextcode = null;
               }
 
-              // console.log(trainmodel.name);
-              // console.log(trainmodel.progress);
-              // console.log(trainmodel.nextcurve);
               // if(trainmodel.status == "02"){
               //   trainmodel.progress = 0;
               // }else if(trainmodel.status == "03"){
@@ -197,7 +186,6 @@ export function UpdateTrain(camera,traindata,control){
 
                   if(trainmodel.children[1].rotalist.length > 0 || trainmodel.children[2].rotalist.length > 0 || trainmodel.children[3].rotalist.length > 0 || trainmodel.children[4].rotalist.length > 0|| trainmodel.children[5].rotalist.length > 0){
                     for(let rs = 1;rs<6;rs++){
-                      //console.log(rs);
                       if(trainmodel.children[rs].rotalist[0]){
                         let offsetz = parseFloat(trainmodel.children[rs].matrixWorld.elements[14]) - parseFloat(trainmodel.children[rs].rotalist[0].posr.z);
 
@@ -219,7 +207,6 @@ export function UpdateTrain(camera,traindata,control){
                             xh = trainmodel.children[rs].rotalist.length;
                           }
                         }
-                        //console.log(trainmodel.children[rs].rotalist.length);
                       }
                     }
                   }
@@ -256,7 +243,6 @@ export function UpdateTrain(camera,traindata,control){
                   if(trainmodel.children[1].rotalist.length > 0 || trainmodel.children[2].rotalist.length > 0 || trainmodel.children[3].rotalist.length > 0 || trainmodel.children[4].rotalist.length > 0|| trainmodel.children[5].rotalist.length > 0){
 
                     for(let rs = 1;rs<6;rs++){
-                        //console.log(rs);
                         if(trainmodel.children[rs].rotalist[0]){
 
                           let offsetz = parseFloat(trainmodel.children[rs].rotalist[0].posr.z) - parseFloat(trainmodel.children[rs].matrixWorld.elements[14]);
@@ -279,16 +265,12 @@ export function UpdateTrain(camera,traindata,control){
                               xh = trainmodel.children[rs].rotalist.length;
                             }
                           }
-                          //console.log(trainmodel.children[rs].rotalist.length);
-
                         }
 
 
                     }
-                    // console.log(trainmodel.rotalist);
                   }
 
-                  // console.log(trainmodel.nextcurve);
                   if(trainmodel.progress > -(trainmodel.speeds)){
                     trainmodel.progress += trainmodel.speeds;
                   }

src/jlmap3d/jl3dmaintainer/Jl3dfaultdevice.js

@@ -106,7 +106,6 @@ export function Jl3dfaultdevice(dom,group,token,skinCode) {
 	let topic = '/user/queue/simulation/'+ group +'/jl3d';
 	let header = {'X-Token': token};
 	try {
-		// console.log("teststomp");
 		teststomp.subscribe(topic, callback, header);
 	} catch (error) {
 		console.error('websocket订阅失败');
@@ -120,7 +119,6 @@ export function Jl3dfaultdevice(dom,group,token,skinCode) {
 		// 	scope.selectmodel(data);
 		// }else{
 		if(data.type == "DeviceCtrl_3D"){
-			// console.log(data.body);
 			if(data.body.code == scope.nowcode){
 				scope.updateaction(data.body);
 			}
@@ -143,7 +141,6 @@ export function Jl3dfaultdevice(dom,group,token,skinCode) {
 	this.anime = null;
 
 	this.modelmanager = new ModelManager();
-	console.log(skinCode);
 	getPublish3dMapDetail(skinCode).then(netdata => {
 		let netDataAssets = JSON.parse(netdata.data.assets);
 		setpsdstationmap(JSON.parse(netdata.data.stands));
@@ -206,7 +203,6 @@ export function Jl3dfaultdevice(dom,group,token,skinCode) {
 	}
 
 	this.selectmodel = function (data) {
-		console.log(data);
 		if (scope.showmodel) {
 
 			if (scope.showmodel.code != data.code) {
@@ -250,7 +246,6 @@ export function Jl3dfaultdevice(dom,group,token,skinCode) {
 				}
 
 				if (data.type == "STAND") {
-					// console.log(data);
 					scope.modelmanager.standmodel.code = data.code;
 					scope.showmodel = scope.modelmanager.standmodel.mesh;
 					scope.scene.add(scope.showmodel);
@@ -267,7 +262,6 @@ export function Jl3dfaultdevice(dom,group,token,skinCode) {
 
 				}
 				if (data.type == "SECTION") {
-					// console.log(data);
 					scope.modelmanager.sectionmodel.code = data.code;
 					scope.showmodel = scope.modelmanager.sectionmodel.mesh;
 					scope.scene.add(scope.showmodel);
@@ -285,7 +279,6 @@ export function Jl3dfaultdevice(dom,group,token,skinCode) {
 		} else {
 			scope.nowcode  = data.code;
 			if (data.type == "room") {
-				// console.log(scope.modelmanager.roommodel.mesh);
 				scope.showmodel = scope.modelmanager.roommodel.mesh;
 				scope.scene.add(scope.showmodel);
 				scope.camera.position.set(5, 7, -9);
@@ -409,7 +402,6 @@ export function Jl3dfaultdevice(dom,group,token,skinCode) {
 		}
 
 		settext(scope.animationmodel,scope.animationmodel.position);
-		// console.log(scope.animationmodel);
 		helpbox = new THREE.BoxHelper( scope.animationmodel, 0xff0000 );
 		moveanima.updatehelpbox(helpbox,textplane);
 		// settext(intersects[0].object,intersects[0].point);
@@ -548,13 +540,11 @@ export function Jl3dfaultdevice(dom,group,token,skinCode) {
 		scope.modelmanager.standmodel.action.play();
 	}
 	this.updateselect = function(updata){
-		// console.log(updata);
 		if(helpbox){
 			scope.scene.remove( helpbox );
 			helpbox = null;
 		}
 		helpbox = new THREE.BoxHelper( updata.mesh, 0xff0000 );
-		// console.log(updata.mesh);
 		let point = {
 			x:updata.mesh.matrixWorld.elements[12],
 			y:updata.mesh.matrixWorld.elements[13],
@@ -566,7 +556,6 @@ export function Jl3dfaultdevice(dom,group,token,skinCode) {
 	}
 
 	function getdevicemsg(selectname){
-		// console.log(selectname);
 		for(let i=0,leni=scope.devicetext.devicelist.length;i<leni;i++){
 
 			if(selectname == scope.devicetext.devicelist[i].name){
@@ -730,7 +719,6 @@ export function Jl3dfaultdevice(dom,group,token,skinCode) {
 			textplane.position.x = point.x;
 			textplane.position.y = point.y+6;
 			textplane.position.z = point.z;
-			// console.log(textplane.position);
 			// textplane.tcode = data[i].code;
 			textplane.rotation.y = -Math.PI/2;
 			textplane.lookAt(scope.camera.position);
@@ -764,7 +752,6 @@ export function Jl3dfaultdevice(dom,group,token,skinCode) {
 		  ctx.textAlign = 'center';
 		  ctx.textBaseline = 'middle';
 		  ctx.clearRect(0,0,256,128);
-		  //console.log(text.groupNumber);
 		  ctx.drawImage(beauty,0,0,256, 128);
 		  ctx.fillText("设备部件:"+text, 90,30);
 		  // ctx.fillText("车组人员:XXX", 40,20);

src/jlmap3d/jl3dmaintainer/jl3dFaultDeviceVr/jl3dFaultDeviceVr.js

@@ -700,7 +700,6 @@ export function jl3dFaultDeviceVr(dom,group,skinCode) {
 	function onSelectStart( event ) {
 
 		var controller = event.target;
-		// console.log(event);
 		let clickGui = getGuiButton(controller);
 		if(clickGui.length > 0){
 			if(positionStatus == "dm"){
@@ -853,9 +852,7 @@ export function jl3dFaultDeviceVr(dom,group,skinCode) {
 
 		}else{
 			var intersections = getIntersections( controller );
-			// console.log(intersections);
 			if ( intersections) {
-				// console.log(intersections);
 				var intersection = intersections[ 0 ];
 				if(intersection.distance <3.5){
 					if(positionStatus != intersection.object.name){
@@ -886,14 +883,12 @@ export function jl3dFaultDeviceVr(dom,group,skinCode) {
 						let posx = intersection.point.x - trainControl.toptrain.position.x;
 						let posz = intersection.point.z - trainControl.toptrain.position.z;
 						human.position.set( posx, intersection.point.y+0.6, posz);
-						// console.log(human.position);
 					}
 					if(positionStatus == "downfloor"){
 						let posx = trainControl.downtrain.position.x - intersection.point.x;
 						let posz = trainControl.downtrain.position.z - intersection.point.z;
 
 						human.position.set( posx, intersection.point.y+0.6, posz);
-						// console.log(human.position);
 					}
 					let postData = {
 						type:"syn",
@@ -929,9 +924,7 @@ export function jl3dFaultDeviceVr(dom,group,skinCode) {
 		// if ( intersections.length > 0 ) {
 		//
 		// 	// for(){}
-		// 	// console.log(intersections);
 		// 	var intersection = intersections[ 0 ];
-		// 	// console.log(intersection);
 		// 	// tempMatrix.getInverse( controller.matrixWorld );
 		// 	//
 		// 	// var object = intersection.object;
@@ -957,7 +950,6 @@ export function jl3dFaultDeviceVr(dom,group,skinCode) {
 	}
 
 	function squeezeStart(){
-		console.log("squeeze");
 		scope.modelmanager.otherDevice.action.play();
 		if(positionStatus == "dm"){
 			if(vrPlaneStatus){
@@ -986,7 +978,6 @@ export function jl3dFaultDeviceVr(dom,group,skinCode) {
 		// }
 
 		// settext(scope.animationmodel,scope.animationmodel.position);
-		// console.log(scope.animationmodel);
 		// helpbox = new THREE.BoxHelper( scope.animationmodel, 0xff0000 );
 		// moveanima.updatehelpbox(helpbox,textplane);
 		// settext(intersects[0].object,intersects[0].point);
@@ -1022,7 +1013,6 @@ export function jl3dFaultDeviceVr(dom,group,skinCode) {
 		raycastervr.ray.direction.set( 0, 0, - 1 ).applyMatrix4( tempMatrix );
 		for(let i=0;i<3;i++){
 			let rayObject = raycastervr.intersectObject( floors[i]);
-			// console.log(rayObject);
 			if(rayObject.length>0){
 				return rayObject;
 			}
@@ -1073,7 +1063,6 @@ export function jl3dFaultDeviceVr(dom,group,skinCode) {
 		if ( intersections) {
 
 			var intersection = intersections[ 0 ];
-			// console.log(intersection);
 			if(intersection.distance <3.5){
 				var object = intersection.object;
 				circle.position.set( intersection.point.x, intersection.point.y+0.05, intersection.point.z );
@@ -1131,7 +1120,6 @@ export function jl3dFaultDeviceVr(dom,group,skinCode) {
 	}
 
 	function getdevicemsg(selectname){
-		// console.log(selectname);
 		for(let i=0,leni=scope.devicetext.devicelist.length;i<leni;i++){
 
 			if(selectname == scope.devicetext.devicelist[i].name){
@@ -1205,7 +1193,6 @@ export function jl3dFaultDeviceVr(dom,group,skinCode) {
 
 
 		}
-		// console.log(scope.nowstation);
 	}
 
 	function initstationanimation(object){

src/jlmap3d/jl3dmaintainer/jl3dFaultDeviceVr/utils/moveanimatevr.js

@@ -299,7 +299,6 @@ export function MoveanimateVr(main){
   }
   //动画播放器
   this.animateupdate = function(){
-    // console.log(scope.animatelist);
 
     if(scope.enable){
       if(scope.playlist){
@@ -335,7 +334,6 @@ export function MoveanimateVr(main){
 
 
           }else{
-            // console.log(scope.animatelist[k].connectmodel);
             if(scope.nowmodelname != scope.playlist[scope.playorder][i].connectmodel.name){
               scope.nowmodelname = scope.playlist[scope.playorder][i].connectmodel.name;
               main.animationmsgshowon(scope.playlist[scope.playorder][i].connectmodel);

src/jlmap3d/jl3dmaintainer/jl3dFaultDeviceVr/utils/vrText.js

@@ -18,7 +18,6 @@ function setTextVr(intersects,plane){
     textplane.position.x = 0;
     textplane.position.y = 1.55;
     textplane.position.z = 0.01;
-    // console.log(textplane.position);
     // textplane.tcode = data[i].code;
     // textplane.rotation.y = -Math.PI/2;
     // scope.textlist.push(textplane);
@@ -51,7 +50,6 @@ function getTextCanvas(text){
     ctx.textAlign = 'center';
     ctx.textBaseline = 'middle';
     ctx.clearRect(0,0,256,128);
-    //console.log(text.groupNumber);
     ctx.drawImage(beauty,0,0,256, 128);
     ctx.fillText("新的设备故障", 110,30);
     ctx.fillText(text.name, 110,65);

src/jlmap3d/jl3dmaintainer/jl3dFaultDeviceVr/utils/vrgui.js

@@ -277,8 +277,6 @@ export function VrGui(){
   //
   // let nowGroupComponent = scope.homeGroup;
   this.setStationPlane = function(stations){
-    // console.log(stations);
-    // console.log(textures);
     let posX,posY;
     for(let i=0,leni = stations.length;i<leni;i++){
 
@@ -368,7 +366,6 @@ export function VrGui(){
   }
 
   this.updataDeviceFaultMsg = function(faultData){
-    console.log(faultData);
     let textt = new THREE.CanvasTexture(getTextCanvas(faultData,"faultMsg"));
     scope.deviceGroup.getObjectByName("deviceText").material.map = textt;
     scope.deviceGroup.getObjectByName("deviceText").material.map.needsUpdate = true;
@@ -474,7 +471,6 @@ export function VrGui(){
         ctx.textAlign = 'center';
         ctx.textBaseline = 'middle';
         ctx.clearRect(0,0,128,64);
-        //console.log(text.groupNumber);
         ctx.drawImage(beauty,0,0,128, 64);
         ctx.fillText(text.name, 64,32);
         //ctx.fillText(text.trainModel.name, width/2,height*3/4);
@@ -493,7 +489,6 @@ export function VrGui(){
         ctx.textAlign = 'center';
         ctx.textBaseline = 'middle';
         ctx.clearRect(0,0,128,64);
-        //console.log(text.groupNumber);
         ctx.drawImage(beauty,0,0,128, 64);
         ctx.fillText("故障设备编号:", 64,16);
         ctx.fillText(text.name, 64,48);
@@ -513,7 +508,6 @@ export function VrGui(){
         ctx.textAlign = 'center';
         ctx.textBaseline = 'middle';
         ctx.clearRect(0,0,256,256);
-        //console.log(text.groupNumber);
         ctx.drawImage(beauty,0,0,256, 256);
         ctx.fillText("当前车站信息", 128,32);
         ctx.fillText("车站名:"+text.name, 128,64);
@@ -540,7 +534,6 @@ export function VrGui(){
         ctx.textAlign = 'center';
         ctx.textBaseline = 'middle';
         ctx.clearRect(0,0,256,256);
-        //console.log(text.groupNumber);
         ctx.drawImage(beauty,0,0,256, 256);
         ctx.fillText("当前故障信息", 128,32);
         ctx.fillText("故障设备:"+text.code, 128,64);

src/jlmap3d/jl3dmaintainer/jl3dOtherVr/Jl3dothervr.js

@@ -183,9 +183,7 @@ export function Jl3dOtherVR(dom,group,skinCode) {
 
 	otherVrViewWorker.onmessage = function (event) {
 		// maintainerHuman
-		console.log(event.data);
 		if(event.data.type == "VR_Sync_3D"){
-			console.log(event.data);
 
 
 			humanMove(event.data);
@@ -268,8 +266,6 @@ export function Jl3dOtherVR(dom,group,skinCode) {
 		}
 
 		if(event.data.type == "takeDownTrain"){
-			console.log(event.data);
-			console.log(stationList);
 			for(let i=0,leni=stationList.length;i<leni;i++){
 				if(stationList[i].code ==  event.data.stationcode){
 					scope.nowstation = stationList[i];
@@ -294,8 +290,6 @@ export function Jl3dOtherVR(dom,group,skinCode) {
 		}
 
 		if(event.data.type == "topTrain"){
-			console.log(event.data);
-			console.log(trainControl.toptrain.status);
 			if(trainControl.toptrain.status != 1){
 				trainControl.toptrain.position.copy(trainControl.toptrain.curve.getPointAt(event.data.offset));
 			}
@@ -310,8 +304,6 @@ export function Jl3dOtherVR(dom,group,skinCode) {
 
 		if(event.data.type == "topTrainDoor"){
 
-			console.log(event.data);
-
 			if(event.data.open == "0"){
 				trainControl.closetraindoor(trainControl.toptrain,event.data.doorCode,"top");
 				// trainLeaveStation("top");
@@ -527,7 +519,6 @@ export function Jl3dOtherVR(dom,group,skinCode) {
 		// }
 
 		// settext(scope.animationmodel,scope.animationmodel.position);
-		// console.log(scope.animationmodel);
 		// helpbox = new THREE.BoxHelper( scope.animationmodel, 0xff0000 );
 		// moveanima.updatehelpbox(helpbox,textplane);
 		// settext(intersects[0].object,intersects[0].point);
@@ -602,7 +593,6 @@ export function Jl3dOtherVR(dom,group,skinCode) {
 
 
 	function getdevicemsg(selectname){
-		// console.log(selectname);
 		for(let i=0,leni=scope.devicetext.devicelist.length;i<leni;i++){
 
 			if(selectname == scope.devicetext.devicelist[i].name){
@@ -666,7 +656,6 @@ export function Jl3dOtherVR(dom,group,skinCode) {
 				}
 
 			}
-			console.log(stationList);
 			scope.nowstation = stationList[0];
 			let stationworket = {
 				type:'station',
@@ -676,7 +665,6 @@ export function Jl3dOtherVR(dom,group,skinCode) {
 
 
 		}
-		// console.log(scope.nowstation);
 	}
 
 
@@ -751,7 +739,6 @@ export function Jl3dOtherVR(dom,group,skinCode) {
 	}
 
 	function humanMove(movedata){
-		console.log(maintainerHuman);
 		let distance = Math.sqrt(Math.pow(movedata.body.pos.x - maintainerGroup.position.x, 2) + Math.pow(movedata.body.pos.y - maintainerGroup.position.y, 2) + Math.pow(movedata.body.pos.z - maintainerGroup.position.z, 2));
 
 		if(distance <5){
@@ -789,8 +776,6 @@ export function Jl3dOtherVR(dom,group,skinCode) {
 	}
 
 	function setTextVr(intersects,plane){
-		console.log(intersects);
-		console.log(plane);
 		if(intersects.text){
 			let textgeometry = new THREE.PlaneBufferGeometry( 1.2, 0.8, 1 );
 			let textt = new THREE.CanvasTexture(getTextCanvas(intersects));
@@ -809,7 +794,6 @@ export function Jl3dOtherVR(dom,group,skinCode) {
 			textplane.position.x = 0;
 			textplane.position.y = 1.55;
 			textplane.position.z = 0.01;
-			// console.log(textplane.position);
 			// textplane.tcode = data[i].code;
 			// textplane.rotation.y = -Math.PI/2;
 			// scope.textlist.push(textplane);
@@ -842,7 +826,6 @@ export function Jl3dOtherVR(dom,group,skinCode) {
 		  ctx.textAlign = 'center';
 		  ctx.textBaseline = 'middle';
 		  ctx.clearRect(0,0,256,128);
-		  //console.log(text.groupNumber);
 		  ctx.drawImage(beauty,0,0,256, 128);
 		  ctx.fillText("新的设备故障", 110,30);
 		  ctx.fillText(text.name, 110,65);