feat: restructure backend project, add configuration files, implement authentication, user and book management, and enhance borrowing and subscription features

Backend/Backend.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BCrypt.Net-Next" Version="4.1.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.13" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.6.2" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="8.17.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Database\Database.csproj" />
+  </ItemGroup>
+
+</Project>

Backend/Backend.http

@@ -0,0 +1,6 @@
+@Backend_HostAddress = http://localhost:5199
+
+GET {{Backend_HostAddress}}/weatherforecast/
+Accept: application/json
+
+###

Backend/Features/Auth/AuthController.cs

@@ -0,0 +1,59 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.Security.Claims;
+
+namespace Backend.Features.Auth
+{
+    [ApiController]
+    [Route("api/auth")]
+    public class AuthController : ControllerBase
+    {
+        private readonly IAuthService _authService;
+
+        public AuthController(IAuthService authService)
+        {
+            _authService = authService;
+        }
+
+        [HttpPost("register")]
+        public async Task<ActionResult<AuthResponse>> Register([FromBody] RegisterRequest request)
+        {
+            try
+            {
+                var response = await _authService.Register(request);
+                return Ok(response);
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(new { message = ex.Message });
+            }
+        }
+
+        [HttpPost("login")]
+        public async Task<ActionResult<AuthResponse>> Login([FromBody] LoginRequest request)
+        {
+            try
+            {
+                var response = await _authService.Login(request);
+                return Ok(response);
+            }
+            catch (Exception ex)
+            {
+                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
+            });
+        }
+    }
+}

Backend/Features/Auth/AuthModels.cs

@@ -0,0 +1,26 @@
+namespace Backend.Features.Auth
+{
+    public class RegisterRequest
+    {
+        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? Address { get; set; }
+        public string? StudentId { get; set; }
+    }
+
+    public class LoginRequest
+    {
+        public string Email { get; set; } = string.Empty;
+        public string Password { get; set; } = string.Empty;
+    }
+
+    public class AuthResponse
+    {
+        public string Token { get; set; } = string.Empty;
+        public string FullName { get; set; } = string.Empty;
+        public string Role { get; set; } = string.Empty;
+        public DateTime Expiry { get; set; }
+    }
+}

Backend/Features/Auth/AuthService.cs

@@ -0,0 +1,110 @@
+using Database.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.IdentityModel.Tokens;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+
+using Backend.Features.Subscriptions;
+
+namespace Backend.Features.Auth
+{
+    public interface IAuthService
+    {
+        Task<AuthResponse> Register(RegisterRequest request);
+        Task<AuthResponse> Login(LoginRequest request);
+    }
+
+    public class AuthService : IAuthService
+    {
+        private readonly LibraryManagementContext _context;
+        private readonly IConfiguration _configuration;
+        private readonly ISubscriptionService _subscriptionService;
+
+        public AuthService(LibraryManagementContext context, IConfiguration configuration, ISubscriptionService subscriptionService)
+        {
+            _context = context;
+            _configuration = configuration;
+            _subscriptionService = subscriptionService;
+        }
+
+        public async Task<AuthResponse> Register(RegisterRequest request)
+        {
+            if (await _context.Users.AnyAsync(u => u.Email == request.Email))
+            {
+                throw new Exception("User already exists with this email.");
+            }
+
+            var user = new User
+            {
+                FullName = request.FullName,
+                Email = request.Email,
+                PhoneNumber = request.PhoneNumber,
+                Address = request.Address,
+                StudentId = request.StudentId,
+                PasswordHash = BCrypt.Net.BCrypt.HashPassword(request.Password),
+                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 await AuthenticateUser(user);
+        }
+
+        public async Task<AuthResponse> Login(LoginRequest request)
+        {
+            var user = await _context.Users.FirstOrDefaultAsync(u => u.Email == request.Email);
+
+            if (user == null || !BCrypt.Net.BCrypt.Verify(request.Password, user.PasswordHash))
+            {
+                throw new Exception("Invalid email or password.");
+            }
+
+            if (!user.IsActive)
+            {
+                throw new Exception("User account is deactivated.");
+            }
+
+            return await AuthenticateUser(user);
+        }
+
+        private async Task<AuthResponse> AuthenticateUser(User user)
+        {
+            var tokenHandler = new JwtSecurityTokenHandler();
+            var key = Encoding.ASCII.GetBytes(_configuration["Jwt:Secret"] ?? "YourSuperSecretKeyForLibraryManagementSystem_AtLeast32CharsLong");
+            
+            var tokenDescriptor = new SecurityTokenDescriptor
+            {
+                Subject = new ClaimsIdentity(new[]
+                {
+                    new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
+                    new Claim(ClaimTypes.Email, user.Email),
+                    new Claim(ClaimTypes.Name, user.FullName),
+                    new Claim(ClaimTypes.Role, user.Role)
+                }),
+                Expires = DateTime.UtcNow.AddDays(7),
+                SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature),
+                Issuer = _configuration["Jwt:Issuer"],
+                Audience = _configuration["Jwt:Audience"]
+            };
+
+            var token = tokenHandler.CreateToken(tokenDescriptor);
+            
+            return new AuthResponse
+            {
+                Token = tokenHandler.WriteToken(token),
+                FullName = user.FullName,
+                Role = user.Role,
+                Expiry = tokenDescriptor.Expires.Value
+            };
+        }
+    }
+}

