MemoryBear/api/app/services/user_service.py

import datetime
import secrets
import string
from sqlalchemy.orm import Session
import uuid

from app.models.user_model import User
from app.repositories import user_repository
from app.schemas.user_schema import UserCreate
from app.schemas.tenant_schema import TenantCreate
from app.services.tenant_service import TenantService
from app.services.session_service import SessionService
from app.core.security import get_password_hash, verify_password
from app.core.config import settings
from app.core.logging_config import get_business_logger
from app.core.exceptions import BusinessException, PermissionDeniedException
from app.core.error_codes import BizCode
# from app.services import workspace_service
# from app.schemas.workspace_schema import WorkspaceCreate

# 获取业务逻辑专用日志器
business_logger = get_business_logger()


def create_initial_superuser(db: Session):
    business_logger.info("检查并创建初始超级用户")
    
    superuser = user_repository.get_superuser(db)
    if superuser:
        business_logger.info("超级用户已存在，跳过创建")
        return
    
    user_in = UserCreate(
            username=settings.FIRST_SUPERUSER_USERNAME,
            email=settings.FIRST_SUPERUSER_EMAIL,
            password=settings.FIRST_SUPERUSER_PASSWORD,
        )

    try:
        business_logger.debug("开始创建初始租户")
         # Create a default tenant for the superuser
        default_tenant = TenantCreate(
            name=f"{user_in.username}'s Tenant",
            description=f"Default tenant for {user_in.username}",
        )
        # Create tenant service and create tenant with user assignment
        tenant_service = TenantService(db)
        tenant =  tenant_service.create_tenant(default_tenant)
        db.flush()
        business_logger.debug("开始创建初始超级用户")
        
        hashed_password = get_password_hash(user_in.password)
        superuser = user_repository.create_user(
            db=db, user=user_in, hashed_password=hashed_password, is_superuser=True, 
            tenant_id=tenant.id
        )
        db.commit()
        db.refresh(superuser)
        business_logger.info(f"初始超级用户创建成功: {superuser.username} (ID: {superuser.id})")
        return superuser
    except Exception as e:
        business_logger.error(f"初始超级用户创建失败: {str(e)}")
        db.rollback()
        raise BusinessException(
            f"初始超级用户创建失败: {str(e)}", 
            code=BizCode.DB_ERROR,
            context={"username": user_in.username, "email": user_in.email},
            cause=e
        )


def create_user(db: Session, user: UserCreate) -> User:
    business_logger.info(f"创建用户: {user.username}, email: {user.email}")
    
    try:
        # 检查用户名是否已存在
        business_logger.debug(f"检查用户名是否已存在: {user.username}")
        db_user_by_username = user_repository.get_user_by_username(db, username=user.username)
        if db_user_by_username:
            business_logger.warning(f"用户名已存在: {user.username}")
            raise BusinessException(
                "用户名已存在", 
                code=BizCode.DUPLICATE_NAME,
                context={"username": user.username, "email": user.email}
            )
        
        # 检查邮箱是否已注册
        business_logger.debug(f"检查邮箱是否已注册: {user.email}")
        db_user_by_email = user_repository.get_user_by_email(db, email=user.email)
        if db_user_by_email:
            business_logger.warning(f"邮箱已注册: {user.email}")
            raise BusinessException(
                "邮箱已注册", 
                code=BizCode.DUPLICATE_NAME,
                context={"email": user.email, "username": user.username}
            )

        # 创建普通用户，需要有默认租户
        business_logger.debug(f"开始创建用户: {user.username}")
        hashed_password = get_password_hash(user.password)
        
        # 获取默认租户（第一个活跃租户）
        from app.repositories.tenant_repository import TenantRepository
        tenant_repo = TenantRepository(db)
        tenants = tenant_repo.get_tenants(skip=0, limit=1, is_active=True)
        
        if not tenants:
            business_logger.error("系统中没有可用的租户")
            raise BusinessException(
                "系统配置错误：没有可用的租户", 
                code=BizCode.TENANT_NOT_FOUND,
                context={"username": user.username, "email": user.email}
            )
        
        default_tenant = tenants[0]
        
        new_user = user_repository.create_user(
            db=db, user=user, hashed_password=hashed_password, 
            tenant_id=default_tenant.id, is_superuser=False
        )

        db.commit()
        db.refresh(new_user)
        business_logger.info(f"用户创建成功: {new_user.username} (ID: {new_user.id})")
        return new_user
    except Exception as e:
        business_logger.error(f"用户创建失败: {user.username} - {str(e)}")
        db.rollback()
        raise BusinessException(
            f"用户创建失败: {user.username} - {str(e)}", 
            code=BizCode.DB_ERROR,
            context={"username": user.username, "email": user.email},
            cause=e
        )


