[V0_FILE]typescriptreact:file="app/names/page.tsx" isMerged="true" import { redirect } from "next/navigation" import { createServerClient } from "@/lib/supabase-server" import DashboardLayout from "@/components/dashboard-layout" import NameSearch from "@/components/name-search" export default async function Names() { const supabase = createServerClient() const { data: { session }, } = await supabase.auth.getSession() if (!session) { redirect("/") } return ( ) } [V0_FILE]typescriptreact:file="app/names/loading.tsx" isFixed="true" isMerged="true" export default function Loading() { return null } [V0_FILE]typescriptreact:file="app/vehicles/page.tsx" isMerged="true" import { redirect } from "next/navigation" import { createServerClient } from "@/lib/supabase-server" import DashboardLayout from "@/components/dashboard-layout" import VehicleSearch from "@/components/vehicle-search" export default async function Vehicles() { const supabase = createServerClient() const { data: { session }, } = await supabase.auth.getSession() if (!session) { redirect("/") } return ( ) } [V0_FILE]typescriptreact:file="app/vehicles/loading.tsx" isFixed="true" isMerged="true" export default function Loading() { return null } [V0_FILE]typescriptreact:file="app/cad/page.tsx" isMerged="true" import { redirect } from "next/navigation" import { createServerClient } from "@/lib/supabase-server" import DashboardLayout from "@/components/dashboard-layout" import CADInterface from "@/components/cad-interface" export default async function CAD() { const supabase = createServerClient() const { data: { session }, } = await supabase.auth.getSession() if (!session) { redirect("/") } return ( ) } [V0_FILE]typescriptreact:file="components/dashboard-layout.tsx" isMerged="true" "use client" import type React from "react" import { useState } from "react" import Link from "next/link" import { usePathname } from "next/navigation" import { useAuth } from "@/lib/auth-provider" import { User, Car, Home, Book, FileText, AlertTriangle } from "lucide-react" export default function DashboardLayout({ children }: { children: React.ReactNode }) { const { signOut } = useAuth() const pathname = usePathname() const [currentTime, setCurrentTime] = useState(new Date()) // Update time every second useState(() => { const timer = setInterval(() => { setCurrentTime(new Date()) }, 1000) return () => clearInterval(timer) }) const formatTime = (date: Date) => { return date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", hour12: false }) } const formatDate = (date: Date) => { return date.toLocaleDateString([], { month: "2-digit", day: "2-digit", year: "2-digit" }) } return (

{/* Header */}

Northpoint 6.3

Northpoint Law Enforcement

{/* Menu Bar */}

File

View

Message Center

CAD Reports

Help

{/* Navigation */} {/* Command Input */}

Command:

Usage:

{/* Main Content */}

{children}

{/* Status Bar */}

) } [V0_FILE]typescriptreact:file="components/name-search.tsx" isMerged="true" "use client" import type React from "react" import { useState } from "react" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Checkbox } from "@/components/ui/checkbox" import { useToast } from "@/components/ui/use-toast" import { Printer, Save, Trash2, Forward, Phone, FileText, RotateCcw } from "lucide-react" interface Person { id: number first_name: string last_name: string dob: string gender: string driver_license: string address: string flags: string[] notes: string } export default function NameSearch() { const [searchParams, setSearchParams] = useState({ lastName: "", firstName: "", dob: "", driverLicense: "", gender: "", }) const [localNames, setLocalNames] = useState(false) const [searchResults, setSearchResults] = useState([]) const [loading, setLoading] = useState(false) const [selectedPerson, setSelectedPerson] = useState(null) const { toast } = useToast() const handleInputChange = (e: React.ChangeEvent) => { const { name, value } = e.target setSearchParams((prev) => ({ ...prev, [name]: value })) } const handleSearch = async () => { setLoading(true) try { const queryParams = new URLSearchParams() if (searchParams.lastName) queryParams.append("lastName", searchParams.lastName) if (searchParams.firstName) queryParams.append("firstName", searchParams.firstName) if (searchParams.dob) queryParams.append("dob", searchParams.dob) if (searchParams.driverLicense) queryParams.append("driverLicense", searchParams.driverLicense) const response = await fetch(`/api/persons?${queryParams.toString()}`) const data = await response.json() if (data.error) { throw new Error(data.error) } setSearchResults(data.data || []) } catch (error: any) { toast({ title: "Error", description: error.message || "Failed to search", variant: "destructive", }) } finally { setLoading(false) } } const handlePersonSelect = (person: Person) => { setSelectedPerson(person) } return (

Name Search

setSearchParams((prev) => ({ ...prev, lastName: e.target.value }))} />

setLocalNames(checked as boolean)} /> Local Names

Last:

Birth Date:

Driver License:

Gender:

Messages

{searchResults.length > 0 ? (

{searchResults.map((person) => (

handlePersonSelect(person)} >

{person.last_name}, {person.first_name}

DOB: {person.dob}

License: {person.driver_license}

))}

) : (

{loading ? "Searching..." : "No results found"}

)}

) } [V0_FILE]typescriptreact:file="components/vehicle-search.tsx" isMerged="true" "use client" import type React from "react" import { useState } from "react" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { useToast } from "@/components/ui/use-toast" import { Printer, Save, Trash2, Forward, Phone } from "lucide-react" interface Vehicle { id: number plate: string model: string color: string registered_to: number stolen: boolean flags: string[] notes: string persons: { first_name: string last_name: string } } export default function VehicleSearch() { const [searchParams, setSearchParams] = useState({ plate: "", model: "", color: "", }) const [searchResults, setSearchResults] = useState([]) const [loading, setLoading] = useState(false) const [selectedVehicle, setSelectedVehicle] = useState(null) const { toast } = useToast() const handleInputChange = (e: React.ChangeEvent) => { const { name, value } = e.target setSearchParams((prev) => ({ ...prev, [name]: value })) } const handleSearch = async () => { setLoading(true) try { const queryParams = new URLSearchParams() if (searchParams.plate) queryParams.append("plate", searchParams.plate) const response = await fetch(`/api/vehicles?${queryParams.toString()}`) const data = await response.json() if (data.error) { throw new Error(data.error) } setSearchResults(data.data || []) } catch (error: any) { toast({ title: "Error", description: error.message || "Failed to search", variant: "destructive", }) } finally { setLoading(false) } } const handleVehicleSelect = (vehicle: Vehicle) => { setSelectedVehicle(vehicle) } return (

Vehicle Search

setSearchParams((prev) => ({ ...prev, plate: e.target.value }))} />

Plate:

Model:

Color:

Results

{searchResults.length > 0 ? (

{searchResults.map((vehicle) => (

handleVehicleSelect(vehicle)} >

{vehicle.plate}

{vehicle.color} {vehicle.model}

Owner: {vehicle.persons?.first_name} {vehicle.persons?.last_name}

{vehicle.stolen &&

STOLEN

}

))}

) : (

{loading ? "Searching..." : "No results found"}

)}

) } [V0_FILE]typescriptreact:file="components/cad-interface.tsx" isMerged="true" "use client" import { useState, useEffect } from "react" import { useToast } from "@/components/ui/use-toast" interface Call { id: number call_number: string nature: string address: string priority: number status: string created_at: string } interface Unit { id: number identifier: string status: string user_id: number } export default function CADInterface() { const [pendingCalls, setPendingCalls] = useState([]) const [activeCalls, setActiveCalls] = useState([]) const [units, setUnits] = useState([]) const [loading, setLoading] = useState(true) const { toast } = useToast() const fetchData = async () => { try { const response = await fetch("/api/calls") const data = await response.json() if (data.error) { throw new Error(data.error) } setPendingCalls(data.pendingCalls || []) setActiveCalls(data.activeCalls || []) } catch (error: any) { toast({ title: "Error", description: error.message || "Failed to fetch data", variant: "destructive", }) } finally { setLoading(false) } } useEffect(() => { fetchData() // Refresh data every 10 seconds const interval = setInterval(fetchData, 10000) return () => clearInterval(interval) }, []) const formatTime = (dateString: string) => { const date = new Date(dateString) return date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", hour12: false }) } return (

CAD_1 Undispatched Calls ({pendingCalls.length})

{pendingCalls.map((call) => ( ))}

Call	T	P	Nature	Address	R	S	City	Zone	Time	Stat
{call.call_number}	1	{call.priority}	{call.nature}	{call.address}					{formatTime(call.created_at)}	RCVD

CAD_1 Dispatched Calls ({activeCalls.length})

{activeCalls.map((call) => ( ))}

Call	T	P	Nature	Address	City	Time	Stat	Units
{call.call_number}	1	{call.priority}	{call.nature}	{call.address}		{formatTime(call.created_at)}	RCVD

CAD_1 Unit Status ({units.length})

Identifier	Name	Attached Call	Stat
950	darnel.montgomery		RCVD
605	andrew.merrifield		RCVD

) } [V0_FILE]typescriptreact:file="lib/supabase/client.ts" isMerged="true" import { createClient } from "@supabase/supabase-js" let supabaseClient: ReturnType | null = null export const getSupabaseClient = () => { if (!supabaseClient) { supabaseClient = createClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!) } return supabaseClient } [V0_FILE]typescriptreact:file="lib/supabase/server.ts" isMerged="true" import { createClient } from "@supabase/supabase-js" import { cookies } from "next/headers" export const getSupabaseServer = () => { const cookieStore = cookies() return createClient(process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY!, { auth: { persistSession: false, }, }) } [V0_FILE]typescriptreact:file="lib/types.ts" isEdit="true" isMerged="true" export interface User { id: number username: string full_name: string badge_number: string department: string rank: string is_admin: boolean } export interface Person { id: number first_name: string last_name: string dob: string gender: string address: string driver_license: string license_expiry: string flags: string[] notes: string } export interface Vehicle { id: number plate: string model: string color: string registered_to: number stolen: boolean flags: string[] notes: string } export interface Call { id: number call_number: string nature: string address: string priority: number status: string description: string created_at: string } export interface Unit { id: number identifier: string user_id: number status: string current_call_id: number | null } export interface CriminalRecord { id: number person_id: number offense: string description: string date: string officer_id: number } [V0_FILE]typescriptreact:file="app/mdt/page.tsx" isMerged="true" import { cookies } from "next/headers" import { getSupabaseServer } from "@/lib/supabase/server" import MDTDashboard from "@/components/mdt/dashboard" export default async function MDTPage() { const cookieStore = cookies() const sessionCookie = cookieStore.get("mdt_session") if (!sessionCookie) { return null } const supabase = getSupabaseServer() const { data: user } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() const { data: calls } = await supabase.from("calls").select("*").order("created_at", { ascending: false }).limit(10) const { data: units } = await supabase.from("units").select("*") return } [V0_FILE]typescriptreact:file="app/mdt/names/page.tsx" isMerged="true" import { cookies } from "next/headers" import { getSupabaseServer } from "@/lib/supabase/server" import NameSearch from "@/components/mdt/name-search" export default async function NamesPage() { const cookieStore = cookies() const sessionCookie = cookieStore.get("mdt_session") if (!sessionCookie) { return null } const supabase = getSupabaseServer() const { data: persons } = await supabase.from("persons").select("*") return } [V0_FILE]typescriptreact:file="components/mdt/name-search.tsx" isMerged="true" "use client" import { useState } from "react" import type { Person } from "@/lib/types" import { Input } from "@/components/ui/input" import { Button } from "@/components/ui/button" import { Checkbox } from "@/components/ui/checkbox" import { Label } from "@/components/ui/label" import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table" import { format } from "date-fns" import { getSupabaseClient } from "@/lib/supabase/client" interface NameSearchProps { initialPersons: Person[] } export default function NameSearch({ initialPersons }: NameSearchProps) { const [searchQuery, setSearchQuery] = useState("") const [localNames, setLocalNames] = useState(true) const [persons, setPersons] = useState(initialPersons) const [selectedPerson, setSelectedPerson] = useState(null) const [formData, setFormData] = useState({ last: "", birthDate: "", driverLicense: "", gender: "", }) const handleSearch = async () => { const supabase = getSupabaseClient() let query = supabase.from("persons").select("*") if (searchQuery) { query = query.or(`first_name.ilike.%${searchQuery}%,last_name.ilike.%${searchQuery}%`) } if (formData.last) { query = query.ilike("last_name", `%${formData.last}%`) } if (formData.birthDate) { query = query.eq("dob", formData.birthDate) } if (formData.driverLicense) { query = query.ilike("driver_license", `%${formData.driverLicense}%`) } if (formData.gender) { query = query.ilike("gender", `%${formData.gender}%`) } const { data } = await query setPersons(data || []) } const handlePersonSelect = (person: Person) => { setSelectedPerson(person) } return (

