add: user balance

Backend/Features/Subscriptions/SubscriptionController.cs

@@ -100,6 +100,34 @@ namespace Backend.Features.Subscriptions
                 return BadRequest(new { message = ex.Message });
             }
         }
+
+        [HttpGet("subscriptions/preview-upgrade/{membershipId}")]
+        [Authorize]
+        public async Task<ActionResult<SubscriptionUpgradePreviewDto>> GetUpgradePreview(int membershipId)
+        {
+            var userIdStr = User.FindFirstValue(ClaimTypes.NameIdentifier);
+            if (string.IsNullOrEmpty(userIdStr)) return Unauthorized();
+
+            var preview = await _subscriptionService.GetUpgradePreviewAsync(Guid.Parse(userIdStr), membershipId);
+            return Ok(preview);
+        }
+
+        [HttpPost("subscriptions/subscribe-wallet")]
+        [Authorize]
+        public async Task<ActionResult<SubscriptionDto>> SubscribeWithWallet([FromBody] SubscribeRequest request)
+        {
+            try
+            {
+                var userIdStr = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                if (string.IsNullOrEmpty(userIdStr)) return Unauthorized();
+
+                var subscription = await _subscriptionService.SubscribeWithWalletAsync(Guid.Parse(userIdStr), request.MembershipId);
+                return Ok(subscription);
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(new { message = ex.Message });
+            }
+        }
     }
 }
-

Backend/Features/Subscriptions/SubscriptionService.cs

@@ -3,6 +3,8 @@ using DbConnect.Data;
 using DbConnect.Entities;
 using Microsoft.EntityFrameworkCore;
 using Backend.Features.Loyalty;
+using Backend.Features.Wallet;
+
 
 namespace Backend.Features.Subscriptions
 {
@@ -14,19 +16,25 @@ namespace Backend.Features.Subscriptions
         Task<bool> HandleLoyaltyRedemptionAsync(Guid userId, string rewardId, string rewardName, string redemptionId);
         Task<SubscriptionDto> SubscribeUserAsync(Guid userId, int membershipId, string? redemptionId = null);
         Task<IEnumerable<SubscriptionDto>> GetAllSubscriptionsAsync();
+        Task<SubscriptionUpgradePreviewDto> GetUpgradePreviewAsync(Guid userId, int newMembershipId);
+        Task<SubscriptionDto> SubscribeWithWalletAsync(Guid userId, int membershipId);
     }
 
