@ganwei-web/ganwei-pc-cli 6.2.9 → 6.3.2

package/ganwei-iotcenter-index-6.2.3/packages/ganwei-iotcenter-template/src/utils/signalr.ts

@@ -0,0 +1,564 @@
+/**
+ * SignalR 实时通信工具类
+ * @version 1.0.0
+ * @description 基于 @aspnet/signalr ^1.1.4 的封装，提供连接管理、断线重连、消息订阅等功能
+ */
+
+import * as signalR from '@aspnet/signalr'
+
+/**
+ * SignalR 连接配置
+ */
+export interface SignalRConfig {
+  /** Hub 路径 */
+  path: string
+  /** 连接标识（可选） */
+  connectionId?: string
+  /** 设备编号（可选） */
+  equipNo?: number | string
+  /** 服务器超时时间（毫秒），默认 500000000 */
+  serverTimeout?: number
+  /** 心跳间隔时间（毫秒），默认 500000000 */
+  keepAliveInterval?: number
+  /** 是否自动重连，默认 true */
+  autoReconnect?: boolean
+  /** 重连延迟（毫秒），默认 3000 */
+  reconnectDelay?: number
+  /** 最大重连次数，默认 5 */
+  maxReconnectAttempts?: number
+}
+
+/**
+ * 消息处理器
+ */
+export interface MessageHandler {
+  /** 事件名称 */
+  eventName: string
+  /** 回调函数 */
+  callback: (data: any) => void
+}
+
+/**
+ * SignalR 连接状态
+ */
+export enum ConnectionState {
+  /** 已连接 */
+  Connected = 'Connected',
+  /** 连接中 */
+  Connecting = 'Connecting',
+  /** 已断开 */
+  Disconnected = 'Disconnected',
+  /** 重连中 */
+  Reconnecting = 'Reconnecting'
+}
+
+/**
+ * SignalR 管理器类
+ */
+export class SignalRManager {
+  private connection: signalR.HubConnection | null = null
+  private config: Required<SignalRConfig>
+  private reconnectAttempts = 0
+  private isReconnecting = false
+  private messageHandlers: Map<string, Set<Function>> = new Map()
+  private state: ConnectionState = ConnectionState.Disconnected
+  private stateChangeCallbacks: ((state: ConnectionState) => void)[] = []
+
+  constructor(config: SignalRConfig) {
+    this.config = {
+      path: config.path,
+      connectionId: config.connectionId || '',
+      equipNo: config.equipNo || '',
+      serverTimeout: config.serverTimeout || 500000000,
+      keepAliveInterval: config.keepAliveInterval || 500000000,
+      autoReconnect: config.autoReconnect !== false,
+      reconnectDelay: config.reconnectDelay || 3000,
+      maxReconnectAttempts: config.maxReconnectAttempts || 5
+    }
+  }
+
+  /**
+   * 获取连接状态
+   */
+  getState(): ConnectionState {
+    return this.state
+  }
+
+  /**
+   * 监听连接状态变化
+   */
+  onStateChange(callback: (state: ConnectionState) => void) {
+    this.stateChangeCallbacks.push(callback)
+    return () => {
+      const index = this.stateChangeCallbacks.indexOf(callback)
+      if (index > -1) {
+        this.stateChangeCallbacks.splice(index, 1)
+      }
+    }
+  }
+
+  /**
+   * 设置连接状态
+   */
+  private setState(state: ConnectionState) {
+    this.state = state
+    this.stateChangeCallbacks.forEach(cb => cb(state))
+  }
+
+  /**
+   * 建立连接
+   */
+  async connect(): Promise<signalR.HubConnection> {
+    // 如果已连接，先断开
+    if (this.connection) {
+      await this.disconnect()
+    }
+
+    this.setState(ConnectionState.Connecting)
+
+    try {
+      // 创建连接
+      this.connection = new signalR.HubConnectionBuilder()
+        .withUrl(this.config.path)
+        .build()
+
+      // 设置超时时间
+      this.connection.serverTimeoutInMilliseconds = this.config.serverTimeout
+      this.connection.keepAliveIntervalInMilliseconds = this.config.keepAliveInterval
+
+      // 监听断线事件
+      this.connection.onclose((error) => {
+        console.log('SignalR 连接断开:', error)
+        this.setState(ConnectionState.Disconnected)
+        
+        // 自动重连
+        if (this.config.autoReconnect) {
+          this.handleReconnect()
+        }
+      })
+
+      // 启动连接
+      await this.connection.start()
+
+      // 发送连接标识
+      if (this.config.connectionId) {
+        await this.sendConnectionId()
+      }
+
+      // 重新订阅消息
+      this.resubscribeMessages()
+
+      this.setState(ConnectionState.Connected)
+      this.reconnectAttempts = 0
+
+      console.log('SignalR 连接成功:', this.config.path)
+      return this.connection
+    } catch (error) {
+      console.error('SignalR 连接失败:', error)
+      this.setState(ConnectionState.Disconnected)
+      throw error
+    }
+  }
+
+  /**
+   * 发送连接标识
+   */
+  private async sendConnectionId() {
+    if (!this.connection || !this.config.connectionId) return
+
+    try {
+      await this.connection.invoke(this.config.connectionId, this.config.equipNo)
+    } catch (error) {
+      console.error('发送连接标识失败:', error)
+    }
+  }
+
+  /**
+   * 处理重连
+   */
+  private async handleReconnect() {
+    if (this.isReconnecting) return
+    this.isReconnecting = true
+    this.setState(ConnectionState.Reconnecting)
+
+    while (this.reconnectAttempts < this.config.maxReconnectAttempts) {
+      this.reconnectAttempts++
+      console.log(
+        `SignalR 尝试重连 (${this.reconnectAttempts}/${this.config.maxReconnectAttempts})...`
+      )
+
+      try {
+        await this.connect()
+        console.log('SignalR 重连成功')
+        this.isReconnecting = false
+        return
+      } catch (error) {
+        console.error(`SignalR 重连失败:`, error)
+        
+        if (this.reconnectAttempts < this.config.maxReconnectAttempts) {
+          await this.sleep(this.config.reconnectDelay)
+        }
+      }
+    }
+
+    console.error('SignalR 重连失败次数过多，停止重连')
+    this.isReconnecting = false
+    this.setState(ConnectionState.Disconnected)
+  }
+
+  /**
+   * 重新订阅消息
+   */
+  private resubscribeMessages() {
+    if (!this.connection) return
+
+    this.messageHandlers.forEach((callbacks, eventName) => {
+      callbacks.forEach(callback => {
+        this.connection!.on(eventName, callback as any)
+      })
+    })
+  }
+
+  /**
+   * 监听消息
+   */
+  on(eventName: string, callback: (data: any) => void): () => void {
+    // 添加到处理器列表
+    if (!this.messageHandlers.has(eventName)) {
+      this.messageHandlers.set(eventName, new Set())
+    }
+    this.messageHandlers.get(eventName)!.add(callback)
+
+    // 如果已连接，立即订阅
+    if (this.connection) {
+      this.connection.on(eventName, callback)
+    }
+
+    // 返回取消订阅函数
+    return () => {
+      this.off(eventName, callback)
+    }
+  }
+
+  /**
+   * 取消监听
+   */
+  off(eventName: string, callback?: Function) {
+    if (callback) {
+      // 取消特定回调
+      const callbacks = this.messageHandlers.get(eventName)
+      if (callbacks) {
+        callbacks.delete(callback)
+        if (callbacks.size === 0) {
+          this.messageHandlers.delete(eventName)
+        }
+      }
+      
+      if (this.connection) {
+        this.connection.off(eventName, callback as any)
+      }
+    } else {
+      // 取消所有回调
+      this.messageHandlers.delete(eventName)
+      
+      if (this.connection) {
+        this.connection.off(eventName)
+      }
+    }
+  }
+
+  /**
+   * 调用服务器方法
+   */
+  async invoke<T = any>(methodName: string, ...args: any[]): Promise<T> {
+    if (!this.connection) {
+      throw new Error('SignalR 未连接')
+    }
+
+    if (this.state !== ConnectionState.Connected) {
+      throw new Error(`SignalR 连接状态异常: ${this.state}`)
+    }
+
+    try {
+      return await this.connection.invoke<T>(methodName, ...args)
+    } catch (error) {
+      console.error(`调用服务器方法失败 [${methodName}]:`, error)
+      throw error
+    }
+  }
+
+  /**
+   * 发送消息（不等待响应）
+   */
+  async send(methodName: string, ...args: any[]): Promise<void> {
+    if (!this.connection) {
+      throw new Error('SignalR 未连接')
+    }
+
+    if (this.state !== ConnectionState.Connected) {
+      throw new Error(`SignalR 连接状态异常: ${this.state}`)
+    }
+
+    try {
+      await this.connection.send(methodName, ...args)
+    } catch (error) {
+      console.error(`发送消息失败 [${methodName}]:`, error)
+      throw error
+    }
+  }
+
+  /**
+   * 断开连接
+   */
+  async disconnect() {
+    if (this.connection) {
+      try {
+        await this.connection.stop()
+      } catch (error) {
+        console.error('SignalR 断开连接失败:', error)
+      }
+      this.connection = null
+    }
+    
+    this.setState(ConnectionState.Disconnected)
+  }
+
+  /**
+   * 获取原始连接实例
+   */
+  getConnection(): signalR.HubConnection | null {
+    return this.connection
+  }
+
+  /**
+   * 清空所有消息订阅
+   */
+  clearAllHandlers() {
+    this.messageHandlers.forEach((callbacks, eventName) => {
+      if (this.connection) {
+        this.connection.off(eventName)
+      }
+    })
+    this.messageHandlers.clear()
+  }
+
+  /**
+   * 销毁实例
+   */
+  async destroy() {
+    this.stateChangeCallbacks = []
+    this.clearAllHandlers()
+    await this.disconnect()
+  }
+
+  /**
+   * 休眠
+   */
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms))
+  }
+}
+
+/**
+ * 创建 SignalR 管理器实例
+ */
+export function createSignalR(config: SignalRConfig): SignalRManager {
+  return new SignalRManager(config)
+}
+
+/**
+ * SignalR 连接池管理器
+ */
+export class SignalRPool {
+  private connections: Map<string, SignalRManager> = new Map()
+
+  /**
+   * 创建或获取连接
+   */
+  getOrCreate(config: SignalRConfig): SignalRManager {
+    const key = config.path
+    
+    if (!this.connections.has(key)) {
+      this.connections.set(key, new SignalRManager(config))
+    }
+    
+    return this.connections.get(key)!
+  }
+
+  /**
+   * 获取连接
+   */
+  get(path: string): SignalRManager | undefined {
+    return this.connections.get(path)
+  }
+
+  /**
+   * 断开指定连接
+   */
+  async disconnect(path: string) {
+    const connection = this.connections.get(path)
+    if (connection) {
+      await connection.destroy()
+      this.connections.delete(path)
+    }
+  }
+
+  /**
+   * 断开所有连接
+   */
+  async disconnectAll() {
+    const promises: Promise<void>[] = []
+    
+    this.connections.forEach(connection => {
+      promises.push(connection.destroy())
+    })
+    
+    await Promise.all(promises)
+    this.connections.clear()
+  }
+
+  /**
+   * 获取所有连接状态
+   */
+  getAllStates(): Record<string, ConnectionState> {
+    const states: Record<string, ConnectionState> = {}
+    
+    this.connections.forEach((connection, path) => {
+      states[path] = connection.getState()
+    })
+    
+    return states
+  }
+}
+
+/**
+ * 全局连接池
+ */
+export const signalRPool = new SignalRPool()
+
+/**
+ * Vue 3 Composition API Hook
+ */
+export function useSignalR(config: SignalRConfig) {
+  const manager = ref<SignalRManager | null>(null)
+  const state = ref<ConnectionState>(ConnectionState.Disconnected)
+  const isConnected = computed(() => state.value === ConnectionState.Connected)
+
+  let unsubscribe: (() => void) | null = null
+
+  const connect = async () => {
+    if (!manager.value) {
+      manager.value = createSignalR(config)
+      
+      // 监听状态变化
+      unsubscribe = manager.value.onStateChange((newState) => {
+        state.value = newState
+      })
+    }
+    
+    await manager.value.connect()
+  }
+
+  const disconnect = async () => {
+    if (manager.value) {
+      await manager.value.disconnect()
+    }
+  }
+
+  const on = (eventName: string, callback: (data: any) => void) => {
+    if (!manager.value) {
+      console.warn('SignalR 未初始化，请先调用 connect()')
+      return () => {}
+    }
+    
+    return manager.value.on(eventName, callback)
+  }
+
+  const off = (eventName: string, callback?: Function) => {
+    if (!manager.value) return
+    manager.value.off(eventName, callback)
+  }
+
+  const invoke = async <T = any>(methodName: string, ...args: any[]): Promise<T> => {
+    if (!manager.value) {
+      throw new Error('SignalR 未初始化')
+    }
+    return manager.value.invoke<T>(methodName, ...args)
+  }
+
+  const send = async (methodName: string, ...args: any[]): Promise<void> => {
+    if (!manager.value) {
+      throw new Error('SignalR 未初始化')
+    }
+    return manager.value.send(methodName, ...args)
+  }
+
+  // 自动连接
+  onMounted(() => {
+    connect()
+  })
+
+  // 自动断开
+  onBeforeUnmount(() => {
+    if (unsubscribe) {
+      unsubscribe()
+    }
+    
+    if (manager.value) {
+      manager.value.destroy()
+      manager.value = null
+    }
+  })
+
+  return {
+    manager,
+    state,
+    isConnected,
+    connect,
+    disconnect,
+    on,
+    off,
+    invoke,
+    send
+  }
+}
+
+// 导入 Vue 相关依赖
+import { ref, computed, onMounted, onBeforeUnmount } from 'vue'
+
+/**
+ * 创建消息处理器工厂
+ */
+export function createMessageHandler(
+  eventName: string,
+  callback: (data: any) => void
+) {
+  return {
+    eventName,
+    callback,
+    subscribe(connection: SignalRManager) {
+      connection.on(eventName, callback)
+    },
+    unsubscribe(connection: SignalRManager) {
+      connection.off(eventName, callback)
+    }
+  }
+}
+
+/**
+ * 批量订阅消息
+ */
+export function batchSubscribe(
+  connection: SignalRManager,
+  handlers: MessageHandler[]
+): () => void {
+  handlers.forEach(handler => {
+    connection.on(handler.eventName, handler.callback)
+  })
+
+  return () => {
+    handlers.forEach(handler => {
+      connection.off(handler.eventName, handler.callback)
+    })
+  }
+}

