Merge pull request #100 from GTBitsOfGood/cindy/email-notifications

Email Notifications

Author: chrisgoggins

netlify/functions/daily-email.mts

@@ -0,0 +1,122 @@
+import type { Config, Handler } from "@netlify/functions";
+import connectMongoDB from "../../src/server/db/mongodb";
+import RouteModel from "../../src/server/db/models/RouteModel";
+import { UserModel } from "../../src/server/db/models/UserModel";
+import { EmailNotifications } from "../../src/server/email/EmailAction";
+import {
+  endOfEstDay,
+  formatEstDate,
+  formatEstTime,
+  startOfEstDay,
+} from "../../src/utils/dateEst";
+
+export const config: Config = {
+  // 7 AM EST
+  schedule: "0 12 * * *",
+};
+
+type UserForSummary = {
+  _id: { toString(): string };
+  firstName: string;
+  lastName: string;
+  preferredName?: string;
+  email: string;
+  type: "Student" | "Driver";
+};
+
+type RouteForSummary = {
+  _id: { toString(): string };
+  scheduledPickupTime: Date;
+  status: string;
+  student: { _id: { toString(): string } };
+  driver?: { _id: { toString(): string } };
+  pickupLocation: { name: string };
+  dropoffLocation: { name: string };
+};
+
+const handler: Handler = async () => {
+  await connectMongoDB();
+
+  const day = new Date();
+  const [dayStart, dayEnd] = [startOfEstDay(day), endOfEstDay(day)];
+  const optedInUsers = (await UserModel.find({
+    type: { $in: ["Student", "Driver"] },
+    "settings.notifications.dailySummary": true,
+  })
+    .select("firstName lastName preferredName email type")
+    .lean()) as unknown as UserForSummary[];
+
+  if (optedInUsers.length === 0) {
+    return { statusCode: 200, body: "No users opted in to daily summaries." };
+  }
+
+  const userIds = optedInUsers.map((user) => user._id);
+  const routes = (await RouteModel.find({
+    scheduledPickupTime: { $gte: dayStart, $lte: dayEnd },
+    $or: [
+      { "student._id": { $in: userIds } },
+      { "driver._id": { $in: userIds } },
+    ],
+  })
+    .populate([
+      { path: "pickupLocation", select: "name" },
+      { path: "dropoffLocation", select: "name" },
+    ])
+    .lean()) as unknown as RouteForSummary[];
+
+  const usersById = new Map(
+    optedInUsers.map((user) => [user._id.toString(), user]),
+  );
+  const ridesByUserId = new Map<string, RouteForSummary[]>();
+
+  for (const route of routes) {
+    const recipientIds = [
+      route.student._id.toString(),
+      route.driver?._id.toString(),
+    ].filter((id): id is string => Boolean(id));
+    for (const userId of recipientIds) {
+      if (usersById.has(userId)) {
+        const rides = ridesByUserId.get(userId) ?? [];
+        rides.push(route);
+        ridesByUserId.set(userId, rides);
+      }
+    }
+  }
+
+  const deliveries = [...ridesByUserId.entries()].map(
+    async ([userId, rides]) => {
+      const user = usersById.get(userId);
+      if (!user) return;
+
+      await EmailNotifications.dailySummary(
+        user.email,
+        user.preferredName ?? `${user.firstName} ${user.lastName}`,
+        rides.map((ride) => ({
+          rideId: ride._id.toString(),
+          date: formatEstDate(ride.scheduledPickupTime),
+          time: formatEstTime(ride.scheduledPickupTime),
+          pickup: ride.pickupLocation.name,
+          dropoff: ride.dropoffLocation.name,
+          status: ride.status,
+        })),
+      );
+    },
+  );
+
+  const results = await Promise.allSettled(deliveries);
+  const failures = results.filter((result) => result.status === "rejected");
+  if (failures.length > 0) {
+    console.error(`Failed to send ${failures.length} daily ride summaries.`);
+    return {
+      statusCode: 500,
+      body: `Sent ${results.length - failures.length} summaries; ${failures.length} failed.`,
+    };
+  }
+
+  return {
+    statusCode: 200,
+    body: `Sent ${results.length} daily ride summaries.`,
+  };
+};
+
+export default handler;

package-lock.json

