Implement comprehensive notification system for LittleShop

- Add admin PWA push notifications for order management
- Integrate TeleBot customer messaging service
- Add push notification endpoints and VAPID key support
- Implement order status notifications throughout workflow
- Add notification UI components in admin panel
- Create TeleBotMessagingService for customer updates
- Add WebPush configuration to appsettings
- Fix compilation issues (BotStatus, BotContacts DbSet)
- Add comprehensive testing documentation

Features:
- Real-time admin notifications for new orders and status changes
- Customer order progress updates via TeleBot
- Graceful failure handling for notification services
- Test endpoints for notification system validation

🤖 Generated with Claude Code
Co-Authored-By: Claude <noreply@anthropic.com>

LittleShop/Services/BotContactService.cs

@@ -7,12 +7,13 @@ using Microsoft.Extensions.Logging;
 using LittleShop.Data;
 using LittleShop.Models;
 using LittleShop.DTOs;
+using LittleShop.Enums;
 
 namespace LittleShop.Services;
 
 public interface IMessageDeliveryService
 {
-    // Placeholder interface for compilation
+    Task<bool> QueueRecoveryMessageAsync(long telegramUserId, string message);
 }
 
 public interface IBotContactService

LittleShop/Services/CryptoPaymentService.cs

@@ -14,17 +14,23 @@ public class CryptoPaymentService : ICryptoPaymentService
     private readonly IBTCPayServerService _btcPayService;
     private readonly ILogger<CryptoPaymentService> _logger;
     private readonly IConfiguration _configuration;
+    private readonly IPushNotificationService _pushNotificationService;
+    private readonly ITeleBotMessagingService _teleBotMessagingService;
 
     public CryptoPaymentService(
         LittleShopContext context,
         IBTCPayServerService btcPayService,
         ILogger<CryptoPaymentService> logger,
-        IConfiguration configuration)
+        IConfiguration configuration,
+        IPushNotificationService pushNotificationService,
+        ITeleBotMessagingService teleBotMessagingService)
     {
         _context = context;
         _btcPayService = btcPayService;
         _logger = logger;
         _configuration = configuration;
+        _pushNotificationService = pushNotificationService;
+        _teleBotMessagingService = teleBotMessagingService;
     }
 
     public async Task<CryptoPaymentDto> CreatePaymentAsync(Guid orderId, CryptoCurrency currency)
@@ -157,9 +163,11 @@ public class CryptoPaymentService : ICryptoPaymentService
         if (status == PaymentStatus.Paid)
         {
             payment.PaidAt = DateTime.UtcNow;
-            
+
             // Update order status
-            var order = await _context.Orders.FindAsync(payment.OrderId);
+            var order = await _context.Orders
+                .Include(o => o.Customer)
+                .FirstOrDefaultAsync(o => o.Id == payment.OrderId);
             if (order != null)
             {
                 order.Status = OrderStatus.PaymentReceived;
@@ -169,7 +177,13 @@ public class CryptoPaymentService : ICryptoPaymentService
 
         await _context.SaveChangesAsync();
 
-        _logger.LogInformation("Processed payment webhook for invoice {InvoiceId}, status: {Status}", 
+        // Send notification for payment confirmation
+        if (status == PaymentStatus.Paid)
+        {
+            await SendPaymentConfirmedNotification(payment.OrderId, amount);
+        }
+
+        _logger.LogInformation("Processed payment webhook for invoice {InvoiceId}, status: {Status}",
             invoiceId, status);
 
         return true;
@@ -209,4 +223,25 @@ public class CryptoPaymentService : ICryptoPaymentService
             _ => "BTC"
         };
     }
+
+    private async Task SendPaymentConfirmedNotification(Guid orderId, decimal amount)
+    {
+        try
+        {
+            var title = "💰 Payment Confirmed";
+            var body = $"Order #{orderId.ToString()[..8]} payment of £{amount:F2} confirmed. Ready for acceptance.";
+
+            // Send push notification to admin users
+            await _pushNotificationService.SendOrderNotificationAsync(orderId, title, body);
+
+            // Send TeleBot message to customer
+            await _teleBotMessagingService.SendPaymentConfirmedAsync(orderId);
+
+            _logger.LogInformation("Sent payment confirmation notifications for order {OrderId} (Admin + Customer)", orderId);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to send payment confirmation notification for order {OrderId}", orderId);
+        }
+    }
 }

