Fix shortcut callback ID, enrich acceptance DM, list all confirmed sl… (#540)

kylehoehns · web-flow · commit 42114315e076 · 2026-04-05T20:03:45.000-05:00
* Fix shortcut callback ID, enrich acceptance DM, list all confirmed slots in channel message

* Move queue position update to session close, fix acceptance DM wording

* Remove dead findConfirmedSlot, decline teammate on zero-slot submit
diff --git a/src/bot/__tests__/acceptPairingSlot.test.ts b/src/bot/__tests__/acceptPairingSlot.test.ts
@@ -105,7 +105,7 @@ describe('acceptPairingSlot', () => {
       );
     });
 
-    it('should mark the user as last reviewed', async () => {
+    it('should not mark the user as last reviewed on submit — only on confirmed close', async () => {
       const param = buildMockActionParam();
       param.body.actions = [{ value: 'thread-1', action_id: 'pairing-submit-slots' } as any];
       param.body.user = { id: 'u1', name: 'Alice' } as any;
@@ -120,7 +120,7 @@ describe('acceptPairingSlot', () => {
 
       await acceptPairingSlot.handleSubmitSlots(param);
 
-      expect(userRepo.markNowAsLastReviewedDate).toHaveBeenCalledWith('u1');
+      expect(userRepo.markNowAsLastReviewedDate).not.toHaveBeenCalled();
     });
 
     it('should call closeIfComplete after recording slot selections', async () => {
@@ -162,6 +162,36 @@ describe('acceptPairingSlot', () => {
       expect(chatService.updateDirectMessage).toHaveBeenCalled();
     });
 
+    it('should call declineTeammate when no slots are selected', async () => {
+      jest
+        .spyOn(PairingRequestService.pairingRequestService, 'declineTeammate')
+        .mockResolvedValue(makeInterview());
+
+      const param = buildMockActionParam();
+      param.body.actions = [{ value: 'thread-1', action_id: 'pairing-submit-slots' } as any];
+      param.body.user = { id: 'u1', name: 'Alice' } as any;
+      param.body.message = { ts: 'msg-ts-1' } as any;
+      param.body.state = {
+        values: {
+          'pairing-dm-slots': {
+            'pairing-slot-selections': { selected_options: [] },
+          },
+        },
+      } as any;
+
+      await acceptPairingSlot.handleSubmitSlots(param);
+
+      expect(PairingRequestService.pairingRequestService.declineTeammate).toHaveBeenCalledWith(
+        app,
+        expect.anything(),
+        'u1',
+        expect.stringContaining("didn't select"),
+      );
+      expect(
+        PairingRequestService.pairingRequestService.recordSlotSelections,
+      ).not.toHaveBeenCalled();
+    });
+
     it('should not record slot selections if user is not pending', async () => {
       pairingSessionsRepo.getByThreadIdOrUndefined = jest
         .fn()
diff --git a/src/bot/acceptPairingSlot.ts b/src/bot/acceptPairingSlot.ts
@@ -1,15 +1,15 @@
 import { ActionParam } from '@/slackTypes';
 import { App } from '@slack/bolt';
 import log from '@utils/log';
-import { ActionId, BlockId } from './enums';
+import { ActionId, BlockId, CandidateTypeLabel, InterviewFormatLabel } from './enums';
 import { userRepo } from '@repos/userRepo';
 import { pairingSessionsRepo } from '@repos/pairingSessionsRepo';
 import { pairingRequestService } from '@/services/PairingRequestService';
 import { pairingSessionCloser } from '@/services/PairingSessionCloser';
 import { reviewLockManager } from '@utils/reviewLockManager';
 import { lockedExecute } from '@utils/lockedExecute';
 import { reportErrorAndContinue } from '@utils/reportError';
-import { textBlock } from '@utils/text';
+import { bold, compose, textBlock, ul } from '@utils/text';
 import { chatService } from '@/services/ChatService';
 
 export const acceptPairingSlot = {
@@ -48,6 +48,16 @@ export const acceptPairingSlot = {
           return;
         }
 
+        if (selectedSlotIds.length === 0) {
+          await pairingRequestService.declineTeammate(
+            acceptPairingSlot.app,
+            interview,
+            userId,
+            "You didn't select any available slots — we've moved on to the next person.",
+          );
+          return;
+        }
+
         const user = await userRepo.find(userId);
         const userFormats = user?.formats ?? [];
 
@@ -57,10 +67,24 @@ export const acceptPairingSlot = {
           selectedSlotIds,
           userFormats,
         );
-        await userRepo.markNowAsLastReviewedDate(userId);
 
+        const selectedSlots = interview.slots.filter(s => selectedSlotIds.includes(s.id));
+        const slotLines = selectedSlots.map(s => `${s.date}, ${s.startTime}–${s.endTime}`);
         await chatService.updateDirectMessage(client, userId, messageTimestamp, [
-          textBlock(`*Thanks! You've submitted your availability.*`),
+          textBlock(
+            compose(
+              `*Thanks for your availability!* Here's what you submitted:`,
+              compose(
+                bold(
+                  `Candidate: ${interview.candidateName} (${CandidateTypeLabel.get(interview.candidateType) ?? interview.candidateType})`,
+                ),
+                bold(`Languages: ${interview.languages.join(', ')}`),
+                bold(`Format: ${InterviewFormatLabel.get(interview.format) ?? interview.format}`),
+              ),
+              `*Your available slots:*\n${ul(...slotLines)}`,
+              `If enough teammates overlap on the same slot, the recruiting team will be notified to coordinate scheduling.`,
+            ),
+          ),
         ]);
 
         await pairingSessionCloser.closeIfComplete(acceptPairingSlot.app, threadId);
diff --git a/src/bot/enums.ts b/src/bot/enums.ts
@@ -2,7 +2,7 @@ export const enum Interaction {
   SHORTCUT_REQUEST_REVIEW = 'shortcut-request-review',
   SUBMIT_REQUEST_REVIEW = 'submit-request-review',
 
-  SHORTCUT_JOIN_QUEUE = 'shortcut-join-queue',
+  SHORTCUT_JOIN_QUEUE = 'shortcut-queue-preferences',
   SUBMIT_JOIN_QUEUE = 'submit-join-queue',
 
   SHORTCUT_TRIGGER_CRON = 'shortcut-trigger-cron',
diff --git a/src/services/PairingSessionCloser.ts b/src/services/PairingSessionCloser.ts
@@ -1,14 +1,15 @@
 import { PairingSession, PairingSlot } from '@models/PairingSession';
 import { InterviewFormat } from '@bot/enums';
 import { pairingSessionsRepo } from '@repos/pairingSessionsRepo';
+import { userRepo } from '@repos/userRepo';
 import { chatService } from '@/services/ChatService';
 import { App } from '@slack/bolt';
-import { mention } from '@utils/text';
+import { mention, ul } from '@utils/text';
 import { reviewLockManager } from '@utils/reviewLockManager';
 import log from '@utils/log';
 
-export function findConfirmedSlot(interview: PairingSession): PairingSlot | undefined {
-  return interview.slots.find(slot =>
+export function findConfirmedSlots(interview: PairingSession): PairingSlot[] {
+  return interview.slots.filter(slot =>
     isSlotConfirmed(slot, interview.format, interview.teammatesNeededCount),
   );
 }
@@ -36,16 +37,25 @@ export const pairingSessionCloser = {
       return;
     }
 
-    const confirmedSlot = findConfirmedSlot(interview);
+    const confirmedSlots = findConfirmedSlots(interview);
 
-    if (confirmedSlot) {
+    if (confirmedSlots.length > 0) {
+      const teammates = Array.from(
+        new Map(
+          confirmedSlots
+            .flatMap(s => s.interestedTeammates)
+            .map(t => [t.userId, t] as [string, typeof t]),
+        ).values(),
+      );
+      const slotLines = confirmedSlots.map(s => `${s.date}, ${s.startTime}–${s.endTime}`);
       await chatService.replyToReviewThread(
         app.client,
         threadId,
-        `${mention({ id: interview.requestorId })} Pairing session for ${interview.candidateName} is confirmed! ` +
-          `Slot: ${confirmedSlot.date}, ${confirmedSlot.startTime}–${confirmedSlot.endTime}. ` +
-          `Teammates: ${confirmedSlot.interestedTeammates.map(t => mention({ id: t.userId })).join(' and ')}.`,
+        `${mention({ id: interview.requestorId })} Pairing session for *${interview.candidateName}* is ready to schedule!\n\n` +
+          `*Teammates:* ${teammates.map(t => mention({ id: t.userId })).join(', ')}\n\n` +
+          `*Available slots (${confirmedSlots.length}):*\n${ul(...slotLines)}`,
       );
+      await Promise.all(teammates.map(t => userRepo.markNowAsLastReviewedDate(t.userId)));
       await pairingSessionsRepo.remove(threadId);
       reviewLockManager.releaseLock(threadId);
       return;
diff --git a/src/services/__tests__/PairingSessionCloser.test.ts b/src/services/__tests__/PairingSessionCloser.test.ts
@@ -2,10 +2,11 @@ import { PairingSession, PairingSlot } from '@models/PairingSession';
 import { CandidateType, InterviewFormat } from '@bot/enums';
 import { pairingSessionsRepo } from '@repos/pairingSessionsRepo';
 import { chatService } from '@/services/ChatService';
-import { pairingSessionCloser, findConfirmedSlot } from '../PairingSessionCloser';
+import { pairingSessionCloser, findConfirmedSlots } from '../PairingSessionCloser';
 import { buildMockApp } from '@utils/slackMocks';
 import { App } from '@slack/bolt';
 import { reviewLockManager } from '@utils/reviewLockManager';
+import { userRepo } from '@repos/userRepo';
 
 function makeSlot(overrides: Partial<PairingSlot> = {}): PairingSlot {
   return {
@@ -44,19 +45,20 @@ describe('PairingSessionCloser', () => {
     pairingSessionsRepo.remove = jest.fn().mockResolvedValue(undefined);
     pairingSessionsRepo.getByThreadIdOrUndefined = jest.fn();
     reviewLockManager.releaseLock = jest.fn();
+    userRepo.markNowAsLastReviewedDate = jest.fn().mockResolvedValue(undefined);
   });
 
-  describe('findConfirmedSlot', () => {
-    it('should return undefined when no slot has 2 interested teammates', () => {
+  describe('findConfirmedSlots', () => {
+    it('should return empty array when no slot has 2 interested teammates', () => {
       const slot = makeSlot({
         interestedTeammates: [{ userId: 'u1', acceptedAt: 1, formats: [InterviewFormat.REMOTE] }],
       });
       const interview = makeInterview({ slots: [slot] });
 
-      expect(findConfirmedSlot(interview)).toBeUndefined();
+      expect(findConfirmedSlots(interview)).toEqual([]);
     });
 
-    it('should return a slot with 2+ interested teammates for remote interviews', () => {
+    it('should return confirmed slots for remote interviews', () => {
       const slot = makeSlot({
         interestedTeammates: [
           { userId: 'u1', acceptedAt: 1, formats: [InterviewFormat.REMOTE] },
@@ -65,10 +67,30 @@ describe('PairingSessionCloser', () => {
       });
       const interview = makeInterview({ format: InterviewFormat.REMOTE, slots: [slot] });
 
-      expect(findConfirmedSlot(interview)).toEqual(slot);
+      expect(findConfirmedSlots(interview)).toEqual([slot]);
     });
 
-    it('should return a slot with 2+ interested teammates for in-person interviews', () => {
+    it('should return all confirmed slots when multiple qualify', () => {
+      const slot1 = makeSlot({
+        id: 'slot-1',
+        interestedTeammates: [
+          { userId: 'u1', acceptedAt: 1, formats: [InterviewFormat.REMOTE] },
+          { userId: 'u2', acceptedAt: 2, formats: [InterviewFormat.REMOTE] },
+        ],
+      });
+      const slot2 = makeSlot({
+        id: 'slot-2',
+        interestedTeammates: [
+          { userId: 'u1', acceptedAt: 1, formats: [InterviewFormat.REMOTE] },
+          { userId: 'u2', acceptedAt: 2, formats: [InterviewFormat.REMOTE] },
+        ],
+      });
+      const interview = makeInterview({ format: InterviewFormat.REMOTE, slots: [slot1, slot2] });
+
+      expect(findConfirmedSlots(interview)).toEqual([slot1, slot2]);
+    });
+
+    it('should return confirmed slots for in-person interviews', () => {
       const slot = makeSlot({
         interestedTeammates: [
           { userId: 'u1', acceptedAt: 1, formats: [InterviewFormat.IN_PERSON] },
@@ -77,7 +99,7 @@ describe('PairingSessionCloser', () => {
       });
       const interview = makeInterview({ format: InterviewFormat.IN_PERSON, slots: [slot] });
 
-      expect(findConfirmedSlot(interview)).toEqual(slot);
+      expect(findConfirmedSlots(interview)).toEqual([slot]);
     });
 
     describe('hybrid interviews', () => {
@@ -90,7 +112,7 @@ describe('PairingSessionCloser', () => {
         });
         const interview = makeInterview({ format: InterviewFormat.HYBRID, slots: [slot] });
 
-        expect(findConfirmedSlot(interview)).toBeUndefined();
+        expect(findConfirmedSlots(interview)).toEqual([]);
       });
 
       it('should confirm a slot where at least 1 teammate is in-person capable', () => {
@@ -102,7 +124,7 @@ describe('PairingSessionCloser', () => {
         });
         const interview = makeInterview({ format: InterviewFormat.HYBRID, slots: [slot] });
 
-        expect(findConfirmedSlot(interview)).toEqual(slot);
+        expect(findConfirmedSlots(interview)).toEqual([slot]);
       });
 
       it('should confirm a slot where both teammates are in-person capable', () => {
@@ -114,7 +136,7 @@ describe('PairingSessionCloser', () => {
         });
         const interview = makeInterview({ format: InterviewFormat.HYBRID, slots: [slot] });
 
-        expect(findConfirmedSlot(interview)).toEqual(slot);
+        expect(findConfirmedSlots(interview)).toEqual([slot]);
       });
     });
   });
@@ -154,6 +176,8 @@ describe('PairingSessionCloser', () => {
         'thread-1',
         expect.stringContaining('2026-03-31'),
       );
+      expect(userRepo.markNowAsLastReviewedDate).toHaveBeenCalledWith('u1');
+      expect(userRepo.markNowAsLastReviewedDate).toHaveBeenCalledWith('u2');
       expect(pairingSessionsRepo.remove).toHaveBeenCalledWith('thread-1');
       expect(reviewLockManager.releaseLock).toHaveBeenCalledWith('thread-1');
     });
