MQTTvue/mqtt-vue-dashboard/server/src/models/user.ts

import bcrypt from 'bcryptjs';
import { executeQuery } from '../config/database';

// 用户角色类型
export type UserRole = 'admin' | 'user' | 'viewer';

// 用户模型接口
export interface User {
  id: string;
  username: string;
  password: string;
  email?: string;
  role: UserRole;
  created_at: Date;
  updated_at: Date;
}

// 用户创建参数接口
export interface UserCreateParams {
  username: string;
  password: string;
  role?: UserRole;
  email?: string;
}

/**
 * 用户模型
 * 处理用户数据的CRUD操作
 */
export class UserModel {
  /**
   * 创建用户
   */
  static async create(params: UserCreateParams): Promise<User> {
    try {
      const { username, password, role = 'user', email } = params;
      
      // 生成密码哈希
      const salt = await bcrypt.genSalt(10);
      const hashedPassword = await bcrypt.hash(password, salt);
      
      // 确保email为null而不是undefined
      const emailValue = email || null;
      
      // 生成UUID作为id
      const uuidResult = await executeQuery('SELECT UUID() as uuid');
      const id = uuidResult[0].uuid;
      
      // 插入用户数据
      const query = `
        INSERT INTO users (id, username, password, email, role, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, NOW(), NOW())
      `;
      
      await executeQuery(query, [id, username, hashedPassword, emailValue, role]);
      
      // 返回创建的用户
      const user = await this.getById(id);
      if (!user) {
        throw new Error('创建用户失败，无法获取创建的用户信息');
      }
      return user;
    } catch (error) {
      console.error('创建用户失败:', error);
      throw error;
    }
  }

  /**
   * 根据ID获取用户
   */
  static async getById(id: any): Promise<User | null> {
    try {
      const query = `
        SELECT id, username, password, email, role, created_at, updated_at
        FROM users
        WHERE id = ?
      `;
      
      const result = await executeQuery(query, [id]);
      
      if (result.length === 0) {
        return null;
      }
      
      return result[0] as User;
    } catch (error) {
      console.error('根据ID获取用户失败:', error);
      throw error;
    }
  }

  /**
   * 根据用户名获取用户
   */
  static async getByUsername(username: string): Promise<User | null> {
    try {
      const query = `
        SELECT id, username, password, email, role, created_at, updated_at
        FROM users
        WHERE username = ?
      `;
      
      const result = await executeQuery(query, [username]);
      
      if (result.length === 0) {
        return null;
      }
      
      return result[0] as User;
    } catch (error) {
      console.error('根据用户名获取用户失败:', error);
      throw error;
    }
  }

  /**
   * 更新用户
   */
  static async update(id: any, updates: Partial<Omit<User, 'id' | 'created_at' | 'password'>>): Promise<User | null> {
    try {
      // 构建更新字段和参数
      const updateFields: string[] = [];
      const params: any[] = [];
      
      if (updates.username) {
        updateFields.push('username = ?');
        params.push(updates.username);
      }
      
      if (updates.role) {
        updateFields.push('role = ?');
        params.push(updates.role);
      }
      
      if (updates.email) {
        updateFields.push('email = ?');
        params.push(updates.email);
      }
      
      // 总是更新updated_at字段
      updateFields.push('updated_at = NOW()');
      
      if (updateFields.length === 1) {
        // 只有updated_at字段更新，直接返回当前用户
        return await this.getById(id);
      }
      
      params.push(id);
      
      // 执行更新
      const query = `
        UPDATE users
        SET ${updateFields.join(', ')}
        WHERE id = ?
      `;
      
      await executeQuery(query, params);
      
      // 返回更新后的用户
      return await this.getById(id);
    } catch (error) {
      console.error('更新用户失败:', error);
      throw error;
    }
  }

  /**
   * 更新用户密码
   */
  static async updatePassword(id: any, newPassword: string): Promise<void> {
    try {
      // 生成新的密码哈希
      const salt = await bcrypt.genSalt(10);
      const hashedPassword = await bcrypt.hash(newPassword, salt);
      
      // 更新密码
      const query = `
        UPDATE users
        SET password = ?, updated_at = NOW()
        WHERE id = ?
      `;
      
      await executeQuery(query, [hashedPassword, id]);
    } catch (error) {
      console.error('更新用户密码失败:', error);
      throw error;
    }
  }

  /**
   * 删除用户
   */
  static async delete(id: number): Promise<boolean> {
    try {
      const query = 'DELETE FROM users WHERE id = ?';
      
      const result = await executeQuery(query, [id]);
      
      return result.affectedRows > 0;
    } catch (error) {
      console.error('删除用户失败:', error);
      throw error;
    }
  }

  /**
   * 获取所有用户
   */
  static async getAll(limit?: number, offset?: number): Promise<User[]> {
    try {
      let query = `
        SELECT id, username, password, email, role, created_at, updated_at
        FROM users
        ORDER BY created_at DESC
      `;
      
      const params: any[] = [];
      
      if (limit !== undefined) {
        query += ' LIMIT ?';
        params.push(limit);
        
        if (offset !== undefined) {
          query += ' OFFSET ?';
          params.push(offset);
        }
      }
      
      const result = await executeQuery(query, params);
      
      return result as User[];
    } catch (error) {
      console.error('获取所有用户失败:', error);
      throw error;
    }
  }


}