QR码登录实现规约

interface GenerateQrCodeLoginRequest {
  platform: "wechat" | "alipay";  // 平台类型
  deviceId?: string;               // PC端设备ID（可选）
  deviceInfo?: string;             // PC端设备信息（可选）
}

interface GenerateQrCodeLoginResponse {
  sessionKey: string;    // 会话key，用于后续轮询
  qrCodeUrl: string;     // 二维码URL
  expiresAt: number;      // 过期时间戳
  expiresIn: number;      // 过期倒计时（秒）
}

interface ConfirmQrCodeLoginRequest {
  sessionKey: string;             // 会话key（从二维码中解析）
  scanDeviceId?: string;          // 扫码端设备ID（可选）
  scanDeviceInfo?: string;        // 扫码端设备信息（可选）
}

import type { UserResponse } from "../types/user";
import type { 
  GenerateQrCodeLoginRequest, 
  ConfirmQrCodeLoginRequest,
  PollQrCodeLoginRequest 
} from "../types/qrLogin";
import { BaseService } from "../types/BaseService";
import { ValidationException, NotFoundException } from "../exceptions/AppException";
 
// 数据库集合定义
const db = cloud.database();
const qrLoginSessionsCollection = db.collection("qrLoginSessions");
 
/**
 * QR码登录服务类
 * 提供QR码登录会话的创建、确认、轮询等核心功能
 */
export class QrLoginService extends BaseService {
  /**
   * 生成QR码登录会话
   */
  public async generateQrCodeLogin(
    params: GenerateQrCodeLoginRequest,
    _userInfo: UserResponse, // PC端不需要用户信息
  ): Promise<GenerateQrCodeLoginResponse> {
    // 参数验证
    if (!params.platform) {
      throw new ValidationException("平台类型不能为空");
    }
    
    if (!["wechat", "alipay"].includes(params.platform)) {
      throw new ValidationException("不支持的平台类型");
    }
    
    // 生成会话key
    const sessionKey = this.generateSessionKey();
    const expiresAt = Date.now() + 5 * 60 * 1000; // 5分钟过期
    
    // 创建会话记录
    const sessionData = {
      sessionKey,
      platform: params.platform,
      deviceId: params.deviceId,
      deviceInfo: params.deviceInfo,
      status: "pending",
      expiresAt,
      createdAt: Date.now(),
      updatedAt: Date.now()
    };
    
    await qrLoginSessionsCollection.add(sessionData);
    
    // 生成二维码URL
    const qrCodeUrl = this.generateQrCodeUrl(sessionKey);
    
    return {
      sessionKey,
      qrCodeUrl,
      expiresAt,
      expiresIn: 300 // 5分钟
    };
  }
  
  /**
   * 确认QR码登录
   */
  public async confirmQrCodeLogin(
    params: ConfirmQrCodeLoginRequest,
    userInfo: UserResponse,
  ): Promise<{ success: boolean; }> {
    // 参数验证
    if (!params.sessionKey) {
      throw new ValidationException("会话key不能为空");
    }
    
    // 查找会话
    const session = await this.validateRecordExists(
      qrLoginSessionsCollection,
      { sessionKey: params.sessionKey },
      "QR码登录会话不存在或已过期"
    );
    
    // 检查会话状态
    if (session.status !== "scanned") {
      throw new ValidationException("会话状态不正确");
    }
    
    // 更新会话状态
    await qrLoginSessionsCollection
      .doc(session._id)
      .update({
        status: "confirmed",
        userId: userInfo.id,
        scanDeviceId: params.scanDeviceId,
        scanDeviceInfo: params.scanDeviceInfo,
        confirmedAt: Date.now(),
        updatedAt: Date.now()
      });
    
    return { success: true };
  }
  
