feat(order): add all-orders APIs and query workflow

src/Application/TakeoutSaaS.Application/App/Orders/Handlers/SearchOrderAllListQueryHandler.cs

@@ -0,0 +1,138 @@
+using MediatR;
+using TakeoutSaaS.Application.App.Orders.Dto;
+using TakeoutSaaS.Application.App.Orders.Queries;
+using TakeoutSaaS.Domain.Orders.Entities;
+using TakeoutSaaS.Domain.Orders.Enums;
+using TakeoutSaaS.Domain.Orders.Repositories;
+using TakeoutSaaS.Shared.Abstractions.Results;
+using TakeoutSaaS.Shared.Abstractions.Tenancy;
+
+namespace TakeoutSaaS.Application.App.Orders.Handlers;
+
+/// <summary>
+/// 全部订单列表查询处理器。
+/// </summary>
+public sealed class SearchOrderAllListQueryHandler(
+    IOrderRepository orderRepository,
+    ITenantProvider tenantProvider)
+    : IRequestHandler<SearchOrderAllListQuery, PagedResult<OrderAllListItemDto>>
+{
+    /// <inheritdoc />
+    public async Task<PagedResult<OrderAllListItemDto>> Handle(SearchOrderAllListQuery request, CancellationToken cancellationToken)
+    {
+        var tenantId = tenantProvider.GetCurrentTenantId();
+
+        var orders = await orderRepository.SearchAllOrdersAsync(
+            tenantId,
+            request.StoreId,
+            request.StartAt,
+            request.EndAt,
+            request.Status,
+            request.DeliveryType,
+            request.PaymentMethod,
+            request.Keyword,
+            cancellationToken);
+
+        var filteredOrders = orders.ToList();
+        var refundedSet = await LoadRefundedOrderIdsAsync(filteredOrders, tenantId, cancellationToken);
+        if (request.RefundedOnly)
+        {
+            filteredOrders = filteredOrders
+                .Where(order => refundedSet.Contains(order.Id))
+                .ToList();
+        }
+
+        var sorted = ApplySorting(filteredOrders, request.SortBy, request.SortDescending);
+        var page = Math.Max(1, request.Page);
+        var pageSize = Math.Clamp(request.PageSize, 1, 200);
+        var pagedOrders = sorted
+            .Skip((page - 1) * pageSize)
+            .Take(pageSize)
+            .ToList();
+
+        var itemsLookup = await orderRepository.GetItemsByOrderIdsAsync(
+            pagedOrders.Select(order => order.Id).ToList(),
+            tenantId,
+            cancellationToken);
+
+        var rows = pagedOrders
+            .Select(order =>
+            {
+                var isRefunded = refundedSet.Contains(order.Id);
+                return new OrderAllListItemDto
+                {
+                    OrderId = order.Id,
+                    OrderNo = order.OrderNo,
+                    OrderedAt = order.CreatedAt,
+                    DeliveryType = order.DeliveryType,
+                    Status = order.Status,
+                    CustomerName = string.IsNullOrWhiteSpace(order.CustomerName) ? "--" : order.CustomerName,
+                    ItemsSummary = BuildItemSummary(order.Id, itemsLookup),
+                    Amount = ResolveDisplayAmount(order),
+                    IsRefunded = isRefunded,
+                    IsDimmed = order.Status == OrderStatus.Cancelled || isRefunded
+                };
+            })
+            .ToList();
+
+        return new PagedResult<OrderAllListItemDto>(rows, page, pageSize, filteredOrders.Count);
+    }
+
+    private async Task<HashSet<long>> LoadRefundedOrderIdsAsync(
+        IReadOnlyCollection<Order> orders,
+        long tenantId,
+        CancellationToken cancellationToken)
+    {
+        var orderIds = orders.Select(order => order.Id).ToList();
+        if (orderIds.Count == 0)
+        {
+            return [];
+        }
+
+        var refunded = await orderRepository.GetRefundedOrderIdsAsync(orderIds, tenantId, cancellationToken);
+        return refunded.ToHashSet();
+    }
+
+    private static decimal ResolveDisplayAmount(Order order)
+    {
+        return order.PaidAmount > 0 ? order.PaidAmount : order.PayableAmount;
+    }
+
+    private static string BuildItemSummary(
+        long orderId,
+        IReadOnlyDictionary<long, IReadOnlyList<OrderItem>> itemsLookup)
+    {
+        if (!itemsLookup.TryGetValue(orderId, out var items) || items.Count == 0)
+        {
+            return "--";
+        }
+
+        var first = string.IsNullOrWhiteSpace(items[0].ProductName) ? "商品" : items[0].ProductName.Trim();
+        var totalQuantity = items.Sum(item => Math.Max(0, item.Quantity));
+        if (totalQuantity <= 0)
+        {
+            totalQuantity = items.Count;
+        }
+
+        return $"{first}等{totalQuantity}件";
+    }
+
+    private static IEnumerable<Order> ApplySorting(
+        IReadOnlyCollection<Order> orders,
+        string? sortBy,
+        bool sortDescending)
+    {
+        return sortBy?.Trim().ToLowerInvariant() switch
+        {
+            "amount" => sortDescending
+                ? orders.OrderByDescending(ResolveDisplayAmount).ThenByDescending(order => order.CreatedAt)
+                : orders.OrderBy(ResolveDisplayAmount).ThenBy(order => order.CreatedAt),
+            "status" => sortDescending
+                ? orders.OrderByDescending(order => order.Status).ThenByDescending(order => order.CreatedAt)
+                : orders.OrderBy(order => order.Status).ThenBy(order => order.CreatedAt),
+            _ => sortDescending
+                ? orders.OrderByDescending(order => order.CreatedAt)
+                : orders.OrderBy(order => order.CreatedAt)
+        };
+    }
+}