feat: add super comment governance and finance oversight

2026-01-16 10:37:24 +08:00
parent f7db11a4df
commit 3af3c854c9
16 changed files with 4139 additions and 285 deletions
--- a/backend/app/services/super.go
+++ b/backend/app/services/super.go
@@ -2311,6 +2311,306 @@ func (s *super) ListContents(ctx context.Context, filter *super_dto.SuperContent
 	}, nil
 }

+func (s *super) ListComments(ctx context.Context, filter *super_dto.SuperCommentListFilter) (*requests.Pager, error) {
+	if filter == nil {
+		filter = &super_dto.SuperCommentListFilter{}
+	}
+
+	tbl, q := models.CommentQuery.QueryContext(ctx)
+
+	if filter.ID != nil && *filter.ID > 0 {
+		q = q.Where(tbl.ID.Eq(*filter.ID))
+	}
+	if filter.TenantID != nil && *filter.TenantID > 0 {
+		q = q.Where(tbl.TenantID.Eq(*filter.TenantID))
+	}
+	if filter.ContentID != nil && *filter.ContentID > 0 {
+		q = q.Where(tbl.ContentID.Eq(*filter.ContentID))
+	}
+	if filter.UserID != nil && *filter.UserID > 0 {
+		q = q.Where(tbl.UserID.Eq(*filter.UserID))
+	}
+	if filter.Keyword != nil && strings.TrimSpace(*filter.Keyword) != "" {
+		keyword := "%" + strings.TrimSpace(*filter.Keyword) + "%"
+		q = q.Where(tbl.Content.Like(keyword))
+	}
+
+	tenantIDs, tenantFilter, err := s.lookupTenantIDs(ctx, filter.TenantCode, filter.TenantName)
+	if err != nil {
+		return nil, err
+	}
+	if tenantFilter {
+		if len(tenantIDs) == 0 {
+			q = q.Where(tbl.ID.Eq(-1))
+		} else {
+			q = q.Where(tbl.TenantID.In(tenantIDs...))
+		}
+	}
+
+	userIDs, userFilter, err := s.lookupUserIDs(ctx, filter.Username)
+	if err != nil {
+		return nil, err
+	}
+	if userFilter {
+		if len(userIDs) == 0 {
+			q = q.Where(tbl.ID.Eq(-1))
+		} else {
+			q = q.Where(tbl.UserID.In(userIDs...))
+		}
+	}
+
+	if filter.ContentTitle != nil && strings.TrimSpace(*filter.ContentTitle) != "" {
+		contentTbl, contentQuery := models.ContentQuery.QueryContext(ctx)
+		keyword := "%" + strings.TrimSpace(*filter.ContentTitle) + "%"
+		contentQuery = contentQuery.Where(field.Or(
+			contentTbl.Title.Like(keyword),
+			contentTbl.Description.Like(keyword),
+			contentTbl.Summary.Like(keyword),
+		))
+		if filter.TenantID != nil && *filter.TenantID > 0 {
+			contentQuery = contentQuery.Where(contentTbl.TenantID.Eq(*filter.TenantID))
+		}
+		if tenantFilter {
+			if len(tenantIDs) == 0 {
+				q = q.Where(tbl.ID.Eq(-1))
+			} else {
+				contentQuery = contentQuery.Where(contentTbl.TenantID.In(tenantIDs...))
+			}
+		}
+		contentIDs, err := contentQuery.Select(contentTbl.ID).Find()
+		if err != nil {
+			return nil, errorx.ErrDatabaseError.WithCause(err)
+		}
+		ids := make([]int64, 0, len(contentIDs))
+		for _, content := range contentIDs {
+			ids = append(ids, content.ID)
+		}
+		if len(ids) == 0 {
+			q = q.Where(tbl.ID.Eq(-1))
+		} else {
+			q = q.Where(tbl.ContentID.In(ids...))
+		}
+	}
+
+	status := ""
+	if filter.Status != nil {
+		status = strings.TrimSpace(*filter.Status)
+	}
+	switch status {
+	case "deleted":
+		q = q.Unscoped().Where(tbl.DeletedAt.IsNotNull())
+	case "all":
+		q = q.Unscoped()
+	default:
+		q = q.Where(tbl.DeletedAt.IsNull())
+	}
+
+	if filter.CreatedAtFrom != nil {
+		from, err := s.parseFilterTime(filter.CreatedAtFrom)
+		if err != nil {
+			return nil, err
+		}
+		if from != nil {
+			q = q.Where(tbl.CreatedAt.Gte(*from))
+		}
+	}
+	if filter.CreatedAtTo != nil {
+		to, err := s.parseFilterTime(filter.CreatedAtTo)
+		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())
+		case "likes":
+			q = q.Order(tbl.Likes.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)
+		case "likes":
+			q = q.Order(tbl.Likes)
+		}
+		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:      0,
+			Items:      []super_dto.SuperCommentItem{},
+		}, nil
+	}
+
+	tenantSet := make(map[int64]struct{})
+	userSet := make(map[int64]struct{})
+	contentSet := make(map[int64]struct{})
+	for _, comment := range list {
+		tenantSet[comment.TenantID] = struct{}{}
+		userSet[comment.UserID] = struct{}{}
+		contentSet[comment.ContentID] = struct{}{}
+	}
+
+	tenantIDs = make([]int64, 0, len(tenantSet))
+	for id := range tenantSet {
+		tenantIDs = append(tenantIDs, id)
+	}
+	userIDs = make([]int64, 0, len(userSet))
+	for id := range userSet {
+		userIDs = append(userIDs, id)
+	}
+	contentIDs := make([]int64, 0, len(contentSet))
+	for id := range contentSet {
+		contentIDs = append(contentIDs, id)
+	}
+
+	tenantMap := make(map[int64]*models.Tenant, len(tenantIDs))
+	if len(tenantIDs) > 0 {
+		tenantTbl, tenantQuery := models.TenantQuery.QueryContext(ctx)
+		tenants, err := tenantQuery.Where(tenantTbl.ID.In(tenantIDs...)).Find()
+		if err != nil {
+			return nil, errorx.ErrDatabaseError.WithCause(err)
+		}
+		for _, tenant := range tenants {
+			tenantMap[tenant.ID] = tenant
+		}
+	}
+
+	userMap := make(map[int64]*models.User, len(userIDs))
+	if len(userIDs) > 0 {
+		userTbl, userQuery := models.UserQuery.QueryContext(ctx)
+		users, err := userQuery.Where(userTbl.ID.In(userIDs...)).Find()
+		if err != nil {
+			return nil, errorx.ErrDatabaseError.WithCause(err)
+		}
+		for _, user := range users {
+			userMap[user.ID] = user
+		}
+	}
+
+	contentMap := make(map[int64]*models.Content, len(contentIDs))
+	if len(contentIDs) > 0 {
+		contentTbl, contentQuery := models.ContentQuery.QueryContext(ctx)
+		contents, err := contentQuery.Where(contentTbl.ID.In(contentIDs...)).Find()
+		if err != nil {
+			return nil, errorx.ErrDatabaseError.WithCause(err)
+		}
+		for _, content := range contents {
+			contentMap[content.ID] = content
+		}
+	}
+
+	items := make([]super_dto.SuperCommentItem, 0, len(list))
+	for _, comment := range list {
+		tenant := tenantMap[comment.TenantID]
+		user := userMap[comment.UserID]
+		content := contentMap[comment.ContentID]
+
+		username := ""
+		if user != nil {
+			if user.Username != "" {
+				username = user.Username
+			} else {
+				username = user.Nickname
+			}
+		}
+
+		item := super_dto.SuperCommentItem{
+			ID:           comment.ID,
+			TenantID:     comment.TenantID,
+			ContentID:    comment.ContentID,
+			UserID:       comment.UserID,
+			ReplyTo:      comment.ReplyTo,
+			Content:      comment.Content,
+			Likes:        comment.Likes,
+			IsDeleted:    comment.DeletedAt.Valid,
+			CreatedAt:    s.formatTime(comment.CreatedAt),
+			TenantCode:   "",
+			TenantName:   "",
+			ContentTitle: "",
+			Username:     username,
+			DeletedAt:    "",
+		}
+		if tenant != nil {
+			item.TenantCode = tenant.Code
+			item.TenantName = tenant.Name
+		}
+		if content != nil {
+			item.ContentTitle = content.Title
+		}
+		if comment.DeletedAt.Valid {
+			item.DeletedAt = s.formatTime(comment.DeletedAt.Time)
+		}
+		items = append(items, item)
+	}
+
+	return &requests.Pager{
+		Pagination: filter.Pagination,
+		Total:      total,
+		Items:      items,
+	}, nil
+}
+
+func (s *super) DeleteComment(ctx context.Context, operatorID, id int64, form *super_dto.SuperCommentDeleteForm) error {
+	if operatorID == 0 {
+		return errorx.ErrUnauthorized.WithMsg("缺少操作者信息")
+	}
+
+	tbl, q := models.CommentQuery.QueryContext(ctx)
+	comment, err := q.Where(tbl.ID.Eq(id)).First()
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return errorx.ErrRecordNotFound
+		}
+		return errorx.ErrDatabaseError.WithCause(err)
+	}
+
+	// 评论删除采用软删除，便于审计追溯与误删恢复。
+	if _, err := q.Where(tbl.ID.Eq(id)).Delete(); err != nil {
+		return errorx.ErrDatabaseError.WithCause(err)
+	}
+
+	if Audit != nil {
+		reason := ""
+		if form != nil {
+			reason = strings.TrimSpace(form.Reason)
+		}
+		detail := "删除评论"
+		if reason != "" {
+			detail = "删除评论: " + reason
+		}
+		Audit.Log(ctx, comment.TenantID, operatorID, "delete_comment", cast.ToString(id), detail)
+	}
+	return nil
+}
+
 func (s *super) UpdateContentStatus(ctx context.Context, tenantID, contentID int64, form *super_dto.SuperTenantContentStatusUpdateForm) error {
 	tbl, q := models.ContentQuery.QueryContext(ctx)
 	_, err := q.Where(tbl.ID.Eq(contentID), tbl.TenantID.Eq(tenantID)).Update(tbl.Status, consts.ContentStatus(form.Status))
@@ -5192,6 +5492,519 @@ func (s *super) ListWithdrawals(ctx context.Context, filter *super_dto.SuperOrde
 	}, nil
 }