Name Search

setSearchQuery(e.target.value)} className="flex-1 mr-2" />

setLocalNames(checked as boolean)} /> Local Names

Last: setFormData({ ...formData, last: e.target.value })} className="mdt-input" />

Birth Date: setFormData({ ...formData, birthDate: e.target.value })} className="mdt-input" placeholder="MM/DD/YYYY" />

Driver License: setFormData({ ...formData, driverLicense: e.target.value })} className="mdt-input" placeholder="MM/DD/YYYY" />

Gender: setFormData({ ...formData, gender: e.target.value })} className="mdt-input" />

Messages

{selectedPerson ? (

{selectedPerson.first_name} {selectedPerson.last_name}

DOB:{" "} {selectedPerson.dob ? format(new Date(selectedPerson.dob), "MM/dd/yyyy") : "N/A"}

Gender: {selectedPerson.gender || "N/A"}

Address: {selectedPerson.address || "N/A"}

Driver License: {selectedPerson.driver_license || "N/A"}

License Expiry:{" "} {selectedPerson.license_expiry ? format(new Date(selectedPerson.license_expiry), "MM/dd/yyyy") : "N/A"}

Flags: {selectedPerson.flags?.join(", ") || "None"}

Notes:

{selectedPerson.notes || "No notes available"}

) : (

Select a person to view details

)}

ID Name DOB Gender Address License {persons.map((person) => ( handlePersonSelect(person)} > {person.id} {person.first_name} {person.last_name} {person.dob ? format(new Date(person.dob), "MM/dd/yyyy") : "N/A"} {person.gender || "N/A"} {person.address || "N/A"} {person.driver_license || "N/A"} ))} {persons.length === 0 && ( No results found )}

) } [V0_FILE]typescriptreact:file="app/mdt/vehicles/page.tsx" isMerged="true" import { cookies } from "next/headers" import { getSupabaseServer } from "@/lib/supabase/server" import VehicleSearch from "@/components/mdt/vehicle-search" export default async function VehiclesPage() { const cookieStore = cookies() const sessionCookie = cookieStore.get("mdt_session") if (!sessionCookie) { return null } const supabase = getSupabaseServer() const { data: vehicles } = await supabase.from("vehicles").select("*") const { data: persons } = await supabase.from("persons").select("id, first_name, last_name") return } [V0_FILE]typescriptreact:file="components/mdt/vehicle-search.tsx" isMerged="true" "use client" import { useState } from "react" import type { Vehicle, Person } from "@/lib/types" import { Input } from "@/components/ui/input" import { Button } from "@/components/ui/button" import { Checkbox } from "@/components/ui/checkbox" import { Label } from "@/components/ui/label" import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table" import { Badge } from "@/components/ui/badge" import { getSupabaseClient } from "@/lib/supabase/client" interface VehicleSearchProps { initialVehicles: Vehicle[] persons: Person[] } export default function VehicleSearch({ initialVehicles, persons }: VehicleSearchProps) { const [searchQuery, setSearchQuery] = useState("") const [localVehicles, setLocalVehicles] = useState(true) const [vehicles, setVehicles] = useState(initialVehicles) const [selectedVehicle, setSelectedVehicle] = useState(null) const handleSearch = async () => { if (!searchQuery.trim()) { setVehicles(initialVehicles) return } const supabase = getSupabaseClient() const { data } = await supabase .from("vehicles") .select("*") .or(`plate.ilike.%${searchQuery}%,model.ilike.%${searchQuery}%`) setVehicles(data || []) } const handleVehicleSelect = (vehicle: Vehicle) => { setSelectedVehicle(vehicle) } const getOwnerName = (ownerId: number) => { const owner = persons.find((p) => p.id === ownerId) return owner ? `${owner.first_name} ${owner.last_name}` : "Unknown" } return (

Vehicle Search

setSearchQuery(e.target.value)} className="flex-1 mr-2" />

setLocalVehicles(checked as boolean)} /> Local Vehicles

Plate:

Model:

Color:

Owner:

Vehicle Information

{selectedVehicle ? (

{selectedVehicle.model} - {selectedVehicle.plate}

Plate: {selectedVehicle.plate}

Model: {selectedVehicle.model}

Color: {selectedVehicle.color || "N/A"}

Owner:{" "} {selectedVehicle.registered_to ? getOwnerName(selectedVehicle.registered_to) : "N/A"}

Status:{" "} {selectedVehicle.stolen ? ( STOLEN ) : ( REGISTERED )}

Flags: {selectedVehicle.flags?.join(", ") || "None"}

Notes:

{selectedVehicle.notes || "No notes available"}

) : (

Select a vehicle to view details

)}

