loginForm3

form

This tailwind example is contributed by Anonymous, on 24-Sep-2026. Component is made with Tailwind v3.4. It is responsive.

Other

Author Anonymous

Tailwind v3.4 78

Fork Fullscreen

<div class="max-w-xl py-6 px-8 h-80 mt-20 bg-white rounded shadow-xl">
  <form action="">
    <div class="mb-6">
      <label for="name" class="block text-gray-800 font-bold">Name:</label>
      <input type="text" name="name" id="name" placeholder="username" class="w-full border border-gray-300 py-2 pl-3 rounded mt-2 outline-none focus:ring-indigo-600 :ring-indigo-600" />
    </div>
    <div>
      <label for="email" class="block text-gray-800 font-bold">Email:</label>
      <input type="text" name="email" id="email" placeholder="@email" class="w-full border border-gray-300 py-2 pl-3 rounded mt-2 outline-none focus:ring-indigo-600 :ring-indigo-600" />
      <a href="#" class="text-sm font-thin text-gray-800 hover:underline mt-2 inline-block hover:text-indigo-600">Forget Password</a>
    </div>
    <button class="cursor-pointer py-2 px-4 block mt-6 bg-indigo-500 text-white font-bold w-full text-center rounded">Login</button>
  </form>
</div>

<!--

using MedicalClinicManagementSystem.Models;

namespace MedicalClinicManagementSystem.Services.Interfaces
{
    public interface IClinicService
    {
        Task<Clinic?> GetByIdAsync(int id);

Task<IEnumerable<Clinic>> GetAllAsync();

Task<IEnumerable<Clinic>> GetActiveClinicsAsync();

Task CreateAsync(
            Clinic clinic,
            string currentUserId);

Task UpdateAsync(
            Clinic clinic,
            string currentUserId);

Task DeleteAsync(
            int id,
            string currentUserId);
    }
}

using MedicalClinicManagementSystem.Models;
using MedicalClinicManagementSystem.Repositories.Interfaces;
using MedicalClinicManagementSystem.Services.Interfaces;

namespace MedicalClinicManagementSystem.Services.Implementations
{
    public class ClinicService : IClinicService
    {
        private readonly IClinicRepository _clinicRepository;

public ClinicService(IClinicRepository clinicRepository)
        {
            _clinicRepository = clinicRepository;
        }

// =========================================================
        // GET BY ID
        // =========================================================

public async Task<Clinic?> GetByIdAsync(int id)
        {
            var clinic = await _clinicRepository.GetByIdAsync(id);

if (clinic == null || clinic.IsDeleted)
            {
                return null;
            }

return clinic;
        }

// =========================================================
        // GET ALL
        // =========================================================

public async Task<IEnumerable<Clinic>> GetAllAsync()
        {
            return await _clinicRepository.GetAllAsync();
        }

// =========================================================
        // GET ACTIVE CLINICS
        // =========================================================

public async Task<IEnumerable<Clinic>>
            GetActiveClinicsAsync()
        {
            return await _clinicRepository
                .GetActiveClinicsAsync();
        }

// =========================================================
        // CREATE CLINIC
        // =========================================================

public async Task CreateAsync(
            Clinic clinic,
            string currentUserId)
        {
            // -----------------------------------------------------
            // 1. Check unique email
            // -----------------------------------------------------

var existingClinic =
                await _clinicRepository
                    .GetByEmailAsync(clinic.Email);

if (existingClinic != null)
            {
                throw new InvalidOperationException(
                    "A clinic with this email already exists.");
            }

// -----------------------------------------------------
            // 2. Opening time must be before closing time
            // -----------------------------------------------------

if (clinic.OpeningTime >= clinic.ClosingTime)
            {
                throw new InvalidOperationException(
                    "Opening time must be before closing time.");
            }

// -----------------------------------------------------
            // 3. Appointment duration
            // Allowed: 15, 30, 45, 60
            // -----------------------------------------------------

var allowedDurations = new[] { 15, 30, 45, 60 };

if (!allowedDurations.Contains(
                    clinic.AppointmentDuration))
            {
                throw new InvalidOperationException(
                    "Appointment duration must be 15, 30, 45 or 60 minutes.");
            }

// -----------------------------------------------------
            // 4. Generate Clinic Code
            // Example: CLN001, CLN002...
            // -----------------------------------------------------

clinic.ClinicCode =
                await GenerateClinicCodeAsync();

// -----------------------------------------------------
            // 5. Default values
            // -----------------------------------------------------

clinic.IsDeleted = false;
            clinic.IsActive = true;

// -----------------------------------------------------
            // 6. Audit fields
            // -----------------------------------------------------

clinic.CreatedBy = currentUserId;
            clinic.CreatedDate = DateTime.UtcNow;

// -----------------------------------------------------
            // 7. Save
            // -----------------------------------------------------

await _clinicRepository.AddAsync(clinic);

await _clinicRepository.SaveChangesAsync();
        }

// =========================================================
        // UPDATE CLINIC
        // =========================================================

public async Task UpdateAsync(
            Clinic clinic,
            string currentUserId)
        {
            // -----------------------------------------------------
            // 1. Find existing clinic
            // -----------------------------------------------------

var existingClinic =
                await _clinicRepository
                    .GetByIdAsync(clinic.Id);

if (existingClinic == null ||
                existingClinic.IsDeleted)
            {
                throw new KeyNotFoundException(
                    "Clinic not found.");
            }

// -----------------------------------------------------
            // 2. Check email uniqueness
            // Exclude current clinic
            // -----------------------------------------------------

var emailClinic =
                await _clinicRepository
                    .GetByEmailAsync(clinic.Email);

if (emailClinic != null &&
                emailClinic.Id != clinic.Id)
            {
                throw new InvalidOperationException(
                    "A clinic with this email already exists.");
            }

// -----------------------------------------------------
            // 3. Opening time / closing time
            // -----------------------------------------------------

if (clinic.OpeningTime >= clinic.ClosingTime)
            {
                throw new InvalidOperationException(
                    "Opening time must be before closing time.");
            }

// -----------------------------------------------------
            // 4. Appointment duration
            // -----------------------------------------------------

var allowedDurations = new[] { 15, 30, 45, 60 };

// -----------------------------------------------------
            // 5. Update editable fields
            // -----------------------------------------------------

existingClinic.ClinicName =
                clinic.ClinicName;

existingClinic.Address =
                clinic.Address;

existingClinic.City =
                clinic.City;

existingClinic.Phone =
                clinic.Phone;

existingClinic.Email =
                clinic.Email;

existingClinic.OpeningTime =
                clinic.OpeningTime;

existingClinic.ClosingTime =
                clinic.ClosingTime;

existingClinic.AppointmentDuration =
                clinic.AppointmentDuration;

existingClinic.EmergencyServices =
                clinic.EmergencyServices;

existingClinic.IsActive =
                clinic.IsActive;

// -----------------------------------------------------
            // 6. Audit
            // -----------------------------------------------------

existingClinic.UpdatedBy =
                currentUserId;

existingClinic.UpdatedDate =
                DateTime.UtcNow;

// -----------------------------------------------------
            // 7. Save
            // -----------------------------------------------------

await _clinicRepository
                .UpdateAsync(existingClinic);

await _clinicRepository
                .SaveChangesAsync();
        }

// =========================================================
        // DELETE CLINIC - SOFT DELETE
        // =========================================================

public async Task DeleteAsync(
            int id,
            string currentUserId)
        {
            // -----------------------------------------------------
            // 1. Find clinic
            // -----------------------------------------------------

var clinic =
                await _clinicRepository
                    .GetByIdAsync(id);

if (clinic == null ||
                clinic.IsDeleted)
            {
                throw new KeyNotFoundException(
                    "Clinic not found.");
            }

// -----------------------------------------------------
            // 2. Cannot delete if active appointments exist
            // Active = Scheduled / CheckedIn
            // -----------------------------------------------------

var hasActiveAppointments =
                await _clinicRepository
                    .HasActiveAppointmentsAsync(id);

if (hasActiveAppointments)
            {
                throw new InvalidOperationException(
                    "Clinic cannot be deleted because active appointments exist.");
            }

// -----------------------------------------------------
            // 3. Cannot delete if patient records exist
            // -----------------------------------------------------

var hasPatientRecords =
                await _clinicRepository
                    .HasPatientRecordsAsync(id);

if (hasPatientRecords)
            {
                throw new InvalidOperationException(
                    "Clinic cannot be deleted because patient records exist.");
            }

// -----------------------------------------------------
            // 4. Soft Delete
            // -----------------------------------------------------

clinic.IsDeleted = true;

// Deleted clinic cannot accept appointments
            clinic.IsActive = false;

clinic.DeletedBy =
                currentUserId;

clinic.DeletedDate =
                DateTime.UtcNow;

// -----------------------------------------------------
            // 5. Save
            // -----------------------------------------------------

await _clinicRepository
                .UpdateAsync(clinic);

await _clinicRepository
                .SaveChangesAsync();
        }

// =========================================================
        // GENERATE CLINIC CODE
        // =========================================================

private async Task<string> GenerateClinicCodeAsync()
        {
            var clinics =
                await _clinicRepository.GetAllAsync();

var maxNumber = 0;

foreach (var clinic in clinics)
            {
                if (string.IsNullOrWhiteSpace(
                        clinic.ClinicCode))
                {
                    continue;
                }

// Expected format: CLN001
                if (clinic.ClinicCode.StartsWith("CLN") &&
                    int.TryParse(
                        clinic.ClinicCode.Substring(3),
                        out int number))
                {
                    if (number > maxNumber)
                    {
                        maxNumber = number;
                    }
                }
            }

return $"CLN{(maxNumber + 1):D3}";
        }
    }
}

