@wger-project/react-components 25.10.16

package/src/services/exercise.ts

@@ -0,0 +1,182 @@
+import axios from 'axios';
+import { Exercise, ExerciseAdapter } from "components/Exercises/models/exercise";
+import { makeHeader, makeUrl } from "utils/url";
+import { ResponseType } from "./responseType";
+
+export const EXERCISE_INFO_PATH = 'exerciseinfo';
+export const EXERCISE_PATH = 'exercise';
+export const EXERCISE_SUBMISSION_PATH = 'exercise-submission';
+
+/*
+ * Process the response from the server and return the exercise bases
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function processExerciseApiData(data: any): Exercise[] {
+    const adapter = new ExerciseAdapter();
+
+    const out: Exercise[] = [];
+    for (const baseData of data.results) {
+        try {
+            out.push(adapter.fromJson(baseData));
+        } catch (e) {
+            console.error('An error happened, skipping base:', e);
+        }
+    }
+    return out;
+}
+
+
+/*
+ * Fetch all exercise bases
+ */
+export const getExercises = async (): Promise<Exercise[]> => {
+    const url = makeUrl(EXERCISE_INFO_PATH, { query: { limit: 900 } });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const response = await axios.get<ResponseType<any>>(url, {
+        headers: makeHeader(),
+    });
+
+    return processExerciseApiData(response.data);
+};
+
+
+/*
+ * Fetch exercise with a particular ID
+ */
+export const getExercise = async (id: number): Promise<Exercise> => {
+    const adapter = new ExerciseAdapter();
+    const url = makeUrl(EXERCISE_INFO_PATH, { id: id });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const response = await axios.get<ResponseType<any>>(url, {
+        headers: makeHeader(),
+    });
+
+    return adapter.fromJson(response.data);
+};
+
+
+/*
+ * Fetch exercise bases with a given variation ID
+ */
+export const getExercisesForVariation = async (id: number | null | undefined): Promise<Exercise[]> => {
+    if (!id) {
+        return [];
+    }
+
+    const url = makeUrl(EXERCISE_INFO_PATH, { query: { variations: id } });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const response = await axios.get<ResponseType<any>>(url, {
+        headers: makeHeader(),
+    });
+
+    return processExerciseApiData(response.data);
+};
+
+/*
+ * Create a new exercise with all its sub-entities
+ */
+type ExerciseSubmissionProps = {
+    categoryId: number,
+    equipmentIds: number[],
+    muscleIds: number[],
+    secondaryMuscleIds: number[],
+}
+type AliasSubmissionProps = {
+    alias: string
+}
+type NotesSubmissionProps = {
+    comment: string
+}
+type TranslationSubmissionProps = {
+    name: string,
+    description: string,
+    language: number,
+    aliases?: AliasSubmissionProps[],
+    comments?: NotesSubmissionProps[]
+}
+
+export type AddExerciseFullProps = {
+    author?: string,
+    exercise: ExerciseSubmissionProps,
+    variations?: number | null,
+    variationsConnectTo?: number | null,
+    translations: TranslationSubmissionProps[],
+}
+
+export const addFullExercise = async (data: AddExerciseFullProps): Promise<number> => {
+
+    const url = makeUrl(EXERCISE_SUBMISSION_PATH);
+    const payload = {
+        category: data.exercise.categoryId,
+        equipment: data.exercise.equipmentIds,
+        muscles: data.exercise.muscleIds,
+        // eslint-disable-next-line camelcase
+        muscles_secondary: data.exercise.secondaryMuscleIds,
+        // eslint-disable-next-line camelcase
+        license_author: data.author ?? '',
+        variations: data.variations ?? null,
+        //eslint-disable-next-line camelcase
+        variations_connect_to: data.variationsConnectTo ?? null,
+        translations: [
+            ...data.translations.map(t => ({
+                    name: t.name,
+                    description: t.description,
+                    language: t.language,
+                    //eslint-disable-next-line camelcase
+                    license_author: data.author ?? '',
+                    aliases: t.aliases ?? [],
+                    comments: t.comments ?? []
+                })
+            )
+        ],
+    };
+
+    const result = await axios.post(
+        url,
+        payload,
+        { headers: makeHeader() }
+    );
+    return result.data.id;
+};
+
+/*
+ * Update an existing exercise
+ */
+type EditExerciseProps = {
+    category?: number,
+    equipment?: number[],
+    muscles?: number[],
+    muscles_secondary?: number[],
+    variations?: number | null,
+    license_author?: string | null
+}
+export const editExercise = async (id: number, data: EditExerciseProps): Promise<number> => {
+
+    const url = makeUrl(EXERCISE_PATH, { id: id });
+    const response = await axios.patch(
+        url,
+        data,
+        { headers: makeHeader() }
+    );
+
+    return response.status;
+};
+
+/*
+ * Delete an existing exercise base
+ */
+export const deleteExercise = async (id: number, replacementUUID?: string): Promise<number> => {
+    const params = replacementUUID === undefined
+        ? { id: id }
+        // eslint-disable-next-line camelcase
+        : { id: id, query: { replaced_by: replacementUUID } };
+
+    const url = makeUrl(EXERCISE_PATH, params);
+    const response = await axios.delete(
+        url,
+        { headers: makeHeader() }
+    );
+
+    return response.status;
+};

