feat: add superadmin user library detail

2026-01-15 16:17:32 +08:00
parent 339fd4fb1d
commit c8ec0af07f
10 changed files with 1104 additions and 10 deletions
--- a/backend/app/services/super.go
+++ b/backend/app/services/super.go
@@ -1704,6 +1704,247 @@ func (s *super) ListUserTenants(ctx context.Context, userID int64, filter *super
 	}, nil
 }

+func (s *super) ListUserLibrary(ctx context.Context, userID int64, filter *super_dto.SuperUserLibraryListFilter) (*requests.Pager, error) {
+	if userID == 0 {
+		return nil, errorx.ErrBadRequest.WithMsg("用户ID不能为空")
+	}
+	if filter == nil {
+		filter = &super_dto.SuperUserLibraryListFilter{}
+	}
+
+	tbl, q := models.ContentAccessQuery.QueryContext(ctx)
+	q = q.Where(tbl.UserID.Eq(userID))
+
+	if filter.Status != nil && *filter.Status != "" {
+		q = q.Where(tbl.Status.Eq(*filter.Status))
+	}
+	if filter.TenantID != nil && *filter.TenantID > 0 {
+		q = q.Where(tbl.TenantID.Eq(*filter.TenantID))
+	}
+	if filter.OrderID != nil && *filter.OrderID > 0 {
+		q = q.Where(tbl.OrderID.Eq(*filter.OrderID))
+	}
+
+	contentIDs, contentFilter, err := s.filterContentIDsForUserLibrary(ctx, filter)
+	if err != nil {
+		return nil, err
+	}
+	if contentFilter {
+		if len(contentIDs) == 0 {
+			filter.Pagination.Format()
+			return &requests.Pager{
+				Pagination: filter.Pagination,
+				Total:      0,
+				Items:      []super_dto.SuperUserLibraryItem{},
+			}, nil
+		}
+		q = q.Where(tbl.ContentID.In(contentIDs...))
+	}
+
+	orderIDs, orderFilter, err := s.filterOrderIDsForUserLibrary(ctx, userID, filter)
+	if err != nil {
+		return nil, err
+	}
+	if orderFilter {
+		if len(orderIDs) == 0 {
+			filter.Pagination.Format()
+			return &requests.Pager{
+				Pagination: filter.Pagination,
+				Total:      0,
+				Items:      []super_dto.SuperUserLibraryItem{},
+			}, nil
+		}
+		q = q.Where(tbl.OrderID.In(orderIDs...))
+	}
+
+	if filter.AccessedAtFrom != nil {
+		from, err := s.parseFilterTime(filter.AccessedAtFrom)
+		if err != nil {
+			return nil, err
+		}
+		if from != nil {
+			q = q.Where(tbl.CreatedAt.Gte(*from))
+		}
+	}
+	if filter.AccessedAtTo != nil {
+		to, err := s.parseFilterTime(filter.AccessedAtTo)
+		if err != nil {
+			return nil, err
+		}
+		if to != nil {
+			q = q.Where(tbl.CreatedAt.Lte(*to))
+		}
+	}
+
+	orderApplied := false
+	if filter.Desc != nil && strings.TrimSpace(*filter.Desc) != "" {
+		switch strings.TrimSpace(*filter.Desc) {
+		case "id":
+			q = q.Order(tbl.ID.Desc())
+		case "created_at":
+			q = q.Order(tbl.CreatedAt.Desc())
+		}
+		orderApplied = true
+	} else if filter.Asc != nil && strings.TrimSpace(*filter.Asc) != "" {
+		switch strings.TrimSpace(*filter.Asc) {
+		case "id":
+			q = q.Order(tbl.ID)
+		case "created_at":
+			q = q.Order(tbl.CreatedAt)
+		}
+		orderApplied = true
+	}
+	if !orderApplied {
+		q = q.Order(tbl.CreatedAt.Desc())
+	}
+
+	filter.Pagination.Format()
+	total, err := q.Count()
+	if err != nil {
+		return nil, errorx.ErrDatabaseError.WithCause(err)
+	}
+	list, err := q.Offset(int(filter.Pagination.Offset())).Limit(int(filter.Pagination.Limit)).Find()
+	if err != nil {
+		return nil, errorx.ErrDatabaseError.WithCause(err)
+	}
+	if len(list) == 0 {
+		return &requests.Pager{
+			Pagination: filter.Pagination,
+			Total:      total,
+			Items:      []super_dto.SuperUserLibraryItem{},
+		}, nil
+	}
+
+	contentIDSet := make(map[int64]struct{}, len(list))
+	contentIDs = make([]int64, 0, len(list))
+	orderIDSet := make(map[int64]struct{}, len(list))
+	orderIDs = make([]int64, 0, len(list))
+	for _, access := range list {
+		if access.ContentID > 0 {
+			if _, ok := contentIDSet[access.ContentID]; !ok {
+				contentIDSet[access.ContentID] = struct{}{}
+				contentIDs = append(contentIDs, access.ContentID)
+			}
+		}
+		if access.OrderID > 0 {
+			if _, ok := orderIDSet[access.OrderID]; !ok {
+				orderIDSet[access.OrderID] = struct{}{}
+				orderIDs = append(orderIDs, access.OrderID)
+			}
+		}
+	}
+
+	var contents []*models.Content
+	if len(contentIDs) > 0 {
+		contentTbl, contentQuery := models.ContentQuery.QueryContext(ctx)
+		err := contentQuery.Where(contentTbl.ID.In(contentIDs...)).
+			UnderlyingDB().
+			Preload("Author").
+			Preload("ContentAssets.Asset").
+			Find(&contents).Error
+		if err != nil {
+			return nil, errorx.ErrDatabaseError.WithCause(err)
+		}
+	}
+
+	priceMap, err := s.contentPriceMap(ctx, contents)
+	if err != nil {
+		return nil, err
+	}
+	tenantMap, err := s.contentTenantMap(ctx, contents)
+	if err != nil {
+		return nil, err
+	}
+
+	contentMap := make(map[int64]*models.Content, len(contents))
+	for _, content := range contents {
+		contentMap[content.ID] = content
+	}
+
+	orderMap := make(map[int64]*models.Order, len(orderIDs))
+	if len(orderIDs) > 0 {
+		orderTbl, orderQuery := models.OrderQuery.QueryContext(ctx)
+		orders, err := orderQuery.Where(orderTbl.ID.In(orderIDs...)).Find()
+		if err != nil {
+			return nil, errorx.ErrDatabaseError.WithCause(err)
+		}
+		for _, order := range orders {
+			orderMap[order.ID] = order
+		}
+	}
+
+	type orderItemKey struct {
+		orderID   int64
+		contentID int64
+	}
+	orderItemMap := make(map[orderItemKey]*models.OrderItem, len(list))
+	if len(orderIDs) > 0 {
+		itemTbl, itemQuery := models.OrderItemQuery.QueryContext(ctx)
+		itemQuery = itemQuery.Where(itemTbl.OrderID.In(orderIDs...), itemTbl.UserID.Eq(userID))
+		if len(contentIDs) > 0 {
+			itemQuery = itemQuery.Where(itemTbl.ContentID.In(contentIDs...))
+		}
+		items, err := itemQuery.Find()
+		if err != nil {
+			return nil, errorx.ErrDatabaseError.WithCause(err)
+		}
+		for _, item := range items {
+			orderItemMap[orderItemKey{orderID: item.OrderID, contentID: item.ContentID}] = item
+		}
+	}
+
+	items := make([]super_dto.SuperUserLibraryItem, 0, len(list))
+	for _, access := range list {
+		var contentItem *super_dto.AdminContentItem
+		if content := contentMap[access.ContentID]; content != nil {
+			item := s.toSuperContentItem(content, priceMap[content.ID], tenantMap[content.TenantID])
+			contentItem = &item
+		}
+
+		order := orderMap[access.OrderID]
+		orderStatusDesc := ""
+		orderType := consts.OrderType("")
+		orderStatus := consts.OrderStatus("")
+		paidAt := ""
+		if order != nil {
+			orderType = order.Type
+			orderStatus = order.Status
+			orderStatusDesc = order.Status.Description()
+			paidAt = s.formatTime(order.PaidAt)
+		}
+
+		amountPaid := int64(0)
+		var snapshot any
+		if orderItem := orderItemMap[orderItemKey{orderID: access.OrderID, contentID: access.ContentID}]; orderItem != nil {
+			amountPaid = orderItem.AmountPaid
+			snapshot = orderItem.Snapshot.Data()
+		}
+
+		items = append(items, super_dto.SuperUserLibraryItem{
+			AccessID:                access.ID,
+			TenantID:                access.TenantID,
+			ContentID:               access.ContentID,
+			OrderID:                 access.OrderID,
+			OrderType:               orderType,
+			OrderStatus:             orderStatus,
+			OrderStatusDescription:  orderStatusDesc,
+			AmountPaid:              amountPaid,
+			PaidAt:                  paidAt,
+			AccessStatus:            access.Status,
+			AccessStatusDescription: access.Status.Description(),
+			AccessedAt:              s.formatTime(access.CreatedAt),
+			Content:                 contentItem,
+			Snapshot:                snapshot,
+		})
+	}
+
+	return &requests.Pager{
+		Pagination: filter.Pagination,
+		Total:      total,
+		Items:      items,
+	}, nil
+}
+
 func (s *super) ListUserFavorites(ctx context.Context, userID int64, filter *super_dto.SuperUserContentActionListFilter) (*requests.Pager, error) {
 	return s.listUserContentActions(ctx, userID, consts.UserContentActionTypeFavorite, filter)
 }
