loginForm2

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 3

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.Repositories.Interfaces
{
    public interface IClinicRepository
    {
        Task<Clinic?> GetByIdAsync(int id);

Task<Clinic?> GetByCodeAsync(string clinicCode);

Task<IEnumerable<Clinic>> GetAllAsync();

Task<IEnumerable<Clinic>> GetActiveClinicsAsync();

Task AddAsync(Clinic clinic);

Task UpdateAsync(Clinic clinic);

Task<bool> HasActiveAppointmentsAsync(int clinicId);

Task<bool> HasPatientRecordsAsync(int clinicId);

Task SaveChangesAsync();
    }
}

using MedicalClinicManagementSystem.Models;

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

Task<Doctor?> GetByCodeAsync(string doctorCode);

Task<IEnumerable<Doctor>> GetAllAsync();

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

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

Task AddAsync(Doctor doctor);

Task UpdateAsync(Doctor doctor);

Task<bool> HasActiveAppointmentsAsync(int doctorId);

Task SaveChangesAsync();
    }
}

using MedicalClinicManagementSystem.Models;

namespace MedicalClinicManagementSystem.Repositories.Interfaces
{
    public interface IAppointmentRepository
    {
        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<Appointment>> GetActiveAppointmentsAsync();

Task AddAsync(Appointment appointment);

Task UpdateAsync(Appointment appointment);

Task<bool> HasOverlappingAppointmentAsync(
            string patientId,
            int doctorId,
            DateTime appointmentDate,
            TimeOnly appointmentTime);

Task<int> GetConcurrentAppointmentCountAsync(
            string patientId);

Task SaveChangesAsync();
    }
}

using MedicalClinicManagementSystem.Models;

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

Task<Prescription?> GetByAppointmentIdAsync(int appointmentId);

Task AddAsync(Prescription prescription);

Task UpdateAsync(Prescription prescription);

Task SaveChangesAsync();
    }
}

using MedicalClinicManagementSystem.Models;

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

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

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

Task AddAsync(MedicalRecord medicalRecord);

Task UpdateAsync(MedicalRecord medicalRecord);

Task SaveChangesAsync();
    }
}

public interface ISpecializationRepository
{
    Task<IEnumerable<MedicalSpecialization>> GetAllAsync();

Task<MedicalSpecialization?> GetByIdAsync(int id);
}

public interface IDoctorAvailabilityRepository
{
    Task<IEnumerable<DoctorAvailability>> GetByDoctorAsync(
        int doctorId);

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

Task AddAsync(DoctorAvailability availability);

Task UpdateAsync(DoctorAvailability availability);

Task SaveChangesAsync();
}

////
using MedicalClinicManagementSystem.Data;
using MedicalClinicManagementSystem.Models;
using MedicalClinicManagementSystem.Repositories.Interfaces;
using Microsoft.EntityFrameworkCore;

namespace MedicalClinicManagementSystem.Repositories.Implementations
{
    public class ClinicRepository : IClinicRepository
    {
        private readonly ApplicationDbContext _context;

public ClinicRepository(ApplicationDbContext context)
        {
            _context = context;
        }

public async Task<Clinic?> GetByIdAsync(int id)
        {
            return await _context.Clinics
                .Include(x => x.Doctors)
                .FirstOrDefaultAsync(x => x.Id == id);
        }

public async Task<Clinic?> GetByCodeAsync(string clinicCode)
        {
            return await _context.Clinics
                .FirstOrDefaultAsync(x => x.ClinicCode == clinicCode);
        }

public async Task<IEnumerable<Clinic>> GetAllAsync()
        {
            return await _context.Clinics
                .Include(x => x.Doctors)
                .ToListAsync();
        }

public async Task<IEnumerable<Clinic>> GetActiveClinicsAsync()
        {
            return await _context.Clinics
                .Include(x => x.Doctors)
                .Where(x => x.IsActive && !x.IsDeleted)
                .ToListAsync();
        }

public async Task AddAsync(Clinic clinic)
        {
            await _context.Clinics.AddAsync(clinic);
        }

public Task UpdateAsync(Clinic clinic)
        {
            _context.Clinics.Update(clinic);

return Task.CompletedTask;
        }

public async Task<bool> HasActiveAppointmentsAsync(int clinicId)
        {
            return await _context.Appointments
                .AnyAsync(x =>
                    x.ClinicId == clinicId &&
                    (x.Status == AppointmentStatus.Scheduled ||
                     x.Status == AppointmentStatus.CheckedIn));
        }

public async Task<bool> HasPatientRecordsAsync(int clinicId)
        {
            return await _context.MedicalRecords
                .AnyAsync(x =>
                    x.Appointment != null &&
                    x.Appointment.ClinicId == clinicId);
        }

public async Task SaveChangesAsync()
        {
            await _context.SaveChangesAsync();
        }
    }
}

