[V0_FILE]typescriptreact:file="app/page.tsx" import Link from "next/link" import { Button } from "@/components/ui/button" import { ArrowRight, Briefcase, CheckCircle, MessageSquare, Star, Users } from "lucide-react" export default function Home() { return (

InteriorConnect

Connect Interior Design Contractors with Skilled Laborers

Find the perfect match for your interior design projects. Post jobs, discover talent, and get work done efficiently.

How It Works

Our platform makes it easy to connect contractors with skilled laborers for interior design projects.

Post a Job

Contractors can easily post job details, requirements, and budget for their interior design projects.

Find Talent

Browse through profiles of skilled laborers, view their portfolios, and check their ratings.

Complete Projects

Collaborate efficiently, track progress, and complete your interior design projects on time.

Key Features

Everything you need to connect and collaborate on interior design projects.

Job Marketplace

A centralized marketplace for posting and finding interior design jobs.

Messaging System

Built-in messaging to facilitate communication between contractors and laborers.

Ratings & Reviews

Transparent rating system to build trust and showcase quality work.

Ready to Get Started?

Join our platform today and transform how you handle interior design projects.

) } [V0_FILE]typescriptreact:file="app/register/page.tsx" "use client" import type React from "react" import { useState } from "react" import { useRouter, useSearchParams } from "next/navigation" import Link from "next/link" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@/components/ui/card" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group" import { toast } from "@/components/ui/use-toast" import { registerUser } from "@/lib/actions" export default function RegisterPage() { const router = useRouter() const searchParams = useSearchParams() const defaultType = searchParams.get("type") || "contractor" const [formData, setFormData] = useState({ name: "", email: "", password: "", confirmPassword: "", userType: defaultType, }) const [loading, setLoading] = useState(false) const handleChange = (e: React.ChangeEvent) => { const { name, value } = e.target setFormData((prev) => ({ ...prev, [name]: value })) } const handleTypeChange = (value: string) => { setFormData((prev) => ({ ...prev, userType: value })) } const handleSubmit = async (e: React.FormEvent) => { e.preventDefault() setLoading(true) if (formData.password !== formData.confirmPassword) { toast({ title: "Passwords don't match", description: "Please make sure your passwords match.", variant: "destructive", }) setLoading(false) return } try { await registerUser(formData) toast({ title: "Registration successful!", description: "You can now log in to your account.", }) router.push("/login") } catch (error) { toast({ title: "Registration failed", description: error instanceof Error ? error.message : "Something went wrong. Please try again.", variant: "destructive", }) } finally { setLoading(false) } } return (

← Back to home

Create an account Enter your information to create an account

Already have an account?{" "} Log in

) } [V0_FILE]typescriptreact:file="app/register/loading.tsx" isFixed="true" export default function Loading() { return null } [V0_FILE]typescriptreact:file="app/login/page.tsx" "use client" import type React from "react" import { useState } from "react" import { useRouter } from "next/navigation" import Link from "next/link" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@/components/ui/card" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { toast } from "@/components/ui/use-toast" import { loginUser } from "@/lib/actions" export default function LoginPage() { const router = useRouter() const [formData, setFormData] = useState({ email: "", password: "", }) const [loading, setLoading] = useState(false) const handleChange = (e: React.ChangeEvent) => { const { name, value } = e.target setFormData((prev) => ({ ...prev, [name]: value })) } const handleSubmit = async (e: React.FormEvent) => { e.preventDefault() setLoading(true) try { const result = await loginUser(formData) if (result.success) { toast({ title: "Login successful!", description: "You are now logged in.", }) router.push("/dashboard") } else { throw new Error(result.error || "Invalid credentials") } } catch (error) { toast({ title: "Login failed", description: error instanceof Error ? error.message : "Invalid email or password.", variant: "destructive", }) } finally { setLoading(false) } } return (

← Back to home

