@wger-project/react-components 25.10.16

package/src/services/measurements.ts

@@ -0,0 +1,173 @@
+import axios from 'axios';
+import { MeasurementCategory, MeasurementCategoryAdapter } from "components/Measurements/models/Category";
+import { MeasurementEntry, MeasurementEntryAdapter } from "components/Measurements/models/Entry";
+import { ApiMeasurementCategoryType } from 'types';
+import { dateToYYYYMMDD } from "utils/date";
+import { fetchPaginated } from 'utils/requests';
+import { makeHeader, makeUrl } from "utils/url";
+
+export const API_MEASUREMENTS_CATEGORY_PATH = 'measurement-category';
+export const API_MEASUREMENTS_ENTRY_PATH = 'measurement';
+
+export type MeasurementQueryOptions = {
+    filtersetQueryCategories?: object,
+    filtersetQueryEntries?: object,
+}
+
+export const getMeasurementCategories = async (options?: MeasurementQueryOptions): Promise<MeasurementCategory[]> => {
+    const { filtersetQueryCategories = {}, filtersetQueryEntries = {} } = options || {};
+
+    const adapter = new MeasurementCategoryAdapter();
+    const entryAdapter = new MeasurementEntryAdapter();
+    const categories: MeasurementCategory[] = [];
+
+    for await (const page of fetchPaginated(makeUrl(API_MEASUREMENTS_CATEGORY_PATH, { query: { ...filtersetQueryCategories } }), makeHeader())) {
+        for (const catData of page) {
+            categories.push(adapter.fromJson(catData));
+        }
+    }
+
+    // Load entries for each category
+    const entryResponses = categories.map(async (category) => {
+        const out: MeasurementEntry[] = [];
+        const url = makeUrl(API_MEASUREMENTS_ENTRY_PATH, { query: { category: category.id, ...filtersetQueryEntries } });
+
+        // Collect all pages of entries
+        for await (const page of fetchPaginated(url, makeHeader())) {
+            for (const entries of page) {
+                out.push(entryAdapter.fromJson(entries));
+            }
+        }
+        return out;
+    });
+    const settingsResponses = await Promise.all(entryResponses);
+
+    // Save entries to each category
+    let categoryId: number;
+    settingsResponses.forEach((entries) => {
+        if (entries.length > 0) {
+            categoryId = entries[0].category;
+            categories.findLast(c => c.id === categoryId)!.entries = entries;
+        }
+    });
+
+    return categories;
+};
+
+export const getMeasurementCategory = async (id: number): Promise<MeasurementCategory> => {
+    const { data: receivedCategories } = await axios.get<ApiMeasurementCategoryType>(
+        makeUrl(API_MEASUREMENTS_CATEGORY_PATH, { id: id }),
+        { headers: makeHeader() },
+    );
+
+    const category = new MeasurementCategoryAdapter().fromJson(receivedCategories);
+    const adapter = new MeasurementEntryAdapter();
+    const measurements: MeasurementEntry[] = [];
+    const url = makeUrl(API_MEASUREMENTS_ENTRY_PATH, { query: { category: category.id } });
+
+    // Collect all pages of entries
+    for await (const page of fetchPaginated(url, makeHeader())) {
+        for (const entries of page) {
+            measurements.push(adapter.fromJson(entries));
+        }
+    }
+
+    category.entries = measurements;
+
+    return category;
+};
+
+export interface AddMeasurementCategoryParams {
+    name: string;
+    unit: string;
+}
+
+export const addMeasurementCategory = async (data: AddMeasurementCategoryParams): Promise<MeasurementCategory> => {
+    const response = await axios.post(
+        makeUrl(API_MEASUREMENTS_CATEGORY_PATH,),
+        {
+            name: data.name,
+            unit: data.unit
+        },
+        { headers: makeHeader() }
+    );
+
+    const adapter = new MeasurementCategoryAdapter();
+    return adapter.fromJson(response.data);
+};
+
+export interface editMeasurementCategoryParams {
+    id: number,
+    name: string;
+    unit: string;
+}
+
+export const editMeasurementCategory = async (data: editMeasurementCategoryParams): Promise<MeasurementCategory> => {
+    const response = await axios.patch(
+        makeUrl(API_MEASUREMENTS_CATEGORY_PATH, { id: data.id }),
+        {
+            name: data.name,
+            unit: data.unit
+        },
+        { headers: makeHeader() }
+    );
+
+    const adapter = new MeasurementCategoryAdapter();
+    return adapter.fromJson(response.data);
+};
+
+export const deleteMeasurementCategory = async (id: number): Promise<void> => {
+    await axios.delete(makeUrl(API_MEASUREMENTS_CATEGORY_PATH, { id: id }), { headers: makeHeader() });
+};
+
+
+export const deleteMeasurementEntry = async (id: number): Promise<void> => {
+    await axios.delete(makeUrl(API_MEASUREMENTS_ENTRY_PATH, { id: id }), { headers: makeHeader() });
+};
+
+export interface editMeasurementParams {
+    id: number,
+    categoryId?: number,
+    date: Date;
+    value: number;
+    notes: string;
+}
+
+export const editMeasurementEntry = async (data: editMeasurementParams): Promise<MeasurementEntry> => {
+    const response = await axios.patch(
+        makeUrl(API_MEASUREMENTS_ENTRY_PATH, { id: data.id }),
+        {
+            date: dateToYYYYMMDD(data.date),
+            value: data.value,
+            notes: data.notes
+        },
+        { headers: makeHeader() }
+    );
+
+    const adapter = new MeasurementEntryAdapter();
+    return adapter.fromJson(response.data);
+};
+
+export interface AddMeasurementParams {
+    categoryId: number;
+    date: Date;
+    value: number;
+    notes: string;
+}
+
+export const addMeasurementEntry = async (data: AddMeasurementParams): Promise<MeasurementEntry> => {
+
+    const response = await axios.post(
+        makeUrl(API_MEASUREMENTS_ENTRY_PATH),
+        {
+            category: data.categoryId,
+            date: dateToYYYYMMDD(data.date),
+            value: data.value,
+            notes: data.notes
+        },
+        { headers: makeHeader() }
+    );
+
+    const adapter = new MeasurementEntryAdapter();
+    return adapter.fromJson(response.data);
+};