def create_superuser(db: Session, user: UserCreate, current_user: User) -> User:
    business_logger.info(f"创建超级管理员: {user.username}, email: {user.email}")
    
    # 检查当前用户是否为超级管理员
    from app.core.permissions import permission_service, Subject
    
    subject = Subject.from_user(current_user)
    try:
        permission_service.check_superuser(
            subject,
            error_message="只有超级管理员才能创建超级管理员用户"
        )
    except PermissionDeniedException as e:
        business_logger.warning(f"非超级管理员尝试创建超级管理员用户: {user.username}")
        raise BusinessException(
            str(e), 
            code=BizCode.FORBIDDEN,
            context={
                "current_user_id": str(current_user.id),
                "current_user_username": current_user.username,
                "target_username": user.username
            }
        )
    
    try:
        # 检查用户名是否已存在
        business_logger.debug(f"检查用户名是否已存在: {user.username}")
        db_user_by_username = user_repository.get_user_by_username(db, username=user.username)
        if db_user_by_username:
            business_logger.warning(f"用户名已存在: {user.username}")
            raise BusinessException(
                "用户名已存在", 
                code=BizCode.DUPLICATE_NAME,
                context={
                    "username": user.username,
                    "email": user.email,
                    "created_by": str(current_user.id)
                }
            )
        
        # 检查邮箱是否已注册
        business_logger.debug(f"检查邮箱是否已注册: {user.email}")
        db_user_by_email = user_repository.get_user_by_email(db, email=user.email)
        if db_user_by_email:
            business_logger.warning(f"邮箱已注册: {user.email}")
            raise BusinessException(
                "邮箱已注册", 
                code=BizCode.DUPLICATE_NAME,
                context={
                    "email": user.email, 
                    "username": user.username,
                    "created_by": str(current_user.id)
                }
            )

        # 创建超级管理员用户并加入当前用户的租户
        business_logger.debug(f"开始创建超级管理员: {user.username}")
        hashed_password = get_password_hash(user.password)
        
        new_user = user_repository.create_user(
            db=db, user=user, hashed_password=hashed_password, 
            tenant_id=current_user.tenant_id, is_superuser=True
        )

        db.commit()
        db.refresh(new_user)
        business_logger.info(f"超级管理员创建成功: {new_user.username} (ID: {new_user.id}), 已加入租户: {current_user.tenant_id}")
        return new_user
    except Exception as e:
        business_logger.error(f"超级管理员创建失败: {user.username} - {str(e)}")
        db.rollback()
        raise BusinessException(
            f"超级管理员创建失败: {user.username} - {str(e)}", 
            code=BizCode.DB_ERROR,
            context={
                "username": user.username, 
                "email": user.email,
                "created_by": str(current_user.id),
                "tenant_id": str(current_user.tenant_id)
            },
            cause=e
        )


