tyapi-server/internal/infrastructure/http/handlers/admin_handler.go

package handlers

import (
	"github.com/gin-gonic/gin"
	"go.uber.org/zap"

	"tyapi-server/internal/application/admin"
	"tyapi-server/internal/application/admin/dto/commands"
	"tyapi-server/internal/application/admin/dto/queries"
	"tyapi-server/internal/shared/interfaces"
)

// AdminHandler 管理员HTTP处理器
type AdminHandler struct {
	appService      admin.AdminApplicationService
	responseBuilder interfaces.ResponseBuilder
	logger          *zap.Logger
}

// NewAdminHandler 创建管理员HTTP处理器
func NewAdminHandler(
	appService admin.AdminApplicationService,
	responseBuilder interfaces.ResponseBuilder,
	logger *zap.Logger,
) *AdminHandler {
	return &AdminHandler{
		appService:      appService,
		responseBuilder: responseBuilder,
		logger:          logger,
	}
}

// Login 管理员登录
// @Summary 管理员登录
// @Description 使用用户名和密码进行管理员登录，返回JWT令牌
// @Tags 管理员认证
// @Accept json
// @Produce json
// @Param request body commands.AdminLoginCommand true "管理员登录请求"
// @Success 200 {object} responses.AdminLoginResponse "登录成功"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "用户名或密码错误"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/auth/login [post]
func (h *AdminHandler) Login(c *gin.Context) {
	var cmd commands.AdminLoginCommand
	if err := c.ShouldBindJSON(&cmd); err != nil {
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	response, err := h.appService.Login(c.Request.Context(), &cmd)
	if err != nil {
		h.logger.Error("管理员登录失败", zap.Error(err))
		h.responseBuilder.Unauthorized(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, response, "登录成功")
}

// CreateAdmin 创建管理员
// @Summary 创建管理员
// @Description 创建新的管理员账户，需要超级管理员权限
// @Tags 管理员管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param request body commands.CreateAdminCommand true "创建管理员请求"
// @Success 201 {object} map[string]interface{} "管理员创建成功"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 403 {object} map[string]interface{} "权限不足"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin [post]
func (h *AdminHandler) CreateAdmin(c *gin.Context) {
	var cmd commands.CreateAdminCommand
	if err := c.ShouldBindJSON(&cmd); err != nil {
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}
	cmd.OperatorID = h.getCurrentAdminID(c)

	if err := h.appService.CreateAdmin(c.Request.Context(), &cmd); err != nil {
		h.logger.Error("创建管理员失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

	h.responseBuilder.Created(c, nil, "管理员创建成功")
}

// UpdateAdmin 更新管理员
// @Summary 更新管理员信息
// @Description 更新指定管理员的基本信息
// @Tags 管理员管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path string true "管理员ID"
// @Param request body commands.UpdateAdminCommand true "更新管理员请求"
// @Success 200 {object} map[string]interface{} "管理员更新成功"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 403 {object} map[string]interface{} "权限不足"
// @Failure 404 {object} map[string]interface{} "管理员不存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/{id} [put]
func (h *AdminHandler) UpdateAdmin(c *gin.Context) {
	var cmd commands.UpdateAdminCommand
	if err := c.ShouldBindJSON(&cmd); err != nil {
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}
	cmd.AdminID = c.Param("id")
	cmd.OperatorID = h.getCurrentAdminID(c)

	if err := h.appService.UpdateAdmin(c.Request.Context(), &cmd); err != nil {
		h.logger.Error("更新管理员失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, nil, "管理员更新成功")
}

// ChangePassword 修改密码
// @Summary 修改管理员密码
// @Description 修改当前登录管理员的密码
// @Tags 管理员管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param request body commands.ChangeAdminPasswordCommand true "修改密码请求"
// @Success 200 {object} map[string]interface{} "密码修改成功"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/change-password [post]
func (h *AdminHandler) ChangePassword(c *gin.Context) {
	var cmd commands.ChangeAdminPasswordCommand
	if err := c.ShouldBindJSON(&cmd); err != nil {
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}
	cmd.AdminID = h.getCurrentAdminID(c)

	if err := h.appService.ChangePassword(c.Request.Context(), &cmd); err != nil {
		h.logger.Error("修改密码失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, nil, "密码修改成功")
}

// ListAdmins 获取管理员列表
// @Summary 获取管理员列表
// @Description 分页获取管理员列表，支持搜索和筛选
// @Tags 管理员管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param page query int false "页码" default(1)
// @Param size query int false "每页数量" default(10)
// @Param keyword query string false "搜索关键词"
// @Param status query string false "状态筛选"
// @Success 200 {object} responses.AdminListResponse "获取管理员列表成功"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin [get]
func (h *AdminHandler) ListAdmins(c *gin.Context) {
	var query queries.ListAdminsQuery
	if err := c.ShouldBindQuery(&query); err != nil {
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	response, err := h.appService.ListAdmins(c.Request.Context(), &query)
	if err != nil {
		h.logger.Error("获取管理员列表失败", zap.Error(err))
		h.responseBuilder.InternalError(c, "获取管理员列表失败")
		return
	}

	h.responseBuilder.Success(c, response, "获取管理员列表成功")
}

// GetAdminByID 根据ID获取管理员
// @Summary 获取管理员详情
// @Description 根据管理员ID获取详细信息
// @Tags 管理员管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path string true "管理员ID"
// @Success 200 {object} responses.AdminInfoResponse "获取管理员详情成功"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 404 {object} map[string]interface{} "管理员不存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/{id} [get]
func (h *AdminHandler) GetAdminByID(c *gin.Context) {
	var query queries.GetAdminInfoQuery
	if err := c.ShouldBindUri(&query); err != nil {
		h.responseBuilder.BadRequest(c, "请求参数错误")
		return
	}

	admin, err := h.appService.GetAdminByID(c.Request.Context(), &query)
	if err != nil {
		h.logger.Error("获取管理员详情失败", zap.Error(err))
		h.responseBuilder.NotFound(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, admin, "获取管理员详情成功")
}

// DeleteAdmin 删除管理员
// @Summary 删除管理员
// @Description 删除指定的管理员账户
// @Tags 管理员管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path string true "管理员ID"
// @Success 200 {object} map[string]interface{} "管理员删除成功"
// @Failure 400 {object} map[string]interface{} "请求参数错误"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 403 {object} map[string]interface{} "权限不足"
// @Failure 404 {object} map[string]interface{} "管理员不存在"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/{id} [delete]
func (h *AdminHandler) DeleteAdmin(c *gin.Context) {
	var cmd commands.DeleteAdminCommand
	cmd.AdminID = c.Param("id")
	cmd.OperatorID = h.getCurrentAdminID(c)

	if err := h.appService.DeleteAdmin(c.Request.Context(), &cmd); err != nil {
		h.logger.Error("删除管理员失败", zap.Error(err))
		h.responseBuilder.BadRequest(c, err.Error())
		return
	}

	h.responseBuilder.Success(c, nil, "管理员删除成功")
}

// GetAdminStats 获取管理员统计信息
// @Summary 获取管理员统计信息
// @Description 获取管理员相关的统计数据
// @Tags 管理员管理
// @Accept json
// @Produce json
// @Security Bearer
// @Success 200 {object} responses.AdminStatsResponse "获取统计信息成功"
// @Failure 401 {object} map[string]interface{} "未认证"
// @Failure 500 {object} map[string]interface{} "服务器内部错误"
// @Router /api/v1/admin/stats [get]
func (h *AdminHandler) GetAdminStats(c *gin.Context) {
	stats, err := h.appService.GetAdminStats(c.Request.Context())
	if err != nil {
		h.logger.Error("获取管理员统计失败", zap.Error(err))
		h.responseBuilder.InternalError(c, "获取统计信息失败")
		return
	}

	h.responseBuilder.Success(c, stats, "获取统计信息成功")
}

// getCurrentAdminID 获取当前管理员ID
func (h *AdminHandler) getCurrentAdminID(c *gin.Context) string {
	if userID, exists := c.Get("user_id"); exists {
		if id, ok := userID.(string); ok {
			return id
		}
	}
	return ""
}