@wger-project/react-components 25.10.16

package/src/services/ingredient.test.ts

@@ -0,0 +1,81 @@
+import axios from "axios";
+import { getIngredient } from "services/ingredient";
+
+jest.mock("axios");
+
+describe("Ingredient service tests", () => {
+
+    test('GET an ingredient', async () => {
+
+        // Arrange
+        const ingredientInfoResponse = {
+            "id": 77897,
+            "uuid": "7b13e612-14e6-424a-9418-4fd366ff3224",
+            "code": "8801043020756",
+            "name": "some test ingredient",
+            "creation_date": "2020-12-20T01:00:00+01:00",
+            "update_date": "2023-04-08T02:00:00+02:00",
+            "energy": 470,
+            "protein": "6.000",
+            "carbohydrates": "72.000",
+            "carbohydrates_sugar": "4.000",
+            "fat": "18.000",
+            "fat_saturated": "6.000",
+            "fiber": null,
+            "sodium": "0.508",
+            "license": 5,
+            "license_title": "감자깡",
+            "license_object_url": "",
+            "license_author": "Open Food Facts",
+            "license_author_url": "",
+            "license_derivative_source_url": "",
+            "language": 2,
+            "image": {
+                "id": 1,
+                "uuid": "b260b245-efe9-4c92-9d8f-d2c4406221dd",
+                "image": "http://localhost:8000/media/ingredients/59197/b260b245-efe9-4c92-9d8f-d2c4406221dd.jpg",
+                "created": "2023-08-10T14:02:50.819376+02:00",
+                "last_update": "2023-08-10T14:02:50.832422+02:00",
+                "size": 21159,
+                "width": 400,
+                "height": 194,
+                "license": 1,
+                "license_title": "Photo",
+                "license_object_url": "https://world.openfoodfacts.org/cgi/product_image.pl?code=4250241203517&id=2",
+                "license_author": "kiliweb",
+                "license_author_url": "https://world.openfoodfacts.org/photographer/kiliweb",
+                "license_derivative_source_url": ""
+            },
+            "thumbnails": {
+                "small": "http://localhost:8000/974e62478222.jpg.200x200_q85.jpg",
+                "small_cropped": "http://localhost:8000/974e62478222.jpg.200x200_q85_crop-smart.jpg",
+                "medium": "http://localhost:8000/media/974e62478222.jpg.400x400_q85.jpg",
+                "medium_cropped": "http://localhost:8000/974e62478222.jpg.400x400_q85_crop-smart.jpg",
+                "large": "http://localhost:8000/media/974e62478222.jpg.800x800_q90.jpg",
+                "large_cropped": "http://localhost:8000/media/974e62478222.jpg.800x800_q90_crop-smart.jpg"
+            }
+        };
+
+        // Act
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ data: ingredientInfoResponse }));
+        const result = await getIngredient(1);
+
+        // Assert
+        expect(axios.get).toHaveBeenCalledTimes(1);
+        expect(result.id).toEqual(77897);
+        expect(result.uuid).toEqual("7b13e612-14e6-424a-9418-4fd366ff3224");
+        expect(result.code).toEqual("8801043020756");
+        expect(result.name).toEqual("some test ingredient");
+        expect(result.energy).toEqual(470);
+        expect(result.protein).toEqual(6);
+        expect(result.carbohydrates).toEqual(72);
+        expect(result.carbohydratesSugar).toEqual(4);
+        expect(result.fat).toEqual(18);
+        expect(result.fatSaturated).toEqual(6);
+        expect(result.fiber).toEqual(null);
+        expect(result.sodium).toEqual(0.508);
+        expect(result.image?.url).toEqual('http://localhost:8000/media/ingredients/59197/b260b245-efe9-4c92-9d8f-d2c4406221dd.jpg');
+    });
+});
+
+

package/src/services/ingredient.ts

