Adding scheduling functions to prepare to schedule reservation requests in the future

src/common/reservation.ts

@@ -12,6 +12,8 @@ export interface DateRange {
   end: dayjs.Dayjs
 }
 
+const RESERVATION_AVAILABLE_WITHIN_DAYS = 7
+
 export class Reservation {
   public readonly dateRange: DateRange
   public readonly opponent: Opponent
@@ -37,4 +39,12 @@ export class Reservation {
 
     return possibleDates
   }
+
+  /**
+   * Method to check if a reservation is available for reservation in the system
+   * @returns is reservation date within 7 days
+   */
+  public isAvailableForReservation(): boolean {
+    return Math.ceil(this.dateRange.start.diff(dayjs(), 'days', true)) <= RESERVATION_AVAILABLE_WITHIN_DAYS
+  }
 }

src/common/schedule.ts

@@ -0,0 +1,10 @@
+import { Dayjs } from 'dayjs'
+
+/**
+ * 
+ * @param requestedDate 
+ * @returns 
+ */
+export const scheduleDateToRequestReservation = (requestedDate: Dayjs): Dayjs => {
+  return requestedDate.hour(0).minute(0).second(0).millisecond(0).subtract(7, 'days')
+}

src/lambdas/reservationHandler.ts

@@ -1,7 +1,5 @@
 import { Handler } from 'aws-lambda'
 
-import { Reservation } from '../common/reservation'
+export const run: Handler = async (): Promise<void> => {
-import { Runner } from '../common/runner'
+  return
-
-export const run: Handler = async (payload: string): Promise<void> => {
 }

src/lambdas/reservationScheduler.ts

@@ -1,22 +1,24 @@
 import { Handler } from 'aws-lambda'
-import dayjs from 'dayjs'
+import { Dayjs } from 'dayjs'
 
 import { InputEvent } from '../stepFunctions/event'
 import { Reservation } from '../common/reservation'
-import { validateRequest } from '../common/request'
+import { validateRequest, ReservationRequest } from '../common/request'
-import { Runner } from '../common/runner'
+import { scheduleDateToRequestReservation } from '../common/schedule'
+
+export interface ScheduledReservationRequest {
+  reservationRequest: ReservationRequest
+  availableAt: Dayjs
+}
 
 export const run: Handler<InputEvent, void> = async (input: InputEvent): Promise<void> => {
   console.log(`Handling event: ${input}`)
-  const { username, password, dateRange, opponent } = validateRequest(JSON.stringify(input.reservationRequest))
+  const reservationRequest = validateRequest(JSON.stringify(input.reservationRequest))
   console.log('Successfully validated request')
 
-  console.log('Creating reservation')
+  const res = new Reservation(reservationRequest.dateRange, reservationRequest.opponent)
-  const reservation = new Reservation(dateRange, opponent)
+  if (!res.isAvailableForReservation()) {
-  console.log('Created reservation')
+    console.log('Reservation date is more than 7 days away; scheduling for later')
-
+    scheduleDateToRequestReservation(reservationRequest.dateRange.start)
-  console.log('Runner starting')
+  }
-  const runner = new Runner(username, password, [reservation])
-  await runner.run()
-  console.log('Runner finished')
 }

tests/common/reservation.test.ts

@@ -1,10 +1,10 @@
 import dayjs from 'dayjs'
 import { DateRange, Reservation } from '../../src/common/reservation'
 
-describe("Reservation", () => {
+describe('Reservation', () => {
-  it("will create correct possible dates", () => {
+  test('will create correct possible dates', () => {
-    const startDate = dayjs().set("hour", 12).set("minute", 0)
+    const startDate = dayjs().set('hour', 12).set('minute', 0)
-    const endDate = dayjs().set("hour", 13).set("minute", 0)
+    const endDate = dayjs().set('hour', 13).set('minute', 0)
     const dateRange: DateRange = {
       start: startDate,
       end: endDate,
@@ -14,9 +14,18 @@ describe("Reservation", () => {
     expect(res.possibleDates).toHaveLength(5)
 
     expect(res.possibleDates[0]).toEqual(startDate)
-    expect(res.possibleDates[1]).toEqual(startDate.add(15, "minute"))
+    expect(res.possibleDates[1]).toEqual(startDate.add(15, 'minute'))
-    expect(res.possibleDates[2]).toEqual(startDate.add(30, "minute"))
+    expect(res.possibleDates[2]).toEqual(startDate.add(30, 'minute'))
-    expect(res.possibleDates[3]).toEqual(startDate.add(45, "minute"))
+    expect(res.possibleDates[3]).toEqual(startDate.add(45, 'minute'))
-    expect(res.possibleDates[4]).toEqual(startDate.add(60, "minute"))
+    expect(res.possibleDates[4]).toEqual(startDate.add(60, 'minute'))
+  })
+
+  test.each([
+    { reservationDate: dayjs().add(7, 'days'), expected: true },
+    { reservationDate: dayjs().add(1, 'days'), expected: true },
+    { reservationDate: dayjs().add(8, 'days'), expected: false },
+  ])('will properly mark reservation availability according to date', ({ reservationDate, expected }) => {
+    const res = new Reservation({ start: reservationDate, end: reservationDate }, { id: 'collin', name: 'collin' })
+    expect(res.isAvailableForReservation()).toBe(expected)
   })
 })

tests/common/schedule.test.ts

@@ -0,0 +1,13 @@
+import dayjs, { Dayjs } from 'dayjs'
+import { scheduleDateToRequestReservation } from '../../src/common/schedule'
+
+describe('scheduleDateToRequestReservation', () => {
+  const zeroTime = (date: Dayjs): Dayjs => date.hour(0).minute(0).second(0).millisecond(0)
+
+  test.each([
+    { date: dayjs().add(8, 'days'), expected: zeroTime(dayjs().add(1, 'days')) },
+    { date: dayjs().add(31, 'days'), expected: zeroTime(dayjs().add(24, 'days')) },
+  ])('should return value indicating if reservation is possible now', ({ date, expected }) => {
+    expect(scheduleDateToRequestReservation(date)).toStrictEqual(expected)
+  })
+})