@wger-project/react-components 25.10.16

package/src/services/session.ts

@@ -0,0 +1,99 @@
+import axios from 'axios';
+import { Exercise } from "components/Exercises/models/exercise";
+import { WorkoutLog, WorkoutLogAdapter } from "components/WorkoutRoutines/models/WorkoutLog";
+import {
+    AddSessionParams,
+    EditSessionParams,
+    WorkoutSession,
+    WorkoutSessionAdapter
+} from "components/WorkoutRoutines/models/WorkoutSession";
+import { getExercise } from "services";
+import { API_MAX_PAGE_SIZE, ApiPath } from "utils/consts";
+import { fetchPaginated } from "utils/requests";
+import { makeHeader, makeUrl } from "utils/url";
+
+export type SessionQueryOptions = {
+    filtersetQuerySessions?: object,
+    filtersetQueryLogs?: object,
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const searchSession = async (queryParams: Record<string, any>): Promise<WorkoutSession | null> => {
+    const response = await axios.get(
+        makeUrl(ApiPath.SESSION, { query: queryParams }),
+        { headers: makeHeader() }
+    );
+
+    if (response.data.count === 1) {
+        return new WorkoutSessionAdapter().fromJson(response.data.results[0]);
+    }
+
+    return null;
+};
+
+export const getSessions = async (options?: SessionQueryOptions): Promise<WorkoutSession[]> => {
+
+    const { filtersetQuerySessions = {}, filtersetQueryLogs = {} } = options || {};
+
+    const sessionAdapter = new WorkoutSessionAdapter();
+    const logAdapter = new WorkoutLogAdapter();
+    const result: WorkoutSession[] = [];
+    const logs: WorkoutLog[] = [];
+    const exercises: Record<number, Exercise> = {};
+
+    // Fetch all logs first
+    for await (const logPage of fetchPaginated(
+        makeUrl(
+            ApiPath.WORKOUT_LOG,
+            { query: { limit: API_MAX_PAGE_SIZE, ...filtersetQueryLogs } }
+        ),
+        makeHeader()
+    )) {
+        for (const logData of logPage) {
+            logs.push(logAdapter.fromJson(logData));
+        }
+    }
+
+    // Fetch all exercises and associate them with logs if it's not known
+    for (const log of logs) {
+        if (!exercises[log.exerciseId]) {
+            exercises[log.exerciseId] = await getExercise(log.exerciseId);
+        }
+        log.exerciseObj = exercises[log.exerciseId];
+    }
+
+    for await (const sessionPage of fetchPaginated(
+        makeUrl(
+            ApiPath.SESSION,
+            { query: { limit: API_MAX_PAGE_SIZE, ...filtersetQuerySessions } }
+        ), makeHeader()
+    )) {
+        for (const sessionData of sessionPage) {
+            const session = sessionAdapter.fromJson(sessionData);
+            session.logs = logs.filter(log => log.sessionId === session.id);
+            result.push(session);
+        }
+    }
+
+    return result;
+};
+
+export const addSession = async (data: AddSessionParams): Promise<WorkoutSession> => {
+    const response = await axios.post(
+        makeUrl(ApiPath.SESSION,),
+        data,
+        { headers: makeHeader() }
+    );
+
+    return new WorkoutSessionAdapter().fromJson(response.data);
+};
+
+export const editSession = async (data: EditSessionParams): Promise<WorkoutSession> => {
+    const response = await axios.patch(
+        makeUrl(ApiPath.SESSION, { id: data.id }),
+        data,
+        { headers: makeHeader() }
+    );
+
+    return new WorkoutSessionAdapter().fromJson(response.data);
+};

package/src/services/slot.test.ts

@@ -0,0 +1,68 @@
+import axios from "axios";
+import { Slot } from "components/WorkoutRoutines/models/Slot";
+import { addSlot, deleteSlot, editSlot } from "services/slot";
+import { ApiPath } from "utils/consts";
+import { makeHeader, makeUrl } from "utils/url";
+
+jest.mock('axios');
+
+describe("Slot service tests", () => {
+    const slotApiData = {
+        day: 1,
+        order: 1,
+        comment: 'test',
+        config: null
+    };
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test('Creates a new Slot', async () => {
+        (axios.post as jest.Mock).mockImplementation(() => Promise.resolve({ data: { id: 123, ...slotApiData } }));
+        const slot = Slot.fromJson(slotApiData);
+
+        const result = await addSlot(slot);
+
+        expect(axios.post).toHaveBeenCalledWith(
+            makeUrl(ApiPath.SLOT),
+            slot.toJson(),
+            { headers: makeHeader() }
+        );
+        expect(result).toStrictEqual(new Slot({ id: 123, dayId: 1, order: 1, comment: 'test', config: null }));
+    });
+
+    test('Update a Slot', async () => {
+        (axios.patch as jest.Mock).mockImplementation(() => Promise.resolve({
+            data: {
+                id: 123,
+                ...slotApiData,
+                comment: 'foo'
+            }
+        }));
+
+        const slot = Slot.fromJson(slotApiData);
+        slot.comment = 'foo';
+        slot.id = 123;
+        const result = await editSlot(slot);
+
+        expect(axios.patch).toHaveBeenCalledWith(
+            makeUrl(ApiPath.SLOT, { id: 123 }),
+            slot.toJson(),
+            { headers: makeHeader() }
+        );
+        expect(result).toStrictEqual(new Slot({ id: 123, dayId: 1, order: 1, comment: 'foo', config: null }));
+    });
+
+
+    test('Delete a Slot', async () => {
+        (axios.delete as jest.Mock).mockImplementation(() => Promise.resolve({}));
+
+        await deleteSlot(1);
+
+        expect(axios.delete).toHaveBeenCalledWith(
+            makeUrl(ApiPath.SLOT, { id: 1 }),
+            { headers: makeHeader() }
+        );
+    });
+});

package/src/services/slot.ts

@@ -0,0 +1,43 @@
+import axios from 'axios';
+import { Slot } from "components/WorkoutRoutines/models/Slot";
+import { ApiPath } from "utils/consts";
+import { makeHeader, makeUrl } from "utils/url";
+
+
+/*
+ * Creates a new Slot
+ */
+export const addSlot = async (slot: Slot): Promise<Slot> => {
+    const response = await axios.post(
+        makeUrl(ApiPath.SLOT),
+        slot.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return Slot.fromJson(response.data);
+};
+
+/*
+ * Update a Slot
+ */
+export const editSlot = async (slot: Slot): Promise<Slot> => {
+    const response = await axios.patch(
+        makeUrl(ApiPath.SLOT, { id: slot.id! }),
+        slot.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return Slot.fromJson(response.data);
+};
+
+/*
+ * Delete an existing lot
+ */
+export const deleteSlot = async (id: number): Promise<void> => {
+    await axios.delete(
+        makeUrl(ApiPath.SLOT, { id: id }),
+        { headers: makeHeader() }
+    );
+};
+
+

package/src/services/slot_entry.ts

@@ -0,0 +1,43 @@
+import axios from 'axios';
+import { SlotEntry } from "components/WorkoutRoutines/models/SlotEntry";
+import { ApiPath } from "utils/consts";
+import { makeHeader, makeUrl } from "utils/url";
+
+
+/*
+ * Update a Slot entry
+ */
+export const editSlotEntry = async (slotEntry: SlotEntry): Promise<SlotEntry> => {
+    const response = await axios.patch(
+        makeUrl(ApiPath.SLOT_ENTRY, { id: slotEntry.id! }),
+        slotEntry.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return SlotEntry.fromJson(response.data);
+};
+
+/*
+ * Delete an existing slot entry
+ */
+export const deleteSlotEntry = async (id: number): Promise<void> => {
+    await axios.delete(
+        makeUrl(ApiPath.SLOT_ENTRY, { id: id }),
+        { headers: makeHeader() }
+    );
+};
+
+/*
+ * Creates a new slot entry
+ */
+export const addSlotEntry = async (slotEntry: SlotEntry): Promise<SlotEntry> => {
+    const response = await axios.post(
+        makeUrl(ApiPath.SLOT_ENTRY),
+        slotEntry.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return SlotEntry.fromJson(response.data);
+};
+
+

package/src/services/variation.test.ts

@@ -0,0 +1,24 @@
+import axios from "axios";
+import { addVariation } from "services/variation";
+
+jest.mock("axios");
+
+
+describe("Variation service API tests", () => {
+
+    test('POST a new variation', async () => {
+
+        // Arrange
+        const response = {
+            "id": 123
+        };
+        (axios.post as jest.Mock).mockImplementation(() => Promise.resolve({ data: response }));
+
+        // Act
+        const result = await addVariation();
+
+        // Assert
+        expect(axios.post).toHaveBeenCalledTimes(1);
+        expect(result).toEqual(123);
+    });
+});

package/src/services/variation.ts

@@ -0,0 +1,18 @@
+import axios from 'axios';
+import { makeHeader, makeUrl } from "utils/url";
+
+export const VARIATION_PATH = 'variation';
+
+
+/*
+ * Create a new exercise base
+ */
+export const addVariation = async (): Promise<number> => {
+
+    const url = makeUrl(VARIATION_PATH);
+    const response = await axios.post(url, {}, {
+        headers: makeHeader(),
+    });
+
+    return response.data.id;
+};

package/src/services/video.test.ts

@@ -0,0 +1,65 @@
+import axios from "axios";
+import { ExerciseVideo } from "components/Exercises/models/video";
+import { deleteExerciseVideo, postExerciseVideo } from "services";
+
+jest.mock("axios");
+
+describe("Exercise video service API tests", () => {
+    test("POST a new video", async () => {
+        // Arrange
+        const response = {
+            id: 1,
+            uuid: "b1c934fa-c4f8-4d84-8cb4-7802be0d284c",
+            exercise: 258,
+            exercise_uuid: "6260e3aa-e46b-4b4b-8ada-58bfd0922d3a",
+            video: "http://localhost:8000/media/exercise-video/258/b1c934fa-c4f8-4d84-8cb4-7802be0d284c.mp4",
+            is_main: false,
+            size: 0,
+            duration: "0.00",
+            width: 0,
+            height: 0,
+            codec: "",
+            codec_long: "",
+            license: 2,
+            license_author: null,
+        };
+
+        const video = new ExerciseVideo(
+            1,
+            "b1c934fa-c4f8-4d84-8cb4-7802be0d284c",
+            "http://localhost:8000/media/exercise-video/258/b1c934fa-c4f8-4d84-8cb4-7802be0d284c.mp4",
+            false
+        );
+
+        (axios.post as jest.Mock).mockImplementation(() => Promise.resolve({ data: response }));
+
+        // Act
+        const result = await postExerciseVideo({
+            exerciseId: 42,
+            author: "Prostetnic Vogon Jeltz",
+            video: new File([], "test.mp4"),
+        });
+
+        // Assert
+        expect(axios.post).toHaveBeenCalled();
+        expect(axios.post).toHaveBeenCalledWith(
+            "https://example.com/api/v2/video/",
+            expect.objectContaining({ exercise: 42 }),
+            expect.anything()
+        );
+        expect(result).toEqual(video);
+    });
+
+    test("DELETE an existing video", async () => {
+        // Arrange
+        (axios.delete as jest.Mock).mockImplementation(() => Promise.resolve({ status: 204 }));
+
+        // Act
+        const result = await deleteExerciseVideo(99);
+
+        // Assert
+        expect(axios.delete).toHaveBeenCalled();
+        expect(axios.delete).toHaveBeenCalledWith("https://example.com/api/v2/video/99/", expect.anything());
+        expect(result).toEqual(204);
+    });
+});

package/src/services/video.ts

@@ -0,0 +1,47 @@
+import axios from 'axios';
+import { ExerciseVideo, ExerciseVideoAdapter } from "components/Exercises/models/video";
+import { makeHeader, makeUrl } from "utils/url";
+
+export const VIDEO_PATH = 'video';
+
+export type PostExerciseVideoParams = {
+    exerciseId: number;
+    author: string;
+    video: File;
+};
+
+/**
+ * Post a new exercise video
+ * @param {number} exerciseId - ID of the exercise to which the video is linked
+ * @param {string} author - Name of the video's author (for license attribution)
+ * @param {File} video - Video file to upload
+ * @returns {Promise<ExerciseVideo>} - A promise that resolves to the uploaded ExerciseVideo object
+ */
+export const postExerciseVideo = async ({
+    exerciseId,
+    author,
+    video,
+}: PostExerciseVideoParams): Promise<ExerciseVideo> => {
+    const url = makeUrl(VIDEO_PATH);
+    const headers = makeHeader();
+    headers['Content-Type'] = 'multipart/form-data';
+
+    const response = await axios.post(
+        url,
+        // eslint-disable-next-line camelcase
+        { exercise: exerciseId, license_author: author, video: video },
+        { headers: headers }
+    );
+    return new ExerciseVideoAdapter().fromJson(response.data);
+};
+
+/*
+ * Delete an exercise video
+ */
+export const deleteExerciseVideo = async (videoId: number): Promise<number> => {
+    const url = makeUrl(VIDEO_PATH, { id: videoId });
+    const headers = makeHeader();
+    const response = await axios.delete(url, { headers: headers });
+
+    return response.status;
+};

package/src/services/weight.test.ts

@@ -0,0 +1,75 @@
+import axios from "axios";
+import { WeightEntry } from "components/BodyWeight/model";
+import { createWeight, deleteWeight, getWeights, updateWeight } from "./weight";
+
+jest.mock("axios");
+
+describe("weight service tests", () => {
+
+    test('GET weight entries', async () => {
+
+        const weightResponse = {
+            count: 2,
+            next: null,
+            previous: null,
+            results: [
+                { id: 1, weight: 80, date: '2021-12-10' },
+                { id: 2, weight: 90, date: '2021-12-20' },
+            ]
+        };
+
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ data: weightResponse }));
+
+        const result = await getWeights();
+        expect(axios.get).toHaveBeenCalledTimes(1);
+
+        expect(result).toStrictEqual([
+            new WeightEntry(new Date('2021-12-10'), 80, 1),
+            new WeightEntry(new Date('2021-12-20'), 90, 2),
+        ]);
+    });
+
+    test('DELETE weight entry', async () => {
+
+        // Arrange
+        (axios.delete as jest.Mock).mockImplementation(() => Promise.resolve({ status: 204 }));
+
+        // Act
+        const result = await deleteWeight(1);
+
+        // Assert
+        expect(axios.delete).toHaveBeenCalledTimes(1);
+        expect(result).toEqual(204);
+    });
+
+    test('PATCH weight entry', async () => {
+
+        // Arrange
+        const weightEntry = new WeightEntry(new Date('2021-12-10'), 80, 1);
+        const weightResponse = { id: 1, weight: 80, date: '2021-12-10' };
+
+        // Act
+        (axios.patch as jest.Mock).mockImplementation(() => Promise.resolve(weightResponse));
+        const result = await updateWeight(weightEntry);
+
+        // Assert
+        expect(axios.patch).toHaveBeenCalledTimes(1);
+        expect(result).toStrictEqual(new WeightEntry(new Date('2021-12-10'), 80, 1));
+    });
+
+    test('POST a new weight entry', async () => {
+
+        // Arrange
+        const weightEntry = new WeightEntry(new Date('2021-12-10'), 80, 1);
+        const weightResponse = { data: { id: 1, weight: 80, date: '2021-12-10' } };
+
+        // Act
+        (axios.post as jest.Mock).mockImplementation(() => Promise.resolve(weightResponse));
+        const result = await createWeight(weightEntry);
+
+        // Assert
+        expect(axios.post).toHaveBeenCalledTimes(1);
+        expect(result).toStrictEqual(new WeightEntry(new Date('2021-12-10'), 80, 1));
+    });
+
+});

package/src/services/weight.ts

@@ -0,0 +1,58 @@
+import axios from 'axios';
+import { WeightEntry } from "components/BodyWeight/model";
+import { ApiBodyWeightType } from 'types';
+import { makeHeader, makeUrl } from "utils/url";
+import { FilterType } from '../components/BodyWeight/widgets/FilterButtons';
+import { calculatePastDate } from '../utils/date';
+import { ResponseType } from "./responseType";
+
+export const WEIGHT_PATH = 'weightentry';
+
+/*
+ * Fetch weight entries based on filter value
+ */
+export const getWeights = async (filter: FilterType = ''): Promise<WeightEntry[]> => {
+
+    // eslint-disable-next-line camelcase
+    const date__gte = calculatePastDate(filter);
+
+    // eslint-disable-next-line camelcase
+    const url = makeUrl(WEIGHT_PATH, { query: { ordering: '-date', limit: 900, ...(date__gte && { date__gte }) } });
+    const { data: receivedWeights } = await axios.get<ResponseType<ApiBodyWeightType>>(url, {
+        headers: makeHeader(),
+    });
+    return receivedWeights.results.map(weight => WeightEntry.fromJson(weight));
+};
+
+/*
+ * Delete a weight entry
+ */
+export const deleteWeight = async (id: number): Promise<number> => {
+    const response = await axios.delete<number>(makeUrl(WEIGHT_PATH, { id: id }), {
+        headers: makeHeader(),
+    });
+
+    return response.status;
+};
+
+/*
+ * Update a weight entry
+ */
+export const updateWeight = async (entry: WeightEntry): Promise<WeightEntry> => {
+    const response = await axios.patch(makeUrl(WEIGHT_PATH, { id: entry.id }), entry.toJson(), {
+        headers: makeHeader(),
+    });
+
+    return WeightEntry.fromJson(response);
+};
+
+/*
+ * Add a new weight entry
+ */
+export const createWeight = async (entry: WeightEntry): Promise<WeightEntry> => {
+    const response = await axios.post(makeUrl(WEIGHT_PATH,), entry.toJson(), {
+        headers: makeHeader(),
+    });
+
+    return WeightEntry.fromJson(response.data);
+};

package/src/services/workoutLogs.test.ts

@@ -0,0 +1,148 @@
+import axios from "axios";
+import { WorkoutLog } from "components/WorkoutRoutines/models/WorkoutLog";
+import { getExercise } from "services";
+import { getRoutineLogs } from "services/workoutLogs";
+import { getRoutineRepUnits, getRoutineWeightUnits } from "services/workoutUnits";
+import { testExerciseSquats } from "tests/exerciseTestdata";
+import {
+    responseRoutineLogs,
+    testRepUnit1,
+    testRepUnit2,
+    testWeightUnit1,
+    testWeightUnit2
+} from "tests/workoutRoutinesTestData";
+
+jest.mock("axios");
+jest.mock("services/workoutUnits");
+jest.mock("services/exercise");
+
+
+describe("workout logs service tests", () => {
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+    });
+
+    test('GET the routine logs', async () => {
+
+        (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,
+
+                repetitionsUnit: testRepUnit1,
+                repetitionsUnitId: 1,
+                repetitions: 12,
+                repetitionsTarget: 12,
+
+                weightUnit: testWeightUnit1,
+                weightUnitId: 1,
+                weight: 10.00,
+                weightTarget: null,
+
+                rir: null,
+                rirTarget: null,
+            }),
+
+            new WorkoutLog({
+                id: 1,
+                routineId: 1,
+                date: new Date("2023-05-13"),
+                iteration: 1,
+                exerciseId: 100,
+                slotEntryId: 2,
+
+                repetitionsUnit: testRepUnit1,
+                repetitionsUnitId: 1,
+                repetitions: 10,
+                repetitionsTarget: null,
+
+                weightUnit: testWeightUnit1,
+                weightUnitId: 1,
+                weight: 20,
+                weightTarget: 20,
+
+                rir: 1.5,
+                rirTarget: 1,
+            }),
+        ]);
+    });
+
+
+    test('GET the routine logs and the exercise bases', 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]));
+        (getExercise as jest.Mock).mockImplementation(() => Promise.resolve(testExerciseSquats));
+
+        // Act
+        const result = await getRoutineLogs(1, { loadExercises: true });
+
+        // Assert
+        expect(axios.get).toHaveBeenCalledTimes(1);
+        expect(result).toStrictEqual([
+            new WorkoutLog({
+                id: 2,
+                routineId: 1,
+                date: new Date("2023-05-10"),
+                iteration: 1,
+                exercise: testExerciseSquats,
+                exerciseId: 100,
+                slotEntryId: 2,
+                sessionId: null,
+
+                repetitionsUnit: testRepUnit1,
+                repetitionsUnitId: 1,
+                repetitions: 12,
+                repetitionsTarget: 12,
+
+                weightUnit: testWeightUnit1,
+                weightUnitId: 1,
+                weight: 10.00,
+                weightTarget: null,
+
+                rir: null,
+                rirTarget: null,
+            }),
+
+            new WorkoutLog({
+                id: 1,
+                routineId: 1,
+                date: new Date("2023-05-13"),
+                iteration: 1,
+                slotEntryId: 2,
+                exercise: testExerciseSquats,
+                exerciseId: 100,
+                sessionId: null,
+
+                repetitionsUnit: testRepUnit1,
+                repetitionsUnitId: 1,
+                repetitions: 10,
+                repetitionsTarget: null,
+
+                weightUnit: testWeightUnit1,
+                weightUnitId: 1,
+                weight: 20,
+                weightTarget: 20,
+
+                rir: 1.5,
+                rirTarget: 1,
+            }),
+        ]);
+    });
+});