Card

This tailwind example is contributed by John, on 16-Oct-2026. Component is made with Tailwind v3.4. It is responsive.

Tailwind v3.4 4

<div class="flex px-3 py-3">
    <div class="max-w-sm rounded overflow-hidden shadow-lg">
        <img class="w-full" src="https://tailwindcss.com/img/card-top.jpg" alt="Sunset in the mountains">
        <div class="px-6 py-4">
            <div class="font-bold text-xl mb-2">The Coldest Sunset</div>
            <p class="text-gray-700 text-base">
                Lorem ipsum dolor sit amet, consectetur adipisicing elit. Voluptatibus quia, nulla! Maiores et
                perferendis eaque, exercitationem praesentium nihil.
            </p>
        </div>
        <div class="px-6 py-4">
            <span class="inline-block bg-gray-200 rounded-full px-3 py-1 text-sm font-semibold text-gray-700 mr-2">#photography</span>
            <span class="inline-block bg-gray-200 rounded-full px-3 py-1 text-sm font-semibold text-gray-700 mr-2">#travel</span>
            <span class="inline-block bg-gray-200 rounded-full px-3 py-1 text-sm font-semibold text-gray-700">#winter</span>
        </div>
    </div>
</div>

<!-- public interface IAcademicYearService
{
    Task<List<AcademicYear>> GetAllAsync();
    Task<AcademicYear?> GetByIdAsync(Guid id);
    Task<AcademicYear?> GetActiveAsync();
    Task<AcademicYear> CreateAsync(AcademicYear academicYear, Guid? userId);
    Task UpdateAsync(Guid id, AcademicYear academicYear, Guid? userId);
    Task DeleteAsync(Guid id, Guid? userId);
}

