798 lines
27 KiB
TypeScript
798 lines
27 KiB
TypeScript
import React, { useState, useEffect, useMemo } from 'react'
|
|
import { createFileRoute, useNavigate } from '@tanstack/react-router'
|
|
import {
|
|
DndContext,
|
|
closestCenter,
|
|
PointerSensor,
|
|
useSensor,
|
|
useSensors
|
|
} from '@dnd-kit/core'
|
|
import type { DragEndEvent } from '@dnd-kit/core'
|
|
import {
|
|
SortableContext,
|
|
useSortable,
|
|
verticalListSortingStrategy,
|
|
arrayMove
|
|
} from '@dnd-kit/sortable'
|
|
import { CSS } from '@dnd-kit/utilities'
|
|
import {
|
|
p as MyText,
|
|
BottomDialog,
|
|
Checkbox,
|
|
Dropdown
|
|
} from 'web-components'
|
|
import dayjs from 'dayjs'
|
|
import { trpc } from '@/lib/trpc-client'
|
|
import { ErrorToast } from '@/services/toaster'
|
|
import { useManualRefresh, useMarkDataFetchers } from '@/lib/refresh-context'
|
|
import {
|
|
MapPin,
|
|
Map as MapIcon,
|
|
EllipsisVertical,
|
|
GripVertical,
|
|
Save,
|
|
ChevronLeft,
|
|
CalendarX,
|
|
ClipboardList
|
|
} from 'lucide-react'
|
|
import { OrderOptionsMenu } from '../components/OrderOptionsMenu'
|
|
import CancelOrderDialog from '../components/CancelOrderDialog'
|
|
import { OrderNotesForm } from '../components/OrderNotesForm'
|
|
import { SearchableSelect } from '@/components/SearchableSelect'
|
|
|
|
export const Route = createFileRoute('/dashboard/orders/sequence')({
|
|
validateSearch: (s: Record<string, unknown>) => ({
|
|
slotId: (s.slotId as string) ?? ''
|
|
}),
|
|
component: DeliverySequences,
|
|
})
|
|
|
|
// Define types outside
|
|
interface OrderWithSequence {
|
|
sequenceId: number,
|
|
readableId: number,
|
|
isPackaged: boolean,
|
|
totalAmount: number,
|
|
address: string,
|
|
latitude: number | null,
|
|
longitude: number | null,
|
|
id: number,
|
|
isDelivered: boolean,
|
|
addressId: number,
|
|
adminNotes?: string | null,
|
|
customerName?: string | null,
|
|
assignedUserName?: string | null
|
|
}
|
|
|
|
interface SlotProgressProps {
|
|
slotId: number,
|
|
orders: any[]
|
|
}
|
|
|
|
const SlotProgress: React.FC<SlotProgressProps> = ({ slotId, orders }) => {
|
|
const delivered = orders.filter((o) => o.isDelivered).length
|
|
const undelivered = orders.filter((o) => !o.isDelivered).length
|
|
const packaged = orders.filter((o) => o.isPackaged).length
|
|
const notPackaged = orders.filter((o) => !o.isPackaged).length
|
|
|
|
const stats = [
|
|
{ label: 'Delivered', value: delivered },
|
|
{ label: 'Undelivered', value: undelivered },
|
|
{ label: 'Packaged', value: packaged },
|
|
{ label: 'Not Packaged', value: notPackaged },
|
|
]
|
|
|
|
return (
|
|
<div className="mb-2 border-b border-gray-200 bg-white px-4 py-3">
|
|
<MyText className="mb-3 text-sm text-gray-700">
|
|
Slot {slotId} Statistics
|
|
</MyText>
|
|
<div className="flex flex-row flex-wrap">
|
|
{stats.map((stat, index) => (
|
|
<div key={index} className="w-1/2 p-2">
|
|
<div className="rounded-lg border border-gray-200 bg-gray-50 p-3">
|
|
<MyText className="text-lg font-bold text-gray-900">
|
|
{stat.value}
|
|
</MyText>
|
|
<MyText className="text-xs text-gray-500">{stat.label}</MyText>
|
|
</div>
|
|
</div>
|
|
))}
|
|
</div>
|
|
</div>
|
|
)
|
|
}
|
|
|
|
interface OrderItemProps {
|
|
item: OrderWithSequence,
|
|
isPending: boolean,
|
|
setSelectedOrder: (order: OrderWithSequence | null) => void,
|
|
setShowOrderMenu: (show: boolean) => void,
|
|
selectedOrderIds: number[],
|
|
onToggleOrder: (id: number) => void,
|
|
assignedUserName?: string | null,
|
|
staffData?: { staff?: Array<{ id: number, name: string }> },
|
|
setSelectedUserId?: (id: number) => void
|
|
}
|
|
|
|
const OrderItem: React.FC<OrderItemProps> = ({
|
|
item,
|
|
isPending,
|
|
setSelectedOrder,
|
|
setShowOrderMenu,
|
|
selectedOrderIds,
|
|
onToggleOrder,
|
|
assignedUserName,
|
|
staffData,
|
|
setSelectedUserId,
|
|
}) => {
|
|
const orderItem = item
|
|
const {
|
|
attributes,
|
|
listeners,
|
|
setNodeRef,
|
|
transform,
|
|
transition,
|
|
isDragging
|
|
} = useSortable({ id: orderItem.sequenceId, disabled: isPending })
|
|
|
|
return (
|
|
<div
|
|
ref={setNodeRef}
|
|
style={{
|
|
transform: CSS.Translate.toString(transform),
|
|
transition,
|
|
opacity: isDragging ? 0.8 : 1,
|
|
zIndex: isDragging ? 50 : undefined,
|
|
touchAction: 'none'
|
|
}}
|
|
{...attributes}
|
|
{...listeners}
|
|
className="mx-4 my-2"
|
|
>
|
|
<div
|
|
className={`rounded-xl border bg-white p-4 ${isDragging ? 'border-blue-500 shadow-xl' : 'border-gray-100 shadow-sm'}`}
|
|
>
|
|
<div className="flex flex-row items-center">
|
|
{/* Checkbox and Drag Handle */}
|
|
<div className="mr-4 flex-col items-center">
|
|
<Checkbox
|
|
checked={selectedOrderIds.includes(orderItem.id)}
|
|
onPress={() => onToggleOrder(orderItem.id)}
|
|
size={20}
|
|
fillColor="#3b82f6"
|
|
checkColor="#FFFFFF"
|
|
/>
|
|
<div className="mt-1">
|
|
<GripVertical
|
|
size={24}
|
|
color={isDragging ? '#3b82f6' : '#9ca3af'}
|
|
/>
|
|
</div>
|
|
</div>
|
|
|
|
{/* Content */}
|
|
<div className="flex-1">
|
|
<div className="mb-2 flex flex-row items-start justify-between">
|
|
<div className="flex flex-row items-center gap-2">
|
|
<MyText className="text-lg font-bold text-gray-800">
|
|
#{orderItem.readableId}
|
|
</MyText>
|
|
<span className="flex flex-row items-center gap-1">
|
|
<MyText className="text-xs font-medium text-gray-600">
|
|
Pkg
|
|
</MyText>
|
|
<Checkbox
|
|
checked={orderItem.isPackaged}
|
|
onPress={() => {}}
|
|
size={16}
|
|
fillColor="#6B7280"
|
|
checkColor="#FFFFFF"
|
|
/>
|
|
</span>
|
|
</div>
|
|
<div className="flex flex-row items-center">
|
|
<span className="mr-2 rounded-lg border border-green-100 bg-green-50 px-2 py-1">
|
|
<MyText className="text-sm font-bold text-green-700">
|
|
₹{orderItem.totalAmount}
|
|
</MyText>
|
|
</span>
|
|
<button
|
|
onClick={() => {
|
|
setSelectedOrder(orderItem)
|
|
setShowOrderMenu(true)
|
|
}}
|
|
className="p-2"
|
|
aria-label="Order options"
|
|
>
|
|
<EllipsisVertical size={20} color="#6b7280" />
|
|
</button>
|
|
</div>
|
|
</div>
|
|
|
|
<div className="flex flex-row items-start">
|
|
<MapPin size={14} color="#6b7280" className="mr-1 mt-0.5" />
|
|
<MyText className="flex-1 text-xs text-gray-500" numberOfLines={2}>
|
|
{orderItem.address}
|
|
</MyText>
|
|
{orderItem.latitude && orderItem.longitude && (
|
|
<button
|
|
onClick={() => {
|
|
window.open(
|
|
`https://www.google.com/maps?q=${orderItem.latitude},${orderItem.longitude}`,
|
|
'_blank'
|
|
)
|
|
}}
|
|
className="ml-2"
|
|
aria-label="Open in maps"
|
|
>
|
|
<MapIcon size={16} color="#3b82f6" />
|
|
</button>
|
|
)}
|
|
</div>
|
|
{assignedUserName && (
|
|
<div className="mt-2 flex flex-row items-center">
|
|
<MyText className="text-xs text-gray-500">
|
|
Assigned to{' '}
|
|
</MyText>
|
|
<button
|
|
onClick={() => {
|
|
const assignedUserId = staffData?.staff?.find(
|
|
(s: { id: number, name: string }) => s.name === assignedUserName
|
|
)?.id
|
|
if (assignedUserId && setSelectedUserId) {
|
|
setSelectedUserId(assignedUserId)
|
|
}
|
|
}}
|
|
className="underline"
|
|
>
|
|
<MyText className="text-xs text-blue-600 underline">
|
|
{assignedUserName}
|
|
</MyText>
|
|
</button>
|
|
</div>
|
|
)}
|
|
</div>
|
|
</div>
|
|
{/* Admin Notes */}
|
|
{orderItem.adminNotes && (
|
|
<div className="mt-2 rounded-lg border border-yellow-100 bg-yellow-50 p-2">
|
|
<MyText className="text-xs leading-4 text-yellow-900">
|
|
{orderItem.adminNotes}
|
|
</MyText>
|
|
</div>
|
|
)}
|
|
</div>
|
|
</div>
|
|
)
|
|
}
|
|
|
|
function DeliverySequences() {
|
|
const { slotId } = Route.useSearch()
|
|
const selectedSlotId = slotId ? Number(slotId) : null
|
|
const [localOrderedOrders, setLocalOrderedOrders] = useState<
|
|
OrderWithSequence[]
|
|
>([])
|
|
const [showOrderMenu, setShowOrderMenu] = useState(false)
|
|
const [selectedOrder, setSelectedOrder] = useState<OrderWithSequence | null>(
|
|
null
|
|
)
|
|
const [selectedUserId, setSelectedUserId] = useState<number>(-1)
|
|
const [selectedOrderIds, setSelectedOrderIds] = useState<number[]>([])
|
|
const [hasSequenceChanged, setHasSequenceChanged] = useState(false)
|
|
const [cancelDialogOpen, setCancelDialogOpen] = useState(false)
|
|
const [notesDialogOpen, setNotesDialogOpen] = useState(false)
|
|
const navigate = useNavigate()
|
|
|
|
const sensors = useSensors(
|
|
useSensor(PointerSensor, { activationConstraint: { delay: 200, tolerance: 8 } })
|
|
)
|
|
|
|
const { data: slotsData, refetch: refetchSlots } =
|
|
trpc.admin.slots.getAll.useQuery()
|
|
const {
|
|
data: ordersData,
|
|
isLoading: ordersLoading,
|
|
refetch: refetchOrders,
|
|
} = trpc.admin.order.getSlotOrders.useQuery(
|
|
{ slotId: String(selectedSlotId) },
|
|
{
|
|
enabled: !!selectedSlotId,
|
|
}
|
|
)
|
|
const { data: sequenceData, refetch: refetchSequence } =
|
|
trpc.admin.slots.getDeliverySequence.useQuery(
|
|
{ id: String(selectedSlotId) },
|
|
{
|
|
enabled: !!selectedSlotId,
|
|
}
|
|
)
|
|
|
|
const { data: staffData } = trpc.admin.staffUser.getStaff.useQuery()
|
|
|
|
// Auto-select first slot if no slotId provided
|
|
useEffect(() => {
|
|
if (!slotId && slotsData?.slots && slotsData.slots.length > 0) {
|
|
navigate({ to: '/dashboard/orders/sequence', search: { slotId: String(slotsData.slots[0].id) }, replace: true })
|
|
}
|
|
}, [slotId, slotsData, navigate])
|
|
|
|
const updateSequenceMutation =
|
|
trpc.admin.slots.updateDeliverySequence.useMutation()
|
|
const updatePackagedMutation = trpc.admin.order.updatePackaged.useMutation()
|
|
const updateDeliveredMutation =
|
|
trpc.admin.order.updateDelivered.useMutation()
|
|
|
|
// Manual refresh functionality
|
|
useManualRefresh(() => {
|
|
refetchSlots()
|
|
refetchOrders()
|
|
refetchSequence()
|
|
})
|
|
|
|
useMarkDataFetchers(() => {
|
|
refetchSlots()
|
|
refetchOrders()
|
|
refetchSequence()
|
|
})
|
|
|
|
const slots = slotsData?.slots || []
|
|
const orders = ordersData?.data || []
|
|
const deliverySequence = sequenceData?.deliverySequence || []
|
|
|
|
const slotOptions =
|
|
slots?.map((slot) => ({
|
|
label: dayjs(slot.deliveryTime).format('ddd DD MMM, h:mm a'),
|
|
value: slot.id,
|
|
})) || []
|
|
|
|
const userOptions = [
|
|
{ label: 'Unassigned', value: -1 },
|
|
{ label: 'All Users', value: -2 },
|
|
...(staffData?.staff?.map((staff) => ({
|
|
label: staff.name,
|
|
value: staff.id,
|
|
})) || []),
|
|
]
|
|
|
|
// Create ordered orders based on delivery sequence
|
|
const computedOrderedOrders = useMemo(() => {
|
|
if (orders.length > 0) {
|
|
const userSequence =
|
|
selectedUserId !== -1
|
|
? (deliverySequence as any)?.[String(selectedUserId)] || []
|
|
: null
|
|
if (selectedUserId !== -1 && userSequence && userSequence.length > 0) {
|
|
// Sort orders according to user's sequence
|
|
const sequenceMap = new Map(
|
|
userSequence.map((id: number, index: number) => [id, index])
|
|
)
|
|
const ordered = orders
|
|
.filter((order) => userSequence.includes(order.id))
|
|
.map((order) => ({ ...order, sequenceId: order.id }))
|
|
.sort((a, b) => {
|
|
const aIndex = sequenceMap.get(a.sequenceId) ?? Infinity
|
|
const bIndex = sequenceMap.get(b.sequenceId) ?? Infinity
|
|
return aIndex < bIndex ? -1 : aIndex > bIndex ? 1 : 0
|
|
})
|
|
return ordered
|
|
} else if (selectedUserId === -1) {
|
|
// Show unassigned orders (not in any user's sequence)
|
|
const assignedIds = new Set(
|
|
Object.values(deliverySequence as any).flat()
|
|
)
|
|
const ordered = orders
|
|
.filter((order) => !assignedIds.has(order.id))
|
|
.map((order) => ({ ...order, sequenceId: order.id }))
|
|
.sort((a, b) =>
|
|
a.sequenceId < b.sequenceId
|
|
? -1
|
|
: a.sequenceId > b.sequenceId
|
|
? 1
|
|
: 0
|
|
)
|
|
return ordered
|
|
} else if (selectedUserId === -2) {
|
|
// Show all orders with assignment info
|
|
const orderToUserMap = new Map<number, number>()
|
|
Object.entries(deliverySequence as any).forEach(([userId, orderIds]) => {
|
|
(orderIds as number[]).forEach((orderId) => {
|
|
orderToUserMap.set(orderId, parseInt(userId))
|
|
})
|
|
})
|
|
const ordered = orders
|
|
.map((order) => {
|
|
const assignedUserId = orderToUserMap.get(order.id)
|
|
const assignedUser = staffData?.staff?.find(
|
|
(s) => s.id === assignedUserId
|
|
)
|
|
return {
|
|
...order,
|
|
sequenceId: order.id,
|
|
assignedUserName: assignedUser?.name || null,
|
|
}
|
|
})
|
|
.sort((a, b) =>
|
|
a.sequenceId < b.sequenceId
|
|
? -1
|
|
: a.sequenceId > b.sequenceId
|
|
? 1
|
|
: 0
|
|
)
|
|
return ordered
|
|
} else {
|
|
// No sequence for user, show empty
|
|
return []
|
|
}
|
|
} else {
|
|
return []
|
|
}
|
|
}, [ordersData, sequenceData, selectedUserId])
|
|
|
|
// Sync local state with computed orders
|
|
useEffect(() => {
|
|
setLocalOrderedOrders(computedOrderedOrders as OrderWithSequence[])
|
|
}, [computedOrderedOrders])
|
|
|
|
const handleDragEnd = ({ data }: { data: OrderWithSequence[] }) => {
|
|
if (selectedUserId !== -1 && selectedUserId !== -2) {
|
|
setLocalOrderedOrders(data)
|
|
setHasSequenceChanged(true)
|
|
}
|
|
}
|
|
|
|
const handleDndDragEnd = (event: DragEndEvent) => {
|
|
const { active, over } = event
|
|
if (!over || active.id === over.id) return
|
|
const oldIndex = localOrderedOrders.findIndex((o) => o.sequenceId === active.id)
|
|
const newIndex = localOrderedOrders.findIndex((o) => o.sequenceId === over.id)
|
|
if (oldIndex === -1 || newIndex === -1) return
|
|
handleDragEnd({ data: arrayMove(localOrderedOrders, oldIndex, newIndex) })
|
|
}
|
|
|
|
const handleSaveSequence = () => {
|
|
if (!selectedSlotId || selectedUserId === -1) return
|
|
|
|
const newSequence = { ...(deliverySequence as any) }
|
|
newSequence[String(selectedUserId)] = localOrderedOrders.map(
|
|
(order) => order.sequenceId
|
|
)
|
|
|
|
updateSequenceMutation.mutate(
|
|
{
|
|
id: selectedSlotId,
|
|
deliverySequence: newSequence,
|
|
},
|
|
{
|
|
onSuccess: () => {
|
|
setHasSequenceChanged(false)
|
|
window.alert('Success: Delivery sequence updated successfully')
|
|
},
|
|
onError: (error: any) => {
|
|
ErrorToast(
|
|
`Failed to update delivery sequence: ${
|
|
error.message || 'Unknown error'
|
|
}`
|
|
)
|
|
},
|
|
}
|
|
)
|
|
}
|
|
|
|
if (!slotsData) {
|
|
return (
|
|
<div className="flex flex-1 flex-col items-center justify-center bg-gray-50 pt-6">
|
|
<div className="h-8 w-8 animate-spin rounded-full border-2 border-gray-300 border-t-blue-500" />
|
|
<MyText className="mt-4 text-gray-500">Loading slots...</MyText>
|
|
</div>
|
|
)
|
|
}
|
|
|
|
if (slotsData.slots.length === 0) {
|
|
return (
|
|
<div className="flex flex-1 flex-col items-center justify-center p-8 pt-6">
|
|
<CalendarX size={64} color="#e5e7eb" />
|
|
<MyText className="mt-4 text-center text-lg text-gray-500">
|
|
No slots available
|
|
</MyText>
|
|
</div>
|
|
)
|
|
}
|
|
|
|
return (
|
|
<div className="flex min-h-full flex-1 flex-col bg-gray-50 pt-6">
|
|
{selectedSlotId ? (
|
|
<>
|
|
{/* Header Section */}
|
|
<div className="z-10 flex flex-row items-center border-b border-gray-200 bg-white px-4 py-4 shadow-sm">
|
|
<button
|
|
onClick={() => window.history.back()}
|
|
className="p-2"
|
|
aria-label="Go back"
|
|
>
|
|
<ChevronLeft size={24} color="#374151" />
|
|
</button>
|
|
|
|
<div className="mx-2 flex-[2]">
|
|
<Dropdown
|
|
label="Select Slot"
|
|
options={slotOptions}
|
|
value={selectedSlotId || ''}
|
|
onValueChange={(val) => {
|
|
if (val !== '' && val !== null && val !== undefined) {
|
|
navigate({ to: '/dashboard/orders/sequence', search: { slotId: String(Number(val)) }, replace: true })
|
|
}
|
|
}}
|
|
/>
|
|
</div>
|
|
<div className="mx-2 flex-1">
|
|
<Dropdown
|
|
label="Select User"
|
|
options={userOptions}
|
|
value={selectedUserId}
|
|
onValueChange={(val) => setSelectedUserId(Number(val))}
|
|
/>
|
|
</div>
|
|
</div>
|
|
|
|
{/* Content Section */}
|
|
{ordersLoading ? (
|
|
<div className="flex flex-1 flex-col items-center justify-center">
|
|
<div className="h-8 w-8 animate-spin rounded-full border-2 border-gray-300 border-t-blue-500" />
|
|
<MyText className="mt-4 text-gray-500">Loading orders...</MyText>
|
|
</div>
|
|
) : localOrderedOrders.length === 0 ? (
|
|
<div className="flex flex-1 flex-col items-center justify-center p-8">
|
|
<ClipboardList size={64} color="#e5e7eb" />
|
|
<MyText className="mt-4 text-center text-lg text-gray-500">
|
|
No orders found for this slot
|
|
</MyText>
|
|
</div>
|
|
) : (
|
|
<div className="flex flex-1 flex-col pb-8">
|
|
<SlotProgress slotId={selectedSlotId!} orders={orders} />
|
|
<DndContext
|
|
sensors={sensors}
|
|
collisionDetection={closestCenter}
|
|
onDragEnd={handleDndDragEnd}
|
|
>
|
|
<SortableContext
|
|
items={localOrderedOrders.map((o) => o.sequenceId)}
|
|
strategy={verticalListSortingStrategy}
|
|
>
|
|
{localOrderedOrders.map((item) => (
|
|
<OrderItem
|
|
key={item.sequenceId}
|
|
item={item}
|
|
isPending={updateSequenceMutation.isPending}
|
|
setSelectedOrder={setSelectedOrder}
|
|
setShowOrderMenu={setShowOrderMenu}
|
|
selectedOrderIds={selectedOrderIds}
|
|
onToggleOrder={(id) => {
|
|
setSelectedOrderIds((prev) =>
|
|
prev.includes(id)
|
|
? prev.filter((i) => i !== id)
|
|
: [...prev, id]
|
|
)
|
|
}}
|
|
assignedUserName={selectedUserId === -2 ? item.assignedUserName : undefined}
|
|
staffData={staffData}
|
|
setSelectedUserId={setSelectedUserId}
|
|
/>
|
|
))}
|
|
</SortableContext>
|
|
</DndContext>
|
|
</div>
|
|
)}
|
|
|
|
{/* Assignment panel (replaces FAB-triggered dropdown; SearchableSelect renders its own trigger) */}
|
|
{selectedOrderIds.length > 0 && (
|
|
<div className="absolute bottom-4 right-4 w-56 rounded-xl bg-white p-3 shadow-lg">
|
|
<SearchableSelect
|
|
label="Assign To"
|
|
options={[
|
|
...userOptions.filter((opt) => opt.value !== -1),
|
|
{ label: 'None', value: -3 },
|
|
]}
|
|
value={-1}
|
|
onValueChange={(val) => {
|
|
const numVal = Number(val)
|
|
if (numVal !== -1) {
|
|
if (numVal === -3) {
|
|
// Unassign selected orders
|
|
const newSequence = { ...(deliverySequence as any) }
|
|
Object.keys(newSequence).forEach((userId) => {
|
|
newSequence[userId] = newSequence[userId].filter(
|
|
(id: number) => !selectedOrderIds.includes(id)
|
|
)
|
|
})
|
|
// Save
|
|
updateSequenceMutation.mutate(
|
|
{
|
|
id: selectedSlotId,
|
|
deliverySequence: newSequence,
|
|
},
|
|
{
|
|
onSuccess: () => {
|
|
setSelectedOrderIds([])
|
|
refetchSequence()
|
|
window.alert(
|
|
'Success: Orders unassigned successfully'
|
|
)
|
|
},
|
|
onError: (error: any) => {
|
|
ErrorToast(
|
|
`Failed to unassign orders: ${
|
|
error.message || 'Unknown error'
|
|
}`
|
|
)
|
|
},
|
|
}
|
|
)
|
|
} else {
|
|
// Assign selected orders to the user
|
|
// Update deliverySequence map
|
|
const newSequence = { ...(deliverySequence as any) }
|
|
// Remove from all other users
|
|
Object.keys(newSequence).forEach((userId) => {
|
|
newSequence[userId] = newSequence[userId].filter(
|
|
(id: number) => !selectedOrderIds.includes(id)
|
|
)
|
|
})
|
|
// Add to selected user
|
|
if (!newSequence[String(numVal)])
|
|
newSequence[String(numVal)] = []
|
|
newSequence[String(numVal)] = [
|
|
...new Set([
|
|
...newSequence[String(numVal)],
|
|
...selectedOrderIds,
|
|
]),
|
|
]
|
|
// Save
|
|
updateSequenceMutation.mutate(
|
|
{
|
|
id: selectedSlotId,
|
|
deliverySequence: newSequence,
|
|
},
|
|
{
|
|
onSuccess: () => {
|
|
setSelectedOrderIds([])
|
|
refetchSequence()
|
|
window.alert(
|
|
'Success: Orders assigned successfully'
|
|
)
|
|
},
|
|
onError: (error: any) => {
|
|
ErrorToast(
|
|
`Failed to assign orders: ${
|
|
error.message || 'Unknown error'
|
|
}`
|
|
)
|
|
},
|
|
}
|
|
)
|
|
}
|
|
}
|
|
}}
|
|
/>
|
|
</div>
|
|
)}
|
|
|
|
{/* FAB for Save */}
|
|
{hasSequenceChanged && (
|
|
<div className="fixed bottom-4 left-4">
|
|
<button
|
|
onClick={handleSaveSequence}
|
|
className="rounded-full bg-blue-600 p-4 shadow-lg disabled:opacity-50"
|
|
disabled={updateSequenceMutation.isPending}
|
|
aria-label="Save sequence"
|
|
>
|
|
<Save size={24} color="white" />
|
|
</button>
|
|
</div>
|
|
)}
|
|
</>
|
|
) : (
|
|
<div className="flex flex-1 flex-col items-center justify-center p-8">
|
|
<CalendarX size={64} color="#e5e7eb" />
|
|
<MyText className="mt-4 text-center text-lg text-gray-500">
|
|
No slot selected. Please select a slot to view delivery sequence.
|
|
</MyText>
|
|
<button
|
|
className="mt-6 rounded-full bg-blue-600 px-6 py-3"
|
|
onClick={() => window.history.back()}
|
|
>
|
|
<MyText className="font-bold text-white">Go Back</MyText>
|
|
</button>
|
|
</div>
|
|
)}
|
|
|
|
{/* Order Menu Dialog */}
|
|
<OrderOptionsMenu
|
|
open={showOrderMenu}
|
|
onClose={() => setShowOrderMenu(false)}
|
|
order={{
|
|
id: selectedOrder?.id || 0,
|
|
readableId: selectedOrder?.readableId || 0,
|
|
isPackaged: selectedOrder?.isPackaged || false,
|
|
isDelivered: selectedOrder?.isDelivered || false,
|
|
address: selectedOrder?.address || '',
|
|
addressId: selectedOrder?.addressId || 0,
|
|
adminNotes: selectedOrder?.adminNotes || null,
|
|
latitude: selectedOrder?.latitude || null,
|
|
longitude: selectedOrder?.longitude || null,
|
|
}}
|
|
onViewDetails={() => {
|
|
if (selectedOrder) {
|
|
navigate({ to: '/dashboard/orders/$id', params: { id: String(selectedOrder.id) } })
|
|
}
|
|
setShowOrderMenu(false)
|
|
}}
|
|
onTogglePackaged={() => {
|
|
if (!selectedOrder) return
|
|
updatePackagedMutation.mutate(
|
|
{ orderId: selectedOrder.id.toString(), isPackaged: !selectedOrder.isPackaged },
|
|
{
|
|
onSuccess: () => {
|
|
refetchOrders()
|
|
refetchSequence()
|
|
},
|
|
onError: () => {
|
|
ErrorToast('Failed to update packaged status')
|
|
},
|
|
}
|
|
)
|
|
}}
|
|
onToggleDelivered={() => {
|
|
if (!selectedOrder) return
|
|
updateDeliveredMutation.mutate(
|
|
{ orderId: selectedOrder.id.toString(), isDelivered: !selectedOrder.isDelivered },
|
|
{
|
|
onSuccess: () => {
|
|
refetchOrders()
|
|
refetchSequence()
|
|
},
|
|
onError: () => {
|
|
ErrorToast('Failed to update delivered status')
|
|
},
|
|
}
|
|
)
|
|
}}
|
|
onOpenAdminNotes={() => {
|
|
setShowOrderMenu(false)
|
|
setNotesDialogOpen(true)
|
|
}}
|
|
onCancelOrder={() => {
|
|
setShowOrderMenu(false)
|
|
setCancelDialogOpen(true)
|
|
}}
|
|
onAttachLocation={() => {}}
|
|
onWhatsApp={() => {}}
|
|
onDial={() => {}}
|
|
/>
|
|
|
|
<CancelOrderDialog
|
|
orderId={selectedOrder?.id || 0}
|
|
open={cancelDialogOpen}
|
|
onClose={() => setCancelDialogOpen(false)}
|
|
onSuccess={() => {
|
|
refetchOrders()
|
|
refetchSequence()
|
|
}}
|
|
/>
|
|
|
|
<BottomDialog open={notesDialogOpen} onClose={() => setNotesDialogOpen(false)}>
|
|
<OrderNotesForm
|
|
orderId={selectedOrder?.id || 0}
|
|
initialNotes={selectedOrder?.adminNotes || ''}
|
|
onSuccess={() => {
|
|
refetchOrders()
|
|
refetchSequence()
|
|
setNotesDialogOpen(false)
|
|
}}
|
|
onCancel={() => setNotesDialogOpen(false)}
|
|
/>
|
|
</BottomDialog>
|
|
</div>
|
|
)
|
|
}
|