nl_cms-api/internal/service/admin.go

package service

import (
	"context"
	"cms-api/internal/dao"
	"cms-api/internal/model"

	"github.com/gogf/gf/v2/crypto/gmd5"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"
	"github.com/gogf/gf/v2/util/gconv"
)

type sAdmin struct{}

func Admin() *sAdmin {
	return &sAdmin{}
}

// Login 管理员登录
func (s *sAdmin) Login(ctx context.Context, req *model.LoginRequest) (*model.LoginResponse, error) {
	// 查询管理员
	admin := &model.Admin{}
	err := dao.Admin.Ctx(ctx).Where("username", req.Username).Where("deleted_at", 0).Scan(admin)
	if err != nil {
		return nil, err
	}
	if admin.Id == 0 {
		return nil, gerror.New("用户名或密码错误")
	}

	// 验证密码
	if !s.VerifyPassword(req.Password, admin.Password) {
		return nil, gerror.New("用户名或密码错误")
	}

	// 检查状态
	if admin.Status != 1 {
		return nil, gerror.New("账号已被禁用")
	}

	// 更新登录信息
	_, err = dao.Admin.Ctx(ctx).Where("id", admin.Id).Update(g.Map{
		"last_login_at": gtime.Now().Unix(),
		"last_login_ip": g.RequestFromCtx(ctx).GetClientIp(),
		"updated_at":    gtime.Now(),
	})
	if err != nil {
		g.Log().Error(ctx, "更新登录信息失败:", err)
	}

	// 生成token
	token, err := Auth.GenerateToken(ctx, uint64(admin.Id))
	if err != nil {
		return nil, err
	}

	// 清除密码字段
	admin.Password = ""

	return &model.LoginResponse{
		Token: token,
		Admin: admin,
	}, nil
}

// GetById 根据ID获取管理员信息
func (s *sAdmin) GetById(ctx context.Context, id int) (*model.Admin, error) {
	admin := &model.Admin{}
	err := dao.Admin.Ctx(ctx).Where("id", id).Where("deleted_at", 0).Scan(admin)
	if err != nil {
		return nil, err
	}
	if admin.Id == 0 {
		return nil, nil
	}
	// 清除密码字段
	admin.Password = ""
	return admin, nil
}

// List 获取管理员列表
func (s *sAdmin) List(ctx context.Context, req *model.ListRequest) (*model.PageResponse, error) {
	var (
		page     = req.Page
		pageSize = req.PageSize
		keyword  = req.Keyword
	)

	if page <= 0 {
		page = 1
	}
	if pageSize <= 0 {
		pageSize = 10
	}

	query := dao.Admin.Ctx(ctx).Where("deleted_at", 0)

	// 关键词搜索
	if keyword != "" {
		query = query.WhereOr("username LIKE ?", "%"+keyword+"%").
			WhereOr("real_name LIKE ?", "%"+keyword+"%").
			WhereOr("email LIKE ?", "%"+keyword+"%")
	}

	// 状态筛选
	if req.Status >= 0 {
		query = query.Where("status", req.Status)
	}

	// 获取总数
	total, err := query.Count()
	if err != nil {
		return nil, err
	}

	// 获取列表
	var admins []*model.Admin
	err = query.Page(page, pageSize).OrderDesc("id").Scan(&admins)
	if err != nil {
		return nil, err
	}

	// 清除密码字段
	for _, admin := range admins {
		admin.Password = ""
	}

	return &model.PageResponse{
		List:       admins,
		Total:      total,
		Page:       page,
		PageSize:   pageSize,
		TotalPages: (total + pageSize - 1) / pageSize,
	}, nil
}

// Create 创建管理员
func (s *sAdmin) Create(ctx context.Context, req *model.CreateAdminRequest) error {
	// 检查用户名是否存在
	count, err := dao.Admin.Ctx(ctx).Where("username", req.Username).Where("deleted_at", 0).Count()
	if err != nil {
		return err
	}
	if count > 0 {
		return gerror.New("用户名已存在")
	}

	// 检查邮箱是否存在
	count, err = dao.Admin.Ctx(ctx).Where("email", req.Email).Where("deleted_at", 0).Count()
	if err != nil {
		return err
	}
	if count > 0 {
		return gerror.New("邮箱已存在")
	}

	// 加密密码
	hashedPassword := s.HashPassword(req.Password)

	// 创建管理员
	_, err = dao.Admin.Ctx(ctx).Insert(g.Map{
		"username":   req.Username,
		"password":   hashedPassword,
		"real_name":  req.RealName,
		"email":      req.Email,
		"phone":      req.Phone,
		"role_id":    req.RoleId,
		"status":     1,
		"created_at": gtime.Now(),
		"updated_at": gtime.Now(),
	})

	return err
}

// Update 更新管理员
func (s *sAdmin) Update(ctx context.Context, id int, req *model.UpdateAdminRequest) error {
	// 检查管理员是否存在
	admin, err := s.GetById(ctx, id)
	if err != nil {
		return err
	}
	if admin == nil {
		return gerror.New("管理员不存在")
	}

	// 检查邮箱是否被其他管理员使用
	count, err := dao.Admin.Ctx(ctx).Where("email", req.Email).Where("id !=", id).Where("deleted_at", 0).Count()
	if err != nil {
		return err
	}
	if count > 0 {
		return gerror.New("邮箱已被使用")
	}

	// 更新管理员
	_, err = dao.Admin.Ctx(ctx).Where("id", id).Update(g.Map{
		"real_name":  req.RealName,
		"email":      req.Email,
		"phone":      req.Phone,
		"role_id":    req.RoleId,
		"status":     req.Status,
		"updated_at": gtime.Now(),
	})

	return err
}

// Delete 删除管理员
func (s *sAdmin) Delete(ctx context.Context, id int) error {
	// 检查管理员是否存在
	admin, err := s.GetById(ctx, id)
	if err != nil {
		return err
	}
	if admin == nil {
		return gerror.New("管理员不存在")
	}

	// 软删除
	_, err = dao.Admin.Ctx(ctx).Where("id", id).Update(g.Map{
		"deleted_at": gtime.Now().Unix(),
		"updated_at": gtime.Now(),
	})

	return err
}

// HashPassword 加密密码
func (s *sAdmin) HashPassword(password string) string {
	return gmd5.MustEncrypt(password + "cms_salt_2024")
}

// VerifyPassword 验证密码
func (s *sAdmin) VerifyPassword(password, hashedPassword string) bool {
	return gmd5.MustEncrypt(password+"cms_salt_2024") == hashedPassword
}

// Profile 获取当前管理员信息
func (s *sAdmin) Profile(ctx context.Context) (*model.Admin, error) {
	adminId := gconv.Int(g.RequestFromCtx(ctx).GetCtxVar("admin_id"))
	return s.GetById(ctx, adminId)
}

// UpdateProfile 更新当前管理员信息
func (s *sAdmin) UpdateProfile(ctx context.Context, req *model.UpdateAdminRequest) error {
	adminId := gconv.Int(g.RequestFromCtx(ctx).GetCtxVar("admin_id"))
	return s.Update(ctx, adminId, req)
}