using MedicalClinicManagementSystem.Models;

namespace MedicalClinicManagementSystem.Services.Interfaces
{
    public interface IDoctorService
    {
        Task<Doctor?> GetByIdAsync(int id);

Task<IEnumerable<Doctor>> GetAllAsync();

Task<IEnumerable<Doctor>> GetByClinicAsync(int clinicId);

Task<IEnumerable<Doctor>> GetAvailableDoctorsAsync(int clinicId);

Task CreateAsync(
            Doctor doctor,
            string currentUserId);

Task UpdateAsync(
            Doctor doctor,
            string currentUserId);

Task DeleteAsync(
            int id,
            string currentUserId);
    }
}

using MedicalClinicManagementSystem.Models;
using MedicalClinicManagementSystem.Repositories.Interfaces;
using MedicalClinicManagementSystem.Services.Interfaces;

namespace MedicalClinicManagementSystem.Services.Implementations
{
    public class DoctorService : IDoctorService
    {
        private readonly IDoctorRepository _doctorRepository;
        private readonly IClinicRepository _clinicRepository;

public DoctorService(
            IDoctorRepository doctorRepository,
            IClinicRepository clinicRepository)
        {
            _doctorRepository = doctorRepository;
            _clinicRepository = clinicRepository;
        }

// GET BY ID
        public async Task<Doctor?> GetByIdAsync(int id)
        {
            var doctor =
                await _doctorRepository.GetByIdAsync(id);

if (doctor == null || doctor.IsDeleted)
            {
                return null;
            }

return doctor;
        }

// GET ALL
        public async Task<IEnumerable<Doctor>> GetAllAsync()
        {
            return await _doctorRepository.GetAllAsync();
        }

// GET DOCTORS BY CLINIC
        public async Task<IEnumerable<Doctor>>
            GetByClinicAsync(int clinicId)
        {
            var clinic =
                await _clinicRepository.GetByIdAsync(clinicId);

if (clinic == null ||
                clinic.IsDeleted ||
                !clinic.IsActive)
            {
                throw new InvalidOperationException(
                    "Clinic is not available.");
            }

return await _doctorRepository
                .GetByClinicAsync(clinicId);
        }

// GET AVAILABLE DOCTORS
        public async Task<IEnumerable<Doctor>>
            GetAvailableDoctorsAsync(int clinicId)
        {
            var clinic =
                await _clinicRepository.GetByIdAsync(clinicId);

return await _doctorRepository
                .GetAvailableDoctorsAsync(clinicId);
        }

// CREATE DOCTOR
        public async Task CreateAsync(
            Doctor doctor,
            string currentUserId)
        {
            // Check clinic
            var clinic =
                await _clinicRepository
                    .GetByIdAsync(doctor.ClinicId);

if (clinic == null ||
                clinic.IsDeleted ||
                !clinic.IsActive)
            {
                throw new InvalidOperationException(
                    "Selected clinic is not available.");
            }

// Check email uniqueness
            var existingEmail =
                await _doctorRepository
                    .GetByEmailAsync(doctor.Email);

if (existingEmail != null)
            {
                throw new InvalidOperationException(
                    "A doctor with this email already exists.");
            }

// Check license uniqueness
            var existingLicense =
                await _doctorRepository
                    .GetByLicenseNumberAsync(
                        doctor.LicenseNumber);

if (existingLicense != null)
            {
                throw new InvalidOperationException(
                    "A doctor with this license number already exists.");
            }

// Experience
            if (doctor.YearsOfExperience < 0)
            {
                throw new InvalidOperationException(
                    "Years of experience cannot be negative.");
            }

// Consultation fee
            if (doctor.ConsultationFee <= 0)
            {
                throw new InvalidOperationException(
                    "Consultation fee must be greater than zero.");
            }

// Generate Doctor Code
            doctor.DoctorCode =
                await GenerateDoctorCodeAsync();

// Default values
            doctor.IsDeleted = false;
            doctor.IsActive = true;

doctor.CreatedBy =
                currentUserId;

doctor.CreatedDate =
                DateTime.UtcNow;

await _doctorRepository
                .AddAsync(doctor);

await _doctorRepository
                .SaveChangesAsync();
        }

// UPDATE DOCTOR
        public async Task UpdateAsync(
            Doctor doctor,
            string currentUserId)
        {
            var existingDoctor =
                await _doctorRepository
                    .GetByIdAsync(doctor.Id);

if (existingDoctor == null ||
                existingDoctor.IsDeleted)
            {
                throw new KeyNotFoundException(
                    "Doctor not found.");
            }

// Check clinic
            var clinic =
                await _clinicRepository
                    .GetByIdAsync(doctor.ClinicId);

// Check email uniqueness
            var emailDoctor =
                await _doctorRepository
                    .GetByEmailAsync(doctor.Email);

if (emailDoctor != null &&
                emailDoctor.Id != doctor.Id)
            {
                throw new InvalidOperationException(
                    "A doctor with this email already exists.");
            }

// Check license uniqueness
            var licenseDoctor =
                await _doctorRepository
                    .GetByLicenseNumberAsync(
                        doctor.LicenseNumber);

if (licenseDoctor != null &&
                licenseDoctor.Id != doctor.Id)
            {
                throw new InvalidOperationException(
                    "A doctor with this license number already exists.");
            }

// Update editable fields
            existingDoctor.DoctorName =
                doctor.DoctorName;

existingDoctor.ClinicId =
                doctor.ClinicId;

existingDoctor.Email =
                doctor.Email;

existingDoctor.Phone =
                doctor.Phone;

existingDoctor.SpecializationId =
                doctor.SpecializationId;

existingDoctor.LicenseNumber =
                doctor.LicenseNumber;

existingDoctor.Qualification =
                doctor.Qualification;

existingDoctor.YearsOfExperience =
                doctor.YearsOfExperience;

existingDoctor.ConsultationFee =
                doctor.ConsultationFee;

existingDoctor.IsAvailable =
                doctor.IsAvailable;

existingDoctor.IsActive =
                doctor.IsActive;

// Audit
            existingDoctor.UpdatedBy =
                currentUserId;

existingDoctor.UpdatedDate =
                DateTime.UtcNow;

await _doctorRepository
                .UpdateAsync(existingDoctor);

await _doctorRepository
                .SaveChangesAsync();
        }

// SOFT DELETE
        public async Task DeleteAsync(
            int id,
            string currentUserId)
        {
            var doctor =
                await _doctorRepository
                    .GetByIdAsync(id);

if (doctor == null ||
                doctor.IsDeleted)
            {
                throw new KeyNotFoundException(
                    "Doctor not found.");
            }

// Cannot delete doctor
            // if active appointments exist
            var hasActiveAppointments =
                await _doctorRepository
                    .HasActiveAppointmentsAsync(id);

if (hasActiveAppointments)
            {
                throw new InvalidOperationException(
                    "Doctor cannot be deleted because active appointments exist.");
            }

// Soft delete
            doctor.IsDeleted = true;
            doctor.IsActive = false;
            doctor.IsAvailable = false;

doctor.DeletedBy =
                currentUserId;

doctor.DeletedDate =
                DateTime.UtcNow;

await _doctorRepository
                .UpdateAsync(doctor);

await _doctorRepository
                .SaveChangesAsync();
        }

// GENERATE DOCTOR CODE
        private async Task<string>
            GenerateDoctorCodeAsync()
        {
            var doctors =
                await _doctorRepository
                    .GetAllAsync();

var maxNumber = 0;

foreach (var doctor in doctors)
            {
                if (string.IsNullOrWhiteSpace(
                        doctor.DoctorCode))
                {
                    continue;
                }

if (doctor.DoctorCode.StartsWith("DOC") &&
                    int.TryParse(
                        doctor.DoctorCode.Substring(3),
                        out int number))
                {
                    if (number > maxNumber)
                    {
                        maxNumber = number;
                    }
                }
            }

return $"DOC{(maxNumber + 1):D3}";
        }
    }
}

