photowall/go/internal/handler/admin_handler.go

package handler

import (
	"photowall/internal/database"
	"photowall/internal/middleware"
	"photowall/internal/service"
	"photowall/pkg/response"
	"photowall/pkg/sensitive"
	"strconv"

	"github.com/gin-gonic/gin"
)

type AdminHandler struct {
	svc *service.AdminService
}

func NewAdminHandler(svc *service.AdminService) *AdminHandler {
	return &AdminHandler{svc: svc}
}

// Stats GET /api/admin/stats
func (h *AdminHandler) Stats(c *gin.Context) {
	stats, err := h.svc.Stats()
	if err != nil {
		response.Internal(c, err.Error())
		return
	}
	response.OK(c, stats)
}

// DetailedStats GET /api/admin/stats/detailed 详细数据统计（仪表盘用）
func (h *AdminHandler) DetailedStats(c *gin.Context) {
	stats, err := h.svc.DetailedStats()
	if err != nil {
		response.Internal(c, err.Error())
		return
	}
	response.OK(c, stats)
}

// AuditQueue GET /api/admin/classes
func (h *AdminHandler) AuditQueue(c *gin.Context) {
	var req service.AuditQueueReq
	if err := c.ShouldBindQuery(&req); err != nil {
		response.BadRequest(c, "参数错误")
		return
	}
	result, err := h.svc.ListAuditQueue(&req)
	if err != nil {
		response.Internal(c, err.Error())
		return
	}
	response.OK(c, result)
}

// Approve POST /api/admin/classes/:id/approve
func (h *AdminHandler) Approve(c *gin.Context) {
	auditorID := middleware.CurrentUserID(c)
	id, _ := strconv.ParseUint(c.Param("id"), 10, 64)
	var body struct {
		Reason string `json:"reason"`
	}
	c.ShouldBindJSON(&body)
	if err := h.svc.Approve(uint(id), auditorID, body.Reason); err != nil {
		response.BadRequest(c, err.Error())
		return
	}
	response.OK(c, gin.H{"message": "已通过审核"})
}

// Reject POST /api/admin/classes/:id/reject
func (h *AdminHandler) Reject(c *gin.Context) {
	auditorID := middleware.CurrentUserID(c)
	id, _ := strconv.ParseUint(c.Param("id"), 10, 64)
	var body struct {
		Reason string `json:"reason" binding:"required"`
	}
	if err := c.ShouldBindJSON(&body); err != nil {
		response.BadRequest(c, "请填写打回原因")
		return
	}
	if err := h.svc.Reject(uint(id), auditorID, body.Reason); err != nil {
		response.BadRequest(c, err.Error())
		return
	}
	response.OK(c, gin.H{"message": "已打回，等待用户补齐"})
}

// Delete DELETE /api/admin/classes/:id
func (h *AdminHandler) Delete(c *gin.Context) {
	auditorID := middleware.CurrentUserID(c)
	id, _ := strconv.ParseUint(c.Param("id"), 10, 64)
	var body struct {
		Reason string `json:"reason"`
	}
	c.ShouldBindJSON(&body)
	if err := h.svc.ManualDelete(uint(id), auditorID, body.Reason); err != nil {
		response.BadRequest(c, err.Error())
		return
	}
	response.OK(c, gin.H{"message": "已删除"})
}

// AuditLogs GET /api/admin/classes/:id/logs
func (h *AdminHandler) AuditLogs(c *gin.Context) {
	id, _ := strconv.ParseUint(c.Param("id"), 10, 64)
	logs, err := h.svc.AuditLogs(uint(id))
	if err != nil {
		response.Internal(c, err.Error())
		return
	}
	response.OK(c, logs)
}

// TriggerCleanup POST /api/admin/cleanup 手动触发过期清理（也可由定时任务自动执行）
func (h *AdminHandler) TriggerCleanup(c *gin.Context) {
	count, err := h.svc.CleanupExpired()
	if err != nil {
		response.Internal(c, err.Error())
		return
	}
	response.OK(c, gin.H{"deleted": count, "message": "清理完成"})
}