public class AcademicYearService : IAcademicYearService
{
    private readonly IAcademicYearRepository _repository;
    private readonly AppDbContext _context;

public AcademicYearService(
        IAcademicYearRepository repository,
        AppDbContext context)
    {
        _repository = repository;
        _context = context;
    }

public async Task<List<AcademicYear>> GetAllAsync()
    {
        return await _repository.GetAllAsync();
    }

public async Task<AcademicYear?> GetByIdAsync(Guid id)
    {
        return await _repository.GetByIdAsync(id);
    }

public async Task<AcademicYear?> GetActiveAsync()
    {
        return await _repository.GetActiveAsync();
    }

public async Task<AcademicYear> CreateAsync(
        AcademicYear academicYear,
        Guid? userId)
    {
        var academicYears = await _repository.GetAllAsync();

if (!System.Text.RegularExpressions.Regex.IsMatch(
            academicYear.YearLabel, @"^\d{4}-\d{4}$"))
        {
            throw new ArgumentException(
                "Year label must be in YYYY-YYYY format.");
        }

var years = academicYear.YearLabel.Split('-');
        var startYear = int.Parse(years[0]);
        var endYear = int.Parse(years[1]);

if (endYear != startYear + 1)
        {
            throw new ArgumentException(
                "Academic year must contain consecutive years.");
        }

if (academicYears.Any(x =>
            x.YearLabel.Equals(
                academicYear.YearLabel,
                StringComparison.OrdinalIgnoreCase)))
        {
            throw new InvalidOperationException(
                "Academic year label already exists.");
        }

if (academicYear.StartDate >= academicYear.EndDate)
        {
            throw new ArgumentException(
                "Start date must be before end date.");
        }

if (academicYear.StartDate.Year != startYear ||
            academicYear.EndDate.Year != endYear)
        {
            throw new ArgumentException(
                "Dates must match the academic year label.");
        }

if (academicYear.AdmissionWindowOpenDate >
                academicYear.AdmissionWindowCloseDate ||
            academicYear.AdmissionWindowOpenDate <
                academicYear.StartDate ||
            academicYear.AdmissionWindowCloseDate >
                academicYear.EndDate)
        {
            throw new ArgumentException(
                "Admission window must be within the academic year dates.");
        }

if (academicYear.Status == AcademicYearStatus.Active &&
            academicYears.Any(x =>
                x.Status == AcademicYearStatus.Active))
        {
            throw new InvalidOperationException(
                "Only one academic year can be active.");
        }

academicYear.Id = Guid.NewGuid();
        academicYear.AcademicYearCode =
            $"AY{Guid.NewGuid().ToString("N")[..8].ToUpper()}";
        academicYear.CreatedBy = userId;
        academicYear.CreatedDate = DateTime.UtcNow;
        academicYear.IsDeleted = false;

await _repository.AddAsync(academicYear);
        await _repository.SaveChangesAsync();

return academicYear;
    }

public async Task UpdateAsync(
        Guid id,
        AcademicYear academicYear,
        Guid? userId)
    {
        var existing = await _repository.GetByIdAsync(id);

if (existing == null)
        {
            throw new KeyNotFoundException(
                "Academic year not found.");
        }

var academicYears = await _repository.GetAllAsync();

var years = academicYear.YearLabel.Split('-');
        var startYear = int.Parse(years[0]);
        var endYear = int.Parse(years[1]);

if (endYear != startYear + 1)
        {
            throw new ArgumentException(
                "Academic year must contain consecutive years.");
        }

if (academicYears.Any(x =>
            x.Id != id &&
            x.YearLabel.Equals(
                academicYear.YearLabel,
                StringComparison.OrdinalIgnoreCase)))
        {
            throw new InvalidOperationException(
                "Academic year label already exists.");
        }

if (academicYear.StartDate >= academicYear.EndDate)
        {
            throw new ArgumentException(
                "Start date must be before end date.");
        }

if (academicYear.Status == AcademicYearStatus.Active &&
            academicYears.Any(x =>
                x.Id != id &&
                x.Status == AcademicYearStatus.Active))
        {
            throw new InvalidOperationException(
                "Only one academic year can be active.");
        }

existing.YearLabel = academicYear.YearLabel;
        existing.StartDate = academicYear.StartDate;
        existing.EndDate = academicYear.EndDate;
        existing.AdmissionWindowOpenDate =
            academicYear.AdmissionWindowOpenDate;
        existing.AdmissionWindowCloseDate =
            academicYear.AdmissionWindowCloseDate;
        existing.Status = academicYear.Status;
        existing.UpdatedBy = userId;
        existing.UpdatedDate = DateTime.UtcNow;

_repository.Update(existing);
        await _repository.SaveChangesAsync();
    }

public async Task DeleteAsync(Guid id, Guid? userId)
    {
        var academicYear = await _repository.GetByIdAsync(id);

if (academicYear == null)
        {
            throw new KeyNotFoundException(
                "Academic year not found.");
        }

var hasApplications = await _context.AdmissionApplications
            .AnyAsync(x => x.SchoolClass.AcademicYearId == id);

if (hasApplications)
        {
            throw new InvalidOperationException(
                "Academic year cannot be deleted because applications exist.");
        }

academicYear.IsDeleted = true;
        academicYear.DeletedBy = userId;
        academicYear.DeletedDate = DateTime.UtcNow;

_repository.Update(academicYear);
        await _repository.SaveChangesAsync();
    }
}

public interface ISchoolClassService
{
    Task<List<SchoolClass>> GetAllAsync();
    Task<SchoolClass?> GetByIdAsync(Guid id);
    Task<List<SchoolClass>> GetByAcademicYearIdAsync(Guid academicYearId);
    Task<List<SchoolClass>> GetAvailableClassesAsync();
    Task<SchoolClass> CreateAsync(SchoolClass schoolClass, Guid? userId);
    Task UpdateAsync(Guid id, SchoolClass schoolClass, Guid? userId);
    Task DeleteAsync(Guid id, Guid? userId);
}

