[V0_FILE]typescriptreact:file="app/register/page.tsx" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle, CardFooter } from "@/components/ui/card" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import { useToast } from "@/components/ui/use-toast" import { useAuth } from "@/contexts/auth-context" import Link from "next/link" import { useRouter } from "next/navigation" import { useState } from "react" export default function RegisterPage() { const [isLoading, setIsLoading] = useState(false) const { toast } = useToast() const router = useRouter() const { register } = useAuth() async function onSubmit(event: React.FormEvent) { event.preventDefault() try { setIsLoading(true) const formData = new FormData(event.currentTarget) await register({ name: formData.get("name") as string, email: formData.get("email") as string, password: formData.get("password") as string, role: formData.get("role") as "DOCTOR" | "PATIENT", }) toast({ title: "Success", description: "Account created successfully", }) router.push("/login") } catch (error) { toast({ variant: "destructive", title: "Error", description: "Something went wrong", }) } finally { setIsLoading(false) } } return (

Create an account Enter your information to create your account

) } [V0_FILE]typescriptreact:file="app/login/page.tsx" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardFooter, CardTitle } from "@/components/ui/card" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { useToast } from "@/components/ui/use-toast" import { useAuth } from "@/contexts/auth-context" import Link from "next/link" import { useRouter } from "next/navigation" import { useState } from "react" export default function LoginPage() { const [isLoading, setIsLoading] = useState(false) const { toast } = useToast() const router = useRouter() const { login } = useAuth() async function onSubmit(event: React.FormEvent) { event.preventDefault() try { setIsLoading(true) const formData = new FormData(event.currentTarget) await login(formData.get("email") as string, formData.get("password") as string) router.push("/dashboard") } catch (error) { toast({ variant: "destructive", title: "Error", description: "Invalid credentials", }) } finally { setIsLoading(false) } } return (

) } [V0_FILE]typescriptreact:file="app/dashboard/layout.tsx" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { Button } from "@/components/ui/button" import { useAuth } from "@/contexts/auth-context" import { Calendar, Clock, Home, LogOut, Settings, User } from "lucide-react" import Link from "next/link" import { useRouter } from "next/navigation" import { useEffect } from "react" import type React from "react" // Added import for React export default function DashboardLayout({ children, }: { children: React.ReactNode }) { const { user, logout } = useAuth() const router = useRouter() useEffect(() => { if (!user) { router.push("/login") } }, [user, router]) if (!user) { return null } return (

{/* Sidebar */}

{user.name}

{user.role}

{/* Main Content */}

{children}

) } [V0_FILE]typescriptreact:file="app/dashboard/page.tsx" isEdit="true" isMerged="true" "use client" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table" import { useAuth } from "@/contexts/auth-context" import { getAppointments } from "@/lib/storage" import { Calendar, Clock, Users } from "lucide-react" import Link from "next/link" import { useEffect, useState } from "react" export default function DashboardPage() { const { user } = useAuth() const [appointments, setAppointments] = useState([]) useEffect(() => { const allAppointments = getAppointments() const userAppointments = allAppointments.filter((apt) => user?.role === "DOCTOR" ? apt.doctorId === user.id : apt.patientId === user.id, ) setAppointments(userAppointments) }, [user]) const todayAppointments = appointments.filter( (apt) => new Date(apt.date).toDateString() === new Date().toDateString(), ) const upcomingAppointments = appointments.filter((apt) => new Date(apt.date) > new Date()).slice(0, 5) return (

Dashboard

Total Appointments

{appointments.length}

Today's Appointments

{todayAppointments.length}

Upcoming

{upcomingAppointments.length}

