vue2-client 1.10.35 → 1.11.1

package/src/utils/indexedDB.js

@@ -1,256 +1,205 @@
-// indexDB 存储
 import { post } from '@vue2-client/services/api'
 
-// 避免重复请求相同配置key的锁
-const locks = {}
-let currentDbVersion = 1
+const DB_CONFIG = {
+  NAME: window.__MICRO_APP_NAME__ ? `view_${window.__MICRO_APP_NAME__}` : 'view',
+  STORE_NAME: 'metaCache',
+  VERSION: 1,
+  CURRENT_VERSION: 1
+}
 
-export const indexedDB = {
-  db: undefined,
-  indexedDB: window?.rawWindow?.indexedDB || window.indexedDB || window.webkitindexedDB,
-  IDBKeyRange: window?.rawWindow?.IDBKeyRange || window.IDBKeyRange || window.webkitIDBKeyRange, // 键范围
-  openDB: function (callback) {
-    const self = this
-    if (self.db) {
-      try {
-        const transaction = self.db.transaction(['metaCache'], 'readwrite')
-        const objectStore = transaction.objectStore('metaCache')
-        const request = objectStore.add({ key: 'alive', data: true })
+class IndexedDBManager {
+  constructor () {
+    this.db = undefined
+    this.locks = {}
+    this.isInMicroApp = !!window.__MICRO_APP_NAME__
+    this.microAppName = window.__MICRO_APP_NAME__ || ''
+    this.indexedDB = window?.rawWindow?.indexedDB || window.indexedDB || window.webkitindexedDB
+    this.IDBKeyRange = window?.rawWindow?.IDBKeyRange || window.IDBKeyRange || window.webkitIDBKeyRange
+  }
 
-        request.onerror = function (e) {
-          self.openDatabase().then(db => {
-            self.db = db
-            callback(db)
-          }).catch(e => {
-            console.error(e)
-          })
-        }
+  async openDatabase () {
+    try {
+      return await new Promise((resolve, reject) => {
+        const checkRequest = this.indexedDB.open(DB_CONFIG.NAME)
 
-        request.onsuccess = function () {
-          callback(self.db)
-        }
-      } catch (e) {
-        self.deleteDB('view')
-        // 重新创建数据库
-        self.openDatabase().then(db => {
-          self.db = db
-          callback(self.db)
-        }).catch(e => {
-          console.error('重新创建数据库:' + e.message)
-        })
-      }
-    } else {
-      self.openDatabase().then(db => {
-        self.db = db
-        callback(self.db)
-      }).catch(e => {
-        console.error('打开数据库失败:' + e.message)
-        if (e.message === 'The requested version (1) is less than the existing version (2).') {
-          self.deleteDB('view')
-          self.openDatabase().then(db => {
-            self.db = db
-            callback(self.db)
-          }).catch(e => {
-            console.error('重新创建数据库:' + e.message)
-          })
+        checkRequest.onsuccess = (e) => {
+          const db = e.target.result
+          const currentVersion = db.version
+          db.close()
+
+          DB_CONFIG.CURRENT_VERSION = Math.max(currentVersion, DB_CONFIG.VERSION)
+          const request = this.indexedDB.open(DB_CONFIG.NAME, DB_CONFIG.CURRENT_VERSION)
+
+          request.onerror = (e) => reject(e.currentTarget.error)
+
+          request.onsuccess = (e) => {
+            const db = e.target.result
+            if (!db.objectStoreNames.contains(DB_CONFIG.STORE_NAME)) {
+              db.close()
+              DB_CONFIG.CURRENT_VERSION++
+              this.upgradeDatabase(resolve, reject)
+            } else {
+              resolve(db)
+            }
+          }
+
+          request.onupgradeneeded = (e) => {
+            const db = e.target.result
+            if (!db.objectStoreNames.contains(DB_CONFIG.STORE_NAME)) {
+              db.createObjectStore(DB_CONFIG.STORE_NAME, { keyPath: 'key' })
+            }
+          }
         }
+
+        checkRequest.onerror = (e) => reject(e.currentTarget.error)
       })
+    } catch (error) {
+      console.error('打开数据库失败:', error)
+      throw error
     }
-  },
-  openDatabase () {
-    const self = this
+  }
 
-    return new Promise((resolve, reject) => {
-      const request = self.indexedDB.open('view', currentDbVersion)
+  async upgradeDatabase (resolve, reject) {
+    const request = this.indexedDB.open(DB_CONFIG.NAME, DB_CONFIG.CURRENT_VERSION)
 
-      request.onerror = function (e) {
-        reject(e.currentTarget.error)
+    request.onupgradeneeded = (e) => {
+      const db = e.target.result
+      if (!db.objectStoreNames.contains(DB_CONFIG.STORE_NAME)) {
+        db.createObjectStore(DB_CONFIG.STORE_NAME, { keyPath: 'key' })
       }
+    }
 
-      request.onsuccess = function (e) {
-        const db = e.target.result
-        if (!db.objectStoreNames.contains('metaCache')) {
-          db.close()
-          currentDbVersion = db.version + 1
-          const upgradeRequest = self.indexedDB.open('view', currentDbVersion)
-          upgradeRequest.onupgradeneeded = function (event) {
-            const upgradeDb = event.target.result
-            upgradeDb.createObjectStore('metaCache', { keyPath: 'key' })
-          }
-          upgradeRequest.onsuccess = function (event) {
-            resolve(event.target.result)
-          }
-          upgradeRequest.onerror = function (event) {
-            reject(event.currentTarget.error)
-          }
-        } else {
-          resolve(db)
+    request.onsuccess = (e) => resolve(e.target.result)
+    request.onerror = (e) => reject(e.currentTarget.error)
+  }
+
+  async openDB (callback) {
+    try {
+      if (this.db) {
+        const isAlive = await this.checkConnection()
+        if (isAlive) {
+          callback(this.db)
+          return
         }
       }
 
-      request.onupgradeneeded = function (e) {
-        const db = e.target.result
-        if (!db.objectStoreNames.contains('metaCache')) {
-          db.createObjectStore('metaCache', { keyPath: 'key' })
-        }
+      this.db = await this.openDatabase()
+      callback(this.db)
+    } catch (error) {
+      console.error('数据库操作失败:', error)
+      if (error.message?.includes('version')) {
+        await this.recreateDatabase()
+        callback(this.db)
       }
-    })
-  },
-  deleteDB: function (dbname) {
-    // 删除数据库
-    const self = this
-    self.indexedDB.deleteDatabase(dbname)
-  },
-  closeDB: function () {
-    const self = this
-    if (self.db) {
-      self.db.close()
     }
-  },
-  add: function (key, data) {
-    const self = this
-    self.openDB((res) => {
-      const request = res.transaction('metaCache', 'readwrite').objectStore('metaCache').add({
-        key: key,
-        data: data
-      })
-      request.onerror = function () {
-        self.update(key, data)
-      }
-      request.onsuccess = function () {
-      }
-    })
-  },
-  update: function (key, data) {
-    const self = this
-    self.openDB((res) => {
-      const request = res.transaction('metaCache', 'readwrite').objectStore('metaCache').put({
-        key: key,
-        data: data
-      })
-      request.onerror = function () {
-        console.error('数据更新失败')
-      }
-      request.onsuccess = function () {
-      }
+  }
+
+  async checkConnection () {
+    try {
+      const transaction = this.db.transaction([DB_CONFIG.STORE_NAME], 'readwrite')
+      const store = transaction.objectStore(DB_CONFIG.STORE_NAME)
+      await this.promisifyRequest(store.add({ key: 'alive', data: true }))
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  promisifyRequest (request) {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result)
+      request.onerror = () => reject(request.error)
     })
-  },
-  get: function (key, callback) {
-    const self = this
-    self.openDB((res) => {
-      // 根据存储空间的键找到对应数据
-      const store = res.transaction('metaCache', 'readwrite').objectStore('metaCache')
-      const request = store.get(key)
-      request.onerror = function () {
-      }
-      request.onsuccess = function (e) {
-        const result = e.target.result
-        if (typeof (callback) === 'function') {
-          callback(result.data)
+  }
+
+  async getByWeb (key, url, params, callback, processFun) {
+    if (this.locks[key]) {
+      await this.locks[key]
+      return this.getByWeb(key, url, params, callback, processFun)
+    }
+
+    this.locks[key] = (async () => {
+      try {
+        const data = await this.getData(key)
+        if (!data && url) {
+          const res = await post(url, params)
+          const processedData = processFun ? processFun(res) : res
+
+          if (process.env.NODE_ENV === 'production' || key !== 'webMobileConfig') {
+            await this.add(key, processedData)
+          }
+
+          callback(processedData)
+        } else {
+          callback(data)
         }
-      }
-    })
-  },
-  getAll: function (callback) {
-    const self = this
-    self.openDB((res) => {
-      const store = res.transaction('metaCache', 'readwrite').objectStore('metaCache')
-      const request = store.getAll()
-      request.onerror = function () {
-      }
-      request.onsuccess = function (e) {
-        const result = e.target.result
-        if (typeof (callback) === 'function') {
-          callback(result)
+      } catch (error) {
+        console.error('获取数据失败:', error)
+        if (process.env.NODE_ENV === 'production' && key !== 'webMobileConfig') {
+          await this.add(key, null)
         }
+        callback(null)
       }
-    })
-  },
-  getByWeb: function (key, url, params, callback, processFun) {
-    // 如果这个键正在被使用，等待它完成
-    if (locks[key]) {
-      locks[key].then(() => {
-        this.getByWeb(key, url, params, callback, processFun)
-      })
-      return
+    })()
+
+    try {
+      await this.locks[key]
+    } finally {
+      delete this.locks[key]
     }
+  }
 
-    // 创建一个新的 Promise
-    locks[key] = new Promise((resolve, reject) => {
-      const self = this
+  async getData (key) {
+    return new Promise((resolve) => {
+      this.openDB((db) => {
+        const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
+        const request = store.get(key)
+        request.onsuccess = (e) => resolve(e.target.result?.data)
+        request.onerror = () => resolve(null)
+      })
+    })
+  }
 
-      const handlePostRequest = () => {
-        post(url, params).then((res) => {
-          if (processFun) { res = processFun(res) }
-          if (process.env.NODE_ENV === 'production' || key !== 'webMobileConfig') { self.add(key, res) }
-          try {
-            callback(res)
-          } catch (e) {
-            console.error(e)
-          }
-          resolve()
-        }).catch((e) => {
-          if (process.env.NODE_ENV === 'production' && key !== 'webMobileConfig') { self.add(key, null) }
-          callback(null)
-          resolve()
-        })
-      }
+  async add (key, data) {
+    this.openDB((db) => {
+      const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
+      const request = store.add({ key, data })
+      request.onerror = () => this.update(key, data)
+    })
+  }
 
-      try {
-        self.openDB((res) => {
-          const store = res.transaction('metaCache', 'readwrite').objectStore('metaCache')
-          const request = store.get(key)
-          request.onerror = function (e) {
-            reject(e)
-          }
-          request.onsuccess = function (e) {
-            const result = e.target.result
-            if (!result && url) {
-              handlePostRequest()
-            } else {
-              callback(result.data)
-              resolve()
-            }
-          }
-        })
-      } catch (e) {
-        console.error('indexDb数据库操作错误', e)
-        handlePostRequest()
-      }
-    }).finally(() => {
-      delete locks[key]
+  async update (key, data) {
+    this.openDB((db) => {
+      const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
+      const request = store.put({ key, data })
+      request.onerror = () => console.error('数据更新失败')
     })
-  },
-  delete: function (key) {
-    const self = this
-    self.openDB((res) => {
-      // 删除某一条记录
-      const request = res.transaction('metaCache', 'readwrite').objectStore('metaCache').delete(key)
+  }
 
-      request.onerror = function () {
-        console.error('数据删除失败')
-      }
-      request.onsuccess = function (event) {
-      }
+  async delete (key) {
+    this.openDB((db) => {
+      const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
+      const request = store.delete(key)
+      request.onerror = () => console.error('数据删除失败')
     })
-  },
-  clear: function (callback) {
-    const self = this
-    self.openDB((res) => {
-      // 删除存储空间全部记录
-      const request = res.transaction('metaCache', 'readwrite').objectStore('metaCache').clear()
+  }
 
-      request.onerror = function () {
+  async clear (callback) {
+    this.openDB((db) => {
+      const store = db.transaction(DB_CONFIG.STORE_NAME, 'readwrite').objectStore(DB_CONFIG.STORE_NAME)
+      const request = store.clear()
+      request.onerror = () => {
         console.error('数据删除失败')
         callback()
       }
-      request.onsuccess = function (event) {
+      request.onsuccess = () => {
         if (typeof callback === 'function') {
           callback()
         }
       }
     })
-  },
+  }
+
   clearCache () {
     if (this.indexedDB) {
       this.clear(() => {
@@ -261,3 +210,5 @@ export const indexedDB = {
     }
   }
 }
+
+export const indexedDB = new IndexedDBManager()

package/vue.config.js

@@ -48,8 +48,8 @@ module.exports = {
       //   changeOrigin: true
       // },
       '/api/af-revenue/logic/openapi/': {
-        pathRewrite: { '^/api/af-revenue/logic/openapi/': '/logic/' },
-        target: 'http://127.0.0.1:9026',
+        // pathRewrite: { '^/api/af-revenue/logic/openapi/': '/logic/' },
+        target: revenue,
         changeOrigin: true
       },
       '/api/af-scada': {
@@ -57,8 +57,8 @@ module.exports = {
         changeOrigin: true
       },
       '/api/af-revenue': {
-        pathRewrite: { '^/api/af-revenue/': '/' },
-        target: 'http://127.0.0.1:9026',
+        // pathRewrite: { '^/api/af-revenue/': '/' },
+        target: revenue,
         changeOrigin: true
       },
       '/api/af-liuli': {
@@ -183,7 +183,8 @@ module.exports = {
               discardComments: { removeAll: true },
               colormin: false,
             }
-          ]
+          ],
+          ignoreOrder: true
         }
       }])
     }