package/src/services/exerciseTranslation.test.ts

@@ -0,0 +1,98 @@
+import axios from "axios";
+import { addTranslation, deleteExerciseTranslation, editTranslation } from "services";
+
+jest.mock("axios");
+
+
+describe("Exercise translation service API tests", () => {
+
+
+    test('POST a new exercise translation', async () => {
+
+        // Arrange
+        const response = {
+            "id": 886,
+            "uuid": "c788d643-150a-4ac7-97ef-84643c6419bf",
+            "exercise": 100,
+            "aliases": [],
+            "name": "Test exercise",
+            "description": "Test description",
+            "notes": [],
+            "creation_date": "2022-06-23",
+            "language": 2,
+            "license": 2,
+            "author_history": [
+                "tester"
+            ]
+        };
+        (axios.post as jest.Mock).mockImplementation(() => Promise.resolve({ data: response }));
+
+        // Act
+        const result = await addTranslation({
+            exerciseId: 100,
+            languageId: 2,
+            name: "Test exercise",
+            description: "Test description",
+            author: "Asimov"
+        });
+
+        // Assert
+        expect(axios.post).toHaveBeenCalledTimes(1);
+        expect(result.id).toEqual(886);
+        expect(result.name).toEqual("Test exercise");
+        expect(result.description).toEqual("Test description");
+    });
+
+
+    test('EDIT a new exercise translation', async () => {
+
+        // Arrange
+        const response = {
+            "id": 886,
+            "uuid": "c788d643-150a-4ac7-97ef-84643c6419bf",
+            "exercise": 100,
+            "aliases": [],
+            "name": "A new, cooler name!!!",
+            "description": "A new, cooler description!!!",
+            "notes": [],
+            "creation_date": "2022-06-23",
+            "language": 2,
+            "license": 2,
+            "author_history": [
+                "tester"
+            ]
+        };
+        (axios.patch as jest.Mock).mockImplementation(() => Promise.resolve({ status: 200, data: response }));
+
+        // Act
+        const result = await editTranslation({
+            id: 886,
+            exerciseId: 100,
+            languageId: 2,
+            name: "A new, cooler name!!!",
+            description: "A new, cooler description!!!",
+            author: "Asimov"
+        });
+
+        // Assert
+        expect(axios.patch).toHaveBeenCalledTimes(1);
+        expect(result.name).toEqual("A new, cooler name!!!");
+    });
+
+    test('DELETE an exercise translation', async () => {
+
+        // Arrange
+        (axios.delete as jest.Mock).mockImplementation(() => Promise.resolve({ status: 204 }));
+
+        // Act
+        const result = await deleteExerciseTranslation(1234);
+
+        // Assert
+        expect(axios.delete).toHaveBeenCalled();
+        expect(axios.delete).toHaveBeenCalledWith(
+            'https://example.com/api/v2/exercise-translation/1234/',
+            expect.anything()
+        );
+        expect(result).toEqual(204);
+    });
+});

