manta/gofaster/backend/internal/auth/service/menu_group_service.go

package service

import (
	"fmt"
	"gofaster/internal/auth/model"
	"gofaster/internal/auth/repository"

	"go.uber.org/zap"
)

// MenuGroupService 菜单分组服务
type MenuGroupService struct {
	menuGroupRepo *repository.MenuGroupRepository
	logger        *zap.Logger
}

// NewMenuGroupService 创建菜单分组服务实例
func NewMenuGroupService(menuGroupRepo *repository.MenuGroupRepository, logger *zap.Logger) *MenuGroupService {
	return &MenuGroupService{
		menuGroupRepo: menuGroupRepo,
		logger:        logger,
	}
}

// CreateMenuGroup 创建菜单分组
func (s *MenuGroupService) CreateMenuGroup(menuGroup *model.MenuGroup) error {
	s.logger.Info("开始创建菜单分组", zap.String("name", menuGroup.Name))

	// 检查名称是否已存在
	if s.menuGroupRepo.ExistsByName(menuGroup.Name) {
		return fmt.Errorf("菜单分组名称已存在: %s", menuGroup.Name)
	}

	// 设置默认值
	if menuGroup.Sort == 0 {
		menuGroup.Sort = 999 // 默认排序值
	}
	if menuGroup.Status == 0 {
		menuGroup.Status = 1 // 默认启用
	}

	if err := s.menuGroupRepo.Create(menuGroup); err != nil {
		s.logger.Error("创建菜单分组失败", zap.Error(err))
		return fmt.Errorf("创建菜单分组失败: %w", err)
	}

	s.logger.Info("菜单分组创建成功", zap.String("name", menuGroup.Name), zap.Uint("id", menuGroup.ID))
	return nil
}

// GetMenuGroupByID 根据ID获取菜单分组
func (s *MenuGroupService) GetMenuGroupByID(id uint) (*model.MenuGroup, error) {
	menuGroup, err := s.menuGroupRepo.FindByID(id)
	if err != nil {
		s.logger.Error("获取菜单分组失败", zap.Uint("id", id), zap.Error(err))
		return nil, fmt.Errorf("获取菜单分组失败: %w", err)
	}
	return menuGroup, nil
}

// GetMenuGroupByName 根据名称获取菜单分组
func (s *MenuGroupService) GetMenuGroupByName(name string) (*model.MenuGroup, error) {
	menuGroup, err := s.menuGroupRepo.FindByName(name)
	if err != nil {
		s.logger.Error("获取菜单分组失败", zap.String("name", name), zap.Error(err))
		return nil, fmt.Errorf("获取菜单分组失败: %w", err)
	}
	return menuGroup, nil
}

// ListMenuGroups 获取菜单分组列表
func (s *MenuGroupService) ListMenuGroups() ([]*model.MenuGroup, error) {
	menuGroups, err := s.menuGroupRepo.List()
	if err != nil {
		s.logger.Error("获取菜单分组列表失败", zap.Error(err))
		return nil, fmt.Errorf("获取菜单分组列表失败: %w", err)
	}
	return menuGroups, nil
}

// ListMenuGroupsByStatus 根据状态获取菜单分组列表
func (s *MenuGroupService) ListMenuGroupsByStatus(status int) ([]*model.MenuGroup, error) {
	menuGroups, err := s.menuGroupRepo.ListByStatus(status)
	if err != nil {
		s.logger.Error("根据状态获取菜单分组列表失败", zap.Int("status", status), zap.Error(err))
		return nil, fmt.Errorf("根据状态获取菜单分组列表失败: %w", err)
	}
	return menuGroups, nil
}

// UpdateMenuGroup 更新菜单分组
func (s *MenuGroupService) UpdateMenuGroup(menuGroup *model.MenuGroup) error {
	s.logger.Info("开始更新菜单分组", zap.Uint("id", menuGroup.ID), zap.String("name", menuGroup.Name))

	// 检查菜单分组是否存在
	existing, err := s.menuGroupRepo.FindByID(menuGroup.ID)
	if err != nil {
		s.logger.Error("菜单分组不存在", zap.Uint("id", menuGroup.ID), zap.Error(err))
		return fmt.Errorf("菜单分组不存在: %w", err)
	}

	// 检查名称是否已被其他记录使用
	if s.menuGroupRepo.ExistsByName(menuGroup.Name, menuGroup.ID) {
		return fmt.Errorf("菜单分组名称已存在: %s", menuGroup.Name)
	}

	// 更新字段
	existing.Name = menuGroup.Name
	existing.Description = menuGroup.Description
	existing.Sort = menuGroup.Sort
	existing.Status = menuGroup.Status

	if err := s.menuGroupRepo.Update(existing); err != nil {
		s.logger.Error("更新菜单分组失败", zap.Error(err))
		return fmt.Errorf("更新菜单分组失败: %w", err)
	}

	s.logger.Info("菜单分组更新成功", zap.Uint("id", menuGroup.ID))
	return nil
}