public class SchoolClassService : ISchoolClassService
{
    private readonly ISchoolClassRepository _repository;
    private readonly AppDbContext _context;

public SchoolClassService(
        ISchoolClassRepository repository,
        AppDbContext context)
    {
        _repository = repository;
        _context = context;
    }

public async Task<List<SchoolClass>> GetAllAsync()
    {
        return await _repository.GetAllAsync();
    }

public async Task<SchoolClass?> GetByIdAsync(Guid id)
    {
        return await _repository.GetByIdAsync(id);
    }

public async Task<List<SchoolClass>> GetByAcademicYearIdAsync(Guid academicYearId)
    {
        return await _repository.GetByAcademicYearIdAsync(academicYearId);
    }

public async Task<List<SchoolClass>> GetAvailableClassesAsync()
    {
        var activeYear = await _context.AcademicYears
            .FirstOrDefaultAsync(x => x.Status == AcademicYearStatus.Active);

if (activeYear == null ||
            DateTime.UtcNow < activeYear.AdmissionWindowOpenDate ||
            DateTime.UtcNow > activeYear.AdmissionWindowCloseDate)
        {
            return new List<SchoolClass>();
        }

var classes = await _context.SchoolClasses
            .Include(x => x.Applications)
            .Where(x => x.AcademicYearId == activeYear.Id &&
                        x.Status == SchoolClassStatus.Active)
            .ToListAsync();

return classes
            .Where(x => x.TotalSeats > x.Applications.Count(a =>
                a.Status == ApplicationStatus.Confirmed))
            .ToList();
    }

public async Task<SchoolClass> CreateAsync(SchoolClass schoolClass, Guid? userId)
    {
        if (schoolClass.Section.Length > 5)
            throw new ArgumentException("Section cannot exceed 5 characters.");

if (schoolClass.TotalSeats < 1)
            throw new ArgumentException("Total seats must be at least 1.");

if (schoolClass.AdmissionFee < 0)
            throw new ArgumentException("Admission fee cannot be negative.");

if (schoolClass.MonthlyTuitionFee <= 0)
            throw new ArgumentException("Monthly tuition fee must be greater than zero.");

if (schoolClass.TransportFee < 0)
            throw new ArgumentException("Transport fee cannot be negative.");

var academicYearExists = await _context.AcademicYears
            .AnyAsync(x => x.Id == schoolClass.AcademicYearId);

var gradeLevelExists = await _context.GradeLevels
            .AnyAsync(x => x.Id == schoolClass.GradeLevelId);

if (!academicYearExists || !gradeLevelExists)
            throw new ArgumentException("Invalid academic year or grade level.");

var duplicate = await _context.SchoolClasses.AnyAsync(x =>
            x.AcademicYearId == schoolClass.AcademicYearId &&
            x.GradeLevelId == schoolClass.GradeLevelId &&
            x.Section == schoolClass.Section);

if (duplicate)
            throw new InvalidOperationException("This class section already exists.");

schoolClass.Id = Guid.NewGuid();
        schoolClass.ClassCode = $"CLS{Guid.NewGuid().ToString("N")[..8].ToUpper()}";
        schoolClass.CreatedBy = userId;
        schoolClass.CreatedDate = DateTime.UtcNow;
        schoolClass.IsDeleted = false;

await _repository.AddAsync(schoolClass);
        await _repository.SaveChangesAsync();

return schoolClass;
    }

public async Task UpdateAsync(Guid id, SchoolClass schoolClass, Guid? userId)
    {
        var existing = await _repository.GetByIdAsync(id);

if (existing == null)
            throw new KeyNotFoundException("School class not found.");

if (schoolClass.Section.Length > 5)
            throw new ArgumentException("Section cannot exceed 5 characters.");

if (schoolClass.TotalSeats < 1)
            throw new ArgumentException("Total seats must be at least 1.");

if (schoolClass.AdmissionFee < 0)
            throw new ArgumentException("Admission fee cannot be negative.");

if (schoolClass.MonthlyTuitionFee <= 0)
            throw new ArgumentException("Monthly tuition fee must be greater than zero.");

if (schoolClass.TransportFee < 0)
            throw new ArgumentException("Transport fee cannot be negative.");

var confirmedCount = await _context.AdmissionApplications.CountAsync(x =>
            x.SchoolClassId == id &&
            x.Status == ApplicationStatus.Confirmed);

if (schoolClass.TotalSeats < confirmedCount)
            throw new InvalidOperationException(
                "Total seats cannot be less than confirmed admissions.");

var duplicate = await _context.SchoolClasses.AnyAsync(x =>
            x.Id != id &&
            x.AcademicYearId == schoolClass.AcademicYearId &&
            x.GradeLevelId == schoolClass.GradeLevelId &&
            x.Section == schoolClass.Section);

if (duplicate)
            throw new InvalidOperationException("This class section already exists.");

existing.AcademicYearId = schoolClass.AcademicYearId;
        existing.GradeLevelId = schoolClass.GradeLevelId;
        existing.Section = schoolClass.Section;
        existing.TotalSeats = schoolClass.TotalSeats;
        existing.AdmissionFee = schoolClass.AdmissionFee;
        existing.MonthlyTuitionFee = schoolClass.MonthlyTuitionFee;
        existing.TransportFee = schoolClass.TransportFee;
        existing.Status = schoolClass.Status;
        existing.UpdatedBy = userId;
        existing.UpdatedDate = DateTime.UtcNow;

_repository.Update(existing);
        await _repository.SaveChangesAsync();
    }

public async Task DeleteAsync(Guid id, Guid? userId)
    {
        var schoolClass = await _repository.GetByIdAsync(id);

if (schoolClass == null)
            throw new KeyNotFoundException("School class not found.");

var hasConfirmedAdmissions = await _context.AdmissionApplications
            .AnyAsync(x =>
                x.SchoolClassId == id &&
                x.Status == ApplicationStatus.Confirmed);

if (hasConfirmedAdmissions)
            throw new InvalidOperationException(
                "Class cannot be deleted because confirmed admissions exist.");

schoolClass.IsDeleted = true;
        schoolClass.DeletedBy = userId;
        schoolClass.DeletedDate = DateTime.UtcNow;

_repository.Update(schoolClass);
        await _repository.SaveChangesAsync();
    }
}