package/src/services/exerciseTranslation.ts

@@ -0,0 +1,112 @@
+import axios from 'axios';
+import { Translation, TranslationAdapter } from "components/Exercises/models/translation";
+import { ENGLISH_LANGUAGE_CODE, LANGUAGE_SHORT_ENGLISH } from "utils/consts";
+import { makeHeader, makeUrl } from "utils/url";
+import { ExerciseSearchResponse, ExerciseSearchType, ResponseType } from "./responseType";
+
+export const EXERCISE_PATH = 'exercise';
+export const EXERCISE_TRANSLATION_PATH = 'exercise-translation';
+export const EXERCISE_SEARCH_PATH = 'exercise/search';
+
+
+/*
+ * Fetch all exercise translations for a given exercise base
+ */
+export const getExerciseTranslations = async (id: number): Promise<Translation[]> => {
+    const url = makeUrl(EXERCISE_PATH, { query: { exercise: id } });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const { data } = await axios.get<ResponseType<any>>(url, {
+        headers: makeHeader(),
+    });
+    const adapter = new TranslationAdapter();
+    return data.results.map(e => adapter.fromJson(e));
+};
+
+
+/*
+ * Fetch all exercise translations for a given exercise base
+ */
+export const searchExerciseTranslations = async (name: string, languageCode: string = ENGLISH_LANGUAGE_CODE, searchEnglish: boolean = true,): Promise<ExerciseSearchResponse[]> => {
+    const languages = [languageCode];
+    if (languageCode !== LANGUAGE_SHORT_ENGLISH && searchEnglish) {
+        languages.push(LANGUAGE_SHORT_ENGLISH);
+    }
+
+
+    const url = makeUrl(EXERCISE_SEARCH_PATH, { query: { term: name, language: languages.join(',') } });
+
+    const { data } = await axios.get<ExerciseSearchType>(url);
+    return data.suggestions;
+};
+
+
+/*
+ * Create a new exercise translation
+ */
+export interface AddTranslationParams {
+    exerciseId: number;
+    languageId: number;
+    name: string;
+    description: string;
+    author: string;
+}
+
+export const addTranslation = async (params: AddTranslationParams): Promise<Translation> => {
+    const { exerciseId, languageId, name, description, author } = params;
+
+    const url = makeUrl(EXERCISE_TRANSLATION_PATH);
+    const baseData = {
+        exercise: exerciseId,
+        language: languageId,
+        name: name,
+        description: description,
+        // eslint-disable-next-line camelcase
+        license_author: author
+    };
+    const response = await axios.post(url, baseData, {
+        headers: makeHeader(),
+    });
+
+    const adapter = new TranslationAdapter();
+    return adapter.fromJson(response.data);
+};
+
+/*
+ * Edit an existing exercise translation
+ */
+export interface EditTranslationParams extends AddTranslationParams {
+    id: number;
+}
+
+export const editTranslation = async (data: EditTranslationParams): Promise<Translation> => {
+    const { id, exerciseId, languageId, name, description } = data;
+
+    const url = makeUrl(EXERCISE_TRANSLATION_PATH, { id: id });
+    const baseData = {
+        exercise: exerciseId,
+        language: languageId,
+        name: name,
+        description: description,
+    };
+    const response = await axios.patch(
+        url,
+        baseData,
+        { headers: makeHeader() }
+    );
+
+    const adapter = new TranslationAdapter();
+    return adapter.fromJson(response.data);
+};
+
+/*
+ * Delete an existing exercise translation
+ */
+export const deleteExerciseTranslation = async (id: number): Promise<number> => {
+    const url = makeUrl(EXERCISE_TRANSLATION_PATH, { id: id });
+    const response = await axios.delete(
+        url,
+        { headers: makeHeader() }
+    );
+
+    return response.status;
+};

