HotelSync
948744e077
- Migration 050: add tariff_id FK to bookings table - Backend: accept tariff_id in POST/PATCH bookings - Frontend: load active tariffs in BookingModal, show tariff dropdown - Price calculation applies tariff modifier (percent or fixed) before discount - tariffId forwarded through CalendarPage → api.bookings.create/update Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
325 lines
14 KiB
TypeScript
325 lines
14 KiB
TypeScript
import { useState, useEffect, useCallback, useRef } from 'react'
|
|
import { BookingCalendar } from '../components/calendar/BookingCalendar'
|
|
import { useModules } from '../contexts/ModulesContext'
|
|
import { useAuth } from '../contexts/AuthContext'
|
|
import { api } from '../lib/api'
|
|
import type { RentalObjectApi, RentalBookingApi } from '../lib/api'
|
|
import { useHotelSocket } from '../hooks/useHotelSocket'
|
|
import type { WsMessage } from '../hooks/useHotelSocket'
|
|
import type { Room, Booking } from '../types'
|
|
import type { HkPriority } from '../components/rooms/RoomContextMenu'
|
|
import type { RentalBooking } from '../data/rentalData'
|
|
|
|
export type BookingLock = { checkIn: string; checkOut: string; lockedBy: string }
|
|
|
|
export function CalendarPage() {
|
|
const { user, session } = useAuth()
|
|
const slug = user?.hotelSlug ?? ''
|
|
const { statuses } = useModules()
|
|
const isRentalActive = statuses['rental'] === 'active' || statuses['rental'] === 'trial'
|
|
|
|
const [rooms, setRooms] = useState<Room[]>([])
|
|
const [bookings, setBookings] = useState<Booking[]>([])
|
|
const [fadingBookings, setFadingBookings] = useState<Set<string>>(new Set())
|
|
const [rentalObjects, setRentalObjects] = useState<RentalObjectApi[]>([])
|
|
const [rentalBookings, setRentalBookings] = useState<RentalBookingApi[]>([])
|
|
const [locks, setLocks] = useState<Map<string, BookingLock>>(new Map())
|
|
const [priceOverrides, setPriceOverrides] = useState<Record<string, Record<string, number>>>({})
|
|
const [hourlyPriceOverrides, setHourlyPriceOverrides] = useState<Record<string, Record<string, number>>>({})
|
|
const [categoryBasePrices, setCategoryBasePrices] = useState<Record<string, { nightlyBase: number; hourlyBase: number }>>({})
|
|
// roomId → assigneeName for "убирается" tooltip
|
|
const [cleaningAssignees, setCleaningAssignees] = useState<Record<string, string>>({})
|
|
// Set of room IDs with active maintenance tasks
|
|
const [activeMaintenance, setActiveMaintenance] = useState<Set<string>>(new Set())
|
|
|
|
useEffect(() => {
|
|
if (!slug) return
|
|
const fetches: Promise<unknown>[] = [
|
|
api.rooms.list(slug),
|
|
api.bookings.list(slug),
|
|
api.rateOverrides.list(slug).catch(() => []),
|
|
api.categories.list(slug).catch(() => []),
|
|
]
|
|
if (isRentalActive) {
|
|
fetches.push(api.rental.listObjects(slug))
|
|
fetches.push(api.rental.listBookings(slug))
|
|
}
|
|
Promise.all(fetches).then(([r, b, overridesRaw, catsRaw, ro, rb]) => {
|
|
setRooms(r as Room[])
|
|
setBookings(b as Booking[])
|
|
// Build categoryId → date → price lookup
|
|
const overrides = overridesRaw as import('../lib/api').RateOverrideApi[]
|
|
const map: Record<string, Record<string, number>> = {}
|
|
const hourlyMap: Record<string, Record<string, number>> = {}
|
|
for (const o of overrides) {
|
|
if (!map[o.categoryId]) map[o.categoryId] = {}
|
|
map[o.categoryId][o.date] = o.price
|
|
if (o.hourlyPrice != null && o.hourlyPrice > 0) {
|
|
if (!hourlyMap[o.categoryId]) hourlyMap[o.categoryId] = {}
|
|
hourlyMap[o.categoryId][o.date] = o.hourlyPrice
|
|
}
|
|
}
|
|
setPriceOverrides(map)
|
|
setHourlyPriceOverrides(hourlyMap)
|
|
// Build category base prices
|
|
const cats = catsRaw as import('../lib/api').CategoryApi[]
|
|
const catBases: Record<string, { nightlyBase: number; hourlyBase: number }> = {}
|
|
for (const cat of cats) {
|
|
catBases[cat.id] = { nightlyBase: cat.base_price ?? 0, hourlyBase: cat.hourly_base_price ?? 0 }
|
|
}
|
|
setCategoryBasePrices(catBases)
|
|
if (isRentalActive) {
|
|
setRentalObjects(ro as RentalObjectApi[])
|
|
setRentalBookings(rb as RentalBookingApi[])
|
|
}
|
|
}).catch(console.error)
|
|
|
|
// Fetch active maintenance tasks
|
|
api.housekeeping.list(slug, { status: 'active', category: 'maintenance' })
|
|
.then(tasks => {
|
|
const ids = new Set(tasks.map(t => {
|
|
const tAny = t as unknown as Record<string, string>
|
|
return tAny.roomId ?? tAny.room_id ?? ''
|
|
}).filter(Boolean))
|
|
setActiveMaintenance(ids)
|
|
})
|
|
.catch(() => {})
|
|
|
|
// Fetch active HK tasks to build "who is cleaning" tooltip map
|
|
api.housekeeping.list(slug, { status: 'active', category: 'housekeeping' })
|
|
.then(tasks => {
|
|
const assignees: Record<string, string> = {}
|
|
for (const t of tasks) {
|
|
const tAny = t as unknown as Record<string, string>
|
|
if (tAny.status === 'in_progress' && tAny.roomId && tAny.assigneeName) {
|
|
assignees[tAny.roomId] = tAny.assigneeName
|
|
}
|
|
}
|
|
setCleaningAssignees(assignees)
|
|
})
|
|
.catch(() => {})
|
|
}, [slug, isRentalActive])
|
|
|
|
const handleWsMessage = useCallback((msg: WsMessage) => {
|
|
if (msg.type === 'lock') {
|
|
setLocks(prev => new Map(prev).set(msg.roomId, { checkIn: msg.checkIn, checkOut: msg.checkOut, lockedBy: msg.lockedBy }))
|
|
} else if (msg.type === 'unlock') {
|
|
setLocks(prev => { const n = new Map(prev); n.delete(msg.roomId); return n })
|
|
} else if (msg.type === 'booking:created') {
|
|
setBookings(prev => prev.find(b => b.id === msg.booking.id) ? prev : [...prev, msg.booking])
|
|
setLocks(prev => { const n = new Map(prev); n.delete(msg.booking.roomId); return n })
|
|
} else if (msg.type === 'booking:updated') {
|
|
setBookings(prev => prev.map(b => b.id === msg.booking.id ? msg.booking : b))
|
|
} else if (msg.type === 'booking:deleted') {
|
|
setBookings(prev => prev.filter(b => b.id !== msg.bookingId))
|
|
} else if (msg.type === 'housekeeping_done') {
|
|
setRooms(prev => prev.map(r =>
|
|
r.id === msg.roomId ? { ...r, housekeepingStatus: msg.roomStatus as Room['housekeepingStatus'] } : r
|
|
))
|
|
// If room is no longer being cleaned, remove from tooltip map
|
|
if (msg.roomStatus !== 'cleaning') {
|
|
setCleaningAssignees(prev => { const n = { ...prev }; delete n[msg.roomId]; return n })
|
|
}
|
|
} else if (msg.type === 'housekeeping_task_created') {
|
|
const t = msg.task as Record<string, string>
|
|
const roomId = t.roomId ?? t.room_id
|
|
if (t.category === 'maintenance' && roomId) {
|
|
setActiveMaintenance(prev => new Set([...prev, roomId]))
|
|
}
|
|
} else if (msg.type === 'housekeeping_updated') {
|
|
const t = msg.task as Record<string, string>
|
|
const roomId = t.roomId ?? t.room_id
|
|
// Track maintenance tasks
|
|
if (t.category === 'maintenance' && roomId) {
|
|
if (t.status === 'done' || t.status === 'cancelled') {
|
|
setActiveMaintenance(prev => { const n = new Set(prev); n.delete(roomId); return n })
|
|
} else {
|
|
setActiveMaintenance(prev => new Set([...prev, roomId]))
|
|
}
|
|
}
|
|
if (t.roomId) {
|
|
if (t.status === 'in_progress' && t.assigneeName) {
|
|
setCleaningAssignees(prev => ({ ...prev, [t.roomId]: t.assigneeName }))
|
|
} else if (t.status !== 'in_progress') {
|
|
setCleaningAssignees(prev => { const n = { ...prev }; delete n[t.roomId]; return n })
|
|
}
|
|
}
|
|
}
|
|
}, [])
|
|
|
|
const { send, connected } = useHotelSocket({ slug, token: session?.token ?? null, onMessage: handleWsMessage })
|
|
|
|
// Clear stale locks on WS reconnect (may have missed unlock/booking:created while disconnected)
|
|
const prevConnected = useRef(false)
|
|
useEffect(() => {
|
|
if (connected && !prevConnected.current) {
|
|
setLocks(new Map())
|
|
}
|
|
prevConnected.current = connected
|
|
}, [connected])
|
|
|
|
const handleCreate = async (data: Partial<Booking>) => {
|
|
try {
|
|
const created = await api.bookings.create(slug, {
|
|
roomId: data.roomId, guestName: data.guestName, guestEmail: data.guestEmail, guestPhone: data.guestPhone,
|
|
checkIn: data.checkIn, checkOut: data.checkOut,
|
|
adults: data.adults, children: data.children,
|
|
status: data.status, source: data.source,
|
|
totalAmount: data.totalAmount, paidAmount: data.paidAmount, notes: data.notes,
|
|
tariffId: data.tariffId,
|
|
})
|
|
setBookings(prev => [...prev, created])
|
|
send({ type: 'booking:created', booking: created })
|
|
if (data.roomId) send({ type: 'unlock', roomId: data.roomId })
|
|
} catch (err) {
|
|
console.error('Failed to create booking:', err)
|
|
const msg = err instanceof Error ? err.message : 'Ошибка создания бронирования'
|
|
alert(msg)
|
|
}
|
|
}
|
|
|
|
const handleUpdate = async (id: string, data: Partial<Booking>) => {
|
|
try {
|
|
const updated = await api.bookings.update(slug, id, {
|
|
roomId: data.roomId,
|
|
guestName: data.guestName, guestEmail: data.guestEmail,
|
|
checkIn: data.checkIn, checkOut: data.checkOut,
|
|
adults: data.adults, children: data.children,
|
|
status: data.status, source: data.source,
|
|
totalAmount: data.totalAmount, notes: data.notes,
|
|
tariffId: data.tariffId,
|
|
})
|
|
setBookings(prev => prev.map(b => b.id === id ? updated : b))
|
|
send({ type: 'booking:updated', booking: updated })
|
|
if (data.status === 'cancelled') {
|
|
setFadingBookings(prev => new Set([...prev, id]))
|
|
setTimeout(() => {
|
|
setBookings(prev => prev.filter(b => b.id !== id))
|
|
setFadingBookings(prev => { const n = new Set(prev); n.delete(id); return n })
|
|
}, 900)
|
|
}
|
|
} catch (err) {
|
|
console.error('Failed to update booking:', err)
|
|
}
|
|
}
|
|
|
|
const handleBulkUpdate = async (updates: Array<{ id: string; data: Partial<Booking> }>) => {
|
|
try {
|
|
const results = await Promise.all(
|
|
updates.map(u => api.bookings.update(slug, u.id, {
|
|
status: u.data.status, checkIn: u.data.checkIn,
|
|
checkOut: u.data.checkOut, roomId: u.data.roomId,
|
|
})),
|
|
)
|
|
setBookings(prev => {
|
|
let next = [...prev]
|
|
results.forEach(r => { next = next.map(b => b.id === r.id ? r : b) })
|
|
return next
|
|
})
|
|
results.forEach(r => send({ type: 'booking:updated', booking: r }))
|
|
} catch (err) {
|
|
console.error('Failed to bulk update bookings:', err)
|
|
}
|
|
}
|
|
|
|
const handleDraftStart = useCallback((roomId: string, checkIn: string, checkOut: string) => {
|
|
send({ type: 'lock', roomId, checkIn, checkOut, lockedBy: user?.name ?? 'Менеджер' })
|
|
}, [send, user?.name])
|
|
|
|
const handleDraftCancel = useCallback((roomId: string) => {
|
|
send({ type: 'unlock', roomId })
|
|
}, [send])
|
|
|
|
const handleRoomUpdate = useCallback(async (roomId: string, patch: Partial<Room>, priority?: HkPriority) => {
|
|
try {
|
|
const updated = await api.rooms.update(slug, roomId, patch)
|
|
setRooms(prev => prev.map(r => r.id === updated.id ? updated : r))
|
|
if (patch.housekeepingStatus === 'dirty') {
|
|
const today = new Date().toISOString().slice(0, 10)
|
|
const task = await api.housekeeping.create(slug, {
|
|
room_id: roomId,
|
|
type: 'cleaning',
|
|
priority: priority ?? 'medium',
|
|
due_date: today,
|
|
category: 'housekeeping',
|
|
})
|
|
send({ type: 'housekeeping_task_created', task: task as unknown as Record<string, unknown> })
|
|
}
|
|
} catch (err) {
|
|
console.error('Failed to update room:', err)
|
|
}
|
|
}, [slug, send])
|
|
|
|
const handleMaintenanceTaskCreate = useCallback(async (roomId: string, description: string, priority: HkPriority, photos: string[] = []) => {
|
|
try {
|
|
const today = new Date().toISOString().slice(0, 10)
|
|
const task = await api.housekeeping.create(slug, {
|
|
room_id: roomId,
|
|
type: 'maintenance',
|
|
priority,
|
|
notes: description,
|
|
due_date: today,
|
|
category: 'maintenance',
|
|
photos,
|
|
})
|
|
send({ type: 'housekeeping_task_created', task: task as unknown as Record<string, unknown> })
|
|
} catch (err) {
|
|
console.error('Failed to create maintenance task:', err)
|
|
}
|
|
}, [slug, send])
|
|
|
|
const handleRentalBookingCreate = useCallback(async (b: RentalBooking) => {
|
|
try {
|
|
const created = await api.rental.createBooking(slug, {
|
|
object_id: b.objectId,
|
|
date: b.date,
|
|
is_full_day: b.isFullDay,
|
|
start_hour: b.startHour,
|
|
end_hour: b.endHour,
|
|
guest_name: b.guestName,
|
|
guest_phone: b.guestPhone ?? '',
|
|
linked_room_id: b.linkedRoomId,
|
|
total_amount: b.totalAmount,
|
|
paid_amount: b.paidAmount ?? 0,
|
|
status: b.status,
|
|
notes: b.notes,
|
|
})
|
|
setRentalBookings(prev => [...prev, created])
|
|
} catch (err) {
|
|
console.error('Failed to create rental booking:', err)
|
|
const msg = err instanceof Error ? err.message : 'Ошибка сохранения аренды'
|
|
alert(msg)
|
|
}
|
|
}, [slug])
|
|
|
|
return (
|
|
<div className="flex flex-col h-full">
|
|
<div className="flex-1 overflow-hidden">
|
|
<BookingCalendar
|
|
slug={slug}
|
|
rooms={rooms}
|
|
bookings={bookings}
|
|
onBookingCreate={handleCreate}
|
|
onBookingUpdate={handleUpdate}
|
|
onBookingBulkUpdate={handleBulkUpdate}
|
|
onRoomUpdate={handleRoomUpdate}
|
|
onMaintenanceTaskCreate={handleMaintenanceTaskCreate}
|
|
cleaningAssignees={cleaningAssignees}
|
|
activeMaintenance={activeMaintenance}
|
|
fadingBookingIds={fadingBookings}
|
|
rentalObjects={isRentalActive ? rentalObjects as unknown as import('../data/rentalData').RentalObject[] : undefined}
|
|
rentalBookings={isRentalActive ? rentalBookings as unknown as RentalBooking[] : undefined}
|
|
onRentalBookingCreate={isRentalActive ? handleRentalBookingCreate : undefined}
|
|
locks={locks}
|
|
onDraftStart={handleDraftStart}
|
|
onDraftCancel={handleDraftCancel}
|
|
wsConnected={connected}
|
|
priceOverrides={priceOverrides}
|
|
hourlyPriceOverrides={hourlyPriceOverrides}
|
|
categoryBasePrices={categoryBasePrices}
|
|
/>
|
|
</div>
|
|
</div>
|
|
)
|
|
}
|