SeeyonFileSystem/server/controller/admin_controller.go

package controller

import (
	"strconv"

	"seeyon-filesystem/dto"
	"seeyon-filesystem/model"
	"seeyon-filesystem/service"
	"seeyon-filesystem/utils"

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

// AdminController 管理后台控制器
type AdminController struct {
	adminService   *service.AdminService
	storageService *service.StorageTestService
}

func NewAdminController() *AdminController {
	return &AdminController{
		adminService:   service.NewAdminService(),
		storageService: service.NewStorageTestService(),
	}
}

// ========== 用户管理 ==========

// ListUsers 用户列表
// GET /api/admin/users?page=1&size=20
func (c *AdminController) ListUsers(ctx *gin.Context) {
	page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
	size, _ := strconv.Atoi(ctx.DefaultQuery("size", "20"))
	if page < 1 { page = 1 }
	if size < 1 || size > 100 { size = 20 }

	users, total, err := c.adminService.ListUsers(page, size)
	if err != nil {
		utils.ServerError(ctx, "查询用户失败")
		return
	}
	utils.PageSuccess(ctx, users, total, page, size)
}

// CreateUser 创建用户
// POST /api/admin/users
func (c *AdminController) CreateUser(ctx *gin.Context) {
	var req dto.UserCreateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	if err := c.adminService.CreateUser(&req); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "用户创建成功", nil)
}

// UpdateUser 更新用户
// PUT /api/admin/users/:id
func (c *AdminController) UpdateUser(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的用户ID")
		return
	}

	var req dto.UserUpdateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	if err := c.adminService.UpdateUser(id, &req); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "更新成功", nil)
}

// DeleteUser 删除用户
// DELETE /api/admin/users/:id
func (c *AdminController) DeleteUser(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的用户ID")
		return
	}

	if err := c.adminService.DeleteUser(id); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "删除成功", nil)
}

// ResetPassword 重置密码
// PUT /api/admin/users/:id/password
func (c *AdminController) ResetPassword(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的用户ID")
		return
	}

	var req struct {
		Password string `json:"password" binding:"required,min=6"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	if err := c.adminService.ResetPassword(id, req.Password); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "密码重置成功", nil)
}

// ========== 存储策略管理 ==========

// ListStoragePolicies 存储策略列表
// GET /api/admin/storage-policies
func (c *AdminController) ListStoragePolicies(ctx *gin.Context) {
	policies, err := c.adminService.ListStoragePolicies()
	if err != nil {
		utils.ServerError(ctx, "查询失败")
		return
	}
	utils.Success(ctx, policies)
}

// CreateStoragePolicy 创建存储策略
// POST /api/admin/storage-policies
func (c *AdminController) CreateStoragePolicy(ctx *gin.Context) {
	var req dto.StoragePolicyCreateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	if err := c.adminService.CreateStoragePolicy(&req); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "创建成功", nil)
}

// UpdateStoragePolicy 更新存储策略
// PUT /api/admin/storage-policies/:id
func (c *AdminController) UpdateStoragePolicy(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的策略ID")
		return
	}

	var req dto.StoragePolicyUpdateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	if err := c.adminService.UpdateStoragePolicy(id, &req); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "更新成功", nil)
}

// DeleteStoragePolicy 删除存储策略
// DELETE /api/admin/storage-policies/:id
func (c *AdminController) DeleteStoragePolicy(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的策略ID")
		return
	}

	if err := c.adminService.DeleteStoragePolicy(id); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "删除成功", nil)
}

// TestStoragePolicy 测试存储策略连通性
// POST /api/admin/storage-policies/:id/test
func (c *AdminController) TestStoragePolicy(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的策略ID")
		return
	}

	result, err := c.storageService.TestPolicy(id)
	if err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.Success(ctx, result)
}

// TestNewStoragePolicy 测试新配置(未保存)
// POST /api/admin/storage-policies/test
func (c *AdminController) TestNewStoragePolicy(ctx *gin.Context) {
	var req struct {
		Type   string                      `json:"type" binding:"required"`
		Config dto.PolicyConfigDTO         `json:"config" binding:"required"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	cfg := model.PolicyConfig{
		BasePath:  req.Config.BasePath,
		Endpoint:  req.Config.Endpoint,
		Bucket:    req.Config.Bucket,
		AccessKey: req.Config.AccessKey,
		SecretKey: req.Config.SecretKey,
		Region:    req.Config.Region,
		UseSSL:    req.Config.UseSSL,
	}

	result := c.storageService.TestNewPolicy(req.Type, cfg)
	utils.Success(ctx, result)
}

// ========== 组织架构管理 ==========

// ListDepartments 部门列表(树形)
// GET /api/admin/departments
func (c *AdminController) ListDepartments(ctx *gin.Context) {
	depts, err := c.adminService.ListDepartments()
	if err != nil {
		utils.ServerError(ctx, "查询失败")
		return
	}
	utils.Success(ctx, depts)
}

// CreateDepartment 创建部门
// POST /api/admin/departments
func (c *AdminController) CreateDepartment(ctx *gin.Context) {
	var req dto.DeptCreateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	if err := c.adminService.CreateDepartment(&req); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "创建成功", nil)
}

// UpdateDepartment 更新部门
// PUT /api/admin/departments/:id
func (c *AdminController) UpdateDepartment(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的部门ID")
		return
	}

	var req dto.DeptUpdateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.BadRequest(ctx, "参数错误: "+err.Error())
		return
	}

	if err := c.adminService.UpdateDepartment(id, &req); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "更新成功", nil)
}

// DeleteDepartment 删除部门
// DELETE /api/admin/departments/:id
func (c *AdminController) DeleteDepartment(ctx *gin.Context) {
	id, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		utils.BadRequest(ctx, "无效的部门ID")
		return
	}

	if err := c.adminService.DeleteDepartment(id); err != nil {
		utils.BadRequest(ctx, err.Error())
		return
	}
	utils.SuccessWithMessage(ctx, "删除成功", nil)
}