package/src/services/image.test.ts

@@ -0,0 +1,77 @@
+import axios from "axios";
+import { ExerciseImage } from "components/Exercises/models/image";
+import { postExerciseImage } from "services";
+import { deleteExerciseImage } from "services/image";
+
+jest.mock("axios");
+
+
+describe("Image service API tests", () => {
+
+
+    test('POST a new exercise image', async () => {
+
+        // Arrange
+        const response = {
+            "id": 1,
+            "uuid": "004bb79f-36bf-4c48-8c00-d863d724717c",
+            "exercise": 101,
+            "image": "https://wger.de/media/exercise-images/1070/004bb79f-36bf-4c48-8c00-d863d724717c.jpg",
+            "is_main": true,
+            "status": "1",
+            "style": "4"
+        };
+        const image = new ExerciseImage(
+            1,
+            "004bb79f-36bf-4c48-8c00-d863d724717c",
+            "https://wger.de/media/exercise-images/1070/004bb79f-36bf-4c48-8c00-d863d724717c.jpg",
+            true
+        );
+
+        (axios.post as jest.Mock).mockImplementation(() => Promise.resolve({ data: response }));
+
+        // Act
+        const result = await postExerciseImage(
+            {
+                exerciseId: 101,
+                image: new File([], "test.jpg"),
+                imageData: {
+                    url: "http://example.com",
+                    file: new File([], "test.jpg"),
+                    author: "Dr No",
+                    authorUrl: "http://dr.no",
+                    title: "top title",
+                    objectUrl: "",
+                    derivativeSourceUrl: "",
+                    style: "3d",
+                }
+            }
+        );
+
+        // Assert
+        expect(axios.post).toHaveBeenCalled();
+        expect(axios.post).toHaveBeenCalledWith(
+            'https://example.com/api/v2/exerciseimage/',
+            expect.objectContaining({ "exercise": 101 }),
+            expect.anything()
+        );
+        expect(result).toEqual(image);
+    });
+
+    test('DELETE an existing image', async () => {
+
+        // Arrange
+        (axios.delete as jest.Mock).mockImplementation(() => Promise.resolve({ status: 204 }));
+
+        // Act
+        const result = await deleteExerciseImage(101);
+
+        // Assert
+        expect(axios.delete).toHaveBeenCalled();
+        expect(axios.delete).toHaveBeenCalledWith(
+            'https://example.com/api/v2/exerciseimage/101/',
+            expect.anything()
+        );
+        expect(result).toEqual(204);
+    });
+});

package/src/services/image.ts

@@ -0,0 +1,54 @@
+import axios from 'axios';
+import { ImageFormData } from "components/Exercises/models/exercise";
+import { ExerciseImage, ExerciseImageAdapter } from "components/Exercises/models/image";
+import { makeHeader, makeUrl } from "utils/url";
+
+export const IMAGE_PATH = 'exerciseimage';
+
+
+/*
+ * Post a new exercise image
+ */
+export type PostExerciseImageParams = {
+    exerciseId: number;
+    image: File;
+    imageData: ImageFormData;
+};
+
+export const postExerciseImage = async (data: PostExerciseImageParams): Promise<ExerciseImage> => {
+    const url = makeUrl(IMAGE_PATH);
+    const headers = makeHeader();
+    headers['Content-Type'] = 'multipart/form-data';
+
+    const response = await axios.post(
+        url,
+        {
+            exercise: data.exerciseId,
+            image: data.image,
+            // eslint-disable-next-line camelcase
+            license_title: data.imageData.title,
+            // eslint-disable-next-line camelcase
+            license_object_url: data.imageData.objectUrl,
+            // eslint-disable-next-line camelcase
+            license_author: data.imageData.author,
+            // eslint-disable-next-line camelcase
+            license_author_url: data.imageData.authorUrl,
+            // eslint-disable-next-line camelcase
+            license_derivative_source_url: data.imageData.derivativeSourceUrl,
+            style: data.imageData.style,
+        },
+        { headers: headers }
+    );
+    return new ExerciseImageAdapter().fromJson(response.data);
+};
+
+/*
+ * Delete an exercise image
+ */
+export const deleteExerciseImage = async (imageId: number): Promise<number> => {
+    const url = makeUrl(IMAGE_PATH, { id: imageId });
+    const headers = makeHeader();
+    const response = await axios.delete(url, { headers: headers });
+
+    return response.status;
+};

