优化

- 调整了多个组件的输入框、按钮等元素的样式
- 优化了部分对话框的布局结构
- 统一了表单项的样式
- 调整了部分字体大小和颜色

.env.development

@@ -1,11 +1,15 @@
 # 页面标题
-VITE_APP_TITLE = 新能源项目管理平台
+VITE_APP_TITLE = 煤科建管平台
 
 # 开发环境配置
 VITE_APP_ENV = 'development'
 
 # 开发环境
-VITE_APP_BASE_API = 'http://192.168.110.119:8899'
+VITE_APP_BASE_API = 'http://192.168.110.209:8899'
+# VITE_APP_BASE_API = 'http://58.17.134.85:8899'
+# GO开发环境
+VITE_APP_BASE_API_GO = 'http://xny.yj-3d.com:7464'
+# VITE_APP_BASE_API_GO = 'http://192.168.110.188:8919'
 
 # 无人机接口地址
 

.env.production

@@ -1,5 +1,5 @@
 # 页面标题
-VITE_APP_TITLE = 新能源项目管理平台
+VITE_APP_TITLE = 煤科建管平台
 
 # 生产环境配置
 VITE_APP_ENV = 'production'
@@ -14,12 +14,14 @@ VITE_APP_MONITOR_ADMIN = '/admin/applications'
 VITE_APP_SNAILJOB_ADMIN = '/snail-job'
 
 # 生产环境
-VITE_APP_BASE_API = 'http://58.17.134.85:8899'
+# GO生产环境
+VITE_APP_BASE_API_GO = 'http://58.17.134.85:7464'
+VITE_APP_BASE_API = 'http://xny.yj-3d.com:8899'
 
 # 是否在打包时开启压缩，支持 gzip 和 brotli
 VITE_BUILD_COMPRESS = gzip
 
-VITE_APP_PORT = 80
+VITE_APP_PORT = 8081
 
 # 接口加密功能开关(如需关闭 后端也必须对应关闭)
 VITE_APP_ENCRYPT = true

absolute/path/to/index.vue

@@ -0,0 +1 @@
+

index.html

@@ -6,7 +6,7 @@
     <meta name="renderer" content="webkit" />
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1.0" />
     <link rel="icon" href="/favicon.ico" />
-    <title>新能源项目管理平台</title>
+    <title>煤科建管平台</title>
     <!--[if lt IE 11
       ]><script>
         window.location.href = '/html/ie.html';
@@ -216,8 +216,8 @@
     <script src="/webrtc/jquery-1.12.2.min.js"></script>
     <script src="/webrtc/srs.sdk.js"></script>
 
-    <script src="./src/assets/sdk/YJEarth.min.js"></script>
-    <script src="./src/utils/reconnecting-websocket.js"></script>
+    <script src="/sdk/YJEarth.min.js"></script>
+    <script src="/js/reconnecting-websocket.js"></script>
     <script type="module" src="/src/main.ts"></script>
   </body>
 </html>

package.json

@@ -14,7 +14,7 @@
     "lint:eslint": "eslint",
     "lint:eslint:fix": "eslint --fix",
     "prettier": "prettier --write .",