package/src/services/muscles.test.ts

@@ -0,0 +1,46 @@
+import axios from "axios";
+import { Muscle } from "components/Exercises/models/muscle";
+import { getMuscles } from "services";
+
+jest.mock("axios");
+
+describe("muscle service tests", () => {
+
+    test('GET muscle entries', async () => {
+
+        const muscleResponse = {
+            count: 2,
+            next: null,
+            previous: null,
+            results: [
+                {
+                    "id": 2,
+                    "name": "Anterior deltoid",
+                    "name_en": "Shoulders",
+                    "is_front": true,
+                    "image_url_main": "/static/images/muscles/main/muscle-2.svg",
+                    "image_url_secondary": "/static/images/muscles/secondary/muscle-2.svg"
+                },
+                {
+                    "id": 1,
+                    "name": "Biceps brachii",
+                    "name_en": "Biceps",
+                    "is_front": false,
+                    "image_url_main": "/static/images/muscles/main/muscle-1.svg",
+                    "image_url_secondary": "/static/images/muscles/secondary/muscle-1.svg"
+                },
+            ]
+        };
+
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ data: muscleResponse }));
+
+        const result = await getMuscles();
+        expect(axios.get).toHaveBeenCalledTimes(1);
+
+        expect(result).toStrictEqual([
+            new Muscle(2, "Anterior deltoid", "Shoulders", true),
+            new Muscle(1, "Biceps brachii", "Biceps", false),
+        ]);
+    });
+});
+

package/src/services/muscles.ts

@@ -0,0 +1,20 @@
+import axios from 'axios';
+import { Muscle, MuscleAdapter } from "components/Exercises/models/muscle";
+import { ApiMuscleType } from 'types';
+import { makeHeader, makeUrl } from "utils/url";
+import { ResponseType } from "./responseType";
+
+export const MUSCLES_PATH = 'muscle';
+
+/*
+ * Fetch all muscles
+ */
+export const getMuscles = async (): Promise<Muscle[]> => {
+    const url = makeUrl(MUSCLES_PATH);
+    const { data: receivedMuscles } = await axios.get<ResponseType<ApiMuscleType>>(url, {
+        headers: makeHeader(),
+    });
+    const adapter = new MuscleAdapter();
+    return receivedMuscles.results.map(m => adapter.fromJson(m));
+};
+

package/src/services/note.ts

