pfadi-bussle/db/index.ts

import * as mongoose from 'mongoose'

import Booker from './booker'
import Booking from './booking'
import { BOOKING_STATUS } from './bookingStatus'

let connectedPromise: Promise<typeof mongoose>

function connect() {
  if (connectedPromise) {
    return
  }

  connectedPromise = mongoose.connect(process.env.MONGO_URI, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
  })

  return connectedPromise
}

export async function getBookedDays() {
  await connect()

  const bookings = await Booking.find(
    {
      status: { $in: [BOOKING_STATUS.REQUESTED, BOOKING_STATUS.CONFIRMED] },
      $or: [
        { endDate: { $gt: new Date() } },
        { startDate: { $gt: new Date() } },
      ],
    },
    'startDate endDate'
  ).exec()

  return bookings
    .map((booking) => booking.days)
    .flat()
    .sort()
}

export async function getBookingByUUID(uuid: string) {
  await connect()
  const booking = await Booking.findOne({ uuid })
  return booking.populate('booker').execPopulate()
}

export async function getBookingByUUIDAsJSON(uuid: string) {
  const booking = await getBookingByUUID(uuid)
  return booking.toJSON()
}

export async function createBooking({
  startDate,
  endDate,
  purpose,
  org,
  destination,
  name,
  email,
  street,
  zip,
  city,
}) {
  await connect()
  const booking = new Booking({ startDate, endDate, purpose, org, destination })
  const bookedDays = await getBookedDays()

  if (booking.days.some((day: string) => bookedDays.includes(day))) {
    throw new mongoose.Error.ValidationError(booking)
  }

  let booker = await Booker.findOne({ email }).exec()
  if (!booker) {
    booker = new Booker({ name, email, street, zip, city })
    await booker.save()
  }

  booking.booker = booker._id
  await booking.save()
  await booking.populate('booker').execPopulate()
  return booking.toJSON()
}