-    "copy-cesium": "cpy 'src/assets/sdk/Cesium/{Workers,Assets,Widgets}' ./public/Cesium --flat --parents"
+    "copy-cesium": "cpy './public/sdk/Cesium/{Workers,Assets,Widgets}' ./public/Cesium --flat --parents"
   },
   "repository": {
     "type": "git",
@@ -31,11 +31,14 @@
     "await-to-js": "3.0.0",
     "axios": "1.7.8",
     "crypto-js": "4.2.0",
+    "date-fns": "^4.1.0",
     "diagram-js": "12.3.0",
     "didi": "9.0.2",
     "echarts": "5.5.0",
+    "echarts-gl": "^2.0.9",
     "element-plus": "2.8.8",
     "esbuild": "^0.25.0",
+    "exceljs": "^4.4.0",
     "ezuikit-js": "^8.1.10",
     "file-saver": "^2.0.5",
     "fuse.js": "7.0.0",
@@ -64,10 +67,12 @@
     "vue-json-pretty": "2.4.0",
     "vue-print-nb": "^1.7.5",
     "vue-router": "4.4.5",
+    "vue-simple-uploader": "^1.0.3",
     "vue-types": "5.1.3",
     "vue3-print-nb": "^0.1.4",
     "vue3-scroll-seamless": "^1.0.6",
-    "vxe-table": "4.5.22"
+    "vxe-table": "4.5.22",
+    "xlsx": "^0.18.5"
   },
   "devDependencies": {
     "@eslint/js": "9.15.0",

public/sdk/3rdparty/reconnecting-websocket.js

@@ -0,0 +1,382 @@
+// MIT License:
+//
+// Copyright (c) 2010-2012, Joe Walnes
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+/**
+ * This behaves like a WebSocket in every way, except if it fails to connect,
+ * or it gets disconnected, it will repeatedly poll until it successfully connects
+ * again.
+ *
+ * It is API compatible, so when you have:
+ *   ws = new WebSocket('ws://....');
+ * you can replace with:
+ *   ws = new ReconnectingWebSocket('ws://....');
+ *
+ * The event stream will typically look like:
+ *  onconnecting
+ *  onopen
+ *  onmessage
+ *  onmessage
+ *  onclose // lost connection
+ *  onconnecting
+ *  onopen  // sometime later...
+ *  onmessage
+ *  onmessage
+ *  etc...
+ *
+ * It is API compatible with the standard WebSocket API, apart from the following members:
+ *
+ * - `bufferedAmount`
+ * - `extensions`
+ * - `binaryType`
+ *
+ * Latest version: https://github.com/joewalnes/reconnecting-websocket/
+ * - Joe Walnes
+ *
+ * Syntax
+ * ======
+ * var socket = new ReconnectingWebSocket(url, protocols, options);
+ *
+ * Parameters
+ * ==========
+ * url - The url you are connecting to.
+ * protocols - Optional string or array of protocols.
+ * options - See below
+ *
+ * Options
+ * =======
+ * Options can either be passed upon instantiation or set after instantiation:
+ *
+ * var socket = new ReconnectingWebSocket(url, null, { debug: true, reconnectInterval: 4000 });
+ *
+ * or
+ *
+ * var socket = new ReconnectingWebSocket(url);
+ * socket.debug = true;
+ * socket.reconnectInterval = 4000;
+ *
+ * debug
+ * - Whether this instance should log debug messages. Accepts true or false. Default: false.
+ *
+ * automaticOpen
+ * - Whether or not the websocket should attempt to connect immediately upon instantiation. The socket can be manually opened or closed at any time using ws.open() and ws.close().
+ *
+ * reconnectInterval
+ * - The number of milliseconds to delay before attempting to reconnect. Accepts integer. Default: 1000.
+ *
+ * maxReconnectInterval
+ * - The maximum number of milliseconds to delay a reconnection attempt. Accepts integer. Default: 30000.
+ *
+ * reconnectDecay
+ * - The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. Accepts integer or float. Default: 1.5.
+ *
+ * timeoutInterval
+ * - The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. Accepts integer. Default: 2000.
+ *
+ */
+// (function (global, factory) {
+//     if (typeof define === 'function' && define.amd) {
+//         define([], factory);
+//     } else if (typeof module !== 'undefined' && module.exports){
+//         module.exports = factory();
+//     } else {
+//         global.ReconnectingWebSocket = factory();
+//     }
+// })(this, function () {
+//
+//     if (!('WebSocket' in window)) {
+//         return;
+//     }
+
+function ReconnectingWebSocket(url, protocols, options) {
+
+  // Default settings
+  var settings = {
+
+    /** Whether this instance should log debug messages. */
+    debug: false,
+
+    /** Whether or not the websocket should attempt to connect immediately upon instantiation. */
+    automaticOpen: true,
+
+    /** The number of milliseconds to delay before attempting to reconnect. */
+    reconnectInterval: 1000,
+    /** The maximum number of milliseconds to delay a reconnection attempt. */
+    maxReconnectInterval: 30000,
+    /** The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. */
+    reconnectDecay: 1.5,
+
+    /** The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. */
+    timeoutInterval: 2000,
+
+    /** The maximum number of reconnection attempts to make. Unlimited if null. */
+    maxReconnectAttempts: null,
+
+    /** The binary type, possible values 'blob' or 'arraybuffer', default 'blob'. */
+    binaryType: 'blob'
+  }
+  if (!options) {
+    options = {};
+  }
+
+  // Overwrite and define settings with options if they exist.
+  for (var key in settings) {
+    if (typeof options[key] !== 'undefined') {
+      this[key] = options[key];
+    } else {
+      this[key] = settings[key];
+    }
+  }
+
+  // These should be treated as read-only properties
+
+  /** The URL as resolved by the constructor. This is always an absolute URL. Read only. */
+  this.url = url;
+
+  /** The number of attempted reconnects since starting, or the last successful connection. Read only. */
+  this.reconnectAttempts = 0;
+
+  /**
+   * The current state of the connection.
+   * Can be one of: WebSocket.CONNECTING, WebSocket.OPEN, WebSocket.CLOSING, WebSocket.CLOSED
+   * Read only.
+   */
+  this.readyState = WebSocket.CONNECTING;
+
+  /**
+   * A string indicating the name of the sub-protocol the server selected; this will be one of
+   * the strings specified in the protocols parameter when creating the WebSocket object.
+   * Read only.
+   */
+  this.protocol = null;
+
+  // Private state variables
+
+  var self = this;
+  var ws;
+  var forcedClose = false;
+  var timedOut = false;
+  var eventTarget = document.createElement('div');
+
+  // Wire up "on*" properties as event handlers
+
+  eventTarget.addEventListener('open', function (event) {
+    self.onopen(event);
+  });
+  eventTarget.addEventListener('close', function (event) {
+    self.onclose(event);
+  });
+  eventTarget.addEventListener('connecting', function (event) {
+    self.onconnecting(event);
+  });
+  eventTarget.addEventListener('message', function (event) {
+    self.onmessage(event);
+  });
+  eventTarget.addEventListener('error', function (event) {
+    self.onerror(event);
+  });
+
+  // Expose the API required by EventTarget
+
+  this.addEventListener = eventTarget.addEventListener.bind(eventTarget);
+  this.removeEventListener = eventTarget.removeEventListener.bind(eventTarget);
+  this.dispatchEvent = eventTarget.dispatchEvent.bind(eventTarget);
+
+  /**
+   * This function generates an event that is compatible with standard
+   * compliant browsers and IE9 - IE11
+   *
+   * This will prevent the error:
+   * Object doesn't support this action
+   *
+   * http://stackoverflow.com/questions/19345392/why-arent-my-parameters-getting-passed-through-to-a-dispatched-event/19345563#19345563
+   * @param s String The name that the event should use
+   * @param args Object an optional object that the event will use
+   */
+  function generateEvent(s, args) {
+    var evt = document.createEvent("CustomEvent");
+    evt.initCustomEvent(s, false, false, args);
+    return evt;
+  };
+
+  this.open = function (reconnectAttempt) {
+    ws = new WebSocket(self.url, protocols || []);
+    ws.binaryType = this.binaryType;
+
+    if (reconnectAttempt) {
+      if (this.maxReconnectAttempts && this.reconnectAttempts > this.maxReconnectAttempts) {
+        return;
+      }
+    } else {
+      eventTarget.dispatchEvent(generateEvent('connecting'));
+      this.reconnectAttempts = 0;
+    }
+
+    if (self.debug || ReconnectingWebSocket.debugAll) {
+      console.debug('ReconnectingWebSocket', 'attempt-connect', self.url);
+    }
+
+    var localWs = ws;
+    var timeout = setTimeout(function () {
+      if (self.debug || ReconnectingWebSocket.debugAll) {
+        console.debug('ReconnectingWebSocket', 'connection-timeout', self.url);
+      }
+      timedOut = true;
+      localWs.close();
+      timedOut = false;
+    }, self.timeoutInterval);
+
+    ws.onopen = function (event) {
+      clearTimeout(timeout);
+      if (self.debug || ReconnectingWebSocket.debugAll) {
+        console.debug('ReconnectingWebSocket', 'onopen', self.url);
+      }
+      self.protocol = ws.protocol;
+      self.readyState = WebSocket.OPEN;
+      self.reconnectAttempts = 0;
+      var e = generateEvent('open');
+      e.isReconnect = reconnectAttempt;
+      reconnectAttempt = false;
+      eventTarget.dispatchEvent(e);
+    };
+
+    ws.onclose = function (event) {
+      clearTimeout(timeout);
+      ws = null;
+      if (forcedClose) {
+        self.readyState = WebSocket.CLOSED;
+        eventTarget.dispatchEvent(generateEvent('close'));
+      } else {
+        self.readyState = WebSocket.CONNECTING;
+        var e = generateEvent('connecting');
+        e.code = event.code;
+        e.reason = event.reason;
+        e.wasClean = event.wasClean;
+        eventTarget.dispatchEvent(e);
+        if (!reconnectAttempt && !timedOut) {
+          if (self.debug || ReconnectingWebSocket.debugAll) {
+            console.debug('ReconnectingWebSocket', 'onclose', self.url);
+          }
+          eventTarget.dispatchEvent(generateEvent('close'));
+        }
+
+        var timeout = self.reconnectInterval * Math.pow(self.reconnectDecay, self.reconnectAttempts);
+        setTimeout(function () {
+          self.reconnectAttempts++;
+          self.open(true);
+        }, timeout > self.maxReconnectInterval ? self.maxReconnectInterval : timeout);
+      }
+    };
+    ws.onmessage = function (event) {
+      if (self.debug || ReconnectingWebSocket.debugAll) {
+        console.debug('ReconnectingWebSocket', 'onmessage', self.url, event.data);
+      }
+      var e = generateEvent('message');
+      e.data = event.data;
+      eventTarget.dispatchEvent(e);
+    };
+    ws.onerror = function (event) {
+      if (self.debug || ReconnectingWebSocket.debugAll) {
+        console.debug('ReconnectingWebSocket', 'onerror', self.url, event);
+      }
+      eventTarget.dispatchEvent(generateEvent('error'));
+    };
+  }
+
+  // Whether or not to create a websocket upon instantiation
+  if (this.automaticOpen == true) {
+    this.open(false);
+  }
+
+  /**
+   * Transmits data to the server over the WebSocket connection.
+   *
+   * @param data a text string, ArrayBuffer or Blob to send to the server.
+   */
+  this.send = function (data) {
+    if (ws) {
+      if (self.debug || ReconnectingWebSocket.debugAll) {
+        console.debug('ReconnectingWebSocket', 'send', self.url, data);
+      }
+      return ws.send(data);
+    } else {
+      throw 'INVALID_STATE_ERR : Pausing to reconnect websocket';
+    }
+  };
+
+  /**
+   * Closes the WebSocket connection or connection attempt, if any.
+   * If the connection is already CLOSED, this method does nothing.
+   */
+  this.close = function (code, reason) {
+    // Default CLOSE_NORMAL code
+    if (typeof code == 'undefined') {
+      code = 1000;
+    }
+    forcedClose = true;
+    if (ws) {
+      ws.close(code, reason);
+    }
+  };
+
+  /**
+   * Additional public API method to refresh the connection if still open (close, re-open).
+   * For example, if the app suspects bad data / missed heart beats, it can try to refresh.
+   */
+  this.refresh = function () {
+    if (ws) {
+      ws.close();
+    }
+  };
+}
+
+/**
+ * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+ * this indicates that the connection is ready to send and receive data.
+ */
+ReconnectingWebSocket.prototype.onopen = function (event) {
+};
+/** An event listener to be called when the WebSocket connection's readyState changes to CLOSED. */
+ReconnectingWebSocket.prototype.onclose = function (event) {
+};
+/** An event listener to be called when a connection begins being attempted. */
+ReconnectingWebSocket.prototype.onconnecting = function (event) {
+};
+/** An event listener to be called when a message is received from the server. */
+ReconnectingWebSocket.prototype.onmessage = function (event) {
+};
+/** An event listener to be called when an error occurs. */
+ReconnectingWebSocket.prototype.onerror = function (event) {
+};
+
+/**
+ * Whether all instances of ReconnectingWebSocket should log debug messages.
+ * Setting this to true is the equivalent of setting all instances of ReconnectingWebSocket.debug to true.
+ */
+ReconnectingWebSocket.debugAll = false;
+
+ReconnectingWebSocket.CONNECTING = WebSocket.CONNECTING;
+ReconnectingWebSocket.OPEN = WebSocket.OPEN;
+ReconnectingWebSocket.CLOSING = WebSocket.CLOSING;
+ReconnectingWebSocket.CLOSED = WebSocket.CLOSED;
+
+// return ReconnectingWebSocket;
+// });