LittleShop/Services/ITeleBotMessagingService.cs

@@ -0,0 +1,16 @@
+using LittleShop.Enums;
+
+namespace LittleShop.Services;
+
+public interface ITeleBotMessagingService
+{
+    Task<bool> SendOrderStatusUpdateAsync(Guid orderId, OrderStatus newStatus);
+    Task<bool> SendPaymentConfirmedAsync(Guid orderId);
+    Task<bool> SendOrderAcceptedAsync(Guid orderId);
+    Task<bool> SendOrderPackingAsync(Guid orderId);
+    Task<bool> SendOrderDispatchedAsync(Guid orderId, string? trackingNumber = null);
+    Task<bool> SendOrderDeliveredAsync(Guid orderId);
+    Task<bool> SendOrderOnHoldAsync(Guid orderId, string? reason = null);
+    Task<bool> SendTestMessageAsync(Guid customerId, string message);
+    Task<bool> IsAvailableAsync();
+}

LittleShop/Services/MessageDeliveryService.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace LittleShop.Services;
+
+public class MessageDeliveryService : IMessageDeliveryService
+{
+    private readonly ILogger<MessageDeliveryService> _logger;
+
+    public MessageDeliveryService(ILogger<MessageDeliveryService> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<bool> QueueRecoveryMessageAsync(long telegramUserId, string message)
+    {
+        _logger.LogInformation("Queuing recovery message for user {UserId}: {Message}", telegramUserId, message);
+
+        // Placeholder implementation - would integrate with actual messaging system
+        await Task.Delay(100);
+
+        return true;
+    }
+}

LittleShop/Services/OrderService.cs

@@ -11,12 +11,16 @@ public class OrderService : IOrderService
     private readonly LittleShopContext _context;
     private readonly ILogger<OrderService> _logger;
     private readonly ICustomerService _customerService;
+    private readonly IPushNotificationService _pushNotificationService;
+    private readonly ITeleBotMessagingService _teleBotMessagingService;
 
-    public OrderService(LittleShopContext context, ILogger<OrderService> logger, ICustomerService customerService)
+    public OrderService(LittleShopContext context, ILogger<OrderService> logger, ICustomerService customerService, IPushNotificationService pushNotificationService, ITeleBotMessagingService teleBotMessagingService)
     {
         _context = context;
         _logger = logger;
         _customerService = customerService;
+        _pushNotificationService = pushNotificationService;
+        _teleBotMessagingService = teleBotMessagingService;
     }
 
     public async Task<IEnumerable<OrderDto>> GetAllOrdersAsync()
@@ -179,15 +183,18 @@ public class OrderService : IOrderService
 
             if (customerId.HasValue)
             {
-                _logger.LogInformation("Created order {OrderId} for customer {CustomerId} with total {Total}", 
+                _logger.LogInformation("Created order {OrderId} for customer {CustomerId} with total {Total}",
                     order.Id, customerId.Value, totalAmount);
             }
             else
             {
-                _logger.LogInformation("Created order {OrderId} for identity {Identity} with total {Total}", 
+                _logger.LogInformation("Created order {OrderId} for identity {Identity} with total {Total}",
                     order.Id, identityReference, totalAmount);
             }
 
+            // Send notification about new order to admin users
+            await SendNewOrderNotification(order);
+
             // Reload order with includes
             var createdOrder = await GetOrderByIdAsync(order.Id);
             return createdOrder!;
@@ -201,11 +208,14 @@ public class OrderService : IOrderService
 
     public async Task<bool> UpdateOrderStatusAsync(Guid id, UpdateOrderStatusDto updateOrderStatusDto)
     {
-        var order = await _context.Orders.FindAsync(id);
+        var order = await _context.Orders
+            .Include(o => o.Customer)
+            .FirstOrDefaultAsync(o => o.Id == id);
         if (order == null) return false;
 
+        var previousStatus = order.Status;
         order.Status = updateOrderStatusDto.Status;
-        
+
         if (!string.IsNullOrEmpty(updateOrderStatusDto.TrackingNumber))
         {
             order.TrackingNumber = updateOrderStatusDto.TrackingNumber;
@@ -225,7 +235,10 @@ public class OrderService : IOrderService
 
         await _context.SaveChangesAsync();
 
-        _logger.LogInformation("Updated order {OrderId} status to {Status}", id, updateOrderStatusDto.Status);
+        _logger.LogInformation("Updated order {OrderId} status from {PreviousStatus} to {NewStatus}", id, previousStatus, updateOrderStatusDto.Status);
+
+        // Send push notifications for status changes
+        await SendOrderStatusNotification(order, previousStatus, updateOrderStatusDto.Status);
 
         return true;
     }
@@ -336,10 +349,13 @@ public class OrderService : IOrderService
     // Enhanced workflow methods
     public async Task<bool> AcceptOrderAsync(Guid id, string userName, AcceptOrderDto acceptDto)
     {
-        var order = await _context.Orders.FindAsync(id);
+        var order = await _context.Orders
+            .Include(o => o.Customer)
+            .FirstOrDefaultAsync(o => o.Id == id);
         if (order == null || order.Status != OrderStatus.PaymentReceived)
             return false;
 
+        var previousStatus = order.Status;
         order.Status = OrderStatus.Accepted;
         order.AcceptedAt = DateTime.UtcNow;
         order.AcceptedByUser = userName;
@@ -349,15 +365,22 @@ public class OrderService : IOrderService
 
         await _context.SaveChangesAsync();
         _logger.LogInformation("Order {OrderId} accepted by {User}", id, userName);
+
+        // Send push notifications
+        await SendOrderStatusNotification(order, previousStatus, OrderStatus.Accepted);
+
         return true;
     }
 
     public async Task<bool> StartPackingAsync(Guid id, string userName, StartPackingDto packingDto)
     {
-        var order = await _context.Orders.FindAsync(id);
+        var order = await _context.Orders
+            .Include(o => o.Customer)
+            .FirstOrDefaultAsync(o => o.Id == id);
         if (order == null || order.Status != OrderStatus.Accepted)
             return false;
 
+        var previousStatus = order.Status;
         order.Status = OrderStatus.Packing;
         order.PackingStartedAt = DateTime.UtcNow;
         order.PackedByUser = userName;
@@ -367,12 +390,18 @@ public class OrderService : IOrderService
 
         await _context.SaveChangesAsync();
         _logger.LogInformation("Order {OrderId} packing started by {User}", id, userName);
+
+        // Send push notifications
+        await SendOrderStatusNotification(order, previousStatus, OrderStatus.Packing);
+
         return true;
     }
 
     public async Task<bool> DispatchOrderAsync(Guid id, string userName, DispatchOrderDto dispatchDto)
     {
-        var order = await _context.Orders.FindAsync(id);
+        var order = await _context.Orders
+            .Include(o => o.Customer)
+            .FirstOrDefaultAsync(o => o.Id == id);
         if (order == null || order.Status != OrderStatus.Packing)
             return false;
 
@@ -398,6 +427,10 @@ public class OrderService : IOrderService
 
         await _context.SaveChangesAsync();
         _logger.LogInformation("Order {OrderId} dispatched by {User} with tracking {TrackingNumber}", id, userName, dispatchDto.TrackingNumber);
+
+        // Send push notifications
+        await SendOrderStatusNotification(order, OrderStatus.Packing, OrderStatus.Dispatched);
+
         return true;
     }
 
@@ -490,4 +523,81 @@ public class OrderService : IOrderService
     {
         return await GetOrdersByStatusAsync(OrderStatus.OnHold);
     }
+
+    private async Task SendNewOrderNotification(Order order)
+    {
+        try
+        {
+            var title = "🛒 New Order Received";
+            var body = $"Order #{order.Id.ToString()[..8]} created for £{order.TotalAmount:F2}. Awaiting payment.";
+
+            // Send notification to all admin users about new order
+            await _pushNotificationService.SendOrderNotificationAsync(order.Id, title, body);
+
+            _logger.LogInformation("Sent new order notification for order {OrderId}", order.Id);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to send new order notification for order {OrderId}", order.Id);
+        }
+    }
+
+    private async Task SendOrderStatusNotification(Order order, OrderStatus previousStatus, OrderStatus newStatus)
+    {
+        try
+        {
+            var title = GetOrderStatusNotificationTitle(newStatus);
+            var body = GetOrderStatusNotificationBody(order, previousStatus, newStatus);
+
+            // Send notification to admin users about order status change
+            await _pushNotificationService.SendOrderNotificationAsync(order.Id, title, body);
+
+            // Send TeleBot message to customer (if customer exists)
+            if (order.Customer != null)
+            {
+                await _teleBotMessagingService.SendOrderStatusUpdateAsync(order.Id, newStatus);
+            }
+
+            _logger.LogInformation("Sent order status notifications for order {OrderId}: {Status} (Admin + Customer)", order.Id, newStatus);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to send order status notification for order {OrderId}", order.Id);
+        }
+    }
+
+    private static string GetOrderStatusNotificationTitle(OrderStatus status)
+    {
+        return status switch
+        {
+            OrderStatus.PaymentReceived => "💰 Payment Confirmed",
+            OrderStatus.Accepted => "✅ Order Accepted",
+            OrderStatus.Packing => "📦 Being Packed",
+            OrderStatus.Dispatched => "🚚 Order Dispatched",
+            OrderStatus.Delivered => "🎉 Order Delivered",
+            OrderStatus.OnHold => "⏸️ Order On Hold",
+            OrderStatus.Cancelled => "❌ Order Cancelled",
+            OrderStatus.Refunded => "💸 Order Refunded",
+            _ => "📋 Order Updated"
+        };
+    }
+
+    private static string GetOrderStatusNotificationBody(Order order, OrderStatus previousStatus, OrderStatus newStatus)
+    {
+        var orderId = order.Id.ToString()[..8];
+        var amount = order.TotalAmount.ToString("F2");
+
+        return newStatus switch
+        {
+            OrderStatus.PaymentReceived => $"Order #{orderId} payment confirmed (£{amount}). Ready for acceptance.",
+            OrderStatus.Accepted => $"Order #{orderId} has been accepted and is ready for packing.",
+            OrderStatus.Packing => $"Order #{orderId} is being packed. Will be dispatched soon.",
+            OrderStatus.Dispatched => $"Order #{orderId} dispatched with tracking: {order.TrackingNumber ?? "TBA"}",
+            OrderStatus.Delivered => $"Order #{orderId} has been delivered successfully.",
+            OrderStatus.OnHold => $"Order #{orderId} has been put on hold: {order.OnHoldReason}",
+            OrderStatus.Cancelled => $"Order #{orderId} has been cancelled.",
+            OrderStatus.Refunded => $"Order #{orderId} has been refunded (£{amount}).",
+            _ => $"Order #{orderId} status updated from {previousStatus} to {newStatus}."
+        };
+    }
 }

LittleShop/Services/TeleBotMessagingService.cs

@@ -0,0 +1,218 @@
+using System.Text;
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using LittleShop.Data;
+using LittleShop.Enums;
+using LittleShop.Models;
+
+namespace LittleShop.Services;
+
+public class TeleBotMessagingService : ITeleBotMessagingService
+{
+    private readonly LittleShopContext _context;
+    private readonly IConfiguration _configuration;
+    private readonly ILogger<TeleBotMessagingService> _logger;
+    private readonly HttpClient _httpClient;
+    private readonly string? _teleBotApiUrl;
+    private readonly string? _teleBotApiKey;
+
+    public TeleBotMessagingService(
+        LittleShopContext context,
+        IConfiguration configuration,
+        ILogger<TeleBotMessagingService> logger,
+        HttpClient httpClient)
+    {
+        _context = context;
+        _configuration = configuration;
+        _logger = logger;
+        _httpClient = httpClient;
+
+        _teleBotApiUrl = _configuration["TeleBot:ApiUrl"];
+        _teleBotApiKey = _configuration["TeleBot:ApiKey"];
+    }
+
+    public async Task<bool> SendOrderStatusUpdateAsync(Guid orderId, OrderStatus newStatus)
+    {
+        return newStatus switch
+        {
+            OrderStatus.PaymentReceived => await SendPaymentConfirmedAsync(orderId),
+            OrderStatus.Accepted => await SendOrderAcceptedAsync(orderId),
+            OrderStatus.Packing => await SendOrderPackingAsync(orderId),
+            OrderStatus.Dispatched => await SendOrderDispatchedAsync(orderId),
+            OrderStatus.Delivered => await SendOrderDeliveredAsync(orderId),
+            OrderStatus.OnHold => await SendOrderOnHoldAsync(orderId),
+            _ => false
+        };
+    }
+
+    public async Task<bool> SendPaymentConfirmedAsync(Guid orderId)
+    {
+        var order = await GetOrderWithCustomerAsync(orderId);
+        if (order?.Customer == null) return false;
+
+        var message = $"💰 *Payment Confirmed!*\n\n" +
+                     $"Your order #{orderId.ToString()[..8]} has been paid successfully. " +
+                     $"We'll start processing it shortly.\n\n" +
+                     $"📦 Total: £{order.TotalAmount:F2}\n" +
+                     $"⏱️ Expected processing: Within 24 hours";
+
+        return await SendTeleBotMessageAsync(order.Customer.TelegramUserId, message);
+    }
+
+    public async Task<bool> SendOrderAcceptedAsync(Guid orderId)
+    {
+        var order = await GetOrderWithCustomerAsync(orderId);
+        if (order?.Customer == null) return false;
+
+        var message = $"✅ *Order Accepted!*\n\n" +
+                     $"Great news! Your order #{orderId.ToString()[..8]} has been accepted " +
+                     $"and is being prepared for packing.\n\n" +
+                     $"⏱️ Expected packing: Within 24 hours\n" +
+                     $"🚚 We'll notify you when it's dispatched";
+
+        return await SendTeleBotMessageAsync(order.Customer.TelegramUserId, message);
+    }
+
+    public async Task<bool> SendOrderPackingAsync(Guid orderId)
+    {
+        var order = await GetOrderWithCustomerAsync(orderId);
+        if (order?.Customer == null) return false;
+
+        var message = $"📦 *Being Packed!*\n\n" +
+                     $"Your order #{orderId.ToString()[..8]} is currently being packed with care.\n\n" +
+                     $"🚚 We'll send tracking details once dispatched.\n" +
+                     $"⏱️ Expected dispatch: Later today";
+
+        return await SendTeleBotMessageAsync(order.Customer.TelegramUserId, message);
+    }
+
+    public async Task<bool> SendOrderDispatchedAsync(Guid orderId, string? trackingNumber = null)
+    {
+        var order = await GetOrderWithCustomerAsync(orderId);
+        if (order?.Customer == null) return false;
+
+        var trackingInfo = !string.IsNullOrEmpty(trackingNumber)
+            ? $"📍 Tracking: `{trackingNumber}`\n"
+            : "";
+
+        var message = $"🚚 *Order Dispatched!*\n\n" +
+                     $"Your order #{orderId.ToString()[..8]} is on its way!\n\n" +
+                     $"{trackingInfo}" +
+                     $"⏱️ Estimated delivery: 1-3 working days\n" +
+                     $"📍 Track your package for real-time updates";
+
+        return await SendTeleBotMessageAsync(order.Customer.TelegramUserId, message);
+    }
+
+    public async Task<bool> SendOrderDeliveredAsync(Guid orderId)
+    {
+        var order = await GetOrderWithCustomerAsync(orderId);
+        if (order?.Customer == null) return false;
+
+        var message = $"🎉 *Order Delivered!*\n\n" +
+                     $"Your order #{orderId.ToString()[..8]} has been delivered successfully!\n\n" +
+                     $"⭐ Please consider leaving a review using the /review command.\n" +
+                     $"🛒 Thank you for choosing us for your order!";
+
+        return await SendTeleBotMessageAsync(order.Customer.TelegramUserId, message);
+    }
+
+    public async Task<bool> SendOrderOnHoldAsync(Guid orderId, string? reason = null)
+    {
+        var order = await GetOrderWithCustomerAsync(orderId);
+        if (order?.Customer == null) return false;
+
+        var reasonText = !string.IsNullOrEmpty(reason)
+            ? $"\n\n📝 Reason: {reason}"
+            : "";
+
+        var message = $"⏸️ *Order On Hold*\n\n" +
+                     $"Your order #{orderId.ToString()[..8]} has been temporarily put on hold.{reasonText}\n\n" +
+                     $"💬 Please contact support if you have any questions.\n" +
+                     $"⏱️ We'll resolve this as quickly as possible";
+
+        return await SendTeleBotMessageAsync(order.Customer.TelegramUserId, message);
+    }
+
+    public async Task<bool> SendTestMessageAsync(Guid customerId, string message)
+    {
+        var customer = await _context.Customers.FindAsync(customerId);
+        if (customer == null) return false;
+
+        var testMessage = $"🧪 *Test Message*\n\n{message}";
+        return await SendTeleBotMessageAsync(customer.TelegramUserId, testMessage);
+    }
+
+    public async Task<bool> IsAvailableAsync()
+    {
+        if (string.IsNullOrEmpty(_teleBotApiUrl) || string.IsNullOrEmpty(_teleBotApiKey))
+        {
+            return false;
+        }
+
+        try
+        {
+            var response = await _httpClient.GetAsync($"{_teleBotApiUrl}/health");
+            return response.IsSuccessStatusCode;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private async Task<Order?> GetOrderWithCustomerAsync(Guid orderId)
+    {
+        return await _context.Orders
+            .Include(o => o.Customer)
+            .FirstOrDefaultAsync(o => o.Id == orderId);
+    }
+
+    private async Task<bool> SendTeleBotMessageAsync(long telegramUserId, string message)
+    {
+        if (!await IsAvailableAsync())
+        {
+            _logger.LogWarning("TeleBot API not available, skipping message to user {UserId}", telegramUserId);
+            return false;
+        }
+
+        try
+        {
+            var requestData = new
+            {
+                userId = telegramUserId,
+                message = message,
+                parseMode = "Markdown"
+            };
+
+            var json = JsonSerializer.Serialize(requestData);
+            var content = new StringContent(json, Encoding.UTF8, "application/json");
+
+            // Add API key header
+            _httpClient.DefaultRequestHeaders.Clear();
+            _httpClient.DefaultRequestHeaders.Add("X-API-Key", _teleBotApiKey);
+
+            var response = await _httpClient.PostAsync($"{_teleBotApiUrl}/api/messages/send", content);
+
+            if (response.IsSuccessStatusCode)
+            {
+                _logger.LogInformation("Successfully sent TeleBot message to user {UserId}", telegramUserId);
+                return true;
+            }
+            else
+            {
+                var responseContent = await response.Content.ReadAsStringAsync();
+                _logger.LogWarning("Failed to send TeleBot message to user {UserId}: {StatusCode} - {Response}",
+                    telegramUserId, response.StatusCode, responseContent);
+                return false;
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error sending TeleBot message to user {UserId}", telegramUserId);
+            return false;
+        }
+    }
+}