@@ -0,0 +1,70 @@
+import axios from 'axios';
+import { Ingredient } from "components/Nutrition/models/Ingredient";
+import { memoize } from "lodash";
+import { ApiIngredientType } from 'types';
+import { API_RESULTS_PAGE_SIZE, ApiPath, LANGUAGE_SHORT_ENGLISH } from "utils/consts";
+import { fetchPaginated } from "utils/requests";
+import { makeHeader, makeUrl } from "utils/url";
+
+
+/*
+ * Memoized version of getIngredient. This caches results in memory for the duration
+ * of the app session, which avoids multiple requests for the same ingredient.
+ */
+export const getIngredient = memoize(async (id: number): Promise<Ingredient> => {
+    const { data: receivedIngredient } = await axios.get<ApiIngredientType>(
+        makeUrl(ApiPath.INGREDIENTINFO_PATH, { id: id }),
+        { headers: makeHeader() },
+    );
+
+    return Ingredient.fromJson(receivedIngredient);
+});
+
+export const getIngredients = async (ids: number[]): Promise<Ingredient[]> => {
+
+    // If IDs is an empty list, return. Otherwise, the resulting empty id__in will
+    // cause the API to not filter at all
+    if (ids.length === 0) {
+        return [];
+    }
+
+    // eslint-disable-next-line camelcase
+    const url = makeUrl(ApiPath.INGREDIENTINFO_PATH, { query: { id__in: ids.join(',') } });
+    const out: Ingredient[] = [];
+
+    // Collect all the ingredients
+    for await (const page of fetchPaginated(url, makeHeader())) {
+        for (const logData of page) {
+            out.push(Ingredient.fromJson(logData));
+        }
+    }
+
+    return out;
+};
+
+
+export const searchIngredient = async (name: string, languageCode: string, searchEnglish: boolean = true): Promise<Ingredient[]> => {
+    // TODO: this currently only converts the results from the new API to the old format
+    //       but this should be properly converted.
+    //       See also https://github.com/wger-project/wger/pull/1724
+
+
+    const languages = [languageCode];
+    if (languageCode !== LANGUAGE_SHORT_ENGLISH && searchEnglish) {
+        languages.push(LANGUAGE_SHORT_ENGLISH);
+    }
+
+    const url = makeUrl(
+        ApiPath.INGREDIENTINFO_PATH,
+        {
+            query: {
+                'name__search': name,
+                'language__code': languages.join(','),
+                'limit': API_RESULTS_PAGE_SIZE,
+            }
+        }
+    );
+
+    const { data } = await axios.get(url);
+    return data.results.map((entry: ApiIngredientType) => Ingredient.fromJson(entry));
+};

package/src/services/ingredientweightunit.ts

@@ -0,0 +1,29 @@
+import axios from 'axios';
+import { NutritionWeightUnit, NutritionWeightUnitAdapter } from "components/Nutrition/models/weightUnit";
+import { ApiIngredientWeightUnitType } from 'types';
+import { ApiPath } from "utils/consts";
+import { makeHeader, makeUrl } from "utils/url";
+import { ResponseType } from "./responseType";
+
+
+export const getWeightUnit = async (unitId: number | null): Promise<NutritionWeightUnit | null> => {
+    if (unitId === null) {
+        return null;
+    }
+
+    const { data: receivedUnit } = await axios.get<ApiIngredientWeightUnitType>(
+        makeUrl(ApiPath.INGREDIENT_WEIGHT_UNIT, { id: unitId }),
+        { headers: makeHeader() }
+    );
+    return new NutritionWeightUnitAdapter().fromJson(receivedUnit);
+};
+
+export const getWeightUnits = async (ingredientId: number): Promise<NutritionWeightUnit[]> => {
+    const { data: receivedUnits } = await axios.get<ResponseType<ApiIngredientWeightUnitType>>(
+        makeUrl(ApiPath.INGREDIENT_WEIGHT_UNIT, { query: { ingredient: ingredientId } }),
+        { headers: makeHeader() }
+    );
+    const adapter = new NutritionWeightUnitAdapter();
+    return receivedUnits.results.map(weight => adapter.fromJson(weight));
+};
+

package/src/services/language.test.ts

@@ -0,0 +1,86 @@
+import axios from "axios";
+import { Language } from "components/Exercises/models/language";
+import { getLanguageByShortName, getLanguages } from "services";
+
+jest.mock("axios");
+
+describe("Language service tests", () => {
+
+    test('GET language entries', async () => {
+
+        // Arrange
+        const muscleResponse = {
+            count: 3,
+            next: null,
+            previous: null,
+            results: [
+                {
+                    "id": 1,
+                    "short_name": "de",
+                    "full_name": "Deutsch"
+                },
+                {
+                    "id": 2,
+                    "short_name": "en",
+                    "full_name": "English"
+                },
+                {
+                    "id": 4,
+                    "short_name": "es",
+                    "full_name": "Español"
+                },
+            ]
+        };
+
+        // Act
+        (axios.get as jest.Mock).mockImplementation(() => Promise.resolve({ data: muscleResponse }));
+        const result = await getLanguages();
+
+        // Assert
+        expect(axios.get).toHaveBeenCalledTimes(1);
+        expect(result).toStrictEqual([
+            new Language(1, "de", "Deutsch"),
+            new Language(2, "en", "English"),
+            new Language(4, "es", "Español"),
+        ]);
+    });
+
+});
+
+describe("Test the getLanguageByShortName helper", () => {
+
+    // Arrange
+    const language = new Language(1, "de", "Deutsch");
+    const language2 = new Language(2, "en", "English");
+    const language3 = new Language(4, "es", "Español");
+    const availableLanguages = [language, language2, language3];
+
+
+    test('Short code could be found', () => {
+
+        // Act
+        const foundLanguage = getLanguageByShortName("de", availableLanguages);
+
+        // Assert
+        expect(foundLanguage).toStrictEqual(new Language(1, "de", "Deutsch"));
+    });
+
+    test('Short code has language code - can be found', () => {
+
+        // Act
+        const foundLanguage = getLanguageByShortName("de-AT", availableLanguages);
+
+        // Assert
+        expect(foundLanguage).toStrictEqual(new Language(1, "de", "Deutsch"));
+    });
+
+    test('Short code could not be found -> undefined', () => {
+
+        // Act
+        const foundLanguage = getLanguageByShortName("ab-CD", availableLanguages);
+
+        // Assert
+        expect(foundLanguage).toStrictEqual(undefined);
+    });
+});
+