+func (s *super) ListLedgers(ctx context.Context, filter *super_dto.SuperLedgerListFilter) (*requests.Pager, error) {
+	if filter == nil {
+		filter = &super_dto.SuperLedgerListFilter{}
+	}
+
+	tbl, q := models.TenantLedgerQuery.QueryContext(ctx)
+	if filter.ID != nil && *filter.ID > 0 {
+		q = q.Where(tbl.ID.Eq(*filter.ID))
+	}
+	if filter.TenantID != nil && *filter.TenantID > 0 {
+		q = q.Where(tbl.TenantID.Eq(*filter.TenantID))
+	}
+	if filter.UserID != nil && *filter.UserID > 0 {
+		q = q.Where(tbl.UserID.Eq(*filter.UserID))
+	}
+	if filter.OrderID != nil && *filter.OrderID > 0 {
+		q = q.Where(tbl.OrderID.Eq(*filter.OrderID))
+	}
+	if filter.Type != nil && *filter.Type != "" {
+		q = q.Where(tbl.Type.Eq(*filter.Type))
+	}
+	if filter.AmountMin != nil {
+		q = q.Where(tbl.Amount.Gte(*filter.AmountMin))
+	}
+	if filter.AmountMax != nil {
+		q = q.Where(tbl.Amount.Lte(*filter.AmountMax))
+	}
+
+	tenantIDs, tenantFilter, err := s.lookupTenantIDs(ctx, filter.TenantCode, filter.TenantName)
+	if err != nil {
+		return nil, err
+	}
+	if tenantFilter {
+		if len(tenantIDs) == 0 {
+			q = q.Where(tbl.ID.Eq(-1))
+		} else {
+			q = q.Where(tbl.TenantID.In(tenantIDs...))
+		}
+	}
+
+	userIDs, userFilter, err := s.lookupUserIDs(ctx, filter.Username)
+	if err != nil {
+		return nil, err
+	}
+	if userFilter {
+		if len(userIDs) == 0 {
+			q = q.Where(tbl.ID.Eq(-1))
+		} else {
+			q = q.Where(tbl.UserID.In(userIDs...))
+		}
+	}
+
+	if filter.CreatedAtFrom != nil {
+		from, err := s.parseFilterTime(filter.CreatedAtFrom)
+		if err != nil {
+			return nil, err
+		}
+		if from != nil {
+			q = q.Where(tbl.CreatedAt.Gte(*from))
+		}
+	}
+	if filter.CreatedAtTo != nil {
+		to, err := s.parseFilterTime(filter.CreatedAtTo)
+		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())
+		case "amount":
+			q = q.Order(tbl.Amount.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)
+		case "amount":
+			q = q.Order(tbl.Amount)
+		}
+		orderApplied = true
+	}
+	if !orderApplied {
+		q = q.Order(tbl.ID.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)
+	}
+
+	tenantSet := make(map[int64]struct{})
+	userSet := make(map[int64]struct{})
+	for _, ledger := range list {
+		if ledger.TenantID > 0 {
+			tenantSet[ledger.TenantID] = struct{}{}
+		}
+		if ledger.UserID > 0 {
+			userSet[ledger.UserID] = struct{}{}
+		}
+	}
+
+	tenantIDs = make([]int64, 0, len(tenantSet))
+	for id := range tenantSet {
+		tenantIDs = append(tenantIDs, id)
+	}
+	userIDs = make([]int64, 0, len(userSet))
+	for id := range userSet {
+		userIDs = append(userIDs, id)
+	}
+
+	tenantMap := make(map[int64]*models.Tenant, len(tenantIDs))
+	if len(tenantIDs) > 0 {
+		tenantTbl, tenantQuery := models.TenantQuery.QueryContext(ctx)
+		tenants, err := tenantQuery.Where(tenantTbl.ID.In(tenantIDs...)).Find()
+		if err != nil {
+			return nil, errorx.ErrDatabaseError.WithCause(err)
+		}
+		for _, tenant := range tenants {
+			tenantMap[tenant.ID] = tenant
+		}
+	}
+
+	userMap := make(map[int64]*models.User, len(userIDs))
+	if len(userIDs) > 0 {
+		userTbl, userQuery := models.UserQuery.QueryContext(ctx)
+		users, err := userQuery.Where(userTbl.ID.In(userIDs...)).Find()
+		if err != nil {
+			return nil, errorx.ErrDatabaseError.WithCause(err)
+		}
+		for _, user := range users {
+			userMap[user.ID] = user
+		}
+	}
+
+	items := make([]super_dto.SuperLedgerItem, 0, len(list))
+	for _, ledger := range list {
+		item := super_dto.SuperLedgerItem{
+			ID:              ledger.ID,
+			TenantID:        ledger.TenantID,
+			UserID:          ledger.UserID,
+			OrderID:         ledger.OrderID,
+			Type:            ledger.Type,
+			TypeDescription: ledger.Type.Description(),
+			Amount:          ledger.Amount,
+			BalanceBefore:   ledger.BalanceBefore,
+			BalanceAfter:    ledger.BalanceAfter,
+			FrozenBefore:    ledger.FrozenBefore,
+			FrozenAfter:     ledger.FrozenAfter,
+			Remark:          ledger.Remark,
+			OperatorUserID:  ledger.OperatorUserID,
+			BizRefType:      ledger.BizRefType,
+			BizRefID:        ledger.BizRefID,
+			CreatedAt:       s.formatTime(ledger.CreatedAt),
+			UpdatedAt:       s.formatTime(ledger.UpdatedAt),
+			TenantCode:      "",
+			TenantName:      "",
+			Username:        "",
+		}
+		if tenant := tenantMap[ledger.TenantID]; tenant != nil {
+			item.TenantCode = tenant.Code
+			item.TenantName = tenant.Name
+		}
+		if user := userMap[ledger.UserID]; user != nil {
+			if user.Username != "" {
+				item.Username = user.Username
+			} else {
+				item.Username = user.Nickname
+			}
+		}
+		items = append(items, item)
+	}
+
+	return &requests.Pager{
+		Pagination: filter.Pagination,
+		Total:      total,
+		Items:      items,
+	}, nil
+}
+
+func (s *super) ListBalanceAnomalies(ctx context.Context, filter *super_dto.SuperBalanceAnomalyFilter) (*requests.Pager, error) {
+	if filter == nil {
+		filter = &super_dto.SuperBalanceAnomalyFilter{}
+	}
+
+	tbl, q := models.UserQuery.QueryContext(ctx)
+	if filter.UserID != nil && *filter.UserID > 0 {
+		q = q.Where(tbl.ID.Eq(*filter.UserID))
+	}
+	if filter.Username != nil && strings.TrimSpace(*filter.Username) != "" {
+		keyword := "%" + strings.TrimSpace(*filter.Username) + "%"
+		q = q.Where(field.Or(tbl.Username.Like(keyword), tbl.Nickname.Like(keyword)))
+	}
+
+	issue := ""
+	if filter.Issue != nil {
+		issue = strings.TrimSpace(*filter.Issue)
+	}
+	switch issue {
+	case "negative_balance":
+		q = q.Where(tbl.Balance.Lt(0))
+	case "negative_frozen":
+		q = q.Where(tbl.BalanceFrozen.Lt(0))
+	default:
+		q = q.Where(field.Or(tbl.Balance.Lt(0), tbl.BalanceFrozen.Lt(0)))
+	}
+
+	orderApplied := false
+	if filter.Desc != nil && strings.TrimSpace(*filter.Desc) != "" {
+		switch strings.TrimSpace(*filter.Desc) {
+		case "id":
+			q = q.Order(tbl.ID.Desc())
+		case "balance":
+			q = q.Order(tbl.Balance.Desc())
+		case "balance_frozen":
+			q = q.Order(tbl.BalanceFrozen.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 "balance":
+			q = q.Order(tbl.Balance)
+		case "balance_frozen":
+			q = q.Order(tbl.BalanceFrozen)
+		}
+		orderApplied = true
+	}
+	if !orderApplied {
+		q = q.Order(tbl.ID.Desc())
+	}
+
+	// 余额异常用于发现负余额或冻结异常的账号。
+	filter.Pagination.Format()
+	total, err := q.Count()
+	if err != nil {
+		return nil, errorx.ErrDatabaseError.WithCause(err)
+	}
+	users, err := q.Offset(int(filter.Pagination.Offset())).Limit(int(filter.Pagination.Limit)).Find()
+	if err != nil {
+		return nil, errorx.ErrDatabaseError.WithCause(err)
+	}
+
+	items := make([]super_dto.SuperBalanceAnomalyItem, 0, len(users))
+	for _, user := range users {
+		itemIssue := "negative_balance"
+		itemDesc := "可用余额为负"
+		if user.Balance < 0 && user.BalanceFrozen < 0 {
+			itemIssue = "negative_balance"
+			itemDesc = "可用余额与冻结余额均为负"
+		} else if user.BalanceFrozen < 0 {
+			itemIssue = "negative_frozen"
+			itemDesc = "冻结余额为负"
+		}
+
+		username := user.Username
+		if username == "" {
+			username = user.Nickname
+		}
+		items = append(items, super_dto.SuperBalanceAnomalyItem{
+			UserID:           user.ID,
+			Username:         username,
+			Balance:          user.Balance,
+			BalanceFrozen:    user.BalanceFrozen,
+			Issue:            itemIssue,
+			IssueDescription: itemDesc,
+			CreatedAt:        s.formatTime(user.CreatedAt),
+		})
+	}
+
+	return &requests.Pager{
+		Pagination: filter.Pagination,
+		Total:      total,
+		Items:      items,
+	}, nil
+}
+
+func (s *super) ListOrderAnomalies(ctx context.Context, filter *super_dto.SuperOrderAnomalyFilter) (*requests.Pager, error) {
+	if filter == nil {
+		filter = &super_dto.SuperOrderAnomalyFilter{}
+	}
+
+	tbl, q := models.OrderQuery.QueryContext(ctx)
+	if filter.ID != nil && *filter.ID > 0 {
+		q = q.Where(tbl.ID.Eq(*filter.ID))
+	}
+	if filter.TenantID != nil && *filter.TenantID > 0 {
+		q = q.Where(tbl.TenantID.Eq(*filter.TenantID))
+	}
+	if filter.UserID != nil && *filter.UserID > 0 {
+		q = q.Where(tbl.UserID.Eq(*filter.UserID))
+	}
+	if filter.Type != nil && *filter.Type != "" {
+		q = q.Where(tbl.Type.Eq(*filter.Type))
+	}
+
+	tenantIDs, tenantFilter, err := s.lookupTenantIDs(ctx, filter.TenantCode, filter.TenantName)
+	if err != nil {
+		return nil, err
+	}
+	if tenantFilter {
+		if len(tenantIDs) == 0 {
+			q = q.Where(tbl.ID.Eq(-1))
+		} else {
+			q = q.Where(tbl.TenantID.In(tenantIDs...))
+		}
+	}
+
+	userIDs, userFilter, err := s.lookupUserIDs(ctx, filter.Username)
+	if err != nil {
+		return nil, err
+	}
+	if userFilter {
+		if len(userIDs) == 0 {
+			q = q.Where(tbl.ID.Eq(-1))
+		} else {
+			q = q.Where(tbl.UserID.In(userIDs...))
+		}
+	}
+
+	if filter.CreatedAtFrom != nil {
+		from, err := s.parseFilterTime(filter.CreatedAtFrom)
+		if err != nil {
+			return nil, err
+		}
+		if from != nil {
+			q = q.Where(tbl.CreatedAt.Gte(*from))
+		}
+	}
+	if filter.CreatedAtTo != nil {
+		to, err := s.parseFilterTime(filter.CreatedAtTo)
+		if err != nil {
+			return nil, err
+		}
+		if to != nil {
+			q = q.Where(tbl.CreatedAt.Lte(*to))
+		}
+	}
+
+	issue := ""
+	if filter.Issue != nil {
+		issue = strings.TrimSpace(*filter.Issue)
+	}
+	zeroTime := time.Time{}
+	missingPaid := field.Or(tbl.PaidAt.IsNull(), tbl.PaidAt.Lte(zeroTime))
+	missingRefund := field.Or(tbl.RefundedAt.IsNull(), tbl.RefundedAt.Lte(zeroTime))
+	switch issue {
+	case "missing_paid_at":
+		q = q.Where(tbl.Status.Eq(consts.OrderStatusPaid), missingPaid)
+	case "missing_refunded_at":
+		q = q.Where(tbl.Status.Eq(consts.OrderStatusRefunded), missingRefund)
+	default:
+		q = q.Where(field.Or(
+			field.And(tbl.Status.Eq(consts.OrderStatusPaid), missingPaid),
+			field.And(tbl.Status.Eq(consts.OrderStatusRefunded), missingRefund),
+		))
+	}
+
+	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())
+		case "amount_paid":
+			q = q.Order(tbl.AmountPaid.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)
+		case "amount_paid":
+			q = q.Order(tbl.AmountPaid)
+		}
+		orderApplied = true
+	}
+	if !orderApplied {
+		q = q.Order(tbl.ID.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)
+	}
+
+	tenantSet := make(map[int64]struct{})
+	userSet := make(map[int64]struct{})
+	for _, order := range list {
+		if order.TenantID > 0 {
+			tenantSet[order.TenantID] = struct{}{}
+		}
+		if order.UserID > 0 {
+			userSet[order.UserID] = struct{}{}
+		}
+	}
+
+	tenantIDs = make([]int64, 0, len(tenantSet))
+	for id := range tenantSet {
+		tenantIDs = append(tenantIDs, id)
+	}
+	userIDs = make([]int64, 0, len(userSet))
+	for id := range userSet {
+		userIDs = append(userIDs, id)
+	}
+
+	tenantMap := make(map[int64]*models.Tenant, len(tenantIDs))
+	if len(tenantIDs) > 0 {
+		tenantTbl, tenantQuery := models.TenantQuery.QueryContext(ctx)
+		tenants, err := tenantQuery.Where(tenantTbl.ID.In(tenantIDs...)).Find()
+		if err != nil {
+			return nil, errorx.ErrDatabaseError.WithCause(err)
+		}
+		for _, tenant := range tenants {
+			tenantMap[tenant.ID] = tenant
+		}
+	}
+
+	userMap := make(map[int64]*models.User, len(userIDs))
+	if len(userIDs) > 0 {
+		userTbl, userQuery := models.UserQuery.QueryContext(ctx)
+		users, err := userQuery.Where(userTbl.ID.In(userIDs...)).Find()
+		if err != nil {
+			return nil, errorx.ErrDatabaseError.WithCause(err)
+		}
+		for _, user := range users {
+			userMap[user.ID] = user
+		}
+	}
+
+	items := make([]super_dto.SuperOrderAnomalyItem, 0, len(list))
+	for _, order := range list {
+		itemIssue := "missing_paid_at"
+		itemDesc := "已支付但缺失支付时间"
+		if order.Status == consts.OrderStatusRefunded && order.RefundedAt.IsZero() {
+			itemIssue = "missing_refunded_at"
+			itemDesc = "已退款但缺失退款时间"
+		}
+
+		tenant := tenantMap[order.TenantID]
+		user := userMap[order.UserID]
+		username := ""
+		if user != nil {
+			if user.Username != "" {
+				username = user.Username
+			} else {
+				username = user.Nickname
+			}
+		}
+
+		item := super_dto.SuperOrderAnomalyItem{
+			OrderID:          order.ID,
+			TenantID:         order.TenantID,
+			UserID:           order.UserID,
+			Type:             order.Type,
+			Status:           order.Status,
+			AmountPaid:       order.AmountPaid,
+			Issue:            itemIssue,
+			IssueDescription: itemDesc,
+			CreatedAt:        s.formatTime(order.CreatedAt),
+			PaidAt:           "",
+			RefundedAt:       "",
+			TenantCode:       "",
+			TenantName:       "",
+			Username:         username,
+		}
+
+		if tenant != nil {
+			item.TenantCode = tenant.Code
+			item.TenantName = tenant.Name
+		}
+		if !order.PaidAt.IsZero() {
+			item.PaidAt = s.formatTime(order.PaidAt)
+		}
+		if !order.RefundedAt.IsZero() {
+			item.RefundedAt = s.formatTime(order.RefundedAt)
+		}
+		items = append(items, item)
+	}
+
+	return &requests.Pager{
+		Pagination: filter.Pagination,
+		Total:      total,
+		Items:      items,
+	}, nil
+}
+
 func (s *super) ListCoupons(ctx context.Context, filter *super_dto.SuperCouponListFilter) (*requests.Pager, error) {
 	if filter == nil {
 		filter = &super_dto.SuperCouponListFilter{}
--- a/backend/app/services/super_test.go
+++ b/backend/app/services/super_test.go
@@ -220,6 +220,122 @@ func (s *SuperTestSuite) Test_WithdrawalApproval() {
 	})
 }

