RD-T49 Store and api fixes

app.config.ts

@@ -227,36 +227,25 @@ export default ({ config }: ConfigContext): ExpoConfig => ({
     [
       'expo-location',
       {
+        // Foreground-only: nothing in src/ requests background location or registers a location task, so every
+        // background flag stays off. isIosBackgroundLocationEnabled would add `location` to UIBackgroundModes and
+        // isAndroidBackgroundLocationEnabled would declare ACCESS_BACKGROUND_LOCATION / FOREGROUND_SERVICE_LOCATION;
+        // App Review (Guideline 2.5.4) and Play reject both when no persistent-location feature exists.
         locationWhenInUsePermission:
           'Resgrid Dispatch uses your location while you use the app to center the department map on you and to attach your coordinates when you dispatch or update a call. For example, when you create a call from the field, your location can be used as the incident address.',
+        // The "Always" keys must exist anyway: expo-location's background requester references
+        // requestAlwaysAuthorization, and App Store static analysis rejects the binary with
+        // ITMS-90683 when they are absent. The app never shows these prompts, so they state the
+        // same foreground-only use.
         locationAlwaysAndWhenInUsePermission:
-          'Resgrid Dispatch uses your location, including in the background, to keep the department map updated with your position. For example, while you are working a call away from the console, your location is periodically sent so other dispatchers and responders can see where you are, even when the app is not on screen.',
+          'Resgrid Dispatch uses your location only while the app is open and never tracks it in the background. It centers the department map on you and attaches your coordinates when you dispatch or update a call. For example, when you create a call from the field, your location can be used as the incident address.',
         locationAlwaysPermission:
-          'Resgrid Dispatch uses your location in the background to keep the department map updated with your position. For example, while you are working a call away from the console, your location is periodically sent so other dispatchers and responders can see where you are, even when the app is not on screen.',
+          'Resgrid Dispatch uses your location only while the app is open and never tracks it in the background. It centers the department map on you and attaches your coordinates when you dispatch or update a call. For example, when you create a call from the field, your location can be used as the incident address.',
         // Required even though getMotionActivityAsync() is never called: expo-location links
         // CoreMotion (MotionActivityPermissionRequester), and App Store static analysis rejects
         // the binary with ITMS-90683 whenever the framework is referenced and the string is absent.
         motionUsagePermission:
           'Resgrid Dispatch uses motion data to improve the accuracy of the location shown on the department map. For example, while you are driving to an incident, motion data helps distinguish travel from a stop so other dispatchers and responders see an accurate position.',
-        isIosBackgroundLocationEnabled: true,
-        isAndroidBackgroundLocationEnabled: true,
-        isAndroidForegroundServiceEnabled: true,
-        taskManager: {
-          locationTaskName: 'location-updates',
-          locationTaskOptions: {
-            accuracy: 'balanced',
-            distanceInterval: 10,
-            timeInterval: 5000,
-          },
-        },
-      },
-    ],
-    [
-      'expo-task-manager',
-      {
-        taskManager: {
-          taskName: 'location-updates',
-        },
       },
     ],
     [
@@ -313,7 +302,7 @@ export default ({ config }: ConfigContext): ExpoConfig => ({
       '@sentry/react-native/expo',
       {
         organization: 'sentry',
-        project: 'unit',
+        project: 'dispatch',
         url: 'https://sentry.resgrid.net/',
       },
     ],

src/api/calendar/__tests__/calendar.test.ts

@@ -0,0 +1,85 @@
+interface MockEndpoint {
+  get: jest.Mock;
+  post: jest.Mock;
+}
+
+// The module under test creates its endpoints at import time, so the registry lives inside the mock factory.
+jest.mock('../../common/client', () => {
+  const endpoints: Record<string, { get: jest.Mock; post: jest.Mock }> = {};
+  return {
+    __endpoints: endpoints,
+    createApiEndpoint: (path: string) => {
+      const api = { get: jest.fn(), post: jest.fn() };
+      endpoints[path] = api;
+      return api;
+    },
+  };
+});
+
+import { getCalendarItem, getCalendarItems, getCalendarItemsForDateRange, getCalendarItemTypes, setCalendarAttending } from '../calendar';
+
+const mockEndpoints: Record<string, MockEndpoint> = jest.requireMock('../../common/client').__endpoints;
+
+const endpoint = (path: string) => {
+  const api = mockEndpoints[path];
+  if (!api) throw new Error(`endpoint ${path} was not created`);
+  return api;
+};
+
+describe('calendar api', () => {
+  beforeEach(() => {
+    Object.values(mockEndpoints).forEach((api) => {
+      api.get.mockReset().mockResolvedValue({ data: { Data: [] } });
+      api.post.mockReset().mockResolvedValue({ data: { Id: '' } });
+    });
+  });
+
+  it('only creates routes that exist on the v4 Calendar controller', () => {
+    expect(Object.keys(mockEndpoints).sort()).toEqual([
+      '/Calendar/GetCalendarItem',
+      '/Calendar/GetDepartmentCalendarItemTypes',
+      '/Calendar/GetDepartmentCalendarItems',
+      '/Calendar/GetDepartmentCalendarItemsInRange',
+      '/Calendar/SetCalendarAttendingStatus',
+    ]);
+  });
+
+  it('reads the department calendar items', async () => {
+    await getCalendarItems();
+
+    expect(endpoint('/Calendar/GetDepartmentCalendarItems').get).toHaveBeenCalledWith();
+  });
+
+  it('sends the calendar item id as id', async () => {
+    await getCalendarItem('42');
+
+    expect(endpoint('/Calendar/GetCalendarItem').get).toHaveBeenCalledWith({ id: '42' });
+  });
+
+  it('reads the department calendar item types', async () => {
+    await getCalendarItemTypes();
+
+    expect(endpoint('/Calendar/GetDepartmentCalendarItemTypes').get).toHaveBeenCalledWith();
+  });
+
+  it('sends the range as start and end without pre-encoding', async () => {
+    await getCalendarItemsForDateRange('2026-10-01T00:00:00.000Z', '2026-10-31T23:59:59.000Z');
+
+    expect(endpoint('/Calendar/GetDepartmentCalendarItemsInRange').get).toHaveBeenCalledWith({
+      start: '2026-10-01T00:00:00.000Z',
+      end: '2026-10-31T23:59:59.000Z',
+    });
+  });
+
+  it('posts attending as CalendarItemAttendInput Type 1', async () => {
+    await setCalendarAttending({ calendarItemId: '42', attending: true, note: 'On my way' });
+
+    expect(endpoint('/Calendar/SetCalendarAttendingStatus').post).toHaveBeenCalledWith({ CalendarEventId: '42', Type: 1, Note: 'On my way' });
+  });
+
+  it('posts not attending as Type 4 with an empty note', async () => {
+    await setCalendarAttending({ calendarItemId: '42', attending: false });
+
+    expect(endpoint('/Calendar/SetCalendarAttendingStatus').post).toHaveBeenCalledWith({ CalendarEventId: '42', Type: 4, Note: '' });
+  });
+});

src/api/calendar/calendar.ts

@@ -4,17 +4,17 @@
  */
 
 import { type CalendarItemResult } from '@/models/v4/calendar/calendarItemResult';
-import { type CalendarItemResultData } from '@/models/v4/calendar/calendarItemResultData';
 import { type CalendarItemsResult } from '@/models/v4/calendar/calendarItemsResult';
 import { type CalendarItemTypesResult } from '@/models/v4/calendar/calendarItemTypesResult';
+import { type SetCalendarAttendingResult } from '@/models/v4/calendar/setCalendarAttendingResult';
 
 import { createApiEndpoint } from '../common/client';
 
-const calendarApi = createApiEndpoint('/Calendar/GetCalendarItems');
+const calendarApi = createApiEndpoint('/Calendar/GetDepartmentCalendarItems');
 const calendarItemApi = createApiEndpoint('/Calendar/GetCalendarItem');
-const calendarItemTypesApi = createApiEndpoint('/Calendar/GetCalendarItemTypes');
-const calendarItemsForDateRangeApi = createApiEndpoint('/Calendar/GetCalendarItemsForDateRange');
-const setCalendarAttendingApi = createApiEndpoint('/Calendar/SetCalendarAttending');
+const calendarItemTypesApi = createApiEndpoint('/Calendar/GetDepartmentCalendarItemTypes');
+const calendarItemsForDateRangeApi = createApiEndpoint('/Calendar/GetDepartmentCalendarItemsInRange');
+const setCalendarAttendingApi = createApiEndpoint('/Calendar/SetCalendarAttendingStatus');
 
 /**
  * Get all calendar items
@@ -28,7 +28,7 @@ export const getCalendarItems = async (): Promise<CalendarItemsResult> => {
  * Get a specific calendar item by ID
  */
 export const getCalendarItem = async (itemId: string): Promise<CalendarItemResult> => {
-  const response = await calendarItemApi.get<CalendarItemResult>({ itemId });
+  const response = await calendarItemApi.get<CalendarItemResult>({ id: itemId });
   return response.data;
 };
 
@@ -45,15 +45,19 @@ export const getCalendarItemTypes = async (): Promise<CalendarItemTypesResult> =
  */
 export const getCalendarItemsForDateRange = async (startDate: string, endDate: string): Promise<CalendarItemsResult> => {
   const response = await calendarItemsForDateRangeApi.get<CalendarItemsResult>({
-    startDate,
-    endDate,
+    start: startDate,
+    end: endDate,
   });
   return response.data;
 };
 
 /**
- * Set calendar attendance
+ * Set calendar attendance (Type 1 = attending, 4 = not attending)
  */
 export const setCalendarAttending = async ({ calendarItemId, attending, note }: { calendarItemId: string; attending: boolean; note?: string }): Promise<void> => {
-  await setCalendarAttendingApi.post({ itemId: calendarItemId, attending, note });
+  await setCalendarAttendingApi.post<SetCalendarAttendingResult>({
+    CalendarEventId: calendarItemId,
+    Type: attending === true ? 1 : 4,
+    Note: note || '',
+  });
 };

src/api/checkIn/__tests__/checkInTimers.test.ts

@@ -0,0 +1,25 @@
+jest.mock('../../common/client', () => ({
+  createApiEndpoint: jest.fn(() => ({
+    get: jest.fn(),
+    post: jest.fn(),
+    put: jest.fn(),
+    delete: jest.fn(),
+  })),
+}));
+
+import { createApiEndpoint } from '../../common/client';
+import { toggleCallTimers } from '../checkInTimers';
+
+const mockCreateApiEndpoint = createApiEndpoint as jest.MockedFunction<typeof createApiEndpoint>;
+
+describe('toggleCallTimers', () => {
+  it('sends callId and enabled in the query string with an empty body', async () => {
+    const endpoint = { get: jest.fn(), post: jest.fn(), put: jest.fn().mockResolvedValue({ data: { Id: '' } }), delete: jest.fn() };
+    mockCreateApiEndpoint.mockReturnValueOnce(endpoint as unknown as ReturnType<typeof createApiEndpoint>);
+
+    await toggleCallTimers(101, false);
+
+    expect(mockCreateApiEndpoint).toHaveBeenLastCalledWith('/CheckInTimers/ToggleCallTimers?callId=101&enabled=false');
+    expect(endpoint.put).toHaveBeenCalledWith({});
+  });
+});

src/api/checkIn/checkInTimers.ts

@@ -10,7 +10,6 @@ const getTimerStatusesApi = createApiEndpoint('/CheckInTimers/GetTimerStatuses')
 const getTimersForCallApi = createApiEndpoint('/CheckInTimers/GetTimersForCall');
 const performCheckInApi = createApiEndpoint('/CheckInTimers/PerformCheckIn');
 const getCheckInHistoryApi = createApiEndpoint('/CheckInTimers/GetCheckInHistory');
-const toggleCallTimersApi = createApiEndpoint('/CheckInTimers/ToggleCallTimers');
 const getCallPersonnelCheckInStatusesApi = createApiEndpoint('/CheckInTimers/GetCallPersonnelCheckInStatuses');
 
 export const getTimerStatuses = async (callId: number) => {
@@ -85,8 +84,10 @@ export const getCheckInHistory = async (callId: number) => {
   return response.data;
 };
 
+// The server binds callId and enabled from the query string, not the body.
 export const toggleCallTimers = async (callId: number, enabled: boolean) => {
-  const response = await toggleCallTimersApi.put<PerformCheckInResult>({ callId, enabled });
+  const endpoint = createApiEndpoint(`/CheckInTimers/ToggleCallTimers?callId=${encodeURIComponent(callId)}&enabled=${encodeURIComponent(enabled)}`);
+  const response = await endpoint.put<PerformCheckInResult>({});
   return response.data;
 };
 

src/api/common/__tests__/client-refresh.integration.test.ts

@@ -69,7 +69,7 @@ describe('API requests using the shared token refresh engine', () => {
 
   it('ends a rejected restored session once and stops all protected requests', async () => {
     useAuthStore.setState({ refreshTokenExpiresOn: String(Date.now() - 1000) });
-    (refreshTokenRequest as jest.Mock).mockRejectedValue(new AxiosError('Rejected', 'ERR_BAD_REQUEST', undefined, undefined, { status: 400 } as AxiosResponse));
+    (refreshTokenRequest as jest.Mock).mockRejectedValue(new AxiosError('Rejected', 'ERR_BAD_REQUEST', undefined, undefined, { status: 400, data: { error: 'invalid_grant' } } as AxiosResponse));
 
     const results = await Promise.allSettled([api.get('/Calls/GetActiveCalls'), api.get('/Units/GetAllUnitsInfos')]);
 
@@ -81,4 +81,19 @@ describe('API requests using the shared token refresh engine', () => {
     }
     expect(jest.getTimerCount()).toBe(0);
   });
+
+  it('keeps a restored session and retries when the token endpoint answers a 400 that is not invalid_grant', async () => {
+    useAuthStore.setState({ refreshTokenExpiresOn: String(Date.now() - 1000) });
+    (refreshTokenRequest as jest.Mock).mockRejectedValue(new AxiosError('Bad Request', 'ERR_BAD_REQUEST', undefined, undefined, { status: 400, data: { error: 'invalid_request' } } as AxiosResponse));
+
+    const results = await Promise.allSettled([api.get('/Calls/GetActiveCalls'), api.get('/Units/GetAllUnitsInfos')]);
+
+    expect(refreshTokenRequest).toHaveBeenCalledTimes(1);
+    expect(adapter).not.toHaveBeenCalled();
+    expect(useAuthStore.getState()).toMatchObject({ status: 'signedIn', accessToken: 'old-access', refreshToken: 'old-refresh' });
+    for (const result of results) {
+      expect(result).toMatchObject({ status: 'rejected' });
+    }
+    expect(jest.getTimerCount()).toBe(1);
+  });
 });

src/api/shifts/__tests__/shifts.test.ts

@@ -0,0 +1,71 @@
+interface MockEndpoint {
+  get: jest.Mock;
+  post: jest.Mock;
+}
+
+// The module under test creates its endpoints at import time, so the registry lives inside the mock factory.
+jest.mock('../../common/client', () => {
+  const endpoints: Record<string, { get: jest.Mock; post: jest.Mock }> = {};
+  return {
+    __endpoints: endpoints,
+    createApiEndpoint: (path: string) => {
+      const api = { get: jest.fn(), post: jest.fn() };
+      endpoints[path] = api;
+      return api;
+    },
+  };
+});
+
+import { getAllShifts, getShift, getShiftDay, getTodaysShifts, signupForShiftDay } from '../shifts';
+
+const mockEndpoints: Record<string, MockEndpoint> = jest.requireMock('../../common/client').__endpoints;
+
+const endpoint = (path: string) => {
+  const api = mockEndpoints[path];
+  if (!api) throw new Error(`endpoint ${path} was not created`);
+  return api;
+};
+
+describe('shifts api', () => {
+  beforeEach(() => {
+    Object.values(mockEndpoints).forEach((api) => {
+      api.get.mockReset().mockResolvedValue({ data: { Data: [] } });
+      api.post.mockReset().mockResolvedValue({ data: { Id: '' } });
+    });
+  });
+
+  it('only creates routes that exist on the v4 Shifts controller', () => {
+    expect(Object.keys(mockEndpoints).sort()).toEqual(['/Shifts/GetShift', '/Shifts/GetShiftDay', '/Shifts/GetShifts', '/Shifts/GetTodaysShifts', '/Shifts/SignupForShiftDay']);
+  });
+
+  it('reads all shifts from GetShifts', async () => {
+    await getAllShifts();
+
+    expect(endpoint('/Shifts/GetShifts').get).toHaveBeenCalledWith();
+  });
+
+  it('sends the shift id as id', async () => {
+    await getShift('7');
+
+    expect(endpoint('/Shifts/GetShift').get).toHaveBeenCalledWith({ id: '7' });
+  });
+
+  it('sends the shift day id as id', async () => {
+    await getShiftDay('12');
+
+    expect(endpoint('/Shifts/GetShiftDay').get).toHaveBeenCalledWith({ id: '12' });
+  });
+
+  it("reads today's shift days", async () => {
+    await getTodaysShifts();
+
+    expect(endpoint('/Shifts/GetTodaysShifts').get).toHaveBeenCalledWith();
+  });
+
+  it('posts ShiftDaySignupInput with numeric ids', async () => {
+    endpoint('/Shifts/SignupForShiftDay').post.mockResolvedValue({ data: { Id: '99' } });
+
+    await expect(signupForShiftDay('12', '3')).resolves.toEqual({ Id: '99' });
+    expect(endpoint('/Shifts/SignupForShiftDay').post).toHaveBeenCalledWith({ ShiftDayId: 12, GroupId: 3 });
+  });
+});