@@ -21,6 +21,7 @@
     "test:e2e:report": "playwright show-report"
   },
   "dependencies": {
+    "@netlify/functions": "^6.0.0",
     "@phosphor-icons/react": "^2.1.10",
     "@radix-ui/react-checkbox": "^1.3.3",
     "@radix-ui/react-icons": "^1.3.2",

package.json

@@ -7,6 +7,7 @@ import {
   updateStudentInfo,
   updateDriverShifts,
   updatePreferredName,
+  updateNotificationSettings,
 } from "@/server/db/actions/UserAction";
 import { findInvalidAccommodations } from "@/server/db/actions/AccommodationAction";
 import { HTTP_STATUS_CODE } from "@/utils/consts";
@@ -94,6 +95,26 @@ const driverShiftsPatchSchema = z
   })
   .strict();
 
+const notificationSettingsPatchSchema = z
+  .object({
+    settings: z
+      .object({
+        notifications: z
+          .object({
+            dailySummary: z.boolean().optional(),
+            driverAssigned: z.boolean().optional(),
+            driverEnRoute: z.boolean().optional(),
+            rideCancelled: z.boolean().optional(),
+            rideAssigned: z.boolean().optional(),
+            rideCompleted: z.boolean().optional(),
+          })
+          .optional(),
+      })
+      .passthrough()
+      .optional(),
+  })
+  .passthrough();
+
 export async function PATCH(
   req: NextRequest,
   { params }: { params: Promise<{ id: string }> },
@@ -149,9 +170,33 @@ export async function PATCH(
   }
 
   try {
+    const parsedNotif = notificationSettingsPatchSchema.safeParse(body);
+    let notificationUpdated;
+    if (parsedNotif.success && parsedNotif.data.settings?.notifications) {
+      notificationUpdated = await updateNotificationSettings(id, {
+        notifications: parsedNotif.data.settings.notifications,
+      });
+
+      if (!notificationUpdated) {
+        return NextResponse.json(
+          { error: "Update failed" },
+          { status: HTTP_STATUS_CODE.INTERNAL_SERVER_ERROR },
+        );
+      }
+    }
+
     let updated;
+    const bodyWithoutSettings =
+      typeof body === "object" && body !== null
+        ? Object.fromEntries(
+            Object.entries(body as Record<string, unknown>).filter(
+              ([key]) => key !== "settings",
+            ),
+          )
+        : {};
+
     if (user.type === "Student") {
-      const parsed = studentInfoPatchSchema.safeParse(body);
+      const parsed = studentInfoPatchSchema.safeParse(bodyWithoutSettings);
       if (!parsed.success) {
         return NextResponse.json(parsed.error.format(), {
           status: HTTP_STATUS_CODE.BAD_REQUEST,
@@ -200,24 +245,26 @@ export async function PATCH(
       }
     } else if (user.type === "Driver") {
       // For drivers, only admins can update shifts
-      if (!isAdmin) {
+      if (!isAdmin && bodyWithoutSettings.shifts !== undefined) {
         return NextResponse.json(
           { error: "Only admins can update driver shifts" },
           { status: HTTP_STATUS_CODE.FORBIDDEN },
         );
       }
-      const parsed = driverShiftsPatchSchema.safeParse(body);
+      const parsed = driverShiftsPatchSchema.safeParse(bodyWithoutSettings);
       if (!parsed.success) {
         return NextResponse.json(parsed.error.format(), {
           status: HTTP_STATUS_CODE.BAD_REQUEST,
         });
       }
-      updated = await updateDriverShifts(id, parsed.data.shifts ?? []);
-      if (!updated) {
-        return NextResponse.json(
-          { error: "User not found or update failed" },
-          { status: HTTP_STATUS_CODE.NOT_FOUND },
-        );
+      if (parsed.data.shifts !== undefined) {
+        updated = await updateDriverShifts(id, parsed.data.shifts ?? []);
+        if (!updated) {
+          return NextResponse.json(
+            { error: "User not found or update failed" },
+            { status: HTTP_STATUS_CODE.NOT_FOUND },
+          );
+        }
       }
     } else {
       return NextResponse.json(
@@ -226,9 +273,18 @@ export async function PATCH(
       );
     }
 
-    const userObj = updated as Record<string, unknown> & {
-      _id: { toString(): string };
-    };
+    const finalUser = (updated ?? notificationUpdated) as
+      | (Record<string, unknown> & { _id: { toString(): string } })
+      | null;
+
+    if (!finalUser) {
+      return NextResponse.json(
+        { error: "User update failed" },
+        { status: HTTP_STATUS_CODE.BAD_REQUEST },
+      );
+    }
+
+    const userObj = finalUser;
     return NextResponse.json(
       { ...userObj, _id: userObj._id.toString() },
       { status: HTTP_STATUS_CODE.OK },