+func (s *SuperTestSuite) Test_CommentGovernance() {
+	Convey("Comment Governance", s.T(), func() {
+		ctx := s.T().Context()
+		database.Truncate(ctx, s.DB, models.TableNameComment, models.TableNameContent, models.TableNameTenant, models.TableNameUser)
+
+		owner := &models.User{Username: "owner_comment"}
+		commenter := &models.User{Username: "commenter"}
+		admin := &models.User{Username: "admin_comment"}
+		models.UserQuery.WithContext(ctx).Create(owner, commenter, admin)
+
+		tenant := &models.Tenant{UserID: owner.ID, Code: "t-comment", Name: "Comment Tenant", Status: consts.TenantStatusVerified}
+		models.TenantQuery.WithContext(ctx).Create(tenant)
+
+		content := &models.Content{
+			TenantID:    tenant.ID,
+			UserID:      owner.ID,
+			Title:       "Comment Content",
+			Description: "Desc",
+		}
+		models.ContentQuery.WithContext(ctx).Create(content)
+
+		Convey("should list comments", func() {
+			comment := &models.Comment{
+				TenantID:  tenant.ID,
+				UserID:    commenter.ID,
+				ContentID: content.ID,
+				Content:   "Nice work",
+			}
+			models.CommentQuery.WithContext(ctx).Create(comment)
+
+			filter := &super_dto.SuperCommentListFilter{
+				Pagination: requests.Pagination{Page: 1, Limit: 10},
+			}
+			res, err := Super.ListComments(ctx, filter)
+			So(err, ShouldBeNil)
+			So(res.Total, ShouldEqual, 1)
+			items := res.Items.([]super_dto.SuperCommentItem)
+			So(items[0].ContentTitle, ShouldEqual, "Comment Content")
+			So(items[0].Username, ShouldEqual, commenter.Username)
+		})
+
+		Convey("should delete comment", func() {
+			comment := &models.Comment{
+				TenantID:  tenant.ID,
+				UserID:    commenter.ID,
+				ContentID: content.ID,
+				Content:   "Spam content",
+			}
+			models.CommentQuery.WithContext(ctx).Create(comment)
+
+			err := Super.DeleteComment(ctx, admin.ID, comment.ID, &super_dto.SuperCommentDeleteForm{Reason: "spam"})
+			So(err, ShouldBeNil)
+
+			deleted, err := models.CommentQuery.WithContext(ctx).Unscoped().Where(models.CommentQuery.ID.Eq(comment.ID)).First()
+			So(err, ShouldBeNil)
+			So(deleted.DeletedAt.Valid, ShouldBeTrue)
+
+			filter := &super_dto.SuperCommentListFilter{
+				Pagination: requests.Pagination{Page: 1, Limit: 10},
+			}
+			res, err := Super.ListComments(ctx, filter)
+			So(err, ShouldBeNil)
+			So(res.Total, ShouldEqual, 0)
+		})
+	})
+}
+
+func (s *SuperTestSuite) Test_FinanceAnomalies() {
+	Convey("Finance Anomalies", s.T(), func() {
+		ctx := s.T().Context()
+		database.Truncate(ctx, s.DB, models.TableNameOrder, models.TableNameTenant, models.TableNameUser)
+
+		user := &models.User{Username: "finance_user", Balance: -100}
+		models.UserQuery.WithContext(ctx).Create(user)
+
+		tenant := &models.Tenant{UserID: user.ID, Code: "t-fin", Name: "Finance Tenant", Status: consts.TenantStatusVerified}
+		models.TenantQuery.WithContext(ctx).Create(tenant)
+
+		order := &models.Order{
+			TenantID:       tenant.ID,
+			UserID:         user.ID,
+			Type:           consts.OrderTypeRecharge,
+			Status:         consts.OrderStatusPaid,
+			AmountOriginal: 100,
+			AmountDiscount: 0,
+			AmountPaid:     100,
+			IdempotencyKey: "anomaly-paid",
+		}
+		models.OrderQuery.WithContext(ctx).Create(order)
+
+		Convey("should list balance anomalies", func() {
+			filter := &super_dto.SuperBalanceAnomalyFilter{
+				Pagination: requests.Pagination{Page: 1, Limit: 10},
+			}
+			res, err := Super.ListBalanceAnomalies(ctx, filter)
+			So(err, ShouldBeNil)
+			So(res.Total, ShouldEqual, 1)
+			items := res.Items.([]super_dto.SuperBalanceAnomalyItem)
+			So(items[0].UserID, ShouldEqual, user.ID)
+			So(items[0].Issue, ShouldEqual, "negative_balance")
+		})
+
+		Convey("should list order anomalies", func() {
+			filter := &super_dto.SuperOrderAnomalyFilter{
+				Pagination: requests.Pagination{Page: 1, Limit: 10},
+			}
+			res, err := Super.ListOrderAnomalies(ctx, filter)
+			So(err, ShouldBeNil)
+			So(res.Total, ShouldEqual, 1)
+			items := res.Items.([]super_dto.SuperOrderAnomalyItem)
+			So(items[0].OrderID, ShouldEqual, order.ID)
+			So(items[0].Issue, ShouldEqual, "missing_paid_at")
+		})
+	})
+}
+
 func (s *SuperTestSuite) Test_TenantHealth() {
 	Convey("TenantHealth", s.T(), func() {
 		ctx := s.T().Context()