public interface IAdmissionApplicationService
{
    Task<List<AdmissionApplication>> GetAllAsync();
    Task<AdmissionApplication?> GetByIdAsync(Guid id);
    Task<List<AdmissionApplication>> GetByParentIdAsync(Guid parentId);

Task<AdmissionApplication> ApplyAsync(
        AdmissionApplication application,
        IFormFile birthCertificate,
        Guid parentId);

Task UpdateStatusAsync(Guid id, ApplicationStatus status);

Task ScheduleInterviewAsync(
        Guid id,
        DateTime interviewDate,
        string interviewLocation,
        string? interviewRemarks);

Task WithdrawAsync(Guid id, Guid parentId);
}

public class AdmissionApplicationService : IAdmissionApplicationService
{
    private readonly IAdmissionApplicationRepository _repository;
    private readonly AppDbContext _context;
    private readonly IWebHostEnvironment _environment;

public AdmissionApplicationService(
        IAdmissionApplicationRepository repository,
        AppDbContext context,
        IWebHostEnvironment environment)
    {
        _repository = repository;
        _context = context;
        _environment = environment;
    }

public async Task<List<AdmissionApplication>> GetAllAsync()
    {
        return await _repository.GetAllAsync();
    }

public async Task<AdmissionApplication?> GetByIdAsync(Guid id)
    {
        return await _repository.GetByIdAsync(id);
    }

public async Task<List<AdmissionApplication>> GetByParentIdAsync(Guid parentId)
    {
        return await _repository.GetByParentIdAsync(parentId);
    }

public async Task<AdmissionApplication> ApplyAsync(
        AdmissionApplication application,
        IFormFile birthCertificate,
        Guid parentId)
    {
        if (birthCertificate == null || birthCertificate.Length == 0)
            throw new ArgumentException("Birth certificate is required.");

if (birthCertificate.Length > 5 * 1024 * 1024)
            throw new ArgumentException("Birth certificate cannot exceed 5 MB.");

var extension = Path.GetExtension(birthCertificate.FileName).ToLowerInvariant();

if (extension != ".pdf" && extension != ".jpg" && extension != ".jpeg")
            throw new ArgumentException("Only PDF and JPG files are allowed.");

if (!application.DeclarationAccepted)
            throw new ArgumentException("Declaration must be accepted.");

var parentExists = await _context.Users.AnyAsync(x => x.Id == parentId);

if (!parentExists)
            throw new ArgumentException("Parent not found.");

var schoolClass = await _context.SchoolClasses
            .Include(x => x.AcademicYear)
            .Include(x => x.GradeLevel)
            .Include(x => x.Applications)
            .FirstOrDefaultAsync(x => x.Id == application.SchoolClassId);

if (schoolClass == null || schoolClass.Status != SchoolClassStatus.Active)
            throw new InvalidOperationException("Class is not available.");

var academicYear = schoolClass.AcademicYear;
        var now = DateTime.UtcNow;

if (academicYear.Status != AcademicYearStatus.Active ||
            now < academicYear.AdmissionWindowOpenDate ||
            now > academicYear.AdmissionWindowCloseDate)
            throw new InvalidOperationException("Admission window is closed.");

var confirmedCount = schoolClass.Applications.Count(x =>
            x.Status == ApplicationStatus.Confirmed);

if (confirmedCount >= schoolClass.TotalSeats)
            throw new InvalidOperationException("No seats are available.");

var activeApplications = await _context.AdmissionApplications
            .CountAsync(x =>
                x.ParentId == parentId &&
                x.Status != ApplicationStatus.Confirmed &&
                x.Status != ApplicationStatus.Rejected &&
                x.Status != ApplicationStatus.Withdrawn);

if (activeApplications >= 3)
            throw new InvalidOperationException(
                "A parent can have a maximum of 3 active applications.");

var duplicate = await _context.AdmissionApplications.AnyAsync(x =>
            x.ParentId == parentId &&
            x.ChildFullName == application.ChildFullName &&
            x.ChildDateOfBirth == application.ChildDateOfBirth &&
            x.SchoolClass.AcademicYearId == schoolClass.AcademicYearId &&
            x.Status != ApplicationStatus.Withdrawn);

if (duplicate)
            throw new InvalidOperationException(
                "An application for this child and academic year already exists.");

var age = now.Year - application.ChildDateOfBirth.Year;

if (application.ChildDateOfBirth.Date > now.AddYears(-age).Date)
            age--;

if (age < schoolClass.GradeLevel.MinimumAge ||
            age > schoolClass.GradeLevel.MaximumAge)
            throw new InvalidOperationException(
                "Child does not meet the age eligibility requirements.");

var uploadFolder = Path.Combine(
            _environment.WebRootPath ?? "wwwroot",
            "uploads",
            "birth-certificates");

Directory.CreateDirectory(uploadFolder);

var fileName = $"{Guid.NewGuid()}{extension}";
        var filePath = Path.Combine(uploadFolder, fileName);

await using (var stream = new FileStream(filePath, FileMode.Create))
        {
            await birthCertificate.CopyToAsync(stream);
        }

application.Id = Guid.NewGuid();
        application.ParentId = parentId;
        application.BirthCertificatePath =
            Path.Combine("uploads", "birth-certificates", fileName)
                .Replace("\\", "/");
        application.SubmittedOn = DateTime.UtcNow;
        application.Status = ApplicationStatus.Submitted;

await _repository.AddAsync(application);
        await _repository.SaveChangesAsync();

return application;
    }

public async Task UpdateStatusAsync(Guid id, ApplicationStatus status)
    {
        var application = await _repository.GetByIdAsync(id);

if (application == null)
            throw new KeyNotFoundException("Application not found.");

if (application.Status == ApplicationStatus.Withdrawn)
            throw new InvalidOperationException(
                "A withdrawn application cannot be updated.");

application.Status = status;

if (status == ApplicationStatus.Confirmed)
        {
            application.ConfirmedOn = DateTime.UtcNow;
            application.AdmissionFeeDueDate = DateTime.UtcNow.AddDays(7);
        }

_repository.Update(application);
        await _repository.SaveChangesAsync();
    }

public async Task ScheduleInterviewAsync(
        Guid id,
        DateTime interviewDate,
        string interviewLocation,
        string? interviewRemarks)
    {
        var application = await _repository.GetByIdAsync(id);

if (application == null)
            throw new KeyNotFoundException("Application not found.");

if (application.Status == ApplicationStatus.Withdrawn ||
            application.Status == ApplicationStatus.Rejected)
            throw new InvalidOperationException(
                "Interview cannot be scheduled for this application.");

application.InterviewDate = interviewDate;
        application.InterviewLocation = interviewLocation;
        application.InterviewRemarks = interviewRemarks;
        application.Status = ApplicationStatus.InterviewScheduled;

_repository.Update(application);
        await _repository.SaveChangesAsync();
    }

public async Task WithdrawAsync(Guid id, Guid parentId)
    {
        var application = await _repository.GetByIdAsync(id);

if (application == null || application.ParentId != parentId)
            throw new KeyNotFoundException("Application not found.");

if (application.Status != ApplicationStatus.Submitted &&
            application.Status != ApplicationStatus.UnderReview &&
            application.Status != ApplicationStatus.Waitlisted)
            throw new InvalidOperationException(
                "Application cannot be withdrawn in its current status.");

application.Status = ApplicationStatus.Withdrawn;

_repository.Update(application);
        await _repository.SaveChangesAsync();
    }
}

