"Fix-order-details-for-customers"

LittleShop.Client/Services/IOrderService.cs

@@ -8,6 +8,7 @@ public interface IOrderService
     Task<ApiResponse<List<Order>>> GetOrdersByIdentityAsync(string identityReference);
     Task<ApiResponse<List<Order>>> GetOrdersByCustomerIdAsync(Guid customerId);
     Task<ApiResponse<Order>> GetOrderByIdAsync(Guid id);
+    Task<ApiResponse<Order>> GetOrderByCustomerIdAsync(Guid customerId, Guid orderId);
     Task<ApiResponse<CryptoPayment>> CreatePaymentAsync(Guid orderId, int currency);
     Task<ApiResponse<List<CryptoPayment>>> GetOrderPaymentsAsync(Guid orderId);
 }

LittleShop.Client/Services/OrderService.cs

@@ -114,6 +114,31 @@ public class OrderService : IOrderService
         }
     }
 
+    public async Task<ApiResponse<Order>> GetOrderByCustomerIdAsync(Guid customerId, Guid orderId)
+    {
+        try
+        {
+            var response = await _httpClient.GetAsync($"api/orders/by-customer/{customerId}/{orderId}");
+            
+            if (response.IsSuccessStatusCode)
+            {
+                var order = await response.Content.ReadFromJsonAsync<Order>();
+                if (order != null)
+                    return ApiResponse<Order>.Success(order);
+            }
+            
+            var error = await response.Content.ReadAsStringAsync();
+            return ApiResponse<Order>.Failure(error, response.StatusCode);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to get order {OrderId} for customer {CustomerId}", orderId, customerId);
+            return ApiResponse<Order>.Failure(
+                ex.Message, 
+                System.Net.HttpStatusCode.InternalServerError);
+        }
+    }
+    
     public async Task<ApiResponse<CryptoPayment>> CreatePaymentAsync(Guid orderId, int currency)
     {
         try

LittleShop/Controllers/OrdersController.cs

@@ -72,6 +72,19 @@ public class OrdersController : ControllerBase
         return Ok(orders);
     }
 
+    [HttpGet("by-customer/{customerId}/{id}")]
+    [AllowAnonymous]
+    public async Task<ActionResult<OrderDto>> GetOrderByCustomerId(Guid customerId, Guid id)
+    {
+        var order = await _orderService.GetOrderByIdAsync(id);
+        if (order == null || order.CustomerId != customerId)
+        {
+            return NotFound();
+        }
+
+        return Ok(order);
+    }
+
     [HttpGet("by-identity/{identityReference}/{id}")]
     [AllowAnonymous]
     public async Task<ActionResult<OrderDto>> GetOrderByIdentity(string identityReference, Guid id)

LittleShop/Program.cs

@@ -73,7 +73,8 @@ builder.Services.AddScoped<IBotMetricsService, BotMetricsService>();
 builder.Services.AddScoped<ICustomerService, CustomerService>();
 builder.Services.AddScoped<ICustomerMessageService, CustomerMessageService>();
 builder.Services.AddSingleton<ITelegramBotManagerService, TelegramBotManagerService>();
-builder.Services.AddHostedService<TelegramBotManagerService>();
+// Temporarily disabled to use standalone TeleBot with customer orders fix
+// builder.Services.AddHostedService<TelegramBotManagerService>();
 
 // AutoMapper
 builder.Services.AddAutoMapper(typeof(Program));

TeleBot/TeleBot/Handlers/CallbackHandler.cs

@@ -109,11 +109,11 @@ namespace TeleBot.Handlers
                         break;
                         
                     case "orders":
-                        await HandleViewOrders(bot, callbackQuery.Message, session);
+                        await HandleViewOrders(bot, callbackQuery.Message, session, callbackQuery.From);
                         break;
                         
                     case "order":
-                        await HandleViewOrder(bot, callbackQuery.Message, session, Guid.Parse(data[1]));
+                        await HandleViewOrder(bot, callbackQuery.Message, session, Guid.Parse(data[1]), callbackQuery.From);
                         break;
                         
                     case "privacy":
@@ -480,20 +480,16 @@ namespace TeleBot.Handlers
             }
         }
         