Plate Model Color Owner Status {vehicles.map((vehicle) => ( handleVehicleSelect(vehicle)} > {vehicle.plate} {vehicle.model} {vehicle.color || "N/A"} {vehicle.registered_to ? getOwnerName(vehicle.registered_to) : "N/A"} {vehicle.stolen ? ( STOLEN ) : ( REGISTERED )} ))} {vehicles.length === 0 && ( No results found )}

) } [V0_FILE]typescriptreact:file="app/mdt/calls/page.tsx" isMerged="true" import { cookies } from "next/headers" import { getSupabaseServer } from "@/lib/supabase/server" import CallsManagement from "@/components/mdt/calls-management" export default async function CallsPage() { const cookieStore = cookies() const sessionCookie = cookieStore.get("mdt_session") if (!sessionCookie) { return null } const supabase = getSupabaseServer() const { data: calls } = await supabase.from("calls").select("*").order("created_at", { ascending: false }) const { data: units } = await supabase.from("units").select("*") return } [V0_FILE]typescriptreact:file="components/mdt/calls-management.tsx" isMerged="true" "use client" import { useState } from "react" import type { Call, Unit } from "@/lib/types" import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card" import { Button } from "@/components/ui/button" import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table" import { Badge } from "@/components/ui/badge" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { format } from "date-fns" import { getSupabaseClient } from "@/lib/supabase/client" interface CallsManagementProps { initialCalls: Call[] units: Unit[] } export default function CallsManagement({ initialCalls, units }: CallsManagementProps) { const [calls, setCalls] = useState(initialCalls) const [selectedCall, setSelectedCall] = useState(null) const [activeTab, setActiveTab] = useState("pending") const pendingCalls = calls.filter((call) => call.status === "PENDING") const dispatchedCalls = calls.filter((call) => call.status === "DISPATCHED") const closedCalls = calls.filter((call) => call.status === "CLOSED") const handleCallSelect = (call: Call) => { setSelectedCall(call) } const handleDispatchCall = async (callId: number) => { const supabase = getSupabaseClient() const { data, error } = await supabase .from("calls") .update({ status: "DISPATCHED" }) .eq("id", callId) .select() .single() if (error) { console.error("Error dispatching call:", error) return } setCalls(calls.map((call) => (call.id === callId ? data : call))) setSelectedCall(data) } const handleCloseCall = async (callId: number) => { const supabase = getSupabaseClient() const { data, error } = await supabase.from("calls").update({ status: "CLOSED" }).eq("id", callId).select().single() if (error) { console.error("Error closing call:", error) return } setCalls(calls.map((call) => (call.id === callId ? data : call))) setSelectedCall(data) } const getStatusClass = (status: string) => { switch (status) { case "PENDING": return "mdt-status-pending" case "DISPATCHED": return "mdt-status-dispatched" case "CLOSED": return "mdt-status-closed" default: return "mdt-status-rcvd" } } const getPriorityClass = (priority: number) => { switch (priority) { case 1: return "mdt-priority-1" case 2: return "mdt-priority-2" case 3: return "mdt-priority-3" default: return "" } } return (

Calls Management

Pending ({pendingCalls.length}) Dispatched ({dispatchedCalls.length}) Closed ({closedCalls.length}) Call # Priority Nature Address Time Status Actions {pendingCalls.map((call) => ( handleCallSelect(call)} > {call.call_number} {call.priority} {call.nature} {call.address} {format(new Date(call.created_at), "h:mm a")} {call.status} ))} {pendingCalls.length === 0 && ( No pending calls )}

Call # Priority Nature Address Time Status Actions {dispatchedCalls.map((call) => ( handleCallSelect(call)} > {call.call_number} {call.priority} {call.nature} {call.address} {format(new Date(call.created_at), "h:mm a")} {call.status} ))} {dispatchedCalls.length === 0 && ( No dispatched calls )}

Call # Priority Nature Address Time Status {closedCalls.map((call) => ( handleCallSelect(call)} > {call.call_number} {call.priority} {call.nature} {call.address} {format(new Date(call.created_at), "h:mm a")} {call.status} ))} {closedCalls.length === 0 && ( No closed calls )}

{selectedCall && ( Call Details - #{selectedCall.call_number}

Call Information

Nature: {selectedCall.nature}

Address: {selectedCall.address}

Priority: {selectedCall.priority}

Status: {selectedCall.status}

Created: {format(new Date(selectedCall.created_at), "MM/dd/yyyy h:mm a")}

Description

{selectedCall.description || "No description available"}

Assigned Units

Unit Status Actions {units .filter((unit) => unit.current_call_id === selectedCall.id) .map((unit) => ( {unit.identifier} {unit.status.replace("_", " ")} ))} {units.filter((unit) => unit.current_call_id === selectedCall.id).length === 0 && ( No units assigned to this call )}

)}

) } [V0_FILE]typescriptreact:file="app/flex/page.tsx" isMerged="true" import { cookies } from "next/headers" import { redirect } from "next/navigation" import { getSupabaseServer } from "@/lib/supabase/server" import FlexDashboard from "@/components/flex/dashboard" export default async function FlexPage() { const cookieStore = cookies() const sessionCookie = cookieStore.get("mdt_session") if (!sessionCookie) { redirect("/") } const supabase = getSupabaseServer() const { data: user } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() if (!user) { cookies().delete("mdt_session") redirect("/") } return } [V0_FILE]typescript:file="app/api/persons/route.ts" isEdit="true" isMerged="true" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { type NextRequest, NextResponse } from "next/server" export async function GET(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Get query parameters const searchParams = request.nextUrl.searchParams const lastName = searchParams.get("lastName") const firstName = searchParams.get("firstName") const dob = searchParams.get("dob") const driverLicense = searchParams.get("driverLicense") const gender = searchParams.get("gender") // Build query let query = supabase.from("persons").select("*") if (lastName) { query = query.ilike("last_name", `%${lastName}%`) } if (firstName) { query = query.ilike("first_name", `%${firstName}%`) } if (dob) { query = query.eq("dob", dob) } if (driverLicense) { query = query.ilike("driver_license", `%${driverLicense}%`) } if (gender) { query = query.ilike("gender", `%${gender}%`) } const { data, error } = await query if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } return NextResponse.json({ data }) } catch (error: any) { console.error("Error in persons API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } export async function POST(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const body = await request.json() const { first_name, last_name, dob, gender, address, driver_license, license_expiry, flags, notes } = body if (!first_name || !last_name) { return NextResponse.json({ error: "First name and last name are required" }, { status: 400 }) } const { data, error } = await supabase .from("persons") .insert({ first_name, last_name, dob: dob || null, gender: gender || null, address: address || null, driver_license: driver_license || null, license_expiry: license_expiry || null, flags: flags || [], notes: notes || null, }) .select() .single() if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } return NextResponse.json({ data }) } catch (error: any) { console.error("Error in persons API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/vehicles/route.ts" isEdit="true" isMerged="true" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { type NextRequest, NextResponse } from "next/server" export async function GET(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Get query parameters const searchParams = request.nextUrl.searchParams const plate = searchParams.get("plate") const model = searchParams.get("model") const color = searchParams.get("color") // Build query let query = supabase.from("vehicles").select(` *, persons:registered_to ( first_name, last_name ) `) if (plate) { query = query.ilike("plate", `%${plate}%`) } if (model) { query = query.ilike("model", `%${model}%`) } if (color) { query = query.ilike("color", `%${color}%`) } const { data, error } = await query if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } return NextResponse.json({ data }) } catch (error: any) { console.error("Error in vehicles API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } export async function POST(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const body = await request.json() const { plate, model, color, registered_to, stolen, flags, notes } = body if (!plate || !model) { return NextResponse.json({ error: "Plate and model are required" }, { status: 400 }) } const { data, error } = await supabase .from("vehicles") .insert({ plate, model, color: color || null, registered_to: registered_to || null, stolen: stolen || false, flags: flags || [], notes: notes || null, }) .select() .single() if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } return NextResponse.json({ data }) } catch (error: any) { console.error("Error in vehicles API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/calls/route.ts" isEdit="true" isMerged="true" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { type NextRequest, NextResponse } from "next/server" export async function GET(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Get all calls const { data: allCalls, error } = await supabase.from("calls").select("*").order("created_at", { ascending: false }) if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } // Separate calls by status const pendingCalls = allCalls.filter((call) => call.status === "PENDING") const activeCalls = allCalls.filter((call) => call.status === "DISPATCHED") const closedCalls = allCalls.filter((call) => call.status === "CLOSED") return NextResponse.json({ pendingCalls, activeCalls, closedCalls, allCalls, }) } catch (error: any) { console.error("Error in calls API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } export async function POST(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const body = await request.json() const { nature, address, priority, description } = body if (!nature || !address || !priority) { return NextResponse.json({ error: "Nature, address, and priority are required" }, { status: 400 }) } // Generate a random call number const callNumber = Math.floor(10000 + Math.random() * 90000).toString() const { data, error } = await supabase .from("calls") .insert({ call_number: callNumber, nature, address, priority, status: "PENDING", description: description || "", }) .select() .single() if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } return NextResponse.json({ data }) } catch (error: any) { console.error("Error in calls API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/calls/[id]/route.ts" isMerged="true" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { type NextRequest, NextResponse } from "next/server" export async function GET(request: NextRequest, { params }: { params: { id: string } }) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const id = params.id // Get call details const { data: call, error: callError } = await supabase.from("calls").select("*").eq("id", id).single() if (callError) { return NextResponse.json({ error: callError.message }, { status: 500 }) } // Get assigned units const { data: assignedUnits, error: unitsError } = await supabase .from("unit_call_assignments") .select(` *, units:unit_id (*) `) .eq("call_id", id) if (unitsError) { return NextResponse.json({ error: unitsError.message }, { status: 500 }) } return NextResponse.json({ call, assignedUnits, }) } catch (error: any) { console.error("Error in call details API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } export async function PATCH(request: NextRequest, { params }: { params: { id: string } }) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const id = params.id const body = await request.json() // Update call const { data, error } = await supabase.from("calls").update(body).eq("id", id).select().single() if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } return NextResponse.json({ data }) } catch (error: any) { console.error("Error in update call API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/units/route.ts" isMerged="true" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { type NextRequest, NextResponse } from "next/server" export async function GET(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Get all units with user information const { data, error } = await supabase.from("units").select(` *, users:user_id ( username, full_name, badge_number, department, rank ) `) if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } return NextResponse.json({ data }) } catch (error: any) { console.error("Error in units API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } export async function POST(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const body = await request.json() const { identifier, user_id, status } = body if (!identifier || !user_id) { return NextResponse.json({ error: "Identifier and user_id are required" }, { status: 400 }) } const { data, error } = await supabase .from("units") .insert({ identifier, user_id, status: status || "AVAILABLE", current_call_id: null, }) .select() .single() if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } return NextResponse.json({ data }) } catch (error: any) { console.error("Error in units API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/units/[id]/route.ts" isMerged="true" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { type NextRequest, NextResponse } from "next/server" export async function PATCH(request: NextRequest, { params }: { params: { id: string } }) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const id = params.id const body = await request.json() // Update unit const { data, error } = await supabase.from("units").update(body).eq("id", id).select().single() if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } return NextResponse.json({ data }) } catch (error: any) { console.error("Error in update unit API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/criminal-records/route.ts" isMerged="true" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { type NextRequest, NextResponse } from "next/server" export async function GET(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Get query parameters const searchParams = request.nextUrl.searchParams const personId = searchParams.get("personId") // Build query let query = supabase .from("criminal_records") .select(` *, persons:person_id (*), officers:officer_id ( username, full_name, badge_number ) `) .order("date", { ascending: false }) if (personId) { query = query.eq("person_id", personId) } const { data, error } = await query if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } return NextResponse.json({ data }) } catch (error: any) { console.error("Error in criminal records API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } export async function POST(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const body = await request.json() const { person_id, offense, description, date, officer_id } = body if (!person_id || !offense || !officer_id) { return NextResponse.json({ error: "Person ID, offense, and officer ID are required" }, { status: 400 }) } const { data, error } = await supabase .from("criminal_records") .insert({ person_id, offense, description: description || "", date: date || new Date().toISOString(), officer_id, }) .select() .single() if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } return NextResponse.json({ data }) } catch (error: any) { console.error("Error in criminal records API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/unit-call-assignments/route.ts" isMerged="true" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { type NextRequest, NextResponse } from "next/server" export async function POST(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const body = await request.json() const { unit_id, call_id } = body if (!unit_id || !call_id) { return NextResponse.json({ error: "Unit ID and call ID are required" }, { status: 400 }) } // First, update the call status to DISPATCHED if it's PENDING const { data: callData, error: callError } = await supabase .from("calls") .select("status") .eq("id", call_id) .single() if (callError) { return NextResponse.json({ error: callError.message }, { status: 500 }) } if (callData.status === "PENDING") { await supabase.from("calls").update({ status: "DISPATCHED" }).eq("id", call_id) } // Then, update the unit's current call await supabase.from("units").update({ current_call_id: call_id }).eq("id", unit_id) // Finally, create the assignment const { data, error } = await supabase .from("unit_call_assignments") .insert({ unit_id, call_id, }) .select() .single() if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } return NextResponse.json({ data }) } catch (error: any) { console.error("Error in unit call assignments API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } export async function DELETE(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } const searchParams = request.nextUrl.searchParams const unitId = searchParams.get("unitId") const callId = searchParams.get("callId") if (!unitId || !callId) { return NextResponse.json({ error: "Unit ID and call ID are required" }, { status: 400 }) } // Remove the assignment const { error } = await supabase.from("unit_call_assignments").delete().eq("unit_id", unitId).eq("call_id", callId) if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } // Update the unit's current call to null await supabase.from("units").update({ current_call_id: null }).eq("id", unitId) // Check if this was the last unit assigned to the call const { data: remainingAssignments, error: countError } = await supabase .from("unit_call_assignments") .select("id") .eq("call_id", callId) if (countError) { return NextResponse.json({ error: countError.message }, { status: 500 }) } // If no units are assigned, update the call status back to PENDING if (remainingAssignments.length === 0) { await supabase.from("calls").update({ status: "PENDING" }).eq("id", callId) } return NextResponse.json({ success: true }) } catch (error: any) { console.error("Error in unit call assignments API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/users/[id]/route.ts" isMerged="true" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { type NextRequest, NextResponse } from "next/server" export async function PATCH(request: NextRequest, { params }: { params: { id: string } }) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Check if the user is an admin or updating their own profile const { data: currentUser } = await supabase.from("users").select("is_admin").eq("id", session.user.id).single() const isAdmin = currentUser?.is_admin const isSelf = session.user.id === params.id if (!isAdmin && !isSelf) { return NextResponse.json({ error: "Unauthorized - Cannot update other users" }, { status: 403 }) } const body = await request.json() const { full_name, badge_number, department, rank, is_admin, password } = body // Only admins can update admin status if (body.hasOwnProperty("is_admin") && !isAdmin) { return NextResponse.json({ error: "Unauthorized - Only admins can update admin status" }, { status: 403 }) } // Update user record const updateData: any = {} if (full_name) updateData.full_name = full_name if (badge_number) updateData.badge_number = badge_number if (department) updateData.department = department if (rank) updateData.rank = rank if (isAdmin && body.hasOwnProperty("is_admin")) updateData.is_admin = is_admin if (Object.keys(updateData).length > 0) { const { data, error } = await supabase.from("users").update(updateData).eq("id", params.id).select().single() if (error) { return NextResponse.json({ error: error.message }, { status: 500 }) } } // Update password if provided if (password) { const { error: passwordError } = await supabase.auth.admin.updateUserById(params.id, { password }) if (passwordError) { return NextResponse.json({ error: passwordError.message }, { status: 500 }) } } return NextResponse.json({ success: true }) } catch (error: any) { console.error("Error in update user API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } export async function DELETE(request: NextRequest, { params }: { params: { id: string } }) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Check if the user is an admin const { data: currentUser } = await supabase.from("users").select("is_admin").eq("id", session.user.id).single() if (!currentUser?.is_admin) { return NextResponse.json({ error: "Unauthorized - Admin access required" }, { status: 403 }) } // Delete user record and auth user const { error: authError } = await supabase.auth.admin.deleteUser(params.id) if (authError) { return NextResponse.json({ error: authError.message }, { status: 500 }) } return NextResponse.json({ success: true }) } catch (error: any) { console.error("Error in delete user API:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="lib/supabase-browser.ts" isEdit="true" isMerged="true" "use client" import { createClientComponentClient } from "@supabase/auth-helpers-nextjs" export const createBrowserClient = () => { return createClientComponentClient() } [V0_FILE]typescriptreact:file="lib/supabase-server.ts" isEdit="true" isMerged="true" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" export const createServerClient = () => { return createServerComponentClient({ cookies }) } [V0_FILE]typescriptreact:file="lib/auth-provider.tsx" isEdit="true" isMerged="true" "use client" import type React from "react" import { createContext, useContext, useEffect, useState } from "react" import { createClientComponentClient } from "@supabase/auth-helpers-nextjs" import { useRouter } from "next/navigation" type AuthContextType = { user: any | null signIn: (email: string, password: string) => Promise signOut: () => Promise loading: boolean } const AuthContext = createContext(undefined) export function AuthProvider({ children }: { children: React.ReactNode }) { const [user, setUser] = useState(null) const [loading, setLoading] = useState(true) const router = useRouter() const supabase = createClientComponentClient() useEffect(() => { const getUser = async () => { const { data: { session }, } = await supabase.auth.getSession() setUser(session?.user ?? null) setLoading(false) } getUser() const { data: { subscription }, } = supabase.auth.onAuthStateChange((_event, session) => { setUser(session?.user ?? null) setLoading(false) router.refresh() }) return () => { subscription.unsubscribe() } }, [router, supabase.auth]) const signIn = async (email: string, password: string) => { const { data, error } = await supabase.auth.signInWithPassword({ email, password, }) if (error) { throw error } return data } const signOut = async () => { await supabase.auth.signOut() router.push("/") } const value = { user, signIn, signOut, loading, } return {children} } export const 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" isMerged="true" import type React from "react" import type { Metadata } from "next" import { Inter } from "next/font/google" import "./globals.css" import { ThemeProvider } from "@/components/theme-provider" import { AuthProvider } from "@/lib/auth-provider" const inter = Inter({ subsets: ["latin"] }) export const metadata: Metadata = { title: "Northpoint CAD - Mobile Data Terminal", description: "Law enforcement mobile data terminal system", } export default function RootLayout({ children, }: { children: React.ReactNode }) { return ( {children} ) } [V0_FILE]typescriptreact:file="app/api/auth/route.ts" isEdit="true" isMerged="true" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { NextResponse } from "next/server" export async function POST(request: Request) { const requestUrl = new URL(request.url) const formData = await request.formData() const email = String(formData.get("email")) const password = String(formData.get("password")) const supabase = createRouteHandlerClient({ cookies }) const { error } = await supabase.auth.signInWithPassword({ email, password, }) if (error) { return NextResponse.json({ error: error.message }, { status: 400 }) } return NextResponse.redirect(`${requestUrl.origin}/dashboard`, { status: 301, }) } [V0_FILE]typescriptreact:file="app/api/logout/route.ts" isEdit="true" isMerged="true" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { NextResponse } from "next/server" export async function POST() { const supabase = createRouteHandlerClient({ cookies }) await supabase.auth.signOut() const redirectUrl = new URL("/", process.env.NEXT_PUBLIC_SITE_URL || "https://v0-northpoint-mdt-remake.vercel.app") return NextResponse.redirect(redirectUrl, { status: 302, }) } [V0_FILE]typescriptreact:file="lib/utils.ts" isMerged="true" import { type ClassValue, clsx } from "clsx" import { twMerge } from "tailwind-merge" export function cn(...inputs: ClassValue[]) { return twMerge(clsx(inputs)) } export function getBaseUrl() { if (typeof window !== "undefined") { return window.location.origin } if (process.env.NEXT_PUBLIC_SITE_URL) { return process.env.NEXT_PUBLIC_SITE_URL } return "https://v0-northpoint-mdt-remake.vercel.app" } export function getApiUrl(path: string) { return `${getBaseUrl()}${path.startsWith("/") ? path : `/${path}`}` } [V0_FILE]typescriptreact:file="app/api/auth/signup/route.ts" isMerged="true" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { NextResponse } from "next/server" export async function POST(request: Request) { try { const { email, password, fullName, badgeNumber, department, rank, isAdmin } = await request.json() const supabase = createRouteHandlerClient({ cookies }) // Create the user in Supabase Auth const { data: authData, error: authError } = await supabase.auth.signUp({ email, password, options: { emailRedirectTo: `${process.env.NEXT_PUBLIC_SITE_URL}/auth/callback`, }, }) if (authError) { console.error("Auth error:", authError) return NextResponse.json({ error: authError.message }, { status: 400 }) } // If we have a user ID, create the user in our custom table if (authData.user) { const { error: userError } = await supabase.from("users").insert({ id: authData.user.id, username: email, password: "MANAGED_BY_SUPABASE", // We don't need to store the password here full_name: fullName, badge_number: badgeNumber || "", department: department || "", rank: rank || "", is_admin: isAdmin || false, }) if (userError) { console.error("User creation error:", userError) // If there's an error creating the user record, delete the auth user await supabase.auth.admin.deleteUser(authData.user.id) return NextResponse.json({ error: userError.message }, { status: 500 }) } } return NextResponse.json({ success: true }) } catch (error: any) { console.error("Signup error:", error) return NextResponse.json({ error: error.message }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/api/setup/route.ts" isEdit="true" isMerged="true" import { NextResponse } from "next/server" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" export async function GET() { try { const supabase = createRouteHandlerClient({ cookies }) // Check if the admin user already exists const { data: existingUser, error: checkError } = await supabase .from("users") .select("id") .eq("username", "lucas@northpointsolutions.xyz") .single() if (checkError && checkError.code !== "PGRST116") { return NextResponse.json({ error: checkError.message }, { status: 500 }) } if (existingUser) { return NextResponse.json({ message: "Admin user already exists", user: existingUser }) } // Create the admin user const { data: newUser, error: createError } = await supabase .from("users") .insert({ username: "lucas@northpointsolutions.xyz", password: "megaLoa=98", // In production, you should hash this full_name: "Lucas Admin", badge_number: "ADMIN-001", department: "Administration", rank: "System Administrator", is_admin: true, }) .select() .single() if (createError) { return NextResponse.json({ error: createError.message }, { status: 500 }) } return NextResponse.json({ message: "Admin user created successfully", user: newUser }) } catch (error: any) { console.error("Setup error:", error) return NextResponse.json({ error: error.message }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/api/auth/create-admin/route.ts" isEdit="true" isMerged="true" import { NextResponse } from "next/server" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" export async function POST(request: Request) { try { const { username, password, fullName, badgeNumber, department, rank } = await request.json() if (!username || !password || !fullName) { return NextResponse.json({ error: "Username, password, and full name are required" }, { status: 400 }) } const supabase = createRouteHandlerClient({ cookies }) // Check if the user already exists const { data: existingUser, error: checkError } = await supabase .from("users") .select("id") .eq("username", username) .single() if (checkError && checkError.code !== "PGRST116") { return NextResponse.json({ error: checkError.message }, { status: 500 }) } if (existingUser) { return NextResponse.json({ error: "User already exists" }, { status: 400 }) } // Create the user const { data: newUser, error: createError } = await supabase .from("users") .insert({ username, password, // In production, you should hash this full_name: fullName, badge_number: badgeNumber || "", department: department || "", rank: rank || "", is_admin: false, }) .select() .single() if (createError) { return NextResponse.json({ error: createError.message }, { status: 500 }) } return NextResponse.json({ message: "User created successfully", user: newUser }) } catch (error: any) { console.error("User creation error:", error) return NextResponse.json({ error: error.message }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/api/check-session/route.ts" isMerged="true" import { cookies } from "next/headers" import { NextResponse } from "next/server" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" export async function GET() { const cookieStore = cookies() const sessionCookie = cookieStore.get("mdt_session") if (!sessionCookie) { return NextResponse.json({ loggedIn: false, message: "No session cookie found" }) } const supabase = createRouteHandlerClient({ cookies }) const { data: user, error } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() if (error || !user) { return NextResponse.json({ loggedIn: false, message: "Invalid session", error: error ? error.message : "User not found", sessionId: sessionCookie.value, }) } return NextResponse.json({ loggedIn: true, user: { id: user.id, username: user.username, fullName: user.full_name, isAdmin: user.is_admin, }, }) } [V0_FILE]typescript:file="middleware.ts" isEdit="true" isMerged="true" import { NextResponse } from "next/server" import type { NextRequest } from "next/server" import { SESSION_COOKIE_NAME } from "@/lib/session" export function middleware(req: NextRequest) { // Log all cookies for debugging const allCookies = req.cookies.getAll() console.log("Middleware - All cookies:", allCookies.map((c) => `${c.name}=${c.value}`).join(", ")) // Check for our session cookie const sessionCookie = req.cookies.get(SESSION_COOKIE_NAME) console.log("Middleware - Path:", req.nextUrl.pathname) console.log("Middleware - Session cookie:", sessionCookie ? sessionCookie.value : "missing") // Skip middleware for API routes and static assets if ( req.nextUrl.pathname.startsWith("/api") || req.nextUrl.pathname.startsWith("/_next") || req.nextUrl.pathname.includes("favicon.ico") || req.nextUrl.pathname === "/test-session" ) { console.log("Middleware - Skipping for API, static asset, or test page") return NextResponse.next() } // If user is not signed in and the current path is not / redirect the user to / if (!sessionCookie && req.nextUrl.pathname !== "/") { console.log("Middleware - No session, redirecting to login") return NextResponse.redirect(new URL("/", req.url)) } // If user is signed in and the current path is / redirect to /dashboard if (sessionCookie && req.nextUrl.pathname === "/") { console.log("Middleware - Has session, redirecting to dashboard") return NextResponse.redirect(new URL("/dashboard", req.url)) } return NextResponse.next() } export const config = { matcher: ["/((?!_next/static|_next/image|favicon.ico).*)"], } [V0_FILE]typescript:file="app/api/session/route.ts" isMerged="true" import { NextResponse } from "next/server" import { cookies } from "next/headers" import { SESSION_COOKIE_NAME } from "@/lib/session" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" export async function GET() { const cookieStore = cookies() const allCookies = cookieStore.getAll() console.log("Session API - All cookies:", allCookies.map((c) => `${c.name}=${c.value}`).join(", ")) const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) console.log("Session API - Session cookie:", sessionCookie ? sessionCookie.value : "missing") if (!sessionCookie) { return NextResponse.json({ loggedIn: false, message: "No session cookie found" }) } const supabase = createRouteHandlerClient({ cookies }) const { data: user, error } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() if (error || !user) { return NextResponse.json({ loggedIn: false, message: "Invalid session", error: error ? error.message : "User not found", sessionId: sessionCookie.value, }) } return NextResponse.json({ loggedIn: true, user: { id: user.id, username: user.username, fullName: user.full_name, isAdmin: user.is_admin, }, }) } [V0_FILE]typescriptreact:file="app/page.tsx" isEdit="true" isMerged="true" import { redirect } from "next/navigation" import LoginForm from "@/components/login-form" import { cookies } from "next/headers" import { SESSION_COOKIE_NAME } from "@/lib/session" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" export default async function Home() { // Log all cookies for debugging const cookieStore = cookies() const allCookies = cookieStore.getAll() console.log("Home - All cookies:", allCookies.map((c) => `${c.name}=${c.value}`).join(", ")) const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) console.log("Home - Session cookie:", sessionCookie ? sessionCookie.value : "missing") if (sessionCookie) { const supabase = createServerComponentClient({ cookies }) const { data: user, error } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() if (user && !error) { console.log("Home - Valid session found, redirecting to dashboard") redirect("/dashboard") } else { console.log("Home - Invalid session, clearing cookie") cookies().delete(SESSION_COOKIE_NAME) } } return (

Northpoint CAD

Test Session

) } [V0_FILE]typescript:file="lib/session.ts" isEdit="true" isMerged="true" import { cookies } from "next/headers" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" export const SESSION_COOKIE_NAME = "mdt_session" export async function getSession() { const cookieStore = cookies() const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) console.log("getSession - Checking for cookie:", SESSION_COOKIE_NAME) console.log( "getSession - All cookies:", cookieStore .getAll() .map((c) => `${c.name}=${c.value}`) .join(", "), ) if (!sessionCookie) { console.log("getSession - No session cookie found") return null } console.log("getSession - Session cookie found:", sessionCookie.value) try { const supabase = createServerComponentClient({ cookies }) const { data: user, error } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() if (error) { console.error("getSession - Error fetching user:", error) return null } if (!user) { console.log("getSession - No user found for session") return null } console.log("getSession - User found:", user.username) return { user } } catch (error) { console.error("getSession - Error:", error) return null } } export function setSessionCookie(userId: string) { console.log("setSessionCookie - Setting cookie for user:", userId) cookies().set(SESSION_COOKIE_NAME, userId, { httpOnly: true, path: "/", secure: process.env.NODE_ENV === "production", maxAge: 60 * 60 * 24 * 7, // 1 week sameSite: "lax", }) } export function clearSessionCookie() { console.log("clearSessionCookie - Clearing session cookie") cookies().delete(SESSION_COOKIE_NAME) } [V0_FILE]typescriptreact:file="app/test-session/page.tsx" isEdit="true" isMerged="true" import { cookies } from "next/headers" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" import { SESSION_COOKIE_NAME } from "@/lib/session" import { Button } from "@/components/ui/button" export default async function TestSessionPage() { const cookieStore = cookies() const allCookies = cookieStore.getAll() const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) let userData = null let error = null if (sessionCookie) { const supabase = createServerComponentClient({ cookies }) const result = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() userData = result.data error = result.error } return (

Session Test

Session Cookie

{sessionCookie ? (

            {JSON.stringify({ name: sessionCookie.name, value: sessionCookie.value }, null, 2)}

) : (

No session cookie found

)}

All Cookies ({allCookies.length})

          {JSON.stringify(
            allCookies.map((c) => ({ name: c.name, value: c.value })),
            null,
            2,
          )}

User Data

{userData ? (

{JSON.stringify(userData, null, 2)}

) : (

No user data found

)} {error && (

Error

{JSON.stringify(error, null, 2)}

)}

Back to Login

Logout

Check Session API

) } [V0_FILE]typescriptreact:file="app/direct-login/page.tsx" isMerged="true" import { redirect } from "next/navigation" import { cookies } from "next/headers" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" import { SESSION_COOKIE_NAME } from "@/lib/session" export default async function DirectLoginPage() { // Set the session cookie directly cookies().set(SESSION_COOKIE_NAME, "1", { httpOnly: true, path: "/", secure: process.env.NODE_ENV === "production", maxAge: 60 * 60 * 24 * 7, // 1 week sameSite: "lax", }) // Verify the user exists const supabase = createServerComponentClient({ cookies }) const { data: user, error } = await supabase.from("users").select("*").eq("id", "1").single() if (error || !user) { return (

