Dev to Main Sync (#2513)

* chore: remove lastOooUntil migration artifacts and code (#2507)

- drop updateLastOooUntil controller now that prod backfill is done
- delete runLastOooUntilMigration helpers from userStatus.js
- remove POST /users/migration/update-last-ooo-until route
- strip integration tests that exercised the migration endpoint

* fix(missed-updates): compute gap window using working days (#2511)

* fix(missed-updates): compute gap window using working days

- import convertTimestampToUTCStartOrEndOfDay so the window uses UTC day bounds
- respect caller-provided exclusions instead of hard-coding Sunday into the set
- step backwards through calendar days, skipping excluded ones, and bail when none remain
- add regression coverage (plus fixture) for Sunday-only gaps and the Sunday-working-day case

* fix(missed-updates): align working-day window counting and tests

- compute the missed-updates window from consecutive working days without overshooting
- adjust the Sunday-gap fixture to actual Saturday/Sunday/Monday dates
- ensure regression tests cover both excluded Sunday and Sunday-as-working-day scenarios

* fix: failing tests

Author: iamitprakash

models/discordactions.js

@@ -22,7 +22,11 @@ const discordMissedUpdatesRoleId = config.get("discordMissedUpdatesRoleId");
 const userStatusModel = firestore.collection("usersStatus");
 const usersUtils = require("../utils/users");
 const { getUsersBasedOnFilter, fetchUser } = require("./users");
-const { convertDaysToMilliseconds, convertMillisToSeconds } = require("../utils/time");
+const {
+  convertDaysToMilliseconds,
+  convertMillisToSeconds,
+  convertTimestampToUTCStartOrEndOfDay,
+} = require("../utils/time");
 const { chunks } = require("../utils/array");
 const tasksModel = firestore.collection("tasks");
 const { FIRESTORE_IN_CLAUSE_SIZE } = require("../constants/users");
@@ -965,23 +969,71 @@ const getMissedProgressUpdatesUsers = async (options = {}) => {
     const discordUsersPromise = discordService.getDiscordMembers();
     const missedUpdatesRoleId = discordMissedUpdatesRoleId;
 
-    let gapWindowStart = Date.now() - convertDaysToMilliseconds(dateGap);
-    const gapWindowEnd = Date.now();
-    excludedDates.forEach((timestamp) => {
-      if (timestamp > gapWindowStart && timestamp < gapWindowEnd) {
-        gapWindowStart -= convertDaysToMilliseconds(1);
+    const normalizedExcludedWeekdays = new Set(
+      excludedDays.map((day) => Number(day)).filter((day) => Number.isInteger(day) && day >= 0 && day <= 6)
+    );
+
+    if (normalizedExcludedWeekdays.size === 7) {
+      return { usersToAddRole: [], ...stats };
+    }
+
+    const normalizedExcludedDates = excludedDates.reduce((set, timestamp) => {
+      const normalizedTimestamp = convertTimestampToUTCStartOrEndOfDay(Number(timestamp));
+      if (normalizedTimestamp !== null) {
+        set.add(normalizedTimestamp);
       }
-    });
+      return set;
+    }, new Set());
+
+    const currentTimestamp = Date.now();
+    const gapWindowEnd = convertTimestampToUTCStartOrEndOfDay(currentTimestamp, true);
+    let gapWindowStart = convertTimestampToUTCStartOrEndOfDay(currentTimestamp, false);
+    let remainingWorkingDays = Number.isInteger(dateGap) && dateGap > 0 ? dateGap : 0;
+
+    while (remainingWorkingDays > 0 && gapWindowStart !== null) {
+      const dayOfWeek = new Date(gapWindowStart).getUTCDay();
+      const isExcludedDay = normalizedExcludedWeekdays.has(dayOfWeek);
+      const isExcludedDate = normalizedExcludedDates.has(gapWindowStart);
+
+      if (!isExcludedDay && !isExcludedDate) {
+        remainingWorkingDays--;
+      }
+
+      const previousDayTimestamp = gapWindowStart - convertDaysToMilliseconds(1);
+      const previousDayStart = convertTimestampToUTCStartOrEndOfDay(previousDayTimestamp, false);
 
-    if (excludedDays.length === 7) {
+      if (remainingWorkingDays === 0) {
+        gapWindowStart = previousDayStart ?? gapWindowStart;
+        break;
+      }
+
+      if (previousDayStart === null) {
+        gapWindowStart = null;
+        break;
+      }
+
+      gapWindowStart = previousDayStart;
+    }
+
+    if (gapWindowStart === null || remainingWorkingDays > 0) {
       return { usersToAddRole: [], ...stats };
     }
 
-    for (let i = gapWindowEnd; i >= gapWindowStart; i -= convertDaysToMilliseconds(1)) {
-      const day = new Date(i).getDay();
-      if (excludedDays.includes(day)) {
-        gapWindowStart -= convertDaysToMilliseconds(1);
+    while (gapWindowStart !== null) {
+      const dayOfWeek = new Date(gapWindowStart).getUTCDay();
+      const isExcludedDay = normalizedExcludedWeekdays.has(dayOfWeek);
+      const isExcludedDate = normalizedExcludedDates.has(gapWindowStart);
+
+      if (!isExcludedDay && !isExcludedDate) {
+        break;
       }
+
+      const previousDayTimestamp = gapWindowStart - convertDaysToMilliseconds(1);
+      gapWindowStart = convertTimestampToUTCStartOrEndOfDay(previousDayTimestamp, false);
+    }
+
+    if (gapWindowStart === null) {
+      return { usersToAddRole: [], ...stats };
     }
 
     let taskQuery = buildTasksQueryForMissedUpdates(size);

test/fixtures/missedUpdates/sundayGap.js

@@ -0,0 +1,26 @@
+const userData = require("../user/user")();
+const tasksData = require("../tasks/tasks")();
+const { TASK_STATUS } = require("../../../constants/tasks");
+
+module.exports = () => {
+  const developer = {
+    ...userData[0],
+    username: "sunday-gap-user",
+    discordId: "sunday-gap-discord",
+    roles: { ...(userData[0].roles || {}), archived: false, in_discord: true },
+  };
+
+  const task = {
+    ...tasksData[0],
+    status: TASK_STATUS.IN_PROGRESS,
+    startedOn: Math.floor(Date.UTC(2025, 2, 31) / 1000),
+    endsOn: Math.floor(Date.UTC(2025, 4, 30) / 1000),
+  };
+
+  return {
+    evaluationTime: Date.UTC(2025, 3, 14, 9, 0, 0, 0),
+    saturdayProgressTimestamp: Date.UTC(2025, 3, 12, 0, 0, 0, 0),
+    developer,
+    task,
+  };
+};

test/unit/models/discordactions.test.js

@@ -1,6 +1,7 @@
 const chai = require("chai");
 const expect = chai.expect;
 const sinon = require("sinon");
+const config = require("config");
 const firestore = require("../../../utils/firestore");
 const photoVerificationModel = firestore.collection("photo-verification");
 const discordRoleModel = firestore.collection("discord-roles");
@@ -66,6 +67,7 @@ const { generateUserStatusData } = require("../../fixtures/userStatus/userStatus
 const { userState } = require("../../../constants/userStatus");
 const { REQUEST_TYPE, REQUEST_STATE } = require("../../../constants/requests");
 const { createRequest } = require("../../../models/requests");
+const getSundayGapFixture = require("../../fixtures/missedUpdates/sundayGap");
 
 chai.should();
 
@@ -1441,4 +1443,72 @@ describe("discordactions", function () {
       expect(users[1].id).to.equal(userId1);
     });
   });
+
+  describe("getMissedProgressUpdatesUsers working days window", function () {
+    let dateNowStub;
+    let developerDiscordId;
+    let developerUserId;
+    let developerTaskId;
+    let sundayFixture;
+
+    beforeEach(async function () {
+      await cleanDb();
+
+      sundayFixture = getSundayGapFixture();
+      dateNowStub = sinon.stub(Date, "now").returns(sundayFixture.evaluationTime);
+
+      developerDiscordId = sundayFixture.developer.discordId;
+      developerUserId = await addUser(sundayFixture.developer);
+
+      await userStatusModel.updateUserStatus(developerUserId, userStatusData.activeStatus);
+
+      const taskPayload = {
+        ...sundayFixture.task,
+        assignee: developerUserId,
+      };
+
+      const taskDocRef = await tasksModel.add(taskPayload);
+      developerTaskId = taskDocRef.id;
+
+      const saturdayProgress = stubbedModelTaskProgressData(
+        developerUserId,
+        developerTaskId,
+        sundayFixture.saturdayProgressTimestamp,
+        sundayFixture.saturdayProgressTimestamp
+      );
+
+      await firestore.collection("progresses").add(saturdayProgress);
+
+      sinon.stub(discordService, "getDiscordMembers").resolves([
+        {
+          user: { id: developerDiscordId },
+          roles: [config.get("discordDeveloperRoleId")],
+        },
+      ]);
+    });
+
+    afterEach(async function () {
+      if (dateNowStub) {
+        dateNowStub.restore();
+      }
+      sinon.restore();
+      await cleanDb();
+    });
+
+    it("should not flag users when the only gap falls on Sunday", async function () {
+      const result = await getMissedProgressUpdatesUsers();
+
+      expect(result).to.be.an("object");
+      expect(result.usersToAddRole).to.not.include(developerDiscordId);
+      expect(result.missedUpdatesTasks).to.equal(0);
+    });
+
+    it("should flag users when Sunday is treated as a working day", async function () {
+      const result = await getMissedProgressUpdatesUsers({ excludedDays: [], dateGap: 1 });
+
+      expect(result).to.be.an("object");
+      expect(result.usersToAddRole).to.include(developerDiscordId);
+      expect(result.missedUpdatesTasks).to.equal(1);
+    });
+  });
 });