elevenlabs-webhook-nodejs 1.0.0

package/frontend/src/layouts/mobile-sidebar.tsx

@@ -0,0 +1,120 @@
+import { useLocation, useNavigate } from "react-router-dom"
+import { useTranslation } from "react-i18next"
+import { cn } from "@/lib/utils"
+import {
+  Sheet,
+  SheetContent,
+  SheetHeader,
+  SheetTitle,
+} from "@/components/ui/sheet"
+import { ScrollArea } from "@/components/ui/scroll-area"
+import { Separator } from "@/components/ui/separator"
+import { Heart } from "lucide-react"
+import {
+  LayoutDashboard,
+  Users,
+  Calendar,
+  CalendarDays,
+  Stethoscope,
+  MessageSquare,
+  Phone,
+  TrendingUp,
+  Megaphone,
+  ClipboardCheck,
+  CreditCard,
+  UserCog,
+  Building2,
+  PhoneCall,
+  Settings,
+  Shield,
+  ShieldCheck,
+  FileText,
+} from "lucide-react"
+import { useUIStore } from "@/stores/ui.store"
+import { useAuthStore } from "@/stores/auth.store"
+
+const navItems: ({ icon: any; labelKey: string; path: string; permission?: string; role?: string } | "sep")[] = [
+  { icon: LayoutDashboard, labelKey: "nav.dashboard", path: "/" },
+  "sep",
+  { icon: Users, labelKey: "nav.patients", path: "/patients", permission: "patients:read" },
+  { icon: Calendar, labelKey: "nav.appointments", path: "/appointments", permission: "appointments:read" },
+  { icon: CalendarDays, labelKey: "nav.calendar", path: "/calendar", permission: "appointments:read" },
+  { icon: Stethoscope, labelKey: "nav.treatments", path: "/treatments", permission: "treatments:read" },
+  "sep",
+  { icon: MessageSquare, labelKey: "nav.chats", path: "/chats", permission: "chats:read,chats:read_own" },
+  { icon: Phone, labelKey: "nav.calls", path: "/calls", permission: "calls:read" },
+  { icon: TrendingUp, labelKey: "nav.leads", path: "/leads", permission: "leads:read" },
+  "sep",
+  { icon: Megaphone, labelKey: "nav.campaigns", path: "/campaigns", permission: "campaigns:read" },
+  { icon: ClipboardCheck, labelKey: "nav.validation", path: "/validation", permission: "validation:read" },
+  "sep",
+  { icon: CreditCard, labelKey: "nav.billing", path: "/billing", permission: "billing:read" },
+  { icon: UserCog, labelKey: "nav.users", path: "/users", permission: "users:read" },
+  { icon: Building2, labelKey: "nav.clinics", path: "/clinics", permission: "clinics:read" },
+  { icon: PhoneCall, labelKey: "nav.phoneNumbers", path: "/phone-numbers", permission: "phone_numbers:read" },
+  { icon: Settings, labelKey: "nav.settings", path: "/settings" },
+  "sep",
+  { icon: Shield, labelKey: "nav.audit", path: "/audit", permission: "audit:read" },
+  { icon: FileText, labelKey: "nav.logs", path: "/logs", permission: "audit:read" },
+  { icon: Building2, labelKey: "nav.platform", path: "/platform", role: "superadmin" },
+  { icon: ShieldCheck, labelKey: "nav.adminPanel", path: "/admin", role: "superadmin" },
+]
+
+export function MobileSidebar() {
+  const { t } = useTranslation()
+  const location = useLocation()
+  const navigate = useNavigate()
+  const open = useUIStore((s) => s.sidebarOpen)
+  const setOpen = useUIStore((s) => s.setSidebarOpen)
+  const user = useAuthStore((s) => s.user)
+  const userPerms = user?.permissions ?? []
+  const userRole = user?.role ?? ""
+  const isSuperadmin = userRole === "superadmin"
+
+  const filteredItems = navItems.filter((item) => {
+    if (item === "sep") return true
+    if (isSuperadmin) return true
+    if (item.role) return userRole === item.role
+    if (item.permission) return item.permission.split(",").some((p: string) => userPerms.includes(p))
+    return true
+  })
+
+  return (
+    <Sheet open={open} onOpenChange={setOpen}>
+      <SheetContent side="left" className="w-[260px] p-0">
+        <SheetHeader className="px-4 py-3 border-b border-border">
+          <SheetTitle className="flex items-center gap-2.5">
+            <div className="w-8 h-8 rounded-lg bg-primary flex items-center justify-center">
+              <Heart className="w-4 h-4 text-primary-foreground" />
+            </div>
+            <span className="text-sm font-semibold">{t("common.appName")}</span>
+          </SheetTitle>
+        </SheetHeader>
+        <ScrollArea className="h-[calc(100dvh-4rem)]">
+          <nav className="p-2 space-y-0.5">
+            {filteredItems.map((item, i) => {
+              if (item === "sep") return <Separator key={`sep-${i}`} className="my-2" />
+              const Icon = item.icon
+              const active = location.pathname === item.path || (item.path !== "/" && location.pathname.startsWith(item.path))
+              return (
+                <button
+                  key={item.path}
+                  onClick={() => { navigate(item.path); setOpen(false) }}
+                  className={cn(
+                    "w-full flex items-center gap-3 rounded-lg px-3 py-2.5 text-sm font-medium transition-colors cursor-pointer active:opacity-70",
+                    active
+                      ? "bg-primary/10 text-primary"
+                      : "text-muted-foreground hover:text-foreground hover:bg-muted",
+                  )}
+                >
+                  <Icon className="w-4 h-4 shrink-0" />
+                  <span>{t(item.labelKey)}</span>
+                </button>
+              )
+            })}
+          </nav>
+        </ScrollArea>
+      </SheetContent>
+    </Sheet>
+  )
+}

