buff3.0/backend-admin/app/utils/history.py

"""
历史记录工具函数
"""
from datetime import datetime
from app.utils.timezone import beijing_now
from sqlalchemy.orm import Session
from app.models import (
    Admin, AdminHis,
    Announcement, AnnouncementHis,
    APIKey, APIKeyHis,
    APILog, APILogHis,
    Card, CardHis,
    KeyRotationConfig, KeyRotationConfigHis,
    OperationLog, OperationLogHis,
    RechargeRecord, RechargeRecordHis,
    Session, SessionHis,
    Software, SoftwareHis,
    SteamAccount, SteamAccountHis,
    SystemConfig, SystemConfigHis,
    User, UserHis
)


def create_admin_history(db: Session, admin: Admin, operation: str):
    """创建管理员历史记录"""
    his_record = AdminHis(
        id=admin.id,
        username=admin.username,
        password=admin.password,
        real_name=admin.real_name,
        email=admin.email,
        role=admin.role,
        last_login_time=admin.last_login_time,
        last_login_ip=admin.last_login_ip,
        status=admin.status,
        is_deleted=admin.is_deleted,
        created_at=admin.created_at,
        updated_at=admin.updated_at,
        his_created_at=beijing_now(),
        his_operation=operation
    )
    db.add(his_record)


def create_announcement_history(db: Session, announcement: Announcement, operation: str):
    """创建公告历史记录"""
    his_record = AnnouncementHis(
        id=announcement.id,
        title=announcement.title,
        content=announcement.content,
        priority=announcement.priority,
        is_active=announcement.is_active,
        publish_time=announcement.publish_time,
        is_deleted=announcement.is_deleted,
        created_at=announcement.created_at,
        updated_at=announcement.updated_at,
        his_created_at=beijing_now(),
        his_operation=operation
    )
    db.add(his_record)


def create_api_key_history(db: Session, api_key: APIKey, operation: str):
    """创建API密钥历史记录"""
    his_record = APIKeyHis(
        id=api_key.id,
        public_key=api_key.public_key,
        private_key=api_key.private_key,
        key_version=api_key.key_version,
        is_active=api_key.is_active,
        is_deleted=api_key.is_deleted,
        created_at=api_key.created_at,
        expire_at=api_key.expire_at,
        his_created_at=beijing_now(),
        his_operation=operation
    )
    db.add(his_record)


def create_api_log_history(db: Session, api_log: APILog, operation: str):
    """创建API日志历史记录"""
    his_record = APILogHis(
        id=api_log.id,
        user_id=api_log.user_id,
        endpoint=api_log.endpoint,
        method=api_log.method,
        request_data=api_log.request_data,
        response_data=api_log.response_data,
        ip_address=api_log.ip_address,
        user_agent=api_log.user_agent,
        response_code=api_log.response_code,
        execution_time=api_log.execution_time,
        is_deleted=api_log.is_deleted,
        created_at=api_log.created_at,
        his_created_at=beijing_now(),
        his_operation=operation
    )
    db.add(his_record)


def create_card_history(db: Session, card: Card, operation: str):
    """创建卡密历史记录"""
    his_record = CardHis(
        id=card.id,
        card_code=card.card_code,
        software_code=card.software_code,
        days=card.days,
        discount=card.discount,
        user_id=card.user_id,
        activated_at=card.activated_at,
        expire_time=card.expire_time,
        status=card.status,
        is_gift=card.is_gift,
        is_extracted=card.is_extracted,
        special_close=getattr(card, "special_close", 0) or 0,
        issue_price=card.issue_price,
        issued_to=card.issued_to,
        issue_remark=card.issue_remark,
        issued_at=card.issued_at,
        issued_admin_id=card.issued_admin_id,
        remark=card.remark,
        is_deleted=card.is_deleted,
        is_revoked=getattr(card, "is_revoked", 0) or 0,
        revoked_at=getattr(card, "revoked_at", None),
        revoked_reason=getattr(card, "revoked_reason", None),
        revoked_admin_id=getattr(card, "revoked_admin_id", None),
        created_at=card.created_at,
        updated_at=card.updated_at,
        his_created_at=beijing_now(),
        his_operation=operation
    )
    db.add(his_record)


def create_key_rotation_config_history(db: Session, config: KeyRotationConfig, operation: str):
    """创建密钥轮换配置历史记录"""
    his_record = KeyRotationConfigHis(
        id=config.id,
        rotation_days=config.rotation_days,
        is_auto_rotate=config.is_auto_rotate,
        last_rotation_time=config.last_rotation_time,
        next_rotation_time=config.next_rotation_time,
        is_deleted=config.is_deleted,
        updated_at=config.updated_at,
        his_created_at=beijing_now(),
        his_operation=operation
    )
    db.add(his_record)


