add car reservation feature

2026-05-09 21:10:38 -04:00
parent 09b0e3b55f
commit 6322b7d2a1
37 changed files with 1169 additions and 119 deletions
@@ -3,6 +3,7 @@ import { z } from 'zod'
 import { prisma } from '../lib/prisma'
 import { optionalRenterAuth } from '../middleware/requireRenterAuth'
 import { sendNotification, sendTransactionalEmail } from '../services/notificationService'
+import { getVehicleAvailabilitySummary } from '../services/vehicleAvailabilityService'

 const router = Router()
 router.use(optionalRenterAuth)
@@ -96,22 +97,25 @@ router.get('/search', async (req, res, next) => {

    const typedVehicles = vehicles as Array<(typeof vehicles)[number]>

-    const unavailableVehicleIds = startDate && endDate
-      ? new Set((await prisma.reservation.findMany({
-          where: {
-            status: { in: ['CONFIRMED', 'ACTIVE'] },
-            vehicleId: { in: typedVehicles.map((vehicle) => vehicle.id) },
-            startDate: { lt: new Date(endDate) },
-            endDate: { gt: new Date(startDate) },
-          },
-          select: { vehicleId: true },
-        })).map((reservation: { vehicleId: string }) => reservation.vehicleId))
-      : null
+    const availabilityByVehicleId = new Map(
+      await Promise.all(
+        typedVehicles.map(async (vehicle) => {
+          const availability = await getVehicleAvailabilitySummary(vehicle.id, {
+            range: startDate && endDate
+              ? { startDate: new Date(startDate), endDate: new Date(endDate) }
+              : undefined,
+          })
+          return [vehicle.id, availability] as const
+        }),
+      ),
+    )

    res.json({
      data: typedVehicles.map((vehicle) => ({
        ...vehicle,
-        availability: unavailableVehicleIds ? !unavailableVehicleIds.has(vehicle.id) : null,
+        availability: availabilityByVehicleId.get(vehicle.id)?.available ?? null,
+        availabilityStatus: availabilityByVehicleId.get(vehicle.id)?.status ?? 'AVAILABLE',
+        nextAvailableAt: availabilityByVehicleId.get(vehicle.id)?.nextAvailableAt ?? null,
      })),
    })
  } catch (err) {
@@ -148,15 +152,17 @@ router.post('/reservations', async (req, res, next) => {
    })
    if (!vehicle) return res.status(404).json({ error: 'not_found', message: 'Vehicle not found', statusCode: 404 })

-    const conflict = await prisma.reservation.findFirst({
-      where: {
-        vehicleId: body.vehicleId,
-        status: { in: ['CONFIRMED', 'ACTIVE'] },
-        startDate: { lt: endDate },
-        endDate: { gt: startDate },
-      },
+    const availability = await getVehicleAvailabilitySummary(body.vehicleId, {
+      range: { startDate, endDate },
    })
-    if (conflict) return res.status(409).json({ error: 'unavailable', message: 'Vehicle is not available for the selected dates', statusCode: 409 })
+    if (!availability.available) {
+      return res.status(409).json({
+        error: 'unavailable',
+        message: 'Vehicle is not available for the selected dates',
+        statusCode: 409,
+        nextAvailableAt: availability.nextAvailableAt?.toISOString() ?? null,
+      })
+    }

    const customer = await prisma.customer.upsert({
      where: { companyId_email: { companyId: vehicle.companyId, email: body.email } },
@@ -248,7 +254,18 @@ router.get('/:slug', async (req, res, next) => {
      },
    })
    if (!company) return res.status(404).json({ error: 'not_found', message: 'Company not found', statusCode: 404 })
-    res.json({ data: company })
+    const vehicles = await Promise.all(
+      company.vehicles.map(async (vehicle) => {
+        const availability = await getVehicleAvailabilitySummary(vehicle.id)
+        return {
+          ...vehicle,
+          availability: availability.available,
+          availabilityStatus: availability.status,
+          nextAvailableAt: availability.nextAvailableAt,
+        }
+      }),
+    )
+    res.json({ data: { ...company, vehicles } })
  } catch (err) {
    if (isDatabaseUnavailableError(err)) {
      return res.status(503).json({ error: 'database_unavailable', message: 'Marketplace data is temporarily unavailable', statusCode: 503 })
@@ -294,13 +311,10 @@ router.get('/:slug/vehicles/:id', async (req, res, next) => {
      where: { id: req.params.id, companyId: company.id, isPublished: true },
      include: {
        company: { include: { brand: true } },
-        reservations: {
-          where: { status: { in: ['CONFIRMED', 'ACTIVE'] } },
-          select: { startDate: true, endDate: true },
-        },
      },
    })
-    res.json({ data: vehicle })
+    const availability = await getVehicleAvailabilitySummary(vehicle.id)
+    res.json({ data: { ...vehicle, availabilityStatus: availability.status, availability: availability.available, nextAvailableAt: availability.nextAvailableAt } })
  } catch (err) {
    if (isDatabaseUnavailableError(err)) {
      return res.status(503).json({ error: 'database_unavailable', message: 'Vehicle details are temporarily unavailable', statusCode: 503 })
@@ -8,6 +8,7 @@ import { applyPricingRules } from '../services/pricingRuleService'
 import { validateAndFlagLicense, validateLicense } from '../services/licenseValidationService'
 import * as paypal from '../services/paypalService'
 import { getMarketplaceHomepageContent } from '../services/platformContentService'
+import { getVehicleAvailabilitySummary } from '../services/vehicleAvailabilityService'

 const router = Router()

@@ -67,7 +68,18 @@ router.get('/:slug/vehicles', async (req, res, next) => {
      where: { companyId: company.id, isPublished: true },
      orderBy: { createdAt: 'desc' },
    })
-    res.json({ data: vehicles })
+    const enrichedVehicles = await Promise.all(
+      vehicles.map(async (vehicle) => {
+        const availability = await getVehicleAvailabilitySummary(vehicle.id)
+        return {
+          ...vehicle,
+          availability: availability.available,
+          availabilityStatus: availability.status,
+          nextAvailableAt: availability.nextAvailableAt,
+        }
+      }),
+    )
+    res.json({ data: enrichedVehicles })
  } catch (err) {
    if (isDatabaseUnavailableError(err)) return res.json({ data: [] })
    next(err)
@@ -79,14 +91,9 @@ router.get('/:slug/vehicles/:id', async (req, res, next) => {
    const company = await findCompanyBySlug(req.params.slug)
    const vehicle = await prisma.vehicle.findFirstOrThrow({
      where: { id: req.params.id, companyId: company.id, isPublished: true },
-      include: {
-        reservations: {
-          where: { status: { in: ['CONFIRMED', 'ACTIVE'] } },
-          select: { startDate: true, endDate: true, status: true },
-        },
-      },
    })
-    res.json({ data: vehicle })
+    const availability = await getVehicleAvailabilitySummary(vehicle.id)
+    res.json({ data: { ...vehicle, availability: availability.available, availabilityStatus: availability.status, nextAvailableAt: availability.nextAvailableAt } })
  } catch (err) {
    if (isDatabaseUnavailableError(err)) {
      return res.status(503).json({ error: 'database_unavailable', message: 'Vehicle details are temporarily unavailable', statusCode: 503 })
@@ -143,18 +150,10 @@ router.post('/:slug/availability', async (req, res, next) => {
      endDate: z.string().datetime(),
    }).parse(req.body)

-    const conflicts = await prisma.reservation.findMany({
-      where: {
-        companyId: company.id,
-        vehicleId,
-        status: { in: ['CONFIRMED', 'ACTIVE'] },
-        startDate: { lt: new Date(endDate) },
-        endDate: { gt: new Date(startDate) },
-      },
-      select: { startDate: true, endDate: true },
+    const availability = await getVehicleAvailabilitySummary(vehicleId, {
+      range: { startDate: new Date(startDate), endDate: new Date(endDate) },
    })
-
-    res.json({ data: { available: conflicts.length === 0, conflicts } })
+    res.json({ data: { available: availability.available, nextAvailableAt: availability.nextAvailableAt } })
  } catch (err) {
    if (isDatabaseUnavailableError(err)) {
      return res.status(503).json({ error: 'database_unavailable', message: 'Availability checks are temporarily unavailable', statusCode: 503 })
@@ -225,6 +224,23 @@ router.post('/:slug/book', async (req, res, next) => {
    const vehicle = await prisma.vehicle.findFirstOrThrow({
      where: { id: body.vehicleId, companyId: company.id, isPublished: true },
    })
+    const start = new Date(body.startDate)
+    const end = new Date(body.endDate)
+    if (end <= start) {
+      return res.status(400).json({ error: 'invalid_dates', message: 'End date must be after start date', statusCode: 400 })
+    }
+
+    const availability = await getVehicleAvailabilitySummary(vehicle.id, {
+      range: { startDate: start, endDate: end },
+    })
+    if (!availability.available) {
+      return res.status(409).json({
+        error: 'unavailable',
+        message: 'Vehicle is not available for the selected dates',
+        statusCode: 409,
+        nextAvailableAt: availability.nextAvailableAt?.toISOString() ?? null,
+      })
+    }

    const customer = await prisma.customer.upsert({
      where: { companyId_email: { companyId: company.id, email: body.email } },
@@ -251,9 +267,6 @@ router.post('/:slug/book', async (req, res, next) => {
        nationality: body.nationality ?? null,
      },
    })
-
-    const start = new Date(body.startDate)
-    const end = new Date(body.endDate)
    const totalDays = Math.max(1, Math.ceil((end.getTime() - start.getTime()) / 86400000))
    const baseAmount = vehicle.dailyRate * totalDays

@@ -112,18 +112,137 @@ router.get('/:id/availability', async (req, res, next) => {
    const { startDate, endDate } = req.query as Record<string, string>
    if (!startDate || !endDate) return res.status(400).json({ error: 'missing_params', message: 'startDate and endDate required', statusCode: 400 })

-    const conflicts = await prisma.reservation.findMany({
-      where: {
-        vehicleId: req.params.id,
-        companyId: req.companyId,
-        status: { in: ['CONFIRMED', 'ACTIVE'] },
-        startDate: { lt: new Date(endDate) },
-        endDate:   { gt: new Date(startDate) },
-      },
-      select: { id: true, startDate: true, endDate: true, status: true },
-    })
+    const start = new Date(startDate)
+    const end   = new Date(endDate)

-    res.json({ data: { available: conflicts.length === 0, conflicts } })
+    const [reservationConflicts, blockConflicts] = await Promise.all([
+      prisma.reservation.findMany({
+        where: {
+          vehicleId: req.params.id,
+          companyId: req.companyId,
+          status: { in: ['CONFIRMED', 'ACTIVE'] },
+          startDate: { lt: end },
+          endDate:   { gt: start },
+        },
+        select: { id: true, startDate: true, endDate: true, status: true },
+      }),
+      prisma.vehicleCalendarBlock.findMany({
+        where: {
+          vehicleId: req.params.id,
+          startDate: { lt: end },
+          endDate:   { gt: start },
+        },
+        select: { id: true, startDate: true, endDate: true, type: true, reason: true },
+      }),
+    ])
+
+    res.json({
+      data: {
+        available: reservationConflicts.length === 0 && blockConflicts.length === 0,
+        conflicts: reservationConflicts,
+        blocks: blockConflicts,
+      },
+    })
+  } catch (err) { next(err) }
+})
+
+router.get('/:id/calendar', async (req, res, next) => {
+  try {
+    const year  = parseInt(req.query.year  as string)
+    const month = parseInt(req.query.month as string)
+    if (isNaN(year) || isNaN(month) || month < 1 || month > 12) {
+      return res.status(400).json({ error: 'invalid_params', message: 'year and month (1-12) required', statusCode: 400 })
+    }
+
+    // Validate vehicle belongs to company
+    await prisma.vehicle.findFirstOrThrow({ where: { id: req.params.id, companyId: req.companyId } })
+
+    const rangeStart = new Date(year, month - 1, 1)
+    const rangeEnd   = new Date(year, month, 1)
+
+    const [reservations, blocks] = await Promise.all([
+      prisma.reservation.findMany({
+        where: {
+          vehicleId: req.params.id,
+          companyId: req.companyId,
+          status: { in: ['DRAFT', 'CONFIRMED', 'ACTIVE'] },
+          startDate: { lt: rangeEnd },
+          endDate:   { gt: rangeStart },
+        },
+        select: {
+          id: true, startDate: true, endDate: true, status: true,
+          customer: { select: { firstName: true, lastName: true } },
+        },
+        orderBy: { startDate: 'asc' },
+      }),
+      prisma.vehicleCalendarBlock.findMany({
+        where: {
+          vehicleId: req.params.id,
+          startDate: { lt: rangeEnd },
+          endDate:   { gt: rangeStart },
+        },
+        orderBy: { startDate: 'asc' },
+      }),
+    ])
+
+    const events = [
+      ...reservations.map((r) => ({
+        id: r.id,
+        type: 'RESERVATION' as const,
+        startDate: r.startDate,
+        endDate: r.endDate,
+        status: r.status,
+        label: r.customer ? `${r.customer.firstName} ${r.customer.lastName}` : 'Reserved',
+      })),
+      ...blocks.map((b) => ({
+        id: b.id,
+        type: b.type === 'MAINTENANCE' ? 'MAINTENANCE' as const : 'BLOCK' as const,
+        startDate: b.startDate,
+        endDate: b.endDate,
+        status: null,
+        label: b.reason ?? (b.type === 'MAINTENANCE' ? 'Maintenance' : 'Blocked'),
+      })),
+    ]
+
+    res.json({ data: events })
+  } catch (err) { next(err) }
+})
+
+router.post('/:id/calendar/blocks', async (req, res, next) => {
+  try {
+    const body = z.object({
+      startDate: z.string().datetime({ offset: true }).or(z.string().regex(/^\d{4}-\d{2}-\d{2}$/)),
+      endDate:   z.string().datetime({ offset: true }).or(z.string().regex(/^\d{4}-\d{2}-\d{2}$/)),
+      reason:    z.string().optional(),
+      type:      z.enum(['MANUAL', 'MAINTENANCE']).default('MANUAL'),
+    }).parse(req.body)
+
+    const start = new Date(body.startDate)
+    const end   = new Date(body.endDate)
+    if (end <= start) return res.status(400).json({ error: 'invalid_range', message: 'endDate must be after startDate', statusCode: 400 })
+
+    await prisma.vehicle.findFirstOrThrow({ where: { id: req.params.id, companyId: req.companyId } })
+
+    const block = await prisma.vehicleCalendarBlock.create({
+      data: {
+        vehicleId: req.params.id,
+        startDate: start,
+        endDate: end,
+        reason: body.reason,
+        type: body.type,
+      },
+    })
+    res.status(201).json({ data: block })
+  } catch (err) { next(err) }
+})
+
+router.delete('/:id/calendar/blocks/:blockId', async (req, res, next) => {
+  try {
+    await prisma.vehicle.findFirstOrThrow({ where: { id: req.params.id, companyId: req.companyId } })
+    await prisma.vehicleCalendarBlock.deleteMany({
+      where: { id: req.params.blockId, vehicleId: req.params.id },
+    })
+    res.json({ data: { success: true } })
  } catch (err) { next(err) }
 })