Merge pull request #2843 from DUC750/fix/mobile-exercise-time-and-duration

fix(workouts): give each exercise its own time and duration in live sessions

Author: nalvazhvu

SparkyFitnessMobile/__tests__/utils/workoutSession.test.ts

@@ -2346,7 +2346,7 @@ describe('workoutSession', () => {
       const startedAt = Date.UTC(2026, 2, 20, 10, 0, 0);
       const min = (n: number) => startedAt + n * 60_000;
 
-      it('splits start→last-completion across exercises by completed-set count', () => {
+      it('gives each exercise the time up to its own completed sets', () => {
         const session = makePreset({
           exercises: [
             makeExercise({
@@ -2368,8 +2368,83 @@ describe('workoutSession', () => {
           {},
           startedAt
         );
-        expect(payload[0].duration_minutes).toBe(20); // 30 × 2/3
-        expect(payload[1].duration_minutes).toBe(10); // 30 × 1/3
+        expect(payload[0].duration_minutes).toBe(12); // start → 12 min
+        expect(payload[1].duration_minutes).toBe(18); // 12 → 30 min
+      });
+
+      it('splits alternating superset sets by their own gaps', () => {
+        const session = makePreset({
+          exercises: [
+            makeExercise({
+              superset_group: 1,
+              sets: [makeSet({ id: 101 }), makeSet({ id: 102, set_number: 2 })],
+            }),
+            makeExercise({
+              id: ENTRY_B,
+              exercise_id: EX_2,
+              superset_group: 1,
+              sets: [makeSet({ id: 201 }), makeSet({ id: 202, set_number: 2 })],
+            }),
+          ],
+        });
+
+        const completed = {
+          '101': min(3),
+          '201': min(5),
+          '102': min(8),
+          '202': min(11),
+        };
+        const payload = buildSessionExercisesPayload(
+          session,
+          completed,
+          {},
+          startedAt
+        );
+        expect(payload[0].duration_minutes).toBe(6); // 0→3 + 5→8
+        expect(payload[1].duration_minutes).toBe(5); // 3→5 + 8→11
+      });
+
+      it('stamps entry_time with the local start of each exercise', () => {
+        const localStart = new Date(2026, 2, 20, 10, 0, 0).getTime();
+        const at = (n: number) => localStart + n * 60_000;
+        const session = makePreset({
+          exercises: [
+            makeExercise({
+              sets: [makeSet({ id: 101 }), makeSet({ id: 102, set_number: 2 })],
+            }),
+            makeExercise({
+              id: ENTRY_B,
+              exercise_id: EX_2,
+              sets: [makeSet({ id: 201 })],
+            }),
+            makeExercise({
+              id: 'cccccccc-cccc-4ccc-8ccc-cccccccccccc',
+              sets: [makeSet({ id: 301 })],
+            }),
+          ],
+        });
+        const payload = buildSessionExercisesPayload(
+          session,
+          { '101': at(4), '102': at(12), '201': at(19) },
+          {},
+          localStart
+        );
+        expect(payload[0].entry_time).toBe('10:00');
+        expect(payload[1].entry_time).toBe('10:12');
+        // Nothing completed yet: omitted so the server keeps its value.
+        expect('entry_time' in payload[2]).toBe(false);
+      });
+
+      it('omits entry_time without a workout start', () => {
+        const session = makePreset({
+          exercises: [makeExercise({ sets: [makeSet({ id: 101 })] })],
+        });
+        const payload = buildSessionExercisesPayload(
+          session,
+          { '101': min(10) },
+          {}
+        );
+        expect('entry_time' in payload[0]).toBe(false);
       });
 
       it('gives an exercise with no completed sets zero duration', () => {

SparkyFitnessMobile/src/utils/workoutSession.ts

@@ -1594,7 +1594,7 @@ export function buildSessionExercisesPayload(
   prSetIds: PrSetMap,
   startedAtMs?: number | null
 ): PresetSessionExerciseRequest[] {
-  const durationByEntryId = buildSessionDurationMinutes(
+  const timing = buildSessionExerciseTiming(
     session,
     completedSetIds,
     startedAtMs
@@ -1608,7 +1608,11 @@ export function buildSessionExercisesPayload(
       resolveSnapshotModality(exercise.exercise_snapshot)
     )
       ? setsDurationMinutes(exercise.sets)
-      : (durationByEntryId?.get(exercise.id) ?? exercise.duration_minutes ?? 0),
+      : (timing?.durations.get(exercise.id) ?? exercise.duration_minutes ?? 0),
+    // Omitted when nothing was completed yet, so the server keeps what it has.
+    ...(timing?.startTimes.has(exercise.id)
+      ? { entry_time: timing.startTimes.get(exercise.id) }
+      : {}),
     notes: exercise.notes ?? null,
     superset_group: exercise.superset_group ?? null,
     sets: exercise.sets.map((set, setIndex) => {
@@ -1638,12 +1642,47 @@ export function buildSessionDurationMinutes(
   completedSetIds: CompletedSetMap,
   startedAtMs?: number | null
 ): Map<string, number> | null {
+  return (
+    buildSessionExerciseTiming(session, completedSetIds, startedAtMs)
+      ?.durations ?? null
+  );
+}
+
+export interface SessionExerciseTiming {
+  /** Minutes per non-cardio entry; entries absent here keep their stored value. */
+  durations: Map<string, number>;
+  /** Local wall-clock 'HH:MM' at which each entry's first timed span began. */
+  startTimes: Map<string, string>;
+}
+
+/** Local wall-clock 'HH:MM' for an instant, the format entry_time expects. */
+export function toEntryTimeString(ms: number): string {
+  const date = new Date(ms);
+  const pad = (n: number) => n.toString().padStart(2, '0');
+  return `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+/**
+ * Walks the completed strength sets in the order they were ticked off and
+ * gives each gap (previous completion, or the workout start, up to this
+ * completion) to the exercise the set belongs to. That is the time spent on
+ * that exercise's set plus the rest before it, so supersets and exercises
+ * done out of order each get their own share. The per-entry durations still
+ * add up to start→last completion.
+ *
+ * An entry's start time is the beginning of its first gap. Cardio entries
+ * are left out: their duration is the sum of their set durations.
+ */
+export function buildSessionExerciseTiming(
+  session: PresetSessionResponse,
+  completedSetIds: CompletedSetMap,
+  startedAtMs?: number | null
+): SessionExerciseTiming | null {
   if (startedAtMs == null) return null;
 
-  let lastCompletedMs = 0;
-  let totalCompleted = 0;
   let anyCompletedAfterStart = false;
   const completedCountByEntryId = new Map<string, number>();
+  const timeline: { ms: number; entryId: string }[] = [];
   for (const exercise of session.exercises) {
     const cardio = isCardioModality(
       resolveSnapshotModality(exercise.exercise_snapshot)
@@ -1655,28 +1694,34 @@ export function buildSessionDurationMinutes(
       if (ms > startedAtMs) anyCompletedAfterStart = true;
       if (cardio) continue;
       count++;
-      totalCompleted++;
-      if (ms > lastCompletedMs) lastCompletedMs = ms;
+      // Completions before the start (a resumed session) can't be placed on
+      // this clock; their entry keeps its stored duration.
+      if (ms > startedAtMs) timeline.push({ ms, entryId: exercise.id });
     }
     if (!cardio) completedCountByEntryId.set(exercise.id, count);
   }
-  if (totalCompleted === 0 || lastCompletedMs <= startedAtMs) {
-    if (!anyCompletedAfterStart) return null;
-    const zeroed = new Map<string, number>();
-    for (const [entryId, count] of completedCountByEntryId) {
-      if (count === 0) zeroed.set(entryId, 0);
-    }
-    return zeroed;
+  if (!anyCompletedAfterStart) return null;
+
+  const durations = new Map<string, number>();
+  const startTimes = new Map<string, string>();
+  for (const [entryId, count] of completedCountByEntryId) {
+    if (count === 0) durations.set(entryId, 0);
   }
 
-  const totalMinutes = (lastCompletedMs - startedAtMs) / 60_000;
-  const byEntryId = new Map<string, number>();
-  for (const exercise of session.exercises) {
-    const count = completedCountByEntryId.get(exercise.id) ?? 0;
-    const share = (totalMinutes * count) / totalCompleted;
-    byEntryId.set(exercise.id, Math.round(share * 10) / 10);
+  timeline.sort((a, b) => a.ms - b.ms);
+  const spanMs = new Map<string, number>();
+  let previousMs = startedAtMs;
+  for (const { ms, entryId } of timeline) {
+    spanMs.set(entryId, (spanMs.get(entryId) ?? 0) + (ms - previousMs));
+    if (!startTimes.has(entryId)) {
+      startTimes.set(entryId, toEntryTimeString(previousMs));
+    }
+    previousMs = ms;
+  }
+  for (const [entryId, ms] of spanMs) {
+    durations.set(entryId, Math.round((ms / 60_000) * 10) / 10);
   }
-  return byEntryId;
+  return { durations, startTimes };
 }
 
 export const WORKOUT_LONG_GAP_MINUTES = 30;

SparkyFitnessServer/services/exerciseService.ts

@@ -2305,7 +2305,8 @@ async function updateGroupedWorkoutSession(
                 preparedEntry.calories_burned
               ),
               entry_date: targetEntryDate,
-              entry_time: ex.entry_time ?? null,
+              // Preserve when omitted; explicit null clears the time of day.
+              entry_time: ex.entry_time,
             },
             actingUserId,
             existingById.get(ex.id)?.source ?? existingSession.source

SparkyFitnessServer/tests/exerciseService.groupedWorkouts.test.ts

@@ -1349,6 +1349,69 @@ describe('exerciseService grouped workouts', () => {
       expect(updateCalls[1][3]).toMatchObject({ superset_group: null });
     });
 
+    it('passes entry_time through the reconcile path', async () => {
+      setupExistingSession();
+
+      await exerciseService.updateGroupedWorkoutSession(
+        'user-1',
+        'actor-1',
+        'preset-entry-1',
+        {
+          exercises: [
+            {
+              id: 'entry-a',
+              exercise_id: exerciseAId,
+              sort_order: 0,
+              duration_minutes: 12,
+              entry_time: '15:59',
+              sets: [],
+            },
+            {
+              id: 'entry-b',
+              exercise_id: exerciseBId,
+              sort_order: 1,
+              duration_minutes: 0,
+              entry_time: null,
+              sets: [],
+            },
+          ],
+        }
+      );
+
+      const updateCalls = vi.mocked(
+        exerciseEntryDb._updateExerciseEntryWithClient
+      ).mock.calls;
+      expect(updateCalls[0][3]).toMatchObject({ entry_time: '15:59' });
+      expect(updateCalls[1][3]).toMatchObject({ entry_time: null });
+    });
+
+    it('leaves entry_time undefined when the reconcile payload omits it', async () => {
+      setupExistingSession();
+
+      await exerciseService.updateGroupedWorkoutSession(
+        'user-1',
+        'actor-1',
+        'preset-entry-1',
+        {
+          exercises: [
+            {
+              id: 'entry-a',
+              exercise_id: exerciseAId,
+              sort_order: 0,
+              duration_minutes: 0,
+              sets: [],
+            },
+          ],
+        }
+      );
+
+      // undefined makes _updateExerciseEntryWithClient keep the stored time.
+      const updateCalls = vi.mocked(
+        exerciseEntryDb._updateExerciseEntryWithClient
+      ).mock.calls;
+      expect(updateCalls[0][3].entry_time).toBeUndefined();
+    });
+
     it('carries superset_group through the delete-and-recreate path', async () => {
       setupExistingSession();
       // @ts-expect-error TS(2339): mockResolvedValue on mocked fn