def deactivate_user(db: Session, user_id_to_deactivate: uuid.UUID, current_user: User) -> User:
    business_logger.info(f"停用用户: user_id={user_id_to_deactivate}, 操作者: {current_user.username}")
    
    try:
        # 查找用户
        business_logger.debug(f"查找待停用用户: {user_id_to_deactivate}")
        db_user = user_repository.get_user_by_id(db, user_id=user_id_to_deactivate)
        if not db_user:
            business_logger.warning(f"用户不存在: {user_id_to_deactivate}")
            raise BusinessException(
                "用户不存在", 
                code=BizCode.USER_NOT_FOUND,
                context={"user_id": str(user_id_to_deactivate)}
            )
        
        # 权限检查 using permission service
        from app.core.permissions import permission_service, Subject, Resource, Action
        
        subject = Subject.from_user(current_user)
        resource = Resource.from_user(db_user)
        
        try:
            permission_service.require_permission(
                subject,
                Action.DEACTIVATE,
                resource,
                error_message="没有权限停用该用户"
            )
        except PermissionDeniedException as e:
            business_logger.warning(f"权限不足: 用户 {current_user.username} 尝试停用用户 {user_id_to_deactivate}")
            raise BusinessException(
                str(e), 
                code=BizCode.FORBIDDEN,
                context={
                    "current_user_id": str(current_user.id),
                    "current_user_username": current_user.username,
                    "target_user_id": str(user_id_to_deactivate)
                }
            )
        # 检查用户类型，如果是超级管理员，判断一下不是唯一的一个
        if db_user.is_superuser:
            is_only_superuser = user_repository.check_superuser_only(db)
            if is_only_superuser:
                business_logger.warning(f"停用超级管理员用户: {db_user.username} (ID: {user_id_to_deactivate})")
                raise BusinessException(
                    "不能停用唯一的超级管理员用户", 
                    code=BizCode.FORBIDDEN,
                    context={
                        "user_id": str(user_id_to_deactivate),
                        "username": db_user.username
                    }
                )

        # 停用用户
        business_logger.debug(f"执行用户停用: {db_user.username} (ID: {user_id_to_deactivate})")
        db_user.is_active = False
        db.add(db_user)
        db.commit()
        db.refresh(db_user)
        business_logger.info(f"用户停用成功: {db_user.username} (ID: {user_id_to_deactivate})")
        return db_user
    except Exception as e:
        business_logger.error(f"用户停用失败: user_id={user_id_to_deactivate} - {str(e)}")
        db.rollback()
        if isinstance(e, BusinessException):
            raise e
        raise BusinessException(f"{str(e)}", code=BizCode.DB_ERROR)

def activate_user(db: Session, user_id_to_activate: uuid.UUID, current_user: User) -> User:
    business_logger.info(f"激活用户: user_id={user_id_to_activate}, 操作者: {current_user.username}")
    
    try:
        # 查找用户
        business_logger.debug(f"查找待激活用户: {user_id_to_activate}")
        db_user = user_repository.get_user_by_id(db, user_id=user_id_to_activate)
        if not db_user:
            business_logger.warning(f"用户不存在: {user_id_to_activate}")
            raise BusinessException("用户不存在", code=BizCode.USER_NOT_FOUND)
        
        # 权限检查 using permission service
        from app.core.permissions import permission_service, Subject, Resource, Action
        
        subject = Subject.from_user(current_user)
        resource = Resource.from_user(db_user)
        
        try:
            permission_service.require_permission(
                subject,
                Action.ACTIVATE,
                resource,
                error_message="没有权限激活该用户"
            )
        except PermissionDeniedException as e:
            business_logger.warning(f"权限不足: 用户 {current_user.username} 尝试激活用户 {user_id_to_activate}")
            raise BusinessException(str(e), code=BizCode.FORBIDDEN)

        # 激活用户
        business_logger.debug(f"执行用户激活: {db_user.username} (ID: {user_id_to_activate})")
        db_user.is_active = True
        db.add(db_user)
        db.commit()
        db.refresh(db_user)
        business_logger.info(f"用户激活成功: {db_user.username} (ID: {user_id_to_activate})")
        return db_user
    except Exception as e:
        business_logger.error(f"用户激活失败: user_id={user_id_to_activate} - {str(e)}")
        db.rollback()
        raise BusinessException(f"用户激活失败: user_id={user_id_to_activate} - {str(e)}", code=BizCode.DB_ERROR)


def get_user(db: Session, user_id: uuid.UUID, current_user: User) -> User:
    business_logger.info(f"获取用户信息: user_id={user_id}, 操作者: {current_user.username}")
    
    try:
        # 查找用户
        business_logger.debug(f"查找用户: {user_id}")
        db_user = user_repository.get_user_by_id(db, user_id=user_id)
        if not db_user:
            business_logger.warning(f"用户不存在: {user_id}")
            raise BusinessException("用户不存在", code=BizCode.USER_NOT_FOUND)
        
        # 权限检查 using permission service
        from app.core.permissions import permission_service, Subject, Resource, Action
        
        subject = Subject.from_user(current_user)
        resource = Resource.from_user(db_user)
        
        try:
            permission_service.require_permission(
                subject,
                Action.READ,
                resource,
                error_message="没有权限获取该用户信息"
            )
        except PermissionDeniedException as e:
            business_logger.warning(f"权限不足: 用户 {current_user.username} 尝试获取用户 {user_id} 信息")
            raise BusinessException(str(e), code=BizCode.FORBIDDEN)

        # 返回用户信息
        business_logger.debug(f"返回用户信息: {db_user.username} (ID: {user_id})")
        return db_user
    except Exception as e:
        business_logger.error(f"获取用户信息失败: user_id={user_id} - {str(e)}")
        raise BusinessException(f"获取用户信息失败: user_id={user_id} - {str(e)}", code=BizCode.DB_ERROR)


