Merge pull request #4056 from Northeastern-Electric-Racing/#4055-attendance

attendance by team

Author: walker-sean

src/backend/index.ts

@@ -27,6 +27,7 @@ import partsRouter from './src/routes/parts.routes.js';
 import financeRouter from './src/routes/finance.routes.js';
 import calendarRouter from './src/routes/calendar.routes.js';
 import prospectiveSponsorRouter from './src/routes/prospective-sponsor.routes.js';
+import attendanceRouter from './src/routes/attendance.routes.js';
 
 const app = express();
 
@@ -112,6 +113,7 @@ app.use('/parts', partsRouter);
 app.use('/finance', financeRouter);
 app.use('/calendar', calendarRouter);
 app.use('/prospective-sponsors', prospectiveSponsorRouter);
+app.use('/attendance', attendanceRouter);
 app.use('/', (_req, res) => {
   res.status(200).json('Welcome to FinishLine');
 });

src/backend/src/controllers/attendance.controllers.ts

@@ -0,0 +1,53 @@
+import { NextFunction, Request, Response } from 'express';
+import AttendanceService from '../services/attendance.services.js';
+
+export default class AttendanceController {
+  static async takeAttendance(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { teamId, message } = req.body;
+      const attendance = await AttendanceService.takeAttendance(req.currentUser, teamId, message, req.organization);
+      res.status(200).json(attendance);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async getAllAttendances(req: Request, res: Response, next: NextFunction) {
+    try {
+      const attendances = await AttendanceService.getAllAttendances(req.organization);
+      res.status(200).json(attendances);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async getOngoingAttendance(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { teamId } = req.params as Record<string, string>;
+      const attendance = await AttendanceService.getOngoingAttendance(teamId, req.organization);
+      res.status(200).json(attendance);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async closeOngoingAttendance(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { teamId } = req.params as Record<string, string>;
+      await AttendanceService.closeOngoingAttendance(teamId, req.currentUser, req.organization);
+      res.status(200).json({ message: 'Attendance closed successfully' });
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async checkChannel(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { teamId } = req.params as Record<string, string>;
+      const result = await AttendanceService.checkTeamChannel(teamId, req.organization);
+      res.status(200).json(result);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+}

src/backend/src/integrations/slack.ts

@@ -143,6 +143,26 @@ export const editMessage = async (
   }
 };
 
+/**
+ * Deletes a slack message
+ * @param channelId - the channel id of the channel containing the message
+ * @param timestamp - the timestamp of the message to delete
+ */
+export const deleteMessage = async (channelId: string, timestamp: string) => {
+  const client = getSlackClient();
+  if (!client) return;
+
+  try {
+    await client.chat.delete({
+      channel: channelId,
+      ts: timestamp
+    });
+  } catch (error) {
+    console.error('Failed to delete Slack message:', (error as any)?.data?.error ?? error);
+    return undefined;
+  }
+};
+
 /**
  * Reacts to a slack message
  * @param slackId - the channel id of the channel of the message to reply to

src/backend/src/prisma-query-args/attendance.query-args.ts

@@ -0,0 +1,21 @@
+import { Prisma } from '@prisma/client';
+import { getUserQueryArgs } from './user.query-args.js';
+
+export type MeetingAttendanceQueryArgs = ReturnType<typeof getMeetingAttendanceQueryArgs>;
+
+export const getMeetingAttendanceQueryArgs = (organizationId: string) =>
+  Prisma.validator<Prisma.Meeting_AttendanceDefaultArgs>()({
+    include: {
+      userCreated: getUserQueryArgs(organizationId),
+      team: {
+        select: {
+          teamId: true,
+          teamName: true,
+          headId: true,
+          members: { select: { userId: true } },
+          leads: { select: { userId: true } }
+        }
+      },
+      attendees: { select: { userId: true } }
+    }
+  });

src/backend/src/prisma/migrations/20260317050642_meeting_attendance/migration.sql

@@ -0,0 +1,45 @@
+-- CreateTable
+CREATE TABLE "Meeting_Attendance" (
+    "meetingAttendanceId" TEXT NOT NULL,
+    "organizationId" TEXT NOT NULL,
+    "teamId" TEXT NOT NULL,
+    "userCreatedId" TEXT NOT NULL,
+    "openedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "closedAt" TIMESTAMP(3),
+    "slackChannelId" TEXT NOT NULL,
+    "slackMessageTimestamp" TEXT NOT NULL,
+
+    CONSTRAINT "Meeting_Attendance_pkey" PRIMARY KEY ("meetingAttendanceId")
+);
+
+-- CreateTable
+CREATE TABLE "_meetingAttendees" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL,
+
+    CONSTRAINT "_meetingAttendees_AB_pkey" PRIMARY KEY ("A","B")
+);
+
+-- CreateIndex
+CREATE INDEX "Meeting_Attendance_organizationId_idx" ON "Meeting_Attendance"("organizationId");
+
+-- CreateIndex
+CREATE INDEX "Meeting_Attendance_teamId_idx" ON "Meeting_Attendance"("teamId");
+
+-- CreateIndex
+CREATE INDEX "_meetingAttendees_B_index" ON "_meetingAttendees"("B");
+
+-- AddForeignKey
+ALTER TABLE "Meeting_Attendance" ADD CONSTRAINT "Meeting_Attendance_organizationId_fkey" FOREIGN KEY ("organizationId") REFERENCES "Organization"("organizationId") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Meeting_Attendance" ADD CONSTRAINT "Meeting_Attendance_teamId_fkey" FOREIGN KEY ("teamId") REFERENCES "Team"("teamId") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Meeting_Attendance" ADD CONSTRAINT "Meeting_Attendance_userCreatedId_fkey" FOREIGN KEY ("userCreatedId") REFERENCES "User"("userId") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "_meetingAttendees" ADD CONSTRAINT "_meetingAttendees_A_fkey" FOREIGN KEY ("A") REFERENCES "Meeting_Attendance"("meetingAttendanceId") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "_meetingAttendees" ADD CONSTRAINT "_meetingAttendees_B_fkey" FOREIGN KEY ("B") REFERENCES "User"("userId") ON DELETE CASCADE ON UPDATE CASCADE;

src/backend/src/prisma/schema.prisma

@@ -303,6 +303,8 @@ model User {
   leadershipCrAsLead                      Leadership_CR[]                      @relation(name: "leadershipCrLead")
   leadershipCrAsManager                   Leadership_CR[]                      @relation(name: "leadershipCrManager")
   prospectiveSponsorsContacted            Prospective_Sponsor[]                @relation(name: "prospectiveSponsorContactor")
+  createdMeetingAttendances               Meeting_Attendance[]                 @relation(name: "meetingAttendanceCreated")
+  attendedMeetingAttendances              Meeting_Attendance[]                 @relation(name: "meetingAttendees")
 }
 
 model Role {
@@ -339,6 +341,7 @@ model Team {
   organization           Organization               @relation(fields: [organizationId], references: [organizationId])
   checklists             Checklist[]
   projectTemplates       Project_Template[]
+  meetingAttendances     Meeting_Attendance[]
 
   @@index([headId])
   @@index([organizationId])
@@ -1444,6 +1447,7 @@ model Organization {
   machineries              Machinery[]
   calendars                Calendar[]
   eventTypes               Event_Type[]
+  meetingAttendances       Meeting_Attendance[]
 }
 
 model FrequentlyAskedQuestion {
@@ -1801,3 +1805,21 @@ model Guest_Definition {
 
   @@index([organizationId])
 }
+
+model Meeting_Attendance {
+  meetingAttendanceId   String       @id @default(uuid())
+  organizationId        String
+  organization          Organization @relation(fields: [organizationId], references: [organizationId])
+  teamId                String
+  team                  Team         @relation(fields: [teamId], references: [teamId])
+  userCreatedId         String
+  userCreated           User         @relation(name: "meetingAttendanceCreated", fields: [userCreatedId], references: [userId])
+  openedAt              DateTime     @default(now())
+  closedAt              DateTime?
+  slackChannelId        String
+  slackMessageTimestamp String
+  attendees             User[]       @relation(name: "meetingAttendees")
+
+  @@index([organizationId])
+  @@index([teamId])
+}

src/backend/src/routes/attendance.routes.ts

@@ -0,0 +1,22 @@
+import express from 'express';
+import { body } from 'express-validator';
+import { nonEmptyString, validateInputs } from '../utils/validation.utils.js';
+import AttendanceController from '../controllers/attendance.controllers.js';
+
+const attendanceRouter = express.Router();
+
+attendanceRouter.post(
+  '/',
+  nonEmptyString(body('teamId')),
+  nonEmptyString(body('message')),
+  validateInputs,
+  AttendanceController.takeAttendance
+);
+
+attendanceRouter.get('/', AttendanceController.getAllAttendances);
+
+attendanceRouter.get('/ongoing/:teamId', AttendanceController.getOngoingAttendance);
+attendanceRouter.post('/close/:teamId', AttendanceController.closeOngoingAttendance);
+attendanceRouter.get('/check-channel/:teamId', AttendanceController.checkChannel);
+
+export default attendanceRouter;

src/backend/src/routes/slack.routes.ts

@@ -1,5 +1,6 @@
 import { getSlackApp } from '../integrations/slack.js';
 import SlackController from '../controllers/slack.controllers.js';
+import AttendanceService from '../services/attendance.services.js';
 
 // Register Slack event listeners only if the Slack app is configured
 const slackApp = getSlackApp();
@@ -14,6 +15,18 @@ if (slackApp) {
       console.error(error);
     }
   });
+
+  // Register reaction_added event listener for attendance tracking
+  slackApp.event('reaction_added', async ({ event, logger }: any) => {
+    try {
+      const { user, item } = event;
+      if (item.type !== 'message') return;
+      await AttendanceService.handleReactionAdded(user, item.channel, item.ts);
+    } catch (error) {
+      logger.error('Error handling reaction_added event:', error);
+      console.error(error);
+    }
+  });
 }
 
 /**