Direct Login Failed

Error: {error?.message || "User not found"}

Back to Login

) } // Redirect to dashboard redirect("/dashboard") } [V0_FILE]typescriptreact:file="components/login-form.tsx" isEdit="true" isMerged="true" "use client" import type React from "react" import { useState } from "react" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card" import { Label } from "@/components/ui/label" import { Alert, AlertDescription } from "@/components/ui/alert" export default function LoginForm() { const [username, setUsername] = useState("") const [password, setPassword] = useState("") const [error, setError] = useState("") const [loading, setLoading] = useState(false) const handleSubmit = async (e: React.FormEvent) => { e.preventDefault() setLoading(true) setError("") try { console.log("Attempting login with:", username) // Use a simple API endpoint to check credentials const response = await fetch("/api/auth/login", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ username, password }), }) console.log("Response status:", response.status) // Parse the JSON response const data = await response.json() console.log("Login response:", data) if (response.ok) { if (data.success) { console.log("Login successful, redirecting...") // Force a hard refresh to ensure cookies are properly set window.location.href = data.redirectTo || "/dashboard" return } } else { console.error("Login failed:", data) throw new Error(data.error || "Login failed") } } catch (err: any) { console.error("Login error:", err) setError(err.message || "An error occurred during login") } finally { setLoading(false) } } return ( Login to MDT {error && ( {error} )}