-        private async Task HandleViewOrders(ITelegramBotClient bot, Message message, UserSession session)
+        private async Task HandleViewOrders(ITelegramBotClient bot, Message message, UserSession session, User telegramUser)
         {
-            var identityRef = session.OrderFlow?.IdentityReference;
+            // Use new customer-based order lookup
-            if (string.IsNullOrEmpty(identityRef))
+            var orders = await _shopService.GetCustomerOrdersAsync(
-            {
+                telegramUser.Id,
-                identityRef = _privacyService.GenerateAnonymousReference();
+                telegramUser.Username ?? "",
-                if (session.OrderFlow == null)
+                $"{telegramUser.FirstName} {telegramUser.LastName}".Trim(),
-                {
+                telegramUser.FirstName ?? "",
-                    session.OrderFlow = new OrderFlowData();
+                telegramUser.LastName ?? ""
-                }
+            );
-                session.OrderFlow.IdentityReference = identityRef;
-            }
-            
-            var orders = await _shopService.GetOrdersAsync(identityRef);
             
             if (!orders.Any())
             {
@@ -519,9 +515,16 @@ namespace TeleBot.Handlers
             session.State = SessionState.ViewingOrders;
         }
         
-        private async Task HandleViewOrder(ITelegramBotClient bot, Message message, UserSession session, Guid orderId)
+        private async Task HandleViewOrder(ITelegramBotClient bot, Message message, UserSession session, Guid orderId, User telegramUser)
         {
-            var order = await _shopService.GetOrderAsync(orderId);
+            var order = await _shopService.GetCustomerOrderAsync(
+                orderId,
+                telegramUser.Id,
+                telegramUser.Username ?? "",
+                $"{telegramUser.FirstName} {telegramUser.LastName}".Trim(),
+                telegramUser.FirstName ?? "",
+                telegramUser.LastName ?? ""
+            );
             
             if (order == null)
             {

TeleBot/TeleBot/Services/LittleShopService.cs

@@ -20,6 +20,7 @@ namespace TeleBot.Services
         Task<List<Order>> GetOrdersAsync(string identityReference);
         Task<List<Order>> GetCustomerOrdersAsync(long telegramUserId, string telegramUsername, string displayName, string firstName, string lastName);
         Task<Order?> GetOrderAsync(Guid orderId);
+        Task<Order?> GetCustomerOrderAsync(Guid orderId, long telegramUserId, string telegramUsername, string displayName, string firstName, string lastName);
         Task<CryptoPayment?> CreatePaymentAsync(Guid orderId, string currency);
         Task<List<CustomerMessage>?> GetPendingMessagesAsync();
         Task<bool> MarkMessageAsSentAsync(Guid messageId, string? platformMessageId = null);
@@ -299,6 +300,47 @@ namespace TeleBot.Services
             }
         }
 
+        public async Task<Order?> GetCustomerOrderAsync(Guid orderId, long telegramUserId, string telegramUsername, string displayName, string firstName, string lastName)
+        {
+            try
+            {
+                if (!await AuthenticateAsync())
+                    return null;
+
+                // Get or create the customer to get customer ID
+                var customer = await _client.Customers.GetOrCreateCustomerAsync(new CreateCustomerRequest
+                {
+                    TelegramUserId = telegramUserId,
+                    TelegramUsername = telegramUsername,
+                    TelegramDisplayName = displayName,
+                    TelegramFirstName = firstName,
+                    TelegramLastName = lastName,
+                    AllowOrderUpdates = true,
+                    AllowMarketing = false
+                });
+
+                if (!customer.IsSuccess || customer.Data == null)
+                {
+                    return null;
+                }
+
+                // Get the specific order using customer validation
+                var result = await _client.Orders.GetOrderByCustomerIdAsync(customer.Data.Id, orderId);
+                
+                if (result.IsSuccess && result.Data != null)
+                {
+                    return result.Data;
+                }
+                
+                return null;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error fetching customer order {OrderId}", orderId);
+                return null;
+            }
+        }
+        
         public async Task<CryptoPayment?> CreatePaymentAsync(Guid orderId, string currency)
         {
             try