  /**
   * 轮询QR码登录状态
   */
  public async pollQrCodeLogin(
    params: PollQrCodeLoginRequest,
    _userInfo: UserResponse, // PC端不需要用户信息
  ): Promise<PollQrCodeLoginResponse> {
    // 参数验证
    if (!params.sessionKey) {
      throw new ValidationException("会话key不能为空");
    }
    
    // 查找会话
    const session = await qrLoginSessionsCollection
      .where({ sessionKey: params.sessionKey })
      .get();
    
    if (session.data.length === 0) {
      throw new NotFoundException("QR码登录会话不存在");
    }
    
    const sessionData = session.data[0];
    
    // 检查是否过期
    if (Date.now() > sessionData.expiresAt) {
      return {
        status: "expired",
        message: "会话已过期"
      };
    }
    
    // 根据状态返回不同信息
    switch (sessionData.status) {
      case "pending":
        return {
          status: "pending",
          message: "等待扫码"
        };
      case "scanned":
        return {
          status: "scanned",
          message: "已扫码，等待确认"
        };
      case "confirmed":
        // 获取用户信息和token
        const user = await this.getUserById(sessionData.userId);
        const token = this.generateToken(user);
        
        return {
          status: "confirmed",
          message: "登录成功",
          token,
          user,
          scanDeviceInfo: sessionData.scanDeviceInfo
        };
      default:
        return {
          status: "cancelled",
          message: "会话已取消"
        };
    }
  }
  
  /**
   * 生成会话key
   */
  private generateSessionKey(): string {
    return `qr_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }
  
  /**
   * 生成二维码URL
   */
  private generateQrCodeUrl(sessionKey: string): string {
    const baseUrl = process.env.QR_CODE_BASE_URL || "https://penny-lens.com/qr";
    return `${baseUrl}?key=${sessionKey}`;
  }
}

import type { AppResponse } from "../types/appResponse";
import type { UserResponse } from "../types/user";
import type {
  GenerateQrCodeLoginRequest,
  ConfirmQrCodeLoginRequest,
  PollQrCodeLoginRequest,
  GenerateQrCodeLoginResponse,
  PollQrCodeLoginResponse,
} from "../types/qrLogin";
import { QrLoginService } from "../services/qrLoginService";
import { BaseController } from "../types/BaseController";
 
/**
 * QR码登录控制器
 */
export class QrLoginController extends BaseController {
  private qrLoginService: QrLoginService;
 
  constructor() {
    super();
    this.qrLoginService = new QrLoginService();
  }
 
  /**
   * 生成QR码登录会话
   */
  async generateQrCodeLogin(
    params: GenerateQrCodeLoginRequest,
    _userInfo: UserResponse, // PC端不需要用户信息
  ): Promise<AppResponse<GenerateQrCodeLoginResponse>> {
    return this.wrapAsync(
      async () => {
        return this.qrLoginService.generateQrCodeLogin(params, _userInfo);
      },
      "生成QR码登录会话成功",
    );
  }
 
  /**
   * 确认QR码登录
   */
  async confirmQrCodeLogin(
    params: ConfirmQrCodeLoginRequest,
    userInfo: UserResponse,
  ): Promise<AppResponse<{ success: boolean; }>> {
    return this.wrapAsync(
      async () => {
        return this.qrLoginService.confirmQrCodeLogin(params, userInfo);
      },
      "确认QR码登录成功",
    );
  }
 
  /**
   * 轮询QR码登录状态
   */
  async pollQrCodeLogin(
    params: PollQrCodeLoginRequest,
    _userInfo: UserResponse, // PC端不需要用户信息
  ): Promise<AppResponse<PollQrCodeLoginResponse>> {
    return this.wrapAsync(
      async () => {
        return this.qrLoginService.pollQrCodeLogin(params, _userInfo);
      },
      "轮询QR码登录状态成功",
    );
  }
}

// QR码登录相关路由
export const qrLoginActions = [
  { action: "generateQrCodeLogin", requireAuth: false }, // PC端生成二维码不需要认证
  { action: "confirmQrCodeLogin", requireAuth: true },   // 小程序端确认需要认证
  { action: "pollQrCodeLogin", requireAuth: false },      // PC端轮询不需要认证
];
 
// 构建路由配置
export const routes: Record<string, RouteConfig> = {
  ...buildRoutes("user", qrLoginActions, qrLoginController),
};

function handleError(error) {
  switch (error.code) {
    case 404:
      showMessage('二维码已失效，请重新生成');
      generateQRCode();
      break;
    case 410:
      showMessage('二维码已过期，请重新生成');
      generateQRCode();
      break;
    default:
      showMessage('操作失败，请重试');
  }
}