// DeleteMenuGroup 删除菜单分组
func (s *MenuGroupService) DeleteMenuGroup(id uint) error {
	s.logger.Info("开始删除菜单分组", zap.Uint("id", id))

	// 检查菜单分组是否存在
	_, err := s.menuGroupRepo.FindByID(id)
	if err != nil {
		s.logger.Error("菜单分组不存在", zap.Uint("id", id), zap.Error(err))
		return fmt.Errorf("菜单分组不存在: %w", err)
	}

	if err := s.menuGroupRepo.Delete(id); err != nil {
		s.logger.Error("删除菜单分组失败", zap.Error(err))
		return fmt.Errorf("删除菜单分组失败: %w", err)
	}

	s.logger.Info("菜单分组删除成功", zap.Uint("id", id))
	return nil
}

// BatchDeleteMenuGroups 批量删除菜单分组
func (s *MenuGroupService) BatchDeleteMenuGroups(ids []uint) error {
	s.logger.Info("开始批量删除菜单分组", zap.Uints("ids", ids))

	if len(ids) == 0 {
		return fmt.Errorf("删除ID列表不能为空")
	}

	if err := s.menuGroupRepo.BatchDelete(ids); err != nil {
		s.logger.Error("批量删除菜单分组失败", zap.Error(err))
		return fmt.Errorf("批量删除菜单分组失败: %w", err)
	}

	s.logger.Info("批量删除菜单分组成功", zap.Uints("ids", ids))
	return nil
}

// UpdateMenuGroupStatus 更新菜单分组状态
func (s *MenuGroupService) UpdateMenuGroupStatus(id uint, status int) error {
	s.logger.Info("开始更新菜单分组状态", zap.Uint("id", id), zap.Int("status", status))

	// 检查菜单分组是否存在
	_, err := s.menuGroupRepo.FindByID(id)
	if err != nil {
		s.logger.Error("菜单分组不存在", zap.Uint("id", id), zap.Error(err))
		return fmt.Errorf("菜单分组不存在: %w", err)
	}

	// 验证状态值
	if status != 0 && status != 1 {
		return fmt.Errorf("状态值无效，只能是0或1")
	}

	if err := s.menuGroupRepo.UpdateStatus(id, status); err != nil {
		s.logger.Error("更新菜单分组状态失败", zap.Error(err))
		return fmt.Errorf("更新菜单分组状态失败: %w", err)
	}

	s.logger.Info("菜单分组状态更新成功", zap.Uint("id", id), zap.Int("status", status))
	return nil
}

// UpdateMenuGroupSort 更新菜单分组排序
func (s *MenuGroupService) UpdateMenuGroupSort(id uint, sort int) error {
	s.logger.Info("开始更新菜单分组排序", zap.Uint("id", id), zap.Int("sort", sort))

	// 检查菜单分组是否存在
	_, err := s.menuGroupRepo.FindByID(id)
	if err != nil {
		s.logger.Error("菜单分组不存在", zap.Uint("id", id), zap.Error(err))
		return fmt.Errorf("菜单分组不存在: %w", err)
	}

	if err := s.menuGroupRepo.UpdateSort(id, sort); err != nil {
		s.logger.Error("更新菜单分组排序失败", zap.Error(err))
		return fmt.Errorf("更新菜单分组排序失败: %w", err)
	}

	s.logger.Info("菜单分组排序更新成功", zap.Uint("id", id), zap.Int("sort", sort))
	return nil
}

// BatchUpdateMenuGroupSort 批量更新菜单分组排序
func (s *MenuGroupService) BatchUpdateMenuGroupSort(sorts map[uint]int) error {
	s.logger.Info("开始批量更新菜单分组排序", zap.Any("sorts", sorts))

	if len(sorts) == 0 {
		return fmt.Errorf("排序数据不能为空")
	}

	if err := s.menuGroupRepo.BatchUpdateSort(sorts); err != nil {
		s.logger.Error("批量更新菜单分组排序失败", zap.Error(err))
		return fmt.Errorf("批量更新菜单分组排序失败: %w", err)
	}

	s.logger.Info("批量更新菜单分组排序成功")
	return nil
}

// GetMenuGroupStats 获取菜单分组统计信息
func (s *MenuGroupService) GetMenuGroupStats() (map[string]interface{}, error) {
	stats, err := s.menuGroupRepo.GetStats()
	if err != nil {
		s.logger.Error("获取菜单分组统计信息失败", zap.Error(err))
		return nil, fmt.Errorf("获取菜单分组统计信息失败: %w", err)
	}
	return stats, nil
}