def create_operation_log_history(db: Session, operation_log: OperationLog, operation: str):
    """创建操作日志历史记录"""
    his_record = OperationLogHis(
        id=operation_log.id,
        admin_id=operation_log.admin_id,
        module=operation_log.module,
        action=operation_log.action,
        description=operation_log.description,
        old_data=operation_log.old_data,
        new_data=operation_log.new_data,
        ip_address=operation_log.ip_address,
        is_deleted=operation_log.is_deleted,
        created_at=operation_log.created_at,
        his_created_at=beijing_now(),
        his_operation=operation
    )
    db.add(his_record)


def create_recharge_record_history(db: Session, recharge_record: RechargeRecord, operation: str):
    """创建充值记录历史记录"""
    his_record = RechargeRecordHis(
        id=recharge_record.id,
        user_id=recharge_record.user_id,
        card_id=recharge_record.card_id,
        software_code=recharge_record.software_code,
        days=recharge_record.days,
        amount=recharge_record.amount,
        expire_time_before=recharge_record.expire_time_before,
        expire_time_after=recharge_record.expire_time_after,
        is_deleted=recharge_record.is_deleted,
        created_at=recharge_record.created_at,
        his_created_at=beijing_now(),
        his_operation=operation
    )
    db.add(his_record)


def create_software_history(db: Session, software: Software, operation: str):
    """创建软件历史记录"""
    his_record = SoftwareHis(
        id=software.id,
        code=software.code,
        name=software.name,
        description=software.description,
        daily_price=software.daily_price,
        is_active=software.is_active,
        is_deleted=software.is_deleted,
        created_at=software.created_at,
        updated_at=software.updated_at,
        his_created_at=beijing_now(),
        his_operation=operation
    )
    db.add(his_record)


def create_session_history(db: Session, session: Session, operation: str):
    """创建会话历史记录（先写 his 再改/删时调用，operation 仅用于语义）"""
    his_record = SessionHis(
        session_id=session.session_id,
        user_id=session.user_id,
        machine_code=session.machine_code,
        ip_address=session.ip_address,
        user_agent=session.user_agent,
        is_active=session.is_active,
        expires_at=session.expires_at,
        created_at=session.created_at,
        updated_at=session.updated_at,
        last_activity=session.last_activity,
    )
    db.add(his_record)


def create_steam_account_history(db: Session, steam_account: SteamAccount, operation: str):
    """创建Steam账号历史记录"""
    his_record = SteamAccountHis(
        id=steam_account.id,
        user_id=steam_account.user_id,
        steam_username=steam_account.steam_username,
        steam_id=steam_account.steam_id,
        is_active=steam_account.is_active,
        is_deleted=steam_account.is_deleted,
        created_at=steam_account.created_at,
        updated_at=steam_account.updated_at,
        his_created_at=beijing_now(),
        his_operation=operation
    )
    db.add(his_record)


def create_system_config_history(db: Session, config: SystemConfig, operation: str):
    """创建系统配置历史记录（先写 his 再改/删时调用）"""
    his_record = SystemConfigHis(
        id=config.id,
        config_key=config.config_key,
        config_value=config.config_value,
        config_type=config.config_type,
        app_name=config.app_name,
        description=config.description,
        is_system=config.is_system,
        is_editable=config.is_editable,
        is_deleted=config.is_deleted,
        created_at=config.created_at,
        updated_at=config.updated_at,
        his_created_at=beijing_now(),
        his_operation=operation
    )
    db.add(his_record)


def create_user_history(db: Session, user: User, operation: str):
    """创建用户历史记录"""
    his_record = UserHis(
        id=user.id,
        username=user.username,
        password=user.password,
        email=user.email,
        machine_code=user.machine_code,
        card_id=user.card_id,
        expire_time=user.expire_time,
        last_login_time=user.last_login_time,
        last_login_ip=user.last_login_ip,
        status=user.status,
        is_deleted=user.is_deleted,
        created_at=user.created_at,
        updated_at=user.updated_at,
        his_created_at=beijing_now(),
        his_operation=operation
    )
    db.add(his_record)


def create_operation_log(
    db: Session,
    admin_id: int,
    module: str,
    action: str,
    description: str,
    old_data: dict = None,
    new_data: dict = None,
    ip_address: str = None
):
    """创建操作日志记录"""
    import json
    from datetime import datetime
    # beijing_now already imported at module level
    operation_log = OperationLog(
        admin_id=admin_id,
        module=module,
        action=action,
        description=description,
        old_data=json.dumps(old_data, ensure_ascii=False) if old_data else None,
        new_data=json.dumps(new_data, ensure_ascii=False) if new_data else None,
        ip_address=ip_address,
        created_at=beijing_now()
    )
    db.add(operation_log)