using MedicalClinicManagementSystem.Data;
using MedicalClinicManagementSystem.Models;
using MedicalClinicManagementSystem.Repositories.Interfaces;
using Microsoft.EntityFrameworkCore;

namespace MedicalClinicManagementSystem.Repositories.Implementations
{
    public class DoctorRepository : IDoctorRepository
    {
        private readonly ApplicationDbContext _context;

public DoctorRepository(ApplicationDbContext context)
        {
            _context = context;
        }

public async Task<Doctor?> GetByIdAsync(int id)
        {
            return await _context.Doctors
                .Include(x => x.Clinic)
                .Include(x => x.Specialization)
                .Include(x => x.Availabilities)
                .FirstOrDefaultAsync(x => x.Id == id);
        }

public async Task<Doctor?> GetByCodeAsync(string doctorCode)
        {
            return await _context.Doctors
                .FirstOrDefaultAsync(x => x.DoctorCode == doctorCode);
        }

public async Task<IEnumerable<Doctor>> GetAllAsync()
        {
            return await _context.Doctors
                .Include(x => x.Clinic)
                .Include(x => x.Specialization)
                .ToListAsync();
        }

public async Task<IEnumerable<Doctor>> GetByClinicAsync(int clinicId)
        {
            return await _context.Doctors
                .Include(x => x.Specialization)
                .Where(x =>
                    x.ClinicId == clinicId &&
                    x.IsActive &&
                    !x.IsDeleted)
                .ToListAsync();
        }

public async Task<IEnumerable<Doctor>> GetAvailableDoctorsAsync(int clinicId)
        {
            return await _context.Doctors
                .Include(x => x.Specialization)
                .Where(x =>
                    x.ClinicId == clinicId &&
                    x.IsActive &&
                    x.IsAvailable &&
                    !x.IsDeleted)
                .ToListAsync();
        }

public async Task AddAsync(Doctor doctor)
        {
            await _context.Doctors.AddAsync(doctor);
        }

public Task UpdateAsync(Doctor doctor)
        {
            _context.Doctors.Update(doctor);

return Task.CompletedTask;
        }

public async Task<bool> HasActiveAppointmentsAsync(int doctorId)
        {
            return await _context.Appointments
                .AnyAsync(x =>
                    x.DoctorId == doctorId &&
                    (x.Status == AppointmentStatus.Scheduled ||
                     x.Status == AppointmentStatus.CheckedIn));
        }

public async Task SaveChangesAsync()
        {
            await _context.SaveChangesAsync();
        }
    }
}

using MedicalClinicManagementSystem.Data;
using MedicalClinicManagementSystem.Models;
using MedicalClinicManagementSystem.Repositories.Interfaces;
using Microsoft.EntityFrameworkCore;

namespace MedicalClinicManagementSystem.Repositories.Implementations
{
    public class DoctorAvailabilityRepository : IDoctorAvailabilityRepository
    {
        private readonly ApplicationDbContext _context;

public DoctorAvailabilityRepository(ApplicationDbContext context)
        {
            _context = context;
        }

public async Task<IEnumerable<DoctorAvailability>> GetByDoctorAsync(
            int doctorId)
        {
            return await _context.DoctorAvailabilities
                .Where(x => x.DoctorId == doctorId)
                .OrderBy(x => x.DayOfWeek)
                .ThenBy(x => x.StartTime)
                .ToListAsync();
        }

public async Task<IEnumerable<DoctorAvailability>> GetAvailableSlotsAsync(
            int doctorId,
            DayOfWeek dayOfWeek)
        {
            return await _context.DoctorAvailabilities
                .Where(x =>
                    x.DoctorId == doctorId &&
                    x.DayOfWeek == dayOfWeek &&
                    x.IsAvailable)
                .OrderBy(x => x.StartTime)
                .ToListAsync();
        }

public async Task AddAsync(DoctorAvailability availability)
        {
            await _context.DoctorAvailabilities
                .AddAsync(availability);
        }

public Task UpdateAsync(DoctorAvailability availability)
        {
            _context.DoctorAvailabilities.Update(availability);

return Task.CompletedTask;
        }

public async Task SaveChangesAsync()
        {
            await _context.SaveChangesAsync();
        }
    }
}

