feat: add user management, book management, categories management, membership management, and borrowing management

Database/Models/Book.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 
 namespace Database.Models;
@@ -22,6 +22,12 @@ public partial class Book
     public string? Description { get; set; }
 
     public string? CoverUrl { get; set; }
+    
+    public int TotalCopies { get; set; }
+    
+    public int AvailableCopies { get; set; }
+    
+    public DateTime? UpdatedAt { get; set; }
 
     public virtual ICollection<Borrowing> Borrowings { get; set; } = new List<Borrowing>();
 

Database/Models/LibraryManagementContext.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using Microsoft.EntityFrameworkCore;
 
@@ -53,6 +53,9 @@ public partial class LibraryManagementContext : DbContext
                 .HasMaxLength(20)
                 .HasDefaultValue("Available");
             entity.Property(e => e.Title).HasMaxLength(200);
+            entity.Property(e => e.TotalCopies).HasDefaultValue(1);
+            entity.Property(e => e.AvailableCopies).HasDefaultValue(1);
+            entity.Property(e => e.UpdatedAt).HasColumnType("datetime");
 
             entity.HasMany(d => d.Categories).WithMany(p => p.Books)
                 .UsingEntity<Dictionary<string, object>>(
@@ -130,7 +133,7 @@ public partial class LibraryManagementContext : DbContext
             entity.Property(e => e.PhoneNumber).HasMaxLength(20);
             entity.Property(e => e.Role)
                 .HasMaxLength(20)
-                .HasDefaultValue("User");
+                .HasDefaultValue("Member");
             entity.Property(e => e.StudentId).HasMaxLength(20);
             entity.Property(e => e.SuspensionEndDate).HasColumnType("datetime");
             entity.Property(e => e.UpdatedAt).HasColumnType("datetime");

LibraryManagement.Backend/Features/Auth/AuthController.cs

@@ -1,4 +1,6 @@
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using System.Security.Claims;
 
 namespace LibraryManagement.Backend.Features.Auth
 {
@@ -40,5 +42,18 @@ namespace LibraryManagement.Backend.Features.Auth
                 return Unauthorized(new { message = ex.Message });
             }
         }
+
+        [HttpGet("me")]
+        [Authorize]
+        public IActionResult GetCurrentUser()
+        {
+            var claims = User.Claims.Select(c => new { c.Type, c.Value }).ToList();
+            return Ok(new
+            {
+                IsAuthenticated = User.Identity?.IsAuthenticated,
+                Name = User.Identity?.Name,
+                Claims = claims
+            });
+        }
     }
 }

LibraryManagement.Backend/Features/Auth/AuthService.cs

@@ -5,6 +5,8 @@ using System.IdentityModel.Tokens.Jwt;
 using System.Security.Claims;
 using System.Text;
 