package/src/services/index.ts

@@ -0,0 +1,104 @@
+export {
+    getWeights,
+    deleteWeight
+} from './weight';
+
+export { getMuscles } from './muscles';
+export { getEquipment } from './equipment';
+export { getCategories } from './category';
+export {
+    addFullExercise,
+    editExercise,
+    getExercises,
+    getExercise,
+    getExercisesForVariation,
+    deleteExercise,
+    processExerciseApiData,
+} from './exercise';
+export {
+    addTranslation,
+    editTranslation,
+    getExerciseTranslations,
+    searchExerciseTranslations,
+    deleteExerciseTranslation
+} from './exerciseTranslation';
+export { getLanguages, getLanguageByShortName } from './language';
+export { postExerciseImage } from './image';
+export { updateWeight, createWeight } from './weight';
+export { postAlias, deleteAlias } from './alias';
+export { postExerciseVideo, deleteExerciseVideo } from './video';
+
+export {
+    getRoutinesShallow,
+    getPrivateTemplatesShallow,
+    getPublicTemplatesShallow,
+    getRoutine,
+    getRoutines,
+    getActiveRoutine,
+    addRoutine,
+    deleteRoutine,
+    editRoutine,
+    getRoutineStatisticsData,
+    getRoutineLogData
+} from './routine';
+
+export {
+    getMeasurementCategories,
+    getMeasurementCategory,
+    deleteMeasurementEntry,
+    editMeasurementEntry,
+} from './measurements';
+
+export { searchIngredient, getIngredient } from './ingredient';
+
+export { addMealItem, editMealItem, deleteMealItem } from './mealItem';
+export { getMealsForPlan, addMeal, editMeal, deleteMeal } from './meal';
+export { getRoutineLogs, addLogs, editLog, deleteLog } from "./workoutLogs";
+export { editSlotEntry, deleteSlotEntry } from './slot_entry';
+export { getRoutineRepUnits, getRoutineWeightUnits } from './workoutUnits';
+export { addDay, editDay, deleteDay } from './day';
+export { addSlot, deleteSlot, editSlot } from './slot';
+export {
+    addRepetitionsConfig,
+    editRepetitionsConfig,
+    deleteRepetitionsConfig,
+    addMaxRepetitionsConfig,
+    editMaxRepetitionsConfig,
+    deleteMaxRepetitionsConfig,
+    addMaxWeightConfig,
+    editMaxWeightConfig,
+    deleteMaxWeightConfig,
+    addWeightConfig,
+    editWeightConfig,
+    deleteWeightConfig,
+    addNrOfSetsConfig,
+    editNrOfSetsConfig,
+    deleteNrOfSetsConfig,
+    addRirConfig,
+    editRirConfig,
+    deleteRirConfig,
+    addRestConfig,
+    editRestConfig,
+    deleteRestConfig,
+    editMaxRestConfig,
+    addMaxRestConfig,
+    deleteMaxRestConfig,
+    addMaxNrOfSetsConfig,
+    editMaxNrOfSetsConfig,
+    deleteMaxNrOfSetsConfig,
+    addMaxRirConfig,
+    editMaxRirConfig,
+    deleteMaxRirConfig,
+} from './config';
+
+export { addSession, editSession, searchSession, getSessions } from './session';
+
+export {
+    getNutritionalDiaryEntries, deleteNutritionalDiaryEntry, addNutritionalDiaryEntry, editNutritionalDiaryEntry
+} from './nutritionalDiary';
+
+export { getProfile, editProfile } from './profile';
+
+export { processBaseConfigs } from './base_config';
+
+export { checkLanguage } from 'services/languageCheck';