@wger-project/react-components 25.10.16

package/src/services/profile.ts

@@ -0,0 +1,49 @@
+import axios from 'axios';
+import { EditProfileParams, Profile } from "components/User/models/profile";
+import { ApiPath } from "utils/consts";
+import { makeHeader, makeUrl } from "utils/url";
+
+export const API_PROFILE_PATH = 'userprofile';
+
+
+/*
+ * Loads the user's profile
+ */
+export const getProfile = async (): Promise<Profile | null> => {
+    const url = makeUrl(API_PROFILE_PATH);
+
+    // We need to manually catch the error, otherwise react-query will retry the
+    // query and report an error in the end
+    try {
+        const response = await axios.get(
+            url,
+            { headers: makeHeader() }
+        );
+        return Profile.fromJson(response.data);
+    } catch {
+        return null;
+    }
+};
+
+/*
+ * Edits the user's profile
+ */
+export const editProfile = async (data: Partial<EditProfileParams>): Promise<Profile> => {
+
+    const { weightRounding, repetitionsRounding, ...rest } = data;
+    const payload = {
+        ...rest,
+        // eslint-disable-next-line camelcase
+        ...(weightRounding !== undefined && { weight_rounding: weightRounding }),
+        // eslint-disable-next-line camelcase
+        ...(repetitionsRounding !== undefined && { repetition_rounding: repetitionsRounding }),
+    };
+
+    const response = await axios.post(
+        makeUrl(ApiPath.API_PROFILE_PATH),
+        payload,
+        { headers: makeHeader() }
+    );
+
+    return Profile.fromJson(response.data);
+};

package/src/services/responseType.ts

@@ -0,0 +1,35 @@
+import { Exercise } from "components/Exercises/models/exercise";
+
+export interface ResponseType<T> {
+    count: number,
+    next: number | null,
+    previous: number | null,
+    results: T[]
+}
+
+export interface ExerciseSearchResponse {
+    value: string,
+    data: {
+        id: number,
+        base_id: number,
+        name: string,
+        category: string,
+        image: string | null,
+        image_thumbnail: string | null,
+    },
+    exercise?: Exercise
+}
+
+export interface ExerciseSearchType {
+    suggestions: ExerciseSearchResponse[];
+}
+
+export interface IngredientSearchResponse {
+    value: string,
+    data: {
+        id: number,
+        name: string,
+        image: string | null,
+        image_thumbnail: string | null,
+    }
+}

package/src/services/routine.test.ts

