Add generate link to book appointment

firebase/functions/src/common/BookAppointmentHelper.ts

@@ -67,6 +67,8 @@ export async function bookAppointment(
     appointmentToBook.donorDetails = donorDetails;
     appointmentToBook.assigningCoordinatorId = coordinatorId;
   } else {
+    appointmentToBook.shareLink = generateRandom();
+
     const donor = await getDonorOrThrow(donorId);
 
     const updateDonorPromise = updateDonorAsync(
@@ -146,3 +148,11 @@ export function validateBookAppointment(
     appointment: appointmentToBook,
   };
 }
+
+function generateRandom(complexity: number = 4) {
+  let ret = "";
+  for (let i = 0; i < complexity; i++) {
+    ret += (Math.random() + 1).toString(36).substring(2);
+  }
+  return ret;
+}

firebase/functions/src/coordinator/CoordinatorBookAppointmentHandler.test.ts

@@ -153,6 +153,7 @@ test("Valid manual donor request books appointment with manual donor", async ()
   expect(appointment.donorId).toEqual(MANUAL_DONOR_ID);
   expect(appointment.assigningCoordinatorId).toEqual(COORDINATOR_ID);
   expect(appointment.status).toEqual(AppointmentStatus.BOOKED);
+  expect(appointment.shareLink).not.toBeDefined();
 
   const bookedAppointment = data.bookedAppointment!;
   expect(bookedAppointment.id).toEqual(APPOINTMENT_TO_BOOK_2);

firebase/functions/src/dal/AppointmentDataAccessLayer.ts

@@ -113,16 +113,33 @@ export async function getAppointmentsByHospital(
   return toDbAppointments(appointments);
 }
 
-export async function getAvailableAppointments() {
-  const now = new Date();
+export async function getAvailableAppointments(
+  hospitals?: Hospital[],
+  fromTime?: Date,
+  toTime?: Date
+) {
+  if (!fromTime) {
+    fromTime = new Date();
+  }
 
-  const appointments = (await admin
+  let request = admin
     .firestore()
     .collection(Collections.APPOINTMENTS)
     .where("status", "==", AppointmentStatus.AVAILABLE)
-    .where("donationStartTime", ">", now)
-    .orderBy("donationStartTime")
-    .get()) as FirebaseFirestore.QuerySnapshot<DbAppointment>;
+    .where("donationStartTime", ">=", fromTime);
+
+  if (hospitals) {
+    request = request.where("hospital", "in", hospitals);
+  }
+
+  if (toTime) {
+    request = request.where("donationStartTime", "<=", toTime);
+  }
+
+  request = request.orderBy("donationStartTime");
+
+  const appointments =
+    (await request.get()) as FirebaseFirestore.QuerySnapshot<DbAppointment>;
 
   return toDbAppointments(appointments);
 }
@@ -151,6 +168,33 @@ export async function getAppointmentsByStatus(
   return toDbAppointments(appointments);
 }
 
+export async function getAppointmentByShareLink(
+  shareLink: string
+): Promise<DbAppointment> {
+  if (!shareLink) {
+    throw Error("you have to give a value for share link id");
+  }
+
+  let request = admin
+    .firestore()
+    .collection(Collections.APPOINTMENTS)
+    .where("shareLink", "==", shareLink);
+
+  const appointments =
+    (await request.get()) as FirebaseFirestore.QuerySnapshot<DbAppointment>;
+
+  const ret = toDbAppointments(appointments);
+  if (ret.length > 1) {
+    throw Error("there is more then one appointment with this share link!");
+  }
+
+  if (ret.length == 0) {
+    throw Error("There is no appointment with this share link!");
+  }
+
+  return ret[0];
+}
+
 export async function getAllAppointments() {
   const appointments = (await admin
     .firestore()

firebase/functions/src/donor/DonorBookAppointmentHandler.test.ts

@@ -129,6 +129,8 @@ test("Valid request books appointment", async () => {
   const appointment = await getAppointmentByIdOrThrow(APPOINTMENT_TO_BOOK_2);
   expect(appointment.donorId).toEqual(DONOR_ID);
   expect(appointment.status).toEqual(AppointmentStatus.BOOKED);
+  expect(appointment.shareLink).toBeDefined();
+  expect(appointment.shareLink).not.toEqual("");
 
   const data = response as FunctionsApi.BookAppointmentResponse;
   expect(data.status).toEqual(FunctionsApi.BookAppointmentStatus.SUCCESS);

firebase/functions/src/donor/GetAvailableAppointmentsHandler.ts

@@ -8,7 +8,11 @@ import {
 export default async function (
   request: FunctionsApi.GetAvailableAppointmentsRequest
 ): Promise<FunctionsApi.GetAvailableAppointmentsResponse> {
-  const availableAppointments = await getAvailableAppointments();
+  const availableAppointments = await getAvailableAppointments(
+    request.hospitals,
+    request.fromMillis ? new Date(request.fromMillis) : undefined,
+    request.toMillis ? new Date(request.toMillis) : undefined
+  );
 
   const result = availableAppointments.map<AvailableAppointment>(
     (appointment) => ({

firebase/functions/src/donor/GetSharedLinkAppointmentHandler.test.ts

@@ -0,0 +1,108 @@
+import firebaseFunctionsTest from "../testUtils/FirebaseTestUtils";
+import {
+  FunctionsApi,
+  Hospital,
+  AppointmentStatus,
+} from "@zm-blood-components/common";
+import * as Functions from "../index";
+import {
+  deleteAppointmentsByIds,
+  setAppointment,
+} from "../dal/AppointmentDataAccessLayer";
+import * as admin from "firebase-admin";
+import { DbAppointment } from "../function-types";
+import { saveTestDonor } from "../testUtils/TestSamples";
+import { deleteDonor } from "../dal/DonorDataAccessLayer";
+
+const wrapped = firebaseFunctionsTest.wrap(
+  Functions[FunctionsApi.GetSharedLinkAppointmentFunctionName]
+);
+
+const CREATING_USER_ID = "GetAvailableAppointmentsHandlerCreatingUserId";
+const DONOR_ID = "GetAvailableAppointmentsHandlerDonorId";
+const SHARED_DONOR_ID = "SHARED_DONOR_ID";
+
+const SHARE_LINK = "JUST_A_Random_Share_link";
+
+const SHARED_APPOINTMENT = "GetAvailableAppointmentsHandlerAppointment1";
+const APPOINTMENT_IN_SAME_TIME = "GetAvailableAppointmentsHandlerAppointment2";
+const APPOINTMENT_IN_SAME_TIME_BOOKED =
+  "GetAvailableAppointmentsHandlerAppointment4";
+const DIFFRENT_APPOINTMENT = "GetAvailableAppointmentsHandlerAppointment3";
+
+const ALL_TEST_APPOINTMENTS_IDS = [
+  SHARED_APPOINTMENT,
+  APPOINTMENT_IN_SAME_TIME,
+  APPOINTMENT_IN_SAME_TIME_BOOKED,
+  DIFFRENT_APPOINTMENT,
+];
+
+beforeAll(reset);
+afterEach(reset);
+
+async function reset() {
+  await deleteDonor(SHARED_DONOR_ID);
+  await deleteDonor(DONOR_ID);
+  await deleteAppointmentsByIds(ALL_TEST_APPOINTMENTS_IDS);
+}
+
+async function saveAppointment(
+  id: string,
+  donationStartTime: Date,
+  booked: boolean,
+  shared: boolean
+) {
+  const appointment: DbAppointment = {
+    id: id,
+    creationTime: admin.firestore.Timestamp.fromDate(donationStartTime),
+    creatorUserId: CREATING_USER_ID,
+    donationStartTime: admin.firestore.Timestamp.fromDate(donationStartTime),
+    hospital: Hospital.ASAF_HAROFE,
+    donorId: "",
+    status: booked ? AppointmentStatus.BOOKED : AppointmentStatus.AVAILABLE,
+  };
+
+  if (shared) {
+    appointment.shareLink = SHARE_LINK;
+  }
+
+  if (booked) {
+    appointment.donorId = DONOR_ID;
+    appointment.bookingTime = admin.firestore.Timestamp.now();
+  }
+
+  await setAppointment(appointment);
+  return appointment;
+}
+
+test("Not authenticated", async () => {
+  await saveTestDonor(DONOR_ID);
+
+  await saveAppointment(SHARED_APPOINTMENT, new Date(), true, true);
+  await saveAppointment(APPOINTMENT_IN_SAME_TIME, new Date(), false, false);
+
+  await expect(
+    wrapped({ donorId: SHARED_DONOR_ID, shareLink: SHARE_LINK })
+  ).rejects.toThrow(Error);
+});
+
+test("Returns available appointments is ascending start time order", async () => {
+  await saveTestDonor(SHARED_DONOR_ID);
+  await saveTestDonor(DONOR_ID);
+
+  await saveAppointment(SHARED_APPOINTMENT, new Date(), true, true);
+  await saveAppointment(APPOINTMENT_IN_SAME_TIME, new Date(), false, false);
+
+  const appointment = (await callTarget()).appointment;
+
+  expect(appointment).not.toBeNaN();
+  expect(appointment.id).toEqual(SHARED_APPOINTMENT);
+  expect(appointment.shareLink).toEqual(SHARE_LINK);
+});
+
+async function callTarget() {
+  return (await wrapped(
+    { donorId: SHARED_DONOR_ID, shareLink: SHARE_LINK },
+    { auth: { uid: SHARED_DONOR_ID } }
+  )) as FunctionsApi.GetSharedLinkAppointmentResponse;
+}

firebase/functions/src/donor/GetSharedLinkAppointmentHandler.ts

@@ -0,0 +1,20 @@
+import { getAppointmentByShareLink } from "../dal/AppointmentDataAccessLayer";
+import { FunctionsApi } from "@zm-blood-components/common";
+import * as DbAppointmentUtils from "../utils/DbAppointmentUtils";
+
+export default async function (
+  request: FunctionsApi.GetSharedLinkAppointmentRequest,
+  callerId: string
+): Promise<FunctionsApi.GetSharedLinkAppointmentResponse> {
+  if (callerId !== request.donorId) {
+    throw Error("Unauthorized to access user");
+  }
+
+  const appointment = await getAppointmentByShareLink(request.shareLink);
+
+  const result = await DbAppointmentUtils.toBookedAppointmentAsync(appointment);
+
+  return {
+    appointment: result,
+  };
+}

firebase/functions/src/function-types.ts

@@ -71,4 +71,6 @@ export type DbAppointment = {
   lastChangeTime?: firestore.Timestamp;
   lastChangeType?: BookingChange;
   donationDoneTimeMillis?: firestore.Timestamp;
+
+  shareLink?: string;
 };

firebase/functions/src/index.ts

@@ -11,6 +11,7 @@ import getDonorHandler from "./donor/GetDonorHandler";
 import saveDonorHandler from "./donor/SaveDonorHandler";
 import getAvailableAppointmentsHandler from "./donor/GetAvailableAppointmentsHandler";
 import getDonorAppointmentsHandler from "./donor/GetDonorAppointmentsHandler";
+import GetSharedLinkAppointmentHandler from "./donor/GetSharedLinkAppointmentHandler";
 import getDonorsHandler from "./coordinator/GetDonorsHandler";
 import getBookedDonationsInHospitalHandler from "./reports/BookedDonationInHospitalReportHandler";
 import * as admin from "firebase-admin";
@@ -55,6 +56,9 @@ export const getAvailableAppointments = unauthenticatedHandler(
   getAvailableAppointmentsHandler
 );
 export const getDonorAppointments = handler(getDonorAppointmentsHandler);
+export const getSharedLinkAppointment = handler(
+  GetSharedLinkAppointmentHandler
+);
 export const unsubscribe = unsubscribeHandler;
 
 // Jobs

firebase/functions/src/utils/DbAppointmentUtils.ts

@@ -182,6 +182,7 @@ function toBookedAppointmentInternal(
     bloodType: bloodType,
     status: appointment.status,
     recentChangeType: getRecentChangeType(appointment),
+    shareLink: appointment.shareLink,
   };
 }