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 261

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

InGen

Dennis Kamp

8 months ago

439
Comparison Pricing Table Component
A responsive pricing table built with HTML and Tailwind CSS, comparing two plans (Free and Unlimited) with a clear feature checklist. Includes distinct styling for the premium plan and a toggle for monthly/annual pricing display.

Hamza Atig

1 year ago

2.1k
Maintenance page template
The site is under maintenance placeholder page

Anonymous

2 years ago

12.5k
form2

Anonymous

3 weeks ago

6
Hero

Anonymous

1 month ago

30
visacardes
I'll create professional Visa card components with realistic styling and multiple card types

Anonymous

1 year ago

1.2k
Simple Payment Successfull Notification Page

Anonymous

1 year ago

2.5k
profile

Anonymous

1 month ago

4
Indie cross

Anonymous

1 week ago

11
Upvote downvote buttons [alpine]
upvote and downvote buttons made as working version in alpine.js

Anonymous

3 years ago

9.6k
Clean AI Chat UI with Tailwind CSS – ChatGPT-Style Interface
A polished and responsive AI chat interface built using modern Web Components and Tailwind CSS. This UI replicates the smooth, minimal experience of ChatGPT with a clean layout, floating input bar, animated scrollable message feed, and mock AI responses. Ideal for SaaS dashboards, AI assistants, or frontend prototypes. Designed with professional spacing, accessible colors, and reusable components. Key features: Responsive layout with mobile support Floating input bar with auto-expanding textarea Tailwind-powered message bubbles with clear sender roles Modern dark theme with subtle gradients and shadows Easily extendable to real AI APIs (e.g., OpenAI)

Ayyamperumal S

1 year ago

3k
Tag Input field
This code creates a dynamic tag input field using HTML, JavaScript, and TailwindCSS. Users can type tags into the input field and press "Enter" to add them. Each tag is displayed inside the input field as a styled container with a remove button. The tag input is limited to a maximum of 5 tags, and an error message is shown if the limit is exceeded. Users can remove tags to free up space for new ones. The input field and tags are styled using TailwindCSS, ensuring a clean and responsive design.

Anonymous

1 month ago

70