Don't have an account?{" "} Sign up

) } [V0_FILE]typescriptreact:file="app/dashboard/page.tsx" "use client" import { useEffect, useState } from "react" import Link from "next/link" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { getUserProfile, getRecentJobs, getRecentApplications } from "@/lib/actions" import { JobCard } from "@/components/job-card" import { ApplicationCard } from "@/components/application-card" import type { UserProfile } from "@/lib/types" export default function DashboardPage() { const [profile, setProfile] = useState(null) const [jobs, setJobs] = useState([]) const [applications, setApplications] = useState([]) const [loading, setLoading] = useState(true) useEffect(() => { const fetchData = async () => { try { const profileData = await getUserProfile() setProfile(profileData) if (profileData.userType === "contractor") { const jobsData = await getRecentJobs() setJobs(jobsData) } else { const applicationsData = await getRecentApplications() setApplications(applicationsData) } } catch (error) { console.error("Error fetching dashboard data:", error) } finally { setLoading(false) } } fetchData() }, []) if (loading) { return

} if (!profile) { return (

Please log in to view your dashboard

) } return (

InteriorConnect

Dashboard {profile.userType === "contractor" ? ( <> Post Job Manage Jobs ) : ( <> Find Jobs My Applications )} Messages

Dashboard

Welcome back, {profile.name}! Here's what's happening with your{" "} {profile.userType === "contractor" ? "projects" : "job applications"}.

Overview

{profile.userType === "contractor" ? jobs.length : applications.length}

{profile.userType === "contractor" ? "Active Jobs" : "Active Applications"}

Messages

Unread messages

Profile Views

Last 7 days

Overview {profile.userType === "contractor" ? ( My Jobs ) : ( My Applications )} Messages Summary Your activity overview for the past 30 days. {profile.userType === "contractor" ? (

Total Jobs Posted

{jobs.length}

Applications Received

Recent Jobs

{jobs.slice(0, 3).map((job: any) => ( ))} {jobs.length === 0 &&

No jobs posted yet.

}

{jobs.length > 0 && ( )}

) : (

Applications Submitted

{applications.length}

Interviews Scheduled

Recent Applications

{applications.slice(0, 3).map((application: any) => ( ))} {applications.length === 0 && (

No applications submitted yet.

)}

{applications.length > 0 && ( )}

)} {profile.userType === "contractor" ? ( My Jobs Manage your posted jobs and review applications.

{jobs.map((job: any) => ( ))} {jobs.length === 0 && (

You haven't posted any jobs yet.

)}

) : ( My Applications Track the status of your job applications.

{applications.map((application: any) => ( ))} {applications.length === 0 && (

You haven't applied to any jobs yet.

)}

)} Messages Communicate with contractors and laborers.

Your messages will appear here.

) } [V0_FILE]typescriptreact:file="app/jobs/page.tsx" isFixed="true" isQuickEdit="true" "use client" import type React from "react" import { useEffect, useState } from "react" import Link from "next/link" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } 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 { Slider } from "@/components/ui/slider" import { getAllJobs } from "@/lib/actions" export default function JobsPage() { const [jobs, setJobs] = useState([]) const [loading, setLoading] = useState(true) const [filters, setFilters] = useState({ search: "", category: "", minBudget: 0, maxBudget: 10000, }) useEffect(() => { const fetchJobs = async () => { try { const jobsData = await getAllJobs() setJobs(jobsData) } catch (error) { console.error("Error fetching jobs:", error) } finally { setLoading(false) } } fetchJobs() }, []) const handleSearchChange = (e: React.ChangeEvent) => { setFilters({ ...filters, search: e.target.value }) } const handleCategoryChange = (value: string) => { setFilters({ ...filters, category: value }) } const handleBudgetChange = (value: number[]) => { setFilters({ ...filters, minBudget: value[0], maxBudget: value[1] }) } const filteredJobs = jobs.filter((job: any) => { const matchesSearch = job.title.toLowerCase().includes(filters.search.toLowerCase()) || job.description.toLowerCase().includes(filters.search.toLowerCase()) const matchesCategory = !filters.category || job.category === filters.category const matchesBudget = job.budget >= filters.minBudget && job.budget <= filters.maxBudget return matchesSearch && matchesCategory && matchesBudget }) return (

InteriorConnect

Filter Jobs

Narrow down jobs based on your preferences.

Available Jobs

Browse and apply for interior design jobs that match your skills.

{loading ? (

Loading jobs...

) : (

{filteredJobs.length > 0 ? ( filteredJobs.map((job: any) => ( {job.title} Posted by {job.contractor.name} • {job.location}

{job.description}

{job.category} ${job.budget} {job.duration}

)) ) : (

No jobs found matching your criteria.

)}

) } [V0_FILE]typescriptreact:file="app/jobs/post/page.tsx" "use client" import type React from "react" import { useState } from "react" import { useRouter } from "next/navigation" import Link from "next/link" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } 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 { toast } from "@/components/ui/use-toast" import { postJob } from "@/lib/actions" export default function PostJobPage() { const router = useRouter() const [formData, setFormData] = useState({ title: "", description: "", category: "", budget: "", duration: "", location: "", skills: "", }) const [loading, setLoading] = useState(false) const handleChange = (e: React.ChangeEvent) => { const { name, value } = e.target setFormData((prev) => ({ ...prev, [name]: value })) } const handleSelectChange = (name: string, value: string) => { setFormData((prev) => ({ ...prev, [name]: value })) } const handleSubmit = async (e: React.FormEvent) => { e.preventDefault() setLoading(true) try { await postJob(formData) toast({ title: "Job posted successfully!", description: "Your job has been posted and is now visible to laborers.", }) router.push("/jobs/manage") } catch (error) { toast({ title: "Failed to post job", description: error instanceof Error ? error.message : "Something went wrong. Please try again.", variant: "destructive", }) } finally { setLoading(false) } } return (

InteriorConnect

Post a New Job

Fill out the form below to post a new interior design job.

Job Details Provide the basic information about your job.

Job Title

Job Description

</div>
                  <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
                    <div className="space-y-2">
                      <Label htmlFor="category">Category</Label>
                      <Select
                        value={formData.category}
                        onValueChange={(value) => handleSelectChange("category", value)}
                        required
                      >
                        <SelectTrigger id="category">
                          <SelectValue placeholder="Select category" />
                        </SelectTrigger>
                        <SelectContent>
                          <SelectItem value="painting">Painting</SelectItem>
                          <SelectItem value="carpentry">Carpentry</SelectItem>
                          <SelectItem value="flooring">Flooring</SelectItem>
                          <SelectItem value="electrical">Electrical</SelectItem>
                          <SelectItem value="plumbing">Plumbing</SelectItem>
                        </SelectContent>
                      </Select>
                    </div>
                    <div className="space-y-2">
                      <Label htmlFor="budget">Budget ($)</Label>
                      <Input
                        id="budget"
                        name="budget"
                        type="number"
                        placeholder="e.g., 1000"
                        value={formData.budget}
                        onChange={handleChange}
                        required
                      />
                    </div>
                  </div>
                  <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
                    <div className="space-y-2">
                      <Label htmlFor="duration">Duration</Label>
                      <Select
                        value={formData.duration}
                        onValueChange={(value) => handleSelectChange("duration", value)}
                        required
                      >
                        <SelectTrigger id="duration">
                          <SelectValue placeholder="Select duration" />
                        </SelectTrigger>
                        <SelectContent>
                          <SelectItem value="1-3 days">1-3 days</SelectItem>
                          <SelectItem value="1 week">1 week</SelectItem>
                          <SelectItem value="2 weeks">2 weeks</SelectItem>
                          <SelectItem value="1 month">1 month</SelectItem>
                          <SelectItem value="2+ months">2+ months</SelectItem>
                        </SelectContent>
                      </Select>
                    </div>
                    <div className="space-y-2">
                      <Label htmlFor="location">Location</Label>
                      <Input
                        id="location"
                        name="location"
                        placeholder="e.g., New York, NY"
                        value={formData.location}
                        onChange={handleChange}
                        required
                      />
                    </div>
                  </div>
                  <div className="space-y-2">
                    <Label htmlFor="skills">Required Skills</Label>
                    <Input
                      id="skills"
                      name="skills"
                      placeholder="e.g., painting, drywall, finishing"
                      value={formData.skills}
                      onChange={handleChange}
                      required
                    />
                    <p className="text-xs text-muted-foreground">Separate skills with commas</p>
                  </div>
                </CardContent>
                <CardFooter className="flex justify-between">
                  <Button variant="outline" type="button" onClick={() => router.back()}>
                    Cancel
                  </Button>
                  <Button type="submit" disabled={loading}>
                    {loading ? "Posting..." : "Post Job"}
                  </Button>
                </CardFooter>
              </Card>
            </form>
          </div>
        </div>
      </main>
    </div>
  )
}

[V0_FILE]typescriptreact:file="components/job-card.tsx"
import Link from "next/link"
import { Button } from "@/components/ui/button"
import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@/components/ui/card"
import { Badge } from "@/components/ui/badge"
import { CalendarDays, DollarSign, MapPin } from "lucide-react"

interface JobCardProps {
  job: {
    id: string
    title: string
    description: string
    category: string
    budget: number
    duration: string
    location: string
    createdAt: string
    status: string
  }
}

export function JobCard({ job }: JobCardProps) {
  return (
    <Card>
      <CardHeader>
        <div className="flex items-start justify-between">
          <div>
            <CardTitle>{job.title}</CardTitle>
            <CardDescription className="flex items-center gap-1 mt-1">
              <MapPin className="h-3 w-3" /> {job.location}
            </CardDescription>
          </div>
          <Badge variant={job.status === "active" ? "default" : "outline"}>{job.status}</Badge>
        </div>
      </CardHeader>
      <CardContent>
        <p className="text-sm line-clamp-2 mb-4">{job.description}</p>
        <div className="flex flex-wrap gap-2 text-sm text-muted-foreground">
          <div className="flex items-center gap-1">
            <DollarSign className="h-4 w-4" />${job.budget}
          </div>
          <div className="flex items-center gap-1">
            <CalendarDays className="h-4 w-4" />
            {job.duration}
          </div>
          <div className="inline-flex items-center rounded-md bg-muted px-2 py-1 text-xs font-medium">
            {job.category}
          </div>
        </div>
      </CardContent>
      <CardFooter>
        <Button asChild variant="outline" size="sm" className="w-full">
          <Link href={`/jobs/${job.id}`}>View Details</Link>
        </Button>
      </CardFooter>
    </Card>
  )
}

[V0_FILE]typescriptreact:file="components/application-card.tsx"
import Link from "next/link"
import { Button } from "@/components/ui/button"
import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@/components/ui/card"
import { Badge } from "@/components/ui/badge"
import { CalendarDays } from "lucide-react"

interface ApplicationCardProps {
  application: {
    id: string
    job: {
      id: string
      title: string
      contractor: {
        name: string
      }
    }
    status: string
    appliedAt: string
  }
}

export function ApplicationCard({ application }: ApplicationCardProps) {
  const getStatusColor = (status: string) => {
    switch (status) {
      case "pending":
        return "bg-yellow-500"
      case "accepted":
        return "bg-green-500"
      case "rejected":
        return "bg-red-500"
      default:
        return "bg-gray-500"
    }
  }

return (
    <Card>
      <CardHeader>
        <div className="flex items-start justify-between">
          <div>
            <CardTitle>{application.job.title}</CardTitle>
            <CardDescription>{application.job.contractor.name}</CardDescription>
          </div>
          <Badge className={`${getStatusColor(application.status)} text-white`}>{application.status}</Badge>
        </div>
      </CardHeader>
      <CardContent>
        <div className="flex items-center text-sm text-muted-foreground">
          <CalendarDays className="mr-1 h-4 w-4" />
          Applied on {new Date(application.appliedAt).toLocaleDateString()}
        </div>
      </CardContent>
      <CardFooter>
        <Button asChild variant="outline" size="sm" className="w-full">
          <Link href={`/applications/${application.id}`}>View Details</Link>
        </Button>
      </CardFooter>
    </Card>
  )
}

[V0_FILE]typescriptreact:file="lib/actions.ts"
"use server"

import { revalidatePath } from "next/cache"
import { cookies } from "next/headers"
import { redirect } from "next/navigation"
import { db } from "@/lib/db"

// Authentication actions
export async function registerUser(userData: {
  name: string
  email: string
  password: string
  userType: string
}) {
  try {
    // In a real app, you would hash the password before storing it
    const user = await db.user.create({
      data: {
        name: userData.name,
        email: userData.email,
        password: userData.password, // This should be hashed in production
        userType: userData.userType,
      },
    })

return { success: true, userId: user.id }
  } catch (error) {
    console.error("Registration error:", error)
    throw new Error("Failed to register user. Email might already be in use.")
  }
}

export async function loginUser(credentials: { email: string; password: string }) {
  try {
    // In a real app, you would verify the hashed password
    const user = await db.user.findUnique({
      where: { email: credentials.email },
    })

if (!user || user.password !== credentials.password) {
      return { success: false, error: "Invalid credentials" }
    }

// Set a session cookie
    const sessionId = crypto.randomUUID()
    cookies().set("sessionId", sessionId, {
      httpOnly: true,
      secure: process.env.NODE_ENV === "production",
      maxAge: 60 * 60 * 24 * 7, // 1 week
      path: "/",
    })

// In a real app, you would store the session in a database
    await db.session.create({
      data: {
        id: sessionId,
        userId: user.id,
        expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), // 1 week
      },
    })

return { success: true, userId: user.id }
  } catch (error) {
    console.error("Login error:", error)
    return { success: false, error: "Something went wrong. Please try again." }
  }
}