package/frontend/src/lib/api.ts

@@ -0,0 +1,68 @@
+import axios from "axios"
+
+// In dev: Vite proxy forwards /api/* → localhost:3005/*
+// In prod: configure reverse proxy or set VITE_API_URL
+const API_BASE = import.meta.env.VITE_API_URL || "/api"
+
+export const api = axios.create({
+  baseURL: API_BASE,
+  headers: { "Content-Type": "application/json" },
+})
+
+// Request interceptor — attach opaque access token
+api.interceptors.request.use((config) => {
+  const token = localStorage.getItem("access_token")
+  if (token) {
+    config.headers.Authorization = `Bearer ${token}`
+  }
+  return config
+})
+
+// Auth endpoints that should NOT trigger refresh/redirect on 401
+const AUTH_PATHS = ["/auth/login", "/auth/register", "/auth/refresh", "/auth/forgot-password", "/auth/reset-password"]
+
+// Response interceptor — handle 401 → refresh → retry (skip for auth endpoints)
+api.interceptors.response.use(
+  (response) => response,
+  async (error) => {
+    const original = error.config
+    const requestPath = original?.url || ""
+
+    // Don't intercept 401 on auth endpoints — let the caller handle it
+    const isAuthRequest = AUTH_PATHS.some((p) => requestPath.includes(p))
+    if (isAuthRequest) {
+      return Promise.reject(error)
+    }
+
+    if (error.response?.status === 401 && !original._retry) {
+      original._retry = true
+
+      const refreshToken = localStorage.getItem("refresh_token")
+      if (!refreshToken) {
+        localStorage.removeItem("access_token")
+        localStorage.removeItem("refresh_token")
+        window.location.href = "/login"
+        return Promise.reject(error)
+      }
+
+      try {
+        const { data } = await axios.post(`${API_BASE}/auth/refresh`, {
+          refreshToken,
+        })
+
+        localStorage.setItem("access_token", data.accessToken)
+        localStorage.setItem("refresh_token", data.refreshToken)
+
+        original.headers.Authorization = `Bearer ${data.accessToken}`
+        return api(original)
+      } catch {
+        localStorage.removeItem("access_token")
+        localStorage.removeItem("refresh_token")
+        window.location.href = "/login"
+        return Promise.reject(error)
+      }
+    }
+
+    return Promise.reject(error)
+  }
+)