+
     public class SubscriptionService : ISubscriptionService
     {
         private readonly AppDbContext _context;
         private readonly ILoyaltyService _loyaltyService;
+        private readonly IWalletService _walletService;
 
-        public SubscriptionService(AppDbContext context, ILoyaltyService loyaltyService)
+        public SubscriptionService(AppDbContext context, ILoyaltyService loyaltyService, IWalletService walletService)
         {
             _context = context;
             _loyaltyService = loyaltyService;
+            _walletService = walletService;
         }
 
+
         public async Task<IEnumerable<MembershipDto>> GetMembershipsAsync()
         {
             return await _context.Memberships
@@ -110,15 +118,41 @@ namespace Backend.Features.Subscriptions
             var membership = await _context.Memberships.FindAsync(membershipId);
             if (membership == null) throw new Exception("Membership plan not found.");
 
-            var latestSubscription = await _context.UserSubscriptions
-                .Where(s => s.UserId == userId && s.IsActive)
+            // Cooldown check: Max 1 active and 1 queued subscription
+            var activeAndQueued = await _context.UserSubscriptions
+                .Where(s => s.UserId == userId && s.IsActive && s.ExpiryDate > DateTime.UtcNow)
+                .ToListAsync();
+
+            if (activeAndQueued.Count >= 2)
+            {
+                throw new Exception("You already have an active and a queued subscription. Please wait until one expires.");
+            }
+
+            var currentActive = activeAndQueued
+                .Where(s => s.StartDate <= DateTime.UtcNow)
                 .OrderByDescending(s => s.ExpiryDate)
-                .FirstOrDefaultAsync();
+                .FirstOrDefault();
 
             DateTime startDate = DateTime.UtcNow;
-            if (latestSubscription != null && latestSubscription.ExpiryDate > startDate)
+            decimal discount = 0;
+
+            if (currentActive != null)
             {
-                startDate = latestSubscription.ExpiryDate;
+                // If it's the same membership, we queue it
+                if (currentActive.MembershipId == membershipId)
+                {
+                    startDate = currentActive.ExpiryDate;
+                }
+                else
+                {
+                    // If it's a different membership, we treat it as an upgrade/change
+                    // Calculate discount and deactivate old one
+                    var preview = await GetUpgradePreviewAsync(userId, membershipId);
+                    discount = preview.DiscountAmount;
+                    currentActive.IsActive = false;
+                    currentActive.Status = "Upgraded";
+                    startDate = DateTime.UtcNow;
+                }
             }
 
             var subscription = new UserSubscription
@@ -138,12 +172,16 @@ namespace Backend.Features.Subscriptions
             await _context.Entry(subscription).Reference(s => s.Membership).LoadAsync();
             await _context.Entry(subscription).Reference(s => s.User).LoadAsync();
 
+            // Only award loyalty points for the amount actually paid (Price - Discount)
+            decimal paidAmount = membership.Price - discount;
+            if (paidAmount < 0) paidAmount = 0;
+
             await _loyaltyService.ProcessEventAsync(
                 externalUserId: userId.ToString(),
                 eventKey: "SUBSCRIBE",
-                eventValue: (double)membership.Price,
+                eventValue: (double)paidAmount,
                 referenceId: $"SUB-{subscription.Id}",
-                description: $"Purchased Membership: {membership.Type}",
+                description: $"Purchased Membership: {membership.Type} (Discount applied: {discount})",
                 email: subscription.User?.Email ?? "No Email",
                 mobile: subscription.User?.PhoneNumber ?? "0000000000"
             );
@@ -151,6 +189,84 @@ namespace Backend.Features.Subscriptions
             return MapToDto(subscription);
         }
 
+        public async Task<SubscriptionUpgradePreviewDto> GetUpgradePreviewAsync(Guid userId, int newMembershipId)
+        {
+            var newMembership = await _context.Memberships.FindAsync(newMembershipId);
+            if (newMembership == null) return new SubscriptionUpgradePreviewDto { CanUpgrade = false, Message = "Plan not found" };
+
+            var currentSubscription = await _context.UserSubscriptions
+                .Include(s => s.Membership)
+                .Where(s => s.UserId == userId && s.IsActive && s.StartDate <= DateTime.UtcNow && s.ExpiryDate > DateTime.UtcNow)
+                .OrderByDescending(s => s.StartDate)
+                .FirstOrDefaultAsync();
+
+            if (currentSubscription == null)
+            {
+                return new SubscriptionUpgradePreviewDto
+                {
+                    OriginalPrice = newMembership.Price,
+                    DiscountAmount = 0,
+                    FinalPrice = newMembership.Price,
+                    CanUpgrade = true
+                };
+            }
+
+            if (currentSubscription.MembershipId == newMembershipId)
+            {
+                return new SubscriptionUpgradePreviewDto
+                {
+                    OriginalPrice = newMembership.Price,
+                    DiscountAmount = 0,
+                    FinalPrice = newMembership.Price,
+                    CanUpgrade = true,
+                    Message = "Same plan selected. This will be queued after your current subscription."
+                };
+            }
+
+            // Calculate unused value
+            var totalDuration = (currentSubscription.ExpiryDate - currentSubscription.StartDate).TotalDays;
+            var daysRemaining = (currentSubscription.ExpiryDate - DateTime.UtcNow).TotalDays;
+            
+            if (daysRemaining < 0) daysRemaining = 0;
+
+            decimal dailyRate = currentSubscription.Membership.Price / (decimal)totalDuration;
+            decimal unusedValue = dailyRate * (decimal)daysRemaining;
+
+            // Cap discount at new price
+            decimal discount = Math.Min(unusedValue, newMembership.Price);
+
+            return new SubscriptionUpgradePreviewDto
+            {
+                OriginalPrice = newMembership.Price,
+                DiscountAmount = Math.Round(discount, 2),
+                FinalPrice = Math.Round(newMembership.Price - discount, 2),
+                CanUpgrade = true,
+                Message = $"Pro-rated discount applied for your current {currentSubscription.Membership.Type} plan."
+            };
+        }
+
+        public async Task<SubscriptionDto> SubscribeWithWalletAsync(Guid userId, int membershipId)
+        {
+            var preview = await GetUpgradePreviewAsync(userId, membershipId);
+            if (!preview.CanUpgrade) throw new Exception(preview.Message ?? "Cannot purchase this plan.");
+
+            var balance = await _walletService.GetBalanceAsync(userId);
+            if (balance < preview.FinalPrice)
+            {
+                throw new Exception($"Insufficient balance. You need {preview.FinalPrice - balance:N0} more MMK.");
+            }
+
+            var membership = await _context.Memberships.FindAsync(membershipId);
+            
+            // Deduct from wallet
+            bool deducted = await _walletService.DeductAsync(userId, preview.FinalPrice, $"Subscription: {membership!.Type}");
+            if (!deducted) throw new Exception("Failed to deduct from wallet.");
+
+            // Create subscription
+            return await SubscribeUserAsync(userId, membershipId);
+        }
+
+
         public async Task<IEnumerable<SubscriptionDto>> GetAllSubscriptionsAsync()
         {
             var subscriptions = await _context.UserSubscriptions

Backend/Features/Subscriptions/SubscriptionUpgradePreviewDto.cs

@@ -0,0 +1,11 @@
+namespace Backend.Features.Subscriptions
+{
+    public class SubscriptionUpgradePreviewDto
+    {
+        public decimal OriginalPrice { get; set; }
+        public decimal DiscountAmount { get; set; }
+        public decimal FinalPrice { get; set; }
+        public string? Message { get; set; }
+        public bool CanUpgrade { get; set; }
+    }
+}

Backend/Features/Wallet/IWalletService.cs

@@ -0,0 +1,21 @@
+using LibraryManagement.Shared.Models;
+
+namespace Backend.Features.Wallet
+{
+    public interface IWalletService
+    {
+        Task<decimal> GetBalanceAsync(Guid userId);
+        Task<IEnumerable<WalletTransactionDto>> GetHistoryAsync(Guid userId);
+        Task<bool> TopUpAsync(Guid userId, decimal amount, Guid librarianId, string? description = null);
+        Task<bool> DeductAsync(Guid userId, decimal amount, string description, Guid? referenceId = null);
+    }
+
+    public class WalletTransactionDto
+    {
+        public Guid Id { get; set; }
+        public decimal Amount { get; set; }
+        public string Type { get; set; } = null!;
+        public string? Description { get; set; }
+        public DateTime CreatedAt { get; set; }
+    }
+}

Backend/Features/Wallet/WalletController.cs

@@ -0,0 +1,64 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.Security.Claims;
+
+namespace Backend.Features.Wallet
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    [Authorize]
+    public class WalletController : ControllerBase
+    {
+        private readonly IWalletService _walletService;
+
+        public WalletController(IWalletService walletService)
+        {
+            _walletService = walletService;
+        }
+
+        [HttpGet("balance")]
+        public async Task<ActionResult<decimal>> GetBalance()
+        {
+            var userIdStr = User.FindFirstValue(ClaimTypes.NameIdentifier);
+            if (string.IsNullOrEmpty(userIdStr)) return Unauthorized();
+
+            var balance = await _walletService.GetBalanceAsync(Guid.Parse(userIdStr));
+            return Ok(balance);
+        }
+
+        [HttpGet("history")]
+        public async Task<ActionResult<IEnumerable<WalletTransactionDto>>> GetHistory()
+        {
+            var userIdStr = User.FindFirstValue(ClaimTypes.NameIdentifier);
+            if (string.IsNullOrEmpty(userIdStr)) return Unauthorized();
+
+            var history = await _walletService.GetHistoryAsync(Guid.Parse(userIdStr));
+            return Ok(history);
+        }
+
+        [HttpPost("topup")]
+        [Authorize(Roles = "Librarian")]
+        public async Task<IActionResult> TopUp([FromBody] TopUpRequest request)
+        {
+            var librarianIdStr = User.FindFirstValue(ClaimTypes.NameIdentifier);
+            if (string.IsNullOrEmpty(librarianIdStr)) return Unauthorized();
+
+            var success = await _walletService.TopUpAsync(
+                request.UserId, 
+                request.Amount, 
+                Guid.Parse(librarianIdStr), 
+                request.Description);
+
+            if (!success) return BadRequest(new { message = "Failed to top up wallet." });
+
+            return Ok(new { message = "Wallet topped up successfully." });
+        }
+    }
+
+    public class TopUpRequest
+    {
+        public Guid UserId { get; set; }
+        public decimal Amount { get; set; }
+        public string? Description { get; set; }
+    }
+}

Backend/Features/Wallet/WalletService.cs

@@ -0,0 +1,79 @@
+using DbConnect.Data;
+using DbConnect.Entities;
+using Microsoft.EntityFrameworkCore;
+
+namespace Backend.Features.Wallet
+{
+    public class WalletService : IWalletService
+    {
+        private readonly AppDbContext _context;
+
+        public WalletService(AppDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<decimal> GetBalanceAsync(Guid userId)
+        {
+            var user = await _context.Users.FindAsync(userId);
+            return user?.Balance ?? 0;
+        }
+
+        public async Task<IEnumerable<WalletTransactionDto>> GetHistoryAsync(Guid userId)
+        {
+            return await _context.WalletTransactions
+                .Where(t => t.UserId == userId)
+                .OrderByDescending(t => t.CreatedAt)
+                .Select(t => new WalletTransactionDto
+                {
+                    Id = t.Id,
+                    Amount = t.Amount,
+                    Type = t.Type,
+                    Description = t.Description,
+                    CreatedAt = t.CreatedAt
+                })
+                .ToListAsync();
+        }
+
+        public async Task<bool> TopUpAsync(Guid userId, decimal amount, Guid librarianId, string? description = null)
+        {
+            var user = await _context.Users.FindAsync(userId);
+            if (user == null) return false;
+
+            user.Balance += amount;
+
+            var transaction = new WalletTransaction
+            {
+                UserId = userId,
+                Amount = amount,
+                Type = "Deposit",
+                Description = description ?? "Cash Deposit",
+                ProcessedBy = librarianId
+            };
+
+            _context.WalletTransactions.Add(transaction);
+            await _context.SaveChangesAsync();
+            return true;
+        }
+
+        public async Task<bool> DeductAsync(Guid userId, decimal amount, string description, Guid? referenceId = null)
+        {
+            var user = await _context.Users.FindAsync(userId);
+            if (user == null || user.Balance < amount) return false;
+
+            user.Balance -= amount;
+
+            var transaction = new WalletTransaction
+            {
+                UserId = userId,
+                Amount = -amount, // Negative for deduction
+                Type = "Purchase",
+                Description = description
+            };
+
+            _context.WalletTransactions.Add(transaction);
+            await _context.SaveChangesAsync();
+            return true;
+        }
+    }
+}

Backend/Program.cs

@@ -15,7 +15,9 @@ using Backend.Features.Borrowings;
 using Backend.Features.Loyalty;
 using Backend.Features.Notification;
 using Backend.Features.Wishlist;
+using Backend.Features.Wallet;
 using FirebaseAdmin;
+
 using Google.Apis.Auth.OAuth2;
 
 AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
@@ -95,8 +97,10 @@ builder.Services.AddScoped<ICategoryService, CategoryService>();
 builder.Services.AddScoped<IBorrowingService, BorrowingService>();
 builder.Services.AddScoped<INotificationService, NotificationService>();
 builder.Services.AddScoped<IWishlistService, WishlistService>();
+builder.Services.AddScoped<IWalletService, WalletService>();
 builder.Services.AddHostedService<NotificationBackgroundService>();
 
+
 // Register Loyalty API Client
 builder.Services.AddHttpClient<ILoyaltyService, LoyaltyService>(client =>
 {

BlazorFrontend/Components/Pages/Members.razor

@@ -232,6 +232,36 @@ else if (_currentView == ViewMode.Details && _selectedUser != null)
                         <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"></path></svg>
                     </button>
                 </div>
+
+                <!-- Wallet Management Section -->
+                <div class="mt-8 pt-8 border-t border-mystic-100">
+                    <div class="flex items-center justify-between mb-6">
+                        <h3 class="text-2xl font-bold text-mystic-900">Library Wallet</h3>
+                        <div class="bg-indigo-50 border border-indigo-100 px-4 py-2 rounded-xl">
+                            <span class="text-xs font-bold text-indigo-400 uppercase tracking-widest block">Current Balance</span>
+                            <span class="text-xl font-black text-indigo-900">@_selectedUser.User.Balance.ToString("N0") MMK</span>
+                        </div>
+                    </div>
+
+                    <div class="bg-white border border-mystic-200 rounded-2xl p-6 shadow-sm">
+                        <h4 class="text-sm font-bold text-mystic-700 mb-4">Add Credits (Cash Deposit)</h4>
+                        <div class="flex flex-col sm:flex-row gap-4">
+                            <div class="flex-1">
+                                <div class="relative">
+                                    <div class="absolute inset-y-0 left-0 pl-3 flex items-center pointer-events-none">
+                                        <span class="text-mystic-400 text-sm font-bold">MMK</span>
+                                    </div>
+                                    <input type="number" @bind="_topUpAmount" class="block w-full pl-12 pr-3 py-3 border border-mystic-300 rounded-xl focus:ring-mystic-900 focus:border-mystic-900 sm:text-sm" placeholder="Amount (e.g. 5000)" />
+                                </div>
+                            </div>
+                            <button @onclick="TopUpWallet" class="btn-primary px-8 whitespace-nowrap" disabled="@(_topUpAmount <= 0)">
+                                Confirm Deposit
+                            </button>
+                        </div>
+                        <p class="mt-3 text-xs text-mystic-400 italic">This will instantly add credits to the user's library wallet.</p>
+                    </div>
+                </div>
+
                 
                 <!-- Subscription Management -->
                 <div class="mt-8 pt-8 border-t border-mystic-100">
@@ -409,6 +439,8 @@ else if (_currentView == ViewMode.Create || _currentView == ViewMode.Edit)
     private UserCreateRequest _createRequest = new();
     private UserUpdateRequest _updateRequest = new();
     private UserDto? _editUser;
+    private decimal _topUpAmount;
+
 
     protected override async Task OnInitializedAsync()
     {
@@ -630,6 +662,40 @@ else if (_currentView == ViewMode.Create || _currentView == ViewMode.Edit)
             await JSRuntime.InvokeVoidAsync("showToast", "Error: " + ex.Message, "error");
         }
     }
+
+    private async Task TopUpWallet()
+    {
+        if (_selectedUser == null || _topUpAmount <= 0) return;
+
+        bool confirmed = await JSRuntime.InvokeAsync<bool>("confirm", $"Add {_topUpAmount:N0} MMK to {_selectedUser.User.FullName}'s wallet?");
+        if (!confirmed) return;
+
+        try
+        {
+            var success = await ApiClient.TopUpWalletAsync(new TopUpRequest 
+            { 
+                UserId = _selectedUser.User.Id, 
+                Amount = _topUpAmount,
+                Description = "Librarian Cash Top-up"
+            });
+
+            if (success)
+            {
+                await JSRuntime.InvokeVoidAsync("showToast", "Wallet topped up successfully!", "success");
+                _topUpAmount = 0;
+                await ShowDetails(_selectedUser.User.Id); // Refresh details to show new balance
+            }
+            else
+            {
+                await JSRuntime.InvokeVoidAsync("showToast", "Failed to top up wallet.", "error");
+            }
+        }
+        catch (Exception ex)
+        {
+            await JSRuntime.InvokeVoidAsync("showToast", "Error: " + ex.Message, "error");
+        }
+    }
 }
 
 
+

BlazorFrontend/Components/Pages/Membership.razor

@@ -38,8 +38,19 @@ else if (_viewModel != null)
                     </div>
                 </div>
             }
+
+            <div class="flex items-center gap-4 bg-mystic-50 px-6 py-4 rounded-xl border border-mystic-200/60">
+                <div class="bg-indigo-100 p-2.5 rounded-lg text-indigo-600">
+                    <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="12" x="2" y="6" rx="2"/><circle cx="12" cy="12" r="2"/><path d="M6 12h.01M18 12h.01"/></svg>
+                </div>
+                <div>
+                    <div class="text-xs font-bold text-mystic-400 uppercase tracking-widest">Wallet Balance</div>
+                    <div class="text-2xl font-black text-mystic-900 leading-none">@_viewModel.WalletBalance.ToString("N0") <span class="text-xs font-bold text-mystic-400">MMK</span></div>
+                </div>
+            </div>
         </div>
 
+
         <div class="grid grid-cols-1 lg:grid-cols-3 gap-8">
             <!-- Current Subscription Card -->
             <div class="lg:col-span-2 space-y-8">
@@ -232,7 +243,13 @@ else if (_viewModel != null)
                             <div class="space-y-3">
                                 <a href="Borrowings" class="block w-full py-4 rounded-2xl bg-white border-2 border-mystic-900 text-mystic-900 text-center font-bold text-sm transition-all duration-200 hover:bg-mystic-900 hover:text-white">Pay Cash</a>
                                 
+                                <button @onclick="() => BuyWithWallet(plan)" 
+                                        class="w-full py-4 rounded-2xl bg-mystic-900 text-white font-bold text-sm hover:bg-mystic-800 transition-all shadow-lg shadow-mystic-900/20">
+                                    Buy with Wallet
+                                </button>
+
                                 @if (!string.IsNullOrEmpty(plan.RewardId) && _viewModel.RewardPointCosts.ContainsKey(plan.RewardId))
+
                                 {
                                     <button @onclick="() => RedeemMembership(plan.RewardId, plan.Type, _viewModel.RewardPointCosts[plan.RewardId])" 
                                             class="w-full py-4 rounded-2xl bg-amber-400 text-mystic-900 font-black text-sm hover:bg-amber-500 transition-all shadow-lg shadow-amber-400/20">
@@ -279,8 +296,10 @@ else if (_viewModel != null)
                 AvailableMemberships = memberships.ToList(),
                 QueuedMemberships = queuedMemberships,
                 LoyaltyAccount = loyaltyAccount,
-                RewardPointCosts = activeRewards.ToDictionary(r => r.Id, r => r.PointCost)
+                RewardPointCosts = activeRewards.ToDictionary(r => r.Id, r => r.PointCost),
+                WalletBalance = await ApiClient.GetWalletBalanceAsync()
             };
+
         }
         catch (Exception ex)
         {
@@ -316,6 +335,55 @@ else if (_viewModel != null)
             await JSRuntime.InvokeVoidAsync("showToast", "An unexpected error occurred: " + ex.Message, "error");
         }
     }