export async function logoutUser() {
  const sessionId = cookies().get("sessionId")?.value

if (sessionId) {
    // Delete the session from the database
    await db.session.delete({
      where: { id: sessionId },
    })

// Clear the cookie
    cookies().delete("sessionId")
  }

redirect("/login")
}

// User profile actions
export async function getUserProfile() {
  const sessionId = cookies().get("sessionId")?.value

if (!sessionId) {
    redirect("/login")
  }

try {
    const session = await db.session.findUnique({
      where: { id: sessionId },
      include: { user: true },
    })

if (!session || session.expires < new Date()) {
      cookies().delete("sessionId")
      redirect("/login")
    }

return session.user
  } catch (error) {
    console.error("Error fetching user profile:", error)
    redirect("/login")
  }
}

export async function updateUserProfile(profileData: {
  name: string
  bio: string
  skills: string
  location: string
  phone: string
}) {
  const sessionId = cookies().get("sessionId")?.value

if (!sessionId) {
    redirect("/login")
  }

try {
    const session = await db.session.findUnique({
      where: { id: sessionId },
    })

if (!session || session.expires < new Date()) {
      cookies().delete("sessionId")
      redirect("/login")
    }

await db.user.update({
      where: { id: session.userId },
      data: {
        name: profileData.name,
        bio: profileData.bio,
        skills: profileData.skills,
        location: profileData.location,
        phone: profileData.phone,
      },
    })

revalidatePath("/profile")
    return { success: true }
  } catch (error) {
    console.error("Error updating profile:", error)
    throw new Error("Failed to update profile. Please try again.")
  }
}

