feat: اصلاح سند payment corrections + audit-log & daily P&L views

Backend:
- POST /orders/{id}/payments/corrections (Manager/Owner): void wrong
  payments (marked Refunded, never deleted) and/or record replacements
  atomically; mandatory reason; requires an open register shift; full
  before/after written to the immutable audit trail.
- GET /orders/closed?date= — closed orders of one Iran-calendar day,
  paged, the browsing surface for corrections.
- CalculateExpectedCash now subtracts cash refunds so corrections keep
  the drawer expectation honest.

Dashboard (reports screen now has three tabs):
- عملکرد و سود: existing KPIs/charts + new day-by-day breakdown table
  (orders, revenue, expenses, net profit per Jalali day).
- اصلاح سند: closed-orders browser with payment chips + correction
  dialog (void checkboxes, replacement rows, live balance, reason).
- گزارش عملیات: filterable audit-log viewer (category, Jalali range,
  branch) with expandable structured details.

fa/en/ar translations included. 86 backend tests pass; dashboard tsc clean.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/Meezi.API/Services/OrderService.cs

@@ -67,6 +67,19 @@ public interface IOrderService
         RecordPaymentsRequest request,
         string? userId,
         CancellationToken cancellationToken = default);
+    Task<(IReadOnlyList<OrderDto> Items, int Total)> GetClosedOrdersAsync(
+        string cafeId,
+        DateOnly date,
+        string? branchId,
+        int page,
+        int pageSize,
+        CancellationToken cancellationToken = default);
+    Task<OrderServiceResult<OrderDto>> CorrectPaymentsAsync(
+        string cafeId,
+        string orderId,
+        CorrectPaymentsRequest request,
+        string? userId,
+        CancellationToken cancellationToken = default);
 }
 
 public class OrderService : IOrderService
@@ -1119,6 +1132,117 @@ public class OrderService : IOrderService
         return new OrderServiceResult<IReadOnlyList<PaymentDto>>(true, dtos);
     }
 
+    public async Task<(IReadOnlyList<OrderDto> Items, int Total)> GetClosedOrdersAsync(
+        string cafeId,
+        DateOnly date,
+        string? branchId,
+        int page,
+        int pageSize,
+        CancellationToken cancellationToken = default)
+    {
+        var (utcStart, utcEnd) = IranCalendar.GetUtcRangeForIranDay(date);
+
+        var query = _db.Orders
+            .Where(o => o.CafeId == cafeId
+                        && (o.Status == OrderStatus.Delivered || o.Status == OrderStatus.Cancelled)
+                        && o.CreatedAt >= utcStart
+                        && o.CreatedAt < utcEnd);
+
+        if (!string.IsNullOrEmpty(branchId))
+            query = query.Where(o => o.BranchId == branchId);
+
+        var total = await query.CountAsync(cancellationToken);
+
+        var orders = await ApplyOrderIncludes(query)
+            .OrderByDescending(o => o.CreatedAt)
+            .Skip((page - 1) * pageSize)
+            .Take(pageSize)
+            .AsNoTracking()
+            .ToListAsync(cancellationToken);
+
+        return (orders.Select(MapOrder).ToList(), total);
+    }
+
+    public async Task<OrderServiceResult<OrderDto>> CorrectPaymentsAsync(
+        string cafeId,
+        string orderId,
+        CorrectPaymentsRequest request,
+        string? userId,
+        CancellationToken cancellationToken = default)
+    {
+        var order = await LoadOrderAsync(cafeId, orderId, cancellationToken);
+        if (order is null)
+            return new OrderServiceResult<OrderDto>(false, null, "ORDER_NOT_FOUND");
+
+        // Resolve the payments being voided — they must belong to this order and
+        // still be live. Payments are never deleted; voiding marks them Refunded
+        // so the original سند stays visible in history and audit.
+        var toVoid = new List<Payment>();
+        foreach (var paymentId in request.VoidPaymentIds.Distinct())
+        {
+            var payment = order.Payments.FirstOrDefault(p => p.Id == paymentId);
+            if (payment is null)
+                return new OrderServiceResult<OrderDto>(false, null, "PAYMENT_NOT_FOUND", "voidPaymentIds");
+            if (payment.Status != PaymentStatus.Completed)
+                return new OrderServiceResult<OrderDto>(false, null, "PAYMENT_ALREADY_REFUNDED", "voidPaymentIds");
+            toVoid.Add(payment);
+        }
+
+        var branchId = await ResolveOrderBranchIdAsync(order, cafeId, cancellationToken);
+        if (string.IsNullOrEmpty(branchId))
+            return new OrderServiceResult<OrderDto>(false, null, "NO_OPEN_SHIFT", "branchId");
+
+        // Corrections move money through the drawer, so they need an open shift
+        // exactly like recording a payment does.
+        var shiftCheck = await _shiftService.RequireOpenShiftForBranchAsync(cafeId, branchId, cancellationToken);
+        if (!shiftCheck.Success)
+            return new OrderServiceResult<OrderDto>(false, null, shiftCheck.ErrorCode, shiftCheck.Field);
+        var openShift = shiftCheck.Data!;
+
+        foreach (var payment in toVoid)
+            payment.Status = PaymentStatus.Refunded;
+
+        var replacements = request.Replacements.Select(p => new Payment
+        {
+            OrderId = orderId,
+            Method = p.Method,
+            Amount = p.Amount,
+            Reference = p.Reference,
+            Status = PaymentStatus.Completed
+        }).ToList();
+        _db.Payments.AddRange(replacements);
+
+        // Fully paid again after the correction → ensure the order is closed;
+        // underpaid → leave the status alone (the remainder can be collected
+        // through the normal payment flow later). EF navigation fixup may have
+        // already appended the replacements to order.Payments, so exclude them
+        // by reference to avoid double-counting.
+        var paidTotal = order.Payments
+                            .Where(p => p.Status == PaymentStatus.Completed && !replacements.Contains(p))
+                            .Sum(p => p.Amount)
+                        + replacements.Sum(p => p.Amount);
+        if (paidTotal >= order.Total && OpenForPaymentStatuses.Contains(order.Status))
+            order.Status = OrderStatus.Delivered;
+
+        await _db.SaveChangesAsync(cancellationToken);
+
+        var createdBy = userId ?? openShift.OpenedByUserId;
+        foreach (var payment in toVoid)
+        {
+            await _shiftService.RecordTransactionAsync(
+                cafeId, openShift.Id, CashTransactionType.Refund, payment.Method,
+                payment.Amount, createdBy, orderId, request.Reason, cancellationToken);
+        }
+        foreach (var payment in replacements)
+        {
+            await _shiftService.RecordTransactionAsync(
+                cafeId, openShift.Id, CashTransactionType.OrderPayment, payment.Method,
+                payment.Amount, createdBy, orderId, request.Reason, cancellationToken);
+        }
+
+        return new OrderServiceResult<OrderDto>(true, MapOrder(order));
+    }
+
     private static IQueryable<Order> ApplyOrderIncludes(IQueryable<Order> query) =>
         query
             .Include(o => o.Items)