pfadi-bussle/db/index.ts

import * as mongoose from 'mongoose'
import Booker from './booker'
import Booking from './booking'
import Bill, { BillDocument } from './bill'
import { dateFormatFrontend } from '../helpers/date'
import { BOOKING_STATUS } from './enums'

let connectedPromise: Promise<typeof mongoose>

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

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

  return connectedPromise
}

export async function getBookedDays() {
  await connect()
  return Booking.findBookedDays()
}

export async function getBookingByUUID(uuid: string) {
  await connect()
  return Booking.findOne({ uuid })
}

export async function getBookings() {
  await connect()
  return await Booking.find({
    status: { $in: [BOOKING_STATUS.REQUESTED, BOOKING_STATUS.CONFIRMED] },
  })
    .populate('booker')
    .exec()
}

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

  const doubleBookedDays = booking.days.filter((day: string) =>
    bookedDays.includes(day)
  )
  if (doubleBookedDays.length) {
    const error = new mongoose.Error.ValidationError(booking)
    error.addError(
      'days',
      new mongoose.Error.ValidatorError({
        message: `${doubleBookedDays
          .map((dateString) => dateFormatFrontend(new Date(dateString)))
          .join(', ')} schon gebucht`,
      })
    )
    throw error
  }

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

export async function createBill(bookingUUID: string, billData: BillDocument) {
  await connect()
  const booking = await getBookingByUUID(bookingUUID)

  const bill = new Bill()
  bill.set(billData)

  await bill.save()

  booking.bill = bill._id
  await booking.save()

  return bill.toJSON()
}

export async function patchBill(bookingUUID: string, billData: BillDocument) {
  await connect()
  const booking = await getBookingByUUID(bookingUUID)
  const bill =
    (booking.bill && (await Bill.findById(booking.bill))) ||
    (await Bill.create())

  bill.set(billData)
  await bill.save()

  if (booking.bill !== bill._id) {
    booking.bill = bill._id
    await booking.save()
  }

  return bill.toJSON()
}

export async function getMilageMax(): Promise<number> {
  const billMaxMilageEnd = await Bill.findOne({})
    .sort('-milageEnd')
    .select('milageEnd')
    .exec()

  return billMaxMilageEnd?.milageEnd || 0
}