// Job actions
export async function postJob(jobData: {
  title: string
  description: string
  category: string
  budget: string
  duration: string
  location: string
  skills: string
}) {
  const sessionId = cookies().get("sessionId")?.value

if (!sessionId) {
    redirect("/login")
  }

try {
    const session = await db.session.findUnique({
      where: { id: sessionId },
      include: { user: true },
    })

if (!session || session.expires < new Date() || session.user.userType !== "contractor") {
      cookies().delete("sessionId")
      redirect("/login")
    }

await db.job.create({
      data: {
        title: jobData.title,
        description: jobData.description,
        category: jobData.category,
        budget: Number.parseFloat(jobData.budget),
        duration: jobData.duration,
        location: jobData.location,
        skills: jobData.skills,
        status: "active",
        contractorId: session.userId,
      },
    })

revalidatePath("/jobs/manage")
    return { success: true }
  } catch (error) {
    console.error("Error posting job:", error)
    throw new Error("Failed to post job. Please try again.")
  }
}

export async function getRecentJobs() {
  const sessionId = cookies().get("sessionId")?.value

if (!sessionId) {
    redirect("/login")
  }

try {
    const session = await db.session.findUnique({
      where: { id: sessionId },
    })

if (!session || session.expires < new Date()) {
      cookies().delete("sessionId")
      redirect("/login")
    }

const jobs = await db.job.findMany({
      where: { contractorId: session.userId },
      orderBy: { createdAt: "desc" },
      take: 5,
    })

return jobs
  } catch (error) {
    console.error("Error fetching recent jobs:", error)
    return []
  }
}

export async function getAllJobs() {
  try {
    const jobs = await db.job.findMany({
      where: { status: "active" },
      include: {
        contractor: {
          select: {
            name: true,
          },
        },
      },
      orderBy: { createdAt: "desc" },
    })

return jobs
  } catch (error) {
    console.error("Error fetching all jobs:", error)
    return []
  }
}

export async function getJobById(jobId: string) {
  try {
    const job = await db.job.findUnique({
      where: { id: jobId },
      include: {
        contractor: {
          select: {
            id: true,
            name: true,
            email: true,
          },
        },
      },
    })

return job
  } catch (error) {
    console.error(`Error fetching job ${jobId}:`, error)
    return null
  }
}

// Application actions
export async function applyForJob(jobId: string, coverLetter: string) {
  const sessionId = cookies().get("sessionId")?.value

if (!sessionId) {
    redirect("/login")
  }

try {
    const session = await db.session.findUnique({
      where: { id: sessionId },
      include: { user: true },
    })

if (!session || session.expires < new Date() || session.user.userType !== "laborer") {
      cookies().delete("sessionId")
      redirect("/login")
    }

// Check if already applied
    const existingApplication = await db.application.findFirst({
      where: {
        jobId,
        laborerId: session.userId,
      },
    })

if (existingApplication) {
      throw new Error("You have already applied for this job.")
    }

await db.application.create({
      data: {
        jobId,
        laborerId: session.userId,
        coverLetter,
        status: "pending",
      },
    })

revalidatePath("/applications")
    return { success: true }
  } catch (error) {
    console.error("Error applying for job:", error)
    throw new Error(error instanceof Error ? error.message : "Failed to apply for job. Please try again.")
  }
}