@@ -0,0 +1,195 @@
+import axios from "axios";
+import { Day } from "components/WorkoutRoutines/models/Day";
+import { Routine } from "components/WorkoutRoutines/models/Routine";
+import { SetConfigData } from "components/WorkoutRoutines/models/SetConfigData";
+import { WorkoutLog } from "components/WorkoutRoutines/models/WorkoutLog";
+import { getRoutinesShallow } from "services";
+import { getRoutineDayDataAllIterations } from "services/routine";
+import { getRoutineLogs } from "services/workoutLogs";
+import { getRoutineRepUnits, getRoutineWeightUnits } from "services/workoutUnits";
+import {
+    responseApiWorkoutRoutine,
+    responseRoutineDayData,
+    responseRoutineLogs,
+    testRepUnit1,
+    testRepUnit2,
+    testWeightUnit1,
+    testWeightUnit2
+} from "tests/workoutRoutinesTestData";
+
+jest.mock("axios");
+jest.mock("services/workoutUnits");
+jest.mock("services/exercise");
+
+describe("workout routine service tests", () => {
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+
+    test('GET the routine data - shallow', async () => {
+
+        // Arrange
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ data: responseApiWorkoutRoutine }));
+
+        // Act
+        const result = await getRoutinesShallow();
+
+        // Assert
+        expect(axios.get).toHaveBeenCalledTimes(1);
+        expect(result).toStrictEqual([
+            new Routine({
+                id: 1,
+                name: 'My first routine!',
+                description: 'Well rounded full body routine',
+                created: new Date("2022-01-01T12:34:30+01:00"),
+                start: new Date("2024-03-01T00:00:00.000Z"),
+                end: new Date("2024-04-30T00:00:00.000Z"),
+                fitInWeek: false,
+            }),
+            new Routine({
+                id: 2,
+                name: 'Beach body',
+                description: 'Train only arms and chest, no legs!!!',
+                created: new Date("2023-01-01T17:22:22+02:00"),
+                start: new Date("2024-03-01T00:00:00.000Z"),
+                end: new Date("2024-04-30T00:00:00.000Z"),
+                fitInWeek: false,
+            }),
+        ]);
+        expect(result[0].days.length).toEqual(0);
+        expect(result[1].days.length).toEqual(0);
+    });
+
+
+    test('GET the routine logs', async () => {
+
+        // Arrange
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ data: responseRoutineLogs }));
+        (getRoutineRepUnits as jest.Mock).mockImplementation(() => Promise.resolve([testRepUnit1, testRepUnit2]));
+        (getRoutineWeightUnits as jest.Mock).mockImplementation(() => Promise.resolve([testWeightUnit1, testWeightUnit2]));
+
+        // Act
+        const result = await getRoutineLogs(1);
+
+        // Assert
+        expect(axios.get).toHaveBeenCalledTimes(1);
+        expect(result).toStrictEqual([
+            new WorkoutLog({
+                id: 2,
+                routineId: 1,
+                date: new Date("2023-05-10"),
+                iteration: 1,
+                exerciseId: 100,
+                slotEntryId: 2,
+                repetitionsUnitId: 1,
+                repetitions: 12,
+                repetitionsTarget: 12,
+                weight: 10.00,
+                weightUnitId: 1,
+                rir: null,
+                repetitionsUnit: testRepUnit1,
+                weightUnit: testWeightUnit1,
+            }),
+
+            new WorkoutLog({
+                id: 1,
+                routineId: 1,
+                date: new Date("2023-05-13"),
+                iteration: 1,
+                exerciseId: 100,
+                slotEntryId: 2,
+                repetitionsUnitId: 1,
+                repetitions: 10,
+                weight: 20,
+                weightTarget: 20,
+                weightUnitId: 1,
+                rir: 1.5,
+                rirTarget: 1,
+                repetitionsUnit: testRepUnit1,
+                weightUnit: testWeightUnit1,
+            }),
+        ]);
+    });
+
+    test('GET the routine day data', async () => {
+        // Arrange
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ data: responseRoutineDayData }));
+
+        // Act
+        const result = await getRoutineDayDataAllIterations(1);
+
+        // Assert
+        expect(axios.get).toHaveBeenCalledTimes(1);
+
+        expect(result[0].iteration).toStrictEqual(42);
+        expect(result[0].date).toStrictEqual(new Date('2024-04-01'));
+        expect(result[0].label).toStrictEqual('first label');
+        expect(result[0].day).toStrictEqual(
+            new Day({
+                id: 100,
+                routineId: null,
+                order: 5,
+                name: 'Push day',
+                description: '',
+                isRest: false,
+                needLogsToAdvance: false,
+                type: 'custom',
+                config: null
+            })
+        );
+        expect(result[0].slots[0].comment).toEqual('Push set 1');
+        expect(result[0].slots[0].isSuperset).toEqual(true);
+        expect(result[0].slots[0].exerciseIds).toEqual([9, 12]);
+        expect(result[0].slots[0].setConfigs[0]).toEqual(
+            new SetConfigData({
+                    exerciseId: 9,
+                    slotEntryId: 1000,
+                    type: "dropset",
+                    nrOfSets: 5,
+                    maxNrOfSets: null,
+                    weight: 100,
+                    maxWeight: 120,
+                    weightUnitId: 1,
+                    weightRounding: 1.25,
+                    repetitions: 10,
+                    maxRepetitions: null,
+                    repetitionsUnitId: 1,
+                    repetitionsRounding: 1,
+                    rir: 2,
+                    maxRir: null,
+                    rpe: 8,
+                    restTime: 120,
+                    maxRestTime: 180,
+                    textRepr: "5 Sets, 10 × 100-120 kg @ 2 RiR",
+                    comment: "foo"
+                },
+            )
+        );
+        expect(result[0].slots[0].setConfigs[1]).toEqual(
+            new SetConfigData({
+                    exerciseId: 12,
+                    slotEntryId: 1001,
+                    type: "normal",
+                    nrOfSets: 3,
+                    maxNrOfSets: null,
+                    weight: 90,
+                    maxWeight: null,
+                    weightUnitId: 1,
+                    weightRounding: 1.25,
+                    repetitions: 12,
+                    maxRepetitions: null,
+                    repetitionsUnitId: 1,
+                    repetitionsRounding: 1,
+                    rir: 2,
+                    rpe: 8,
+                    restTime: 120,
+                    maxRestTime: null,
+                    textRepr: "3 Sets, 12 × 90 kg @ 2 RiR",
+                    comment: "bar"
+                },
+            )
+        );
+    });
+});

