feat(payment): 支付管理 - 合并 PR #533 支付订单与对账 CSV 导出

Co-authored-by: Cursor <cursoragent@cursor.com>

backend/internal/app/payment.go

@@ -929,12 +929,16 @@ func paymentOrderView(order model.PaymentOrder) PaymentOrderView {
 	}
 }
 
-func (s *Service) AdminPaymentOrderPage(actor *model.User, status, keyword string, page, limit int) (*AdminPaymentOrderPage, error) {
+func (s *Service) AdminPaymentOrderPage(actor *model.User, query PaymentOrderQuery, page, limit int) (*AdminPaymentOrderPage, error) {
 	if err := s.RequireAdmin(actor); err != nil {
 		return nil, err
 	}
 	page, limit = normalizeAdminPage(page, limit)
-	orders, total, err := s.repo.AdminPaymentOrders(status, keyword, limit, (page-1)*limit)
+	filter, err := query.filter()
+	if err != nil {
+		return nil, err
+	}
+	orders, total, err := s.repo.AdminPaymentOrders(filter, limit, (page-1)*limit)
 	if err != nil {
 		return nil, err
 	}

backend/internal/app/payment_export.go

@@ -0,0 +1,256 @@
+package app
+
+import (
+	"bytes"
+	"context"
+	"encoding/csv"
+	"errors"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+
+	"infinite-canvas/backend/internal/model"
+	"infinite-canvas/backend/internal/repository"
+)
+
+const paymentExportLimit = 10_000
+
+type PaymentOrderQuery struct {
+	Status, Keyword, ProviderID, TimeField, From, To string
+}
+
+type PaymentReconciliationQuery struct {
+	ProviderID, Status, From, To string
+}
+
+func paymentDateRange(from, to string) (time.Time, time.Time, error) {
+	var start, end time.Time
+	var err error
+	if from != "" {
+		start, err = time.ParseInLocation("2006-01-02", from, paymentBillLocation)
+		if err != nil {
+			return start, end, BadAuthRequest("开始日期格式必须为 YYYY-MM-DD")
+		}
+	}
+	if to != "" {
+		end, err = time.ParseInLocation("2006-01-02", to, paymentBillLocation)
+		if err != nil {
+			return start, end, BadAuthRequest("结束日期格式必须为 YYYY-MM-DD")
+		}
+		if !start.IsZero() && end.Before(start) {
+			return start, end, BadAuthRequest("结束日期不能早于开始日期")
+		}
+		end = end.AddDate(0, 0, 1)
+	}
+	return start, end, nil
+}
+
+func (q PaymentOrderQuery) filter() (repository.PaymentOrderFilter, error) {
+	f := repository.PaymentOrderFilter{Status: strings.TrimSpace(q.Status), Keyword: strings.TrimSpace(q.Keyword), ProviderID: strings.TrimSpace(q.ProviderID), TimeField: q.TimeField}
+	switch f.Status {
+	case "", "all", "created", "pending", "closing", "closed", "credited", "create_failed":
+	default:
+		return f, BadAuthRequest("无效的订单状态")
+	}
+	switch f.TimeField {
+	case "", "created", "paid", "credited":
+	default:
+		return f, BadAuthRequest("无效的订单时间口径")
+	}
+	var err error
+	f.From, f.Until, err = paymentDateRange(q.From, q.To)
+	return f, err
+}
+
+func (q PaymentReconciliationQuery) filter() (repository.PaymentReconciliationFilter, error) {
+	f := repository.PaymentReconciliationFilter{ProviderID: strings.TrimSpace(q.ProviderID), Status: strings.TrimSpace(q.Status), From: q.From, To: q.To}
+	switch f.Status {
+	case "", "all", "running", "completed", "failed":
+	default:
+		return f, BadAuthRequest("无效的对账状态")
+	}
+	_, _, err := paymentDateRange(q.From, q.To)
+	return f, err
+}
+
+func validatePaymentResult(result string) error {
+	switch result {
+	case "", "all", "abnormal", "matched", "recovered", "local_order_not_found", "provider_record_missing", "amount_mismatch", "trade_no_mismatch", "credit_failed":
+		return nil
+	default:
+		return BadAuthRequest("无效的对账结果")
+	}
+}
+
+func (s *Service) AdminPaymentOrdersCSV(ctx context.Context, actor *model.User, query PaymentOrderQuery) ([]byte, error) {
+	if err := s.RequireAdmin(actor); err != nil {
+		return nil, err
+	}
+	filter, err := query.filter()
+	if err != nil {
+		return nil, err
+	}
+	orders, users, err := s.repo.WithContext(ctx).ExportPaymentOrders(filter, paymentExportLimit+1)
+	if err != nil {
+		return nil, err
+	}
+	if err := checkPaymentExportSize(len(orders)); err != nil {
+		return nil, err
+	}
+	rows := [][]string{{"订单ID", "商户订单号", "渠道交易号", "用户ID", "用户名", "显示名称", "邮箱", "商品名称", "支付渠道", "金额（元）", "币种", "积分", "订单状态", "渠道状态", "创建时间（北京时间）", "支付时间（北京时间）", "入账时间（北京时间）", "关闭时间（北京时间）"}}
+	for _, order := range orders {
+		user := users[order.UserID]
+		trade := ""
+		if order.ProviderTradeNo != nil {
+			trade = *order.ProviderTradeNo
+		}
+		rows = append(rows, []string{paymentCSVIdentifier(order.ID), paymentCSVIdentifier(order.MerchantOrderNo), paymentCSVIdentifier(trade), paymentCSVIdentifier(order.UserID), user.Username, user.DisplayName, user.Email, order.ProductName, s.paymentExportProviderName(order.ProviderID), paymentDecimal(order.AmountFen, 2, false), order.Currency, paymentDecimal(order.CreditsMicrocredits, 6, true), paymentExportLabel(string(order.Status)), order.ProviderStatus, paymentCSVTime(&order.CreatedAt), paymentCSVTime(order.ProviderPaidAt), paymentCSVTime(order.CreditedAt), paymentCSVTime(order.ClosedAt)})
+	}
+	return paymentCSV(rows)
+}
+
+func (s *Service) AdminPaymentReconciliationsCSV(ctx context.Context, actor *model.User, query PaymentReconciliationQuery) ([]byte, error) {
+	if err := s.RequireAdmin(actor); err != nil {
+		return nil, err
+	}
+	filter, err := query.filter()
+	if err != nil {
+		return nil, err
+	}
+	runs, err := s.repo.WithContext(ctx).ExportPaymentReconciliations(filter, paymentExportLimit+1)
+	if err != nil {
+		return nil, err
+	}
+	if err := checkPaymentExportSize(len(runs)); err != nil {
+		return nil, err
+	}
+	rows := [][]string{{"对账记录ID", "账单日期", "支付渠道", "执行状态", "总笔数", "一致笔数", "自动补发笔数", "异常笔数", "失败原因", "发起人ID／系统", "开始时间（北京时间）", "完成时间（北京时间）"}}
+	for _, run := range runs {
+		actor := run.StartedBy
+		if actor == "system" {
+			actor = "系统"
+		}
+		rows = append(rows, []string{paymentCSVIdentifier(run.ID), run.BillDate, s.paymentExportProviderName(run.ProviderID), paymentExportLabel(string(run.Status)), strconv.Itoa(run.TotalItems), strconv.Itoa(run.MatchItems), strconv.Itoa(run.RecoveredItems), strconv.Itoa(run.ErrorItems), run.Error, paymentCSVIdentifier(actor), paymentCSVTime(&run.StartedAt), paymentCSVTime(run.CompletedAt)})
+	}
+	return paymentCSV(rows)
+}
+
+func (s *Service) AdminPaymentReconciliationItemsCSV(ctx context.Context, actor *model.User, runID, result string) ([]byte, error) {
+	if err := s.RequireAdmin(actor); err != nil {
+		return nil, err
+	}
+	if err := validatePaymentResult(result); err != nil {
+		return nil, err
+	}
+	run, items, err := s.repo.WithContext(ctx).ExportPaymentReconciliationItems(runID, result, paymentExportLimit+1)
+	if errors.Is(err, repository.ErrPaymentReconciliationRunning) {
+		return nil, NewAppError(http.StatusConflict, "对账正在执行，请完成后再导出")
+	}
+	if err != nil {
+		return nil, err
+	}
+	if run.Status != model.PaymentReconciliationCompleted {
+		return nil, NewAppError(http.StatusConflict, "本次对账未完成，请导出汇总查看失败原因")
+	}
+	if err := checkPaymentExportSize(len(items)); err != nil {
+		return nil, err
+	}
+	rows := [][]string{{"对账记录ID", "账单日期", "支付渠道", "本地订单ID", "商户订单号", "渠道交易号", "记录金额（元）", "金额来源", "币种", "对账结果", "是否已解决", "异常说明", "对账开始时间（北京时间）", "对账完成时间（北京时间）"}}
+	for _, item := range items {
+		source, resolved := "渠道账单", "否"
+		if item.Result == model.PaymentReconciliationProviderRecordMissing {
+			source = "本地订单"
+		}
+		if item.Resolved {
+			resolved = "是"
+		}
+		rows = append(rows, []string{paymentCSVIdentifier(run.ID), run.BillDate, s.paymentExportProviderName(run.ProviderID), paymentCSVIdentifier(item.PaymentOrderID), paymentCSVIdentifier(item.MerchantOrderNo), paymentCSVIdentifier(item.ProviderTradeNo), paymentDecimal(item.AmountFen, 2, false), source, item.Currency, paymentExportLabel(string(item.Result)), resolved, item.Detail, paymentCSVTime(&run.StartedAt), paymentCSVTime(run.CompletedAt)})
+	}
+	return paymentCSV(rows)
+}
+
+func checkPaymentExportSize(size int) error {
+	if size > paymentExportLimit {
+		return BadAuthRequest("单次最多导出 10000 行，请缩小筛选范围后重试")
+	}
+	return nil
+}
+
+func paymentCSV(rows [][]string) ([]byte, error) {
+	var buffer bytes.Buffer
+	buffer.WriteString("\xEF\xBB\xBF")
+	writer := csv.NewWriter(&buffer)
+	writer.UseCRLF = true
+	for _, row := range rows {
+		for i, value := range row {
+			row[i] = paymentCSVText(value)
+		}
+		if err := writer.Write(row); err != nil {
+			return nil, err
+		}
+	}
+	writer.Flush()
+	return buffer.Bytes(), writer.Error()
+}
+
+func paymentCSVText(value string) string {
+	trimmed := strings.TrimLeftFunc(value, func(r rune) bool { return unicode.IsSpace(r) || unicode.IsControl(r) || r == '\uFEFF' })
+	if strings.ContainsAny(value, "\t\r\n") || (trimmed != "" && strings.ContainsRune("=+-@", rune(trimmed[0]))) {
+		return "'" + value
+	}
+	return value
+}
+
+func paymentCSVIdentifier(value string) string {
+	// CSV cannot declare text types. Prefix numeric/scientific IDs with a literal
+	// apostrophe, never a formula; generic CSV consumers may remove this prefix.
+	if value != "" {
+		if _, err := strconv.ParseFloat(strings.TrimSpace(value), 64); err == nil {
+			return "'" + value
+		}
+	}
+	return value
+}
+
+func paymentDecimal(value int64, places int, trim bool) string {
+	// Format integers directly to avoid rounding microcredits through float64.
+	digits := strconv.FormatInt(value, 10)
+	sign := ""
+	if strings.HasPrefix(digits, "-") {
+		sign, digits = "-", digits[1:]
+	}
+	if len(digits) <= places {
+		digits = strings.Repeat("0", places+1-len(digits)) + digits
+	}
+	result := sign + digits[:len(digits)-places] + "." + digits[len(digits)-places:]
+	if trim {
+		result = strings.TrimRight(strings.TrimRight(result, "0"), ".")
+	}
+	return result
+}
+
+func paymentCSVTime(value *time.Time) string {
+	if value == nil || value.IsZero() {
+		return ""
+	}
+	return value.In(paymentBillLocation).Format("2006-01-02 15:04:05")
+}
+
+func (s *Service) paymentExportProviderName(id string) string {
+	if s.paymentRegistry != nil {
+		if provider, ok := s.paymentRegistry.Get(id); ok {
+			return provider.Descriptor().Name
+		}
+	}
+	return id
+}
+
+func paymentExportLabel(value string) string {
+	labels := map[string]string{"created": "创建中", "pending": "待支付", "closing": "关单中", "closed": "已关闭", "credited": "已入账", "create_failed": "下单失败", "running": "执行中", "completed": "已完成", "failed": "失败", "matched": "一致", "recovered": "已自动补发", "local_order_not_found": "本地订单缺失", "provider_record_missing": "渠道记录缺失", "amount_mismatch": "金额不一致", "trade_no_mismatch": "交易号不一致", "credit_failed": "补发失败"}
+	if label, ok := labels[value]; ok {
+		return label
+	}
+	return value
+}

backend/internal/app/payment_export_test.go

@@ -0,0 +1,220 @@
+package app
+
+import (
+	"context"
+	"encoding/csv"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+
+	"infinite-canvas/backend/internal/model"
+	"infinite-canvas/backend/internal/repository"
+
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+)
+
+func TestPaymentCSVEncodingAndPrecision(t *testing.T) {
+	id := "000123456789012345678901234567890"
+	rows := [][]string{{"名称", "订单号", "金额", "积分", "备注"}, {"中文,\"名称\"", paymentCSVIdentifier(id), paymentDecimal(1001, 2, false), paymentDecimal(999999999999999, 6, true), "换行\n说明"}, {" \t=HYPERLINK(\"evil\")", paymentCSVIdentifier("12E20"), "", "", "@SUM(1)"}}
+	data, err := paymentCSV(rows)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.HasPrefix(string(data), "\xEF\xBB\xBF") || !strings.Contains(string(data), "\r\n") {
+		t.Fatalf("missing BOM/CRLF: %q", data)
+	}
+	parsed, err := csv.NewReader(strings.NewReader(strings.TrimPrefix(string(data), "\xEF\xBB\xBF"))).ReadAll()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if parsed[1][0] != "中文,\"名称\"" || parsed[1][1] != "'"+id || parsed[1][2] != "10.01" || parsed[1][3] != "999999999.999999" {
+		t.Fatalf("lost precision or escaping: %#v", parsed[1])
+	}
+	if !strings.HasPrefix(parsed[2][0], "'") || parsed[2][1] != "'12E20" || parsed[2][4] != "'@SUM(1)" {
+		t.Fatalf("unsafe cell: %#v", parsed[2])
+	}
+	for _, dangerous := range []string{"=1", "+1", "-1", "@SUM(1)", " \r=1", "\uFEFF=1", "\x00=1"} {
+		if !strings.HasPrefix(paymentCSVText(dangerous), "'") {
+			t.Fatalf("unsafe: %q", dangerous)
+		}
+	}
+	if paymentDecimal(1, 6, true) != "0.000001" || paymentDecimal(1000000, 6, true) != "1" || paymentDecimal(0, 2, false) != "0.00" {
+		t.Fatal("invalid decimal formatting")
+	}
+	if paymentCSVTime(nil) != "" {
+		t.Fatal("nil date should be empty")
+	}
+}
+
+func TestPaymentExportDateValidation(t *testing.T) {
+	f, err := (PaymentOrderQuery{From: "2026-09-01", To: "2026-09-01", TimeField: "paid"}).filter()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if f.From.UTC().Format(time.RFC3339) != "2026-08-31T16:00:00Z" || f.Until.Sub(f.From) != 24*time.Hour {
+		t.Fatalf("wrong date bounds: %#v", f)
+	}
+	for _, query := range []PaymentOrderQuery{{From: "2026-02-30"}, {To: "2026-9-1"}, {From: "2026-09-02", To: "2026-09-01"}, {TimeField: "created_at; DELETE"}, {Status: "unknown"}} {
+		if _, err := query.filter(); err == nil {
+			t.Fatalf("accepted invalid query: %#v", query)
+		}
+	}
+	if _, err := (PaymentReconciliationQuery{Status: "unknown"}).filter(); err == nil {
+		t.Fatal("accepted invalid run status")
+	}
+	if validatePaymentResult("abnormal") != nil || validatePaymentResult("unknown") == nil {
+		t.Fatal("invalid result validation")
+	}
+	if checkPaymentExportSize(10000) != nil || checkPaymentExportSize(10001) == nil {
+		t.Fatal("export limit is not enforced")
+	}
+}
+
+func TestPaymentExportsRequireAdmin(t *testing.T) {
+	s := &Service{}
+	for _, actor := range []*model.User{nil, {Role: model.UserRoleUser}} {
+		for _, export := range []func() ([]byte, error){
+			func() ([]byte, error) {
+				return s.AdminPaymentOrdersCSV(context.Background(), actor, PaymentOrderQuery{})
+			},
+			func() ([]byte, error) {
+				return s.AdminPaymentReconciliationsCSV(context.Background(), actor, PaymentReconciliationQuery{})
+			},
+			func() ([]byte, error) {
+				return s.AdminPaymentReconciliationItemsCSV(context.Background(), actor, "run", "")
+			},
+		} {
+			if _, err := export(); err == nil {
+				t.Fatal("non-admin export accepted")
+			}
+		}
+	}
+}
+
+func TestPaymentExportsAllRowsAndReconciliationSemantics(t *testing.T) {
+	db, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=shared"), &gorm.Config{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	sqlDB, _ := db.DB()
+	t.Cleanup(func() { _ = sqlDB.Close() })
+	if err := db.AutoMigrate(&model.User{}, &model.PaymentOrder{}, &model.PaymentReconciliationRun{}, &model.PaymentReconciliationItem{}); err != nil {
+		t.Fatal(err)
+	}
+	s := &Service{repo: repository.New(db)}
+	admin := &model.User{ID: "admin", Role: model.UserRoleAdmin}
+	now := time.Date(2026, 9, 17, 8, 0, 0, 0, time.UTC)
+	orders := make([]model.PaymentOrder, 31)
+	for i := range orders {
+		orders[i] = model.PaymentOrder{ID: fmt.Sprint(i), UserID: "missing", IdempotencyKey: fmt.Sprint(i), MerchantOrderNo: fmt.Sprintf("000000000000000000%02d", i), AmountFen: 1001, CreditsMicrocredits: 1000001, CreatedAt: now}
+	}
+	if err := db.Create(&orders).Error; err != nil {
+		t.Fatal(err)
+	}
+	data, err := s.AdminPaymentOrdersCSV(context.Background(), admin, PaymentOrderQuery{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := readPaymentTestCSV(t, data)
+	if len(rows) != 32 || rows[1][3] != "missing" || rows[1][4] != "" || rows[1][9] != "10.01" || rows[1][11] != "1.000001" || rows[1][14] != "2026-09-17 16:00:00" {
+		t.Fatalf("wrong order export: count=%d row=%#v", len(rows), rows[1])
+	}
+	run := model.PaymentReconciliationRun{ID: "run", ProviderID: "wechat-native", BillDate: "2026-09-17", Status: model.PaymentReconciliationCompleted, TotalItems: 2, MatchItems: 1, ErrorItems: 1, StartedBy: "system", StartedAt: now, CompletedAt: &now}
+	if err := db.Create(&run).Error; err != nil {
+		t.Fatal(err)
+	}
+	items := []model.PaymentReconciliationItem{{ID: "matched", RunID: run.ID, Result: model.PaymentReconciliationMatched, Resolved: true}, {ID: "missing", RunID: run.ID, Result: model.PaymentReconciliationProviderRecordMissing, AmountFen: 1001, Detail: "本地已入账"}}
+	if err := db.Create(&items).Error; err != nil {
+		t.Fatal(err)
+	}
+	data, err = s.AdminPaymentReconciliationItemsCSV(context.Background(), admin, run.ID, "abnormal")
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows = readPaymentTestCSV(t, data)
+	if len(rows) != 2 || rows[1][7] != "本地订单" || rows[1][9] != "渠道记录缺失" || rows[1][10] != "否" {
+		t.Fatalf("wrong detail export: %#v", rows)
+	}
+	data, err = s.AdminPaymentReconciliationsCSV(context.Background(), admin, PaymentReconciliationQuery{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows = readPaymentTestCSV(t, data)
+	if rows[1][3] != "已完成" || rows[1][7] != "1" || rows[1][9] != "系统" {
+		t.Fatalf("completed must retain anomalies: %#v", rows)
+	}
+	for _, status := range []model.PaymentReconciliationStatus{model.PaymentReconciliationRunning, model.PaymentReconciliationFailed} {
+		if err := db.Model(&run).Updates(map[string]any{"status": status, "error": "BILL_ERROR"}).Error; err != nil {
+			t.Fatal(err)
+		}
+		_, err = s.AdminPaymentReconciliationItemsCSV(context.Background(), admin, run.ID, "")
+		var appErr *AppError
+		if !errors.As(err, &appErr) || appErr.Status != 409 {
+			t.Fatalf("unfinished detail export: %v", err)
+		}
+	}
+	data, err = s.AdminPaymentReconciliationsCSV(context.Background(), admin, PaymentReconciliationQuery{Status: "failed"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows = readPaymentTestCSV(t, data)
+	if len(rows) != 2 || rows[1][8] != "BILL_ERROR" {
+		t.Fatal("failed run lost its error")
+	}
+}
+
+func TestPaymentExportRejectsTruncation(t *testing.T) {
+	db, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=shared"), &gorm.Config{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	sqlDB, _ := db.DB()
+	t.Cleanup(func() { _ = sqlDB.Close() })
+	if err := db.AutoMigrate(&model.User{}, &model.PaymentOrder{}); err != nil {
+		t.Fatal(err)
+	}
+	s := &Service{repo: repository.New(db)}
+	admin := &model.User{Role: model.UserRoleAdmin}
+	orders := make([]model.PaymentOrder, paymentExportLimit)
+	for i := range orders {
+		id := fmt.Sprintf("order-%05d", i)
+		orders[i] = model.PaymentOrder{ID: id, UserID: "missing", IdempotencyKey: id, MerchantOrderNo: id}
+	}
+	if err := db.CreateInBatches(orders, 100).Error; err != nil {
+		t.Fatal(err)
+	}
+	data, err := s.AdminPaymentOrdersCSV(context.Background(), admin, PaymentOrderQuery{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rows := readPaymentTestCSV(t, data); len(rows) != paymentExportLimit+1 {
+		t.Fatalf("truncated export: %d", len(rows))
+	}
+	if err := db.Create(&model.PaymentOrder{ID: "overflow", UserID: "missing", IdempotencyKey: "overflow", MerchantOrderNo: "overflow"}).Error; err != nil {
+		t.Fatal(err)
+	}
+	data, err = s.AdminPaymentOrdersCSV(context.Background(), admin, PaymentOrderQuery{})
+	var appErr *AppError
+	if !errors.As(err, &appErr) || appErr.Status != 400 || len(data) != 0 {
+		t.Fatalf("oversize returned file: bytes=%d err=%v", len(data), err)
+	}
+	data, err = s.AdminPaymentOrdersCSV(context.Background(), admin, PaymentOrderQuery{Keyword: "no-such-order"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rows := readPaymentTestCSV(t, data); len(rows) != 1 {
+		t.Fatalf("empty export: %d", len(rows))
+	}
+}
+
+func readPaymentTestCSV(t *testing.T, data []byte) [][]string {
+	t.Helper()
+	rows, err := csv.NewReader(strings.NewReader(strings.TrimPrefix(string(data), "\xEF\xBB\xBF"))).ReadAll()
+	if err != nil {
+		t.Fatal(err)
+	}
+	return rows
+}

backend/internal/app/payment_reconciliation.go

@@ -272,12 +272,16 @@ func safePaymentReconciliationError(err error) string {
 	return truncateRunes(strings.TrimSpace(err.Error()), 1000)
 }
 
-func (s *Service) AdminPaymentReconciliationPage(actor *model.User, providerID, status string, page, limit int) (*AdminPaymentReconciliationPage, error) {
+func (s *Service) AdminPaymentReconciliationPage(actor *model.User, query PaymentReconciliationQuery, page, limit int) (*AdminPaymentReconciliationPage, error) {
 	if err := s.RequireAdmin(actor); err != nil {
 		return nil, err
 	}
 	page, limit = normalizeAdminPage(page, limit)
-	runs, total, err := s.repo.AdminPaymentReconciliationRuns(providerID, status, limit, (page-1)*limit)
+	filter, err := query.filter()
+	if err != nil {
+		return nil, err
+	}
+	runs, total, err := s.repo.AdminPaymentReconciliationRuns(filter, limit, (page-1)*limit)
 	if err != nil {
 		return nil, err
 	}
@@ -289,6 +293,9 @@ func (s *Service) AdminPaymentReconciliationItems(actor *model.User, runID, resu
 		return nil, err
 	}
 	page, limit = normalizeAdminPage(page, limit)
+	if err := validatePaymentResult(result); err != nil {
+		return nil, err
+	}
 	run, err := s.repo.PaymentReconciliationRun(runID)
 	if err != nil {
 		return nil, err