Upcoming Appointments Your next {upcomingAppointments.length} appointments {user?.role === "DOCTOR" ? "Patient" : "Doctor"} Date Time Type Status {upcomingAppointments.map((appointment) => ( {user?.role === "DOCTOR" ? appointment.patientName : appointment.doctorName} {new Date(appointment.date).toLocaleDateString()} {new Date(appointment.date).toLocaleTimeString()} {appointment.type} {appointment.status} ))}

) } [V0_FILE]typescriptreact:file="app/dashboard/appointments/new/page.tsx" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle, CardFooter } from "@/components/ui/card" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import { Textarea } from "@/components/ui/textarea" import { useToast } from "@/components/ui/use-toast" import { useAuth } from "@/contexts/auth-context" import { createAppointment, getUsers } from "@/lib/storage" import type { User } from "@/lib/types" import { useRouter } from "next/navigation" import { useEffect, useState } from "react" export default function NewAppointmentPage() { const [isLoading, setIsLoading] = useState(false) const [doctors, setDoctors] = useState([]) const { toast } = useToast() const router = useRouter() const { user } = useAuth() useEffect(() => { const allUsers = getUsers() const doctorsList = allUsers.filter((user) => user.role === "DOCTOR") setDoctors(doctorsList) }, []) async function onSubmit(event: React.FormEvent) { event.preventDefault() try { setIsLoading(true) const formData = new FormData(event.currentTarget) const date = formData.get("date") as string const time = formData.get("time") as string const type = formData.get("type") as string const notes = formData.get("notes") as string const doctorId = formData.get("doctorId") as string const selectedDoctor = doctors.find((d) => d.id === doctorId) if (!selectedDoctor) { throw new Error("Doctor not found") } createAppointment({ date: new Date(`${date}T${time}`).toISOString(), type: type as any, notes, status: "PENDING", doctorId, patientId: user!.id, doctorName: selectedDoctor.name, patientName: user!.name, }) toast({ title: "Success", description: "Appointment created successfully", }) router.push("/dashboard") } catch (error) { toast({ variant: "destructive", title: "Error", description: "Something went wrong", }) } finally { setIsLoading(false) } } if (user?.role === "DOCTOR") { return (

Not Available Doctors cannot create appointments. Please ask patients to book appointments.

) } return (

Book New Appointment Fill in the details below to schedule a new appointment

Select Doctor

Appointment Date

Preferred Time

Appointment Type

Notes

</div>
          </CardContent>
          <CardFooter className="flex justify-end space-x-4">
            <Button type="button" variant="outline" onClick={() => router.back()} disabled={isLoading}>
              Cancel
            </Button>
            <Button type="submit" disabled={isLoading}>
              {isLoading ? "Creating..." : "Book Appointment"}
            </Button>
          </CardFooter>
        </form>
      </Card>
    </div>
  )
}

[V0_FILE]typescriptreact:file="app/api/auth/[...nextauth]/route.ts" isMerged="true"
import { PrismaAdapter } from "@auth/prisma-adapter"
import { PrismaClient } from "@prisma/client"
import NextAuth from "next-auth"
import CredentialsProvider from "next-auth/providers/credentials"
import bcrypt from "bcryptjs"

const prisma = new PrismaClient()

const handler = NextAuth({
  adapter: PrismaAdapter(prisma),
  providers: [
    CredentialsProvider({
      name: "Credentials",
      credentials: {
        email: { label: "Email", type: "email" },
        password: { label: "Password", type: "password" },
      },
      async authorize(credentials) {
        if (!credentials?.email || !credentials?.password) {
          throw new Error("Invalid credentials")
        }

const user = await prisma.user.findUnique({
          where: {
            email: credentials.email,
          },
        })

if (!user || !user?.password) {
          throw new Error("Invalid credentials")
        }

const isCorrectPassword = await bcrypt.compare(credentials.password, user.password)

if (!isCorrectPassword) {
          throw new Error("Invalid credentials")
        }

return {
          id: user.id,
          email: user.email,
          name: user.name,
          role: user.role,
        }
      },
    }),
  ],
  session: {
    strategy: "jwt",
  },
  pages: {
    signIn: "/login",
  },
  callbacks: {
    async session({ session, token }) {
      if (token && session.user) {
        session.user.id = token.sub
        session.user.role = token.role
      }
      return session
    },
    async jwt({ token, user }) {
      if (user) {
        token.role = user.role
      }
      return token
    },
  },
})

export { handler as GET, handler as POST }

[V0_FILE]plaintext:file="prisma/schema.prisma" isMerged="true"
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model User {
  id            String    @id @default(cuid())
  name          String
  email         String    @unique
  password      String
  role          String    // "DOCTOR" or "PATIENT"
  speciality    String?   // Only for doctors
  appointments  Appointment[] @relation("DoctorAppointments")
  bookings      Appointment[] @relation("PatientAppointments")
  createdAt     DateTime  @default(now())
  updatedAt     DateTime  @updatedAt
}

model Appointment {
  id          String    @id @default(cuid())
  date        DateTime
  status      String    // "PENDING", "CONFIRMED", "CANCELLED", "COMPLETED"
  type        String    // "CHECKUP", "FOLLOWUP", "CONSULTATION", "EMERGENCY"
  notes       String?
  doctorId    String
  patientId   String
  doctor      User      @relation("DoctorAppointments", fields: [doctorId], references: [id])
  patient     User      @relation("PatientAppointments", fields: [patientId], references: [id])
  createdAt   DateTime  @default(now())
  updatedAt   DateTime  @updatedAt
}

