pfadi-bussle/db/index.ts

import * as mongoose from 'mongoose'
import BookingModel, { Booking, BookingDocument } from './booking'
import BillModel, { Bill } from './bill'
import { getBookedDays as calendarGetBookedDays } from '../lib/googlecalendar'
import { BOOKING_STATUS } from './enums'
import { uniqueFilter } from '../helpers/array'

let connectedPromise: Promise<mongoose.Mongoose>

export const MONGODB_URI = process.env.MONGODB_URI

export function connect(): Promise<mongoose.Mongoose> {
  if (connectedPromise) {
    return connectedPromise
  }

  connectedPromise = mongoose.connect(MONGODB_URI)

  return connectedPromise
}

export async function getBookedDays(
  uuidsToIngore?: string[]
): Promise<string[]> {
  await connect()
  const bookedInDatabase = await BookingModel.findBookedDays(uuidsToIngore)
  const bookedInCalendar = await calendarGetBookedDays()

  return [...bookedInDatabase, ...bookedInCalendar].filter(uniqueFilter).sort()
}

export async function getBookingByUUID(uuid: string): Promise<BookingDocument> {
  await connect()
  return BookingModel.findOne({ uuid })
}

export async function getBookings({
  status = [BOOKING_STATUS.CONFIRMED, BOOKING_STATUS.REQUESTED],
  startDateGreaterThan = '2000-01-01T00:00:00Z',
}: { status?: BOOKING_STATUS[]; startDateGreaterThan?: string } = {}): Promise<
  BookingDocument[]
> {
  await connect()
  return await BookingModel.find({
    status: { $in: status },
    startDate: { $gte: startDateGreaterThan },
  })
    .sort({ startDate: -1 })
    .exec()
}

export async function createBooking({
  startDate,
  endDate,
  purpose,
  org,
  destination,
  name,
  email,
  phone,
  street,
  zip,
  city,
}: Booking): Promise<Booking> {
  await connect()
  const booking = new BookingModel({
    startDate,
    endDate,
    purpose,
    org,
    destination,
    name,
    email,
    phone,
    street,
    zip,
    city,
  })

  await booking.save()
  return booking.toJSON<Booking>()
}

export async function patchBooking(
  bookingUUID: string,
  bookingData: Booking
): Promise<{ current: Booking; previous: Booking }> {
  await connect()
  const booking = await getBookingByUUID(bookingUUID)
  const oldBooking = booking.toJSON<Booking>()
  booking.set(bookingData)
  await booking.save()

  return { current: booking.toJSON<Booking>(), previous: oldBooking }
}

export async function createBill(
  bookingUUID: string,
  billData: Bill
): Promise<Bill> {
  await connect()
  const booking = await getBookingByUUID(bookingUUID)

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

  await bill.save()

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

  return bill.toJSON<Bill>()
}

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

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

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

  return bill.toJSON<Bill>()
}

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

  return billMaxMilageEnd?.milageEnd || 0
}