//
using MedicalClinicManagementSystem.Models;

namespace MedicalClinicManagementSystem.Services.Interfaces
{
    public interface IDoctorAvailabilityService
    {
        Task<IEnumerable<DoctorAvailability>>
            GetByDoctorAsync(int doctorId);

Task<IEnumerable<DoctorAvailability>>
            GetAvailableSlotsAsync(
                int doctorId,
                DayOfWeek dayOfWeek);

Task CreateAsync(
            DoctorAvailability availability);

Task UpdateAsync(
            DoctorAvailability availability);
    }
}

using MedicalClinicManagementSystem.Models;
using MedicalClinicManagementSystem.Repositories.Interfaces;
using MedicalClinicManagementSystem.Services.Interfaces;

namespace MedicalClinicManagementSystem.Services.Implementations
{
    public class DoctorAvailabilityService
        : IDoctorAvailabilityService
    {
        private readonly IDoctorAvailabilityRepository
            _availabilityRepository;

private readonly IDoctorRepository
            _doctorRepository;

public DoctorAvailabilityService(
            IDoctorAvailabilityRepository availabilityRepository,
            IDoctorRepository doctorRepository)
        {
            _availabilityRepository =
                availabilityRepository;

_doctorRepository =
                doctorRepository;
        }

// GET DOCTOR SCHEDULE
        public async Task<IEnumerable<DoctorAvailability>>
            GetByDoctorAsync(int doctorId)
        {
            var doctor =
                await _doctorRepository
                    .GetByIdAsync(doctorId);

if (doctor == null ||
                doctor.IsDeleted)
            {
                throw new KeyNotFoundException(
                    "Doctor not found.");
            }

return await _availabilityRepository
                .GetByDoctorAsync(doctorId);
        }

// GET AVAILABLE SLOTS FOR A DAY
        public async Task<IEnumerable<DoctorAvailability>>
            GetAvailableSlotsAsync(
                int doctorId,
                DayOfWeek dayOfWeek)
        {
            var doctor =
                await _doctorRepository
                    .GetByIdAsync(doctorId);

if (doctor == null ||
                doctor.IsDeleted)
            {
                throw new KeyNotFoundException(
                    "Doctor not found.");
            }

if (!doctor.IsActive ||
                !doctor.IsAvailable)
            {
                return Enumerable.Empty<DoctorAvailability>();
            }

return await _availabilityRepository
                .GetAvailableSlotsAsync(
                    doctorId,
                    dayOfWeek);
        }

// CREATE AVAILABILITY
        public async Task CreateAsync(
            DoctorAvailability availability)
        {
            // Check doctor
            var doctor =
                await _doctorRepository
                    .GetByIdAsync(
                        availability.DoctorId);

if (doctor == null ||
                doctor.IsDeleted)
            {
                throw new KeyNotFoundException(
                    "Doctor not found.");
            }

// Doctor must be active
            if (!doctor.IsActive)
            {
                throw new InvalidOperationException(
                    "Availability cannot be created for an inactive doctor.");
            }

// Start time must be before end time
            if (availability.StartTime >=
                availability.EndTime)
            {
                throw new InvalidOperationException(
                    "Start time must be before end time.");
            }

// Check conflicting schedule
            var existingAvailabilities =
                await _availabilityRepository
                    .GetByDoctorAsync(
                        availability.DoctorId);

var hasConflict =
                existingAvailabilities.Any(x =>
                    x.DayOfWeek ==
                    availability.DayOfWeek
                    &&
                    x.StartTime <
                    availability.EndTime
                    &&
                    availability.StartTime <
                    x.EndTime);

if (hasConflict)
            {
                throw new InvalidOperationException(
                    "Doctor already has an overlapping availability for this day.");
            }

await _availabilityRepository
                .AddAsync(availability);

await _availabilityRepository
                .SaveChangesAsync();
        }

// UPDATE AVAILABILITY
        public async Task UpdateAsync(
            DoctorAvailability availability)
        {
            var existingAvailability =
                await GetExistingAvailabilityAsync(
                    availability.Id);

if (existingAvailability == null)
            {
                throw new KeyNotFoundException(
                    "Doctor availability not found.");
            }

// Check doctor
            var doctor =
                await _doctorRepository
                    .GetByIdAsync(
                        availability.DoctorId);

if (doctor == null ||
                doctor.IsDeleted)
            {
                throw new KeyNotFoundException(
                    "Doctor not found.");
            }

if (!doctor.IsActive)
            {
                throw new InvalidOperationException(
                    "Availability cannot be updated for an inactive doctor.");
            }

// Prevent changing availability
            // to another doctor accidentally
            if (existingAvailability.DoctorId !=
                availability.DoctorId)
            {
                throw new InvalidOperationException(
                    "Doctor cannot be changed for an existing availability.");
            }

var hasConflict =
                existingAvailabilities.Any(x =>
                    x.Id != availability.Id
                    &&
                    x.DayOfWeek ==
                    availability.DayOfWeek
                    &&
                    x.StartTime <
                    availability.EndTime
                    &&
                    availability.StartTime <
                    x.EndTime);

if (hasConflict)
            {
                throw new InvalidOperationException(
                    "Doctor already has an overlapping availability for this day.");
            }

existingAvailability.DayOfWeek =
                availability.DayOfWeek;

existingAvailability.StartTime =
                availability.StartTime;

existingAvailability.EndTime =
                availability.EndTime;

existingAvailability.IsAvailable =
                availability.IsAvailable;

await _availabilityRepository
                .UpdateAsync(existingAvailability);

await _availabilityRepository
                .SaveChangesAsync();
        }

// GET EXISTING AVAILABILITY
        private async Task<DoctorAvailability?>
            GetExistingAvailabilityAsync(int id)
        {
            var allAvailabilities =
                await _availabilityRepository
                    .GetByDoctorAsync(
                        await GetDoctorIdFromAvailabilityAsync(id));

return allAvailabilities
                .FirstOrDefault(x => x.Id == id);
        }

// GET DOCTOR ID FROM AVAILABILITY
        private async Task<int>
            GetDoctorIdFromAvailabilityAsync(int id)
        {
            // This method is used only because the current
            // repository interface does not have GetByIdAsync.
            //
            // It searches through doctors' availability records.

var doctors =
                await _doctorRepository
                    .GetAllAsync();

foreach (var doctor in doctors)
            {
                var availabilities =
                    await _availabilityRepository
                        .GetByDoctorAsync(doctor.Id);

if (availabilities.Any(x => x.Id == id))
                {
                    return doctor.Id;
                }
            }

return 0;
        }
    }
}