@@ -0,0 +1,39 @@
+import axios from "axios";
+import { Note, NoteAdapter } from "components/Exercises/models/note";
+import { makeHeader, makeUrl } from "utils/url";
+
+export const API_NOTE_PATH = 'exercisecomment';
+
+
+/*
+ * Create a new note
+ */
+export const addNote = async (note: Note): Promise<Note> => {
+    const adapter = new NoteAdapter();
+    const url = makeUrl(API_NOTE_PATH);
+    const response = await axios.post(
+        url,
+        adapter.toJson(note),
+        { headers: makeHeader() }
+    );
+
+    return adapter.fromJson(response.data);
+};
+
+/*
+ * Edit an existing note
+ */
+export const editNote = async (note: Note): Promise<Note> => {
+    const adapter = new NoteAdapter();
+
+    const url = makeUrl(API_NOTE_PATH, { id: note.id! });
+    const response = await axios.patch(
+        url,
+        adapter.toJson(note),
+        { headers: makeHeader() }
+    );
+
+    return adapter.fromJson(response.data);
+};
+
+

package/src/services/nutritionalDiary.test.ts

@@ -0,0 +1,35 @@
+import axios from "axios";
+import { getNutritionalDiaryEntries } from "services";
+
+jest.mock("axios");
+
+describe("Nutritional plan diary service tests", () => {
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+    });
+
+    test('Correctly filters diary entries', async () => {
+        (axios.get as jest.Mock).mockImplementation(() => {
+            return Promise.resolve({
+                data: {
+                    count: 2,
+                    next: null,
+                    previous: null,
+                    results: []
+                }
+            });
+        });
+
+        await getNutritionalDiaryEntries({
+            filtersetQuery: { foo: "bar" },
+        });
+
+        // No results, so no loading of ingredients or weight units
+        expect(axios.get).toHaveBeenCalledTimes(1);
+        expect(axios.get).toHaveBeenNthCalledWith(1,
+            expect.stringContaining('foo=bar'),
+            expect.anything()
+        );
+    });
+});

package/src/services/nutritionalDiary.ts

@@ -0,0 +1,70 @@
+import axios from 'axios';
+import { DiaryEntry } from "components/Nutrition/models/diaryEntry";
+import { getIngredient } from "services/ingredient";
+import { getWeightUnit } from "services/ingredientweightunit";
+import { API_MAX_PAGE_SIZE, ApiPath } from "utils/consts";
+import { fetchPaginated } from "utils/requests";
+import { makeHeader, makeUrl } from "utils/url";
+
+
+export type NutritionalDiaryEntriesOptions = {
+    filtersetQuery?: object;
+    loadUnit?: true,
+    loadIngredient?: true
+}
+
+export const getNutritionalDiaryEntries = async (options?: NutritionalDiaryEntriesOptions): Promise<DiaryEntry[]> => {
+    const { filtersetQuery = {}, loadUnit = true, loadIngredient = true } = options || {};
+
+    const url = makeUrl(ApiPath.NUTRITIONAL_DIARY, {
+        query: {
+            limit: API_MAX_PAGE_SIZE,
+            ...filtersetQuery
+        }
+    });
+    const out: DiaryEntry[] = [];
+
+    for await (const page of fetchPaginated(url, makeHeader())) {
+        for (const logData of page) {
+            const entry = DiaryEntry.fromJson(logData);
+
+            if (loadUnit) {
+                entry.weightUnit = await getWeightUnit(entry.weightUnitId);
+            }
+
+            if (loadIngredient) {
+                entry.ingredient = await getIngredient(entry.ingredientId);
+            }
+            out.push(entry);
+        }
+    }
+    return out;
+};
+
+
+export const addNutritionalDiaryEntry = async (diaryEntry: DiaryEntry): Promise<DiaryEntry> => {
+    const response = await axios.post(
+        makeUrl(ApiPath.NUTRITIONAL_DIARY),
+        diaryEntry.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return DiaryEntry.fromJson(response.data);
+};
+
+export const editNutritionalDiaryEntry = async (diaryEntry: DiaryEntry): Promise<DiaryEntry> => {
+    const response = await axios.patch(
+        makeUrl(ApiPath.NUTRITIONAL_DIARY, { id: diaryEntry.id! }),
+        diaryEntry.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return DiaryEntry.fromJson(response.data);
+};
+
+export const deleteNutritionalDiaryEntry = async (id: number): Promise<void> => {
+    await axios.delete(
+        makeUrl(ApiPath.NUTRITIONAL_DIARY, { id: id }),
+        { headers: makeHeader() },
+    );
+};

package/src/services/nutritionalPlan.test.ts

@@ -0,0 +1,74 @@
+import axios from "axios";
+import { NutritionalPlan } from "components/Nutrition/models/nutritionalPlan";
+import { getNutritionalPlansSparse } from "services/nutritionalPlan";
+
+jest.mock("axios");
+
+describe("Nutritional plan service tests", () => {
+
+    test('GET plans - sparse', async () => {
+
+        const planResponse = {
+            count: 2,
+            next: null,
+            previous: null,
+            results: [
+                {
+                    "id": 72559,
+                    "creation_date": "2023-05-26",
+                    "start": "2023-06-01",
+                    "end": "2023-06-30",
+                    "description": "first plan",
+                    "only_logging": true,
+                },
+                {
+                    "id": 60131,
+                    "creation_date": "2022-06-01",
+                    "start": "2022-06-01",
+                    "end": null,
+                    "description": "",
+                    "only_logging": false,
+                },
+                {
+                    "id": 24752,
+                    "creation_date": "2023-08-01",
+                    "start": "2023-08-01",
+                    "end": "2023-08-31",
+                    "description": "",
+                    "only_logging": false,
+                },
+            ]
+        };
+
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ data: planResponse }));
+
+        const result = await getNutritionalPlansSparse();
+        expect(axios.get).toHaveBeenCalledTimes(1);
+
+        expect(result).toStrictEqual([
+            new NutritionalPlan({
+                id: 72559,
+                creationDate: new Date('2023-05-26'),
+                start: new Date('2023-06-01'),
+                end: new Date('2023-06-30'),
+                description: 'first plan',
+                onlyLogging: true
+            }),
+            new NutritionalPlan({
+                id: 60131,
+                creationDate: new Date('2022-06-01'),
+                description: '',
+                onlyLogging: false
+            }),
+            new NutritionalPlan({
+                id: 24752,
+                creationDate: new Date('2023-08-01'),
+                start: new Date('2023-08-01'),
+                end: new Date('2023-08-31'),
+                description: '',
+                onlyLogging: false
+            }),
+        ]);
+    });
+
+});