export async function getRecentApplications() {
  const sessionId = cookies().get("sessionId")?.value

if (!sessionId) {
    redirect("/login")
  }

try {
    const session = await db.session.findUnique({
      where: { id: sessionId },
    })

if (!session || session.expires < new Date()) {
      cookies().delete("sessionId")
      redirect("/login")
    }

const applications = await db.application.findMany({
      where: { laborerId: session.userId },
      include: {
        job: {
          include: {
            contractor: {
              select: {
                name: true,
              },
            },
          },
        },
      },
      orderBy: { appliedAt: "desc" },
      take: 5,
    })

return applications
  } catch (error) {
    console.error("Error fetching recent applications:", error)
    return []
  }
}

export async function getApplicationById(applicationId: string) {
  const sessionId = cookies().get("sessionId")?.value

if (!sessionId) {
    redirect("/login")
  }

try {
    const session = await db.session.findUnique({
      where: { id: sessionId },
    })

if (!session || session.expires < new Date()) {
      cookies().delete("sessionId")
      redirect("/login")
    }

const application = await db.application.findUnique({
      where: { id: applicationId },
      include: {
        job: {
          include: {
            contractor: {
              select: {
                id: true,
                name: true,
                email: true,
              },
            },
          },
        },
        laborer: {
          select: {
            id: true,
            name: true,
            email: true,
          },
        },
      },
    })

// Check if user has permission to view this application
    if (application?.laborerId !== session.userId && application?.job.contractorId !== session.userId) {
      throw new Error("You don't have permission to view this application.")
    }

return application
  } catch (error) {
    console.error(`Error fetching application ${applicationId}:`, error)
    return null
  }
}

export async function updateApplicationStatus(applicationId: string, status: string) {
  const sessionId = cookies().get("sessionId")?.value

if (!sessionId) {
    redirect("/login")
  }

try {
    const session = await db.session.findUnique({
      where: { id: sessionId },
      include: { user: true },
    })

if (!session || session.expires < new Date() || session.user.userType !== "contractor") {
      cookies().delete("sessionId")
      redirect("/login")
    }

const application = await db.application.findUnique({
      where: { id: applicationId },
      include: {
        job: true,
      },
    })

if (!application || application.job.contractorId !== session.userId) {
      throw new Error("You don't have permission to update this application.")
    }

await db.application.update({
      where: { id: applicationId },
      data: { status },
    })

revalidatePath(`/applications/${applicationId}`)
    return { success: true }
  } catch (error) {
    console.error("Error updating application status:", error)
    throw new Error("Failed to update application status. Please try again.")
  }
}

[V0_FILE]typescriptreact:file="lib/db.ts"
// This is a mock database implementation
// In a real application, you would use a real database like PostgreSQL with Prisma

import { v4 as uuidv4 } from "uuid"

// Define types
type User = {
  id: string
  name: string
  email: string
  password: string
  userType: string
  bio?: string
  skills?: string
  location?: string
  phone?: string
  createdAt: Date
}

type Session = {
  id: string
  userId: string
  expires: Date
  user?: User
}

type Job = {
  id: string
  title: string
  description: string
  category: string
  budget: number
  duration: string
  location: string
  skills: string
  status: string
  contractorId: string
  contractor?: User
  createdAt: Date
}

type Application = {
  id: string
  jobId: string
  laborerId: string
  coverLetter: string
  status: string
  appliedAt: Date
  job?: Job
  laborer?: User
}

// Mock database
const users: User[] = []
const sessions: Session[] = []
const jobs: Job[] = []
const applications: Application[] = []

// Helper functions
const findUserByEmail = (email: string) => users.find((user) => user.email === email)
const findUserById = (id: string) => users.find((user) => user.id === id)
const findSessionById = (id: string) => {
  const session = sessions.find((session) => session.id === id)
  if (session) {
    session.user = findUserById(session.userId)
  }
  return session
}
const findJobById = (id: string) => {
  const job = jobs.find((job) => job.id === id)
  if (job) {
    job.contractor = findUserById(job.contractorId)
  }
  return job
}
const findApplicationById = (id: string) => {
  const application = applications.find((app) => app.id === id)
  if (application) {
    application.job = findJobById(application.jobId)
    application.laborer = findUserById(application.laborerId)
  }
  return application
}