def get_tenant_superusers(db: Session, current_user: User, include_inactive: bool = True) -> list[User]:
    """获取当前租户下的超管账号列表"""
    business_logger.info(f"获取租户超管列表: tenant_id={current_user.tenant_id}, 请求者: {current_user.username}, include_inactive={include_inactive}") 
    
    try:
        # 检查当前用户是否有权限查看（只有超管才能查看超管列表）
        from app.core.permissions import permission_service, Subject
        
        subject = Subject.from_user(current_user)
        try:
            permission_service.check_superuser(
                subject,
                error_message="只有超级管理员才能查看超管列表"
            )
        except PermissionDeniedException as e:
            business_logger.warning(f"非超级管理员尝试查看超管列表: {current_user.username}")
            raise BusinessException(str(e), code=BizCode.FORBIDDEN)
        
        # 检查用户是否有租户
        if not current_user.tenant_id:
            business_logger.warning(f"用户没有租户信息: {current_user.username}")
            raise BusinessException("用户没有租户信息", code=BizCode.TENANT_NOT_FOUND)
        
        # 获取租户下的超管列表
        business_logger.debug(f"查询租户超管: tenant_id={current_user.tenant_id}, include_inactive={include_inactive}")
        is_active_filter = None if include_inactive else True
        superusers = user_repository.get_superusers_by_tenant(
            db=db, 
            tenant_id=current_user.tenant_id, 
            is_active=is_active_filter
        )
        
        business_logger.info(f"租户超管查询成功: tenant_id={current_user.tenant_id}, count={len(superusers)}")
        return superusers
        
    except Exception as e:
        business_logger.error(f"获取租户超管列表失败: tenant_id={current_user.tenant_id} - {str(e)}")
        raise BusinessException(f"获取租户超管列表失败: tenant_id={current_user.tenant_id} - {str(e)}", code=BizCode.DB_ERROR)


def update_last_login_time(db: Session, user_id: uuid.UUID) -> User:
    """更新用户的最后登录时间"""
    business_logger.info(f"更新用户最后登录时间: user_id={user_id}")
    
    try:
        # 获取用户
        db_user = user_repository.get_user_by_id(db=db, user_id=user_id)
        if not db_user:
            business_logger.warning(f"用户不存在: {user_id}")
            raise BusinessException("用户不存在", code=BizCode.USER_NOT_FOUND)
        
        # 更新最后登录时间
        db_user.last_login_at = datetime.datetime.now()
        db.commit()
        db.refresh(db_user)
        
        business_logger.info(f"用户最后登录时间更新成功: {db_user.username} (ID: {user_id})")
        return db_user
        
    except (BusinessException, PermissionDeniedException):
        raise
    except Exception as e:
        business_logger.error(f"更新用户最后登录时间失败: user_id={user_id} - {str(e)}")
        db.rollback()
        raise


async def change_password(db: Session, user_id: uuid.UUID, old_password: str, new_password: str, current_user: User) -> User:
    """普通用户修改自己的密码"""
    business_logger.info(f"用户修改密码请求: user_id={user_id}, current_user={current_user.id}")
    
    # 检查权限：只能修改自己的密码
    if current_user.id != user_id:
        business_logger.warning(f"用户尝试修改他人密码: current_user={current_user.id}, target_user={user_id}")
        raise PermissionDeniedException("You can only change your own password")
    
    try:
        # 获取用户
        db_user = user_repository.get_user_by_id(db=db, user_id=user_id)
        if not db_user:
            business_logger.warning(f"用户不存在: {user_id}")
            raise BusinessException("User not found", code=BizCode.USER_NOT_FOUND)
        
        # 验证旧密码
        if not verify_password(old_password, db_user.hashed_password):
            business_logger.warning(f"用户旧密码验证失败: {user_id}")
            raise BusinessException("当前密码不正确", code=BizCode.VALIDATION_FAILED)
        
        # 更新密码
        db_user.hashed_password = get_password_hash(new_password)
        db.commit()
        db.refresh(db_user)
        
        # 使所有旧 tokens 失效
        await SessionService.invalidate_all_user_tokens(str(user_id))
        
        business_logger.info(f"用户密码修改成功: {db_user.username} (ID: {user_id})")
        return db_user
        
    except Exception as e:
        business_logger.error(f"修改用户密码失败: user_id={user_id} - {str(e)}")
        db.rollback()
        raise BusinessException(f"修改用户密码失败: user_id={user_id} - {str(e)}", code=BizCode.DB_ERROR)


