freshyo/apps/admin-web/src/routes/dashboard.orders.sequence.tsx
2026-09-06 23:05:20 +05:30

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>
)
}