public interface IFeePaymentService
{
    Task<List<FeePayment>> GetAllAsync();
    Task<FeePayment?> GetByIdAsync(Guid id);
    Task<List<FeePayment>> GetByAdmissionApplicationIdAsync(Guid admissionApplicationId);
    Task<FeePayment> CreateAsync(Guid admissionApplicationId, decimal amount);
    Task UpdatePaymentStatusAsync(Guid id, PaymentStatus status, string? transactionId);
    Task<bool> CheckAdmissionFeeDeadlineAsync(Guid admissionApplicationId);
}

public class FeePaymentService : IFeePaymentService
{
    private readonly IFeePaymentRepository _repository;
    private readonly AppDbContext _context;

public FeePaymentService(
        IFeePaymentRepository repository,
        AppDbContext context)
    {
        _repository = repository;
        _context = context;
    }

public async Task<List<FeePayment>> GetAllAsync()
    {
        return await _repository.GetAllAsync();
    }

public async Task<FeePayment?> GetByIdAsync(Guid id)
    {
        return await _repository.GetByIdAsync(id);
    }

public async Task<List<FeePayment>> GetByAdmissionApplicationIdAsync(
        Guid admissionApplicationId)
    {
        return await _repository.GetByAdmissionApplicationIdAsync(
            admissionApplicationId);
    }

public async Task<FeePayment> CreateAsync(
        Guid admissionApplicationId,
        decimal amount)
    {
        if (amount <= 0)
            throw new ArgumentException("Payment amount must be greater than zero.");

var application = await _context.AdmissionApplications
            .Include(x => x.SchoolClass)
            .FirstOrDefaultAsync(x => x.Id == admissionApplicationId);

if (application == null)
            throw new KeyNotFoundException("Admission application not found.");

if (application.Status != ApplicationStatus.Confirmed)
            throw new InvalidOperationException(
                "Payment is allowed only for confirmed admissions.");

if (application.AdmissionFeeDueDate == null ||
            DateTime.UtcNow > application.AdmissionFeeDueDate)
            throw new InvalidOperationException("Admission fee payment deadline has passed.");

if (amount != application.SchoolClass.AdmissionFee)
            throw new ArgumentException("Payment amount does not match the admission fee.");

var existingPaidPayment = await _context.FeePayments.AnyAsync(x =>
            x.AdmissionApplicationId == admissionApplicationId &&
            x.Status == PaymentStatus.Paid);

if (existingPaidPayment)
            throw new InvalidOperationException("Admission fee has already been paid.");

var payment = new FeePayment
        {
            Id = Guid.NewGuid(),
            AdmissionApplicationId = admissionApplicationId,
            Amount = amount,
            Status = PaymentStatus.Pending,
            CreatedDate = DateTime.UtcNow
        };

await _repository.AddAsync(payment);
        await _repository.SaveChangesAsync();

return payment;
    }

public async Task UpdatePaymentStatusAsync(
        Guid id,
        PaymentStatus status,
        string? transactionId)
    {
        var payment = await _repository.GetByIdAsync(id);

if (payment == null)
            throw new KeyNotFoundException("Fee payment not found.");

if (status == PaymentStatus.Paid &&
            string.IsNullOrWhiteSpace(transactionId))
            throw new ArgumentException("Transaction ID is required for paid payments.");

if (status == PaymentStatus.Paid)
        {
            var application = await _context.AdmissionApplications
                .FirstOrDefaultAsync(x => x.Id == payment.AdmissionApplicationId);

if (application == null)
                throw new KeyNotFoundException("Admission application not found.");

if (application.AdmissionFeeDueDate == null ||
                DateTime.UtcNow > application.AdmissionFeeDueDate)
                throw new InvalidOperationException("Admission fee payment deadline has passed.");

var alreadyPaid = await _context.FeePayments.AnyAsync(x =>
                x.Id != id &&
                x.AdmissionApplicationId == payment.AdmissionApplicationId &&
                x.Status == PaymentStatus.Paid);

if (alreadyPaid)
                throw new InvalidOperationException("Admission fee has already been paid.");

payment.PaymentDate = DateTime.UtcNow;
        }

payment.Status = status;
        payment.TransactionId = transactionId;

_repository.Update(payment);
        await _repository.SaveChangesAsync();
    }

public async Task<bool> CheckAdmissionFeeDeadlineAsync(
        Guid admissionApplicationId)
    {
        var application = await _context.AdmissionApplications
            .Include(x => x.FeePayments)
            .FirstOrDefaultAsync(x => x.Id == admissionApplicationId);

if (application == null)
            throw new KeyNotFoundException("Admission application not found.");

if (application.Status != ApplicationStatus.Confirmed ||
            application.AdmissionFeeDueDate == null ||
            DateTime.UtcNow <= application.AdmissionFeeDueDate)
            return false;

var isPaid = application.FeePayments.Any(x =>
            x.Status == PaymentStatus.Paid);

if (isPaid)
            return false;

application.Status = ApplicationStatus.Waitlisted;

_context.AdmissionApplications.Update(application);
        await _context.SaveChangesAsync();

return true;
    }
}