+using LibraryManagement.Backend.Features.Subscriptions;
+
 namespace LibraryManagement.Backend.Features.Auth
 {
     public interface IAuthService
@@ -17,11 +19,13 @@ namespace LibraryManagement.Backend.Features.Auth
     {
         private readonly LibraryManagementContext _context;
         private readonly IConfiguration _configuration;
+        private readonly ISubscriptionService _subscriptionService;
 
-        public AuthService(LibraryManagementContext context, IConfiguration configuration)
+        public AuthService(LibraryManagementContext context, IConfiguration configuration, ISubscriptionService subscriptionService)
         {
             _context = context;
             _configuration = configuration;
+            _subscriptionService = subscriptionService;
         }
 
         public async Task<AuthResponse> Register(RegisterRequest request)
@@ -47,6 +51,11 @@ namespace LibraryManagement.Backend.Features.Auth
             _context.Users.Add(user);
             await _context.SaveChangesAsync();
 
+            if (!string.IsNullOrEmpty(user.StudentId))
+            {
+                await _subscriptionService.SubscribeUserAsync(user.Id, 3); // 3 is "Basic Yearly"
+            }
+
             return await AuthenticateUser(user);
         }
 

LibraryManagement.Backend/Features/Books/BookController.cs

@@ -0,0 +1,67 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace LibraryManagement.Backend.Features.Books
+{
+    [ApiController]
+    [Route("api/books")]
+    public class BookController : ControllerBase
+    {
+        private readonly IBookService _bookService;
+
+        public BookController(IBookService bookService)
+        {
+            _bookService = bookService;
+        }
+
+        [HttpGet]
+        [Authorize]
+        public async Task<ActionResult<IEnumerable<BookDto>>> GetBooks()
+        {
+            var books = await _bookService.GetAllBooksAsync();
+            return Ok(books);
+        }
+
+        [HttpGet("{id}")]
+        [Authorize]
+        public async Task<ActionResult<BookDto>> GetBook(int id)
+        {
+            var book = await _bookService.GetBookByIdAsync(id);
+            if (book == null) return NotFound();
+            return Ok(book);
+        }
+
+        [HttpPost]
+        [Authorize(Roles = "Librarian")]
+        public async Task<ActionResult<BookDto>> CreateBook([FromBody] BookCreateRequest request)
+        {
+            try
+            {
+                var book = await _bookService.CreateBookAsync(request);
+                return CreatedAtAction(nameof(GetBook), new { id = book.Id }, book);
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(new { message = ex.Message });
+            }
+        }
+
+        [HttpPut("{id}")]
+        [Authorize(Roles = "Librarian")]
+        public async Task<ActionResult<BookDto>> UpdateBook(int id, [FromBody] BookUpdateRequest request)
+        {
+            var updatedBook = await _bookService.UpdateBookAsync(id, request);
+            if (updatedBook == null) return NotFound();
+            return Ok(updatedBook);
+        }
+
+        [HttpDelete("{id}")]
+        [Authorize(Roles = "Librarian")]
+        public async Task<IActionResult> DeleteBook(int id)
+        {
+            var success = await _bookService.DeleteBookAsync(id);
+            if (!success) return NotFound();
+            return NoContent();
+        }
+    }
+}

LibraryManagement.Backend/Features/Books/BookService.cs

@@ -0,0 +1,152 @@
+using Database.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace LibraryManagement.Backend.Features.Books
+{
+    public interface IBookService
+    {
+        Task<IEnumerable<BookDto>> GetAllBooksAsync();
+        Task<BookDto?> GetBookByIdAsync(int id);
+        Task<BookDto> CreateBookAsync(BookCreateRequest request);
+        Task<BookDto?> UpdateBookAsync(int id, BookUpdateRequest request);
+        Task<bool> DeleteBookAsync(int id);
+    }
+
+    public class BookService : IBookService
+    {
+        private readonly LibraryManagementContext _context;
+
+        public BookService(LibraryManagementContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<IEnumerable<BookDto>> GetAllBooksAsync()
+        {
+            return await _context.Books
+                .Where(b => b.IsActive)
+                .Select(b => MapToDto(b))
+                .ToListAsync();
+        }
+
+        public async Task<BookDto?> GetBookByIdAsync(int id)
+        {
+            var book = await _context.Books.FindAsync(id);
+            if (book == null || !book.IsActive) return null;
+            return MapToDto(book);
+        }
+
+        public async Task<BookDto> CreateBookAsync(BookCreateRequest request)
+        {
+            if (await _context.Books.AnyAsync(b => b.Isbn == request.Isbn))
+            {
+                throw new Exception("A book with this ISBN already exists.");
+            }
+
+            var book = new Book
+            {
+                Title = request.Title,
+                Isbn = request.Isbn,
+                Author = request.Author,
+                Description = request.Description,
+                CoverUrl = request.CoverUrl,
+                TotalCopies = request.TotalCopies,
+                AvailableCopies = request.TotalCopies,
+                Status = request.TotalCopies > 0 ? "Available" : "Out Of Stock",
+                IsActive = true,
+                CreatedAt = DateTime.UtcNow
+            };
+
+            _context.Books.Add(book);
+            await _context.SaveChangesAsync();
+
+            return MapToDto(book);
+        }
+
+        public async Task<BookDto?> UpdateBookAsync(int id, BookUpdateRequest request)
+        {
+            var book = await _context.Books.FindAsync(id);
+            if (book == null || !book.IsActive) return null;
+
+            book.Title = request.Title;
+            book.Author = request.Author;
+            book.Description = request.Description;
+            book.CoverUrl = request.CoverUrl;
+            
+            // Basic logic to sync availability when total copies change
+            int difference = request.TotalCopies - book.TotalCopies;
+            book.TotalCopies = request.TotalCopies;
+            book.AvailableCopies += difference;
+
+            if (book.AvailableCopies < 0) book.AvailableCopies = 0;
+            book.Status = book.AvailableCopies > 0 ? "Available" : "Out Of Stock";
+            
+            book.UpdatedAt = DateTime.UtcNow;
+
+            await _context.SaveChangesAsync();
+            return MapToDto(book);
+        }
+
+        public async Task<bool> DeleteBookAsync(int id)
+        {
+            var book = await _context.Books.FindAsync(id);
+            if (book == null) return false;
+
+            book.IsActive = false;
+            book.UpdatedAt = DateTime.UtcNow;
+
+            await _context.SaveChangesAsync();
+            return true;
+        }
+
+        private static BookDto MapToDto(Book book)
+        {
+            return new BookDto
+            {
+                Id = book.Id,
+                Title = book.Title,
+                Isbn = book.Isbn,
+                Author = book.Author,
+                Status = book.Status,
+                Description = book.Description,
+                CoverUrl = book.CoverUrl,
+                TotalCopies = book.TotalCopies,
+                AvailableCopies = book.AvailableCopies,
+                CreatedAt = book.CreatedAt
+            };
+        }
+    }
+
+    public class BookDto
+    {
+        public int Id { get; set; }
+        public string Title { get; set; } = string.Empty;
+        public string Isbn { get; set; } = string.Empty;
+        public string Author { get; set; } = string.Empty;
+        public string Status { get; set; } = string.Empty;
+        public string? Description { get; set; }
+        public string? CoverUrl { get; set; }
+        public int TotalCopies { get; set; }
+        public int AvailableCopies { get; set; }
+        public DateTime CreatedAt { get; set; }
+    }
+
+    public class BookCreateRequest
+    {
+        public string Title { get; set; } = string.Empty;
+        public string Isbn { get; set; } = string.Empty;
+        public string Author { get; set; } = string.Empty;
+        public string? Description { get; set; }
+        public string? CoverUrl { get; set; }
+        public int TotalCopies { get; set; }
+    }
+
+    public class BookUpdateRequest
+    {
+        public string Title { get; set; } = string.Empty;
+        public string Author { get; set; } = string.Empty;
+        public string? Description { get; set; }
+        public string? CoverUrl { get; set; }
+        public int TotalCopies { get; set; }
+    }
+}

LibraryManagement.Backend/Features/Borrowing/BorrowingController.cs

@@ -0,0 +1,72 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.Security.Claims;
+
+namespace LibraryManagement.Backend.Features.Borrowings
+{
+    [ApiController]
+    [Route("api/borrowings")]
+    public class BorrowingController : ControllerBase
+    {
+        private readonly IBorrowingService _borrowingService;
+
+        public BorrowingController(IBorrowingService borrowingService)
+        {
+            _borrowingService = borrowingService;
+        }
+
+        [HttpPost("borrow")]
+        [Authorize]
+        public async Task<ActionResult<BorrowingDto>> BorrowBook([FromBody] BorrowRequest request)
+        {
+            try
+            {
+                var userIdStr = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                if (string.IsNullOrEmpty(userIdStr)) return Unauthorized();
+
+                var userId = int.Parse(userIdStr);
+                var borrowing = await _borrowingService.BorrowBookAsync(userId, request.BookId);
+                return Ok(borrowing);
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(new { message = ex.Message });
+            }
+        }
+
+        [HttpPost("return/{id}")]
+        [Authorize(Roles = "Librarian")]
+        public async Task<ActionResult<BorrowingDto>> ReturnBook(int id)
+        {
+            try
+            {
+                var borrowing = await _borrowingService.ReturnBookAsync(id);
+                return Ok(borrowing);
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(new { message = ex.Message });
+            }
+        }
+
+        [HttpGet("me")]
+        [Authorize]
+        public async Task<ActionResult<IEnumerable<BorrowingDto>>> GetMyBorrowings()
+        {
+            var userIdStr = User.FindFirstValue(ClaimTypes.NameIdentifier);
+            if (string.IsNullOrEmpty(userIdStr)) return Unauthorized();
+
+            var userId = int.Parse(userIdStr);
+            var borrowings = await _borrowingService.GetUserBorrowingsAsync(userId);
+            return Ok(borrowings);
+        }
+
+        [HttpGet]
+        [Authorize(Roles = "Librarian")]
+        public async Task<ActionResult<IEnumerable<BorrowingDto>>> GetAllBorrowings()
+        {
+            var borrowings = await _borrowingService.GetAllBorrowingsAsync();
+            return Ok(borrowings);
+        }
+    }
+}

LibraryManagement.Backend/Features/Borrowing/BorrowingModels.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace LibraryManagement.Backend.Features.Borrowings
+{
+    public class BorrowingDto
+    {
+        public int Id { get; set; }
+        public int UserId { get; set; }
+        public string UserEmail { get; set; } = string.Empty;
+        public int BookId { get; set; }
+        public string BookTitle { get; set; } = string.Empty;
+        public DateTime BorrowDate { get; set; }
+        public DateTime DueDate { get; set; }
+        public DateTime? ReturnDate { get; set; }
+        public string Status { get; set; } = string.Empty;
+        public decimal FineAmount { get; set; }
+        public bool IsFinePaid { get; set; }
+    }
+
+    public class BorrowRequest
+    {
+        public int BookId { get; set; }
+    }
+}

LibraryManagement.Backend/Features/Borrowing/BorrowingService.cs

@@ -0,0 +1,166 @@
+using Database.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace LibraryManagement.Backend.Features.Borrowings
+{
+    public interface IBorrowingService
+    {
+        Task<BorrowingDto> BorrowBookAsync(int userId, int bookId);
+        Task<BorrowingDto> ReturnBookAsync(int borrowingId);
+        Task<IEnumerable<BorrowingDto>> GetUserBorrowingsAsync(int userId);
+        Task<IEnumerable<BorrowingDto>> GetAllBorrowingsAsync();
+    }
+
+    public class BorrowingService : IBorrowingService
+    {
+        private readonly LibraryManagementContext _context;
+        private const decimal FinePerDay = 500;
+
+        public BorrowingService(LibraryManagementContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<BorrowingDto> BorrowBookAsync(int userId, int bookId)
+        {
+            // 1. Check for Active Membership
+            var subscription = await _context.UserSubscriptions
+                .Include(s => s.Membership)
+                .Where(s => s.UserId == userId && s.IsActive && s.ExpiryDate > DateTime.UtcNow)
+                .FirstOrDefaultAsync();
+
+            if (subscription == null)
+            {
+                throw new Exception("Active membership required to borrow books.");
+            }
+
+            // 2. Check for Overdue Books or Unpaid Fines
+            var hasBlockers = await _context.Borrowings
+                .AnyAsync(b => b.UserId == userId && 
+                    ((b.Status == "Borrowed" && b.DueDate < DateTime.UtcNow) || (b.FineAmount > 0 && !b.IsFinePaid)));
+
+            if (hasBlockers)
+            {
+                throw new Exception("Borrowing blocked: You have overdue books or unpaid fines.");
+            }
+
+            // 3. Check MaxBooks limit
+            var activeBorrowCount = await _context.Borrowings
+                .CountAsync(b => b.UserId == userId && b.Status == "Borrowed");
+
+            if (activeBorrowCount >= subscription.Membership.MaxBooks)
+            {
+                throw new Exception($"Borrowing limit reached: You can only borrow {subscription.Membership.MaxBooks} books at a time.");
+            }
+
+            // 4. Check Book Availability
+            var book = await _context.Books.FindAsync(bookId);
+            if (book == null || !book.IsActive || book.AvailableCopies <= 0)
+            {
+                throw new Exception("Book is currently unavailable.");
+            }
+
+            // 5. Create Borrowing Record
+            var borrowing = new Borrowing
+            {
+                UserId = userId,
+                BookId = bookId,
+                BorrowDate = DateTime.UtcNow,
+                DueDate = DateTime.UtcNow.AddDays(subscription.Membership.BorrowingDays),
+                Status = "Borrowed",
+                FineAmount = 0,
+                IsFinePaid = false
+            };
+
+            // 6. Update Book Stock
+            book.AvailableCopies--;
+            if (book.AvailableCopies == 0)
+            {
+                book.Status = "Out Of Stock";
+            }
+
+            _context.Borrowings.Add(borrowing);
+            await _context.SaveChangesAsync();
+
+            // Load relations for mapping
+            await _context.Entry(borrowing).Reference(b => b.Book).LoadAsync();
+            await _context.Entry(borrowing).Reference(b => b.User).LoadAsync();
+
+            return MapToDto(borrowing);
+        }
+
+        public async Task<BorrowingDto> ReturnBookAsync(int borrowingId)
+        {
+            var borrowing = await _context.Borrowings
+                .Include(b => b.Book)
+                .Include(b => b.User)
+                .FirstOrDefaultAsync(b => b.Id == borrowingId);
+
+            if (borrowing == null) throw new Exception("Borrowing record not found.");
+            if (borrowing.Status == "Returned") throw new Exception("Book has already been returned.");
+
+            var now = DateTime.UtcNow;
+            borrowing.ReturnDate = now;
+            borrowing.Status = "Returned";
+
+            // Calculate Fine
+            if (now > borrowing.DueDate)
+            {
+                var overdueDays = (now.Date - borrowing.DueDate.Date).Days;
+                if (overdueDays > 0)
+                {
+                    borrowing.FineAmount = overdueDays * FinePerDay;
+                }
+            }
+
+            // Update Book Stock
+            var book = borrowing.Book;
+            book.AvailableCopies++;
+            book.Status = "Available";
+
+            await _context.SaveChangesAsync();
+            return MapToDto(borrowing);
+        }
+
+        public async Task<IEnumerable<BorrowingDto>> GetUserBorrowingsAsync(int userId)
+        {
+            var borrowings = await _context.Borrowings
+                .Include(b => b.Book)
+                .Include(b => b.User)
+                .Where(b => b.UserId == userId)
+                .OrderByDescending(b => b.BorrowDate)
+                .ToListAsync();
+
+            return borrowings.Select(MapToDto);
+        }
+
+        public async Task<IEnumerable<BorrowingDto>> GetAllBorrowingsAsync()
+        {
+            var borrowings = await _context.Borrowings
+                .Include(b => b.Book)
+                .Include(b => b.User)
+                .OrderByDescending(b => b.BorrowDate)
+                .ToListAsync();
+
+            return borrowings.Select(MapToDto);
+        }
+
+        private static BorrowingDto MapToDto(Borrowing b)
+        {
+            return new BorrowingDto
+            {
+                Id = b.Id,
+                UserId = b.UserId,
+                UserEmail = b.User?.Email ?? "Unknown",
+                BookId = b.BookId,
+                BookTitle = b.Book?.Title ?? "Unknown",
+                BorrowDate = b.BorrowDate,
+                DueDate = b.DueDate,
+                ReturnDate = b.ReturnDate,
+                Status = b.Status,
+                FineAmount = b.FineAmount,
+                IsFinePaid = b.IsFinePaid
+            };
+        }
+    }
+}

LibraryManagement.Backend/Features/Categories/CategoryController.cs

@@ -0,0 +1,49 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace LibraryManagement.Backend.Features.Categories
+{
+    [ApiController]
+    [Route("api/categories")]
+    public class CategoryController : ControllerBase
+    {
+        private readonly ICategoryService _categoryService;
+
+        public CategoryController(ICategoryService categoryService)
+        {
+            _categoryService = categoryService;
+        }
+
+        [HttpGet]
+        [Authorize] // Accessible by both Librarian and Member
+        public async Task<ActionResult<IEnumerable<CategoryDto>>> GetCategories()
+        {
+            var categories = await _categoryService.GetAllCategoriesAsync();
+            return Ok(categories);
+        }
+
+        [HttpPost]
+        [Authorize(Roles = "Librarian")]
+        public async Task<ActionResult<CategoryDto>> CreateCategory([FromBody] CategoryCreateRequest request)
+        {
+            try
+            {
+                var category = await _categoryService.CreateCategoryAsync(request);
+                return CreatedAtAction(nameof(GetCategories), category);
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(new { message = ex.Message });
+            }
+        }
+
+        [HttpDelete("{id}")]
+        [Authorize(Roles = "Librarian")]
+        public async Task<IActionResult> DeleteCategory(int id)
+        {
+            var success = await _categoryService.DeleteCategoryAsync(id);
+            if (!success) return NotFound();
+            return NoContent();
+        }
+    }
+}

LibraryManagement.Backend/Features/Categories/CategoryService.cs

@@ -0,0 +1,69 @@
+using Database.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace LibraryManagement.Backend.Features.Categories
+{
+    public interface ICategoryService
+    {
+        Task<IEnumerable<CategoryDto>> GetAllCategoriesAsync();
+        Task<CategoryDto> CreateCategoryAsync(CategoryCreateRequest request);
+        Task<bool> DeleteCategoryAsync(int id);
+    }
+
+    public class CategoryService : ICategoryService
+    {
+        private readonly LibraryManagementContext _context;
+
+        public CategoryService(LibraryManagementContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<IEnumerable<CategoryDto>> GetAllCategoriesAsync()
+        {
+            return await _context.Categories
+                .Select(c => new CategoryDto { Id = c.Id, Name = c.Name })
+                .ToListAsync();
+        }
+
+        public async Task<CategoryDto> CreateCategoryAsync(CategoryCreateRequest request)
+        {
+            if (await _context.Categories.AnyAsync(c => c.Name == request.Name))
+            {
+                throw new Exception("Category with this name already exists.");
+            }
+
+            var category = new Category
+            {
+                Name = request.Name
+            };
+
+            _context.Categories.Add(category);
+            await _context.SaveChangesAsync();
+
+            return new CategoryDto { Id = category.Id, Name = category.Name };
+        }
+
+        public async Task<bool> DeleteCategoryAsync(int id)
+        {
+            var category = await _context.Categories.FindAsync(id);
+            if (category == null) return false;
+
+            // Note: EF automatically handles removing associations in many-to-many join tables
+            _context.Categories.Remove(category);
+            await _context.SaveChangesAsync();
+            return true;
+        }
+    }
+
+    public class CategoryDto
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = string.Empty;
+    }
+
+    public class CategoryCreateRequest
+    {
+        public string Name { get; set; } = string.Empty;
+    }
+}

LibraryManagement.Backend/Features/Subscriptions/SubscriptionController.cs

@@ -0,0 +1,59 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.Security.Claims;
+
+namespace LibraryManagement.Backend.Features.Subscriptions
+{
+    [ApiController]
+    [Route("api")]
+    public class SubscriptionController : ControllerBase
+    {
+        private readonly ISubscriptionService _subscriptionService;
+
+        public SubscriptionController(ISubscriptionService subscriptionService)
+        {
+            _subscriptionService = subscriptionService;
+        }
+
+        [HttpGet("memberships")]
+        [AllowAnonymous]
+        public async Task<ActionResult<IEnumerable<MembershipDto>>> GetMemberships()
+        {
+            return Ok(await _subscriptionService.GetMembershipsAsync());
+        }
+
+        [HttpGet("subscriptions/me")]
+        [Authorize]
+        public async Task<ActionResult<SubscriptionDto>> GetMySubscription()
+        {
+            var userIdStr = User.FindFirstValue(ClaimTypes.NameIdentifier);
+            if (string.IsNullOrEmpty(userIdStr)) return Unauthorized();
+
+            var userId = int.Parse(userIdStr);
+            var subscription = await _subscriptionService.GetUserSubscriptionAsync(userId);
+            
+            if (subscription == null) return NotFound(new { message = "No active subscription found." });
+            
+            return Ok(subscription);
+        }
+
+        [HttpPost("subscriptions/subscribe")]
+        [Authorize]
+        public async Task<ActionResult<SubscriptionDto>> Subscribe([FromBody] SubscribeRequest request)
+        {
+            try
+            {
+                var userIdStr = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                if (string.IsNullOrEmpty(userIdStr)) return Unauthorized();
+
+                var userId = int.Parse(userIdStr);
+                var subscription = await _subscriptionService.SubscribeUserAsync(userId, request.MembershipId);
+                return Ok(subscription);
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(new { message = ex.Message });
+            }
+        }
+    }
+}

LibraryManagement.Backend/Features/Subscriptions/SubscriptionModels.cs

@@ -0,0 +1,32 @@
+using System;
+
+namespace LibraryManagement.Backend.Features.Subscriptions
+{
+    public class MembershipDto
+    {
+        public int Id { get; set; }
+        public string Type { get; set; } = string.Empty;
+        public int MaxBooks { get; set; }
+        public int BorrowingDays { get; set; }
+        public decimal Price { get; set; }
+        public string Currency { get; set; } = "MMK";
+        public int DurationMonths { get; set; }
+    }
+
+    public class SubscriptionDto
+    {
+        public int Id { get; set; }
+        public int UserId { get; set; }
+        public int MembershipId { get; set; }
+        public string MembershipType { get; set; } = string.Empty;
+        public DateTime StartDate { get; set; }
+        public DateTime ExpiryDate { get; set; }
+        public bool IsActive { get; set; }
+        public bool IsExpired => DateTime.UtcNow > ExpiryDate;
+    }
+
+    public class SubscribeRequest
+    {
+        public int MembershipId { get; set; }
+    }
+}

LibraryManagement.Backend/Features/Subscriptions/SubscriptionService.cs

@@ -0,0 +1,96 @@
+using Database.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace LibraryManagement.Backend.Features.Subscriptions
+{
+    public interface ISubscriptionService
+    {
+        Task<IEnumerable<MembershipDto>> GetMembershipsAsync();
+        Task<SubscriptionDto?> GetUserSubscriptionAsync(int userId);
+        Task<SubscriptionDto> SubscribeUserAsync(int userId, int membershipId);
+    }
+
+    public class SubscriptionService : ISubscriptionService
+    {
+        private readonly LibraryManagementContext _context;
+
+        public SubscriptionService(LibraryManagementContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<IEnumerable<MembershipDto>> GetMembershipsAsync()
+        {
+            return await _context.Memberships
+                .Select(m => new MembershipDto
+                {
+                    Id = m.Id,
+                    Type = m.Type,
+                    MaxBooks = m.MaxBooks,
+                    BorrowingDays = m.BorrowingDays,
+                    Price = m.Price,
+                    DurationMonths = m.DurationMonths
+                }).ToListAsync();
+        }
+
+        public async Task<SubscriptionDto?> GetUserSubscriptionAsync(int userId)
+        {
+            var subscription = await _context.UserSubscriptions
+                .Include(s => s.Membership)
+                .Where(s => s.UserId == userId && s.IsActive)
+                .OrderByDescending(s => s.StartDate)
+                .FirstOrDefaultAsync();
+
+            if (subscription == null) return null;
+
+            return MapToDto(subscription);
+        }
+
+        public async Task<SubscriptionDto> SubscribeUserAsync(int userId, int membershipId)
+        {
+            var membership = await _context.Memberships.FindAsync(membershipId);
+            if (membership == null) throw new Exception("Membership plan not found.");
+
+            // Deactivate any existing active subscriptions for this user
+            var activeSubscriptions = await _context.UserSubscriptions
+                .Where(s => s.UserId == userId && s.IsActive)
+                .ToListAsync();
+
+            foreach (var s in activeSubscriptions)
+            {
+                s.IsActive = false;
+            }
+
+            var subscription = new UserSubscription
+            {
+                UserId = userId,
+                MembershipId = membershipId,
+                StartDate = DateTime.UtcNow,
+                ExpiryDate = DateTime.UtcNow.AddMonths(membership.DurationMonths),
+                IsActive = true
+            };
+
+            _context.UserSubscriptions.Add(subscription);
+            await _context.SaveChangesAsync();
+
+            // Explicitly load the membership data for the DTO mapping
+            await _context.Entry(subscription).Reference(s => s.Membership).LoadAsync();
+
+            return MapToDto(subscription);
+        }
+
+        private static SubscriptionDto MapToDto(UserSubscription subscription)
+        {
+            return new SubscriptionDto
+            {
+                Id = subscription.Id,
+                UserId = subscription.UserId,
+                MembershipId = subscription.MembershipId,
+                MembershipType = subscription.Membership.Type,
+                StartDate = subscription.StartDate,
+                ExpiryDate = subscription.ExpiryDate,
+                IsActive = subscription.IsActive
+            };
+        }
+    }
+}

LibraryManagement.Backend/Features/Users/UserController.cs

@@ -1,3 +1,4 @@
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
 namespace LibraryManagement.Backend.Features.Users
@@ -13,11 +14,64 @@ namespace LibraryManagement.Backend.Features.Users
             _userService = userService;
         }
 
+        [HttpGet]
+        [Authorize(Roles = "Librarian")]
+        public async Task<ActionResult<IEnumerable<UserDto>>> GetUsers()
+        {
+            var users = await _userService.GetAllUsersAsync();
+            return Ok(users);
+        }
+
+        [HttpGet("{id}")]
+        [Authorize(Roles = "Librarian")]
+        public async Task<ActionResult<UserDto>> GetUser(int id)
+        {
+            var user = await _userService.GetUserByIdAsync(id);
+            if (user == null) return NotFound();
+            return Ok(user);
+        }
+
         [HttpPost]
-        public async Task<ActionResult<UserCreateResponse>> CreateUser([FromBody] UserCreateRequest request)
+        [AllowAnonymous]
+        public async Task<ActionResult<UserDto>> CreateUser([FromBody] UserCreateRequest request)
+        {
+            try
+            {
+                var response = await _userService.CreateUserAsync(request);
+                return CreatedAtAction(nameof(GetUser), new { id = response.Id }, response);
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(new { message = ex.Message });
+            }
+        }
+
+        [HttpPut("{id}")]
+        [Authorize(Roles = "Librarian")]
+        public async Task<ActionResult<UserDto>> UpdateUser(int id, [FromBody] UserUpdateRequest request)
+        {
+            var updatedUser = await _userService.UpdateUserAsync(id, request);
+            if (updatedUser == null) return NotFound();
+            return Ok(updatedUser);
+        }
+
+        [HttpPatch("{id}/role")]
+        [Authorize(Roles = "Librarian")]
+        public async Task<IActionResult> UpdateUserRole(int id, [FromBody] UserRoleUpdateRequest request)
         {
-            var response = await _userService.CreateUser(request);
-            return Ok(response);
+            var success = await _userService.UpdateUserRoleAsync(id, request.Role);
+            if (!success) return NotFound();
+            return NoContent();
+        }
+
+        [HttpDelete("{id}")]
+        [Authorize(Roles = "Librarian")]
+        public async Task<IActionResult> DeleteUser(int id)
+        {
+            var success = await _userService.DeleteUserAsync(id);
+            if (!success) return NotFound();
+            return NoContent();
         }
     }
 }
+

LibraryManagement.Backend/Features/Users/UserService.cs

@@ -1,30 +1,176 @@
-using Database.Models;
+using Database.Models;
+using Microsoft.EntityFrameworkCore;
+using LibraryManagement.Backend.Features.Subscriptions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 
 namespace LibraryManagement.Backend.Features.Users
 {
     public interface IUserService
     {
-        public Task<UserCreateResponse> CreateUser(UserCreateRequest request);
+        Task<IEnumerable<UserDto>> GetAllUsersAsync();
+        Task<UserDto?> GetUserByIdAsync(int id);
+        Task<UserDto> CreateUserAsync(UserCreateRequest request);
+        Task<UserDto?> UpdateUserAsync(int id, UserUpdateRequest request);
+        Task<bool> UpdateUserRoleAsync(int id, string role);
+        Task<bool> DeleteUserAsync(int id);
     }
 
     public class UserService : IUserService
     {
         private readonly LibraryManagementContext _context;
+        private readonly ISubscriptionService _subscriptionService;
 
-        public UserService(LibraryManagementContext context) { 
+        public UserService(LibraryManagementContext context, ISubscriptionService subscriptionService)
+        {
             _context = context;
+            _subscriptionService = subscriptionService;
+        }
+
+        public async Task<IEnumerable<UserDto>> GetAllUsersAsync()
+        {
+            var users = await _context.Users.ToListAsync();
+            return users.Select(MapToDto);
+        }
+
+        public async Task<UserDto?> GetUserByIdAsync(int id)
+        {
+            var user = await _context.Users.FindAsync(id);
+            return user == null ? null : MapToDto(user);
+        }
+
+        public async Task<UserDto> CreateUserAsync(UserCreateRequest request)
+        {
+            if (await _context.Users.AnyAsync(u => u.Email == request.Email))
+            {
+                throw new Exception("Email already registered.");
+            }
+
+            var user = new User
+            {
+                FullName = request.FullName,
+                Email = request.Email,
+                PasswordHash = BCrypt.Net.BCrypt.HashPassword(request.Password),
+                PhoneNumber = request.PhoneNumber,
+                Address = request.Address,
+                StudentId = request.StudentId,
+                Role = "Member", // Default role
+                IsActive = true,
+                CreatedAt = DateTime.UtcNow
+            };
+
+            _context.Users.Add(user);
+            await _context.SaveChangesAsync();
+
+            if (!string.IsNullOrEmpty(user.StudentId))
+            {
+                await _subscriptionService.SubscribeUserAsync(user.Id, 3); // 3 is "Basic Yearly"
+            }
+
+            return MapToDto(user);
+        }
+
+        public async Task<UserDto?> UpdateUserAsync(int id, UserUpdateRequest request)
+        {
+            var user = await _context.Users.FindAsync(id);
+            if (user == null) return null;
+
+            bool isNewlyStudent = string.IsNullOrEmpty(user.StudentId) && !string.IsNullOrEmpty(request.StudentId);
+
+            user.FullName = request.FullName;
+            user.PhoneNumber = request.PhoneNumber;
+            user.Address = request.Address;
+            user.StudentId = request.StudentId;
+            user.UpdatedAt = DateTime.UtcNow;
+
+            await _context.SaveChangesAsync();
+
+            if (isNewlyStudent)
+            {
+                await _subscriptionService.SubscribeUserAsync(user.Id, 3);
+            }
+
+            return MapToDto(user);
+        }
+
+        public async Task<bool> UpdateUserRoleAsync(int id, string role)
+        {
+            var user = await _context.Users.FindAsync(id);
+            if (user == null) return false;
+
+            user.Role = role;
+            user.UpdatedAt = DateTime.UtcNow;
+
+            await _context.SaveChangesAsync();
+            return true;
+        }
+
+        public async Task<bool> DeleteUserAsync(int id)
+        {
+            var user = await _context.Users.FindAsync(id);
+            if (user == null) return false;
+
+            // Soft delete
+            user.IsActive = false;
+            user.UpdatedAt = DateTime.UtcNow;
+
+            await _context.SaveChangesAsync();
+            return true;
         }
 
-        public Task<UserCreateResponse> CreateUser(UserCreateRequest request)
+        private static UserDto MapToDto(User user)
         {
-            throw new NotImplementedException();
+            return new UserDto
+            {
+                Id = user.Id,
+                FullName = user.FullName,
+                Email = user.Email,
+                PhoneNumber = user.PhoneNumber,
+                Role = user.Role,
+                IsActive = user.IsActive,
+                StudentId = user.StudentId,
+                Address = user.Address,
+                CreatedAt = user.CreatedAt
+            };
         }
     }
 
-    public class UserCreateRequest {
-        
+    public class UserDto
+    {
+        public int Id { get; set; }
+        public string Name => FullName;
+        public string FullName { get; set; } = string.Empty;
+        public string Email { get; set; } = string.Empty;
+        public string? PhoneNumber { get; set; }
+        public string Role { get; set; } = string.Empty;
+        public bool IsActive { get; set; }
+        public string? StudentId { get; set; }
+        public string? Address { get; set; }
+        public DateTime CreatedAt { get; set; }
+    }
+
+    public class UserCreateRequest
+    {
+        public string FullName { get; set; } = string.Empty;
+        public string Email { get; set; } = string.Empty;
+        public string Password { get; set; } = string.Empty;
+        public string? PhoneNumber { get; set; }
+        public string? StudentId { get; set; }
+        public string? Address { get; set; }
     }
 
-    public class UserCreateResponse { 
+    public class UserUpdateRequest
+    {
+        public string FullName { get; set; } = string.Empty;
+        public string? PhoneNumber { get; set; }
+        public string? StudentId { get; set; }
+        public string? Address { get; set; }
+    }
+
+    public class UserRoleUpdateRequest
+    {
+        public string Role { get; set; } = string.Empty;
     }
 }

LibraryManagement.Backend/Program.cs

@@ -2,25 +2,31 @@ using System.Text;
 using Database.Models;
 using LibraryManagement.Backend.Features.Auth;
 using LibraryManagement.Backend.Features.Users;
+using LibraryManagement.Backend.Features.Books;
 using Microsoft.AspNetCore.Authentication.JwtBearer;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.IdentityModel.Tokens;
 using Microsoft.OpenApi.Models;
+using LibraryManagement.Backend.Features.Subscriptions;
+using LibraryManagement.Backend.Features.Categories;
+using LibraryManagement.Backend.Features.Borrowings;
 
 var builder = WebApplication.CreateBuilder(args);
 
 builder.Services.AddControllers();
+builder.Services.AddAuthorization();
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen(c =>
 {
     c.SwaggerDoc("v1", new OpenApiInfo { Title = "Library Management API", Version = "v1" });
     c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
     {
-        Description = "JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
+        Description = "JWT Authorization header using the Bearer scheme.",
         Name = "Authorization",
         In = ParameterLocation.Header,
-        Type = SecuritySchemeType.ApiKey,
-        Scheme = "Bearer"
+        Type = SecuritySchemeType.Http,
+        Scheme = "bearer",
+        BearerFormat = "JWT"
     });
     c.AddSecurityRequirement(new OpenApiSecurityRequirement
     {
@@ -44,6 +50,10 @@ builder.Services.AddDbContext<LibraryManagementContext>(options =>
 // Register Services
 builder.Services.AddScoped<IAuthService, AuthService>();
 builder.Services.AddScoped<IUserService, UserService>();
+builder.Services.AddScoped<IBookService, BookService>();
+builder.Services.AddScoped<ISubscriptionService, SubscriptionService>();
+builder.Services.AddScoped<ICategoryService, CategoryService>();
+builder.Services.AddScoped<IBorrowingService, BorrowingService>();
 
 // Configure JWT Authentication
 var key = Encoding.ASCII.GetBytes(builder.Configuration["Jwt:Secret"] ?? "YourSuperSecretKeyForLibraryManagementSystem_AtLeast32CharsLong");