@@ -3667,6 +3908,117 @@ func (s *super) filterContentIDsForUserActions(
 	return ids, true, nil
 }

+func (s *super) filterContentIDsForUserLibrary(
+	ctx context.Context,
+	filter *super_dto.SuperUserLibraryListFilter,
+) ([]int64, bool, error) {
+	if filter == nil {
+		return nil, false, nil
+	}
+
+	tbl, q := models.ContentQuery.QueryContext(ctx)
+	filterApplied := false
+
+	if filter.ContentID != nil && *filter.ContentID > 0 {
+		q = q.Where(tbl.ID.Eq(*filter.ContentID))
+		filterApplied = true
+	}
+	if filter.TenantID != nil && *filter.TenantID > 0 {
+		q = q.Where(tbl.TenantID.Eq(*filter.TenantID))
+		filterApplied = true
+	}
+
+	tenantIDs, tenantFilter, err := s.lookupTenantIDs(ctx, filter.TenantCode, filter.TenantName)
+	if err != nil {
+		return nil, false, err
+	}
+	if tenantFilter {
+		filterApplied = true
+		if len(tenantIDs) == 0 {
+			return []int64{}, true, nil
+		}
+		q = q.Where(tbl.TenantID.In(tenantIDs...))
+	}
+
+	if filter.Keyword != nil && strings.TrimSpace(*filter.Keyword) != "" {
+		keyword := "%" + strings.TrimSpace(*filter.Keyword) + "%"
+		q = q.Where(field.Or(
+			tbl.Title.Like(keyword),
+			tbl.Description.Like(keyword),
+			tbl.Summary.Like(keyword),
+		))
+		filterApplied = true
+	}
+
+	if !filterApplied {
+		return nil, false, nil
+	}
+
+	ids, err := q.PluckIDs()
+	if err != nil {
+		return nil, true, errorx.ErrDatabaseError.WithCause(err)
+	}
+	return ids, true, nil
+}
+
+func (s *super) filterOrderIDsForUserLibrary(
+	ctx context.Context,
+	userID int64,
+	filter *super_dto.SuperUserLibraryListFilter,
+) ([]int64, bool, error) {
+	if filter == nil {
+		return nil, false, nil
+	}
+
+	tbl, q := models.OrderQuery.QueryContext(ctx)
+	q = q.Where(tbl.UserID.Eq(userID))
+	filterApplied := false
+
+	if filter.OrderID != nil && *filter.OrderID > 0 {
+		q = q.Where(tbl.ID.Eq(*filter.OrderID))
+		filterApplied = true
+	}
+	if filter.OrderStatus != nil && *filter.OrderStatus != "" {
+		q = q.Where(tbl.Status.Eq(*filter.OrderStatus))
+		filterApplied = true
+	}
+	if filter.PaidAtFrom != nil {
+		from, err := s.parseFilterTime(filter.PaidAtFrom)
+		if err != nil {
+			return nil, false, err
+		}
+		if from != nil {
+			q = q.Where(tbl.PaidAt.Gte(*from))
+			filterApplied = true
+		}
+	}
+	if filter.PaidAtTo != nil {
+		to, err := s.parseFilterTime(filter.PaidAtTo)
+		if err != nil {
+			return nil, false, err
+		}
+		if to != nil {
+			q = q.Where(tbl.PaidAt.Lte(*to))
+			filterApplied = true
+		}
+	}
+
+	if !filterApplied {
+		return nil, false, nil
+	}
+
+	orders, err := q.Select(tbl.ID).Find()
+	if err != nil {
+		return nil, true, errorx.ErrDatabaseError.WithCause(err)
+	}
+
+	ids := make([]int64, 0, len(orders))
+	for _, order := range orders {
+		ids = append(ids, order.ID)
+	}
+	return ids, true, nil
+}
+
 func (s *super) lookupOrderIDsByContent(ctx context.Context, contentID *int64, contentTitle *string) ([]int64, bool, error) {
 	var id int64
 	if contentID != nil {