async def admin_change_password(db: Session, target_user_id: uuid.UUID, new_password: str = None, current_user: User = None) -> tuple[User, str]:
    """
    超级管理员修改指定用户的密码
    
    Args:
        db: 数据库会话
        target_user_id: 目标用户ID
        new_password: 新密码，如果为None则自动生成随机密码
        current_user: 当前用户（超级管理员）
        
    Returns:
        tuple[User, str]: (更新后的用户对象, 实际使用的密码)
    """
    business_logger.info(f"管理员修改用户密码请求: admin={current_user.id}, target_user={target_user_id}")
    
    # 检查权限：只有超级管理员可以修改他人密码
    from app.core.permissions import permission_service, Subject
    
    subject = Subject.from_user(current_user)
    try:
        permission_service.check_superuser(
            subject,
            error_message="只有超级管理员可以修改他人密码"
        )
    except PermissionDeniedException as e:
        business_logger.warning(f"非超管用户尝试修改他人密码: current_user={current_user.id}")
        raise BusinessException(str(e), code=BizCode.FORBIDDEN)
    
    try:
        # 获取目标用户
        target_user = user_repository.get_user_by_id(db=db, user_id=target_user_id)
        if not target_user:
            business_logger.warning(f"目标用户不存在: {target_user_id}")
            raise BusinessException("目标用户不存在", code=BizCode.USER_NOT_FOUND)
        
        # 检查租户权限：超管只能修改同租户用户的密码
        if current_user.tenant_id != target_user.tenant_id:
            business_logger.warning(f"跨租户密码修改尝试: admin_tenant={current_user.tenant_id}, target_tenant={target_user.tenant_id}")
            raise BusinessException("不可跨租户修改用户密码", code=BizCode.FORBIDDEN)
        
        # 如果没有提供新密码，则生成随机密码
        actual_password = new_password if new_password else generate_random_password()
        
        # 更新密码
        target_user.hashed_password = get_password_hash(actual_password)
        db.commit()
        db.refresh(target_user)
        
        # 使所有旧 tokens 失效
        await SessionService.invalidate_all_user_tokens(str(target_user_id))
        
        password_type = "指定密码" if new_password else "随机生成密码"
        business_logger.info(f"管理员修改用户密码成功: admin={current_user.username}, target={target_user.username} (ID: {target_user_id}), 类型={password_type}")
        return target_user, actual_password
        
    except Exception as e:
        business_logger.error(f"管理员修改用户密码失败: admin={current_user.id}, target_user={target_user_id} - {str(e)}")
        db.rollback()
        raise BusinessException(f"管理员修改用户密码失败: admin={current_user.id}, target_user={target_user_id} - {str(e)}", code=BizCode.DB_ERROR)


def generate_random_password(length: int = 12) -> str:
    """
    生成随机密码
    
    Args:
        length: 密码长度，默认12位
        
    Returns:
        str: 生成的随机密码
    """
    # 确保密码包含大小写字母、数字和特殊字符
    lowercase = string.ascii_lowercase
    uppercase = string.ascii_uppercase
    digits = string.digits
    special_chars = "!@#$%^&*"
    
    # 确保至少包含每种字符类型
    password = [
        secrets.choice(lowercase),
        secrets.choice(uppercase),
        secrets.choice(digits),
        secrets.choice(special_chars)
    ]
    
    # 填充剩余长度
    all_chars = lowercase + uppercase + digits + special_chars
    for _ in range(length - 4):
        password.append(secrets.choice(all_chars))
    
    # 打乱顺序
    secrets.SystemRandom().shuffle(password)
    
    return ''.join(password)