using MedicalClinicManagementSystem.Models;

namespace MedicalClinicManagementSystem.Services.Interfaces
{
    public interface IAppointmentService
    {
        Task<Appointment?> GetByIdAsync(int id);

Task<IEnumerable<Appointment>> GetAllAsync();

Task<IEnumerable<Appointment>>
            GetByPatientAsync(string patientId);

Task<IEnumerable<Appointment>>
            GetByDoctorAsync(int doctorId);

Task<IEnumerable<Appointment>>
            GetByClinicAsync(int clinicId);

Task<IEnumerable<TimeOnly>>
            GetAvailableSlotsAsync(
                int clinicId,
                int doctorId,
                DateTime appointmentDate);

Task CreateAsync(
            Appointment appointment);

Task UpdateStatusAsync(
            int appointmentId,
            AppointmentStatus status);

Task CancelAsync(
            int appointmentId,
            string patientId,
            string? reason);

Task RescheduleAsync(
            int appointmentId,
            DateTime appointmentDate,
            TimeOnly appointmentTime,
            string patientId);
    }
}

using MedicalClinicManagementSystem.Models;
using MedicalClinicManagementSystem.Repositories.Interfaces;
using MedicalClinicManagementSystem.Services.Interfaces;
using Microsoft.AspNetCore.Identity;

