feat: add tenant content management features for superadmin

- Implemented API endpoints for listing tenant contents and updating content status.
- Added Swagger documentation for new endpoints:
  - GET /super/v1/tenants/{tenantID}/contents
  - PATCH /super/v1/tenants/{tenantID}/contents/{contentID}/status
- Created DTOs for content item and status update form.
- Enhanced frontend to support content management in the tenant detail page.
- Added search and filter functionalities for tenant contents.
- Implemented unpublish functionality with confirmation dialog.
- Updated service layer to handle new content management logic.

backend/app/http/super/dto/content.go

@@ -0,0 +1,44 @@
+package dto
+
+import (
+	"strings"
+	"time"
+
+	"quyun/v2/app/requests"
+	"quyun/v2/database/models"
+	"quyun/v2/pkg/consts"
+)
+
+// TenantContentFilter defines list query filters for tenant contents (superadmin).
+type TenantContentFilter struct {
+	requests.Pagination      `json:",inline" query:",inline"`
+	requests.SortQueryFilter `json:",inline" query:",inline"`
+
+	Keyword *string `json:"keyword,omitempty" query:"keyword"`
+
+	Status     *consts.ContentStatus     `json:"status,omitempty" query:"status"`
+	Visibility *consts.ContentVisibility `json:"visibility,omitempty" query:"visibility"`
+
+	UserID *int64 `json:"user_id,omitempty" query:"user_id"`
+
+	PublishedAtFrom *time.Time `json:"published_at_from,omitempty" query:"published_at_from"`
+	PublishedAtTo   *time.Time `json:"published_at_to,omitempty" query:"published_at_to"`
+	CreatedAtFrom   *time.Time `json:"created_at_from,omitempty" query:"created_at_from"`
+	CreatedAtTo     *time.Time `json:"created_at_to,omitempty" query:"created_at_to"`
+}
+
+func (f *TenantContentFilter) KeywordTrimmed() string {
+	if f == nil || f.Keyword == nil {
+		return ""
+	}
+	return strings.TrimSpace(*f.Keyword)
+}
+
+type SuperTenantContentItem struct {
+	Content *models.Content      `json:"content,omitempty"`
+	Price   *models.ContentPrice `json:"price,omitempty"`
+	Owner   *SuperUserLite       `json:"owner,omitempty"`
+
+	StatusDescription     string `json:"status_description,omitempty"`
+	VisibilityDescription string `json:"visibility_description,omitempty"`
+}

backend/app/http/super/dto/content_status.go

@@ -0,0 +1,8 @@
+package dto
+
+import "quyun/v2/pkg/consts"
+
+type SuperTenantContentStatusUpdateForm struct {
+	// Status supports: unpublished (下架) / blocked (封禁)
+	Status consts.ContentStatus `json:"status" validate:"required,oneof=unpublished blocked"`
+}

backend/app/http/super/routes.gen.go

@@ -87,6 +87,12 @@ func (r *Routes) Register(router fiber.Router) {
 		r.tenant.detail,
 		PathParam[int64]("tenantID"),
 	))
