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 169

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

Responsive Multi-Step Registration
Responsive Multi-Step Registration

Tanvir Hasan Bappy (Tanvir)

1 year ago

2.4k
chatbot
is my chatbot

Omer fils ELENGA

11 months ago

1.3k
OTP Verification Page

JUGENDRA GANGWAR

3 weeks ago

20
Text Overlay Effect
This is a text overlay effect, featuring a subtle background title and a prominent foreground heading. This design enhances visual interest while maintaining a clean, modern aesthetic.

Anum Shahana

1 year ago

2.3k
Font testing
comparing old fonts to tailwind with clamp sizing

Sherry Lynne

2 months ago

359
tab5
table

Anonymous

3 weeks ago

28
Modern Architecture Blog & News Grid UI Layout
A clean, minimal, and fully responsive Blog/News grid layout built with Tailwind CSS. Features a 2-column article grid with fixed title alignment, clean pagination, and a sticky sidebar with categories & CTA widget. Perfect for architectural firms, magazine portals, and CMS integrations.

Alief Malik

2 months ago

108
Show credit card details

Manuela Bianka

3 years ago

13.2k
Swiss-Grid Dark Pricing
A brutally minimalist pricing section that relies on strict grid architecture and typographic hierarchy instead of decorative elements. Features responsive border collapsing, monospaced technical accents, and high-performance CSS-only hover states. Designed for high-end SaaS, dev-tools, or agency portfolios that prioritize data clarity and structural rhythm.

Hamza Atig

9 months ago

827
Fake Medicine Detector
Fake Medicine Detector

Tanvir Hasan Bappy (Tanvir)

1 year ago

1.1k
Soft Lights & Slow Beats
Sink into the tranquil rhythms of a Sunday afternoon. This playlist blends soft melodies and gentle beats to create a mysterious yet comforting atmosphere — perfect for relaxing, reflecting, or simply unwinding as the day fades away.

Bonimater

1 year ago

1.1k
Background image section

Marc

2 years ago

7.4k