namespace MedicalClinicManagementSystem.Services.Implementations
{
    public class AppointmentService : IAppointmentService
    {
        private readonly IAppointmentRepository _appointmentRepository;
        private readonly IClinicRepository _clinicRepository;
        private readonly IDoctorRepository _doctorRepository;
        private readonly IDoctorAvailabilityRepository
            _availabilityRepository;

private readonly UserManager<ApplicationUser> _userManager;

public AppointmentService(
            IAppointmentRepository appointmentRepository,
            IClinicRepository clinicRepository,
            IDoctorRepository doctorRepository,
            IDoctorAvailabilityRepository availabilityRepository,
            UserManager<ApplicationUser> userManager)
        {
            _appointmentRepository =
                appointmentRepository;

_clinicRepository =
                clinicRepository;

_doctorRepository =
                doctorRepository;

_availabilityRepository =
                availabilityRepository;

_userManager =
                userManager;
        }

// GET BY ID
        public async Task<Appointment?> GetByIdAsync(int id)
        {
            return await _appointmentRepository
                .GetByIdAsync(id);
        }

// GET ALL
        public async Task<IEnumerable<Appointment>>
            GetAllAsync()
        {
            return await _appointmentRepository
                .GetAllAsync();
        }

// GET PATIENT APPOINTMENTS
        public async Task<IEnumerable<Appointment>>
            GetByPatientAsync(string patientId)
        {
            var patient =
                await _userManager.FindByIdAsync(patientId);

if (patient == null)
            {
                throw new KeyNotFoundException(
                    "Patient not found.");
            }

return await _appointmentRepository
                .GetByPatientAsync(patientId);
        }

// GET DOCTOR APPOINTMENTS
        public async Task<IEnumerable<Appointment>>
            GetByDoctorAsync(int doctorId)
        {
            var doctor =
                await _doctorRepository
                    .GetByIdAsync(doctorId);

if (doctor == null ||
                doctor.IsDeleted)
            {
                throw new KeyNotFoundException(
                    "Doctor not found.");
            }

return await _appointmentRepository
                .GetByDoctorAsync(doctorId);
        }

// GET CLINIC APPOINTMENTS
        public async Task<IEnumerable<Appointment>>
            GetByClinicAsync(int clinicId)
        {
            var clinic =
                await _clinicRepository
                    .GetByIdAsync(clinicId);

if (clinic == null ||
                clinic.IsDeleted)
            {
                throw new KeyNotFoundException(
                    "Clinic not found.");
            }

return await _appointmentRepository
                .GetByClinicAsync(clinicId);
        }

// GET AVAILABLE SLOTS
        public async Task<IEnumerable<TimeOnly>>
            GetAvailableSlotsAsync(
                int clinicId,
                int doctorId,
                DateTime appointmentDate)
        {
            var clinic =
                await _clinicRepository
                    .GetByIdAsync(clinicId);

var doctor =
                await _doctorRepository
                    .GetByIdAsync(doctorId);

if (doctor == null ||
                doctor.IsDeleted)
            {
                throw new KeyNotFoundException(
                    "Doctor not found.");
            }

if (!doctor.IsActive ||
                !doctor.IsAvailable)
            {
                return Enumerable.Empty<TimeOnly>();
            }

if (doctor.ClinicId != clinicId)
            {
                throw new InvalidOperationException(
                    "Doctor does not belong to the selected clinic.");
            }

if (!IsValidAppointmentDate(appointmentDate))
            {
                return Enumerable.Empty<TimeOnly>();
            }

var dayOfWeek =
                appointmentDate.DayOfWeek;

var availabilities =
                await _availabilityRepository
                    .GetAvailableSlotsAsync(
                        doctorId,
                        dayOfWeek);

var appointments =
                await _appointmentRepository
                    .GetByDoctorAsync(doctorId);

var activeAppointments =
                appointments
                    .Where(x =>
                        x.AppointmentDate.Date ==
                        appointmentDate.Date
                        &&
                        x.Status == AppointmentStatus.Scheduled
                        ||
                        x.AppointmentDate.Date ==
                        appointmentDate.Date
                        &&
                        x.Status == AppointmentStatus.CheckedIn)
                    .ToList();

var availableSlots =
                new List<TimeOnly>();

foreach (var availability in availabilities)
            {
                if (!availability.IsAvailable)
                {
                    continue;
                }

var currentTime =
                    availability.StartTime;

while (
                    currentTime.AddMinutes(
                        clinic.AppointmentDuration)
                    <= availability.EndTime)
                {
                    var slotEnd =
                        currentTime.AddMinutes(
                            clinic.AppointmentDuration);

var isBooked =
                        activeAppointments.Any(
                            appointment =>
                                IsTimeOverlapping(
                                    currentTime,
                                    slotEnd,
                                    appointment.AppointmentTime,
                                    appointment.AppointmentTime
                                        .AddMinutes(
                                            clinic.AppointmentDuration)));

if (!isBooked)
                    {
                        availableSlots.Add(
                            currentTime);
                    }

currentTime =
                        currentTime.AddMinutes(
                            clinic.AppointmentDuration);
                }
            }

return availableSlots
                .Distinct()
                .OrderBy(x => x);
        }

// CREATE / BOOK APPOINTMENT
        public async Task CreateAsync(
            Appointment appointment)
        {
            // Validate patient
            var patient =
                await _userManager.FindByIdAsync(
                    appointment.PatientId);

if (patient == null)
            {
                throw new KeyNotFoundException(
                    "Patient not found.");
            }

// Validate clinic
            var clinic =
                await _clinicRepository
                    .GetByIdAsync(
                        appointment.ClinicId);

if (clinic == null ||
                clinic.IsDeleted ||
                !clinic.IsActive)
            {
                throw new InvalidOperationException(
                    "Clinic is not available for booking.");
            }

// Validate doctor
            var doctor =
                await _doctorRepository
                    .GetByIdAsync(
                        appointment.DoctorId);

if (doctor == null ||
                doctor.IsDeleted)
            {
                throw new KeyNotFoundException(
                    "Doctor not found.");
            }

if (!doctor.IsActive)
            {
                throw new InvalidOperationException(
                    "Doctor is not active.");
            }

if (!doctor.IsAvailable)
            {
                throw new InvalidOperationException(
                    "Doctor is currently unavailable.");
            }

// Doctor must belong to selected clinic
            if (doctor.ClinicId !=
                appointment.ClinicId)
            {
                throw new InvalidOperationException(
                    "Selected doctor does not belong to this clinic.");
            }

// Terms must be accepted
            if (!appointment.TermsAccepted)
            {
                throw new InvalidOperationException(
                    "Terms and conditions must be accepted.");
            }

// Date validation
            if (!IsValidAppointmentDate(
                    appointment.AppointmentDate))
            {
                throw new InvalidOperationException(
                    "Appointment date must be today or a future date and within 30 days.");
            }

// Time must be within clinic hours
            if (!IsWithinClinicHours(
                    appointment.AppointmentTime,
                    clinic))
            {
                throw new InvalidOperationException(
                    "Appointment time is outside clinic operating hours.");
            }

// Time must align with clinic duration
            if (!IsValidAppointmentSlot(
                    appointment.AppointmentTime,
                    clinic))
            {
                throw new InvalidOperationException(
                    "Appointment time is not a valid appointment slot.");
            }

// Doctor schedule validation
            var isDoctorAvailable =
                await IsDoctorAvailableAtTimeAsync(
                    doctor.Id,
                    appointment.AppointmentDate.DayOfWeek,
                    appointment.AppointmentTime,
                    clinic.AppointmentDuration);

if (!isDoctorAvailable)
            {
                throw new InvalidOperationException(
                    "Doctor is not available at the selected time.");
            }

// Maximum 3 concurrent appointments
            var concurrentAppointments =
                await _appointmentRepository
                    .GetConcurrentAppointmentCountAsync(
                        appointment.PatientId);

if (concurrentAppointments >= 3)
            {
                throw new InvalidOperationException(
                    "Patient cannot have more than 3 concurrent appointments.");
            }

// Prevent overlapping appointment
            var hasOverlap =
                await HasOverlappingAppointmentAsync(
                    appointment.PatientId,
                    appointment.DoctorId,
                    appointment.AppointmentDate,
                    appointment.AppointmentTime,
                    clinic.AppointmentDuration);

if (hasOverlap)
            {
                throw new InvalidOperationException(
                    "Patient already has an overlapping appointment with this doctor.");
            }

// Prevent doctor slot double booking
            var doctorSlotBooked =
                await IsDoctorSlotBookedAsync(
                    appointment.DoctorId,
                    appointment.AppointmentDate,
                    appointment.AppointmentTime,
                    clinic.AppointmentDuration);

if (doctorSlotBooked)
            {
                throw new InvalidOperationException(
                    "The selected doctor slot is already booked.");
            }

// Copy current consultation fee
            appointment.ConsultationFee =
                doctor.ConsultationFee;

appointment.CancellationFee = 0;

appointment.BookedOn =
                DateTime.UtcNow;

appointment.Status =
                AppointmentStatus.Scheduled;

appointment.CreatedDate =
                DateTime.UtcNow;

appointment.UpdatedDate = null;

await _appointmentRepository
                .AddAsync(appointment);

await _appointmentRepository
                .SaveChangesAsync();
        }

// UPDATE APPOINTMENT STATUS
        public async Task UpdateStatusAsync(
            int appointmentId,
            AppointmentStatus status)
        {
            var appointment =
                await _appointmentRepository
                    .GetByIdAsync(appointmentId);

if (appointment == null)
            {
                throw new KeyNotFoundException(
                    "Appointment not found.");
            }

if (!IsValidStatusTransition(
                    appointment.Status,
                    status))
            {
                throw new InvalidOperationException(
                    $"Appointment cannot be changed from " +
                    $"{appointment.Status} to {status}.");
            }

appointment.Status = status;

appointment.UpdatedDate =
                DateTime.UtcNow;

await _appointmentRepository
                .UpdateAsync(appointment);

await _appointmentRepository
                .SaveChangesAsync();
        }

// CANCEL APPOINTMENT
        public async Task CancelAsync(
            int appointmentId,
            string patientId,
            string? reason)
        {
            var appointment =
                await _appointmentRepository
                    .GetByIdAsync(appointmentId);

if (appointment == null)
            {
                throw new KeyNotFoundException(
                    "Appointment not found.");
            }

// Patient can only cancel own appointment
            if (appointment.PatientId != patientId)
            {
                throw new UnauthorizedAccessException(
                    "You cannot cancel this appointment.");
            }

// Only Scheduled can be cancelled
            if (appointment.Status !=
                AppointmentStatus.Scheduled)
            {
                if (appointment.Status ==
                    AppointmentStatus.CheckedIn)
                {
                    throw new InvalidOperationException(
                        "Checked-In appointment cannot be cancelled.");
                }

throw new InvalidOperationException(
                    "Only scheduled appointments can be cancelled.");
            }

var appointmentDateTime =
                appointment.AppointmentDate.Date
                .Add(appointment.AppointmentTime
                    .ToTimeSpan());

var hoursRemaining =
                (appointmentDateTime -
                 DateTime.Now).TotalHours;

// More than 24 hours = no fee
            if (hoursRemaining > 24)
            {
                appointment.CancellationFee = 0;
            }
            else
            {
                // Less than or equal to 24 hours
                // = 50% non-refundable fee
                appointment.CancellationFee =
                    appointment.ConsultationFee * 0.50m;
            }

appointment.Status =
                AppointmentStatus.Cancelled;

appointment.CancelledOn =
                DateTime.UtcNow;

appointment.CancellationReason =
                reason;

appointment.UpdatedDate =
                DateTime.UtcNow;

await _appointmentRepository
                .UpdateAsync(appointment);

await _appointmentRepository
                .SaveChangesAsync();
        }

// RESCHEDULE APPOINTMENT
        public async Task RescheduleAsync(
            int appointmentId,
            DateTime appointmentDate,
            TimeOnly appointmentTime,
            string patientId)
        {
            var appointment =
                await _appointmentRepository
                    .GetByIdAsync(appointmentId);

if (appointment == null)
            {
                throw new KeyNotFoundException(
                    "Appointment not found.");
            }

// Patient can only reschedule own appointment
            if (appointment.PatientId != patientId)
            {
                throw new UnauthorizedAccessException(
                    "You cannot reschedule this appointment.");
            }

// Only Scheduled appointments can be rescheduled
            if (appointment.Status !=
                AppointmentStatus.Scheduled)
            {
                throw new InvalidOperationException(
                    "Only scheduled appointments can be rescheduled.");
            }

var clinic =
                await _clinicRepository
                    .GetByIdAsync(
                        appointment.ClinicId);

var doctor =
                await _doctorRepository
                    .GetByIdAsync(
                        appointment.DoctorId);

if (doctor == null ||
                doctor.IsDeleted)
            {
                throw new KeyNotFoundException(
                    "Doctor not found.");
            }

if (!doctor.IsActive ||
                !doctor.IsAvailable)
            {
                throw new InvalidOperationException(
                    "Doctor is currently unavailable.");
            }

// Date validation
            if (!IsValidAppointmentDate(
                    appointmentDate))
            {
                throw new InvalidOperationException(
                    "Appointment date must be today or a future date and within 30 days.");
            }

// Clinic hours
            if (!IsWithinClinicHours(
                    appointmentTime,
                    clinic))
            {
                throw new InvalidOperationException(
                    "Appointment time is outside clinic operating hours.");
            }

// Valid slot
            if (!IsValidAppointmentSlot(
                    appointmentTime,
                    clinic))
            {
                throw new InvalidOperationException(
                    "Appointment time is not a valid appointment slot.");
            }

// Doctor schedule
            var doctorAvailable =
                await IsDoctorAvailableAtTimeAsync(
                    doctor.Id,
                    appointmentDate.DayOfWeek,
                    appointmentTime,
                    clinic.AppointmentDuration);

if (!doctorAvailable)
            {
                throw new InvalidOperationException(
                    "Doctor is not available at the selected time.");
            }

// Check patient + doctor overlap
            var hasOverlap =
                await HasOverlappingAppointmentAsync(
                    appointment.PatientId,
                    appointment.DoctorId,
                    appointmentDate,
                    appointmentTime,
                    clinic.AppointmentDuration,
                    appointment.Id);

if (hasOverlap)
            {
                throw new InvalidOperationException(
                    "Patient already has an overlapping appointment with this doctor.");
            }

// Check doctor slot
            var slotBooked =
                await IsDoctorSlotBookedAsync(
                    appointment.DoctorId,
                    appointmentDate,
                    appointmentTime,
                    clinic.AppointmentDuration,
                    appointment.Id);

if (slotBooked)
            {
                throw new InvalidOperationException(
                    "The selected doctor slot is already booked.");
            }

appointment.AppointmentDate =
                appointmentDate;

appointment.AppointmentTime =
                appointmentTime;

appointment.UpdatedDate =
                DateTime.UtcNow;

await _appointmentRepository
                .UpdateAsync(appointment);

await _appointmentRepository
                .SaveChangesAsync();
        }

// ---------------------------------------------------------
        // PRIVATE BUSINESS LOGIC
        // ---------------------------------------------------------

// Validate appointment date
        private bool IsValidAppointmentDate(
            DateTime appointmentDate)
        {
            var today =
                DateTime.Now.Date;

var maximumDate =
                today.AddDays(30);

return appointmentDate.Date >= today
                &&
                appointmentDate.Date <= maximumDate;
        }

// Check clinic operating hours
        private bool IsWithinClinicHours(
            TimeOnly appointmentTime,
            Clinic clinic)
        {
            var appointmentEnd =
                appointmentTime.AddMinutes(
                    clinic.AppointmentDuration);

return appointmentTime >=
                   clinic.OpeningTime
                   &&
                   appointmentEnd <=
                   clinic.ClosingTime;
        }

// Check whether appointment time
        // is aligned with clinic duration
        private bool IsValidAppointmentSlot(
            TimeOnly appointmentTime,
            Clinic clinic)
        {
            var minutesFromOpening =
                appointmentTime.ToTimeSpan()
                .Subtract(
                    clinic.OpeningTime.ToTimeSpan())
                .TotalMinutes;

if (minutesFromOpening < 0)
            {
                return false;
            }

return minutesFromOpening %
                       clinic.AppointmentDuration
                   == 0;
        }

// Check doctor's weekly schedule
        private async Task<bool>
            IsDoctorAvailableAtTimeAsync(
                int doctorId,
                DayOfWeek dayOfWeek,
                TimeOnly appointmentTime,
                int appointmentDuration)
        {
            var availabilities =
                await _availabilityRepository
                    .GetAvailableSlotsAsync(
                        doctorId,
                        dayOfWeek);

foreach (var availability in availabilities)
            {
                if (!availability.IsAvailable)
                {
                    continue;
                }

var appointmentEnd =
                    appointmentTime.AddMinutes(
                        appointmentDuration);

if (appointmentTime >=
                    availability.StartTime
                    &&
                    appointmentEnd <=
                    availability.EndTime)
                {
                    return true;
                }
            }

return false;
        }

// Check patient + doctor overlapping appointment
        private async Task<bool>
            HasOverlappingAppointmentAsync(
                string patientId,
                int doctorId,
                DateTime appointmentDate,
                TimeOnly appointmentTime,
                int appointmentDuration,
                int? excludeAppointmentId = null)
        {
            var appointments =
                await _appointmentRepository
                    .GetByPatientAsync(patientId);

var newStart =
                appointmentTime.ToTimeSpan();

var newEnd =
                appointmentTime
                    .AddMinutes(appointmentDuration)
                    .ToTimeSpan();

foreach (var existing in appointments)
            {
                if (excludeAppointmentId.HasValue &&
                    existing.Id ==
                    excludeAppointmentId.Value)
                {
                    continue;
                }

if (existing.DoctorId != doctorId)
                {
                    continue;
                }

if (existing.AppointmentDate.Date !=
                    appointmentDate.Date)
                {
                    continue;
                }

if (existing.Status !=
                        AppointmentStatus.Scheduled
                    &&
                    existing.Status !=
                        AppointmentStatus.CheckedIn)
                {
                    continue;
                }

var existingStart =
                    existing.AppointmentTime
                        .ToTimeSpan();

var existingEnd =
                    existing.AppointmentTime
                        .AddMinutes(
                            appointmentDuration)
                        .ToTimeSpan();

if (newStart < existingEnd &&
                    existingStart < newEnd)
                {
                    return true;
                }
            }

return false;
        }

// Check whether doctor slot is already booked
        private async Task<bool>
            IsDoctorSlotBookedAsync(
                int doctorId,
                DateTime appointmentDate,
                TimeOnly appointmentTime,
                int appointmentDuration,
                int? excludeAppointmentId = null)
        {
            var appointments =
                await _appointmentRepository
                    .GetByDoctorAsync(doctorId);

var newStart =
                appointmentTime.ToTimeSpan();

var newEnd =
                appointmentTime
                    .AddMinutes(appointmentDuration)
                    .ToTimeSpan();

if (existing.AppointmentDate.Date !=
                    appointmentDate.Date)
                {
                    continue;
                }

var existingStart =
                    existing.AppointmentTime
                        .ToTimeSpan();

var existingEnd =
                    existing.AppointmentTime
                        .AddMinutes(
                            appointmentDuration)
                        .ToTimeSpan();

if (newStart < existingEnd &&
                    existingStart < newEnd)
                {
                    return true;
                }
            }

return false;
        }

// Validate appointment status transition
        private bool IsValidStatusTransition(
            AppointmentStatus currentStatus,
            AppointmentStatus newStatus)
        {
            return currentStatus switch
            {
                AppointmentStatus.Scheduled =>
                    newStatus ==
                        AppointmentStatus.CheckedIn
                    ||
                    newStatus ==
                        AppointmentStatus.Cancelled
                    ||
                    newStatus ==
                        AppointmentStatus.NoShow,

AppointmentStatus.CheckedIn =>
                    newStatus ==
                        AppointmentStatus.Completed,

_ => false
            };
        }

// Check time overlap
        private bool IsTimeOverlapping(
            TimeOnly firstStart,
            TimeOnly firstEnd,
            TimeOnly secondStart,
            TimeOnly secondEnd)
        {
            return firstStart < secondEnd
                &&
                secondStart < firstEnd;
        }
    }
}