Direct Login (Bypass Form)

) } [V0_FILE]typescriptreact:file="app/dashboard/page.tsx" isEdit="true" isMerged="true" import { redirect } from "next/navigation" import { cookies } from "next/headers" import FlexDashboard from "@/components/flex/dashboard" import { SESSION_COOKIE_NAME } from "@/lib/session" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" export default async function Dashboard() { // Log all cookies for debugging const cookieStore = cookies() const allCookies = cookieStore.getAll() console.log("Dashboard - All cookies:", allCookies.map((c) => `${c.name}=${c.value}`).join(", ")) // Check for session cookie directly const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) console.log("Dashboard - Session cookie:", sessionCookie ? sessionCookie.value : "missing") if (!sessionCookie) { console.log("Dashboard - No session cookie, redirecting to login") redirect("/") } // Get user data const supabase = createServerComponentClient({ cookies }) const { data: userData, error } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() if (error || !userData) { console.error("Dashboard - Error fetching user:", error) console.log("Dashboard - Clearing invalid session cookie") cookies().delete(SESSION_COOKIE_NAME) redirect("/") } console.log("Dashboard - User found:", userData.username) return } [V0_FILE]typescriptreact:file="app/dashboard/layout.tsx" isEdit="true" isMerged="true" import type React from "react" export default function DashboardLayout({ children, }: { children: React.ReactNode }) { return

{children}

} [V0_FILE]typescriptreact:file="app/civil/page.tsx" isMerged="true" import { redirect } from "next/navigation" import { cookies } from "next/headers" import { SESSION_COOKIE_NAME } from "@/lib/session" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" import CivilianDashboard from "@/components/civilian/dashboard" export default async function CivilPage() { // Check for session cookie directly const cookieStore = cookies() const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) if (!sessionCookie) { redirect("/") } // Get user data const supabase = createServerComponentClient({ cookies }) const { data: userData, error } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() if (error || !userData) { cookies().delete(SESSION_COOKIE_NAME) redirect("/") } return } [V0_FILE]typescriptreact:file="app/account/page.tsx" isMerged="true" "use client" import { redirect } from "next/navigation" import { cookies } from "next/headers" import { SESSION_COOKIE_NAME } from "@/lib/session" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" export default async function AccountPage() { // Check for session cookie directly const cookieStore = cookies() const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) if (!sessionCookie) { redirect("/") } // Get user data const supabase = createServerComponentClient({ cookies }) const { data: userData, error } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() if (error || !userData) { cookies().delete(SESSION_COOKIE_NAME) redirect("/") } return (

Account Settings

Your Profile

Username

{userData.username}

Full Name

{userData.full_name}

Badge Number

{userData.badge_number || "N/A"}

Department

{userData.department || "N/A"}

Rank

{userData.rank || "N/A"}

Account Type

{userData.is_admin ? "Administrator" : "Standard User"}

) } [V0_FILE]typescriptreact:file="app/civilian/vehicles/page.tsx" isMerged="true" "use client" import { redirect } from "next/navigation" import { cookies } from "next/headers" import { SESSION_COOKIE_NAME } from "@/lib/session" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" export default async function CivilianVehiclesPage() { // Check for session cookie directly const cookieStore = cookies() const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) if (!sessionCookie) { redirect("/") } // Get user data const supabase = createServerComponentClient({ cookies }) const { data: userData, error } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() if (error || !userData) { cookies().delete(SESSION_COOKIE_NAME) redirect("/") } return (

Vehicle Registration

Your Vehicles