+
+    private async Task BuyWithWallet(MembershipDto plan)
+    {
+        try
+        {
+            var preview = await ApiClient.GetUpgradePreviewAsync(plan.Id);
+            if (preview == null || !preview.CanUpgrade)
+            {
+                await JSRuntime.InvokeVoidAsync("showToast", preview?.Message ?? "Cannot upgrade to this plan.", "error");
+                return;
+            }
+
+            string confirmMsg = $"Are you sure you want to purchase {plan.Type} membership?\n\n" +
+                               $"Original Price: {preview.OriginalPrice:N0} MMK\n";
+            
+            if (preview.DiscountAmount > 0)
+            {
+                confirmMsg += $"Upgrade Discount: -{preview.DiscountAmount:N0} MMK\n";
+            }
+            
+            confirmMsg += $"Final Price: {preview.FinalPrice:N0} MMK\n\n" +
+                         $"Your Balance: {_viewModel?.WalletBalance:N0} MMK";
+
+            bool confirmed = await JSRuntime.InvokeAsync<bool>("confirm", confirmMsg);
+            if (!confirmed) return;
+
+            if (_viewModel?.WalletBalance < preview.FinalPrice)
+            {
+                await JSRuntime.InvokeVoidAsync("showToast", "Insufficient wallet balance. Please top up at the library.", "error");
+                return;
+            }
+
+            var result = await ApiClient.SubscribeWithWalletAsync(new SubscribeRequest { MembershipId = plan.Id });
+            if (result != null)
+            {
+                await JSRuntime.InvokeVoidAsync("showToast", "Subscription purchased successfully!", "success");
+                await OnInitializedAsync();
+            }
+            else
+            {
+                await JSRuntime.InvokeVoidAsync("showToast", "Failed to complete purchase.", "error");
+            }
+        }
+        catch (Exception ex)
+        {
+            await JSRuntime.InvokeVoidAsync("showToast", "Error: " + ex.Message, "error");
+        }
+    }
 }
 
 