package/src/services/language.ts

@@ -0,0 +1,35 @@
+import axios from 'axios';
+import { Language, LanguageAdapter } from "components/Exercises/models/language";
+import { ApiLanguageType } from 'types';
+import { makeHeader, makeUrl } from "utils/url";
+import { ResponseType } from "./responseType";
+
+export const API_LANGUAGE_PATH = 'language';
+
+
+/*
+ * Fetch all languages
+ */
+export const getLanguages = async (): Promise<Language[]> => {
+    const url = makeUrl(API_LANGUAGE_PATH);
+    const { data: receivedLanguages } = await axios.get<ResponseType<ApiLanguageType>>(url, {
+        headers: makeHeader(),
+    });
+    const adapter = new LanguageAdapter();
+    return receivedLanguages.results.map(l => adapter.fromJson(l));
+};
+
+/*
+ * Searches for the language with the given short name
+ */
+export const getLanguageByShortName = (name: string, availableLanguages: Language[]): Language | undefined => {
+
+    // If the name is in the form of "en-US", remove the country code
+    const shortName = name.split('-')[0];
+
+    const language = availableLanguages.find(l => l.nameShort === shortName);
+    if (language) {
+        return language;
+    }
+    return undefined;
+};

package/src/services/languageCheck.ts

@@ -0,0 +1,33 @@
+import axios from 'axios';
+import { makeHeader, makeUrl } from "utils/url";
+
+export const LANGUAGE_DETECTION = 'check-language';
+
+
+/*
+ * Check if an input string is in a particular language.
+ *
+ * Either languageId or languageCode must be provided.
+ */
+export type LanguageCheckInput =
+    | { input: string; languageId: number; languageCode?: string }
+    | { input: string; languageCode: string; languageId?: number };
+
+export const checkLanguage = async (data: LanguageCheckInput): Promise<object> => {
+
+    const url = makeUrl(LANGUAGE_DETECTION);
+    const payload = {
+        input: data.input,
+        ...(data.languageId !== undefined
+            ? { language: data.languageId }
+            : { languageCode: data.languageCode })
+    };
+
+    const response = await axios.post(
+        url,
+        payload,
+        { headers: makeHeader() },
+    );
+
+    return response.data;
+};

package/src/services/meal.ts