using MedicalClinicManagementSystem.Models;

namespace MedicalClinicManagementSystem.Services.Interfaces
{
    public interface IPrescriptionService
    {
        Task<Prescription?> GetByIdAsync(int id);

Task<Prescription?> GetByAppointmentIdAsync(
            int appointmentId);

Task CreateAsync(
            Prescription prescription);

Task UpdateAsync(
            Prescription prescription);
    }
}

using MedicalClinicManagementSystem.Models;
using MedicalClinicManagementSystem.Repositories.Interfaces;
using MedicalClinicManagementSystem.Services.Interfaces;

namespace MedicalClinicManagementSystem.Services.Implementations
{
    public class PrescriptionService : IPrescriptionService
    {
        private readonly IPrescriptionRepository
            _prescriptionRepository;

private readonly IAppointmentRepository
            _appointmentRepository;

public PrescriptionService(
            IPrescriptionRepository prescriptionRepository,
            IAppointmentRepository appointmentRepository)
        {
            _prescriptionRepository =
                prescriptionRepository;

_appointmentRepository =
                appointmentRepository;
        }

// GET PRESCRIPTION BY ID
        public async Task<Prescription?>
            GetByIdAsync(int id)
        {
            return await _prescriptionRepository
                .GetByIdAsync(id);
        }

// GET PRESCRIPTION BY APPOINTMENT
        public async Task<Prescription?>
            GetByAppointmentIdAsync(
                int appointmentId)
        {
            var appointment =
                await _appointmentRepository
                    .GetByIdAsync(appointmentId);

if (appointment == null)
            {
                throw new KeyNotFoundException(
                    "Appointment not found.");
            }

return await _prescriptionRepository
                .GetByAppointmentId(appointmentId);
        }

// CREATE PRESCRIPTION
        public async Task CreateAsync(
            Prescription prescription)
        {
            // Check appointment
            var appointment =
                await _appointmentRepository
                    .GetByIdAsync(
                        prescription.AppointmentId);

if (appointment == null)
            {
                throw new KeyNotFoundException(
                    "Appointment not found.");
            }

// Prescription only after completed appointment
            if (appointment.Status !=
                AppointmentStatus.Completed)
            {
                throw new InvalidOperationException(
                    "Prescription can only be issued for a completed appointment.");
            }

// Only one prescription per appointment
            var existingPrescription =
                await _prescriptionRepository
                    .GetByAppointmentId(
                        prescription.AppointmentId);

if (existingPrescription != null)
            {
                throw new InvalidOperationException(
                    "A prescription already exists for this appointment.");
            }

// Set system-generated fields
            prescription.PrescriptionDate =
                DateTime.UtcNow;

prescription.CreatedDate =
                DateTime.UtcNow;

await _prescriptionRepository
                .AddAsync(prescription);

await _prescriptionRepository
                .SaveChangesAsync();
        }

// UPDATE PRESCRIPTION
        public async Task UpdateAsync(
            Prescription prescription)
        {
            // Get existing prescription
            var existingPrescription =
                await _prescriptionRepository
                    .GetByIdAsync(
                        prescription.Id);

if (existingPrescription == null)
            {
                throw new KeyNotFoundException(
                    "Prescription not found.");
            }

// Check associated appointment
            var appointment =
                await _appointmentRepository
                    .GetByIdAsync(
                        existingPrescription.AppointmentId);

if (appointment == null)
            {
                throw new KeyNotFoundException(
                    "Appointment not found.");
            }

// Prescription belongs to completed appointment
            if (appointment.Status !=
                AppointmentStatus.Completed)
            {
                throw new InvalidOperationException(
                    "Prescription can only be updated for a completed appointment.");
            }

// Appointment should not be changed
            if (prescription.AppointmentId !=
                existingPrescription.AppointmentId)
            {
                throw new InvalidOperationException(
                    "Prescription appointment cannot be changed.");
            }

// Update prescription details
            existingPrescription.Diagnosis =
                prescription.Diagnosis;

existingPrescription.Medicines =
                prescription.Medicines;

existingPrescription.Instructions =
                prescription.Instructions;

existingPrescription.PrescriptionDate =
                DateTime.UtcNow;

await _prescriptionRepository
                .UpdateAsync(existingPrescription);

await _prescriptionRepository
                .SaveChangesAsync();
        }
    }
}