Backend/Features/Books/BookController.cs

@@ -0,0 +1,67 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace 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();
+        }
+    }
+}

Backend/Features/Books/BookService.cs

@@ -0,0 +1,150 @@
+using Database.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace 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,
+                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;
+            
+            // 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,
+                IsActive = book.IsActive,
+                Description = book.Description,
+                TotalCopies = book.TotalCopies,
+                AvailableCopies = book.AvailableCopies,
+                CreatedAt = book.CreatedAt,
+                UpdatedAt = book.UpdatedAt
+            };
+        }
+    }
+
+    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 bool IsActive { get; set; }
+        public string? Description { get; set; }
+        public int TotalCopies { get; set; }
+        public int AvailableCopies { get; set; }
+        public DateTime CreatedAt { get; set; }
+        public DateTime? UpdatedAt { 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 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 int TotalCopies { get; set; }
+    }
+}

Backend/Features/Borrowing/BorrowingController.cs

@@ -0,0 +1,72 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.Security.Claims;
+
+namespace 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);
+        }
+    }
+}

Backend/Features/Borrowing/BorrowingModels.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace 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; }
+    }
+}

Backend/Features/Borrowing/BorrowingService.cs

@@ -0,0 +1,166 @@
+using Database.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace 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
+            };
+        }
+    }
+}

Backend/Features/Categories/CategoryController.cs

@@ -0,0 +1,49 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace 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();
+        }
+    }
+}

Backend/Features/Categories/CategoryService.cs

@@ -0,0 +1,69 @@
+using Database.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace 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;
+    }
+}

Backend/Features/Subscriptions/SubscriptionController.cs

@@ -0,0 +1,84 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using System.Security.Claims;
+
+namespace 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 });
+            }
+        }
+
+        [HttpGet("subscriptions/user/{userId}")]
+        [Authorize(Roles = "Admin")]
+        public async Task<ActionResult<SubscriptionDto>> GetUserSubscription(int userId)
+        {
+            var subscription = await _subscriptionService.GetUserSubscriptionAsync(userId);
+            if (subscription == null) return NotFound(new { message = "No active subscription found." });
+            
+            return Ok(subscription);
+        }
+
+        [HttpPost("subscriptions/admin-subscribe")]
+        [Authorize(Roles = "Admin")]
+        public async Task<ActionResult<SubscriptionDto>> AdminSubscribe([FromBody] AdminSubscribeRequest request)
+        {
+            try
+            {
+                var subscription = await _subscriptionService.SubscribeUserAsync(request.UserId, request.MembershipId);
+                return Ok(subscription);
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(new { message = ex.Message });
+            }
+        }
+    }
+}

Backend/Features/Subscriptions/SubscriptionModels.cs

@@ -0,0 +1,38 @@
+using System;
+
+namespace 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; }
+    }
+
+    public class AdminSubscribeRequest
+    {
+        public int UserId { get; set; }
+        public int MembershipId { get; set; }
+    }
+}

Backend/Features/Subscriptions/SubscriptionService.cs

@@ -0,0 +1,96 @@
+using Database.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace 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
+            };
+        }
+    }
+}

Backend/Features/Users/UserController.cs

@@ -0,0 +1,77 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Backend.Features.Users
+{
+    [ApiController]
+    [Route("api/users")]
+    public class UserController : ControllerBase
+    {
+        private readonly IUserService _userService;
+
+        public UserController(IUserService userService)
+        {
+            _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]
+        [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 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();
+        }
+    }
+}
+

Backend/Features/Users/UserService.cs

