Frontend Release to Main [5.05]

.mise.toml

@@ -0,0 +1,2 @@
+[settings]
+python.github_attestations = false

.nvmrc

@@ -1 +1 @@
-lts/iron
+22

mise.toml

@@ -0,0 +1,5 @@
+[settings]
+python.github_attestations = false
+
+[tools]
+node = "22"

src/actions/__tests__/userManagement.test.js

@@ -87,21 +87,50 @@ describe('User Management Actions', () => {
       ]);
     });
 
-    it('allows an empty reason and removes a previously saved reason', async () => {
-      const mockUser = { _id: '123', notRehireableReason: 'Previous reason' };
-      axios.patch.mockResolvedValueOnce({ data: {} });
+    it('stores the audit history returned by the backend', async () => {
+      const mockUser = { _id: '123' };
+      const history = [
+        {
+          action: 'submitted',
+          reason: 'Missed commitments',
+          changedAt: '2026-01-02T03:04:00.000Z',
+          changedBy: { username: 'admin@example.org', firstName: 'Alex', lastName: 'Admin' },
+        },
+      ];
+      axios.patch.mockResolvedValueOnce({
+        data: {
+          notRehireableReason: 'Missed commitments',
+          notRehireableReasonHistory: history,
+        },
+      });
 
-      await store.dispatch(actions.updateRehireableStatus(mockUser, false, ''));
+      await store.dispatch(actions.updateRehireableStatus(mockUser, false, 'Missed commitments'));
 
-      expect(axios.patch).toHaveBeenCalledWith(ENDPOINTS.UPDATE_REHIREABLE_STATUS(mockUser._id), {
-        isRehireable: false,
-        notRehireableReason: '',
-      });
       expect(store.getActions()).toEqual([
-        { type: 'USER_PROFILE_UPDATE', user: { _id: '123', isRehireable: false } },
+        {
+          type: 'USER_PROFILE_UPDATE',
+          user: {
+            _id: '123',
+            isRehireable: false,
+            notRehireableReason: 'Missed commitments',
+            notRehireableReasonHistory: history,
+          },
+        },
       ]);
     });
 
+    it('does not send an empty reason when changing to not rehireable', async () => {
+      const mockUser = { _id: '123', notRehireableReason: 'Previous reason' };
+      axios.patch.mockResolvedValueOnce({ data: {} });
+
+      await expect(
+        store.dispatch(actions.updateRehireableStatus(mockUser, false, '   ')),
+      ).rejects.toThrow('A reason is required');
+
+      expect(axios.patch).not.toHaveBeenCalled();
+      expect(store.getActions()).toEqual([]);
+    });
+
     it('clears a saved reason when changing back to rehireable', async () => {
       const mockUser = { _id: '123', notRehireableReason: 'Previous reason' };
       axios.patch.mockResolvedValueOnce({ data: {} });
@@ -250,6 +279,37 @@ describe('User Management Actions', () => {
       await store.dispatch(actions.getUserProfileBasicInfo({ source: mockSource }));
       expect(store.getActions()).toEqual(expectedActions);
     });
+
+    it('fetches a single user basic info by userId using the query-param contract', async () => {
+      const mockUserId = 'user-123';
+      const mockBasicInfo = { _id: mockUserId, firstName: 'John', lastName: 'Doe' };
+
+      axios.get.mockResolvedValueOnce({ data: mockBasicInfo });
+
+      const expectedActions = [
+        { type: 'FETCH_USER_PROFILE_BASIC_INFO' },
+        { type: 'RECEIVE_USER_PROFILE_BASIC_INFO', payload: mockBasicInfo }
+      ];
+
+      await store.dispatch(actions.getUserProfileBasicInfo({ userId: mockUserId }));
+      expect(store.getActions()).toEqual(expectedActions);
+      expect(axios.get).toHaveBeenCalledWith(ENDPOINTS.USER_PROFILE_BASIC_INFO_BY_ID(mockUserId));
+    });
+
+    it('does not leave the fetch pending when the userId lookup is rejected (400)', async () => {
+      const mockUserId = 'user-123';
+      const badRequestError = { response: { status: 400, data: { error: 'Source parameter is required' } } };
+
+      axios.get.mockRejectedValueOnce(badRequestError);
+
+      const expectedActions = [
+        { type: 'FETCH_USER_PROFILE_BASIC_INFO' },
+        { type: 'FETCH_USER_PROFILE_BASIC_INFO_ERROR' }
+      ];
+
+      await store.dispatch(actions.getUserProfileBasicInfo({ userId: mockUserId }));
+      expect(store.getActions()).toEqual(expectedActions);
+    });
   });
 
   describe('UI State Actions', () => {

src/actions/__tests__/weeklyProjectSummaryActions.test.js

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import configureMockStore from 'redux-mock-store';
+import thunk from 'redux-thunk';
+import axios from 'axios';
+import {
+  fetchWeeklyProjectSummaryProjectStatus,
+} from '../bmdashboard/weeklyProjectSummaryActions';
+import {
+  FETCH_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS_BEGIN,
+  FETCH_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS_ERROR,
+  FETCH_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS_SUCCESS,
+} from '../../constants/bmdashboard/weeklyProjectSummaryConstants';
+
+vi.mock('axios');
+
+const mockStore = configureMockStore([thunk]);
+
+const createDeferred = () => {
+  let resolve;
+  let reject;
+  const promise = new Promise((promiseResolve, promiseReject) => {
+    resolve = promiseResolve;
+    reject = promiseReject;
+  });
+
+  return { promise, resolve, reject };
+};
+
+describe('weeklyProjectSummaryActions Project Status requests', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('dispatches unique request metadata for rapid Project Status requests', async () => {
+    const firstRequest = createDeferred();
+    const secondRequest = createDeferred();
+    axios.get.mockReturnValueOnce(firstRequest.promise).mockReturnValueOnce(secondRequest.promise);
+    const store = mockStore({});
+
+    const firstDispatch = store.dispatch(
+      fetchWeeklyProjectSummaryProjectStatus({
+        startDate: '2026-09-13',
+        endDate: '2026-09-19',
+        projectId: '',
+        comparisonStartDate: null,
+        comparisonEndDate: undefined,
+      }),
+    );
+    const secondDispatch = store.dispatch(
+      fetchWeeklyProjectSummaryProjectStatus({
+        startDate: '2026-09-20',
+        endDate: '2026-09-26',
+      }),
+    );
+
+    const [firstBegin, secondBegin] = store.getActions();
+    expect(firstBegin.type).toBe(FETCH_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS_BEGIN);
+    expect(secondBegin.type).toBe(FETCH_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS_BEGIN);
+    expect(firstBegin.meta.requestId).not.toBe(secondBegin.meta.requestId);
+    expect(firstBegin.meta.requestKey).toBe('endDate=2026-09-19&startDate=2026-09-13');
+    expect(secondBegin.meta.requestKey).toBe('endDate=2026-09-26&startDate=2026-09-20');
+
+    secondRequest.resolve({ data: { current: { metrics: { totalProjects: { value: 2 } } } } });
+    await secondDispatch;
+    firstRequest.resolve({ data: { current: { metrics: { totalProjects: { value: 1 } } } } });
+    await firstDispatch;
+
+    const successActions = store
+      .getActions()
+      .filter(action => action.type === FETCH_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS_SUCCESS);
+    expect(successActions).toHaveLength(2);
+    expect(successActions[0].meta.requestId).toBe(secondBegin.meta.requestId);
+    expect(successActions[1].meta.requestId).toBe(firstBegin.meta.requestId);
+  });
+
+  it('dispatches the active request metadata on Project Status failure', async () => {
+    const error = new Error('network failure');
+    axios.get.mockRejectedValue(error);
+    const store = mockStore({});
+
+    const result = await store.dispatch(
+      fetchWeeklyProjectSummaryProjectStatus({
+        startDate: '2026-09-13',
+        endDate: '2026-09-19',
+      }),
+    );
+
+    const [beginAction, errorAction] = store.getActions();
+    expect(result).toBeNull();
+    expect(errorAction).toMatchObject({
+      type: FETCH_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS_ERROR,
+      payload: error,
+      meta: beginAction.meta,
+    });
+  });
+});

src/actions/actionTypes.js

@@ -0,0 +1,2 @@
+export const FETCH_ALL_BADGES = 'FETCH_ALL_BADGES';
+export const FETCH_BADGES_FAILURE = 'FETCH_BADGES_FAILURE';

src/actions/bmdashboard/weeklyProjectSummaryActions.js

@@ -1,7 +1,12 @@
+import axios from 'axios';
+import { ENDPOINTS } from '~/utils/URL';
 import {
   SET_PROJECT_FILTER,
   SET_DATE_RANGE_FILTER,
   SET_COMPARISON_PERIOD_FILTER,
+  FETCH_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS_BEGIN,
+  FETCH_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS_SUCCESS,
+  FETCH_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS_ERROR,
 } from '../../constants/bmdashboard/weeklyProjectSummaryConstants';
 
 export const setProjectFilter = project => ({
@@ -18,3 +23,64 @@ export const setComparisonPeriodFilter = comparisonPeriod => ({
   type: SET_COMPARISON_PERIOD_FILTER,
   payload: comparisonPeriod,
 });
+
+let weeklyProjectSummaryProjectStatusRequestCounter = 0;
+
+const createWeeklyProjectSummaryProjectStatusRequestId = () => {
+  weeklyProjectSummaryProjectStatusRequestCounter += 1;
+  return `weekly-project-summary-project-status-${Date.now()}-${weeklyProjectSummaryProjectStatusRequestCounter}`;
+};
+
+export const getWeeklyProjectSummaryProjectStatusRequestKey = params => {
+  const queryParams = new URLSearchParams();
+  Object.entries(params || {})
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
+    .forEach(([key, value]) => {
+      queryParams.append(key, value);
+    });
+
+  return queryParams.toString();
+};
+
+export const fetchWeeklyProjectSummaryProjectStatusBegin = meta => ({
+  type: FETCH_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS_BEGIN,
+  meta,
+});
+
+export const fetchWeeklyProjectSummaryProjectStatusSuccess = (payload, meta) => ({
+  type: FETCH_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS_SUCCESS,
+  payload,
+  meta,
+});
+
+export const fetchWeeklyProjectSummaryProjectStatusError = (error, meta) => ({
+  type: FETCH_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS_ERROR,
+  payload: error,
+  meta,
+});
+
+export const fetchWeeklyProjectSummaryProjectStatus = params => async dispatch => {
+  const requestId = createWeeklyProjectSummaryProjectStatusRequestId();
+  const requestKey = getWeeklyProjectSummaryProjectStatusRequestKey(params);
+  const requestMeta = { requestId, requestKey };
+
+  dispatch(fetchWeeklyProjectSummaryProjectStatusBegin(requestMeta));
+
+  try {
+    const queryParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+      if (value !== undefined && value !== null && value !== '') {
+        queryParams.append(key, value);
+      }
+    });
+
+    const url = `${ENDPOINTS.BM_WEEKLY_PROJECT_SUMMARY_PROJECT_STATUS}?${queryParams.toString()}`;
+    const response = await axios.get(url);
+    dispatch(fetchWeeklyProjectSummaryProjectStatusSuccess(response.data, requestMeta));
+    return response.data;
+  } catch (error) {
+    dispatch(fetchWeeklyProjectSummaryProjectStatusError(error, requestMeta));
+    return null;
+  }
+};

src/actions/promotionActions.js

@@ -6,6 +6,11 @@ export const getPromotionEligibility = async requestor => {
   return res.data;
 };
 
+export const getPromotionPending = async requestor => {
+  const res = await axios.post(ENDPOINTS.PROMOTION_PENDING, { requestor });
+  return res.data;
+};
+
 export const postPromotionEligibility = async (memberIds, requestor) => {
   const res = await axios.post(ENDPOINTS.PROMOTE_MEMBERS, {
     memberIds,

src/actions/userManagement.js

@@ -305,16 +305,31 @@ export const updateRehireableStatus = (user, isRehireable, notRehireableReason =
     const reason = typeof notRehireableReason === 'string' ? notRehireableReason.trim() : '';
     const requestData = { isRehireable };
 
-    if (!isRehireable && reason) {
+    if (!isRehireable && !reason) {
+      throw new Error('A reason is required when a user is not rehireable.');
+    }
+
+    if (!isRehireable) {
       userProfile.notRehireableReason = reason;
       requestData.notRehireableReason = reason;
     } else {
       delete userProfile.notRehireableReason;
-      if (!isRehireable) requestData.notRehireableReason = '';
     }
 
-    await axios.patch(ENDPOINTS.UPDATE_REHIREABLE_STATUS(user._id), requestData);
+    const response = await axios.patch(ENDPOINTS.UPDATE_REHIREABLE_STATUS(user._id), requestData);
+    const responseData = response?.data || {};
+    if (Array.isArray(responseData.notRehireableReasonHistory)) {
+      userProfile.notRehireableReasonHistory = responseData.notRehireableReasonHistory;
+    }
+    if (typeof responseData.notRehireableReason === 'string') {
+      if (responseData.notRehireableReason) {
+        userProfile.notRehireableReason = responseData.notRehireableReason;
+      } else {
+        delete userProfile.notRehireableReason;
+      }
+    }
     dispatch(userProfileUpdateAction(userProfile));
+    return userProfile;
   };
 };
 
@@ -423,7 +438,7 @@ export const getUserProfileBasicInfo = ({ userId, source } = {}) => {
   // API request to fetch basic user profile information
   let userProfileBasicInfoPromise;
   if (userId)
-    userProfileBasicInfoPromise = axios.get(ENDPOINTS.USER_PROFILE(userId));
+    userProfileBasicInfoPromise = axios.get(ENDPOINTS.USER_PROFILE_BASIC_INFO_BY_ID(userId));
   else if (source)
     userProfileBasicInfoPromise = axios.get(ENDPOINTS.USER_PROFILE_BASIC_INFO(source));
   else
@@ -471,4 +486,4 @@ export const updateUserInfomation = value => dispatch => {
  */
 export const finishUserInfoUpdate = () => dispatch => {
   dispatch({ type: FINISH_USER_INFO_UPDATE });
-};
+};