道闸软件全量执行总控

// ============================================================
// IGateAdapter 道闸适配器标准接口 v1.0
// 所有厂商适配器必须实现此接口
// ============================================================

interface IGateAdapter {

  // ===== 1. 基础信息（5个方法）=====
  getVendor(): string;                    // 获取厂商名称
  getModel(): string;                     // 获取设备型号
  getProtocol(): string;                  // 获取通信协议
  getVersion(): string;                   // 获取固件版本
  getCapabilities(): DeviceCapabilities;    // 获取设备能力清单

  // ===== 2. 连接管理（5个方法）=====
  connect(config: DeviceConfig): Promise<boolean>;
  disconnect(): Promise<boolean>;
  isConnected(): boolean;
  reconnect(): Promise<boolean>;
  getConnectionInfo(): ConnectionInfo;

  // ===== 3. 车牌识别（4个方法）=====
  recognizePlate(image: Buffer): Promise<PlateResult>;
  recognizePlateMultiFrame(images: Buffer[]): Promise<PlateResult>;
  getRecognizeConfig(): RecognizeConfig;
  setRecognizeConfig(config: RecognizeConfig): boolean;

  // ===== 4. 道闸控制（5个方法）=====
  openGate(reason: string, plate?: string): Promise<GateResult>;
  closeGate(): Promise<GateResult>;
  stopGate(): Promise<GateResult>;
  resetGate(): Promise<GateResult>;
  getGateStatus(): Promise<GateStatus>;

  // ===== 5. 通行记录（4个方法）=====
  getRecords(filter: RecordFilter): Promise<Record[]>;
  onRecord(callback: (record: Record) => void): void;
  syncRecords(): Promise<number>;
  exportRecords(filter: RecordFilter, format: string): Promise<Buffer>;

  // ===== 6. 白名单/计费（4个方法）=====
  checkWhitelist(plate: string): Promise<WhitelistResult>;
  calculateBilling(entry: Date, exit: Date, plate: string): Promise<BillingResult>;
  syncWhitelist(): Promise<number>;
  getBillingRules(): BillingRule[];

  // ===== 7. 事件告警（3个方法）=====
  onEvent(callback: (event: GateEvent) => void): void;
  getEvents(filter: EventFilter): Promise<GateEvent[]>;
  acknowledgeEvent(eventId: string): boolean;

  // ===== 8. 设备管理（5个方法）=====
  getDeviceInfo(): DeviceInfo;
  getDeviceStatus(): Promise<DeviceStatus>;
  reboot(): Promise<boolean>;
  upgradeFirmware(url: string, md5: string): Promise<boolean>;
  getLogs(level: string, limit: number): Promise<string[]>;
}

// ============================================================
// AdapterRegistry 适配器注册中心（热插拔）
// ============================================================

class AdapterRegistry {
  private adapters: Map<string, IGateAdapter>;

  register(vendor: string, adapter: IGateAdapter): void;
  unregister(vendor: string): void;
  getAdapter(vendor: string): IGateAdapter | null;
  listAdapters(): string[];
  getByGateId(gateId: string): IGateAdapter | null;
  loadAdapter(path: string): Promise<boolean>;  // 动态加载
}

class JieshunAdapter implements IGateAdapter {
  private socket: net.Socket;
  private config: DeviceConfig;
  private connected: boolean = false;
  private requestQueue: Map<string, Function>;

  // 基础信息
  getVendor() { return 'jieshun'; }
  getProtocol() { return 'tcp_json'; }

  // 连接管理
  async connect(config: DeviceConfig): Promise<boolean> {
    this.config = config;
    return new Promise((resolve, reject) => {
      this.socket = net.connect(config.port, config.host, () => {
        this.connected = true;
        resolve(true);
      });
      this.socket.on('data', (data) => this.handleResponse(data));
      this.socket.on('error', reject);
      this.socket.on('close', () => { this.connected = false; });
    });
  }

  // 道闸控制 - 核心方法
  async openGate(reason: string, plate?: string): Promise<GateResult> {
    const cmd = {
      cmd: 'OPEN_GATE',
      gateId: this.config.gateId,
      reason: reason,
      plateNumber: plate || '',
      timestamp: Date.now()
    };
    const response = await this.sendRequest(cmd, 3000);  // 3秒超时
    return {
      success: response.code === 0,
      message: response.message,
      action: 'open',
      timestamp: new Date()
    };
  }

  // 车牌识别
  async recognizePlate(image: Buffer): Promise<PlateResult> {
    const cmd = {
      cmd: 'RECOGNIZE_PLATE',
      gateId: this.config.gateId,
      imageBase64: image.toString('base64')
    };
    const response = await this.sendRequest(cmd, 5000);
    return {
      plateNumber: response.plateNumber,
      plateColor: response.plateColor,
      confidence: response.confidence,
      vehicleType: response.vehicleType
    };
  }

  // 私有方法：发送请求并等待响应
  private async sendRequest(cmd: any, timeout: number): Promise<any> {
    const requestId = uuid();
    cmd.requestId = requestId;
    return new Promise((resolve, reject) => {
      const timer = setTimeout(() => {
        this.requestQueue.delete(requestId);
        reject(new Error('Request timeout'));
      }, timeout);
      this.requestQueue.set(requestId, (response) => {
        clearTimeout(timer);
        resolve(response);
      });
      this.socket.write(JSON.stringify(cmd) + '\n');
    });
  }
}