package/frontend/src/lib/hooks/use-appointments.ts

@@ -0,0 +1,224 @@
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query"
+import { api } from "@/lib/api"
+
+// ─── Types ───────────────────────────────────────────────────
+
+interface AppointmentPatient {
+  id: string
+  firstName: string
+  lastName: string
+  displayName: string
+  phone: string
+}
+
+interface AppointmentDoctor {
+  id: string
+  firstName: string
+  lastName: string
+}
+
+interface AppointmentClinic {
+  id: string
+  name: string
+}
+
+interface AppointmentTreatment {
+  id: string
+  name: string
+}
+
+interface Appointment {
+  id: string
+  clinicId: string
+  patientId: string
+  doctorId: string | null
+  treatmentId: string | null
+  patientName: string
+  patientPhone: string
+  startTime: string
+  endTime: string
+  durationMinutes: number
+  type: string
+  status: string
+  source: string
+  notes: string
+  cancelledAt: string | null
+  completedAt: string | null
+  createdAt: string
+  updatedAt: string
+  patient: AppointmentPatient
+  doctor: AppointmentDoctor | null
+  clinic: AppointmentClinic
+  treatment?: AppointmentTreatment
+}
+
+interface AppointmentsResponse {
+  data: Appointment[]
+  meta: {
+    total: number
+    page: number
+    limit: number
+    totalPages: number
+  }
+}
+
+interface AppointmentsQuery {
+  page?: number
+  limit?: number
+  status?: string
+  doctorId?: string
+  clinicId?: string
+  from?: string
+  to?: string
+  search?: string
+}
+
+interface AppointmentStats {
+  total: number
+  byStatus: Record<string, number>
+  bySource: Record<string, number>
+  today: number
+  upcoming: number
+}
+
+interface CreateAppointmentPayload {
+  patientId: string
+  clinicId: string
+  doctorId?: string
+  treatmentId?: string
+  startTime: string
+  endTime: string
+  durationMinutes: number
+  type?: string
+  source?: string
+  notes?: string
+}
+
+interface UpdateStatusPayload {
+  status: string
+  cancelledReason?: string
+}
+
+// ─── Hooks ───────────────────────────────────────────────────
+
+export function useAppointments(query: AppointmentsQuery = {}) {
+  return useQuery({
+    queryKey: ["appointments", query],
+    queryFn: async () => {
+      const params = new URLSearchParams()
+      if (query.page) params.set("page", String(query.page))
+      if (query.limit) params.set("limit", String(query.limit))
+      if (query.status) params.set("status", query.status)
+      if (query.doctorId) params.set("doctorId", query.doctorId)
+      if (query.clinicId) params.set("clinicId", query.clinicId)
+      if (query.from) params.set("from", query.from)
+      if (query.to) params.set("to", query.to)
+      const { data } = await api.get<AppointmentsResponse>(`/appointments?${params}`)
+      return data
+    },
+  })
+}
+
+export function useAppointmentStats() {
+  return useQuery({
+    queryKey: ["appointment-stats"],
+    queryFn: async () => {
+      const { data } = await api.get<AppointmentStats>("/appointments/stats")
+      return data
+    },
+  })
+}
+
+export function useCreateAppointment() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: async (payload: CreateAppointmentPayload) => {
+      const { data } = await api.post<Appointment>("/appointments", payload)
+      return data
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["appointments"] })
+      queryClient.invalidateQueries({ queryKey: ["appointment-stats"] })
+    },
+  })
+}
+
+export function useUpdateAppointmentStatus() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: async ({ id, ...payload }: UpdateStatusPayload & { id: string }) => {
+      const { data } = await api.put<Appointment>(`/appointments/${id}/status`, payload)
+      return data
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["appointments"] })
+      queryClient.invalidateQueries({ queryKey: ["appointment-stats"] })
+    },
+  })
+}
+
+export function useCancelAppointment() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: async (id: string) => {
+      await api.delete(`/appointments/${id}`)
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["appointments"] })
+      queryClient.invalidateQueries({ queryKey: ["appointment-stats"] })
+    },
+  })
+}
+
+// ─── Availability ────────────────────────────────────────────
+
+interface AvailabilitySlot {
+  start: string
+  end: string
+  available: boolean
+}
+
+interface AvailabilityResponse {
+  date: string
+  slotDuration: number
+  slots: AvailabilitySlot[]
+  message?: string
+}
+
+interface AvailabilityQuery {
+  clinicId: string
+  date: string
+  doctorId?: string
+}
+
+export function useAvailability(query: AvailabilityQuery | null) {
+  return useQuery({
+    queryKey: ["availability", query],
+    queryFn: async () => {
+      if (!query) return null
+      const params = new URLSearchParams()
+      params.set("clinicId", query.clinicId)
+      params.set("date", query.date)
+      if (query.doctorId) params.set("doctorId", query.doctorId)
+      const { data } = await api.get<AvailabilityResponse>(`/appointments/availability?${params}`)
+      return data
+    },
+    enabled: !!query?.clinicId && !!query?.date,
+  })
+}
+
+export type {
+  Appointment,
+  AppointmentPatient,
+  AppointmentDoctor,
+  AppointmentClinic,
+  AppointmentTreatment,
+  AppointmentsResponse,
+  AppointmentsQuery,
+  AppointmentStats,
+  CreateAppointmentPayload,
+  UpdateStatusPayload,
+  AvailabilitySlot,
+  AvailabilityResponse,
+  AvailabilityQuery,
+}