package/ganwei-iotcenter-index-6.2.3/packages/ganwei-iotcenter-template/src/utils/storage.ts

@@ -0,0 +1,80 @@
+/**
+ * 本地存储工具类
+ */
+class StorageUtil {
+    private storage: Storage
+
+    constructor(storage: Storage) {
+        this.storage = storage
+    }
+
+    /**
+     * 设置存储项
+     * @param key - 键名
+     * @param value - 值
+     * @param expires - 过期时间（毫秒）
+     */
+    set<T>(key: string, value: T, expires?: number): void {
+        const data = {
+            value,
+            expires: expires ? Date.now() + expires : undefined
+        }
+        this.storage.setItem(key, JSON.stringify(data))
+    }
+
+    /**
+     * 获取存储项
+     */
+    get<T>(key: string): T | null {
+        const item = this.storage.getItem(key)
+        if (!item) return null
+
+        try {
+            const data = JSON.parse(item)
+
+            // 检查是否过期
+            if (data.expires && Date.now() > data.expires) {
+                this.remove(key)
+                return null
+            }
+
+            return data.value as T
+        } catch {
+            return null
+        }
+    }
+
+    /**
+     * 移除存储项
+     */
+    remove(key: string): void {
+        this.storage.removeItem(key)
+    }
+
+    /**
+     * 清空存储
+     */
+    clear(): void {
+        this.storage.clear()
+    }
+
+    /**
+     * 获取所有键
+     */
+    keys(): string[] {
+        const keys: string[] = []
+        for (let i = 0; i < this.storage.length; i++) {
+            const key = this.storage.key(i)
+            if (key) keys.push(key)
+        }
+        return keys
+    }
+}
+
+export const localStorageUtil = new StorageUtil(window.localStorage)
+export const sessionStorageUtil = new StorageUtil(window.sessionStorage)
+export const setTheme = (theme: string) => {
+    localStorage.setItem('theme', theme);
+    sessionStorage.setItem('theme', theme);
+    window.document.documentElement.setAttribute('data-theme', theme)
+}