public interface IDashboardService
{
    Task<Dictionary<ApplicationStatus, int>> GetApplicationStatusCountsAsync();

Task<int> GetTotalApplicationsAsync();

Task<int> GetConfirmedAdmissionsAsync();

Task<int> GetAvailableSeatsAsync();

Task<List<AdmissionApplication>> GetParentApplicationsAsync(Guid parentId);
}

public class DashboardService : IDashboardService
{
    private readonly AppDbContext _context;

public DashboardService(AppDbContext context)
    {
        _context = context;
    }

public async Task<Dictionary<ApplicationStatus, int>> GetApplicationStatusCountsAsync()
    {
        return await _context.AdmissionApplications
            .GroupBy(x => x.Status)
            .ToDictionaryAsync(x => x.Key, x => x.Count());
    }

public async Task<int> GetTotalApplicationsAsync()
    {
        return await _context.AdmissionApplications.CountAsync();
    }

public async Task<int> GetConfirmedAdmissionsAsync()
    {
        return await _context.AdmissionApplications
            .CountAsync(x => x.Status == ApplicationStatus.Confirmed);
    }

public async Task<int> GetAvailableSeatsAsync()
    {
        var classes = await _context.SchoolClasses
            .Include(x => x.Applications)
            .Where(x => x.Status == SchoolClassStatus.Active)
            .ToListAsync();

return classes.Sum(x =>
            Math.Max(0, x.TotalSeats - x.Applications.Count(a =>
                a.Status == ApplicationStatus.Confirmed)));
    }

public async Task<List<AdmissionApplication>> GetParentApplicationsAsync(Guid parentId)
    {
        return await _context.AdmissionApplications
            .Where(x => x.ParentId == parentId)
            .ToListAsync();
    }
} -->