package/src/services/nutritionalPlan.ts

@@ -0,0 +1,104 @@
+import axios from 'axios';
+import { NutritionalPlan, nutritionalPlanAdapter } from "components/Nutrition/models/nutritionalPlan";
+import { getNutritionalDiaryEntries } from "services";
+import { getIngredients } from "services/ingredient";
+import { getMealsForPlan } from "services/meal";
+import { ResponseType } from "services/responseType";
+import { ApiNutritionalPlanType } from 'types';
+import { makeHeader, makeUrl } from "utils/url";
+
+export const API_NUTRITIONAL_PLAN_PATH = 'nutritionplan';
+
+export type NutritionalPlanOptions = {
+    filtersetQueryLogs?: object,
+}
+
+export const getNutritionalPlansSparse = async (): Promise<NutritionalPlan[]> => {
+    const { data: receivedPlans } = await axios.get<ResponseType<ApiNutritionalPlanType>>(
+        makeUrl(API_NUTRITIONAL_PLAN_PATH),
+        { headers: makeHeader() },
+    );
+    return receivedPlans.results.map((plan) => nutritionalPlanAdapter.fromJson(plan));
+};
+
+export const getLastNutritionalPlan = async (): Promise<NutritionalPlan | null> => {
+    const { data: receivedPlan } = await axios.get<ResponseType<ApiNutritionalPlanType>>(
+        makeUrl(API_NUTRITIONAL_PLAN_PATH, { query: { limit: '1' } }),
+        { headers: makeHeader() },
+    );
+
+    if (receivedPlan.count === 0) {
+        return null;
+    }
+
+    return await getNutritionalPlanFull(receivedPlan.results[0].id);
+};
+
+export const getNutritionalPlanFull = async (id: number | null, options?: NutritionalPlanOptions): Promise<NutritionalPlan | null> => {
+    if (id === null) {
+        return null;
+    }
+    const { filtersetQueryLogs = {} } = options || {};
+
+    const { data: receivedPlan } = await axios.get<ApiNutritionalPlanType>(
+        makeUrl(API_NUTRITIONAL_PLAN_PATH, { id: id, }),
+        { headers: makeHeader() },
+    );
+
+    // Collect the ingredient ids from the diary entries
+    const ingredientIds: number[] = [];
+
+    const plan = nutritionalPlanAdapter.fromJson(receivedPlan);
+    const responses = await Promise.all([
+        getMealsForPlan(id),
+        getNutritionalDiaryEntries({ filtersetQuery: { plan: id, ...filtersetQueryLogs } })
+    ]);
+
+    plan.meals = responses[0];
+    plan.diaryEntries = responses[1];
+
+    // Fetch and set the ingredients
+    plan.diaryEntries.forEach((entry) => {
+        if (!ingredientIds.includes(entry.ingredientId)) {
+            ingredientIds.push(entry.ingredientId);
+        }
+    });
+    const ingredients = await getIngredients(ingredientIds);
+    plan.diaryEntries.forEach((entry) => {
+        entry.ingredient = ingredients.find((ingredient) => ingredient.id === entry.ingredientId)!;
+    });
+
+    plan.meals.forEach((meal) => {
+        meal.diaryEntries = plan.diaryEntries.filter((entry) => entry.mealId === meal.id);
+    });
+
+    return plan;
+};
+
+
+export const addNutritionalPlan = async (plan: NutritionalPlan): Promise<NutritionalPlan> => {
+    const response = await axios.post(
+        makeUrl(API_NUTRITIONAL_PLAN_PATH,),
+        nutritionalPlanAdapter.toJson(plan),
+        { headers: makeHeader() }
+    );
+
+    return nutritionalPlanAdapter.fromJson(response.data);
+};
+
+export const editNutritionalPlan = async (plan: NutritionalPlan): Promise<NutritionalPlan> => {
+    const response = await axios.patch(
+        makeUrl(API_NUTRITIONAL_PLAN_PATH, { id: plan.id! }),
+        nutritionalPlanAdapter.toJson(plan),
+        { headers: makeHeader() }
+    );
+
+    return nutritionalPlanAdapter.fromJson(response.data);
+};
+
+export const deleteNutritionalPlan = async (id: number): Promise<void> => {
+    await axios.delete(
+        makeUrl(API_NUTRITIONAL_PLAN_PATH, { id: id }),
+        { headers: makeHeader() },
+    );
+};