+

BlazorFrontend/Models/MembershipViewModel.cs

@@ -10,6 +10,8 @@ namespace BlazorFrontend.Models
         public List<SubscriptionDto> QueuedMemberships { get; set; } = new List<SubscriptionDto>();
         public LoyaltyAccountDto? LoyaltyAccount { get; set; }
         public Dictionary<string, double> RewardPointCosts { get; set; } = new Dictionary<string, double>();
+        public decimal WalletBalance { get; set; }
     }
+
 }
 

BlazorFrontend/Services/LibraryApiClient.cs

@@ -171,8 +171,50 @@ namespace BlazorFrontend.Services
         {
             return await _httpClient.GetFromJsonAsync<IEnumerable<SubscriptionDto>>("api/subscriptions/all") ?? Enumerable.Empty<SubscriptionDto>();
         }
+
+        public async Task<SubscriptionUpgradePreviewDto?> GetUpgradePreviewAsync(int membershipId)
+        {
+            try
+            {
+                return await _httpClient.GetFromJsonAsync<SubscriptionUpgradePreviewDto>($"api/subscriptions/preview-upgrade/{membershipId}");
+            }
+            catch { return null; }
+        }
+
+        public async Task<SubscriptionDto?> SubscribeWithWalletAsync(SubscribeRequest request)
+        {
+            var response = await _httpClient.PostAsJsonAsync("api/subscriptions/subscribe-wallet", request);
+            return response.IsSuccessStatusCode ? await response.Content.ReadFromJsonAsync<SubscriptionDto>() : null;
+        }
+        #endregion
+
+        #region Wallet
+        public async Task<decimal> GetWalletBalanceAsync()
+        {
+            try
+            {
+                return await _httpClient.GetFromJsonAsync<decimal>("api/wallet/balance");
+            }
+            catch { return 0; }
+        }
+
+        public async Task<IEnumerable<WalletTransactionDto>> GetWalletHistoryAsync()
+        {
+            try
+            {
+                return await _httpClient.GetFromJsonAsync<IEnumerable<WalletTransactionDto>>("api/wallet/history") ?? Enumerable.Empty<WalletTransactionDto>();
+            }
+            catch { return Enumerable.Empty<WalletTransactionDto>(); }
+        }
+
+        public async Task<bool> TopUpWalletAsync(TopUpRequest request)
+        {
+            var response = await _httpClient.PostAsJsonAsync("api/wallet/topup", request);
+            return response.IsSuccessStatusCode;
+        }
         #endregion
 