Related Examples

Coffee Menu

ariaw

1 year ago

927
dashboard2

John

20 hours ago

3
Instagram Post UI Mockup
A static HTML and Tailwind CSS component that visually replicates the user interface of an Instagram post. This mockup includes the post header (avatar, username, options), image area, action buttons (like, comment, share, save), like count, caption, and comment section. It features responsive constraints and supports both light and dark mode, closely mimicking the look and feel of the actual Instagram app. Ideal for UI prototyping, style guides, or frontend development practice.

Hamza Atig

1 year ago

2.2k
Login Form (Balsamiq Look)

Ahmad Syaifuddin

11 months ago

991
cancel form

Anonymous

2 weeks ago

6
Detail Article

Alief Malik

1 month ago

61
Payment success page example

Anonymous

1 year ago

2.3k
Glassmorphism form

Geoffrey Callaghan

2 years ago

7.5k
Phone Simulator with Built-in Car Racing Game and Play.
This is a complete virtual smartphone simulator built using HTML, CSS, Tailwind CSS, JavaScript, and Font Awesome Icons and mobile responsive . It provides a realistic phone interface with multiple apps, and the highlight is a fully playable Car Racing Game built right into it where you can actually play the car game.

Arjun Kumar

4 months ago

647
cards
cards with background animation

Anonymous

2 years ago

3.8k
chat ui advanced
Professional chat ui, connect me for jsx https://abhirajk.vercel.app/

Abhiraj

1 year ago

2.5k
htmlcss0

Anonymous

1 year ago

1.1k