using MedicalClinicManagementSystem.Models;

namespace MedicalClinicManagementSystem.Services.Interfaces
{
    public interface IMedicalRecordService
    {
        Task<MedicalRecord?> GetByIdAsync(int id);

Task<IEnumerable<MedicalRecord>>
            GetByPatientAsync(string patientId);

Task<IEnumerable<MedicalRecord>>
            GetByAppointmentAsync(int appointmentId);

Task CreateAsync(
            MedicalRecord medicalRecord);

Task UpdateAsync(
            MedicalRecord medicalRecord);
    }
}

using MedicalClinicManagementSystem.Models;
using MedicalClinicManagementSystem.Repositories.Interfaces;
using MedicalClinicManagementSystem.Services.Interfaces;
using Microsoft.AspNetCore.Identity;

namespace MedicalClinicManagementSystem.Services.Implementations
{
    public class MedicalRecordService : IMedicalRecordService
    {
        private readonly IMedicalRecordRepository
            _medicalRecordRepository;

private readonly IAppointmentRepository
            _appointmentRepository;

private readonly UserManager<ApplicationUser>
            _userManager;

public MedicalRecordService(
            IMedicalRecordRepository medicalRecordRepository,
            IAppointmentRepository appointmentRepository,
            UserManager<ApplicationUser> userManager)
        {
            _medicalRecordRepository =
                medicalRecordRepository;

_appointmentRepository =
                appointmentRepository;

_userManager =
                userManager;
        }

// GET BY ID
        public async Task<MedicalRecord?>
            GetByIdAsync(int id)
        {
            return await _medicalRecordRepository
                .GetByIdAsync(id);
        }

// GET PATIENT MEDICAL RECORDS
        public async Task<IEnumerable<MedicalRecord>>
            GetByPatientAsync(string patientId)
        {
            // Check patient exists
            var patient =
                await _userManager
                    .FindByIdAsync(patientId);

if (patient == null)
            {
                throw new KeyNotFoundException(
                    "Patient not found.");
            }

return await _medicalRecordRepository
                .GetByPatientAsync(patientId);
        }

// GET RECORDS BY APPOINTMENT
        public async Task<IEnumerable<MedicalRecord>>
            GetByAppointmentAsync(int appointmentId)
        {
            // Check appointment exists
            var appointment =
                await _appointmentRepository
                    .GetByIdAsync(appointmentId);

if (appointment == null)
            {
                throw new KeyNotFoundException(
                    "Appointment not found.");
            }

return await _medicalRecordRepository
                .GetByAppointmentAsync(appointmentId);
        }

// CREATE MEDICAL RECORD
        public async Task CreateAsync(
            MedicalRecord medicalRecord)
        {
            // Check patient exists
            var patient =
                await _userManager
                    .FindByIdAsync(
                        medicalRecord.PatientId);

if (patient == null)
            {
                throw new KeyNotFoundException(
                    "Patient not found.");
            }

// If appointment is provided,
            // validate appointment
            if (medicalRecord.AppointmentId.HasValue)
            {
                var appointment =
                    await _appointmentRepository
                        .GetByIdAsync(
                            medicalRecord.AppointmentId.Value);

if (appointment == null)
                {
                    throw new KeyNotFoundException(
                        "Appointment not found.");
                }

// Appointment must belong
                // to the same patient
                if (appointment.PatientId !=
                    medicalRecord.PatientId)
                {
                    throw new InvalidOperationException(
                        "The appointment does not belong to this patient.");
                }
            }

// System generated fields
            medicalRecord.RecordDate =
                DateTime.UtcNow;

medicalRecord.CreatedDate =
                DateTime.UtcNow;

await _medicalRecordRepository
                .AddAsync(medicalRecord);

await _medicalRecordRepository
                .SaveChangesAsync();
        }

// UPDATE MEDICAL RECORD
        public async Task UpdateAsync(
            MedicalRecord medicalRecord)
        {
            // Get existing record
            var existingRecord =
                await _medicalRecordRepository
                    .GetByIdAsync(
                        medicalRecord.Id);

if (existingRecord == null)
            {
                throw new KeyNotFoundException(
                    "Medical record not found.");
            }

// Patient cannot be changed
            if (existingRecord.PatientId !=
                medicalRecord.PatientId)
            {
                throw new InvalidOperationException(
                    "Medical record patient cannot be changed.");
            }

if (appointment == null)
                {
                    throw new KeyNotFoundException(
                        "Appointment not found.");
                }

// Appointment must belong
                // to same patient
                if (appointment.PatientId !=
                    existingRecord.PatientId)
                {
                    throw new InvalidOperationException(
                        "The appointment does not belong to this patient.");
                }
            }

// Update editable fields
            existingRecord.AppointmentId =
                medicalRecord.AppointmentId;

existingRecord.RecordType =
                medicalRecord.RecordType;

existingRecord.Diagnosis =
                medicalRecord.Diagnosis;

existingRecord.Description =
                medicalRecord.Description;

existingRecord.RecordDate =
                DateTime.UtcNow;

existingRecord.UpdatedDate =
                DateTime.UtcNow;

await _medicalRecordRepository
                .UpdateAsync(existingRecord);

await _medicalRecordRepository
                .SaveChangesAsync();
        }
    }
}