package/src/services/routine.ts

@@ -0,0 +1,250 @@
+import axios from 'axios';
+import { Exercise } from "components/Exercises/models/exercise";
+import { Day } from "components/WorkoutRoutines/models/Day";
+import { RoutineStatsData, RoutineStatsDataAdapter } from "components/WorkoutRoutines/models/LogStats";
+import { Routine } from "components/WorkoutRoutines/models/Routine";
+import { RoutineDayData } from "components/WorkoutRoutines/models/RoutineDayData";
+import { RoutineLogData, RoutineLogDataAdapter } from "components/WorkoutRoutines/models/RoutineLogData";
+import { getExercise } from "services/exercise";
+import { getRoutineRepUnits, getRoutineWeightUnits } from "services/workoutUnits";
+import { ApiPath } from "utils/consts";
+import { makeHeader, makeUrl } from "utils/url";
+import { ResponseType } from "./responseType";
+
+export const ROUTINE_API_STRUCTURE_PATH = 'structure';
+export const ROUTINE_API_LOGS_PATH = 'logs';
+export const ROUTINE_API_STATS_PATH = 'stats';
+export const ROUTINE_API_ALL_ITERATION_DISPLAY = 'date-sequence-display';
+
+
+/*
+ * Processes a routine with all sub-objects
+ */
+const exerciseMap: { [id: number]: Exercise } = {};
+
+export const processRoutine = async (id: number): Promise<Routine> => {
+
+    const response = await axios.get(
+        makeUrl(ApiPath.ROUTINE, { id: id }),
+        { headers: makeHeader() }
+    );
+    const routine = Routine.fromJson(response.data);
+
+    const responses = await Promise.all([
+        getRoutineRepUnits(),
+        getRoutineWeightUnits(),
+        getRoutineDayDataAllIterations(id),
+        getRoutineStructure(id),
+
+    ]);
+    const repsUnits = responses[0];
+    const weightUnits = responses[1];
+    const dayDataAllIterations = responses[2];
+    const dayStructure = responses[3];
+
+
+    // Collect all unique exercise IDs and load the data in bulk
+    const exerciseIds = new Set<number>();
+    for (const dayData of dayDataAllIterations.filter(d => d.day !== null && d.iteration === 1)) {
+        for (const slotData of dayData.slots) {
+            for (const setData of slotData.setConfigs) {
+                exerciseIds.add(setData.exerciseId);
+            }
+        }
+    }
+    const exercisePromises = Array.from(exerciseIds).map(id => getExercise(id));
+    const exercises = await Promise.all(exercisePromises);
+    exercises.forEach(exercise => {
+        exerciseMap[exercise.id!] = exercise;
+    });
+
+    // Collect and load all exercises for the workout
+    for (const dayData of dayDataAllIterations) {
+        for (const slotData of dayData.slots) {
+            for (const setData of slotData.setConfigs) {
+                setData.exercise = exerciseMap[setData.exerciseId];
+                if (setData.repetitionsUnitId !== null) {
+                    setData.repetitionsUnit = repsUnits.find(r => r.id === setData.repetitionsUnitId) ?? null;
+                }
+
+                if (setData.weightUnitId !== null) {
+                    setData.weightUnit = weightUnits.find(w => w.id === setData.weightUnitId) ?? null;
+                }
+            }
+
+            for (const exerciseId of slotData.exerciseIds) {
+                slotData.exercises?.push(exerciseMap[exerciseId]);
+            }
+        }
+    }
+
+    for (const day of dayStructure) {
+        for (const slot of day.slots) {
+            for (const slotEntry of slot.entries) {
+                slotEntry.exercise = exerciseMap[slotEntry.exerciseId];
+
+                if (slotEntry.repetitionUnitId !== null) {
+                    slotEntry.repetitionUnit = repsUnits.find(r => r.id === slotEntry.repetitionUnitId) ?? null;
+                }
+
+                if (slotEntry.weightUnitId !== null) {
+                    slotEntry.weightUnit = weightUnits.find(w => w.id === slotEntry.weightUnitId) ?? null;
+                }
+            }
+        }
+    }
+
+    routine.dayData = dayDataAllIterations;
+    routine.days = dayStructure;
+
+    return routine;
+};
+
+
+/*
+ * Retrieves all routines
+ *
+ * Note: this returns all the data, including all sub-objects
+ */
+export const getRoutines = async (): Promise<Routine[]> => {
+    const url = makeUrl(ApiPath.ROUTINE, { query: { 'is_public': false } });
+    const response = await axios.get<ResponseType<Routine>>(
+        url,
+        { headers: makeHeader() }
+    );
+
+    const out: Routine[] = [];
+    for (const routineData of response.data.results) {
+        out.push(await processRoutine(routineData.id!));
+    }
+    return out;
+};
+
+/*
+ * Returns the current active routine
+ *
+ * Note that at the moment this is simply the newest one
+ */
+export const getActiveRoutine = async (): Promise<null | Routine> => {
+    const url = makeUrl(ApiPath.ROUTINE, { query: { 'limit': '1', 'is_template': false } });
+
+    const response = await axios.get<ResponseType<Routine>>(
+        url,
+        { headers: makeHeader() }
+    );
+
+    if (response.data.count === 0) {
+        return null;
+    }
+
+    return await processRoutine(response.data.results[0].id!);
+};
+
+export const getRoutine = async (id: number): Promise<Routine> => {
+    return await processRoutine(id);
+};
+
+/*
+ * Retrieves all routines
+ *
+ * Note: strictly only the routine data, no days or any other sub-objects
+ */
+export const getRoutinesShallow = async (): Promise<Routine[]> => {
+    const url = makeUrl(ApiPath.ROUTINE, { query: { 'is_public': false } });
+    const response = await axios.get<ResponseType<Routine>>(
+        url,
+        { headers: makeHeader() }
+    );
+
+    return response.data.results.map(routineData => Routine.fromJson(routineData)).filter(routine => routine.isNotTemplate);
+};
+
+export const getPrivateTemplatesShallow = async (): Promise<Routine[]> => {
+    const url = makeUrl(ApiPath.PRIVATE_TEMPLATE);
+    const response = await axios.get<ResponseType<Routine>>(
+        url,
+        { headers: makeHeader() }
+    );
+
+    return response.data.results.map(routineData => Routine.fromJson(routineData));
+};
+
+export const getPublicTemplatesShallow = async (): Promise<Routine[]> => {
+    const url = makeUrl(ApiPath.PUBLIC_TEMPLATE);
+    const response = await axios.get<ResponseType<Routine>>(
+        url,
+        { headers: makeHeader() }
+    );
+
+    return response.data.results.map(routineData => Routine.fromJson(routineData));
+};
+
+export const addRoutine = async (routine: Routine): Promise<Routine> => {
+    const response = await axios.post(
+        makeUrl(ApiPath.ROUTINE,),
+        routine.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return Routine.fromJson(response.data);
+};
+
+export const editRoutine = async (routine: Routine): Promise<Routine> => {
+    const response = await axios.patch(
+        makeUrl(ApiPath.ROUTINE, { id: routine.id! }),
+        routine.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return Routine.fromJson(response.data);
+};
+
+export const deleteRoutine = async (id: number): Promise<number> => {
+    const response = await axios.delete(
+        makeUrl(ApiPath.ROUTINE, { id: id }),
+        { headers: makeHeader() }
+    );
+
+    return response.status;
+};
+
+
+export const getRoutineDayDataAllIterations = async (routineId: number): Promise<RoutineDayData[]> => {
+    const response = await axios.get(
+        makeUrl(ApiPath.ROUTINE, { id: routineId, objectMethod: ROUTINE_API_ALL_ITERATION_DISPLAY }),
+        { headers: makeHeader() }
+    );
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return response.data.map((data: any) => RoutineDayData.fromJson(data));
+};
+
+export const getRoutineStructure = async (routineId: number): Promise<Day[]> => {
+    const response = await axios.get(
+        makeUrl(ApiPath.ROUTINE, { id: routineId, objectMethod: ROUTINE_API_STRUCTURE_PATH }),
+        { headers: makeHeader() }
+    );
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return response.data.days.map((data: any) => Day.fromJson(data));
+};
+
+export const getRoutineLogData = async (routineId: number): Promise<RoutineLogData[]> => {
+    const response = await axios.get(
+        makeUrl(ApiPath.ROUTINE, { id: routineId, objectMethod: ROUTINE_API_LOGS_PATH }),
+        { headers: makeHeader() }
+    );
+
+    const adapter = new RoutineLogDataAdapter();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return response.data.map((data: any) => adapter.fromJson(data));
+};
+
+export const getRoutineStatisticsData = async (routineId: number): Promise<RoutineStatsData> => {
+    const response = await axios.get(
+        makeUrl(ApiPath.ROUTINE, { id: routineId, objectMethod: ROUTINE_API_STATS_PATH }),
+        { headers: makeHeader() }
+    );
+
+    return new RoutineStatsDataAdapter().fromJson(response.data);
+};

package/src/services/session.test.ts

@@ -0,0 +1,157 @@
+import axios from "axios";
+import { getSessions } from "services";
+import * as exerciseService from "services/exercise";
+import { testExerciseBenchPress, testExerciseSquats } from "tests/exerciseTestdata";
+
+jest.mock("axios");
+jest.mock("services/exercise");
+
+describe("Session service tests", () => {
+    beforeEach(() => {
+        jest.resetAllMocks();
+    });
+
+    test('Loads sessions with associated logs and exercises', async () => {
+        // Arrange
+        (axios.get as jest.Mock).mockImplementationOnce(() => {
+            return Promise.resolve({
+                data: {
+                    count: 2,
+                    next: null,
+                    previous: null,
+                    results: [
+                        {
+                            "id": 4072327,
+                            "date": "2025-08-07T00:00:00+02:00",
+                            "session": 24284,
+                            "routine": 39764,
+                            "iteration": 1,
+                            "slot_entry": 316691,
+                            "next_log": null,
+                            "exercise": 200,
+                            "repetitions_unit": 1,
+                            "repetitions": "2.00",
+                            "repetitions_target": "1.00",
+                            "weight_unit": 1,
+                            "weight": "33.00",
+                            "weight_target": null,
+                            "rir": "0.5",
+                            "rir_target": null,
+                            "rest": 167,
+                            "rest_target": null
+                        },
+                        {
+                            "id": 4072329,
+                            "date": "2025-08-07T00:00:00+02:00",
+                            "session": 24284,
+                            "routine": 39764,
+                            "iteration": 1,
+                            "slot_entry": 316693,
+                            "next_log": null,
+                            "exercise": 201,
+                            "repetitions_unit": 1,
+                            "repetitions": "2.00",
+                            "repetitions_target": "3.00",
+                            "weight_unit": 1,
+                            "weight": "46.00",
+                            "weight_target": null,
+                            "rir": "1.0",
+                            "rir_target": null,
+                            "rest": 178,
+                            "rest_target": null
+                        },
+                    ]
+                }
+            });
+        });
+
+        (axios.get as jest.Mock).mockImplementationOnce(() => {
+            return Promise.resolve({
+                data: {
+                    count: 1,
+                    next: null,
+                    previous: null,
+                    results: [
+                        {
+                            "id": 24284,
+                            "routine": 39764,
+                            "day": null,
+                            "date": "2025-08-07",
+                            "notes": null,
+                            "impression": "3",
+                            "time_start": "20:10:58",
+                            "time_end": "23:28:21"
+                        },
+                    ]
+                }
+            });
+        });
+
+        (exerciseService.getExercise as jest.Mock).mockImplementation((id) => {
+            if (id === 200) {
+                return Promise.resolve(testExerciseSquats);
+            } else if (id === 201) {
+                return Promise.resolve(testExerciseBenchPress);
+            }
+        });
+
+        // Act
+        const sessions = await getSessions();
+
+        // Assert
+        expect(sessions).toHaveLength(1);
+        expect(sessions[0].id).toBe(24284);
+        expect(sessions[0].logs).toHaveLength(2);
+        expect(sessions[0].logs[0].exerciseId).toBe(200);
+        expect(sessions[0].logs[0].exerciseObj).toBeDefined();
+        expect(sessions[0].logs[0].exerciseObj?.getTranslation().name).toBe('Squats');
+        expect(sessions[0].logs[1].exerciseId).toBe(201);
+        expect(sessions[0].logs[1].exerciseObj).toBeDefined();
+        expect(sessions[0].logs[1].exerciseObj?.getTranslation().name).toBe('Benchpress');
+
+        expect(exerciseService.getExercise).toHaveBeenCalledWith(200);
+        expect(exerciseService.getExercise).toHaveBeenCalledWith(201);
+
+        // Check that API calls were made correctly
+        expect(axios.get).toHaveBeenNthCalledWith(
+            1,
+            expect.stringContaining('/workoutlog/'),
+            expect.anything()
+        );
+        expect(axios.get).toHaveBeenNthCalledWith(
+            2,
+            expect.stringContaining('/workoutsession/'),
+            expect.anything()
+        );
+    });
+
+    // Keep the existing test
+    test('Correctly filters sessions and log entries', async () => {
+        (axios.get as jest.Mock).mockImplementation(() => {
+            return Promise.resolve({
+                data: {
+                    count: 2,
+                    next: null,
+                    previous: null,
+                    results: []
+                }
+            });
+        });
+
+        await getSessions({
+            filtersetQueryLogs: { foo: "bar" },
+            filtersetQuerySessions: { baz: 1234 }
+        });
+
+        // No results, so no loading of ingredients or weight units
+        expect(axios.get).toHaveBeenCalledTimes(2);
+        expect(axios.get).toHaveBeenNthCalledWith(1,
+            expect.stringContaining('foo=bar'),
+            expect.anything()
+        );
+        expect(axios.get).toHaveBeenNthCalledWith(2,
+            expect.stringContaining('baz=1234'),
+            expect.anything()
+        );
+    });
+});