enum EntryState {
  ARRIVED = 'ARRIVED',              // 1.车辆到达识别区
  PLATE_RECOGNIZED = 'PLATE_RECOGNIZED', // 2.车牌已识别
  WHITELIST_CHECKED = 'WHITELIST_CHECKED', // 3.白名单已查询
  PARKING_ASSIGNED = 'PARKING_ASSIGNED', // 4.车位已分配
  GATE_OPENED = 'GATE_OPENED',          // 5.道闸已开
  ENTERED = 'ENTERED',                  // 6.已入场
  NAVIGATING = 'NAVIGATING',            // 7.导航中
  ARRIVED_PARKING = 'ARRIVED_PARKING', // 8.已到达车位
  LOCK_DOWN = 'LOCK_DOWN',              // 9.地锁已降下
  PARKED = 'PARKED',                    // 10.已停好
  CHARGING = 'CHARGING',                // 11.充电中
  COMPLETED = 'COMPLETED'              // 12.流程完成
}

class LinkageStateMachine {
  private currentState: EntryState;
  private context: LinkageContext;
  private transitions: Map<EntryState, StateTransition>;

  constructor() {
    this.currentState = EntryState.ARRIVED;
    this.initTransitions();
  }

  // 状态转换定义（严格时序，不可跳跃）
  private initTransitions() {
    this.transitions.set(EntryState.ARRIVED, {
      next: EntryState.PLATE_RECOGNIZED,
      action: async (ctx) => {
        const result = await ctx.adapter.recognizePlate(ctx.image);
        if (result.confidence < 0.8) throw new Error('Low confidence');
        ctx.plate = result.plateNumber;
      },
      timeout: 2000,
      retries: 2
    });
    // ... 其他11个状态转换定义
  }

  // 执行下一步（带重试+超时+补偿）
  async next(): Promise<boolean> {
    const transition = this.transitions.get(this.currentState);
    if (!transition) return false;

    for (let i = 0; i < transition.retries; i++) {
      try {
        await this.executeWithTimeout(transition.action, transition.timeout);
        this.currentState = transition.next;
        return true;
      } catch (e) {
        await sleep(500 * (i + 1));  // 指数退避
      }
    }
    // 重试失败，触发补偿+回滚
    await this.compensate();
    return false;
  }

  // 补偿机制（根据当前状态回滚）
  private async compensate() {
    switch (this.currentState) {
      case EntryState.LOCK_DOWN:
        await this.context.lockAdapter.raiseLock();  // 升起地锁
        await this.context.parkingService.release();  // 释放车位
        break;
      // ... 其他状态的补偿逻辑
    }
    await this.triggerAlarm('LINKAGE_FAILED', this.currentState);
  }
}

// ===== 车牌识别结果 =====
interface PlateResult {
  plateNumber: string;        // 车牌号 如"闽A12345"
  plateColor: 'blue' | 'green' | 'yellow' | 'white';
  confidence: number;          // 置信度 0-1
  vehicleType: 'car' | 'truck' | 'motorcycle' | 'bus';
  recognizedAt: Date;
  imageUrl?: string;
}

// ===== 道闸控制结果 =====
interface GateResult {
  success: boolean;
  message: string;
  action: 'open' | 'close' | 'stop' | 'reset';
  timestamp: Date;
  errorCode?: string;
}

// ===== 道闸状态 =====
interface GateStatus {
  gateId: string;
  status: 'open' | 'closed' | 'moving' | 'fault' | 'offline';
  currentAngle: number;       // 当前角度 0-90
  lastAction: string;
  lastActionAt: Date;
  faultCode?: string;
  online: boolean;
  motorCurrent?: number;    // 电机电流(A)
  motorTemp?: number;       // 电机温度(℃)
}

// ===== 通行记录 =====
interface Record {
  recordId: string;
  gateId: string;
  plateNumber: string;
  direction: 'in' | 'out';
  passType: 'recognized' | 'manual' | 'free' | 'monthly';
  entryTime: Date;
  exitTime?: Date;
  imageUrl?: string;
  confidence: number;
  vehicleType: string;
  parkingLotId: string;
  synced: boolean;          // 是否已同步到云端
}

// ===== 白名单查询结果 =====
interface WhitelistResult {
  plateNumber: string;
  inWhitelist: boolean;
  whitelistType?: 'monthly' | 'vip' | 'employee' | 'free' | 'temp';
  expireTime?: Date;
  remainingTimes?: number;     // 次卡剩余次数
  discountRate?: number;        // 折扣率 0-1
  freeHours?: number;          // 免费时长(小时)
}

// ===== 计费结果 =====
interface BillingResult {
  durationMinutes: number;
  freeMinutes: number;
  billableMinutes: number;
  originalAmount: number;
  discountAmount: number;
  finalAmount: number;
  currency: string;
  billingRuleId: string;
  breakdown: BillingItem[];
}

// ===== 事件告警 =====
interface GateEvent {
  eventId: string;
  gateId: string;
  eventType: 'fault' | 'alarm' | 'info';
  eventCode: string;
  eventName: string;
  severity: 'low' | 'medium' | 'high' | 'critical';
  description: string;
  timestamp: Date;
  deviceStatus?: any;
  acknowledged: boolean;
}