+
         public async Task<LoyaltyAccountDto?> GetMyLoyaltyAccountAsync()
         {
             try

DbConnect/Data/AppDbContext.cs

@@ -27,6 +27,8 @@ public partial class AppDbContext : DbContext
     public virtual DbSet<UserSubscription> UserSubscriptions { get; set; }
 
     public virtual DbSet<WishlistItem> WishlistItems { get; set; }
+    public virtual DbSet<WalletTransaction> WalletTransactions { get; set; }
+
 
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
@@ -152,8 +154,10 @@ public partial class AppDbContext : DbContext
             entity.Property(e => e.StudentId).HasMaxLength(20);
             entity.Property(e => e.SuspensionEndDate).HasColumnType("timestamp");
             entity.Property(e => e.UpdatedAt).HasColumnType("timestamp");
+            entity.Property(e => e.Balance).HasColumnType("decimal(18, 2)").HasDefaultValue(0);
         });
 
+
         modelBuilder.Entity<UserSubscription>(entity =>
         {
             entity.Property(e => e.Id).HasDefaultValueSql("gen_random_uuid()");
@@ -195,6 +199,21 @@ public partial class AppDbContext : DbContext
                 .HasConstraintName("FK_WishlistItems_Users");
         });
 
+        modelBuilder.Entity<WalletTransaction>(entity =>
+        {
+            entity.HasKey(e => e.Id);
+            entity.Property(e => e.Id).HasDefaultValueSql("gen_random_uuid()");
+            entity.Property(e => e.Amount).HasColumnType("decimal(18, 2)");
+            entity.Property(e => e.Type).HasMaxLength(20);
+            entity.Property(e => e.CreatedAt).HasColumnType("timestamp").HasDefaultValueSql("now()");
+
+            entity.HasOne(d => d.User)
+                .WithMany()
+                .HasForeignKey(d => d.UserId)
+                .OnDelete(DeleteBehavior.Cascade);
+        });
+
+
         OnModelCreatingPartial(modelBuilder);
     }
 

