nanocode/new-media-platform/website-new/backend/app/routers/home_modules.py

# app/routers/home_modules.py
import json
from typing import List, Optional
from fastapi import APIRouter, Depends, HTTPException
from pydantic import BaseModel
from sqlalchemy.orm import Session

from app.database import get_db
from app.models.home_module import HomeModule
from app.models.admin import Admin
from app.auth import get_current_admin

router = APIRouter()


# Schemas
class ModuleContent(BaseModel):
    pass


class ModuleStyleConfig(BaseModel):
    pass


class ModuleUpdate(BaseModel):
    title: Optional[str] = None
    subtitle: Optional[str] = None
    content: Optional[dict] = None
    style_config: Optional[dict] = None
    is_enabled: Optional[bool] = None
    sort_order: Optional[int] = None


class ModuleSortItem(BaseModel):
    id: int
    sort_order: int


class ModuleSortRequest(BaseModel):
    orders: List[ModuleSortItem]


class ModuleResponse(BaseModel):
    code: int = 200
    data: dict | list = None


# Helper functions
def module_to_dict(module: HomeModule) -> dict:
    return {
        "id": module.id,
        "name": module.name,
        "code": module.code,
        "type": module.type,
        "sort_order": module.sort_order,
        "is_enabled": module.is_enabled,
        "is_fixed": module.is_fixed,
        "title": module.title,
        "subtitle": module.subtitle,
        "content": json.loads(module.content) if module.content else {},
        "style_config": json.loads(module.style_config) if module.style_config else {}
    }


# Public routes
@router.get("/home/modules", response_model=ModuleResponse)
def get_public_modules(db: Session = Depends(get_db)):
    """Get all enabled home modules for public display"""
    modules = db.query(HomeModule).filter(
        HomeModule.is_enabled == True
    ).order_by(HomeModule.sort_order.asc()).all()
    
    return ModuleResponse(data=[module_to_dict(m) for m in modules])


# Admin routes
@router.get("/admin/home/modules", response_model=ModuleResponse)
def get_admin_modules(
    db: Session = Depends(get_db),
    current_admin: Admin = Depends(get_current_admin)
):
    """Get all home modules for admin management"""
    modules = db.query(HomeModule).order_by(HomeModule.sort_order.asc()).all()
    
    # Auto-create missing default modules
    existing_types = {m.type for m in modules}
    if 'experts' not in existing_types:
        expert_module = HomeModule(
            name="专家团队",
            code="experts",
            type="experts",
            sort_order=7,
            is_enabled=True,
            is_fixed=False,
            title="专家团队",
            content=json.dumps({"view_more_link": ""}),
            style_config=json.dumps({"backgroundColor": "#ffffff"})
        )
        db.add(expert_module)
        db.commit()
        db.refresh(expert_module)
        modules = db.query(HomeModule).order_by(HomeModule.sort_order.asc()).all()
    
    return ModuleResponse(data=[module_to_dict(m) for m in modules])


@router.get("/admin/home/modules/{module_id}", response_model=ModuleResponse)
def get_module_detail(
    module_id: int,
    db: Session = Depends(get_db),
    current_admin: Admin = Depends(get_current_admin)
):
    """Get single module detail"""
    module = db.query(HomeModule).filter(HomeModule.id == module_id).first()
    if not module:
        raise HTTPException(status_code=404, detail="Module not found")
    return ModuleResponse(data=module_to_dict(module))


@router.put("/admin/home/modules/{module_id}", response_model=ModuleResponse)
def update_module(
    module_id: int,
    request: ModuleUpdate,
    db: Session = Depends(get_db),
    current_admin: Admin = Depends(get_current_admin)
):
    """Update module content and settings"""
    module = db.query(HomeModule).filter(HomeModule.id == module_id).first()
    if not module:
        raise HTTPException(status_code=404, detail="Module not found")
    
    if request.title is not None:
        module.title = request.title
    if request.subtitle is not None:
        module.subtitle = request.subtitle
    if request.content is not None:
        module.content = json.dumps(request.content, ensure_ascii=False)
    if request.style_config is not None:
        module.style_config = json.dumps(request.style_config, ensure_ascii=False)
    if request.is_enabled is not None:
        module.is_enabled = request.is_enabled
    if request.sort_order is not None:
        module.sort_order = request.sort_order
    
    db.commit()
    db.refresh(module)
    
    return ModuleResponse(message="更新成功", data=module_to_dict(module))


@router.put("/admin/home/modules/sort", response_model=ModuleResponse)
def update_module_sort(
    request: ModuleSortRequest,
    db: Session = Depends(get_db),
    current_admin: Admin = Depends(get_current_admin)
):
    """Batch update module sort order"""
    for item in request.orders:
        module = db.query(HomeModule).filter(HomeModule.id == item.id).first()
        if module:
            module.sort_order = item.sort_order
    
    db.commit()
    return ModuleResponse(message="排序更新成功")


@router.put("/admin/home/modules/{module_id}/toggle", response_model=ModuleResponse)
def toggle_module(
    module_id: int,
    db: Session = Depends(get_db),
    current_admin: Admin = Depends(get_current_admin)
):
    """Toggle module enabled status"""
    module = db.query(HomeModule).filter(HomeModule.id == module_id).first()
    if not module:
        raise HTTPException(status_code=404, detail="Module not found")
    
    module.is_enabled = not module.is_enabled
    db.commit()
    
    return ModuleResponse(
        message="状态更新成功",
        data={"id": module.id, "is_enabled": module.is_enabled}
    )