fix(admin): 超管看不到下游订单——新增平台侧跨商户订单视图

问题：管理员首页 Dashboard 显示平台总量（37 单，跨全部商户），点进「发货订单」
却只有 29 单，两个数字互相矛盾且界面上没有任何解释。

根因是「平台管理员」在两套接口里语义不同：
- /api/dashboard：isPlatformAdmin 只看 JWT 角色 → 平台视角，跨商户聚合
- /api/merchant/*：Tenant 中间件强制落到单个 merchant_id → 商户成员视角。
  管理员唯一的成员关系是自营商户，于是被静默框定在商户 1
且 34 条 /platform/* 路由中没有任何订单入口，前端也没有商户切换器或上下文提示。

修复（不改动商户侧隔离语义）：
- 新增 GET /api/platform/orders，support 按商户/状态/来源/关键字筛选，缺省为全部商户
- Service 抽出共用的 orderFilters 集中校验，ListOrders 与 ListPlatformOrders 并行；
  ListOrders 仍强制单商户，避免新增平台路径时顺手放宽商户侧可见范围
- FulfillmentOrder 增加 Merchant 关联字段，仅平台侧 Preload，商户侧响应结构不变
- 前端新增「下游订单（全部商户）」页与菜单项，「发货订单」更名为「发货订单（当前商户）」
- README 补充两个订单入口的说明，避免后来者重踩

验证：单测覆盖跨商户可见性、按商户筛选、筛选校验、以及商户侧隔离不回归；
实测新接口返回 37 单（自营 29 + 测试商户 8）且带商户信息，商户侧仍为 29 单且无 merchant 字段。

backend/internal/handler/merchant_order.go

@@ -1,6 +1,7 @@
 package handler
 
 import (
+	"strconv"
 	"strings"
 
 	"affiliate_dash/internal/middleware"
@@ -25,6 +26,37 @@ func (h *MerchantHandler) ListOrders(c *gin.Context) {
 	response.Page(c, list, total, page, size)
 }
 
+// ListPlatformOrders GET /api/platform/orders
+//
+// 平台管理员跨商户查看下游订单。merchant_id 查询参数可选：不传表示全部商户。
+// 与商户侧 /api/merchant/orders 是两条独立路径——商户侧仍强制单商户隔离，
+// 这里不依赖 X-Merchant-ID，因此管理员遗留的商户上下文不会影响本接口。
+func (h *MerchantHandler) ListPlatformOrders(c *gin.Context) {
+	page, size := pageParams(c)
+
+	var merchantID *uint
+	if raw := strings.TrimSpace(c.Query("merchant_id")); raw != "" {
+		id, err := strconv.ParseUint(raw, 10, 64)
+		if err != nil || id == 0 {
+			response.BadRequest(c, "商户 ID 无效")
+			return
+		}
+		value := uint(id)
+		merchantID = &value
+	}
+
+	list, total, err := h.fulfillmentSvc.ListPlatformOrders(merchantID, page, size, c.Query("order_status"), c.Query("order_source"), c.Query("keyword"))
+	if err != nil {
+		if err.Error() == "无效的订单来源" || err.Error() == "无效的订单状态" {
+			response.BadRequest(c, err.Error())
+			return
+		}
+		response.ServerError(c, err.Error())
+		return
+	}
+	response.Page(c, list, total, page, size)
+}
+
 type merchantManualOrderReq struct {
 	ClientOrderNo  string `json:"client_order_no" binding:"required,max=96"`
 	SKU            string `json:"sku" binding:"required,max=96"`

backend/internal/model/merchant.go

@@ -246,6 +246,9 @@ type FulfillmentOrder struct {
 	DeliveryLinkGeneratedAt *time.Time `json:"delivery_link_generated_at"`
 
 	MerchantProduct *MerchantProduct `gorm:"foreignKey:MerchantProductID" json:"merchant_product,omitempty"`
+	// Merchant 仅在平台侧跨商户查询时 Preload；商户侧响应里为 nil，被 omitempty 省略，
+	// 因此该字段不改变既有接口结构。
+	Merchant *Merchant `gorm:"foreignKey:MerchantID" json:"merchant,omitempty"`
 }
 
 // CallbackSubscription 为商户提供独立、可禁用的事件订阅。

backend/internal/router/router.go

@@ -284,6 +284,9 @@ func Setup(h *Handlers) *gin.Engine {
 				admin.PATCH("/platform/admins/:id", h.User.UpdatePlatformAdmin)
 				admin.DELETE("/platform/admins/:id", h.User.DeletePlatformAdmin)
 				admin.GET("/platform/merchants", h.Merchant.ListPlatformMerchants)
+				// 跨商户订单视图：商户后台的 /api/merchant/orders 强制单商户隔离，
+				// 超管需要一条平台视角入口来查看全部下游订单。
+				admin.GET("/platform/orders", h.Merchant.ListPlatformOrders)
 				admin.POST("/platform/merchants", h.Merchant.CreateMerchant)
 				admin.PATCH("/platform/merchants/:id", h.Merchant.UpdateMerchantSettings)
 				admin.POST("/platform/merchants/:id/members", h.Merchant.AddPlatformMerchantMember)

backend/internal/service/fulfillment_platform_orders_test.go

@@ -0,0 +1,135 @@
+package service
+
+import (
+	"testing"
+
+	"affiliate_dash/internal/model"
+)
+
+// seedPlatformOrders 为两个商户各造若干订单，用于平台侧跨商户查询测试。
+func seedPlatformOrders(t *testing.T) (*FulfillmentService, uint, uint) {
+	t.Helper()
+	db := newServiceTestDB(t)
+	svc := NewFulfillmentService(db, nil)
+
+	merchantA, productA := seedFulfillmentMerchant(t, db, "pf-merchant-a", 0, -1, 100)
+	merchantB, productB := seedFulfillmentMerchant(t, db, "pf-merchant-b", 0, -1, 100)
+
+	orders := []model.FulfillmentOrder{
+		{MerchantID: merchantA, OrderNo: "A-1", ClientOrderNo: "A-C1", MerchantProductID: productA.ID, ProductSKU: productA.SKU, ProductName: "商品A", Amount: 100, OrderStatus: model.OrderStatusPaid, OrderSource: model.OrderSourceAPI},
+		{MerchantID: merchantA, OrderNo: "A-2", ClientOrderNo: "A-C2", MerchantProductID: productA.ID, ProductSKU: productA.SKU, ProductName: "商品A", Amount: 100, OrderStatus: model.OrderStatusDelivered, OrderSource: model.OrderSourceManual},
+		{MerchantID: merchantB, OrderNo: "B-1", ClientOrderNo: "B-C1", MerchantProductID: productB.ID, ProductSKU: productB.SKU, ProductName: "商品B", Amount: 200, OrderStatus: model.OrderStatusPaid, OrderSource: model.OrderSourceAPI},
+	}
+	for i := range orders {
+		if err := db.Create(&orders[i]).Error; err != nil {
+			t.Fatalf("create order: %v", err)
+		}
+	}
+	return svc, merchantA, merchantB
+}
+
+// TestListPlatformOrdersSpansMerchants 是本次修复的核心断言：
+// 平台视角必须能同时看到全部商户的订单，并带出订单所属商户。
+func TestListPlatformOrdersSpansMerchants(t *testing.T) {
+	svc, merchantA, merchantB := seedPlatformOrders(t)
+
+	list, total, err := svc.ListPlatformOrders(nil, 1, 20, "", "", "")
+	if err != nil {
+		t.Fatalf("平台侧跨商户查询失败: %v", err)
+	}
+	if total != 3 || len(list) != 3 {
+		t.Fatalf("期望 3 单（A 2 单 + B 1 单），实际 total=%d len=%d", total, len(list))
+	}
+
+	seen := map[uint]int{}
+	for _, order := range list {
+		seen[order.MerchantID]++
+		// 跨商户列表必须能说明每单属于哪个商户，否则管理员无法分辨。
+		if order.Merchant == nil {
+			t.Fatalf("订单 %s 未预加载商户信息", order.OrderNo)
+		}
+	}
+	if seen[merchantA] != 2 || seen[merchantB] != 1 {
+		t.Fatalf("商户分布不符：%v", seen)
+	}
+}
+
+// TestListPlatformOrdersFiltersByMerchant 指定 merchant_id 时只返回该商户。
+func TestListPlatformOrdersFiltersByMerchant(t *testing.T) {
+	svc, merchantA, _ := seedPlatformOrders(t)
+
+	list, total, err := svc.ListPlatformOrders(&merchantA, 1, 20, "", "", "")
+	if err != nil {
+		t.Fatalf("按商户筛选失败: %v", err)
+	}
+	if total != 2 || len(list) != 2 {
+		t.Fatalf("期望商户 A 的 2 单，实际 total=%d len=%d", total, len(list))
+	}
+	for _, order := range list {
+		if order.MerchantID != merchantA {
+			t.Fatalf("出现了其他商户的订单：merchant_id=%d", order.MerchantID)
+		}
+	}
+}
+
+// TestListPlatformOrdersAppliesFilters 平台侧同样要支持状态/来源/关键字筛选与非法值校验。
+func TestListPlatformOrdersAppliesFilters(t *testing.T) {
+	svc, _, _ := seedPlatformOrders(t)
+
+	cases := []struct {
+		name        string
+		status      string
+		source      string
+		keyword     string
+		wantTotal   int64
+		wantErrText string
+	}{
+		{name: "按状态筛选", status: model.OrderStatusPaid, wantTotal: 2},
+		{name: "按来源筛选", source: model.OrderSourceManual, wantTotal: 1},
+		{name: "按订单号关键字", keyword: "B-", wantTotal: 1},
+		{name: "按商户单号关键字", keyword: "A-C", wantTotal: 2},
+		{name: "非法状态", status: "not-a-status", wantErrText: "无效的订单状态"},
+		{name: "非法来源", source: "not-a-source", wantErrText: "无效的订单来源"},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			list, total, err := svc.ListPlatformOrders(nil, 1, 20, tc.status, tc.source, tc.keyword)
+			if tc.wantErrText != "" {
+				if err == nil || err.Error() != tc.wantErrText {
+					t.Fatalf("期望错误 %q，实际 %v", tc.wantErrText, err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("查询失败: %v", err)
+			}
+			if total != tc.wantTotal || int64(len(list)) != tc.wantTotal {
+				t.Fatalf("期望 %d 单，实际 total=%d len=%d", tc.wantTotal, total, len(list))
+			}
+		})
+	}
+}
+
+// TestListOrdersStillIsolatesSingleMerchant 卡住商户侧隔离语义：
+// 这次修复新增了平台侧路径，但绝不能顺手放宽商户侧的可见范围。
+// 同时商户侧响应不应带上 Merchant（保持既有接口结构不变）。
+func TestListOrdersStillIsolatesSingleMerchant(t *testing.T) {
+	svc, merchantA, _ := seedPlatformOrders(t)
+
+	list, total, err := svc.ListOrders(merchantA, 1, 20, "", "", "")
+	if err != nil {
+		t.Fatalf("商户侧查询失败: %v", err)
+	}
+	if total != 2 || len(list) != 2 {
+		t.Fatalf("商户侧必须只看到自己的 2 单，实际 total=%d len=%d", total, len(list))
+	}
+	for _, order := range list {
+		if order.MerchantID != merchantA {
+			t.Fatalf("商户侧串到了其他商户的订单：merchant_id=%d", order.MerchantID)
+		}
+		if order.Merchant != nil {
+			t.Fatal("商户侧不应预加载 Merchant，否则会改变既有响应结构")
+		}
+	}
+}

backend/internal/service/fulfillment_query.go

@@ -24,38 +24,86 @@ func (s *FulfillmentService) GetOrder(merchantID uint, orderNo string) (*model.F
 	return &order, nil
 }
 
-func (s *FulfillmentService) ListOrders(merchantID uint, page, size int, orderStatus, orderSource, keyword string) ([]model.FulfillmentOrder, int64, error) {
-	page, size = normalizePage(page, size)
-	tx := s.db.Model(&model.FulfillmentOrder{}).Where("merchant_id = ?", merchantID)
-	if orderStatus != "" {
-		switch orderStatus {
+// orderFilters 是商户侧与平台侧共用的订单筛选条件。
+// 集中在一处校验，避免以后新增筛选项时只改了一边。
+type orderFilters struct {
+	// merchantID 为 nil 表示不限商户（仅平台侧使用）；指向 0 时仍会按 merchant_id=0 过滤，
+	// 以保持 ListOrders 的原有语义不变。
+	merchantID  *uint
+	orderStatus string
+	orderSource string
+	keyword     string
+}
+
+func (f orderFilters) apply(tx *gorm.DB) (*gorm.DB, error) {
+	if f.merchantID != nil {
+		tx = tx.Where("merchant_id = ?", *f.merchantID)
+	}
+	if f.orderStatus != "" {
+		switch f.orderStatus {
 		case model.OrderStatusPaid, model.OrderStatusDelivering, model.OrderStatusDelivered, model.OrderStatusShipFailed, model.OrderStatusCancelled:
 		default:
-			return nil, 0, errors.New("无效的订单状态")
+			return nil, errors.New("无效的订单状态")
 		}
-		tx = tx.Where("order_status = ?", orderStatus)
+		tx = tx.Where("order_status = ?", f.orderStatus)
 	}
-	if orderSource != "" {
-		switch orderSource {
+	if f.orderSource != "" {
+		switch f.orderSource {
 		case model.OrderSourceAPI, model.OrderSourceManual, model.OrderSourceTest:
-			tx = tx.Where("order_source = ?", orderSource)
+			tx = tx.Where("order_source = ?", f.orderSource)
 		default:
-			return nil, 0, errors.New("无效的订单来源")
+			return nil, errors.New("无效的订单来源")
 		}
 	}
-	if keyword = strings.TrimSpace(keyword); keyword != "" {
+	if keyword := strings.TrimSpace(f.keyword); keyword != "" {
 		like := "%" + keyword + "%"
 		tx = tx.Where("order_no LIKE ? OR client_order_no LIKE ?", like, like)
 	}
+	return tx, nil
+}
+
+func (s *FulfillmentService) listOrders(f orderFilters, page, size int, withMerchant bool) ([]model.FulfillmentOrder, int64, error) {
+	page, size = normalizePage(page, size)
+	tx, err := f.apply(s.db.Model(&model.FulfillmentOrder{}))
+	if err != nil {
+		return nil, 0, err
+	}
 	var total int64
 	if err := tx.Count(&total).Error; err != nil {
 		return nil, 0, err
 	}
+	query := tx.Preload("MerchantProduct.Product")
+	if withMerchant {
+		// 平台侧跨商户列表需要展示订单属于哪个商户。
+		query = query.Preload("Merchant")
+	}
 	var orders []model.FulfillmentOrder
-	err := tx.Preload("MerchantProduct.Product").Order("id DESC").Offset((page - 1) * size).Limit(size).Find(&orders).Error
+	err = query.Order("id DESC").Offset((page - 1) * size).Limit(size).Find(&orders).Error
 	return orders, total, err
 }
 
+// ListOrders 商户后台订单列表，强制按单个商户隔离。
+func (s *FulfillmentService) ListOrders(merchantID uint, page, size int, orderStatus, orderSource, keyword string) ([]model.FulfillmentOrder, int64, error) {
+	return s.listOrders(orderFilters{
+		merchantID:  &merchantID,
+		orderStatus: orderStatus,
+		orderSource: orderSource,
+		keyword:     keyword,
+	}, page, size, false)
+}
+
+// ListPlatformOrders 平台侧跨商户订单查询，供超管在管理端查看全部下游订单。
+// merchantID 为 nil 表示不限商户。这是与 ListOrders 并行的另一条路径，
+// 刻意不改动商户侧「必须落到单个商户」的隔离语义。
+func (s *FulfillmentService) ListPlatformOrders(merchantID *uint, page, size int, orderStatus, orderSource, keyword string) ([]model.FulfillmentOrder, int64, error) {
+	return s.listOrders(orderFilters{
+		merchantID:  merchantID,
+		orderStatus: orderStatus,
+		orderSource: orderSource,
+		keyword:     keyword,
+	}, page, size, true)
+}
+
 type OpenOrderQuery struct {
 	OrderNo          string            `json:"order_no"`
 	Status           string            `json:"status"`