namespace MedicalClinicManagementSystem.Services.Interfaces
{
    public interface IDashboardService
    {
        Task<int> GetTotalAppointmentsAsync();

Task<double> GetPatientNoShowRateAsync();

Task<double> GetClinicOccupancyRateAsync();

Task<decimal> GetConsultationRevenueAsync();
    }
}

using MedicalClinicManagementSystem.Models;
using MedicalClinicManagementSystem.Repositories.Interfaces;
using MedicalClinicManagementSystem.Services.Interfaces;

namespace MedicalClinicManagementSystem.Services.Implementations
{
    public class DashboardService : IDashboardService
    {
        private readonly IAppointmentRepository
            _appointmentRepository;

private readonly IClinicRepository
            _clinicRepository;

private readonly IDoctorRepository
            _doctorRepository;

private readonly IDoctorAvailabilityRepository
            _availabilityRepository;

public DashboardService(
            IAppointmentRepository appointmentRepository,
            IClinicRepository clinicRepository,
            IDoctorRepository doctorRepository,
            IDoctorAvailabilityRepository availabilityRepository)
        {
            _appointmentRepository =
                appointmentRepository;

_clinicRepository =
                clinicRepository;

_doctorRepository =
                doctorRepository;

_availabilityRepository =
                availabilityRepository;
        }

// TOTAL APPOINTMENTS
        public async Task<int>
            GetTotalAppointmentsAsync()
        {
            var appointments =
                await _appointmentRepository
                    .GetAllAsync();

return appointments.Count();
        }

// PATIENT NO-SHOW RATE
        public async Task<double>
            GetPatientNoShowRateAsync()
        {
            var appointments =
                await _appointmentRepository
                    .GetAllAsync();

var completedOrNoShow =
                appointments.Count(x =>
                    x.Status ==
                        AppointmentStatus.Completed
                    ||
                    x.Status ==
                        AppointmentStatus.NoShow);

if (completedOrNoShow == 0)
            {
                return 0;
            }

var noShowCount =
                appointments.Count(x =>
                    x.Status ==
                    AppointmentStatus.NoShow);

return
                (double)noShowCount
                /
                completedOrNoShow
                *
                100;
        }

// CLINIC OCCUPANCY RATE
        public async Task<double>
            GetClinicOccupancyRateAsync()
        {
            var clinics =
                await _clinicRepository
                    .GetActiveClinicsAsync();

var totalAvailableSlots = 0;

var totalBookedSlots = 0;

foreach (var clinic in clinics)
            {
                var doctors =
                    await _doctorRepository
                        .GetAvailableDoctorsAsync(
                            clinic.Id);

foreach (var doctor in doctors)
                {
                    var availabilities =
                        await _availabilityRepository
                            .GetByDoctorAsync(
                                doctor.Id);

foreach (var availability
                        in availabilities)
                    {
                        if (!availability.IsAvailable)
                        {
                            continue;
                        }

var duration =
                            clinic.AppointmentDuration;

var availableMinutes =
                            (
                                availability.EndTime
                                .ToTimeSpan()
                                -
                                availability.StartTime
                                .ToTimeSpan()
                            ).TotalMinutes;

if (availableMinutes <= 0)
                        {
                            continue;
                        }

var slots =
                            (int)(
                                availableMinutes
                                /
                                duration);

totalAvailableSlots += slots;
                    }
                }
            }

var appointments =
                await _appointmentRepository
                    .GetActiveAppointmentsAsync();

totalBookedSlots =
                appointments.Count();

if (totalAvailableSlots == 0)
            {
                return 0;
            }

return
                (double)totalBookedSlots
                /
                totalAvailableSlots
                *
                100;
        }

// CONSULTATION REVENUE
        public async Task<decimal>
            GetConsultationRevenueAsync()
        {
            var appointments =
                await _appointmentRepository
                    .GetAllAsync();

return appointments
                .Where(x =>
                    x.Status ==
                    AppointmentStatus.Completed)
                .Sum(x => x.ConsultationFee);
        }
    }
} -->

Related Examples

Automation that delivers real results
We design high modern UI

Alif Bima Pradana

8 months ago

534
Moving Background Animation

$$@(\/)(\/)¥$ $@(\/)(\/)¥

1 year ago

4.3k
3d Box
Let's build a 3d world empowered by Orgin Dreams.these are 3d objects

ORGIN_DREAMS

1 year ago

1.8k
Responsive Multi-Tier Pricing Table Component
flexible and responsive 3-tier pricing table component built with HTML and Tailwind CSS. Features distinct visual styles for different plans (e.g., highlighting a recommended option), adapts to various screen sizes, and supports both light and dark color schemes. Uses generic placeholders for easy adaptation to any product or service.

Hamza Atig

1 year ago

2k
Hero Section
Responsive Hero Section for you Project Background Image: A stunning, high-quality Unsplash photo that creates a unique visual impact. Overlay: Semi-transparent black overlay with blur effect for readability and a modern aesthetic. Content Area: Centered with a gradient background overlay for contrast, bold headline, engaging subtext. Buttons: Vibrant gradient and clean border with smooth hover animations to draw attention. Responsive Design: Looks great on all screen sizes with adaptable padding and font sizes.

KULDEEP

1 year ago

2.5k
blog component
good blog

Uwera Dorcas

1 year ago

1.4k
tiny fishing
fun fishing

Abel Wright

7 months ago

235
Spinner
The Spinner is a simple and visually appealing component that indicates ongoing processes like loading or data fetching. It's a great way to improve user engagement and reduce frustration during wait times. Different styles and animations (circular, dots, pulsating). Customizable size, color, and speed. Easy to integrate with loading states in any app. Lightweight and responsive.

Abhiraj

1 year ago

2.4k
Engineering Project Dashboard
Track engineering assignments, project progress, technology stack, and delivery timelines in one simple dashboard.

Ayyamperumal S

7 months ago

531
Elegant Dock
Useful Tailwind classes for constructing a basic Dock (usually used on mobile).

Nick Girga

1 year ago

1.4k
htmlcss0

Anonymous

1 year ago

1.1k
form1

Anonymous

3 days ago

8