[V0_FILE]sql:file="scripts/01-create-tables.sql" -- Enable necessary extensions CREATE EXTENSION IF NOT EXISTS "uuid-ossp"; -- Users table (extends Supabase auth.users) CREATE TABLE public.users ( id UUID REFERENCES auth.users(id) PRIMARY KEY, name TEXT NOT NULL, email TEXT NOT NULL, phone TEXT, location_lat DECIMAL(10, 8), location_lng DECIMAL(11, 8), postal_code TEXT, address TEXT, deposit_status TEXT DEFAULT 'pending' CHECK (deposit_status IN ('pending', 'paid', 'refunded')), stripe_customer_id TEXT, notification_sound BOOLEAN DEFAULT true, created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Books table CREATE TABLE public.books ( id UUID DEFAULT uuid_generate_v4() PRIMARY KEY, seller_id UUID REFERENCES public.users(id) NOT NULL, title TEXT NOT NULL, author TEXT NOT NULL, isbn TEXT, genre TEXT NOT NULL, condition TEXT NOT NULL CHECK (condition IN ('new', 'like-new', 'good', 'fair')), price DECIMAL(10, 2) NOT NULL, images TEXT[] DEFAULT '{}', transfer_mode TEXT NOT NULL CHECK (transfer_mode IN ('self-transfer', 'shipping')), expected_delivery_date DATE, status TEXT DEFAULT 'available' CHECK (status IN ('pending-approval', 'available', 'sold', 'reserved', 'rejected')), admin_notes TEXT, created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Transactions table CREATE TABLE public.transactions ( id UUID DEFAULT uuid_generate_v4() PRIMARY KEY, book_id UUID REFERENCES public.books(id) NOT NULL, buyer_id UUID REFERENCES public.users(id) NOT NULL, seller_id UUID REFERENCES public.users(id) NOT NULL, offer_price DECIMAL(10, 2), final_price DECIMAL(10, 2), deposit_paid DECIMAL(10, 2) DEFAULT 100.00, platform_fee DECIMAL(10, 2) DEFAULT 20.00, payout_amount DECIMAL(10, 2), status TEXT DEFAULT 'requested' CHECK (status IN ('requested', 'negotiating', 'accepted', 'payment-pending', 'paid', 'delivered', 'completed', 'cancelled')), delivery_otp TEXT, otp_verified BOOLEAN DEFAULT false, buyer_confirmed BOOLEAN DEFAULT false, seller_confirmed BOOLEAN DEFAULT false, stripe_payment_intent_id TEXT, created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Chat channels table CREATE TABLE public.chat_channels ( id UUID DEFAULT uuid_generate_v4() PRIMARY KEY, transaction_id UUID REFERENCES public.transactions(id) NOT NULL, participants UUID[] NOT NULL, created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Chat messages table CREATE TABLE public.chat_messages ( id UUID DEFAULT uuid_generate_v4() PRIMARY KEY, channel_id UUID REFERENCES public.chat_channels(id) NOT NULL, sender_id UUID REFERENCES public.users(id) NOT NULL, message TEXT NOT NULL, message_type TEXT DEFAULT 'text' CHECK (message_type IN ('text', 'offer', 'system')), offer_amount DECIMAL(10, 2), created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Saved searches table CREATE TABLE public.saved_searches ( id UUID DEFAULT uuid_generate_v4() PRIMARY KEY, user_id UUID REFERENCES public.users(id) NOT NULL, name TEXT NOT NULL, search_params JSONB NOT NULL, notifications_enabled BOOLEAN DEFAULT true, created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Search history table CREATE TABLE public.search_history ( id UUID DEFAULT uuid_generate_v4() PRIMARY KEY, user_id UUID REFERENCES public.users(id) NOT NULL, search_query TEXT NOT NULL, search_params JSONB, created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Notifications table CREATE TABLE public.notifications ( id UUID DEFAULT uuid_generate_v4() PRIMARY KEY, user_id UUID REFERENCES public.users(id) NOT NULL, title TEXT NOT NULL, message TEXT NOT NULL, type TEXT NOT NULL, read BOOLEAN DEFAULT false, data JSONB, created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() ); -- Enable Row Level Security ALTER TABLE public.users ENABLE ROW LEVEL SECURITY; ALTER TABLE public.books ENABLE ROW LEVEL SECURITY; ALTER TABLE public.transactions ENABLE ROW LEVEL SECURITY; ALTER TABLE public.chat_channels ENABLE ROW LEVEL SECURITY; ALTER TABLE public.chat_messages ENABLE ROW LEVEL SECURITY; ALTER TABLE public.saved_searches ENABLE ROW LEVEL SECURITY; ALTER TABLE public.search_history ENABLE ROW LEVEL SECURITY; ALTER TABLE public.notifications ENABLE ROW LEVEL SECURITY; -- RLS Policies CREATE POLICY "Users can view their own profile" ON public.users FOR SELECT USING (auth.uid() = id); CREATE POLICY "Users can update their own profile" ON public.users FOR UPDATE USING (auth.uid() = id); CREATE POLICY "Anyone can view available books" ON public.books FOR SELECT USING (status = 'available' OR seller_id = auth.uid()); CREATE POLICY "Users can create books" ON public.books FOR INSERT WITH CHECK (auth.uid() = seller_id); CREATE POLICY "Sellers can update their books" ON public.books FOR UPDATE USING (auth.uid() = seller_id); CREATE POLICY "Users can view their transactions" ON public.transactions FOR SELECT USING (auth.uid() = buyer_id OR auth.uid() = seller_id); CREATE POLICY "Users can create transactions" ON public.transactions FOR INSERT WITH CHECK (auth.uid() = buyer_id); CREATE POLICY "Users can update their transactions" ON public.transactions FOR UPDATE USING (auth.uid() = buyer_id OR auth.uid() = seller_id); -- Chat policies CREATE POLICY "Users can view their chat channels" ON public.chat_channels FOR SELECT USING (auth.uid() = ANY(participants)); CREATE POLICY "Users can view messages in their channels" ON public.chat_messages FOR SELECT USING ( EXISTS ( SELECT 1 FROM public.chat_channels WHERE id = channel_id AND auth.uid() = ANY(participants) ) ); CREATE POLICY "Users can send messages in their channels" ON public.chat_messages FOR INSERT WITH CHECK ( auth.uid() = sender_id AND EXISTS ( SELECT 1 FROM public.chat_channels WHERE id = channel_id AND auth.uid() = ANY(participants) ) ); -- Other policies CREATE POLICY "Users can manage their saved searches" ON public.saved_searches FOR ALL USING (auth.uid() = user_id); CREATE POLICY "Users can manage their search history" ON public.search_history FOR ALL USING (auth.uid() = user_id); CREATE POLICY "Users can view their notifications" ON public.notifications FOR ALL USING (auth.uid() = user_id); [V0_FILE]sql:file="scripts/02-create-functions.sql" -- Function to handle new user registration CREATE OR REPLACE FUNCTION public.handle_new_user() RETURNS TRIGGER AS $$ BEGIN INSERT INTO public.users (id, name, email) VALUES (NEW.id, NEW.raw_user_meta_data->>'name', NEW.email); RETURN NEW; END; $$ LANGUAGE plpgsql SECURITY DEFINER; -- Trigger for new user registration CREATE TRIGGER on_auth_user_created AFTER INSERT ON auth.users FOR EACH ROW EXECUTE FUNCTION public.handle_new_user(); -- Function to generate OTP CREATE OR REPLACE FUNCTION public.generate_otp() RETURNS TEXT AS $$ BEGIN RETURN LPAD(FLOOR(RANDOM() * 1000000)::TEXT, 6, '0'); END; $$ LANGUAGE plpgsql; -- Function to calculate distance between two points CREATE OR REPLACE FUNCTION public.calculate_distance( lat1 DECIMAL, lng1 DECIMAL, lat2 DECIMAL, lng2 DECIMAL ) RETURNS DECIMAL AS $$ DECLARE earth_radius DECIMAL := 6371; -- Earth's radius in kilometers dlat DECIMAL; dlng DECIMAL; a DECIMAL; c DECIMAL; BEGIN dlat := RADIANS(lat2 - lat1); dlng := RADIANS(lng2 - lng1); a := SIN(dlat/2) * SIN(dlat/2) + COS(RADIANS(lat1)) * COS(RADIANS(lat2)) * SIN(dlng/2) * SIN(dlng/2); c := 2 * ATAN2(SQRT(a), SQRT(1-a)); RETURN earth_radius * c; END; $$ LANGUAGE plpgsql; -- Function to create notification CREATE OR REPLACE FUNCTION public.create_notification( p_user_id UUID, p_title TEXT, p_message TEXT, p_type TEXT, p_data JSONB DEFAULT NULL ) RETURNS UUID AS $$ DECLARE notification_id UUID; BEGIN INSERT INTO public.notifications (user_id, title, message, type, data) VALUES (p_user_id, p_title, p_message, p_type, p_data) RETURNING id INTO notification_id; RETURN notification_id; END; $$ LANGUAGE plpgsql SECURITY DEFINER; [V0_FILE]typescriptreact:file="lib/supabase.ts" import { createClient } from "@supabase/supabase-js" const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL! const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY! export const supabase = createClient(supabaseUrl, supabaseAnonKey) // Server-side client export const createServerClient = () => { return createClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY!) } [V0_FILE]typescriptreact:file="lib/stripe.ts" import Stripe from "stripe" export const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, { apiVersion: "2024-06-20", }) export const STRIPE_CONFIG = { SECURITY_DEPOSIT_AMOUNT: 10000, // ₹100 in paise PLATFORM_FEE: 2000, // ₹20 in paise CURRENCY: "inr", } [V0_FILE]typescriptreact:file="lib/types.ts" export interface User { id: string name: string email: string phone?: string location_lat?: number location_lng?: number postal_code?: string address?: string deposit_status: "pending" | "paid" | "refunded" stripe_customer_id?: string notification_sound: boolean created_at: string updated_at: string } export interface Book { id: string seller_id: string title: string author: string isbn?: string genre: string condition: "new" | "like-new" | "good" | "fair" price: number images: string[] transfer_mode: "self-transfer" | "shipping" expected_delivery_date?: string status: "pending-approval" | "available" | "sold" | "reserved" | "rejected" admin_notes?: string created_at: string updated_at: string seller?: User distance?: number } export interface Transaction { id: string book_id: string buyer_id: string seller_id: string offer_price?: number final_price?: number deposit_paid: number platform_fee: number payout_amount?: number status: | "requested" | "negotiating" | "accepted" | "payment-pending" | "paid" | "delivered" | "completed" | "cancelled" delivery_otp?: string otp_verified: boolean buyer_confirmed: boolean seller_confirmed: boolean stripe_payment_intent_id?: string created_at: string updated_at: string book?: Book buyer?: User seller?: User } export interface ChatMessage { id: string channel_id: string sender_id: string message: string message_type: "text" | "offer" | "system" offer_amount?: number created_at: string sender?: User } export interface SavedSearch { id: string user_id: string name: string search_params: any notifications_enabled: boolean created_at: string } export interface Notification { id: string user_id: string title: string message: string type: string read: boolean data?: any created_at: string } [V0_FILE]typescriptreact:file="hooks/use-auth.ts" "use client" import { useEffect, useState } from "react" import type { User } from "@supabase/supabase-js" import { supabase } from "@/lib/supabase" import type { User as AppUser } from "@/lib/types" export function useAuth() { const [user, setUser] = useState(null) const [profile, setProfile] = useState(null) const [loading, setLoading] = useState(true) useEffect(() => { // Get initial session supabase.auth.getSession().then(({ data: { session } }) => { setUser(session?.user ?? null) if (session?.user) { fetchProfile(session.user.id) } else { setLoading(false) } }) // Listen for auth changes const { data: { subscription }, } = supabase.auth.onAuthStateChange(async (event, session) => { setUser(session?.user ?? null) if (session?.user) { fetchProfile(session.user.id) } else { setProfile(null) setLoading(false) } }) return () => subscription.unsubscribe() }, []) const fetchProfile = async (userId: string) => { try { const { data, error } = await supabase.from("users").select("*").eq("id", userId).single() if (error) throw error setProfile(data) } catch (error) { console.error("Error fetching profile:", error) } finally { setLoading(false) } } const signIn = async (email: string, password: string) => { const { error } = await supabase.auth.signInWithPassword({ email, password, }) return { error } } const signUp = async (email: string, password: string, name: string) => { const { error } = await supabase.auth.signUp({ email, password, options: { data: { name }, }, }) return { error } } const signOut = async () => { const { error } = await supabase.auth.signOut() return { error } } return { user, profile, loading, signIn, signUp, signOut, refetchProfile: () => user && fetchProfile(user.id), } } [V0_FILE]typescriptreact:file="hooks/use-location.ts" "use client" import { useState } from "react" interface Location { lat: number lng: number } export function useLocation() { const [location, setLocation] = useState(null) const [loading, setLoading] = useState(false) const [error, setError] = useState(null) const getCurrentLocation = () => { if (!navigator.geolocation) { setError("Geolocation is not supported by this browser.") return } setLoading(true) setError(null) navigator.geolocation.getCurrentPosition( (position) => { setLocation({ lat: position.coords.latitude, lng: position.coords.longitude, }) setLoading(false) }, (error) => { setError(error.message) setLoading(false) }, { enableHighAccuracy: true, timeout: 10000, maximumAge: 300000, // 5 minutes }, ) } return { location, loading, error, getCurrentLocation, setLocation, } } [V0_FILE]typescriptreact:file="app/layout.tsx" import type React from "react" import type { Metadata } from "next" import { Inter } from "next/font/google" import "./globals.css" import { Toaster } from "@/components/ui/toaster" import { AuthProvider } from "@/components/auth-provider" const inter = Inter({ subsets: ["latin"] }) export const metadata: Metadata = { title: "BookEx - Second-Hand Book Exchange", description: "Buy and sell second-hand books with secure transactions", } export default function RootLayout({ children, }: { children: React.ReactNode }) { return ( {children} ) } [V0_FILE]typescriptreact:file="components/auth-provider.tsx" "use client" import type React from "react" import { createContext, useContext } from "react" import { useAuth } from "@/hooks/use-auth" import type { User } from "@supabase/supabase-js" import type { User as AppUser } from "@/lib/types" interface AuthContextType { user: User | null profile: AppUser | null loading: boolean signIn: (email: string, password: string) => Promise<{ error: any }> signUp: (email: string, password: string, name: string) => Promise<{ error: any }> signOut: () => Promise<{ error: any }> refetchProfile: () => void } const AuthContext = createContext(undefined) export function AuthProvider({ children }: { children: React.ReactNode }) { const auth = useAuth() return {children} } export function useAuthContext() { const context = useContext(AuthContext) if (context === undefined) { throw new Error("useAuthContext must be used within an AuthProvider") } return context } [V0_FILE]typescriptreact:file="app/page.tsx" "use client" import type React from "react" import { useEffect, useState } from "react" import { useRouter } from "next/navigation" import { useAuthContext } from "@/components/auth-provider" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Input } from "@/components/ui/input" import { Badge } from "@/components/ui/badge" import { BookOpen, MapPin, Search, Shield, Zap } from "lucide-react" import { supabase } from "@/lib/supabase" import type { Book } from "@/lib/types" import Link from "next/link" export default function HomePage() { const { user, loading } = useAuthContext() const router = useRouter() const [searchQuery, setSearchQuery] = useState("") const [featuredBooks, setFeaturedBooks] = useState([]) const [stats, setStats] = useState({ totalBooks: 0, totalUsers: 0, totalTransactions: 0, }) useEffect(() => { fetchFeaturedBooks() fetchStats() }, []) const fetchFeaturedBooks = async () => { try { const { data, error } = await supabase .from("books") .select(` *, seller:users(name, location_lat, location_lng) `) .eq("status", "available") .order("created_at", { ascending: false }) .limit(6) if (error) throw error setFeaturedBooks(data || []) } catch (error) { console.error("Error fetching featured books:", error) } } const fetchStats = async () => { try { const [booksResult, usersResult, transactionsResult] = await Promise.all([ supabase.from("books").select("id", { count: "exact", head: true }), supabase.from("users").select("id", { count: "exact", head: true }), supabase.from("transactions").select("id", { count: "exact", head: true }), ]) setStats({ totalBooks: booksResult.count || 0, totalUsers: usersResult.count || 0, totalTransactions: transactionsResult.count || 0, }) } catch (error) { console.error("Error fetching stats:", error) } } const handleSearch = (e: React.FormEvent) => { e.preventDefault() if (searchQuery.trim()) { router.push(`/search?q=${encodeURIComponent(searchQuery.trim())}`) } } if (loading) { return (

) } return (

{/* Header */}

BookEx

{/* Hero Section */}

Buy & Sell Books with Confidence

Discover amazing second-hand books from trusted sellers near you. Secure transactions, fair pricing, and a community of book lovers.

{/* Search Bar */} {/* Stats */}

{stats.totalBooks}+

Books Available

{stats.totalUsers}+

Active Users

{stats.totalTransactions}+

Successful Trades

{/* Features */}

Why Choose BookEx?

Secure Transactions

₹100 security deposit system ensures trust and accountability between buyers and sellers.

Location-Based

Find books near you with our smart location matching and distance calculation.

Real-time Chat

Negotiate prices and coordinate exchanges with built-in messaging system.

{/* Featured Books */} {featuredBooks.length > 0 && (

Featured Books

{featuredBooks.map((book) => (

{book.title} by {book.author}

{book.condition}

₹{book.price}

{book.seller?.name}

))}

)} {/* CTA Section */}

Ready to Start Trading Books?

Join thousands of book lovers who are already buying and selling on BookEx.

{/* Footer */}

) } [V0_FILE]typescriptreact:file="app/loading.tsx" isFixed="true" export default function Loading() { return null } [V0_FILE]typescriptreact:file="app/auth/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 { useAuthContext } from "@/components/auth-provider" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Alert, AlertDescription } from "@/components/ui/alert" import { BookOpen, Eye, EyeOff } from "lucide-react" import { useToast } from "@/hooks/use-toast" export default function LoginPage() { const [email, setEmail] = useState("") const [password, setPassword] = useState("") const [showPassword, setShowPassword] = useState(false) const [loading, setLoading] = useState(false) const [error, setError] = useState("") const { signIn } = useAuthContext() const router = useRouter() const { toast } = useToast() const handleSubmit = async (e: React.FormEvent) => { e.preventDefault() setLoading(true) setError("") try { const { error } = await signIn(email, password) if (error) { setError(error.message) } else { toast({ title: "Welcome back!", description: "You have been successfully logged in.", }) router.push("/dashboard") } } catch (err) { setError("An unexpected error occurred") } finally { setLoading(false) } } return (

{/* Logo */}

BookEx

Welcome Back Sign in to your account to continue buying and selling books

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

Forgot your password?

) } [V0_FILE]typescriptreact:file="app/auth/register/page.tsx" "use client" import type React from "react" import { useState } from "react" import { useRouter } from "next/navigation" import Link from "next/link" import { useAuthContext } from "@/components/auth-provider" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Alert, AlertDescription } from "@/components/ui/alert" import { Checkbox } from "@/components/ui/checkbox" import { BookOpen, Eye, EyeOff } from "lucide-react" import { useToast } from "@/hooks/use-toast" export default function RegisterPage() { const [formData, setFormData] = useState({ name: "", email: "", password: "", confirmPassword: "", }) const [showPassword, setShowPassword] = useState(false) const [showConfirmPassword, setShowConfirmPassword] = useState(false) const [acceptTerms, setAcceptTerms] = useState(false) const [loading, setLoading] = useState(false) const [error, setError] = useState("") const { signUp } = useAuthContext() const router = useRouter() const { toast } = useToast() const handleChange = (e: React.ChangeEvent) => { setFormData((prev) => ({ ...prev, [e.target.name]: e.target.value, })) } const handleSubmit = async (e: React.FormEvent) => { e.preventDefault() setLoading(true) setError("") // Validation if (formData.password !== formData.confirmPassword) { setError("Passwords do not match") setLoading(false) return } if (formData.password.length < 6) { setError("Password must be at least 6 characters long") setLoading(false) return } if (!acceptTerms) { setError("Please accept the terms and conditions") setLoading(false) return } try { const { error } = await signUp(formData.email, formData.password, formData.name) if (error) { setError(error.message) } else { toast({ title: "Account created!", description: "Please check your email to verify your account.", }) router.push("/auth/verify-email") } } catch (err) { setError("An unexpected error occurred") } finally { setLoading(false) } } return (

{/* Logo */}

BookEx

Create Account Join BookEx to start buying and selling books

{error && ( {error} )}

Full Name

Password

Confirm Password

setAcceptTerms(checked as boolean)} /> I agree to the{" "} Terms of Service {" "} and{" "} Privacy Policy

Already have an account?{" "} Sign in

) } [V0_FILE]typescriptreact:file="app/dashboard/page.tsx" isFixed="true" isQuickEdit="true" "use client" import { useEffect, useState } from "react" import { useRouter } from "next/navigation" import { useAuthContext } from "@/components/auth-provider" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Badge } from "@/components/ui/badge" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { Alert, AlertDescription } from "@/components/ui/alert" import { BookOpen, Plus, ShoppingCart, DollarSign, MessageCircle, Bell, AlertCircle, CheckCircle, Clock, } from "lucide-react" import { supabase } from "@/lib/supabase" import type { Book, Transaction, Notification } from "@/lib/types" import Link from "next/link" import { useToast } from "@/hooks/use-toast" export default function DashboardPage() { const { user, profile, loading } = useAuthContext() const router = useRouter() const { toast } = useToast() const [myBooks, setMyBooks] = useState([]) const [myPurchases, setMyPurchases] = useState([]) const [mySales, setMySales] = useState([]) const [notifications, setNotifications] = useState([]) const [stats, setStats] = useState({ totalListings: 0, activeSales: 0, completedSales: 0, totalPurchases: 0, }) useEffect(() => { if (!loading && !user) { router.push("/auth/login") return } if (user) { fetchDashboardData() } }, [user, loading, router]) const fetchDashboardData = async () => { if (!user) return try { // Fetch user's books const { data: books } = await supabase .from("books") .select("*") .eq("seller_id", user.id) .order("created_at", { ascending: false }) setMyBooks(books || []) // Fetch purchases const { data: purchases } = await supabase .from("transactions") .select(` *, book:books(*), seller:users(name) `) .eq("buyer_id", user.id) .order("created_at", { ascending: false }) setMyPurchases(purchases || []) // Fetch sales const { data: sales } = await supabase .from("transactions") .select(` *, book:books(*), buyer:users(name) `) .eq("seller_id", user.id) .order("created_at", { ascending: false }) setMySales(sales || []) // Fetch notifications const { data: notifs } = await supabase .from("notifications") .select("*") .eq("user_id", user.id) .order("created_at", { ascending: false }) .limit(10) setNotifications(notifs || []) // Calculate stats const totalListings = books?.length || 0 const activeSales = sales?.filter((s) => ["requested", "negotiating", "accepted", "payment-pending", "paid"].includes(s.status)) .length || 0 const completedSales = sales?.filter((s) => s.status === "completed").length || 0 const totalPurchases = purchases?.length || 0 setStats({ totalListings, activeSales, completedSales, totalPurchases, }) } catch (error) { console.error("Error fetching dashboard data:", error) toast({ title: "Error", description: "Failed to load dashboard data", variant: "destructive", }) } } const getStatusColor = (status: string) => { switch (status) { case "available": return "bg-green-100 text-green-800" case "pending-approval": return "bg-yellow-100 text-yellow-800" case "sold": return "bg-blue-100 text-blue-800" case "reserved": return "bg-purple-100 text-purple-800" case "rejected": return "bg-red-100 text-red-800" default: return "bg-gray-100 text-gray-800" } } const getTransactionStatusColor = (status: string) => { switch (status) { case "completed": return "bg-green-100 text-green-800" case "requested": return "bg-blue-100 text-blue-800" case "negotiating": return "bg-yellow-100 text-yellow-800" case "accepted": return "bg-purple-100 text-purple-800" case "cancelled": return "bg-red-100 text-red-800" default: return "bg-gray-100 text-gray-800" } } if (loading) { return (

) } if (!user) { return null } return (

{/* Header */}

BookEx

{/* Welcome Section */}

Welcome back, {profile?.name}!

Manage your books, track your transactions, and stay updated with your BookEx activity.

{/* Deposit Status Alert */} {profile?.deposit_status === "pending" && ( You need to pay a ₹100 security deposit before you can sell books.{" "} List your first book to get started. )} {/* Stats Cards */}

Total Listings

{stats.totalListings}

Active Sales

{stats.activeSales}

Completed Sales

{stats.completedSales}

Total Purchases

{stats.totalPurchases}

{/* Main Content */} My Books My Purchases My Sales Notifications

My Books Manage your book listings

{myBooks.length === 0 ? (

No books listed yet

Start selling by adding your first book.

) : (

{myBooks.map((book) => (

{book.title}

by {book.author}

{book.status.replace("-", " ")} ₹{book.price}

))}

)} My Purchases Track your book purchases and transactions {myPurchases.length === 0 ? (

No purchases yet

Start browsing books to make your first purchase.

) : (

{myPurchases.map((transaction) => (

{transaction.book?.title}

Seller: {transaction.seller?.name}

{transaction.status.replace("-", " ")} ₹{transaction.final_price || transaction.offer_price}

{transaction.status === "requested" && ( )}

))}

)} My Sales Track your book sales and manage transactions {mySales.length === 0 ? (

No sales yet

List some books to start receiving purchase requests.

) : (

{mySales.map((transaction) => (

{transaction.book?.title}

Buyer: {transaction.buyer?.name}

{transaction.status.replace("-", " ")} ₹{transaction.final_price || transaction.offer_price}

{["requested", "negotiating"].includes(transaction.status) && ( )}

))}

)} Notifications Stay updated with your BookEx activity {notifications.length === 0 ? (

No notifications

You're all caught up!

) : (

{notifications.map((notification) => (

{notification.title}

{notification.message}

{new Date(notification.created_at).toLocaleDateString()}

{!notification.read &&

}

))}

)}

) } [V0_FILE]typescriptreact:file="app/search/page.tsx" isFixed="true" isQuickEdit="true" "use client" import type React from "react" import { useEffect, useState } from "react" import { useSearchParams, useRouter } from "next/navigation" import { useAuthContext } from "@/components/auth-provider" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, 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 { Badge } from "@/components/ui/badge" import { Slider } from "@/components/ui/slider" import { BookOpen, Search, MapPin, Filter, Heart, Navigation } from "lucide-react" import { supabase } from "@/lib/supabase" import { useLocation } from "@/hooks/use-location" import type { Book } from "@/lib/types" import Link from "next/link" import { useToast } from "@/hooks/use-toast" const GENRES = [ "Fiction", "Non-Fiction", "Mystery", "Romance", "Science Fiction", "Fantasy", "Biography", "History", "Self-Help", "Business", "Technology", "Health", "Travel", "Cooking", "Art", ] const CONDITIONS = [ { value: "new", label: "New" }, { value: "like-new", label: "Like New" }, { value: "good", label: "Good" }, { value: "fair", label: "Fair" }, ] export default function SearchPage() { const { user } = useAuthContext() const searchParams = useSearchParams() const router = useRouter() const { toast } = useToast() const { location, getCurrentLocation, loading: locationLoading } = useLocation() const [searchQuery, setSearchQuery] = useState(searchParams.get("q") || "") const [books, setBooks] = useState([]) const [loading, setLoading] = useState(false) const [showFilters, setShowFilters] = useState(false) // Filters const [filters, setFilters] = useState({ genre: "", condition: "", minPrice: 0, maxPrice: 1000, distance: 50, // km transferMode: "", }) const [savedSearches, setSavedSearches] = useState([]) useEffect(() => { const query = searchParams.get("q") if (query) { setSearchQuery(query) performSearch(query) } else { performSearch("") } if (user) { fetchSavedSearches() } }, [searchParams, user]) const fetchSavedSearches = async () => { if (!user) return try { const { data, error } = await supabase .from("saved_searches") .select("*") .eq("user_id", user.id) .order("created_at", { ascending: false }) if (error) throw error setSavedSearches(data || []) } catch (error) { console.error("Error fetching saved searches:", error) } } const performSearch = async (query: string = searchQuery) => { setLoading(true) try { let supabaseQuery = supabase .from("books") .select(` *, seller:users(name, location_lat, location_lng) `) .eq("status", "available") // Text search if (query.trim()) { supabaseQuery = supabaseQuery.or(`title.ilike.%${query}%,author.ilike.%${query}%,isbn.ilike.%${query}%`) } // Apply filters if (filters.genre) { supabaseQuery = supabaseQuery.eq("genre", filters.genre) } if (filters.condition) { supabaseQuery = supabaseQuery.eq("condition", filters.condition) } if (filters.transferMode) { supabaseQuery = supabaseQuery.eq("transfer_mode", filters.transferMode) } supabaseQuery = supabaseQuery .gte("price", filters.minPrice) .lte("price", filters.maxPrice) .order("created_at", { ascending: false }) const { data, error } = await supabaseQuery if (error) throw error let booksWithDistance = data || [] // Calculate distance if user location is available if (location) { booksWithDistance = booksWithDistance.map((book) => { if (book.seller?.location_lat && book.seller?.location_lng) { const distance = calculateDistance( location.lat, location.lng, book.seller.location_lat, book.seller.location_lng, ) return { ...book, distance } } return book }) // Filter by distance booksWithDistance = booksWithDistance.filter((book) => !book.distance || book.distance <= filters.distance) // Sort by distance booksWithDistance.sort((a, b) => (a.distance || 999) - (b.distance || 999)) } setBooks(booksWithDistance) // Save search history if (user && query.trim()) { await supabase.from("search_history").insert({ user_id: user.id, search_query: query, search_params: filters, }) } } catch (error) { console.error("Error searching books:", error) toast({ title: "Search Error", description: "Failed to search books. Please try again.", variant: "destructive", }) } finally { setLoading(false) } } const calculateDistance = (lat1: number, lng1: number, lat2: number, lng2: number) => { const R = 6371 // Earth's radius in kilometers const dLat = ((lat2 - lat1) * Math.PI) / 180 const dLng = ((lng2 - lng1) * Math.PI) / 180 const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos((lat1 * Math.PI) / 180) * Math.cos((lat2 * Math.PI) / 180) * Math.sin(dLng / 2) * Math.sin(dLng / 2) const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)) return R * c } const handleSearch = (e: React.FormEvent) => { e.preventDefault() const params = new URLSearchParams() if (searchQuery.trim()) { params.set("q", searchQuery.trim()) } router.push(`/search?${params.toString()}`) } const saveSearch = async () => { if (!user) { toast({ title: "Login Required", description: "Please login to save searches.", variant: "destructive", }) return } const searchName = prompt("Enter a name for this search:") if (!searchName) return try { const { error } = await supabase.from("saved_searches").insert({ user_id: user.id, name: searchName, search_params: { query: searchQuery, ...filters, }, }) if (error) throw error toast({ title: "Search Saved", description: "Your search has been saved successfully.", }) fetchSavedSearches() } catch (error) { console.error("Error saving search:", error) toast({ title: "Error", description: "Failed to save search.", variant: "destructive", }) } } const loadSavedSearch = (savedSearch: any) => { const params = savedSearch.search_params setSearchQuery(params.query || "") setFilters({ genre: params.genre || "", condition: params.condition || "", minPrice: params.minPrice || 0, maxPrice: params.maxPrice || 1000, distance: params.distance || 50, transferMode: params.transferMode || "", }) performSearch(params.query || "") } return (

{/* Header */}

BookEx

{/* Sidebar - Filters */}

Filters

{/* Location */}

Location {location && (

Distance (km) setFilters((prev) => ({ ...prev, distance: value[0] }))} max={100} min={1} step={1} className="mt-2" />

Within {filters.distance} km

)}