DbConnect/Entities/User.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 
 namespace DbConnect.Entities;
@@ -32,6 +32,9 @@ public partial class User
     public string? Address { get; set; }
 
     public string? FcmToken { get; set; }
+    
+    public decimal Balance { get; set; }
+
 
     public virtual ICollection<Borrowing> Borrowings { get; set; } = new List<Borrowing>();
 

DbConnect/Entities/WalletTransaction.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace DbConnect.Entities;
+
+public class WalletTransaction
+{
+    public Guid Id { get; set; }
+    public Guid UserId { get; set; }
+    public decimal Amount { get; set; }
+    public string Type { get; set; } = null!; // Deposit, Purchase, Refund
+    public string? Description { get; set; }
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+    public Guid? ProcessedBy { get; set; } // Librarian ID
+
+    public virtual User User { get; set; } = null!;
+}

LibraryManagement.Shared/Models/LibraryDtos.cs

@@ -138,12 +138,20 @@ namespace LibraryManagement.Shared.Models
         public int MembershipId { get; set; }
     }
 
-    public class AdminSubscribeRequest
-    {
         public Guid UserId { get; set; }
         public int MembershipId { get; set; }
     }
 
+    public class SubscriptionUpgradePreviewDto
+    {
+        public decimal OriginalPrice { get; set; }
+        public decimal DiscountAmount { get; set; }
+        public decimal FinalPrice { get; set; }
+        public string? Message { get; set; }
+        public bool CanUpgrade { get; set; }
+    }
+
+
     // Loyalty DTOs
     public class LoyaltyAccountDto
     {
@@ -238,8 +246,26 @@ namespace LibraryManagement.Shared.Models
         public DateTime? UpdatedAt { get; set; }
         public bool? BanStatus { get; set; }
         public DateTime? SuspensionEndDate { get; set; }
+        public decimal Balance { get; set; }
     }
 
+    public class WalletTransactionDto
+    {
+        public Guid Id { get; set; }
+        public decimal Amount { get; set; }
+        public string Type { get; set; } = null!;
+        public string? Description { get; set; }
+        public DateTime CreatedAt { get; set; }
+    }
+
+    public class TopUpRequest
+    {
+        public Guid UserId { get; set; }
+        public decimal Amount { get; set; }
+        public string? Description { get; set; }
+    }
+
+
     public class UserCreateRequest
     {
         public string FullName { get; set; } = string.Empty;