+	r.log.Debugf("Registering route: Get /super/v1/tenants/:tenantID<int>/contents -> tenant.contents")
+	router.Get("/super/v1/tenants/:tenantID<int>/contents"[len(r.Path()):], DataFunc2(
+		r.tenant.contents,
+		PathParam[int64]("tenantID"),
+		Query[dto.TenantContentFilter]("filter"),
+	))
 	r.log.Debugf("Registering route: Get /super/v1/tenants/:tenantID<int>/users -> tenant.users")
 	router.Get("/super/v1/tenants/:tenantID<int>/users"[len(r.Path()):], DataFunc2(
 		r.tenant.users,
@@ -103,6 +109,13 @@ func (r *Routes) Register(router fiber.Router) {
 		PathParam[int64]("tenantID"),
 		Body[dto.TenantExpireUpdateForm]("form"),
 	))
+	r.log.Debugf("Registering route: Patch /super/v1/tenants/:tenantID<int>/contents/:contentID<int>/status -> tenant.updateContentStatus")
+	router.Patch("/super/v1/tenants/:tenantID<int>/contents/:contentID<int>/status"[len(r.Path()):], DataFunc3(
+		r.tenant.updateContentStatus,
+		PathParam[int64]("tenantID"),
+		PathParam[int64]("contentID"),
+		Body[dto.SuperTenantContentStatusUpdateForm]("form"),
+	))
 	r.log.Debugf("Registering route: Patch /super/v1/tenants/:tenantID<int>/status -> tenant.updateStatus")
 	router.Patch("/super/v1/tenants/:tenantID<int>/status"[len(r.Path()):], Func2(
 		r.tenant.updateStatus,

backend/app/http/super/tenant_content.go

@@ -0,0 +1,30 @@
+package super
+
+import (
+	"quyun/v2/app/http/super/dto"
+	"quyun/v2/app/requests"
+	"quyun/v2/app/services"
+
+	"github.com/gofiber/fiber/v3"
+)
+
+// contents
+//
+//	@Summary	租户内容列表（平台侧）
+//	@Tags		Super
+//	@Accept		json
+//	@Produce	json
+//	@Param		tenantID	path	int64					true	"TenantID"
+//	@Param		filter		query	dto.TenantContentFilter	true	"Filter"
+//	@Success	200			{object}	requests.Pager{items=dto.SuperTenantContentItem}
+//
+//	@Router		/super/v1/tenants/:tenantID<int>/contents [get]
+//	@Bind		tenantID path
+//	@Bind		filter query
+func (*tenant) contents(ctx fiber.Ctx, tenantID int64, filter *dto.TenantContentFilter) (*requests.Pager, error) {
+	if filter == nil {
+		filter = &dto.TenantContentFilter{}
+	}
+	filter.Pagination.Format()
+	return services.Content.SuperTenantContentsPage(ctx, tenantID, filter)
+}

backend/app/http/super/tenant_content_status.go

@@ -0,0 +1,47 @@
+package super
+
+import (
+	"time"
+
+	"quyun/v2/app/errorx"
+	"quyun/v2/app/http/super/dto"
+	"quyun/v2/app/services"
+	"quyun/v2/database/models"
+	"quyun/v2/pkg/consts"
+	"quyun/v2/providers/jwt"
+
+	"github.com/gofiber/fiber/v3"
+)
+
+// updateContentStatus
+//
+//	@Summary	更新租户内容状态（平台侧：下架/封禁）
+//	@Tags		Super
+//	@Accept		json
+//	@Produce	json
+//	@Param		tenantID	path	int64								true	"TenantID"
+//	@Param		contentID	path	int64								true	"ContentID"
+//	@Param		form		body	dto.SuperTenantContentStatusUpdateForm	true	"Form"
+//	@Success	200			{object}	models.Content
+//
+//	@Router		/super/v1/tenants/:tenantID<int>/contents/:contentID<int>/status [patch]
+//	@Bind		tenantID path
+//	@Bind		contentID path
+//	@Bind		form body
+func (*tenant) updateContentStatus(
+	ctx fiber.Ctx,
+	tenantID int64,
+	contentID int64,
+	form *dto.SuperTenantContentStatusUpdateForm,
+) (*models.Content, error) {
+	if form == nil {
+		return nil, errorx.ErrInvalidParameter
+	}
+
+	claims, ok := ctx.Locals(consts.CtxKeyClaims).(*jwt.Claims)
+	if !ok || claims == nil || claims.UserID <= 0 {
+		return nil, errorx.ErrTokenInvalid
+	}
+
+	return services.Content.SuperUpdateTenantContentStatus(ctx, claims.UserID, tenantID, contentID, form.Status, time.Now())
+}

backend/app/services/content_super.go

@@ -0,0 +1,238 @@
+package services
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"quyun/v2/app/errorx"
+	superdto "quyun/v2/app/http/super/dto"
+	"quyun/v2/app/requests"
+	"quyun/v2/database"
+	"quyun/v2/database/models"
+	"quyun/v2/pkg/consts"
+
+	"github.com/pkg/errors"
+	"github.com/samber/lo"
+	log "github.com/sirupsen/logrus"
+	"go.ipao.vip/gen"
+	"go.ipao.vip/gen/field"
+)
+
+// SuperTenantContentsPage returns tenant contents list for superadmin.
+func (s *content) SuperTenantContentsPage(ctx context.Context, tenantID int64, filter *superdto.TenantContentFilter) (*requests.Pager, error) {
+	if tenantID <= 0 {
+		return nil, errors.New("tenant_id must be > 0")
+	}
+	if filter == nil {
+		filter = &superdto.TenantContentFilter{}
+	}
+
+	log.WithFields(log.Fields{
+		"tenant_id": tenantID,
+		"page":      filter.Page,
+		"limit":     filter.Limit,
+	}).Info("services.content.super_tenant_contents_page")
+
+	tbl, query := models.ContentQuery.QueryContext(ctx)
+	conds := []gen.Condition{
+		tbl.TenantID.Eq(tenantID),
+		tbl.DeletedAt.IsNull(),
+	}
+
+	if kw := strings.TrimSpace(filter.KeywordTrimmed()); kw != "" {
+		conds = append(conds, tbl.Title.Like(database.WrapLike(kw)))
+	}
+	if filter.Status != nil {
+		conds = append(conds, tbl.Status.Eq(*filter.Status))
+	}
+	if filter.Visibility != nil {
+		conds = append(conds, tbl.Visibility.Eq(*filter.Visibility))
+	}
+	if filter.UserID != nil && *filter.UserID > 0 {
+		conds = append(conds, tbl.UserID.Eq(*filter.UserID))
+	}
+	if filter.PublishedAtFrom != nil {
+		conds = append(conds, tbl.PublishedAt.Gte(*filter.PublishedAtFrom))
+	}
+	if filter.PublishedAtTo != nil {
+		conds = append(conds, tbl.PublishedAt.Lte(*filter.PublishedAtTo))
+	}
+	if filter.CreatedAtFrom != nil {
+		conds = append(conds, tbl.CreatedAt.Gte(*filter.CreatedAtFrom))
+	}
+	if filter.CreatedAtTo != nil {
+		conds = append(conds, tbl.CreatedAt.Lte(*filter.CreatedAtTo))
+	}
+
+	filter.Pagination.Format()
+
+	orderBys := make([]field.Expr, 0, 6)
+	allowedAsc := map[string]field.Expr{
+		"id":           tbl.ID.Asc(),
+		"title":        tbl.Title.Asc(),
+		"user_id":      tbl.UserID.Asc(),
+		"status":       tbl.Status.Asc(),
+		"visibility":   tbl.Visibility.Asc(),
+		"published_at": tbl.PublishedAt.Asc(),
+		"created_at":   tbl.CreatedAt.Asc(),
+		"updated_at":   tbl.UpdatedAt.Asc(),
+	}
+	allowedDesc := map[string]field.Expr{
+		"id":           tbl.ID.Desc(),
+		"title":        tbl.Title.Desc(),
+		"user_id":      tbl.UserID.Desc(),
+		"status":       tbl.Status.Desc(),
+		"visibility":   tbl.Visibility.Desc(),
+		"published_at": tbl.PublishedAt.Desc(),
+		"created_at":   tbl.CreatedAt.Desc(),
+		"updated_at":   tbl.UpdatedAt.Desc(),
+	}
+	for _, f := range filter.AscFields() {
+		f = strings.TrimSpace(f)
+		if f == "" {
+			continue
+		}
+		if ob, ok := allowedAsc[f]; ok {
+			orderBys = append(orderBys, ob)
+		}
+	}
+	for _, f := range filter.DescFields() {
+		f = strings.TrimSpace(f)
+		if f == "" {
+			continue
+		}
+		if ob, ok := allowedDesc[f]; ok {
+			orderBys = append(orderBys, ob)
+		}
+	}
+	if len(orderBys) == 0 {
+		orderBys = append(orderBys, tbl.ID.Desc())
+	} else {
+		orderBys = append(orderBys, tbl.ID.Desc())
+	}
+
+	items, total, err := query.Where(conds...).Order(orderBys...).FindByPage(int(filter.Offset()), int(filter.Limit))
+	if err != nil {
+		return nil, err
+	}
+
+	contentIDs := lo.Map(items, func(item *models.Content, _ int) int64 {
+		if item == nil {
+			return 0
+		}
+		return item.ID
+	})
+	contentIDs = lo.Filter(contentIDs, func(id int64, _ int) bool { return id > 0 })
+
+	priceByContent, err := s.contentPriceMapping(ctx, tenantID, contentIDs)
+	if err != nil {
+		return nil, err
+	}
+
+	ownerIDs := lo.Uniq(lo.FilterMap(items, func(item *models.Content, _ int) (int64, bool) {
+		if item == nil || item.UserID <= 0 {
+			return 0, false
+		}
+		return item.UserID, true
+	}))
+
+	ownerMap := map[int64]*superdto.SuperUserLite{}
+	if len(ownerIDs) > 0 {
+		uTbl, uQuery := models.UserQuery.QueryContext(ctx)
+		users, err := uQuery.Where(uTbl.ID.In(ownerIDs...)).Find()
+		if err != nil {
+			return nil, err
+		}
+		for _, u := range users {
+			if u == nil {
+				continue
+			}
+			ownerMap[u.ID] = &superdto.SuperUserLite{
+				ID:                u.ID,
+				Username:          u.Username,
+				Status:            u.Status,
+				Roles:             u.Roles,
+				VerifiedAt:        u.VerifiedAt,
+				CreatedAt:         u.CreatedAt,
+				UpdatedAt:         u.UpdatedAt,
+				StatusDescription: u.Status.Description(),
+			}
+		}
+	}
+
+	respItems := lo.Map(items, func(model *models.Content, _ int) *superdto.SuperTenantContentItem {
+		if model == nil {
+			return nil
+		}
+		return &superdto.SuperTenantContentItem{
+			Content:               model,
+			Price:                 priceByContent[model.ID],
+			Owner:                 ownerMap[model.UserID],
+			StatusDescription:     model.Status.Description(),
+			VisibilityDescription: model.Visibility.Description(),
+		}
+	})
+
+	return &requests.Pager{
+		Pagination: filter.Pagination,
+		Total:      total,
+		Items:      respItems,
+	}, nil
+}
+
+func (s *content) SuperUpdateTenantContentStatus(
+	ctx context.Context,
+	operatorUserID, tenantID, contentID int64,
+	status consts.ContentStatus,
+	now time.Time,
+) (*models.Content, error) {
+	if operatorUserID <= 0 {
+		return nil, errorx.ErrTokenInvalid
+	}
+	if tenantID <= 0 {
+		return nil, errors.New("tenant_id must be > 0")
+	}
+	if contentID <= 0 {
+		return nil, errors.New("content_id must be > 0")
+	}
+	if status != consts.ContentStatusUnpublished && status != consts.ContentStatusBlocked {
+		return nil, errorx.ErrInvalidParameter.WithMsg("invalid status")
+	}
+
+	log.WithFields(log.Fields{
+		"operator_user_id": operatorUserID,
+		"tenant_id":        tenantID,
+		"content_id":       contentID,
+		"status":           status,
+	}).Info("services.content.super_update_tenant_content_status")
+
+	tbl, query := models.ContentQuery.QueryContext(ctx)
+
+	model, err := query.Where(
+		tbl.TenantID.Eq(tenantID),
+		tbl.ID.Eq(contentID),
+		tbl.DeletedAt.IsNull(),
+	).First()
+	if err != nil {
+		return nil, err
+	}
+
+	if status == consts.ContentStatusUnpublished && model.Status != consts.ContentStatusPublished {
+		return nil, errorx.ErrPreconditionFailed.WithMsg("content is not published")
+	}
+
+	if _, err := query.Where(
+		tbl.TenantID.Eq(tenantID),
+		tbl.ID.Eq(contentID),
+		tbl.DeletedAt.IsNull(),
+	).UpdateSimple(
+		tbl.Status.Value(status),
+	); err != nil {
+		return nil, err
+	}
+
+	model.Status = status
+	model.UpdatedAt = now
+	return model, nil
+}