// Mock database operations
export const db = {
  user: {
    create: async ({ data }: { data: Omit<User, "id" | "createdAt"> }) => {
      if (findUserByEmail(data.email)) {
        throw new Error("Email already in use")
      }
      const user: User = {
        id: uuidv4(),
        ...data,
        createdAt: new Date(),
      }
      users.push(user)
      return user
    },
    findUnique: async ({ where }: { where: { id?: string; email?: string } }) => {
      if (where.id) return findUserById(where.id)
      if (where.email) return findUserByEmail(where.email)
      return null
    },
    update: async ({ where, data }: { where: { id: string }; data: Partial<User> }) => {
      const userIndex = users.findIndex((user) => user.id === where.id)
      if (userIndex === -1) throw new Error("User not found")

users[userIndex] = { ...users[userIndex], ...data }
      return users[userIndex]
    },
  },
  session: {
    create: async ({ data }: { data: Omit<Session, "user"> }) => {
      const session: Session = { ...data }
      sessions.push(session)
      return session
    },
    findUnique: async ({ where, include }: { where: { id: string }; include?: { user?: boolean } }) => {
      const session = findSessionById(where.id)
      if (!session) return null

if (include?.user) {
        session.user = findUserById(session.userId)
      }

return session
    },
    delete: async ({ where }: { where: { id: string } }) => {
      const sessionIndex = sessions.findIndex((session) => session.id === where.id)
      if (sessionIndex === -1) return null

const [deletedSession] = sessions.splice(sessionIndex, 1)
      return deletedSession
    },
  },
  job: {
    create: async ({ data }: { data: Omit<Job, "id" | "createdAt"> }) => {
      const job: Job = {
        id: uuidv4(),
        ...data,
        createdAt: new Date(),
      }
      jobs.push(job)
      return job
    },
    findMany: async ({
      where,
      include,
      orderBy,
      take,
    }: {
      where?: { contractorId?: string; status?: string }
      include?: { contractor?: { select: { name?: boolean; email?: boolean; id?: boolean } } }
      orderBy?: { createdAt: "asc" | "desc" }
      take?: number
    }) => {
      let filteredJobs = [...jobs]

if (where?.contractorId) {
        filteredJobs = filteredJobs.filter((job) => job.contractorId === where.contractorId)
      }

if (where?.status) {
        filteredJobs = filteredJobs.filter((job) => job.status === where.status)
      }

if (orderBy?.createdAt) {
        filteredJobs.sort((a, b) => {
          if (orderBy.createdAt === "asc") {
            return a.createdAt.getTime() - b.createdAt.getTime()
          } else {
            return b.createdAt.getTime() - a.createdAt.getTime()
          }
        })
      }

if (include?.contractor) {
        filteredJobs = filteredJobs.map((job) => ({
          ...job,
          contractor:
            include.contractor.select.name || include.contractor.select.email || include.contractor.select.id
              ? {
                  ...(include.contractor.select.id ? { id: findUserById(job.contractorId)?.id } : {}),
                  ...(include.contractor.select.name ? { name: findUserById(job.contractorId)?.name } : {}),
                  ...(include.contractor.select.email ? { email: findUserById(job.contractorId)?.email } : {}),
                }
              : undefined,
        }))
      }

if (take) {
        filteredJobs = filteredJobs.slice(0, take)
      }

return filteredJobs
    },
    findUnique: async ({
      where,
      include,
    }: {
      where: { id: string }
      include?: { contractor?: { select: { name?: boolean; email?: boolean; id?: boolean } } }
    }) => {
      const job = findJobById(where.id)
      if (!job) return null

if (include?.contractor) {
        const contractor = findUserById(job.contractorId)
        if (contractor) {
          job.contractor = {
            ...(include.contractor.select.id ? { id: contractor.id } : {}),
            ...(include.contractor.select.name ? { name: contractor.name } : {}),
            ...(include.contractor.select.email ? { email: contractor.email } : {}),
          }
        }
      }

return job
    },
    update: async ({ where, data }: { where: { id: string }; data: Partial<Job> }) => {
      const jobIndex = jobs.findIndex((job) => job.id === where.id)
      if (jobIndex === -1) throw new Error("Job not found")

jobs[jobIndex] = { ...jobs[jobIndex], ...data }
      return jobs[jobIndex]
    },
  },
  application: {
    create: async ({ data }: { data: Omit<Application, "id" | "appliedAt"> }) => {
      const application: Application = {
        id: uuidv4(),
        ...data,
        appliedAt: new Date(),
      }
      applications.push(application)
      return application
    },
    findFirst: async ({ where }: { where: { jobId: string; laborerId: string } }) => {
      return applications.find((app) => app.jobId === where.jobId && app.laborerId === where.laborerId) || null
    },
    findMany: async ({
      where,
      include,
      orderBy,
      take,
    }: {
      where?: { laborerId?: string; jobId?: string }
      include?: {
        job?: {
          include?: {
            contractor?: {
              select: { name?: boolean; email?: boolean; id?: boolean }
            }
          }
        }
        laborer?: {
          select: { name?: boolean; email?: boolean; id?: boolean }
        }
      }
      orderBy?: { appliedAt: "asc" | "desc" }
      take?: number
    }) => {
      let filteredApplications = [...applications]

if (where?.laborerId) {
        filteredApplications = filteredApplications.filter((app) => app.laborerId === where.laborerId)
      }

if (where?.jobId) {
        filteredApplications = filteredApplications.filter((app) => app.jobId === where.jobId)
      }

if (orderBy?.appliedAt) {
        filteredApplications.sort((a, b) => {
          if (orderBy.appliedAt === "asc") {
            return a.appliedAt.getTime() - b.appliedAt.getTime()
          } else {
            return b.appliedAt.getTime() - a.appliedAt.getTime()
          }
        })
      }

if (include?.job) {
        filteredApplications = filteredApplications.map((app) => {
          const job = findJobById(app.jobId)
          if (!job) return app

const jobWithContractor = { ...job }

if (include.job.include?.contractor && job.contractorId) {
            const contractor = findUserById(job.contractorId)
            if (contractor) {
              jobWithContractor.contractor = {
                ...(include.job.include.contractor.select.id ? { id: contractor.id } : {}),
                ...(include.job.include.contractor.select.name ? { name: contractor.name } : {}),
                ...(include.job.include.contractor.select.email ? { email: contractor.email } : {}),
              }
            }
          }

return {
            ...app,
            job: jobWithContractor,
          }
        })
      }

if (include?.laborer) {
        filteredApplications = filteredApplications.map((app) => {
          const laborer = findUserById(app.laborerId)
          if (!laborer) return app

return {
            ...app,
            laborer: {
              ...(include.laborer?.select.id ? { id: laborer.id } : {}),
              ...(include.laborer?.select.name ? { name: laborer.name } : {}),
              ...(include.laborer?.select.email ? { email: laborer.email } : {}),
            },
          }
        })
      }

if (take) {
        filteredApplications = filteredApplications.slice(0, take)
      }

return filteredApplications
    },
    findUnique: async ({
      where,
      include,
    }: {
      where: { id: string }
      include?: {
        job?: {
          include?: {
            contractor?: {
              select: { name?: boolean; email?: boolean; id?: boolean }
            }
          }
        }
        laborer?: {
          select: { name?: boolean; email?: boolean; id?: boolean }
        }
      }
    }) => {
      const application = findApplicationById(where.id)
      if (!application) return null

if (include?.job) {
        const job = findJobById(application.jobId)
        if (job) {
          const jobWithContractor = { ...job }

application.job = jobWithContractor
        }
      }

if (include?.laborer) {
        const laborer = findUserById(application.laborerId)
        if (laborer) {
          application.laborer = {
            ...(include.laborer.select.id ? { id: laborer.id } : {}),
            ...(include.laborer.select.name ? { name: laborer.name } : {}),
            ...(include.laborer.select.email ? { email: laborer.email } : {}),
          }
        }
      }

return application
    },
    update: async ({ where, data }: { where: { id: string }; data: Partial<Application> }) => {
      const applicationIndex = applications.findIndex((app) => app.id === where.id)
      if (applicationIndex === -1) throw new Error("Application not found")

applications[applicationIndex] = { ...applications[applicationIndex], ...data }
      return applications[applicationIndex]
    },
  },
}

