d8d-admin-mobile-starter-public/server/controllers/sms.ts

import type { Context } from 'hono'
import type {
  DeviceStatus,
  SmsItem,
  SmsConfig,
  SmsApiRequest,
  SmsApiResponse,
  SmsError,
  SmsMetrics
} from '../types/smsTypes.ts'
import { getSystemSettings } from './systemSettings.ts'
import { createHash } from 'node:crypto'
import { fetchWithRetry } from '../utils/http.ts'
import { logger } from '../utils/logger.ts'

// 加密密钥(应从环境变量获取)
const ENCRYPT_KEY = process.env.SMS_ENCRYPT_KEY || 'default-encrypt-key'

// 性能指标
const smsMetrics: SmsMetrics = {
  requestCount: 0,
  successCount: 0,
  failureCount: 0,
  averageLatency: 0
}

// 加密函数
function encryptPassword(password: string): string {
  return createHash('sha256')
    .update(password + ENCRYPT_KEY)
    .digest('hex')
}

// 生成Basic认证头
function generateAuthHeader(username: string, password: string): string {
  const text = `${username}:${password}`
  const bytes = new TextEncoder().encode(text)
  const token = btoa(String.fromCharCode(...bytes))
  return `Basic ${token}`
}

// 获取短信配置
async function getSmsConfig(): Promise<SmsConfig> {
  const settings = await getSystemSettings()
  return {
    apiUrl: settings.apiUrl,
    username: settings.username,
    encryptedPassword: settings.encryptedPassword,
    timeout: settings.timeout ?? 5000,
    maxRetries: settings.maxRetries ?? 3
  }
}

// 模拟数据存储
const mockDeviceStatus: DeviceStatus = {
  signalStrength: 85,
  carrier: '中国移动',
  mode: '短信'
}

const mockSmsList: SmsItem[] = []

export const SmsController = {
  async login(ctx: Context) {
    const { username, password } = await ctx.req.json<SmsApiRequest>()
    
    if (username === 'vsmsd' && password === 'Vsmsd123') {
      return ctx.json({ 
        success: true,
        token: 'dummy-token-for-demo'
      })
    }
    
    return ctx.json({ success: false }, 401)
  },

  async getDeviceStatus(ctx: Context) {
    return ctx.json({
      data: {
        status: mockDeviceStatus,
        list: mockSmsList
      }
    })
  },

  async sendSms(ctx: Context) {
    const { phone, content } = await ctx.req.json<SmsApiRequest>()
    if (!phone || !content) {
      return ctx.json({
        success: false,
        message: '手机号和短信内容不能为空'
      }, 400)
    }
    
    const taskId = `task-${Date.now()}`
    const newSms: SmsItem = {
      id: Date.now().toString(),
      phone,
      content,
      taskId,
      status: 'pending',
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString()
    }

    try {
      const config = await getSmsConfig()
      const startTime = Date.now()
      
      const response = await fetchWithRetry(config.apiUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': generateAuthHeader(config.username, config.encryptedPassword)
        },
        body: JSON.stringify({ phone, content }),
        timeout: config.timeout ?? 5000,
        maxRetries: config.maxRetries ?? 3
      })
      
      const data: SmsApiResponse = await response.json()
      
      if (data.success) {
        newSms.status = 'success'
        smsMetrics.successCount++
        logger.info(`短信发送成功: ${taskId}`, { phone, taskId })
      } else {
        newSms.status = 'failed'
        smsMetrics.failureCount++
        logger.error(`短信发送失败: ${data.code} - ${data.message}`, {
          phone,
          taskId,
          error: data
        })
      }
      
      const latency = Date.now() - startTime
      smsMetrics.requestCount++
      smsMetrics.averageLatency =
        (smsMetrics.averageLatency * (smsMetrics.requestCount - 1) + latency) /
        smsMetrics.requestCount
      smsMetrics.lastRequestTime = new Date().toISOString()
      
    } catch (error) {
      // 真实接口失败时使用模拟发送作为fallback
      newSms.status = 'success' // 模拟成功
      if (error instanceof Error) {
        logger.warn(`使用模拟短信发送: ${error.message}`, {
          phone,
          taskId,
          error: error.stack
        })
      } else {
        logger.warn(`使用模拟短信发送: ${String(error)}`, {
          phone,
          taskId
        })
      }
    }

    mockSmsList.unshift(newSms)
    
    return ctx.json({
      success: true,
      data: newSms
    })
  },

  async getSmsResult(ctx: Context) {
    const id = ctx.req.param('id')
    const sms = mockSmsList.find(item => item.id === id)
    
    if (!sms) {
      return ctx.json({
        success: false,
        message: '未找到该短信记录'
      }, 404)
    }

    // 模拟短信发送结果详情
    return ctx.json({
      success: true,
      data: {
        ...sms,
        results: [
          {
            serial: '001',
            carrier: '中国移动',
            time: new Date().toISOString(),
            status: sms.status === 'pending' ? '处理中' :
                   sms.status === 'success' ? '成功' : '失败'
          }
        ]
      }
    })
  },
  
  async getMetrics(ctx: Context) {
    return ctx.json({
      success: true,
      data: smsMetrics
    })
  }
}