@@ -0,0 +1,182 @@
+using Database.Models;
+using Microsoft.EntityFrameworkCore;
+using Backend.Features.Subscriptions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Backend.Features.Users
+{
+    public interface IUserService
+    {
+        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, 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;
+        }
+
+        private static UserDto MapToDto(User user)
+        {
+            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,
+                UpdatedAt = user.UpdatedAt,
+                BanStatus = user.BanStatus,
+                SuspensionEndDate = user.SuspensionEndDate
+            };
+        }
+    }
+
+    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 DateTime? UpdatedAt { get; set; }
+        public bool? BanStatus { get; set; }
+        public DateTime? SuspensionEndDate { 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 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;
+    }
+}

Backend/Program.cs

@@ -0,0 +1,91 @@
+using System.Text;
+using Database.Models;
+using Backend.Features.Auth;
+using Backend.Features.Users;
+using Backend.Features.Books;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.IdentityModel.Tokens;
+using Microsoft.OpenApi.Models;
+using Backend.Features.Subscriptions;
+using Backend.Features.Categories;
+using 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.",
+        Name = "Authorization",
+        In = ParameterLocation.Header,
+        Type = SecuritySchemeType.Http,
+        Scheme = "bearer",
+        BearerFormat = "JWT"
+    });
+    c.AddSecurityRequirement(new OpenApiSecurityRequirement
+    {
+        {
+            new OpenApiSecurityScheme
+            {
+                Reference = new OpenApiReference
+                {
+                    Type = ReferenceType.SecurityScheme,
+                    Id = "Bearer"
+                }
+            },
+            new string[] {}
+        }
+    });
+});
+
+builder.Services.AddDbContext<LibraryManagementContext>(options =>
+    options.UseSqlServer(builder.Configuration.GetConnectionString("MssqlConnection")));
+
+// 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");
+builder.Services.AddAuthentication(x =>
+{
+    x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+    x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+})
+.AddJwtBearer(x =>
+{
+    x.RequireHttpsMetadata = false;
+    x.SaveToken = true;
+    x.TokenValidationParameters = new TokenValidationParameters
+    {
+        ValidateIssuerSigningKey = true,
+        IssuerSigningKey = new SymmetricSecurityKey(key),
+        ValidateIssuer = true,
+        ValidateAudience = true,
+        ValidIssuer = builder.Configuration["Jwt:Issuer"],
+        ValidAudience = builder.Configuration["Jwt:Audience"],
+        ClockSkew = TimeSpan.Zero
+    };
+});
+
+var app = builder.Build();
+
+app.UseSwagger();
+app.UseSwaggerUI();
+app.UseAuthentication();
+app.UseAuthorization();
+
+app.MapControllers();
+
+app.Run();
+

Backend/Properties/launchSettings.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:13110",
+      "sslPort": 44374
+    }
+  },
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "http://localhost:5001",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:7028;http://localhost:5199",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

Backend/WeatherForecast.cs

@@ -0,0 +1,13 @@
+namespace Backend
+{
+    public class WeatherForecast
+    {
+        public DateOnly Date { get; set; }
+
+        public int TemperatureC { get; set; }
+
+        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
+
+        public string? Summary { get; set; }
+    }
+}

Backend/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

Backend/appsettings.json

@@ -0,0 +1,18 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*",
+  "ConnectionStrings": {
+    //"MssqlConnection": "Server=DESKTOP-BP9A061;Database=LibraryManagement;User Id=sa;Password=sasa@123;TrustServerCertificate=True;"
+    "MssqlConnection": "Server=.;Database=LibraryManagement;User Id=sa;Password=sasa@123;TrustServerCertificate=True;"
+  },
+  "Jwt": {
+    "Secret": "YourSuperSecretKeyForLibraryManagementSystem_AtLeast32CharsLong",
+    "Issuer": "LibraryManagementSystem",
+    "Audience": "LibraryManagementUsers"
+  }
+}

LibraryManagement.slnx

@@ -1,5 +1,5 @@
 <Solution>
   <Project Path="Database/Database.csproj" Id="1ec23dc7-355d-4456-a503-cfd0fb81cd5c" />
   <Project Path="Frontend/Frontend.csproj" Id="824d7fed-4fd3-41c5-8c5e-acd458ccbcdb" />
-  <Project Path="LibraryManagement.Backend/LibraryManagement.Backend.csproj" Id="82e311b1-ce76-4235-9d5f-0d06a942d038" />
+  <Project Path="Backend/Backend.csproj" Id="82e311b1-ce76-4235-9d5f-0d06a942d038" />
 </Solution>