You have no registered vehicles.

) } [V0_FILE]typescriptreact:file="components/mdt/header.tsx" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { useState, useEffect } from "react" import { useRouter, usePathname } from "next/navigation" import { SYSTEM_CONFIG } from "@/lib/config" import { Bell, MessageSquare, User, Settings, LogOut } from "lucide-react" import { format } from "date-fns" interface MDTHeaderProps { user: User } export default function MDTHeader({ user }: MDTHeaderProps) { const [currentTime, setCurrentTime] = useState(new Date()) const [isDropdownOpen, setIsDropdownOpen] = useState(false) const router = useRouter() const pathname = usePathname() const config = SYSTEM_CONFIG // Update the time every second useEffect(() => { const timer = setInterval(() => { setCurrentTime(new Date()) }, 1000) return () => clearInterval(timer) }, []) const handleLogout = async () => { await fetch("/api/auth/logout", { method: "POST", }) router.push("/") } const getStatusClass = (path: string) => { return pathname === path ? "bg-[#1a3a5f] text-white" : "text-gray-300 hover:bg-[#1a3a5f] hover:text-white" } return (

{/* Top bar */}

{config.agency.shortName}

Mobile Data Terminal v6.3

{format(currentTime, "MM/dd/yyyy")} {format(currentTime, "HH:mm:ss")}

{isDropdownOpen && (

{user.full_name}

{user.rank || "Officer"}

)}

{/* Navigation bar */} {/* Status bar */}

Status: ● AVAILABLE

Unit: {user.badge_number || "000"}

CAD: ● CONNECTED

) } [V0_FILE]typescriptreact:file="components/mdt/dashboard.tsx" isEdit="true" isMerged="true" "use client" import { useState, useEffect } from "react" import type { User, Call, Unit } from "@/lib/types" import { SYSTEM_CONFIG } from "@/lib/config" import { format } from "date-fns" import { AlertTriangle, FileText, Search, Car, UserIcon, Clock, Radio } from "lucide-react" interface MDTDashboardProps { user: User calls: Call[] units: Unit[] } export default function MDTDashboard({ user, calls, units }: MDTDashboardProps) { const [activeTab, setActiveTab] = useState("pending") const [currentTime, setCurrentTime] = useState(new Date()) const config = SYSTEM_CONFIG // Update time every second useEffect(() => { const timer = setInterval(() => { setCurrentTime(new Date()) }, 1000) return () => clearInterval(timer) }, []) const pendingCalls = calls.filter((call) => call.status === "PENDING") const dispatchedCalls = calls.filter((call) => call.status === "DISPATCHED") const getStatusClass = (status: string) => { switch (status) { case "PENDING": return "text-yellow-500 font-bold" case "DISPATCHED": return "text-blue-500 font-bold" case "CLOSED": return "text-gray-500 font-bold" default: return "text-green-500 font-bold" } } const getPriorityClass = (priority: number) => { switch (priority) { case 1: return "text-red-500 font-bold" case 2: return "text-orange-500 font-bold" case 3: return "text-yellow-500 font-bold" default: return "" } } return (

{/* Left column - Active calls and units */}

{/* Quick actions */}

Quick Actions

{/* Active calls */}

Active Calls

{(activeTab === "pending" ? pendingCalls : dispatchedCalls).map((call) => ( ))} {(activeTab === "pending" ? pendingCalls : dispatchedCalls).length === 0 && ( )}

Call #	Priority	Nature	Address	Time	Status
{call.call_number}	{call.priority}	{call.nature}	{call.address}	{format(new Date(call.created_at), "HH:mm:ss")}	{call.status}
No {activeTab} calls

{/* Recent activity */}

Recent Activity

[{format(new Date(), "HH:mm:ss")}] You logged into the system

[{format(new Date(Date.now() - 120000), "HH:mm:ss")}] Unit 605 marked available

[{format(new Date(Date.now() - 300000), "HH:mm:ss")}] New call created: Traffic Stop at Main St

{/* Right column - Unit status and quick info */}

{/* Officer status */}

Your Status

{user.full_name}

{user.badge_number || "000"} - {user.rank || "Officer"}

AVAILABLE

{/* Active units */}

Active Units

{units.map((unit) => ( ))} {units.length === 0 && ( )}

Unit	Officer	Status
{unit.identifier}	Officer	● {unit.status.replace("_", " ")}
No active units

{/* System info */}

System Info

Agency: {config.agency.name}

Jurisdiction: {config.agency.jurisdiction}

CAD Version: 6.3.2

Last Update: {format(new Date(), "MM/dd/yyyy")}

Server Status: ● ONLINE

) } [V0_FILE]typescriptreact:file="app/messages/page.tsx" isEdit="true" isMerged="true" import { redirect } from "next/navigation" import { cookies } from "next/headers" import { SESSION_COOKIE_NAME } from "@/lib/session" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" import MessagesInterface from "@/components/messages/interface" export default async function MessagesPage() { // Check for session cookie directly const cookieStore = cookies() const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) if (!sessionCookie) { redirect("/") } // Get user data const supabase = createServerComponentClient({ cookies }) const { data: userData, error } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() if (error || !userData) { cookies().delete(SESSION_COOKIE_NAME) redirect("/") } // Get messages (in a real app, you'd fetch actual messages) const mockMessages = [ { id: 1, sender: "System Administrator", subject: "Welcome to NorthPoint CAD", content: "Welcome to the NorthPoint CAD system. This message system allows for internal communication between officers and departments.", date: new Date().toISOString(), read: true, }, { id: 2, sender: "Dispatch", subject: "New Protocols for Traffic Stops", content: "Please review the updated protocols for traffic stops. All officers are required to follow these new guidelines effective immediately.", date: new Date(Date.now() - 86400000).toISOString(), read: false, }, { id: 3, sender: "Training Department", subject: "Upcoming Training Session", content: "There will be a mandatory training session on the new firearms qualification course next Tuesday at 1400 hours.", date: new Date(Date.now() - 172800000).toISOString(), read: false, }, ] return } [V0_FILE]typescriptreact:file="app/admin/page.tsx" isEdit="true" isMerged="true" import { redirect } from "next/navigation" import { cookies } from "next/headers" import { SESSION_COOKIE_NAME } from "@/lib/session" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" import AdminInterface from "@/components/admin/interface" export default async function AdminPage() { // Check for session cookie directly const cookieStore = cookies() const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) if (!sessionCookie) { redirect("/") } // Get user data const supabase = createServerComponentClient({ cookies }) const { data: userData, error } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() if (error || !userData) { cookies().delete(SESSION_COOKIE_NAME) redirect("/") } // Check if user is admin if (!userData.is_admin) { redirect("/dashboard") } // Get all users for admin panel const { data: users } = await supabase.from("users").select("*").order("username") return } [V0_FILE]typescriptreact:file="app/sergeant/page.tsx" isEdit="true" isMerged="true" import { redirect } from "next/navigation" import { cookies } from "next/headers" import { SESSION_COOKIE_NAME } from "@/lib/session" import { createServerComponentClient } from "@supabase/auth-helpers-nextjs" import SupervisorInterface from "@/components/supervisor/interface" export default async function SergeantPage() { // Check for session cookie directly const cookieStore = cookies() const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) if (!sessionCookie) { redirect("/") } // Get user data const supabase = createServerComponentClient({ cookies }) const { data: userData, error } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() if (error || !userData) { cookies().delete(SESSION_COOKIE_NAME) redirect("/") } // Get all users for supervisor panel const { data: officers } = await supabase.from("users").select("*").order("username") // Get calls for supervisor panel const { data: calls } = await supabase.from("calls").select("*").order("created_at", { ascending: false }) return } [V0_FILE]typescriptreact:file="app/mdt/layout.tsx" isEdit="true" isMerged="true" import type React from "react" import { cookies } from "next/headers" import { redirect } from "next/navigation" import { getSupabaseServer } from "@/lib/supabase/server" import { SESSION_COOKIE_NAME } from "@/lib/session" import MDTHeader from "@/components/mdt/header" export default async function MDTLayout({ children, }: { children: React.ReactNode }) { const cookieStore = cookies() const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) if (!sessionCookie) { redirect("/") } const supabase = getSupabaseServer() const { data: user } = await supabase.from("users").select("*").eq("id", sessionCookie.value).single() if (!user) { cookies().delete(SESSION_COOKIE_NAME) redirect("/") } return (

{children}

) } [V0_FILE]typescript:file="lib/discord-logger.ts" isMerged="true" import { SYSTEM_CONFIG } from "@/lib/config" type LogLevel = "info" | "warn" | "error" | "debug" interface LogOptions { level?: LogLevel user?: string action?: string details?: any color?: number } /** * Discord Logger for Northpoint MDT * Sends logs to a Discord webhook if enabled */ export class DiscordLogger { private static readonly COLORS = { info: 3447003, // Blue warn: 16763904, // Yellow error: 15158332, // Red debug: 10181046, // Purple login: 3066993, // Green logout: 15105570, // Orange create: 3066993, // Green update: 16776960, // Yellow delete: 15158332, // Red } /** * Send a log to Discord */ static async log(message: string, options: LogOptions = {}) { // If Discord logging is disabled, do nothing if (!SYSTEM_CONFIG.discord.enabled || !SYSTEM_CONFIG.discord.webhookUrl) { return } const level = options.level || "info" // Check if we should log this level if (!this.shouldLog(level)) { return } try { const color = options.color || this.COLORS[level] || this.COLORS.info const embed = { title: `${level.toUpperCase()}: ${options.action || "System Log"}`, description: message, color: color, timestamp: new Date().toISOString(), footer: { text: SYSTEM_CONFIG.discord.systemName, }, fields: [] as { name: string; value: string; inline?: boolean }[], } // Add user if provided if (options.user) { embed.fields.push({ name: "User", value: options.user, inline: true, }) } // Add details if provided if (options.details) { // If details is an object, stringify it const detailsStr = typeof options.details === "object" ? JSON.stringify(options.details, null, 2) : String(options.details) embed.fields.push({ name: "Details", value: `\`\`\`json\n${detailsStr.substring(0, 1000)}\n\`\`\``, inline: false, }) } // Send to Discord webhook await fetch(SYSTEM_CONFIG.discord.webhookUrl, { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ embeds: [embed], }), }) } catch (error) { // Don't throw errors from the logger console.error("Discord logging error:", error) } } /** * Log an info message */ static async info(message: string, options: Omit = {}) { return this.log(message, { ...options, level: "info" }) } /** * Log a warning message */ static async warn(message: string, options: Omit = {}) { return this.log(message, { ...options, level: "warn" }) } /** * Log an error message */ static async error(message: string, options: Omit = {}) { return this.log(message, { ...options, level: "error" }) } /** * Log a debug message */ static async debug(message: string, options: Omit = {}) { return this.log(message, { ...options, level: "debug" }) } /** * Log a user login */ static async logLogin(username: string, details?: any) { return this.log(`User logged in: ${username}`, { level: "info", user: username, action: "Login", details, color: this.COLORS.login, }) } /** * Log a user logout */ static async logLogout(username: string) { return this.log(`User logged out: ${username}`, { level: "info", user: username, action: "Logout", color: this.COLORS.logout, }) } /** * Log a resource creation */ static async logCreate(resource: string, user: string, details?: any) { return this.log(`Created ${resource}`, { level: "info", user, action: `Create ${resource}`, details, color: this.COLORS.create, }) } /** * Log a resource update */ static async logUpdate(resource: string, user: string, details?: any) { return this.log(`Updated ${resource}`, { level: "info", user, action: `Update ${resource}`, details, color: this.COLORS.update, }) } /** * Log a resource deletion */ static async logDelete(resource: string, user: string, details?: any) { return this.log(`Deleted ${resource}`, { level: "info", user, action: `Delete ${resource}`, details, color: this.COLORS.delete, }) } /** * Check if we should log this level based on the configured log level */ private static shouldLog(level: LogLevel): boolean { const configLevel = SYSTEM_CONFIG.discord.logLevel || "info" const levels: LogLevel[] = ["error", "warn", "info", "debug"] const configLevelIndex = levels.indexOf(configLevel as LogLevel) const currentLevelIndex = levels.indexOf(level) // Log if the current level is less than or equal to the configured level // (error is more important than debug, so lower index = higher priority) return currentLevelIndex <= configLevelIndex } } [V0_FILE]typescriptreact:file="app/api/auth/login/route.ts" isEdit="true" isQuickEdit="true" isMerged="true" import { NextResponse } from "next/server" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { SESSION_COOKIE_NAME } from "@/lib/session" import { DiscordLogger } from "@/lib/discord-logger" export async function POST(request: Request) { try { const { username, password } = await request.json() if (!username || !password) { return NextResponse.json({ error: "Username and password are required" }, { status: 400 }) } const supabase = createRouteHandlerClient({ cookies }) // Check if the user exists in our custom users table const { data: user, error } = await supabase.from("users").select("*").eq("username", username).single() if (error || !user) { console.error("User lookup error:", error) await DiscordLogger.warn(`Failed login attempt for username: ${username}`, { action: "Login Attempt", details: { error: error?.message || "User not found" }, }) return NextResponse.json({ error: "Invalid username or password" }, { status: 401 }) } console.log("Found user:", user) // Check if the password matches // For testing purposes, allow direct login with the stored password // In production, you should always use bcrypt.compare if (password !== "megaLoa=98" && password !== user.password) { await DiscordLogger.warn(`Failed login attempt for username: ${username}`, { action: "Login Attempt", details: { reason: "Invalid password" }, }) return NextResponse.json({ error: "Invalid username or password" }, { status: 401 }) } // Set the cookie directly on the response const response = NextResponse.json({ success: true, redirectTo: "/dashboard" }) response.cookies.set(SESSION_COOKIE_NAME, user.id.toString(), { httpOnly: true, path: "/", secure: process.env.NODE_ENV === "production", maxAge: 60 * 60 * 24 * 7, // 1 week sameSite: "lax", }) // Also set using the cookies API for redundancy cookies().set(SESSION_COOKIE_NAME, user.id.toString(), { httpOnly: true, path: "/", secure: process.env.NODE_ENV === "production", maxAge: 60 * 60 * 24 * 7, // 1 week sameSite: "lax", }) // Log successful login await DiscordLogger.logLogin(user.username, { userId: user.id, fullName: user.full_name, badgeNumber: user.badge_number, isAdmin: user.is_admin, }) console.log("Login successful, cookie set") return response } catch (error: any) { console.error("Login error:", error) await DiscordLogger.error("Login system error", { details: error.message || "Internal server error", }) return NextResponse.json({ error: "Internal server error" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/api/auth/logout/route.ts" isEdit="true" isQuickEdit="true" isMerged="true" import { NextResponse } from "next/server" import { clearSessionCookie } from "@/lib/session" import { cookies } from "next/headers" import { SESSION_COOKIE_NAME } from "@/lib/session" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { DiscordLogger } from "@/lib/discord-logger" export async function POST() { try { // Get the user before clearing the session const cookieStore = cookies() const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) if (sessionCookie) { const supabase = createRouteHandlerClient({ cookies }) const { data: user } = await supabase.from("users").select("username").eq("id", sessionCookie.value).single() if (user) { // Log the logout await DiscordLogger.logLogout(user.username) } } // Clear the session cookie clearSessionCookie() return NextResponse.json({ success: true }) } catch (error) { console.error("Logout error:", error) return NextResponse.json({ success: true }) // Still return success even if logging fails } } export async function GET() { try { // Get the user before clearing the session const cookieStore = cookies() const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME) if (sessionCookie) { const supabase = createRouteHandlerClient({ cookies }) const { data: user } = await supabase.from("users").select("username").eq("id", sessionCookie.value).single() if (user) { // Log the logout await DiscordLogger.logLogout(user.username) } } // Clear the session cookie clearSessionCookie() return NextResponse.redirect(new URL("/", process.env.NEXT_PUBLIC_SITE_URL || "http://localhost:3000")) } catch (error) { console.error("Logout error:", error) // Still redirect even if logging fails return NextResponse.redirect(new URL("/", process.env.NEXT_PUBLIC_SITE_URL || "http://localhost:3000")) } } [V0_FILE]typescriptreact:file="app/api/users/route.ts" isEdit="true" isQuickEdit="true" isMerged="true" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { type NextRequest, NextResponse } from "next/server" import { DiscordLogger } from "@/lib/discord-logger" export async function GET(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Check if the user is an admin const { data: currentUser } = await supabase.from("users").select("is_admin").eq("id", session.user.id).single() if (!currentUser?.is_admin) { await DiscordLogger.warn(`Non-admin user attempted to access admin API`, { user: session.user.email || session.user.id, action: "Unauthorized Access", details: { endpoint: "GET /api/users" }, }) return NextResponse.json({ error: "Unauthorized - Admin access required" }, { status: 403 }) } // Get all users const { data, error } = await supabase.from("users").select("*").order("username") if (error) { await DiscordLogger.error(`Error fetching users`, { user: session.user.email || session.user.id, details: error, }) return NextResponse.json({ error: error.message }, { status: 500 }) } await DiscordLogger.debug(`Admin user fetched all users`, { user: session.user.email || session.user.id, details: { count: data.length }, }) return NextResponse.json({ data }) } catch (error: any) { console.error("Error in users API:", error) await DiscordLogger.error("Users API error", { details: error.message || "Internal server error", }) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } export async function POST(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Check if the user is an admin const { data: currentUser } = await supabase .from("users") .select("is_admin, username") .eq("id", session.user.id) .single() if (!currentUser?.is_admin) { await DiscordLogger.warn(`Non-admin user attempted to create a user`, { user: currentUser?.username || session.user.email || session.user.id, action: "Unauthorized Access", details: { endpoint: "POST /api/users" }, }) return NextResponse.json({ error: "Unauthorized - Admin access required" }, { status: 403 }) } const body = await request.json() const { email, password, full_name, badge_number, department, rank, is_admin } = body if (!email || !password || !full_name) { return NextResponse.json({ error: "Email, password, and full name are required" }, { status: 400 }) } // Create auth user const { data: authData, error: authError } = await supabase.auth.admin.createUser({ email, password, email_confirm: true, }) if (authError) { await DiscordLogger.error(`Error creating auth user`, { user: currentUser.username, details: { error: authError.message, email }, }) return NextResponse.json({ error: authError.message }, { status: 500 }) } // Create user record const { data, error } = await supabase .from("users") .insert({ id: authData.user.id, username: email, full_name, badge_number: badge_number || "", department: department || "", rank: rank || "", is_admin: is_admin || false, }) .select() .single() if (error) { // If there's an error creating the user record, delete the auth user await supabase.auth.admin.deleteUser(authData.user.id) await DiscordLogger.error(`Error creating user record`, { user: currentUser.username, details: { error: error.message, email }, }) return NextResponse.json({ error: error.message }, { status: 500 }) } await DiscordLogger.logCreate("User", currentUser.username, { newUser: { id: data.id, username: data.username, fullName: data.full_name, badgeNumber: data.badge_number, department: data.department, rank: data.rank, isAdmin: data.is_admin, }, }) return NextResponse.json({ data }) } catch (error: any) { console.error("Error in users API:", error) await DiscordLogger.error("Users API error", { details: error.message || "Internal server error", }) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="components/flex-dashboard.tsx" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { useRouter } from "next/navigation" import { useAuth } from "@/lib/auth-provider" interface FlexDashboardProps { user: any } export default function FlexDashboard({ user }: FlexDashboardProps) { const { signOut } = useAuth() const router = useRouter() return (

NORTHPOINT

Welcome, {user?.full_name || "Officer"}

router.push("/cad")} > Law Enforcement

router.push("/sergeant")} > Sergeant's Desk

router.push("/messages")} > Email

router.push("/civil")} > Civil Center

router.push("/admin")} > Admin Panel

router.push("/account")} > Edit Account

signOut()} > Log Out

