/** * Bookings Page * Clean, minimal SaaS-style bookings management page */ import React, { useState, useMemo } from "react"; import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query"; import { Plus, ArrowUpDown, ArrowUp, ArrowDown, Eye, Edit, Trash2, AlertTriangle, CreditCard, CircleDollarSign, Undo2, Mail, Download, } from "lucide-react"; import { Pagination, SearchFilterToolbar, BulkActionToolbar, Table as SharedTable, } from "../components/shared"; import { __ } from "../lib/i18n"; import { downloadAdminBookingInvoice } from "../lib/invoice-download"; import { buildYatraSinglePublicUrls, isWordPressPlainPermalink, } from "../lib/frontend-permalink-urls"; import { useToast } from "../components/ui/toast"; import { Button } from "../components/ui/button"; import { Select } from "../components/ui/select"; import { PageHeader } from "../components/common/PageHeader"; import { Card, CardContent } from "../components/ui/card"; import { ConditionalRender } from "../components/ui/conditional-render"; import { ConfirmationDialog } from "../components/ui/confirmation-dialog"; import { formatYatraMoney } from "../lib/currency-display"; import { apiService, apiClient } from "../lib/api-client"; import { formatDate as formatDateUtil } from "../lib/dateFormat"; import { getErrorContext } from "../lib/errors"; import { usePermissions } from "../hooks/usePermissions"; interface Booking { id: number; booking_number: string; customer_name: string; customer_email: string; trip_title: string; trip_id: number; trip_slug?: string; booking_date: string; travel_date: string; travelers?: number; travelers_count?: number; total_amount: number; amount_paid?: number; currency?: string; payment_status: string; booking_status: string; payment_method?: string; payment_gateway?: string; created_at: string; } /** * Payment statuses an administrator can set straight from the booking list. * * Labels are prefixed with "Payment:" because the same menu already carries * booking-status actions ("Mark as Pending", "Mark as Cancelled") — without the * prefix two entries would read identically and set different fields. * * `failed` is deliberately omitted: it describes a gateway outcome rather than * something an operator records by hand, and it is still settable from the * booking edit screen. */ const PAYMENT_STATUS_ACTIONS: Array<{ value: string; label: () => string; icon: React.ReactNode; }> = [ { value: "paid", label: () => __("Payment: Mark as Paid"), icon: , }, { value: "partial", label: () => __("Payment: Mark as Partially Paid"), icon: , }, { value: "pending", label: () => __("Payment: Mark as Pending"), icon: , }, { value: "refunded", label: () => __("Payment: Mark as Refunded"), icon: , }, ]; const Bookings: React.FC = () => { const [searchTerm, setSearchTerm] = useState(""); const [statusFilter, setStatusFilter] = useState("all"); const [paymentFilter, setPaymentFilter] = useState("all"); const [sortBy, setSortBy] = useState("booking_date"); const [sortOrder, setSortOrder] = useState<"asc" | "desc">("desc"); const [page, setPage] = useState(1); const [selectedIds, setSelectedIds] = useState<(string | number)[]>([]); const [bulkAction, setBulkAction] = useState(""); const [showColumnsDropdown, setShowColumnsDropdown] = useState(false); const [isBulkPending, setIsBulkPending] = useState(false); const [deleteDialogOpen, setDeleteDialogOpen] = useState(false); const [bookingToDelete, setBookingToDelete] = useState(null); const [visibleColumns, setVisibleColumns] = useState(() => { if (typeof window === "undefined") { return { booking_number: true, customer: true, trip: true, travelers: true, booking_date: true, travel_date: true, amount: true, payment_status: true, booking_status: true, }; } const saved = window.localStorage.getItem("yatra-bookings-visible-columns"); return saved ? JSON.parse(saved) : { booking_number: true, customer: true, trip: true, travelers: true, booking_date: true, travel_date: true, amount: true, payment_status: true, booking_status: true, }; }); const queryClient = useQueryClient(); const { can } = usePermissions(); const { showToast } = useToast(); const defaultCurrency = (window as any)?.yatraAdmin?.currency || (window as any)?.yatraBookingData?.currency || "USD"; const translations = (window as any)?.yatraAdmin?.translations || {}; const statsEnabled = can("yatra_view_bookings") !== false; // Helper function for translations const __ = (text: string) => translations[text] || text; // Build query params const BOOKINGS_PER_PAGE = 10; const queryParams = useMemo(() => { const params: Record = { page, per_page: BOOKINGS_PER_PAGE, orderby: sortBy, order: sortOrder, }; if (searchTerm) { params.search = searchTerm; } if (statusFilter !== "all") { params.status = statusFilter; } if (paymentFilter !== "all") { params.payment_status = paymentFilter; } return params; }, [searchTerm, statusFilter, paymentFilter, sortBy, sortOrder, page]); // Fetch bookings from API const canViewBookings = can("yatra_view_bookings") !== false; // default true when capability data missing const { data, isLoading, error, refetch } = useQuery({ queryKey: ["bookings", queryParams], queryFn: async () => { // Check URL parameter for error simulation (for testing) const urlParams = new URLSearchParams(window.location.search); if (urlParams.get("simulate_error") === "true") { throw new Error( "Simulated API error for testing error UI functionality", ); } const params = new URLSearchParams(); params.append("page", String(queryParams.page)); params.append("per_page", String(queryParams.per_page)); if (queryParams.search) { params.append("search", queryParams.search); } if (queryParams.status) { params.append("status", queryParams.status); } if (queryParams.payment_status) { params.append("payment_status", queryParams.payment_status); } return await apiService.getBookings({ page: queryParams.page, per_page: queryParams.per_page, search: queryParams.search, status: queryParams.status, payment_status: queryParams.payment_status, // Forward sort params so column-header sorting reaches the backend. orderby: queryParams.orderby, order: queryParams.order, }); }, enabled: canViewBookings, }); // Fetch booking stats (counts) const { data: statsRaw } = useQuery({ queryKey: ["bookings-stats"], queryFn: async () => { return await apiService.getBookingsStats(); }, enabled: statsEnabled, }); const statsData: any = statsRaw ?? {}; const totalBookings = statsData?.all ?? 0; const confirmedCount = statsData?.confirmed ?? 0; const pendingCount = statsData?.pending ?? 0; const cancelledCount = statsData?.cancelled ?? 0; const completedCount = statsData?.completed ?? 0; // Delete mutation const deleteMutation = useMutation({ mutationFn: async (id: number) => { await apiService.deleteBooking(id); }, onSuccess: () => { queryClient.invalidateQueries({ queryKey: ["bookings"] }); queryClient.invalidateQueries({ queryKey: ["bookings-stats"] }); showToast(__("Booking deleted successfully"), "success"); }, onError: (error: any) => { showToast(error?.message || __("Failed to delete booking"), "error"); }, }); const bookings: Booking[] = data?.data || []; const listMeta = data?.meta ?? {}; const total = Number(listMeta.total ?? data?.total ?? 0); const perPage = Number(listMeta.per_page ?? data?.per_page ?? BOOKINGS_PER_PAGE) || BOOKINGS_PER_PAGE; const totalPages = Math.max( 1, Number(listMeta.total_pages) || (total > 0 ? Math.ceil(total / perPage) : 1), ); // Enhanced error handling const errorContext = getErrorContext(error); const apiErrorMessage = (data as any)?.error || (data as any)?.message; const derivedErrorDetails = errorContext.details || (apiErrorMessage ? String(apiErrorMessage) : undefined) || (error ? String(error?.message || error) : undefined); const isBookingsError = !!error || !!apiErrorMessage; const formatDate = (dateString: string) => { return formatDateUtil(dateString); }; const formatPrice = (price: number, currencyCode: string = defaultCurrency) => formatYatraMoney(Number(price) || 0, currencyCode, { zeroAsUnknown: false, }); const getBookingStatusBadge = (status: string) => { const statusMap: Record = { confirmed: { className: "bg-green-100 text-green-700 dark:bg-green-900/20 dark:text-green-400", label: __("Confirmed"), }, pending: { className: "bg-yellow-100 text-yellow-700 dark:bg-yellow-900/20 dark:text-yellow-400", label: __("Pending"), }, // Guest-checkout holding state: row exists but the customer hasn't // clicked the email-verification link yet, so the booking-created // fan-out (admin notify + customer confirmation) is deferred. // Visually amber-on-amber so it reads as "waiting on something // outside our control" — distinct from the regular yellow "pending" // (which means waiting on the operator). pending_verification: { className: "bg-amber-100 text-amber-800 dark:bg-amber-900/20 dark:text-amber-300 border border-amber-200 dark:border-amber-800", label: __("Awaiting email verification"), }, cancelled: { className: "bg-red-100 text-red-700 dark:bg-red-900/20 dark:text-red-400", label: __("Cancelled"), }, completed: { className: "bg-blue-100 text-blue-700 dark:bg-blue-900/20 dark:text-blue-400", label: __("Completed"), }, }; const statusInfo = statusMap[status] || { className: "bg-gray-100 text-gray-700 dark:bg-gray-700 dark:text-gray-400", label: status, }; return ( {statusInfo.label} ); }; const getPaymentStatusBadge = (status: string) => { const statusMap: Record = { paid: { className: "bg-green-100 text-green-700 dark:bg-green-900/20 dark:text-green-400", label: __("Paid"), }, pending: { className: "bg-yellow-100 text-yellow-700 dark:bg-yellow-900/20 dark:text-yellow-400", label: __("Pending"), }, partial: { className: "bg-orange-100 text-orange-700 dark:bg-orange-900/20 dark:text-orange-400", label: __("Partial"), }, refunded: { className: "bg-gray-100 text-gray-700 dark:bg-gray-700 dark:text-gray-400", label: __("Refunded"), }, }; const statusInfo = statusMap[status] || { className: "bg-gray-100 text-gray-700 dark:bg-gray-700 dark:text-gray-400", label: status, }; return ( {statusInfo.label} ); }; const handleEdit = (booking: Booking) => { window.location.href = `${window.yatraAdmin?.siteUrl || ""}/wp-admin/admin.php?page=yatra&subpage=bookings&action=edit&id=${booking.id}`; }; const handleDelete = (booking: Booking) => { setBookingToDelete(booking); setDeleteDialogOpen(true); }; const confirmDelete = () => { if (bookingToDelete) { deleteMutation.mutate(bookingToDelete.id); setDeleteDialogOpen(false); setBookingToDelete(null); } }; const cancelDelete = () => { setDeleteDialogOpen(false); setBookingToDelete(null); }; const handleView = (booking: Booking) => { window.location.href = `${window.yatraAdmin?.siteUrl || ""}/wp-admin/admin.php?page=yatra&subpage=bookings&action=view&id=${booking.id}`; }; const handleCreateBooking = () => { window.location.href = `${window.yatraAdmin?.siteUrl || ""}/wp-admin/admin.php?page=yatra&subpage=bookings&action=create`; }; const handleResetFilters = () => { setSearchTerm(""); setStatusFilter("all"); setPaymentFilter("all"); setSortBy("booking_date"); setSortOrder("desc"); setPage(1); }; const handleSort = (field: string) => { if (sortBy === field) { setSortOrder(sortOrder === "asc" ? "desc" : "asc"); } else { setSortBy(field); setSortOrder("desc"); } }; const getSortIcon = (field: string) => { if (sortBy !== field) { return ; } return sortOrder === "asc" ? ( ) : ( ); }; const hasFilters = searchTerm || statusFilter !== "all" || paymentFilter !== "all" || sortBy !== "booking_date" || sortOrder !== "desc"; const toggleColumn = (columnKey: string) => { const newVisibleColumns = { ...visibleColumns, [columnKey]: !visibleColumns[columnKey as keyof typeof visibleColumns], }; setVisibleColumns(newVisibleColumns); if (typeof window !== "undefined") { window.localStorage.setItem( "yatra-bookings-visible-columns", JSON.stringify(newVisibleColumns), ); } }; const handleSelectItem = (id: string | number, checked: boolean) => { setSelectedIds((prev) => checked ? [...prev, id] : prev.filter((selectedId) => selectedId !== id), ); }; const handleSelectAll = (checked: boolean) => { if (checked) { setSelectedIds(bookings.map((booking: Booking) => booking.id)); } else { setSelectedIds([]); } }; const isAllSelected = bookings.length > 0 && selectedIds.length === bookings.length; const updateStatusForIds = async ( ids: (string | number)[], newStatus: string, ) => { await apiService.bulkUpdateStatus("bookings", ids, newStatus); }; /** * Set a booking's payment status from the actions menu. * * Marking a booking paid also settles its money fields server-side * (BookingService::handlePaymentStatusChange), so the invoice reports the * correct Amount Paid / Amount Due rather than staying at "Payment Pending". */ const updatePaymentStatus = async (booking: Booking, status: string) => { setIsBulkPending(true); try { await apiService.updateBooking(booking.id, { payment_status: status }); queryClient.invalidateQueries({ queryKey: ["bookings"] }); queryClient.invalidateQueries({ queryKey: ["bookings-stats"] }); showToast(__("Payment status updated"), "success"); } catch (error: any) { showToast( error?.message || __("Failed to update payment status"), "error", ); } finally { setIsBulkPending(false); } }; const handleBulkApply = async () => { if (!bulkAction || selectedIds.length === 0) { return; } try { setIsBulkPending(true); if (bulkAction === "delete") { await apiService.bulkDelete("bookings", selectedIds); showToast(__("Selected bookings deleted successfully"), "success"); } else { await updateStatusForIds(selectedIds, bulkAction); showToast(__("Bulk booking status updated successfully"), "success"); } queryClient.invalidateQueries({ queryKey: ["bookings"] }); queryClient.invalidateQueries({ queryKey: ["bookings-stats"] }); setSelectedIds([]); setBulkAction(""); } catch (error: any) { showToast( __("Error: ") + (error?.message || __("Failed to perform bulk action on bookings")), "error", ); } finally { setIsBulkPending(false); } }; const allBulkActionOptions = [ { value: "confirmed", label: __("Mark as Confirmed") }, { value: "pending", label: __("Mark as Pending") }, { value: "cancelled", label: __("Mark as Cancelled") }, { value: "completed", label: __("Mark as Completed") }, { value: "delete", label: __("Delete permanently") }, ]; const getBulkActionOptionsForStatus = (view: string) => { switch (view) { case "confirmed": return allBulkActionOptions.filter((opt) => ["pending", "cancelled", "completed", "delete"].includes(opt.value), ); case "pending": return allBulkActionOptions.filter((opt) => ["confirmed", "cancelled", "completed", "delete"].includes(opt.value), ); case "cancelled": return allBulkActionOptions.filter((opt) => ["pending", "confirmed", "delete"].includes(opt.value), ); case "completed": return allBulkActionOptions.filter((opt) => ["confirmed", "cancelled", "delete"].includes(opt.value), ); default: return allBulkActionOptions; } }; const bulkActionOptions = getBulkActionOptionsForStatus(statusFilter); const statusOptions = [ { value: "all", label: __("All Status"), count: statsData?.all ?? totalBookings, }, { value: "confirmed", label: __("Confirmed"), count: confirmedCount }, { value: "pending", label: __("Pending"), count: pendingCount }, { value: "cancelled", label: __("Cancelled"), count: cancelledCount }, { value: "completed", label: __("Completed"), count: completedCount }, ]; const sortOptions = [ { value: "booking_date", label: __("Booking Date") }, { value: "travel_date", label: __("Travel Date") }, { value: "booking_number", label: __("Booking Number") }, { value: "customer_name", label: __("Customer") }, { value: "trip_title", label: __("Trip") }, { value: "total_amount", label: __("Amount") }, { value: "booking_status", label: __("Status") }, ]; const columnOptions = [ { key: "booking_number", label: __("Booking #"), visible: visibleColumns.booking_number, }, { key: "customer", label: __("Customer"), visible: visibleColumns.customer, }, { key: "trip", label: __("Trip"), visible: visibleColumns.trip }, { key: "travelers", label: __("Travelers"), visible: visibleColumns.travelers, }, { key: "booking_date", label: __("Booking Date"), visible: visibleColumns.booking_date, }, { key: "travel_date", label: __("Travel Date"), visible: visibleColumns.travel_date, }, { key: "amount", label: __("Amount"), visible: visibleColumns.amount }, { key: "payment_status", label: __("Payment"), visible: visibleColumns.payment_status, }, { key: "booking_status", label: __("Status"), visible: visibleColumns.booking_status, }, ]; const columns = [ { key: "booking_number", label: __("Booking #"), sortable: true, visible: visibleColumns.booking_number, width: "w-[140px]", render: (booking: Booking) => ( ), }, { key: "customer", label: __("Customer"), sortable: true, visible: visibleColumns.customer, render: (booking: Booking) => (
{booking.customer_name || __("Guest")} {booking.customer_email}
), }, { key: "trip", label: __("Trip"), sortable: true, visible: visibleColumns.trip, render: (booking: Booking) => { // Link to the tour's PUBLIC single page (opens in a new tab), not the // tour editor — a booking overview should never be a one-click path to // editing the underlying tour. Without a slug we can't build the public // URL, so the name is shown as plain text rather than falling back to // the editor. const slug = booking.trip_slug || ""; let tourUrl = ""; if (slug) { const { plainUrl, prettyUrl } = buildYatraSinglePublicUrls({ entity: "trip", slug, }); tourUrl = isWordPressPlainPermalink() ? plainUrl : prettyUrl; } return (
{tourUrl ? ( {booking.trip_title} ) : ( {booking.trip_title} )} {booking.trip_id ? `(ID: ${booking.trip_id})` : ""}
); }, }, { key: "travelers", label: __("Travelers"), sortable: true, visible: visibleColumns.travelers, render: (booking: Booking) => ( {booking.travelers ?? booking.travelers_count ?? 0} ), }, { key: "booking_date", label: __("Booking Date"), sortable: true, visible: visibleColumns.booking_date, render: (booking: Booking) => ( {formatDate(booking.booking_date)} ), }, { key: "travel_date", label: __("Travel Date"), sortable: true, visible: visibleColumns.travel_date, render: (booking: Booking) => ( {formatDate(booking.travel_date)} ), }, { key: "amount", label: __("Amount"), sortable: true, visible: visibleColumns.amount, render: (booking: Booking) => (
{formatPrice(booking.total_amount, booking.currency)} {booking.amount_paid ? ( {__("Paid: ")} {formatPrice(booking.amount_paid, booking.currency)} ) : null}
), }, { key: "payment_status", label: __("Payment"), sortable: true, visible: visibleColumns.payment_status, render: (booking: Booking) => getPaymentStatusBadge(booking.payment_status), }, { key: "booking_status", label: __("Status"), sortable: true, visible: visibleColumns.booking_status, render: (booking: Booking) => getBookingStatusBadge(booking.booking_status), }, ]; /** * Manually (re)send a transactional email for a booking from the row actions. * Errors and disabled-recipient cases surface via the endpoint's message. */ const resendBookingEmail = async (bookingId: number, type: string) => { try { const res: any = await apiClient.post( `/bookings/${bookingId}/send-email`, { type }, ); if (res?.success === false) { throw new Error(res.message || __("Failed to send email")); } showToast(res?.message || __("Email sent"), "success"); } catch (error: any) { showToast(error?.message || __("Failed to send email"), "error"); } }; const actions = [ { key: "view", label: __("View"), icon: , onClick: (booking: Booking) => handleView(booking), condition: () => can("yatra_view_bookings"), }, { key: "edit", label: __("Edit"), icon: , onClick: (booking: Booking) => handleEdit(booking), condition: () => can("yatra_edit_bookings"), }, { key: "mark_confirmed", label: __("Mark as Confirmed"), icon: , onClick: async (booking: Booking) => { setIsBulkPending(true); try { await updateStatusForIds([booking.id], "confirmed"); queryClient.invalidateQueries({ queryKey: ["bookings"] }); queryClient.invalidateQueries({ queryKey: ["bookings-stats"] }); showToast(__("Booking status updated"), "success"); } catch (error: any) { showToast( error?.message || __("Failed to update booking status"), "error", ); } finally { setIsBulkPending(false); } }, condition: (booking: Booking) => can("yatra_edit_bookings") && booking.booking_status !== "confirmed", }, { key: "mark_pending", label: __("Mark as Pending"), icon: , onClick: async (booking: Booking) => { setIsBulkPending(true); try { await updateStatusForIds([booking.id], "pending"); queryClient.invalidateQueries({ queryKey: ["bookings"] }); queryClient.invalidateQueries({ queryKey: ["bookings-stats"] }); showToast(__("Booking status updated"), "success"); } catch (error: any) { showToast( error?.message || __("Failed to update booking status"), "error", ); } finally { setIsBulkPending(false); } }, condition: (booking: Booking) => can("yatra_edit_bookings") && booking.booking_status !== "pending", }, { key: "mark_cancelled", label: __("Mark as Cancelled"), icon: , onClick: async (booking: Booking) => { setIsBulkPending(true); try { await updateStatusForIds([booking.id], "cancelled"); queryClient.invalidateQueries({ queryKey: ["bookings"] }); queryClient.invalidateQueries({ queryKey: ["bookings-stats"] }); showToast(__("Booking status updated"), "success"); } catch (error: any) { showToast( error?.message || __("Failed to update booking status"), "error", ); } finally { setIsBulkPending(false); } }, condition: (booking: Booking) => can("yatra_edit_bookings") && booking.booking_status !== "cancelled", }, { key: "mark_completed", label: __("Mark as Completed"), icon: , onClick: async (booking: Booking) => { setIsBulkPending(true); try { await updateStatusForIds([booking.id], "completed"); queryClient.invalidateQueries({ queryKey: ["bookings"] }); queryClient.invalidateQueries({ queryKey: ["bookings-stats"] }); showToast(__("Booking status updated"), "success"); } catch (error: any) { showToast( error?.message || __("Failed to update booking status"), "error", ); } finally { setIsBulkPending(false); } }, condition: (booking: Booking) => can("yatra_edit_bookings") && booking.booking_status !== "completed", }, ...PAYMENT_STATUS_ACTIONS.map((action) => ({ key: `payment_${action.value}`, label: action.label(), icon: action.icon, onClick: (booking: Booking) => updatePaymentStatus(booking, action.value), // Hidden when the booking is already in that payment state, matching how // the booking-status actions above behave. condition: (booking: Booking) => can("yatra_edit_bookings") && booking.payment_status !== action.value, })), { key: "download_invoice", label: __("Download invoice"), icon: , onClick: async (booking: Booking) => { try { await downloadAdminBookingInvoice(booking.id); } catch (error: any) { showToast( error?.message || __("Failed to download invoice"), "error", ); } }, // Available for every booking, paid or not: an unpaid booking renders a // pro-forma invoice with the gateway's payment instructions. condition: () => can("yatra_view_bookings"), }, { key: "resend_confirmation", label: __("Resend confirmation email"), icon: , onClick: (booking: Booking) => resendBookingEmail(booking.id, "confirmation"), condition: (booking: Booking) => can("yatra_edit_bookings") && !!booking.customer_email, }, { key: "resend_payment", label: __("Resend payment email"), icon: , onClick: (booking: Booking) => resendBookingEmail(booking.id, "payment_confirmation"), // Only when a payment has actually been recorded. condition: (booking: Booking) => can("yatra_edit_bookings") && !!booking.customer_email && Number(booking.amount_paid || 0) > 0, }, { key: "resend_reminder", label: __("Resend trip reminder"), icon: , onClick: (booking: Booking) => resendBookingEmail(booking.id, "reminder"), // Only for a trip still to come: "your trip is coming up" makes no // sense to a cancelled guest or after the travel date. condition: (booking: Booking) => { if (!can("yatra_edit_bookings") || !booking.customer_email) { return false; } if ( ["cancelled", "refunded", "completed", "failed"].includes( (booking.booking_status || "").toLowerCase(), ) ) { return false; } const travel = (booking.travel_date || "").slice(0, 10); const now = new Date(); const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`; return travel === "" || travel >= today; }, }, { key: "delete", label: __("Delete"), icon: , onClick: (booking: Booking) => handleDelete(booking), variant: "destructive" as const, condition: () => can("yatra_delete_bookings"), }, ]; return (
} /> {/* Stats summary */} {statsData && (
{__("Total Bookings")}
{totalBookings}
{__("Confirmed")}
{confirmedCount}
{__("Pending")}
{pendingCount}
{__("Cancelled")}
{cancelledCount}
)}
{ setStatusFilter(value); setPage(1); }} statusOptions={statusOptions} sortBy={sortBy} onSortByChange={(field) => { setSortBy(field); setPage(1); }} sortOrder={sortOrder} onSortOrderChange={(order) => { setSortOrder(order); setPage(1); }} sortOptions={sortOptions} onResetFilters={handleResetFilters} hasFilters={!!hasFilters} placeholder={__("Search bookings...")} />
{/* Payment Status Filter */}
<> setSelectedIds([])} statusFilter={statusFilter} setStatusFilter={(value) => { setStatusFilter(value); setPage(1); }} statusOptions={[ { key: "all", label: __("All"), count: statsData?.all ?? totalBookings, }, { key: "confirmed", label: __("Confirmed"), count: confirmedCount, }, { key: "pending", label: __("Pending"), count: pendingCount }, { key: "cancelled", label: __("Cancelled"), count: cancelledCount, }, { key: "completed", label: __("Completed"), count: completedCount, }, ]} showColumnsDropdown={showColumnsDropdown} setShowColumnsDropdown={setShowColumnsDropdown} columnOptions={columnOptions} onToggleColumn={toggleColumn} bulkMutationPending={isBulkPending} totalItems={total} bulkActionOptions={bulkActionOptions} /> refetch()} emptyText={__("No bookings found")} emptyDescription={ hasFilters ? __("Try adjusting your filters to see more results.") : __("Get started by creating your first booking.") } onCreateClick={ can("yatra_edit_bookings") ? handleCreateBooking : undefined } onSort={handleSort} getSortIcon={getSortIcon} selectedItemIds={selectedIds} onSelectItem={handleSelectItem} onSelectAll={handleSelectAll} isAllSelected={isAllSelected} getItemId={(booking: Booking) => booking.id} skeletonRows={5} capability="yatra_view_bookings" /> {total > 0 && (
setPage(newPage)} itemName={__("bookings")} />
)}
{/* Delete Confirmation Dialog */} } /> ); }; export default Bookings;