@@ -0,0 +1,67 @@
+import axios from 'axios';
+import { ApiMealType, Meal } from "components/Nutrition/models/meal";
+import { ApiMealItemType, MealItem } from "components/Nutrition/models/mealItem";
+import { getIngredients } from "services/ingredient";
+import { getWeightUnit } from "services/ingredientweightunit";
+import { ResponseType } from "services/responseType";
+import { ApiPath } from "utils/consts";
+import { makeHeader, makeUrl } from "utils/url";
+
+
+export const addMeal = async (meal: Meal): Promise<Meal> => {
+    const response = await axios.post(
+        makeUrl(ApiPath.MEAL),
+        meal.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return Meal.fromJson(response.data);
+};
+
+export const editMeal = async (meal: Meal): Promise<Meal> => {
+    const response = await axios.patch(
+        makeUrl(ApiPath.MEAL, { id: meal.id! }),
+        meal.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return Meal.fromJson(response.data);
+};
+
+export const deleteMeal = async (id: number): Promise<void> => {
+    await axios.delete(
+        makeUrl(ApiPath.MEAL, { id: id }),
+        { headers: makeHeader() },
+    );
+};
+
+export const getMealsForPlan = async (planId: number): Promise<Meal[]> => {
+
+    let ingredientIds: number[] = [];
+    const { data: receivedMeals } = await axios.get<ResponseType<ApiMealType>>(
+        makeUrl(ApiPath.MEAL, { query: { plan: planId } }),
+        { headers: makeHeader() },
+    );
+    const meals = receivedMeals.results.map((meal) => Meal.fromJson(meal));
+    for (const meal of meals) {
+        ingredientIds = [];
+
+        const { data: receivedMealItems } = await axios.get<ResponseType<ApiMealItemType>>(
+            makeUrl(ApiPath.MEAL_ITEM, { query: { meal: meal.id } }),
+            { headers: makeHeader() },
+        );
+        const items = receivedMealItems.results.map((item) => MealItem.fromJson(item));
+
+        for (const item of items) {
+            ingredientIds.push(item.ingredientId);
+        }
+        const ingredients = await getIngredients(ingredientIds);
+
+        for (const item of items) {
+            item.weightUnit = await getWeightUnit(item.weightUnitId);
+            item.ingredient = ingredients.find((ingredient) => ingredient.id === item.ingredientId)!;
+        }
+        meal.items = items;
+    }
+    return meals;
+};

package/src/services/mealItem.ts

@@ -0,0 +1,32 @@
+import axios from 'axios';
+import { MealItem } from "components/Nutrition/models/mealItem";
+import { ApiPath } from "utils/consts";
+import { makeHeader, makeUrl } from "utils/url";
+
+
+export const addMealItem = async (data: MealItem): Promise<MealItem> => {
+    const response = await axios.post(
+        makeUrl(ApiPath.MEAL_ITEM),
+        data.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return MealItem.fromJson(response.data);
+};
+
+export const editMealItem = async (mealItem: MealItem): Promise<MealItem> => {
+    const response = await axios.patch(
+        makeUrl(ApiPath.MEAL_ITEM, { id: mealItem.id! }),
+        mealItem.toJson(),
+        { headers: makeHeader() }
+    );
+
+    return MealItem.fromJson(response.data);
+};
+
+export const deleteMealItem = async (id: number): Promise<void> => {
+    await axios.delete(
+        makeUrl(ApiPath.MEAL_ITEM, { id: id }),
+        { headers: makeHeader() },
+    );
+};

package/src/services/measurements.test.ts

@@ -0,0 +1,106 @@
+import axios from "axios";
+import { MeasurementCategory } from "components/Measurements/models/Category";
+import { MeasurementEntry } from "components/Measurements/models/Entry";
+import { getMeasurementCategories, getMeasurementCategory } from "services/measurements";
+
+jest.mock("axios");
+
+describe('measurement service tests', () => {
+    const measurementEntryResponse = {
+        count: 2,
+        next: null,
+        previous: null,
+        results: [
+            {
+                "id": 1,
+                "category": 1,
+                "value": 80,
+                "date": "2021-01-01",
+                "notes": ""
+            }
+        ]
+    };
+
+    const measurementOverviewResponse = {
+        count: 2,
+        next: null,
+        previous: null,
+        results: [
+            {
+                "id": 1,
+                "name": "Weight",
+                "unit": "kg"
+            }
+        ]
+    };
+
+    const measurementDetailResponse = {
+        "id": 1,
+        "name": "Weight",
+        "unit": "kg"
+    };
+
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+
+        (axios.get as jest.Mock).mockImplementation((url: string) => {
+            if (url.includes("measurement-category")) {
+                return Promise.resolve({ data: measurementOverviewResponse });
+            } else if (url.includes("measurement/?category=1")) {
+                return Promise.resolve({ data: measurementEntryResponse });
+            }
+        });
+    });
+
+    test('Correctly filters categories and entries', async () => {
+
+        await getMeasurementCategories({
+            filtersetQueryEntries: { foo: "bar" },
+            filtersetQueryCategories: { baz: "1234" }
+        });
+
+        expect(axios.get).toHaveBeenCalledTimes(2);
+        expect(axios.get).toHaveBeenNthCalledWith(1,
+            expect.stringContaining('baz=1234'),
+            expect.anything()
+        );
+        expect(axios.get).toHaveBeenNthCalledWith(2,
+            expect.stringContaining('foo=bar'),
+            expect.anything()
+        );
+
+    });
+
+    test('GET measurement categories', async () => {
+
+        const result = await getMeasurementCategories();
+        expect(axios.get).toHaveBeenCalledTimes(2);
+
+        expect(result).toStrictEqual([
+            new MeasurementCategory(1, "Weight", "kg", [
+                new MeasurementEntry(1, 1, new Date("2021-01-01"), 80, "")
+            ])
+        ]);
+    });
+
+    test('GET measurement category', async () => {
+
+        (axios.get as jest.Mock).mockImplementation((url: string) => {
+            if (url.includes("measurement-category/1")) {
+                return Promise.resolve({ data: measurementDetailResponse });
+            } else if (url.includes("measurement/?category=1")) {
+                return Promise.resolve({ data: measurementEntryResponse });
+            }
+        });
+
+        const result = await getMeasurementCategory(1);
+        expect(axios.get).toHaveBeenCalledTimes(2);
+
+        expect(result).toStrictEqual(
+            new MeasurementCategory(1, "Weight", "kg", [
+                new MeasurementEntry(1, 1, new Date("2021-01-01"), 80, "")
+            ])
+        );
+    });
+});