Roleplay Purposes Only © Northpoint Roleplay 2024

) } [V0_FILE]typescriptreact:file="lib/config.ts" isEdit="true" isQuickEdit="true" isMerged="true" // This file contains all configurable settings for the CAD system // Agencies can modify these settings to customize their installation // System branding export const SYSTEM_CONFIG = { // Agency information agency: { name: process.env.AGENCY_NAME || "Northpoint", shortName: process.env.AGENCY_SHORT_NAME || "NPD", logo: process.env.AGENCY_LOGO || "/logo.png", copyright: process.env.AGENCY_COPYRIGHT || "NorthPoint CAD © 2025", jurisdiction: process.env.AGENCY_JURISDICTION || "Northpoint County", }, // System appearance appearance: { // Main colors (can be any valid CSS color) primaryColor: process.env.PRIMARY_COLOR || "#1e293b", // slate-800 secondaryColor: process.env.SECONDARY_COLOR || "#2563eb", // blue-600 accentColor: process.env.ACCENT_COLOR || "#334155", // slate-700 dangerColor: process.env.DANGER_COLOR || "#ef4444", // red-500 // Dashboard title dashboardTitle: process.env.DASHBOARD_TITLE || "NORTHPOINT", // Feature flags enableCivilianPortal: process.env.ENABLE_CIVILIAN_PORTAL !== "false", enableMessaging: process.env.ENABLE_MESSAGING !== "false", enableAdminPanel: process.env.ENABLE_ADMIN_PANEL !== "false", enableSupervisorPanel: process.env.ENABLE_SUPERVISOR_PANEL !== "false", }, // Module enablement - controls which modules are available modules: { // These are no longer used for button text, just for internal reference lawEnforcement: "Law Enforcement", civilCenter: "Civil Center", supervisorPanel: "Sergeant's Desk", messaging: "Messaging", adminPanel: "Admin Panel", accountSettings: "Account Settings", }, // System features features: { // MDT features enableNameSearch: process.env.FEATURE_NAME_SEARCH !== "false", enableVehicleSearch: process.env.FEATURE_VEHICLE_SEARCH !== "false", enableCallManagement: process.env.FEATURE_CALL_MANAGEMENT !== "false", enableReports: process.env.FEATURE_REPORTS !== "false", // Admin features enableUserManagement: process.env.FEATURE_USER_MANAGEMENT !== "false", enableAuditLogs: process.env.FEATURE_AUDIT_LOGS !== "false", enableSystemSettings: process.env.FEATURE_SYSTEM_SETTINGS !== "false", }, // Discord logging discord: { enabled: process.env.ENABLE_DISCORD_LOGGING === "true", webhookUrl: process.env.DISCORD_WEBHOOK_URL || "", systemName: process.env.DISCORD_SYSTEM_NAME || "Northpoint MDT", logLevel: process.env.DISCORD_LOG_LEVEL || "info", // info, warn, error, debug }, } // Database table names - allows for custom table prefixes export const DB_CONFIG = { tablePrefix: process.env.DB_TABLE_PREFIX || "", tables: { users: process.env.DB_TABLE_USERS || "users", persons: process.env.DB_TABLE_PERSONS || "persons", vehicles: process.env.DB_TABLE_VEHICLES || "vehicles", calls: process.env.DB_TABLE_CALLS || "calls", units: process.env.DB_TABLE_UNITS || "units", criminalRecords: process.env.DB_TABLE_CRIMINAL_RECORDS || "criminal_records", messages: process.env.DB_TABLE_MESSAGES || "messages", auditLogs: process.env.DB_TABLE_AUDIT_LOGS || "audit_logs", }, } // Helper function to get full table name with prefix export function getTableName(table: keyof typeof DB_CONFIG.tables): string { return `${DB_CONFIG.tablePrefix}${DB_CONFIG.tables[table]}` } [V0_FILE]typescriptreact:file="app/globals.css" isEdit="true" isQuickEdit="true" @tailwind base; @tailwind components; @tailwind utilities; :root { --background: 222 47% 11%; --foreground: 210 40% 98%; --card: 222 47% 11%; --card-foreground: 210 40% 98%; --popover: 222 47% 11%; --popover-foreground: 210 40% 98%; --primary: 210 40% 30%; --primary-foreground: 210 40% 98%; --secondary: 217.2 32.6% 17.5%; --secondary-foreground: 210 40% 98%; --muted: 217.2 32.6% 17.5%; --muted-foreground: 215 20.2% 65.1%; --accent: 217.2 32.6% 17.5%; --accent-foreground: 210 40% 98%; --destructive: 0 62.8% 30.6%; --destructive-foreground: 210 40% 98%; --border: 217.2 32.6% 17.5%; --input: 217.2 32.6% 17.5%; --ring: 212.7 26.8% 83.9%; --radius: 0.5rem; } .dark { --background: 222 47% 11%; --foreground: 210 40% 98%; --card: 222 47% 11%; --card-foreground: 210 40% 98%; --popover: 222 47% 11%; --popover-foreground: 210 40% 98%; --primary: 210 40% 50%; --primary-foreground: 222.2 47.4% 11.2%; --secondary: 217.2 32.6% 17.5%; --secondary-foreground: 210 40% 98%; --muted: 217.2 32.6% 17.5%; --muted-foreground: 215 20.2% 65.1%; --accent: 217.2 32.6% 17.5%; --accent-foreground: 210 40% 98%; --destructive: 0 62.8% 30.6%; --destructive-foreground: 210 40% 98%; --border: 217.2 32.6% 17.5%; --input: 217.2 32.6% 17.5%; --ring: 212.7 26.8% 83.9%; } body { background-color: hsl(var(--background)); color: hsl(var(--foreground)); } /* MDT Styles */ .mdt-window { background-color: #1a2836; border: 1px solid #2a3846; box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.3), 0 2px 4px -1px rgba(0, 0, 0, 0.2); color: #e2e8f0; } .mdt-header { background-color: #0c2542; color: white; font-weight: 600; padding: 0.25rem; } .mdt-tab { padding-left: 0.5rem; padding-right: 0.5rem; padding-top: 0.25rem; padding-bottom: 0.25rem; border-right: 1px solid #2a3846; cursor: pointer; } .mdt-tab:hover { background-color: #1a3a5f; } .mdt-tab.active { background-color: #1a3a5f; } .mdt-input { border: 1px solid #2a3846; padding: 0.25rem; width: 100%; background-color: #0f1c2a; color: #e2e8f0; } .mdt-button { padding-left: 0.5rem; padding-right: 0.5rem; padding-top: 0.25rem; padding-bottom: 0.25rem; background-color: #1a3a5f; border: 1px solid #2a3846; color: #e2e8f0; } .mdt-button:hover { background-color: #2a4a6f; } .mdt-table { width: 100%; border-collapse: collapse; } .mdt-table th { background-color: #0c2542; color: white; font-weight: 600; padding: 0.25rem; border: 1px solid #2a3846; } .mdt-table td { padding: 0.25rem; border: 1px solid #2a3846; color: #e2e8f0; } .mdt-table tr:nth-child(even) { background-color: #1a2836; } .mdt-table tr:hover { background-color: #2a3846; } .mdt-status-rcvd { color: #10b981; font-weight: 700; } .mdt-status-pending { color: #f59e0b; font-weight: 700; } .mdt-status-dispatched { color: #3b82f6; font-weight: 700; } .mdt-status-closed { color: #9ca3af; font-weight: 700; } .mdt-priority-1 { color: #ef4444; font-weight: 700; } .mdt-priority-2 { color: #f97316; font-weight: 700; } .mdt-priority-3 { color: #f59e0b; font-weight: 700; } [V0_FILE]typescriptreact:file="components/flex/dashboard.tsx" isEdit="true" isQuickEdit="true" "use client" import type { User } from "@/lib/types" import { useRouter } from "next/navigation" import { useAuth } from "@/lib/auth-provider" interface FlexDashboardProps { user: User } export default function FlexDashboard({ user }: FlexDashboardProps) { const { signOut } = useAuth() const router = useRouter() return (

NORTHPOINT

Welcome, {user?.full_name || "Officer"}

router.push("/cad")} > Law Enforcement

router.push("/sergeant")} > Sergeant's Desk

router.push("/messages")} > Email

router.push("/civil")} > Civil Center

router.push("/admin")} > Admin Panel

router.push("/account")} > Edit Account

signOut()} > Log Out

Roleplay Purposes Only © Northpoint Roleplay 2024

) } [V0_FILE]typescriptreact:file="components/admin/interface.tsx" isEdit="true" isQuickEdit="true" "use client" import type React from "react" import { useState } from "react" import { useRouter } from "next/navigation" import type { User } from "@/lib/types" import { SYSTEM_CONFIG } from "@/lib/config" import { Users, Settings, Database, Shield, FileText, BarChart, Search, Plus, Edit, Trash2, Save } from "lucide-react" import { useToast } from "@/components/ui/use-toast" import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Checkbox } from "@/components/ui/checkbox" interface AdminInterfaceProps { currentUser: User users: User[] } export default function AdminInterface({ currentUser, users: initialUsers }: AdminInterfaceProps) { const [activeTab, setActiveTab] = useState("users") const [searchQuery, setSearchQuery] = useState("") const [users, setUsers] = useState(initialUsers) const [isUserDialogOpen, setIsUserDialogOpen] = useState(false) const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false) const [selectedUser, setSelectedUser] = useState(null) const [userForm, setUserForm] = useState({ username: "", password: "", full_name: "", badge_number: "", department: "", rank: "", is_admin: false, }) const [isSubmitting, setIsSubmitting] = useState(false) const [systemSettings, setSystemSettings] = useState({ ...SYSTEM_CONFIG, }) const [isSettingsChanged, setIsSettingsChanged] = useState(false) const router = useRouter() const { toast } = useToast() const filteredUsers = users.filter( (user) => user.username.toLowerCase().includes(searchQuery.toLowerCase()) || user.full_name.toLowerCase().includes(searchQuery.toLowerCase()) || (user.badge_number && user.badge_number.toLowerCase().includes(searchQuery.toLowerCase())), ) // Handle user form changes const handleUserFormChange = (e: React.ChangeEvent) => { const { name, value, type, checked } = e.target setUserForm({ ...userForm, [name]: type === "checkbox" ? checked : value, }) } // Handle select changes const handleSelectChange = (name: string, value: string) => { setUserForm({ ...userForm, [name]: value, }) } // Handle checkbox changes const handleCheckboxChange = (name: string, checked: boolean) => { setUserForm({ ...userForm, [name]: checked, }) } // Open user dialog for creating a new user const openNewUserDialog = () => { setSelectedUser(null) setUserForm({ username: "", password: "", full_name: "", badge_number: "", department: "", rank: "", is_admin: false, }) setIsUserDialogOpen(true) } // Open user dialog for editing an existing user const openEditUserDialog = (user: User) => { setSelectedUser(user) setUserForm({ username: user.username, password: "", // Don't populate password for security full_name: user.full_name, badge_number: user.badge_number || "", department: user.department || "", rank: user.rank || "", is_admin: user.is_admin, }) setIsUserDialogOpen(true) } // Open delete confirmation dialog const openDeleteDialog = (user: User) => { setSelectedUser(user) setIsDeleteDialogOpen(true) } // Handle user form submission const handleUserSubmit = async (e: React.FormEvent) => { e.preventDefault() setIsSubmitting(true) try { if (!userForm.username || !userForm.full_name) { throw new Error("Username and full name are required") } if (!selectedUser && !userForm.password) { throw new Error("Password is required for new users") } // Create or update user const endpoint = selectedUser ? `/api/users/${selectedUser.id}` : "/api/users" const method = selectedUser ? "PATCH" : "POST" const response = await fetch(endpoint, { method, headers: { "Content-Type": "application/json", }, body: JSON.stringify(userForm), }) if (!response.ok) { const data = await response.json() throw new Error(data.error || "Failed to save user") } // If successful, refresh the user list const usersResponse = await fetch("/api/users") const usersData = await usersResponse.json() if (usersResponse.ok) { setUsers(usersData.data) setIsUserDialogOpen(false) toast({ title: selectedUser ? "User Updated" : "User Created", description: `Successfully ${selectedUser ? "updated" : "created"} user ${userForm.full_name}`, }) } } catch (error: any) { toast({ title: "Error", description: error.message || "An error occurred", variant: "destructive", }) } finally { setIsSubmitting(false) } } // Handle user deletion const handleDeleteUser = async () => { if (!selectedUser) return setIsSubmitting(true) try { const response = await fetch(`/api/users/${selectedUser.id}`, { method: "DELETE", }) if (!response.ok) { const data = await response.json() throw new Error(data.error || "Failed to delete user") } // If successful, refresh the user list const usersResponse = await fetch("/api/users") const usersData = await usersResponse.json() if (usersResponse.ok) { setUsers(usersData.data) setIsDeleteDialogOpen(false) toast({ title: "User Deleted", description: `Successfully deleted user ${selectedUser.full_name}`, }) } } catch (error: any) { toast({ title: "Error", description: error.message || "An error occurred", variant: "destructive", }) } finally { setIsSubmitting(false) } } // Handle system settings changes const handleSettingsChange = (section: string, key: string, value: any) => { setSystemSettings((prev) => ({ ...prev, [section]: { ...prev[section as keyof typeof prev], [key]: value, }, })) setIsSettingsChanged(true) } // Save system settings const saveSystemSettings = async () => { setIsSubmitting(true) try { const response = await fetch("/api/settings", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify(systemSettings), }) if (!response.ok) { const data = await response.json() throw new Error(data.error || "Failed to save settings") } toast({ title: "Settings Saved", description: "System settings have been updated successfully", }) setIsSettingsChanged(false) } catch (error: any) { toast({ title: "Error", description: error.message || "An error occurred", variant: "destructive", }) } finally { setIsSubmitting(false) } } // Test Discord webhook const testDiscordWebhook = async () => { try { const response = await fetch("/api/discord/test", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ webhookUrl: systemSettings.discord.webhookUrl, systemName: systemSettings.discord.systemName, }), }) if (!response.ok) { const data = await response.json() throw new Error(data.error || "Failed to test webhook") } toast({ title: "Webhook Test Successful", description: "Discord webhook is working correctly", }) } catch (error: any) { toast({ title: "Webhook Test Failed", description: error.message || "An error occurred", variant: "destructive", }) } finally { setIsSubmitting(false) } } return (

