junhong_cmp_fiber/internal/query/businessusergroup/query.go

// Package businessusergroup 提供业务用户组及其成员规模的只读投影。
// Query 只做筛选、分页与 DTO 投影，不修改任何状态。
package businessusergroup

import (
	"context"
	"strings"
	"time"

	"gorm.io/gorm"

	"github.com/break/junhong_cmp_fiber/internal/model"
	"github.com/break/junhong_cmp_fiber/internal/model/dto"
	"github.com/break/junhong_cmp_fiber/internal/store/postgres"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
	"github.com/break/junhong_cmp_fiber/pkg/errors"
)

// Query 查询业务用户组。
type Query struct {
	db    *gorm.DB
	store *postgres.BusinessUserGroupStore
}

// NewQuery 创建业务用户组查询。
func NewQuery(db *gorm.DB, groupStore *postgres.BusinessUserGroupStore) *Query {
	return &Query{db: db, store: groupStore}
}

// List 分页查询业务用户组，供维护与筛选下拉使用。
func (q *Query) List(ctx context.Context, request dto.BusinessUserGroupListRequest) (*dto.BusinessUserGroupPageResult, error) {
	if q == nil || q.db == nil {
		return nil, errors.New(errors.CodeServiceUnavailable, "业务用户组查询尚未配置")
	}
	page, pageSize := normalizePage(request.Page, request.PageSize)
	status := enabledToStatus(request.Enabled)
	query := q.db.WithContext(ctx).Model(&model.BusinessUserGroup{})
	if status != nil {
		query = query.Where("status = ?", *status)
	}
	if request.BusinessLine != nil {
		query = query.Where("business_line = ?", *request.BusinessLine)
	}
	if keyword := strings.TrimSpace(request.Keyword); keyword != "" {
		like := "%" + keyword + "%"
		query = query.Where("name LIKE ? OR code LIKE ?", like, like)
	}
	var total int64
	if err := query.Count(&total).Error; err != nil {
		return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询业务用户组总数失败")
	}
	var groups []*model.BusinessUserGroup
	if err := query.Order("sort_order ASC, id ASC").
		Offset((page - 1) * pageSize).Limit(pageSize).Find(&groups).Error; err != nil {
		return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询业务用户组列表失败")
	}
	items := make([]*dto.BusinessUserGroupResponse, 0, len(groups))
	for _, group := range groups {
		items = append(items, toResponse(group))
	}
	return &dto.BusinessUserGroupPageResult{Items: items, Total: total, Page: page, Size: pageSize}, nil
}

// Detail 查询单个业务用户组详情。
func (q *Query) Detail(ctx context.Context, groupID uint) (*dto.BusinessUserGroupResponse, error) {
	if q == nil || q.store == nil {
		return nil, errors.New(errors.CodeServiceUnavailable, "业务用户组查询尚未配置")
	}
	if groupID == 0 {
		return nil, errors.New(errors.CodeInvalidParam)
	}
	group, err := q.store.GetByID(ctx, groupID)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, errors.New(errors.CodeNotFound, "业务用户组不存在")
		}
		return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询业务用户组失败")
	}
	return toResponse(group), nil
}

// toResponse 将业务用户组投影为对外响应。
func toResponse(group *model.BusinessUserGroup) *dto.BusinessUserGroupResponse {
	return &dto.BusinessUserGroupResponse{
		ID: group.ID, Code: group.Code, Name: group.Name,
		BusinessLine: group.BusinessLine, BusinessLineName: constants.GetBusinessLineName(group.BusinessLine),
		Sort: group.SortOrder, Enabled: group.Status == constants.StatusEnabled, Remark: group.Remark,
		CreatedAt: group.CreatedAt.Format(time.RFC3339), UpdatedAt: group.UpdatedAt.Format(time.RFC3339),
	}
}

// enabledToStatus 把对外启停布尔映射为既有状态值；未提交时返回 nil 表示不过滤。
func enabledToStatus(enabled *bool) *int {
	if enabled == nil {
		return nil
	}
	status := constants.StatusDisabled
	if *enabled {
		status = constants.StatusEnabled
	}
	return &status
}

// normalizePage 归一化分页参数，执行 DefaultPageSize 与 MaxPageSize 上限。
func normalizePage(page, pageSize int) (int, int) {
	if page <= 0 {
		page = constants.DefaultPage
	}
	if pageSize <= 0 {
		pageSize = constants.DefaultPageSize
	}
	if pageSize > constants.MaxPageSize {
		pageSize = constants.MaxPageSize
	}
	return page, pageSize
}