[V0_FILE]typescript:file="app/actions/auth.ts" isMerged="true"
"use server"

import { PrismaClient } from "@prisma/client"
import bcrypt from "bcryptjs"

const prisma = new PrismaClient()

export async function register(formData: FormData) {
  try {
    const email = formData.get("email") as string
    const password = formData.get("password") as string
    const name = formData.get("name") as string
    const role = formData.get("role") as string

// Check if user exists
    const existingUser = await prisma.user.findUnique({
      where: { email },
    })

if (existingUser) {
      return { error: "User already exists" }
    }

// Hash password
    const hashedPassword = await bcrypt.hash(password, 10)

// Create user
    const user = await prisma.user.create({
      data: {
        email,
        name,
        password: hashedPassword,
        role,
      },
    })

return { success: true }
  } catch (error) {
    return { error: "Something went wrong" }
  }
}

[V0_FILE]typescript:file="app/actions/appointments.ts" isMerged="true"
"use server"

import { PrismaClient } from "@prisma/client"
import { getServerSession } from "next-auth"

const prisma = new PrismaClient()

export async function createAppointment(formData: FormData) {
  try {
    const session = await getServerSession()
    if (!session?.user) {
      return { error: "Not authenticated" }
    }

const date = formData.get("date") as string
    const time = formData.get("time") as string
    const type = formData.get("type") as string
    const notes = formData.get("notes") as string
    const doctorId = formData.get("doctorId") as string

// Combine date and time
    const appointmentDate = new Date(`${date}T${time}`)

const appointment = await prisma.appointment.create({
      data: {
        date: appointmentDate,
        type,
        notes,
        status: "PENDING",
        doctorId,
        patientId: session.user.id,
      },
    })

return { success: true, appointment }
  } catch (error) {
    return { error: "Failed to create appointment" }
  }
}

export async function getAppointments() {
  try {
    const session = await getServerSession()
    if (!session?.user) {
      return { error: "Not authenticated" }
    }

const appointments = await prisma.appointment.findMany({
      where: {
        OR: [{ doctorId: session.user.id }, { patientId: session.user.id }],
      },
      include: {
        doctor: {
          select: {
            name: true,
            email: true,
          },
        },
        patient: {
          select: {
            name: true,
            email: true,
          },
        },
      },
    })

return { appointments }
  } catch (error) {
    return { error: "Failed to fetch appointments" }
  }
}

export async function updateAppointmentStatus(id: string, status: string) {
  try {
    const session = await getServerSession()
    if (!session?.user) {
      return { error: "Not authenticated" }
    }

const appointment = await prisma.appointment.update({
      where: { id },
      data: { status },
    })

return { success: true, appointment }
  } catch (error) {
    return { error: "Failed to update appointment" }
  }
}

[V0_FILE]typescriptreact:file="lib/types.ts" isEdit="true"
export type User = {
  id: string
  name: string
  email: string
  password: string
  role: "DOCTOR" | "PATIENT"
  speciality?: string
}

export type Appointment = {
  id: string
  date: string
  status: "PENDING" | "CONFIRMED" | "CANCELLED" | "COMPLETED"
  type: "CHECKUP" | "FOLLOWUP" | "CONSULTATION" | "EMERGENCY"
  notes?: string
  doctorId: string
  patientId: string
  doctorName: string
  patientName: string
}

[V0_FILE]typescriptreact:file="lib/storage.ts" isEdit="true"
import type { Appointment, User } from "./types"

// Initialize localStorage with some sample data
export function initializeStorage() {
  if (typeof window === "undefined") return

if (!localStorage.getItem("users")) {
    localStorage.setItem(
      "users",
      JSON.stringify([
        {
          id: "1",
          name: "Dr. John Doe",
          email: "doctor@test.com",
          password: "password123",
          role: "DOCTOR",
          speciality: "Cardiologist",
        },
        {
          id: "2",
          name: "Jane Smith",
          email: "patient@test.com",
          password: "password123",
          role: "PATIENT",
        },
      ]),
    )
  }

if (!localStorage.getItem("appointments")) {
    localStorage.setItem("appointments", JSON.stringify([]))
  }
}

// User related functions
export function getUsers(): User[] {
  if (typeof window === "undefined") return []
  return JSON.parse(localStorage.getItem("users") || "[]")
}

export function getUserByEmail(email: string): User | undefined {
  return getUsers().find((user) => user.email === email)
}