// ============ 账号封禁管理 ============

// BanUser POST /api/admin/users/:id/ban 封禁用户
func (h *AdminHandler) BanUser(c *gin.Context) {
	adminID := middleware.CurrentUserID(c)
	id, _ := strconv.ParseUint(c.Param("id"), 10, 64)
	var body struct {
		Reason string `json:"reason" binding:"required"`
	}
	if err := c.ShouldBindJSON(&body); err != nil {
		response.BadRequest(c, "请填写封禁原因")
		return
	}
	req := &service.BanUserReq{UserID: uint(id), Reason: body.Reason}
	if err := h.svc.BanUser(req, adminID); err != nil {
		response.BadRequest(c, err.Error())
		return
	}
	response.OK(c, gin.H{"message": "已封禁"})
}

// UnbanUser POST /api/admin/users/:id/unban 解封用户
func (h *AdminHandler) UnbanUser(c *gin.Context) {
	id, _ := strconv.ParseUint(c.Param("id"), 10, 64)
	if err := h.svc.UnbanUser(uint(id)); err != nil {
		response.BadRequest(c, err.Error())
		return
	}
	response.OK(c, gin.H{"message": "已解封"})
}

// BannedUsers GET /api/admin/users/banned 封禁用户列表
func (h *AdminHandler) BannedUsers(c *gin.Context) {
	list, err := h.svc.ListBannedUsers()
	if err != nil {
		response.Internal(c, err.Error())
		return
	}
	response.OK(c, list)
}

// ============ 敏感词管理 ============

// SensitiveWords GET /api/admin/sensitive-words 敏感词列表
func (h *AdminHandler) SensitiveWords(c *gin.Context) {
	list, err := h.svc.ListSensitiveWords()
	if err != nil {
		response.Internal(c, err.Error())
		return
	}
	response.OK(c, list)
}

// AddSensitiveWord POST /api/admin/sensitive-words 添加敏感词
func (h *AdminHandler) AddSensitiveWord(c *gin.Context) {
	var body struct {
		Word     string `json:"word" binding:"required"`
		Category string `json:"category"`
	}
	if err := c.ShouldBindJSON(&body); err != nil {
		response.BadRequest(c, "请填写敏感词")
		return
	}
	if body.Category == "" {
		body.Category = "other"
	}
	sw, err := h.svc.AddSensitiveWord(body.Word, body.Category)
	if err != nil {
		response.BadRequest(c, err.Error())
		return
	}
	// 重新加载敏感词过滤器
	sensitive.Reload(database.DB)
	response.Created(c, sw)
}

// DeleteSensitiveWord DELETE /api/admin/sensitive-words/:id 删除敏感词
func (h *AdminHandler) DeleteSensitiveWord(c *gin.Context) {
	id, _ := strconv.ParseUint(c.Param("id"), 10, 64)
	if err := h.svc.DeleteSensitiveWord(uint(id)); err != nil {
		response.BadRequest(c, err.Error())
		return
	}
	sensitive.Reload(database.DB)
	response.OK(c, gin.H{"message": "已删除"})
}

// ToggleSensitiveWord PUT /api/admin/sensitive-words/:id/toggle 启用/禁用
func (h *AdminHandler) ToggleSensitiveWord(c *gin.Context) {
	id, _ := strconv.ParseUint(c.Param("id"), 10, 64)
	var body struct {
		Enabled bool `json:"enabled"`
	}
	c.ShouldBindJSON(&body)
	if err := h.svc.ToggleSensitiveWord(uint(id), body.Enabled); err != nil {
		response.BadRequest(c, err.Error())
		return
	}
	sensitive.Reload(database.DB)
	response.OK(c, gin.H{"message": "已更新"})
}