feat(model): add full recur rule support

Author: nicholaschiang

lib/model/availability.ts

@@ -10,14 +10,6 @@ import {
 import { getDate, getMonthsTimeslots, sameDate } from 'lib/utils/time';
 import clone from 'lib/utils/clone';
 
-/**
- * One's schedule contains all your booked timeslots (the inverse of one's
- * availability).
- * @deprecated We have no use of this for now (though we might in the future
- * when we implement a dashboard view).
- */
-export type ScheduleAlias = TimeslotInterface[];
-
 /**
  * One's availability contains all your open timeslots (the inverse of one's
  * schedule).
@@ -63,9 +55,7 @@ export class Availability extends Array<Timeslot> implements AvailabilityAlias {
    * avail.sort(); // Returns [past, now, future] sort.
    */
   public sort(): this {
-    return super.sort((timeslotA, timeslotB) => {
-      return timeslotA.from.valueOf() - timeslotB.from.valueOf();
-    });
+    return super.sort((a, b) => a.from.valueOf() - b.from.valueOf());
   }
 
   public static full(month: number, year: number): Availability {
@@ -101,15 +91,6 @@ export class Availability extends Array<Timeslot> implements AvailabilityAlias {
     return new Availability(...this.filter((t) => timeslotOnDate(t, date)));
   }
 
-  /**
-   * @return Whether or not this availability contains the exact given timeslot.
-   * @deprecated I'm not sure where I would need to use this, but whereever I do
-   * it should be removed.
-   */
-  public hasTimeslot(timeslot: TimeslotInterface): boolean {
-    return this.some((t) => t.equalTo(timeslot));
-  }
-
   /**
    * @return Whether this availability overlaps at all with the given timeslot.
    */
@@ -191,19 +172,6 @@ export class Availability extends Array<Timeslot> implements AvailabilityAlias {
     updated.forEach((time: Timeslot) => this.push(time));
   }
 
-  /**
-   * Returns whether two availabilities contain all the same timeslots.
-   * @param other - The other availability to check against.
-   * @return Whether this availability contained all the same timeslots as the
-   * other availability.
-   * @deprecated We should just use a `dequal` which should do the same thing.
-   */
-  public equalTo(other: Availability): boolean {
-    if (!other.every((t: Timeslot) => this.hasTimeslot(t))) return false;
-    if (!this.every((t: Timeslot) => other.hasTimeslot(t))) return false;
-    return true;
-  }
-
   public toString(locale = 'en'): string {
     return this.map((t) => t.toString(locale)).join(', ');
   }

lib/model/meeting.ts

@@ -61,6 +61,7 @@ export type MeetingStatus = 'created' | 'pending' | 'logged' | 'approved';
  * @property time - Time of the meeting (e.g. Tuesday 3:00 - 3:30 PM).
  * @property creator - The person who logged the meeting (typically the tutor).
  * @property notes - Notes about the meeting (e.g. what they worked on).
+ * @property [parentId] - The recurring parent meeting ID (if any).
  */
 export interface MeetingInterface extends ResourceInterface {
   status: MeetingStatus;
@@ -70,6 +71,7 @@ export interface MeetingInterface extends ResourceInterface {
   time: Timeslot;
   notes: string;
   ref?: DocumentReference;
+  parentId?: string;
   id: string;
 }
 
@@ -106,6 +108,7 @@ export function isMeetingJSON(json: unknown): json is MeetingJSON {
   if (!isVenueJSON(json.venue)) return false;
   if (!isTimeslotJSON(json.time)) return false;
   if (typeof json.notes !== 'string') return false;
+  if (json.parentId && typeof json.parentId !== 'string') return false;
   if (typeof json.id !== 'string') return false;
   return true;
 }
@@ -129,6 +132,8 @@ export class Meeting extends Resource implements MeetingInterface {
 
   public notes = '';
 
+  public parentId?: string;
+
   public id = '';
 
   public ref?: DocumentReference;

lib/model/timeslot.ts

@@ -3,6 +3,7 @@ import * as admin from 'firebase-admin';
 import { isDateJSON, isJSON } from 'lib/model/json';
 import clone from 'lib/utils/clone';
 import construct from 'lib/model/construct';
+import definedVals from 'lib/model/defined-vals';
 
 /**
  * This is a painful workaround as we then import the entire Firebase library
@@ -18,31 +19,36 @@ type Timestamp = admin.firestore.Timestamp;
 
 /**
  * A timeslot is a window of time and provides all the necessary scheduling data
- * for any scenario.
+ * for any scenario (including support for complex rrules used server-side).
+ * @typedef {Object} TimeslotInterface
  * @property id - A unique identifier for this timeslot (used as React keys and
  * thus only stored client-side as we have no use for this on our server).
- * @property from - The start time and date of this timeslot (typically
- * represented by a `Date`, `Timestamp`, or UTC date string).
- * @property to - The end time and date of this timeslot (represented in the
- * same format as the `from` property).
+ * @property from - The start time of this particular timeslot instance.
+ * @property to - The end time of this particular timeslot instance.
+ * @property recur - The timeslot's recurrence rule (uses the iCal RFC string).
+ * @property [last] - The timeslot's last possible end time. Undefined
+ * client-side; only used server-side for querying recurring timeslots.
  */
-export interface TimeslotBase<T> {
+export interface TimeslotInterface<T = Date> {
   id: string;
   from: T;
   to: T;
+  recur: string;
+  last?: T;
 }
 
-export type TimeslotInterface = TimeslotBase<Date>;
-export type TimeslotFirestore = TimeslotBase<Timestamp>;
-export type TimeslotJSON = TimeslotBase<string>;
-export type TimeslotSearchHit = TimeslotBase<number>;
+export type TimeslotFirestore = TimeslotInterface<Timestamp>;
+export type TimeslotJSON = TimeslotInterface<string>;
+export type TimeslotSearchHit = TimeslotInterface<number>;
 export type TimeslotSegment = { from: Date; to: Date };
 
 export function isTimeslotJSON(json: unknown): json is TimeslotJSON {
   if (!isJSON(json)) return false;
+  if (typeof json.id !== 'string') return false;
   if (!isDateJSON(json.from)) return false;
   if (!isDateJSON(json.to)) return false;
-  if (typeof json.id !== 'string') return false;
+  if (typeof json.recur !== 'string') return false;
+  if (json.last && !isDateJSON(json.last)) return false;
   return true;
 }
 
@@ -53,6 +59,11 @@ export class Timeslot implements TimeslotInterface {
 
   public to: Date = new Date();
 
+  // TODO: Should I prefill this with `RRULE:COUNT=1` for single instances?
+  public recur = '';
+
+  public last?: Date;
+
   /**
    * Constructor that takes advantage of Typescript's shorthand assignment.
    * @see {@link https://bit.ly/2XjNmB5}
@@ -77,6 +88,7 @@ export class Timeslot implements TimeslotInterface {
    * 1. (Contained) Timeslot contains the given timeslot, OR;
    * 2. (Overlap Start) Timeslot contains the given timeslot's start time, OR;
    * 3. (Overlap End) Timeslot contains the given timeslot's end time.
+   * @todo Why can't we use this in the calendar positioning logic?
    */
   public overlaps(other: { from: Date; to: Date }): boolean {
     return (
@@ -143,45 +155,59 @@ export class Timeslot implements TimeslotInterface {
   }
 
   public toFirestore(): TimeslotFirestore {
-    const { from, to, ...rest } = this;
-    return {
+    const { from, to, last, ...rest } = this;
+    return definedVals({
       ...rest,
       from: (from as unknown) as Timestamp,
       to: (to as unknown) as Timestamp,
-    };
+      last: last ? ((last as unknown) as Timestamp) : undefined,
+    });
   }
 
   public static fromFirestore(data: TimeslotFirestore): Timeslot {
     return new Timeslot({
       ...data,
       from: data.from.toDate(),
       to: data.to.toDate(),
+      last: data.last?.toDate(),
     });
   }
 
   public toJSON(): TimeslotJSON {
-    const { from, to, ...rest } = this;
-    return { ...rest, from: from.toJSON(), to: to.toJSON() };
+    const { from, to, last, ...rest } = this;
+    return definedVals({
+      ...rest,
+      from: from.toJSON(),
+      to: to.toJSON(),
+      last: last?.toJSON(),
+    });
   }
 
   public static fromJSON(json: TimeslotJSON): Timeslot {
     return new Timeslot({
       ...json,
       from: new Date(json.from),
       to: new Date(json.to),
+      last: json.last ? new Date(json.last) : undefined,
     });
   }
 
   public toSearchHit(): TimeslotSearchHit {
-    const { from, to, ...rest } = this;
-    return { ...rest, from: from.valueOf(), to: to.valueOf() };
+    const { from, to, last, ...rest } = this;
+    return definedVals({
+      ...rest,
+      from: from.valueOf(),
+      to: to.valueOf(),
+      last: last?.valueOf(),
+    });
   }
 
   public static fromSearchHit(hit: TimeslotSearchHit): Timeslot {
     return new Timeslot({
       ...hit,
       from: new Date(hit.from),
       to: new Date(hit.to),
+      last: hit.last ? new Date(hit.last) : undefined,
     });
   }
 
@@ -192,9 +218,13 @@ export class Timeslot implements TimeslotInterface {
   public static fromURLParam(param: string): Timeslot {
     const params: URLSearchParams = new URLSearchParams(param);
     return new Timeslot({
+      id: params.get('id') || undefined,
       from: new Date(params.get('from') as string),
       to: new Date(params.get('to') as string),
-      id: params.get('id') || undefined,
+      recur: params.get('recur') || undefined,
+      last: params.get('last')
+        ? new Date(params.get('last') as string)
+        : undefined,
     });
   }