{/* Genre */}

Genre

{/* Condition */}

Condition

{/* Price Range */}

Price Range

setFilters((prev) => ({ ...prev, minPrice: value[0], maxPrice: value[1] })) } max={2000} min={0} step={50} />

₹{filters.minPrice} ₹{filters.maxPrice}

{/* Transfer Mode */}

Transfer Mode

{user && ( )} {/* Saved Searches */} {user && savedSearches.length > 0 && ( Saved Searches

{savedSearches.map((search) => ( ))}

)}

{/* Main Content */}

{/* Search Bar */} {/* Results */}

{loading ? (

Searching for books...

) : books.length === 0 ? (

No books found

Try adjusting your search terms or filters to find more books.

) : ( <>

Found {books.length} book{books.length !== 1 ? "s" : ""}

{books.map((book) => (

{book.title} by {book.author} {book.isbn &&

ISBN: {book.isbn}

}

{book.condition.replace("-", " ")}

₹{book.price}

{book.genre}

{book.seller?.name} {book.distance && • {book.distance.toFixed(1)} km away}

{book.transfer_mode.replace("-", " ")}

))}

)}

) } [V0_FILE]typescriptreact:file="app/search/loading.tsx" isFixed="true" export default function Loading() { return null } [V0_FILE]typescriptreact:file="app/api/stripe/create-payment-intent/route.ts" import { type NextRequest, NextResponse } from "next/server" import { stripe } from "@/lib/stripe" export async function POST(request: NextRequest) { try { const { amount, currency = "inr", metadata = {} } = await request.json() if (!amount || amount < 50) { return NextResponse.json({ error: "Amount must be at least ₹0.50" }, { status: 400 }) } const paymentIntent = await stripe.paymentIntents.create({ amount: Math.round(amount * 100), // Convert to paise currency, metadata, automatic_payment_methods: { enabled: true, }, }) return NextResponse.json({ clientSecret: paymentIntent.client_secret, paymentIntentId: paymentIntent.id, }) } catch (error) { console.error("Error creating payment intent:", error) return NextResponse.json({ error: "Failed to create payment intent" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/api/stripe/webhook/route.ts" import { type NextRequest, NextResponse } from "next/server" import { stripe } from "@/lib/stripe" import { createServerClient } from "@/lib/supabase" import type Stripe from "stripe" const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET! export async function POST(request: NextRequest) { try { const body = await request.text() const signature = request.headers.get("stripe-signature")! let event: Stripe.Event try { event = stripe.webhooks.constructEvent(body, signature, webhookSecret) } catch (err) { console.error("Webhook signature verification failed:", err) return NextResponse.json({ error: "Invalid signature" }, { status: 400 }) } const supabase = createServerClient() switch (event.type) { case "payment_intent.succeeded": const paymentIntent = event.data.object as Stripe.PaymentIntent // Handle security deposit payment if (paymentIntent.metadata.type === "security_deposit") { await supabase.from("users").update({ deposit_status: "paid" }).eq("id", paymentIntent.metadata.user_id) } // Handle book purchase payment if (paymentIntent.metadata.type === "book_purchase") { const transactionId = paymentIntent.metadata.transaction_id await supabase .from("transactions") .update({ status: "paid", stripe_payment_intent_id: paymentIntent.id, }) .eq("id", transactionId) // Generate delivery OTP const { data: transaction } = await supabase .from("transactions") .select("*, book:books(*)") .eq("id", transactionId) .single() if (transaction) { const otp = Math.floor(100000 + Math.random() * 900000).toString() await supabase.from("transactions").update({ delivery_otp: otp }).eq("id", transactionId) // Create notifications await Promise.all([ supabase.from("notifications").insert({ user_id: transaction.buyer_id, title: "Payment Successful", message: `Your payment for "${transaction.book.title}" has been processed. You will receive an OTP for delivery confirmation.`, type: "payment_success", }), supabase.from("notifications").insert({ user_id: transaction.seller_id, title: "Payment Received", message: `Payment received for "${transaction.book.title}". Please coordinate delivery with the buyer.`, type: "payment_received", }), ]) } } break case "payment_intent.payment_failed": const failedPayment = event.data.object as Stripe.PaymentIntent if (failedPayment.metadata.type === "book_purchase") { await supabase .from("transactions") .update({ status: "payment-pending" }) .eq("id", failedPayment.metadata.transaction_id) } break } return NextResponse.json({ received: true }) } catch (error) { console.error("Webhook error:", error) return NextResponse.json({ error: "Webhook handler failed" }, { status: 500 }) } }