using MedicalClinicManagementSystem.Data;
using MedicalClinicManagementSystem.Models;
using MedicalClinicManagementSystem.Repositories.Interfaces;
using Microsoft.EntityFrameworkCore;

namespace MedicalClinicManagementSystem.Repositories.Implementations
{
    public class AppointmentRepository : IAppointmentRepository
    {
        private readonly ApplicationDbContext _context;

public AppointmentRepository(ApplicationDbContext context)
        {
            _context = context;
        }

public async Task<Appointment?> GetByIdAsync(int id)
        {
            return await _context.Appointments
                .Include(x => x.Patient)
                .Include(x => x.Clinic)
                .Include(x => x.Doctor)
                    .ThenInclude(x => x.Specialization)
                .Include(x => x.Prescription)
                .FirstOrDefaultAsync(x => x.Id == id);
        }

public async Task<IEnumerable<Appointment>> GetAllAsync()
        {
            return await _context.Appointments
                .Include(x => x.Patient)
                .Include(x => x.Clinic)
                .Include(x => x.Doctor)
                .ToListAsync();
        }

public async Task<IEnumerable<Appointment>> GetByPatientAsync(
            string patientId)
        {
            return await _context.Appointments
                .Include(x => x.Doctor)
                .Include(x => x.Clinic)
                .Include(x => x.Prescription)
                .Where(x => x.PatientId == patientId)
                .OrderByDescending(x => x.AppointmentDate)
                .ToListAsync();
        }

public async Task<IEnumerable<Appointment>> GetByDoctorAsync(
            int doctorId)
        {
            return await _context.Appointments
                .Include(x => x.Patient)
                .Include(x => x.Clinic)
                .Where(x => x.DoctorId == doctorId)
                .OrderBy(x => x.AppointmentDate)
                .ToListAsync();
        }

public async Task<IEnumerable<Appointment>> GetByClinicAsync(
            int clinicId)
        {
            return await _context.Appointments
                .Include(x => x.Patient)
                .Include(x => x.Doctor)
                .Where(x => x.ClinicId == clinicId)
                .OrderBy(x => x.AppointmentDate)
                .ToListAsync();
        }

public async Task<IEnumerable<Appointment>> GetActiveAppointmentsAsync()
        {
            return await _context.Appointments
                .Include(x => x.Patient)
                .Include(x => x.Clinic)
                .Include(x => x.Doctor)
                .Where(x =>
                    x.Status == AppointmentStatus.Scheduled ||
                    x.Status == AppointmentStatus.CheckedIn)
                .ToListAsync();
        }

public async Task AddAsync(Appointment appointment)
        {
            await _context.Appointments.AddAsync(appointment);
        }

public Task UpdateAsync(Appointment appointment)
        {
            _context.Appointments.Update(appointment);

return Task.CompletedTask;
        }

public async Task<bool> HasOverlappingAppointmentAsync(
            string patientId,
            int doctorId,
            DateTime appointmentDate,
            TimeOnly appointmentTime)
        {
            return await _context.Appointments
                .AnyAsync(x =>
                    x.PatientId == patientId &&
                    x.DoctorId == doctorId &&
                    x.AppointmentDate.Date == appointmentDate.Date &&
                    x.AppointmentTime == appointmentTime &&
                    (x.Status == AppointmentStatus.Scheduled ||
                     x.Status == AppointmentStatus.CheckedIn));
        }

public async Task<int> GetConcurrentAppointmentCountAsync(
            string patientId)
        {
            return await _context.Appointments
                .CountAsync(x =>
                    x.PatientId == patientId &&
                    (x.Status == AppointmentStatus.Scheduled ||
                     x.Status == AppointmentStatus.CheckedIn));
        }

public async Task SaveChangesAsync()
        {
            await _context.SaveChangesAsync();
        }
    }
}

using MedicalClinicManagementSystem.Data;
using MedicalClinicManagementSystem.Models;
using MedicalClinicManagementSystem.Repositories.Interfaces;
using Microsoft.EntityFrameworkCore;