package/src/services/permission.ts

@@ -0,0 +1,26 @@
+import axios from 'axios';
+import { makeHeader, makeUrl } from "utils/url";
+
+export const PERMISSION_PATH = 'check-permission';
+
+
+/*
+ * Checks if the user has a given permission
+ */
+export const checkPermission = async (permission: string): Promise<boolean> => {
+    const url = makeUrl(PERMISSION_PATH, { query: { 'permission': permission } });
+    const response = await axios.get(
+        url,
+        { headers: makeHeader() }
+    );
+
+    // User is logged out, etc.
+    if (response.status === 400) {
+        return false;
+    }
+
+    return response.data.result;
+};
+
+
+

package/src/services/permissions.test.ts

@@ -0,0 +1,34 @@
+import axios from "axios";
+import { checkPermission } from "services/permission";
+
+jest.mock("axios");
+
+
+describe("Permission API tests", () => {
+
+
+    test('Check an exising permission', async () => {
+
+        // Arrange
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ data: { "result": true } }));
+
+        // Act
+        const result = await checkPermission('exercises.delete_exercise');
+
+        // Assert
+        expect(axios.get).toHaveBeenCalled();
+        expect(result).toEqual(true);
+    });
+
+    test('Check permission logged out user', async () => {
+        // Arrange
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ status: 400 }));
+
+        // Act
+        const result = await checkPermission('exercises.sus_scrofa');
+
+        // Assert
+        expect(axios.get).toHaveBeenCalled();
+        expect(result).toEqual(false);
+    });
+});

package/src/services/profile.test.ts

@@ -0,0 +1,40 @@
+import axios from "axios";
+import { getProfile } from "services";
+import { testProfileApiResponse, testProfileDataVerified } from "tests/userTestdata";
+
+jest.mock("axios");
+
+
+describe("Profile API tests", () => {
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+    });
+
+
+    test('get the user profile (logged in)', async () => {
+
+        // Arrange
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ data: testProfileApiResponse }));
+
+        // Act
+        const result = await getProfile();
+
+        // Assert
+        expect(axios.get).toHaveBeenCalledTimes(1);
+        expect(result).toEqual(testProfileDataVerified);
+    });
+
+    test('get the user profile (logged out)', async () => {
+
+        // Arrange
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ status: 403 }));
+
+        // Act
+        const result = await getProfile();
+
+        // Assert
+        expect(axios.get).toHaveBeenCalledTimes(1);
+        expect(result).toEqual(null);
+    });
+});