[V0_FILE]typescriptreact:file="lib/types.ts"
export interface UserProfile {
  id: string
  name: string
  email: string
  userType: string
  bio?: string
  skills?: string
  location?: string
  phone?: string
}

export interface Job {
  id: string
  title: string
  description: string
  category: string
  budget: number
  duration: string
  location: string
  skills: string
  status: string
  contractorId: string
  createdAt: string
  contractor?: {
    id: string
    name: string
    email: string
  }
}

export interface Application {
  id: string
  jobId: string
  laborerId: string
  coverLetter: string
  status: string
  appliedAt: string
  job?: Job
  laborer?: {
    id: string
    name: string
    email: string
  }
}

[V0_FILE]typescriptreact:file="components/ui/toast.tsx"
import * as React from "react"
import { Cross2Icon } from "@radix-ui/react-icons"
import * as ToastPrimitives from "@radix-ui/react-toast"
import { cva, type VariantProps } from "class-variance-authority"

import { cn } from "@/lib/utils"

const ToastProvider = ToastPrimitives.Provider

const ToastViewport = React.forwardRef<
  React.ElementRef<typeof ToastPrimitives.Viewport>,
  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Viewport>
>(({ className, ...props }, ref) => (
  <ToastPrimitives.Viewport
    ref={ref}
    className={cn(
      "fixed top-0 z-[100] flex max-h-screen w-full flex-col-reverse p-4 sm:bottom-0 sm:right-0 sm:top-auto sm:flex-col md:max-w-[420px]",
      className,
    )}
    {...props}
  />
))
ToastViewport.displayName = ToastPrimitives.Viewport.displayName

const toastVariants = cva(
  "group pointer-events-auto relative flex w-full items-center justify-between space-x-2 overflow-hidden rounded-md border p-4 pr-6 shadow-lg transition-all data-[swipe=cancel]:translate-x-0 data-[swipe=end]:translate-x-[var(--radix-toast-swipe-end-x)] data-[swipe=move]:translate-x-[var(--radix-toast-swipe-move-x)] data-[swipe=move]:transition-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[swipe=end]:animate-out data-[state=closed]:fade-out-80 data-[state=closed]:slide-out-to-right-full data-[state=open]:slide-in-from-top-full data-[state=open]:sm:slide-in-from-bottom-full",
  {
    variants: {
      variant: {
        default: "border bg-background text-foreground",
        destructive: "destructive group border-destructive bg-destructive text-destructive-foreground",
      },
    },
    defaultVariants: {
      variant: "default",
    },
  },
)

const Toast = React.forwardRef<
  React.ElementRef<typeof ToastPrimitives.Root>,
  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Root> & VariantProps<typeof toastVariants>
>(({ className, variant, ...props }, ref) => {
  return <ToastPrimitives.Root ref={ref} className={cn(toastVariants({ variant }), className)} {...props} />
})
Toast.displayName = ToastPrimitives.Root.displayName

const ToastAction = React.forwardRef<
  React.ElementRef<typeof ToastPrimitives.Action>,
  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Action>
>(({ className, ...props }, ref) => (
  <ToastPrimitives.Action
    ref={ref}
    className={cn(
      "inline-flex h-8 shrink-0 items-center justify-center rounded-md border bg-transparent px-3 text-sm font-medium transition-colors hover:bg-secondary focus:outline-none focus:ring-1 focus:ring-ring disabled:pointer-events-none disabled:opacity-50 group-[.destructive]:border-muted/40 group-[.destructive]:hover:border-destructive/30 group-[.destructive]:hover:bg-destructive group-[.destructive]:hover:text-destructive-foreground group-[.destructive]:focus:ring-destructive",
      className,
    )}
    {...props}
  />
))
ToastAction.displayName = ToastPrimitives.Action.displayName

const ToastClose = React.forwardRef<
  React.ElementRef<typeof ToastPrimitives.Close>,
  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Close>
>(({ className, ...props }, ref) => (
  <ToastPrimitives.Close
    ref={ref}
    className={cn(
      "absolute right-1 top-1 rounded-md p-1 text-foreground/50 opacity-0 transition-opacity hover:text-foreground focus:opacity-100 focus:outline-none focus:ring-1 group-hover:opacity-100 group-[.destructive]:text-red-300 group-[.destructive]:hover:text-red-50 group-[.destructive]:focus:ring-red-400 group-[.destructive]:focus:ring-offset-red-600",
      className,
    )}
    toast-close=""
    {...props}
  >
    <Cross2Icon className="h-4 w-4" />
  </ToastPrimitives.Close>
))
ToastClose.displayName = ToastPrimitives.Close.displayName