namespace MedicalClinicManagementSystem.Repositories.Implementations
{
    public class PrescriptionRepository : IPrescriptionRepository
    {
        private readonly ApplicationDbContext _context;

public PrescriptionRepository(ApplicationDbContext context)
        {
            _context = context;
        }

public async Task<Prescription?> GetByIdAsync(int id)
        {
            return await _context.Prescriptions
                .Include(x => x.Appointment)
                    .ThenInclude(x => x.Patient)
                .Include(x => x.Appointment)
                    .ThenInclude(x => x.Doctor)
                .FirstOrDefaultAsync(x => x.Id == id);
        }

public async Task<Prescription?> GetByAppointmentIdAsync(
            int appointmentId)
        {
            return await _context.Prescriptions
                .Include(x => x.Appointment)
                    .ThenInclude(x => x.Patient)
                .Include(x => x.Appointment)
                    .ThenInclude(x => x.Doctor)
                .FirstOrDefaultAsync(x =>
                    x.AppointmentId == appointmentId);
        }

public async Task AddAsync(Prescription prescription)
        {
            await _context.Prescriptions
                .AddAsync(prescription);
        }

public Task UpdateAsync(Prescription prescription)
        {
            _context.Prescriptions.Update(prescription);

return Task.CompletedTask;
        }

public async Task SaveChangesAsync()
        {
            await _context.SaveChangesAsync();
        }
    }
}

using MedicalClinicManagementSystem.Data;
using MedicalClinicManagementSystem.Models;
using MedicalClinicManagementSystem.Repositories.Interfaces;
using Microsoft.EntityFrameworkCore;

namespace MedicalClinicManagementSystem.Repositories.Implementations
{
    public class MedicalRecordRepository : IMedicalRecordRepository
    {
        private readonly ApplicationDbContext _context;

public MedicalRecordRepository(ApplicationDbContext context)
        {
            _context = context;
        }

public async Task<MedicalRecord?> GetByIdAsync(int id)
        {
            return await _context.MedicalRecords
                .Include(x => x.Patient)
                .Include(x => x.Appointment)
                .FirstOrDefaultAsync(x => x.Id == id);
        }

public async Task<IEnumerable<MedicalRecord>> GetByPatientAsync(
            string patientId)
        {
            return await _context.MedicalRecords
                .Include(x => x.Appointment)
                .Include(x => x.Patient)
                .Where(x => x.PatientId == patientId)
                .OrderByDescending(x => x.RecordDate)
                .ToListAsync();
        }

public async Task<IEnumerable<MedicalRecord>> GetByAppointmentAsync(
            int appointmentId)
        {
            return await _context.MedicalRecords
                .Include(x => x.Patient)
                .Include(x => x.Appointment)
                .Where(x => x.AppointmentId == appointmentId)
                .ToListAsync();
        }

public async Task AddAsync(MedicalRecord medicalRecord)
        {
            await _context.MedicalRecords
                .AddAsync(medicalRecord);
        }

public Task UpdateAsync(MedicalRecord medicalRecord)
        {
            _context.MedicalRecords.Update(medicalRecord);

return Task.CompletedTask;
        }

public async Task SaveChangesAsync()
        {
            await _context.SaveChangesAsync();
        }
    }
}

-->

Related Examples

NFT Header with Hero

Abdul Baset Bappy

1 year ago

1.9k
pages / slides

MD Fardous Alom

1 year ago

2.2k
Stepper - Without Buttons

farisubuntu

2 years ago

2k
Coffee & Tea
Coffee: A brewed drink prepared from roasted seeds, called coffee beans, of the coffee plant. Tea: An agricultural product of the leaves, leaf buds, and internodes of various cultivars and sub-varieties of the Camellia sinensis plant, processed and cured using various methods.

Augustin

1 year ago

1.5k
Banner Page
Community Banner section code

Sayista Yazdani

1 month ago

147
Periodic Table with Tailwind CSS

Michael Andreuzza

2 years ago

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

ORGIN_DREAMS

1 year ago

1.8k
Show user details

Lucas Martinez

3 years ago

26.2k
Giftcard grid

ariaw

1 year ago

1.2k
Verify OTP
verification code

gidy

1 year ago

1.3k
AI Orb For Voice To Voice

Hamza Atig

6 months ago

820
Gaming UI Card, Form
A modern, senior-level gaming UI built with Tailwind CSS focusing on spacing, typography, and calm visual hierarchy rather than noisy effects. This component set includes: A premium gaming card with clear content structure and outcome-focused copy A clean player signup form with accessible focus states and minimal visual noise A custom animated button using a restrained light-sweep effect for premium interaction feedback Designed to resemble real production gaming platforms rather than demo or template UI. Fully responsive, copy-paste ready, and easy to extend for real-world projects.

Ayyamperumal S

8 months ago

614