package/frontend/src/lib/hooks/use-availability-blocks.ts

@@ -0,0 +1,83 @@
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query"
+import { api } from "@/lib/api"
+
+interface AvailabilityBlock {
+  id: string
+  clinicId: string
+  doctorId: string | null
+  title: string
+  type: string
+  startDate: string
+  endDate: string
+  allDay: boolean
+  startTime: string | null
+  endTime: string | null
+  recurring: boolean
+  notes: string
+  doctor: { id: string; firstName: string; lastName: string } | null
+  createdBy: { id: string; firstName: string; lastName: string } | null
+  createdAt: string
+}
+
+interface CreateBlockPayload {
+  clinicId: string
+  doctorId?: string
+  title: string
+  type?: string
+  startDate: string
+  endDate: string
+  allDay?: boolean
+  startTime?: string
+  endTime?: string
+  recurring?: boolean
+  notes?: string
+}
+
+interface BlocksQuery {
+  clinicId?: string
+  doctorId?: string
+  from?: string
+  to?: string
+}
+
+export function useAvailabilityBlocks(query: BlocksQuery = {}) {
+  return useQuery({
+    queryKey: ["availability-blocks", query],
+    queryFn: async () => {
+      const params = new URLSearchParams()
+      if (query.clinicId) params.set("clinicId", query.clinicId)
+      if (query.doctorId) params.set("doctorId", query.doctorId)
+      if (query.from) params.set("from", query.from)
+      if (query.to) params.set("to", query.to)
+      const { data } = await api.get<AvailabilityBlock[]>(`/availability-blocks?${params}`)
+      return data
+    },
+  })
+}
+
+export function useCreateAvailabilityBlock() {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: async (payload: CreateBlockPayload) => {
+      const { data } = await api.post<AvailabilityBlock>("/availability-blocks", payload)
+      return data
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ["availability-blocks"] })
+    },
+  })
+}
+
+export function useDeleteAvailabilityBlock() {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: async (id: string) => {
+      await api.delete(`/availability-blocks/${id}`)
+    },
+    onSuccess: () => {
+      qc.invalidateQueries({ queryKey: ["availability-blocks"] })
+    },
+  })
+}
+
+export type { AvailabilityBlock, CreateBlockPayload, BlocksQuery }