const ToastTitle = React.forwardRef<
  React.ElementRef<typeof ToastPrimitives.Title>,
  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Title>
>(({ className, ...props }, ref) => (
  <ToastPrimitives.Title ref={ref} className={cn("text-sm font-semibold [&+div]:text-xs", className)} {...props} />
))
ToastTitle.displayName = ToastPrimitives.Title.displayName

const ToastDescription = React.forwardRef<
  React.ElementRef<typeof ToastPrimitives.Description>,
  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Description>
>(({ className, ...props }, ref) => (
  <ToastPrimitives.Description ref={ref} className={cn("text-sm opacity-90", className)} {...props} />
))
ToastDescription.displayName = ToastPrimitives.Description.displayName

type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>

type ToastActionElement = React.ReactElement<typeof ToastAction>

export {
  type ToastProps,
  type ToastActionElement,
  ToastProvider,
  ToastViewport,
  Toast,
  ToastTitle,
  ToastDescription,
  ToastClose,
  ToastAction,
}

[V0_FILE]typescriptreact:file="components/ui/use-toast.ts"
"use client"

import * as React from "react"

import type { ToastActionElement, ToastProps } from "@/components/ui/toast"

const TOAST_LIMIT = 5
const TOAST_REMOVE_DELAY = 1000000

type ToasterToast = ToastProps & {
  id: string
  title?: React.ReactNode
  description?: React.ReactNode
  action?: ToastActionElement
}

const actionTypes = {
  ADD_TOAST: "ADD_TOAST",
  UPDATE_TOAST: "UPDATE_TOAST",
  DISMISS_TOAST: "DISMISS_TOAST",
  REMOVE_TOAST: "REMOVE_TOAST",
} as const

let count = 0

function genId() {
  count = (count + 1) % Number.MAX_VALUE
  return count.toString()
}

type ActionType = typeof actionTypes

type Action =
  | {
      type: ActionType["ADD_TOAST"]
      toast: ToasterToast
    }
  | {
      type: ActionType["UPDATE_TOAST"]
      toast: Partial<ToasterToast>
    }
  | {
      type: ActionType["DISMISS_TOAST"]
      toastId?: string
    }
  | {
      type: ActionType["REMOVE_TOAST"]
      toastId?: string
    }

interface State {
  toasts: ToasterToast[]
}

const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()

const reducer = (state: State, action: Action): State => {
  switch (action.type) {
    case "ADD_TOAST":
      return {
        ...state,
        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
      }

case "UPDATE_TOAST":
      return {
        ...state,
        toasts: state.toasts.map((t) => (t.id === action.toast.id ? { ...t, ...action.toast } : t)),
      }

case "DISMISS_TOAST": {
      const { toastId } = action

// ! Side effects ! - This could be extracted into a dismissToast() action,
      // but I'll keep it here for simplicity
      if (toastId) {
        addToRemoveQueue(toastId)
      } else {
        state.toasts.forEach((toast) => {
          addToRemoveQueue(toast.id)
        })
      }

return {
        ...state,
        toasts: state.toasts.map((t) =>
          t.id === toastId || toastId === undefined
            ? {
                ...t,
                open: false,
              }
            : t,
        ),
      }
    }
    case "REMOVE_TOAST":
      if (action.toastId === undefined) {
        return {
          ...state,
          toasts: [],
        }
      }
      return {
        ...state,
        toasts: state.toasts.filter((t) => t.id !== action.toastId),
      }
  }
}

const listeners: Array<(state: State) => void> = []

let memoryState: State = { toasts: [] }

function dispatch(action: Action) {
  memoryState = reducer(memoryState, action)
  listeners.forEach((listener) => {
    listener(memoryState)
  })
}

type Toast = Omit<ToasterToast, "id">

function toast({ ...props }: Toast) {
  const id = genId()

const update = (props: ToasterToast) =>
    dispatch({
      type: "UPDATE_TOAST",
      toast: { ...props, id },
    })
  const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id })

dispatch({
    type: "ADD_TOAST",
    toast: {
      ...props,
      id,
      open: true,
      onOpenChange: (open) => {
        if (!open) dismiss()
      },
    },
  })

return {
    id: id,
    dismiss,
    update,
  }
}

function useToast() {
  const [state, setState] = React.useState<State>(memoryState)

React.useEffect(() => {
    listeners.push(setState)
    return () => {
      const index = listeners.indexOf(setState)
      if (index > -1) {
        listeners.splice(index, 1)
      }
    }
  }, [state])

return {
    ...state,
    toast,
    dismiss: (toastId?: string) => dispatch({ type: "DISMISS_TOAST", toastId }),
  }
}

function addToRemoveQueue(toastId: string) {
  if (toastTimeouts.has(toastId)) {
    return
  }

const timeout = setTimeout(() => {
    toastTimeouts.delete(toastId)
    dispatch({
      type: "REMOVE_TOAST",
      toastId,
    })
  }, TOAST_REMOVE_DELAY)

toastTimeouts.set(toastId, timeout)
}

export { useToast, toast }

[V0_FILE]typescriptreact:file="lib/utils.ts"
import { type ClassValue, clsx } from "clsx"
import { twMerge } from "tailwind-merge"

export function cn(...inputs: ClassValue[]) {
  return twMerge(clsx(inputs))
}
</article></body></html>

About

About