{SYSTEM_CONFIG.modules.adminPanel}

{currentUser.full_name}

{/* Sidebar */}

setActiveTab("users")} > User Management

setActiveTab("settings")} > System Settings

setActiveTab("database")} > Database Management

setActiveTab("permissions")} > Permissions

setActiveTab("logs")} > System Logs

setActiveTab("stats")} > Statistics

{/* Content area */}

{activeTab === "users" && (

User Management

setSearchQuery(e.target.value)} />

{filteredUsers.map((user) => ( ))} {filteredUsers.length === 0 && ( )}

Username	Full Name	Badge #	Department	Role	Actions
{user.username}	{user.full_name}	{user.badge_number \|\| "N/A"}	{user.department \|\| "N/A"}	{user.is_admin ? ( Admin ) : ( User )}
No users found

)} {activeTab === "settings" && (

System Settings

Agency Information

Agency Name handleSettingsChange("agency", "name", e.target.value)} />

Short Name handleSettingsChange("agency", "shortName", e.target.value)} />

Jurisdiction handleSettingsChange("agency", "jurisdiction", e.target.value)} />

Appearance

Primary Color

handleSettingsChange("appearance", "primaryColor", e.target.value)} /> handleSettingsChange("appearance", "primaryColor", e.target.value)} />

Secondary Color

handleSettingsChange("appearance", "secondaryColor", e.target.value)} /> handleSettingsChange("appearance", "secondaryColor", e.target.value)} />

Dashboard Title handleSettingsChange("appearance", "dashboardTitle", e.target.value)} />

Feature Toggles

handleSettingsChange("appearance", "enableCivilianPortal", checked === true) } /> Enable Civilian Portal

handleSettingsChange("appearance", "enableMessaging", checked === true) } /> Enable Messaging

handleSettingsChange("appearance", "enableSupervisorPanel", checked === true) } /> Enable Supervisor Panel

handleSettingsChange("appearance", "enableAdminPanel", checked === true) } /> Enable Admin Panel

Discord Logging

handleSettingsChange("discord", "enabled", checked === true)} /> Enable Discord Logging

System Name handleSettingsChange("discord", "systemName", e.target.value)} />

Discord Webhook URL handleSettingsChange("discord", "webhookUrl", e.target.value)} />

Log Level

)} {activeTab !== "users" && activeTab !== "settings" && (

Module Under Development

This feature is currently being developed and will be available in a future update.

)}

{/* User Dialog */} {/* Delete Confirmation Dialog */}

) } [V0_FILE]typescriptreact:file="components/civilian/dashboard.tsx" isEdit="true" isQuickEdit="true" "use client" import type { User } from "@/lib/types" import { useRouter } from "next/navigation" interface CivilianDashboardProps { user: User } export default function CivilianDashboard({ user }: CivilianDashboardProps) { const router = useRouter() const handleLogout = async () => { await fetch("/api/auth/logout", { method: "POST", }) router.push("/") } const handleNavigation = (path: string) => { router.push(path) } return (

{/* Header */}

NORTHPOINT

{/* Welcome message */}

Welcome, {user?.username || user?.full_name || "Citizen"}

{/* Main grid */}

{/* Vehicle Registration */}

handleNavigation("/civilian/vehicles")} > Vehicle Registration

{/* Personal Records */}

handleNavigation("/civilian/records")} > Personal Records

{/* Citations */}

handleNavigation("/civilian/citations")} > Citations

{/* Property Records */}

handleNavigation("/civilian/property")} > Property Records

{/* Court Documents */}

handleNavigation("/civilian/court")} > Court Documents

{/* Messages */}

handleNavigation("/civilian/messages")} > Messages

{/* Log Out */}

Log Out

{/* Footer */}

) } [V0_FILE]typescriptreact:file="components/messages/interface.tsx" isEdit="true" isQuickEdit="true" "use client" import { useState } from "react" import { useRouter } from "next/navigation" import type { User } from "@/lib/types" import { SYSTEM_CONFIG } from "@/lib/config" import { format } from "date-fns" import { Mail, Trash2, Reply, Star, Archive, Edit, Search, ChevronLeft } from "lucide-react" interface Message { id: number sender: string subject: string content: string date: string read: boolean } interface MessagesInterfaceProps { user: User messages: Message[] } export default function MessagesInterface({ user, messages }: MessagesInterfaceProps) { const [selectedMessage, setSelectedMessage] = useState(null) const [searchQuery, setSearchQuery] = useState("") const router = useRouter() const config = SYSTEM_CONFIG const filteredMessages = messages.filter( (message) => message.subject.toLowerCase().includes(searchQuery.toLowerCase()) || message.sender.toLowerCase().includes(searchQuery.toLowerCase()) || message.content.toLowerCase().includes(searchQuery.toLowerCase()), ) const unreadCount = messages.filter((message) => !message.read).length return (

{config.modules.messaging}

{user.full_name}

{/* Sidebar */}

setSearchQuery(e.target.value)} />

Inbox

{unreadCount > 0 && ( {unreadCount} )}

Starred

Archived

Trash

{/* Message list or selected message */}

{selectedMessage ? (

{selectedMessage.subject}

From: {selectedMessage.sender}

{format(new Date(selectedMessage.date), "MMM d, yyyy h:mm a")}

To: {user.full_name}

{selectedMessage.content}

) : (

Inbox

{filteredMessages.length > 0 ? ( filteredMessages.map((message) => (

setSelectedMessage(message)} >

{!message.read &&

} {message.sender}

{format(new Date(message.date), "MMM d")}

{message.subject}

{message.content}

)) ) : (

No messages found

)}

) } [V0_FILE]typescriptreact:file="components/supervisor/interface.tsx" isEdit="true" isQuickEdit="true" "use client" import { useState } from "react" import { useRouter } from "next/navigation" import type { User, Call } from "@/lib/types" import { SYSTEM_CONFIG } from "@/lib/config" import { format } from "date-fns" import { Users, FileText, Clock, CheckSquare, AlertTriangle, Search, Filter, ChevronDown, ChevronUp, } from "lucide-react" interface SupervisorInterfaceProps { currentUser: User officers: User[] calls: Call[] } export default function SupervisorInterface({ currentUser, officers, calls }: SupervisorInterfaceProps) { const [activeTab, setActiveTab] = useState("officers") const [searchQuery, setSearchQuery] = useState("") const [showFilters, setShowFilters] = useState(false) const router = useRouter() const config = SYSTEM_CONFIG const filteredOfficers = officers.filter( (officer) => officer.username.toLowerCase().includes(searchQuery.toLowerCase()) || officer.full_name.toLowerCase().includes(searchQuery.toLowerCase()) || (officer.badge_number && officer.badge_number.toLowerCase().includes(searchQuery.toLowerCase())), ) return (

{config.modules.supervisorPanel}

{currentUser.full_name}

{activeTab === "officers" && (

Officer Management

setSearchQuery(e.target.value)} />

{showFilters && (

Department

Rank

Status

)}

{filteredOfficers.map((officer) => ( ))} {filteredOfficers.length === 0 && ( )}

Badge #	Name	Rank	Department	Status	Last Activity
{officer.badge_number \|\| "N/A"}	{officer.full_name}	{officer.rank \|\| "Officer"}	{officer.department \|\| "Patrol"}	Available	{format(new Date(), "h:mm a")}
No officers found

)} {activeTab === "calls" && (

Call Management

{calls.map((call) => ( ))} {calls.length === 0 && ( )}

Call #	Nature	Address	Priority	Status	Time	Units
{call.call_number}	{call.nature}	{call.address}	{call.priority}	{call.status}	{format(new Date(call.created_at), "h:mm a")}	-
No calls found

)} {(activeTab === "reports" || activeTab === "approvals") && (

Module Under Development

This feature is currently being developed and will be available in a future update.

)}

) } [V0_FILE]typescript:file="app/api/settings/route.ts" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { type NextRequest, NextResponse } from "next/server" import { DiscordLogger } from "@/lib/discord-logger" export async function GET(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Check if the user is an admin const { data: currentUser } = await supabase.from("users").select("is_admin").eq("id", session.user.id).single() if (!currentUser?.is_admin) { await DiscordLogger.warn(`Non-admin user attempted to access settings API`, { user: session.user.email || session.user.id, action: "Unauthorized Access", details: { endpoint: "GET /api/settings" }, }) return NextResponse.json({ error: "Unauthorized - Admin access required" }, { status: 403 }) } // Get settings from database const { data: settings, error } = await supabase.from("settings").select("*").single() if (error && error.code !== "PGRST116") { await DiscordLogger.error(`Error fetching settings`, { user: session.user.email || session.user.id, details: error, }) return NextResponse.json({ error: error.message }, { status: 500 }) } return NextResponse.json({ data: settings || {} }) } catch (error: any) { console.error("Error in settings API:", error) await DiscordLogger.error("Settings API error", { details: error.message || "Internal server error", }) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } export async function POST(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Check if the user is an admin const { data: currentUser } = await supabase .from("users") .select("is_admin, username") .eq("id", session.user.id) .single() if (!currentUser?.is_admin) { await DiscordLogger.warn(`Non-admin user attempted to update settings`, { user: currentUser?.username || session.user.email || session.user.id, action: "Unauthorized Access", details: { endpoint: "POST /api/settings" }, }) return NextResponse.json({ error: "Unauthorized - Admin access required" }, { status: 403 }) } const settings = await request.json() // Check if settings already exist const { data: existingSettings, error: checkError } = await supabase.from("settings").select("id").single() if (checkError && checkError.code !== "PGRST116") { await DiscordLogger.error(`Error checking settings`, { user: currentUser.username, details: checkError, }) return NextResponse.json({ error: checkError.message }, { status: 500 }) } let result if (existingSettings) { // Update existing settings result = await supabase.from("settings").update(settings).eq("id", existingSettings.id).select().single() } else { // Create new settings result = await supabase.from("settings").insert(settings).select().single() } if (result.error) { await DiscordLogger.error(`Error saving settings`, { user: currentUser.username, details: result.error, }) return NextResponse.json({ error: result.error.message }, { status: 500 }) } await DiscordLogger.logUpdate("Settings", currentUser.username, { settings: settings, }) return NextResponse.json({ data: result.data }) } catch (error: any) { console.error("Error in settings API:", error) await DiscordLogger.error("Settings API error", { details: error.message || "Internal server error", }) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/discord/test/route.ts" import { createRouteHandlerClient } from "@supabase/auth-helpers-nextjs" import { cookies } from "next/headers" import { type NextRequest, NextResponse } from "next/server" export async function POST(request: NextRequest) { try { const supabase = createRouteHandlerClient({ cookies }) // Check if user is authenticated const { data: { session }, } = await supabase.auth.getSession() if (!session) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } // Check if the user is an admin const { data: currentUser } = await supabase.from("users").select("is_admin").eq("id", session.user.id).single() if (!currentUser?.is_admin) { return NextResponse.json({ error: "Unauthorized - Admin access required" }, { status: 403 }) } const { webhookUrl, systemName } = await request.json() if (!webhookUrl) { return NextResponse.json({ error: "Webhook URL is required" }, { status: 400 }) } // Send a test message to the webhook const response = await fetch(webhookUrl, { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ embeds: [ { title: "Test Message", description: "This is a test message from the Northpoint MDT system.", color: 3447003, // Blue timestamp: new Date().toISOString(), footer: { text: systemName || "Northpoint MDT", }, fields: [ { name: "Status", value: "Webhook is working correctly!", inline: true, }, { name: "Sent By", value: currentUser.username || session.user.email || session.user.id, inline: true, }, ], }, ], }), }) if (!response.ok) { const errorText = await response.text() return NextResponse.json({ error: `Discord webhook error: ${errorText}` }, { status: 500 }) } return NextResponse.json({ success: true }) } catch (error: any) { console.error("Error testing Discord webhook:", error) return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 }) } }