export function createUser(user: Omit<User, "id">): User {
  const users = getUsers()
  const newUser = { ...user, id: Math.random().toString(36).substr(2, 9) }
  localStorage.setItem("users", JSON.stringify([...users, newUser]))
  return newUser
}

// Appointment related functions
export function getAppointments(): Appointment[] {
  if (typeof window === "undefined") return []
  return JSON.parse(localStorage.getItem("appointments") || "[]")
}

export function createAppointment(appointment: Omit<Appointment, "id">): Appointment {
  const appointments = getAppointments()
  const newAppointment = { ...appointment, id: Math.random().toString(36).substr(2, 9) }
  localStorage.setItem("appointments", JSON.stringify([...appointments, newAppointment]))
  return newAppointment
}

export function updateAppointment(id: string, data: Partial<Appointment>): Appointment {
  const appointments = getAppointments()
  const updatedAppointments = appointments.map((apt) => (apt.id === id ? { ...apt, ...data } : apt))
  localStorage.setItem("appointments", JSON.stringify(updatedAppointments))
  return updatedAppointments.find((apt) => apt.id === id)!
}

[V0_FILE]typescriptreact:file="contexts/auth-context.tsx" isFixed="true" isEdit="true" isQuickEdit="true"
"use client"

import type { User } from "@/lib/types"
import { createContext, useContext, useEffect, useState } from "react"
import { initializeStorage } from "@/lib/storage"

type AuthContextType = {
  user: User | null
  login: (email: string, password: string) => Promise<void>
  register: (userData: Omit<User, "id">) => Promise<void>
  logout: () => void
}

const AuthContext = createContext<AuthContextType | undefined>(undefined)

export function AuthProvider({ children }: { children: React.ReactNode }) {
  const [user, setUser] = useState<User | null>(null)

useEffect(() => {
    // Initialize storage with sample data
    initializeStorage()

// Check if user is logged in
    const storedUser = localStorage.getItem("currentUser")
    if (storedUser) {
      setUser(JSON.parse(storedUser))
    }
  }, [])

const login = async (email: string, password: string) => {
    const users = JSON.parse(localStorage.getItem("users") || "[]")
    const user = users.find((u: User) => u.email === email && u.password === password)

if (!user) {
      throw new Error("Invalid credentials")
    }

localStorage.setItem("currentUser", JSON.stringify(user))
    setUser(user)
  }

const register = async (userData: Omit<User, "id">) => {
    const users = JSON.parse(localStorage.getItem("users") || "[]")
    const exists = users.some((u: User) => u.email === userData.email)

if (exists) {
      throw new Error("User already exists")
    }

const newUser = { ...userData, id: Math.random().toString(36).substr(2, 9) }
    localStorage.setItem("users", JSON.stringify([...users, newUser]))
  }

const logout = () => {
    localStorage.removeItem("currentUser")
    setUser(null)
  }

return <AuthContext.Provider value={{ user, login, register, logout }}>{children}</AuthContext.Provider>
}

export function useAuth() {
  const context = useContext(AuthContext)
  if (context === undefined) {
    throw new Error("useAuth must be used within an AuthProvider")
  }
  return context
}

[V0_FILE]typescriptreact:file="app/layout.tsx" isEdit="true"
import { AuthProvider } from "@/contexts/auth-context"
import { Toaster } from "@/components/ui/toaster"
import "./globals.css"
import type React from "react"

export default function RootLayout({
  children,
}: {
  children: React.ReactNode
}) {
  return (
    <html lang="en">
      <body>
        <AuthProvider>
          {children}
          <Toaster />
        </AuthProvider>
      </body>
    </html>
  )
}

[V0_FILE]typescriptreact:file="middleware.ts" isEdit="true"
import { NextResponse } from "next/server"
import type { NextRequest } from "next/server"

export function middleware(request: NextRequest) {
  const currentUser = request.cookies.get("currentUser")

if (!currentUser && request.nextUrl.pathname.startsWith("/dashboard")) {
    return NextResponse.redirect(new URL("/login", request.url))
  }

if (currentUser && (request.nextUrl.pathname === "/login" || request.nextUrl.pathname === "/register")) {
    return NextResponse.redirect(new URL("/dashboard", request.url))
  }

return NextResponse.next()
}

export const config = {
  matcher: ["/dashboard/:path*", "/login", "/register"],
}

[V0_FILE]typescriptreact:file="app/page.tsx"
import { redirect } from "next/navigation"

export default function Home() {
  redirect("/login")
}
</article></body></html>

About

Tags

Share

More Templates Like This

About

Tags

Share

About

Tags

Share

More Templates Like This