@wger-project/react-components 25.10.16

package/src/components/WorkoutRoutines/models/BaseConfig.ts

@@ -0,0 +1,118 @@
+/* eslint-disable camelcase */
+
+import { Adapter } from "utils/Adapter";
+
+export interface BaseConfigEntryForm {
+    // This value is only used to change the conditional validation.
+    // This is kinda ugly but seems to be the cleanest way to do it
+    forceInteger: boolean;
+
+    edited: boolean;
+    iteration: number;
+    id: number | null;
+    idMax: number | null;
+    value: number | string;
+    valueMax: number | string;
+    operation: OperationType;
+    operationMax: OperationType;
+    step: StepType;
+    stepMax: StepType;
+    requirements: RequirementsType[];
+    requirementsMax: RequirementsType[];
+    repeat: boolean;
+    repeatMax: boolean;
+}
+
+export const OPERATION_REPLACE = 'r';
+export const OPERATION_ADD = '+';
+export const OPERATION_SUBSTRACT = '-';
+
+export const REQUIREMENTS_VALUES = ["weight", "repetitions", "rir", "rest"] as const;
+
+export type OperationType = "+" | "-" | "r";
+export type StepType = "abs" | "percent";
+export type RequirementsType = typeof REQUIREMENTS_VALUES;
+
+
+export const STEP_VALUES_SELECT = [
+    { value: 'abs', 'label': 'Absolute' },
+    { value: 'percent', 'label': 'Percent' },
+];
+
+export const OPERATION_VALUES_SELECT = [
+    { value: OPERATION_ADD, label: 'Add' },
+    { value: OPERATION_SUBSTRACT, label: 'Subtract' },
+    { value: OPERATION_REPLACE, label: 'Replace' },
+];
+
+export const RIR_VALUES_SELECT_LIST = [
+    { value: '', label: '-/-' },
+    ...[0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4].map(value => ({ value: value, label: value.toString() })),
+    { value: 4.5, label: '4+' }
+];
+
+export const RIR_VALUES_SELECT = [...RIR_VALUES_SELECT_LIST] as const;
+
+export interface RuleRequirements {
+    rules: RequirementsType[];
+}
+
+export class BaseConfig {
+    id: number;
+    slotEntryId: number;
+    iteration: number;
+    value: number;
+    operation: OperationType;
+    step: StepType;
+    repeat: boolean;
+    requirements: RuleRequirements | null;
+
+
+    constructor(data: {
+        id: number;
+        slotEntryId: number;
+        iteration: number;
+        value: number;
+        operation?: OperationType;
+        step?: StepType;
+        repeat?: boolean;
+        requirements?: RuleRequirements | null;
+    }) {
+        this.id = data.id;
+        this.slotEntryId = data.slotEntryId;
+        this.iteration = data.iteration;
+        this.value = data.value;
+        this.operation = data.operation ?? 'r';
+        this.step = data.step ?? 'abs';
+        this.repeat = data.repeat ?? false;
+        this.requirements = data.requirements ?? null;
+    }
+
+    get replace() {
+        return this.operation === "r";
+    }
+}
+
+export class BaseConfigAdapter implements Adapter<BaseConfig> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fromJson = (item: any) => new BaseConfig({
+        id: item.id,
+        slotEntryId: item.slot_entry,
+        iteration: item.iteration,
+        value: parseFloat(item.value),
+        operation: item.operation,
+        step: item.step,
+        repeat: item.repeat,
+        requirements: item.requirements
+    });
+
+    toJson = (item: BaseConfig) => ({
+        slot_entry: item.slotEntryId,
+        iteration: item.iteration,
+        value: item.value,
+        operation: item.operation,
+        step: item.step,
+        repeat: item.repeat,
+        requirements: item.requirements,
+    });
+}

package/src/components/WorkoutRoutines/models/Day.test.ts

@@ -0,0 +1,15 @@
+import { Day } from "components/WorkoutRoutines/models/Day";
+
+describe('Day model tests', () => {
+
+    test('correctly clones an object', async () => {
+        const day = new Day({ id: 1, routineId: 2, name: 'Chest Day', order: 0, isRest: false });
+        const day2 = Day.clone(day, { name: 'Leg Day', isRest: true });
+
+        expect(day2.id).toBe(1);
+        expect(day2.isRest).toBe(true);
+        expect(day2.name).toBe('Leg Day');
+        expect(day2.routineId).toBe(2);
+        expect(day2.order).toBe(0);
+    });
+});

package/src/components/WorkoutRoutines/models/Day.ts

@@ -0,0 +1,117 @@
+/* eslint-disable camelcase */
+
+import { Slot } from "components/WorkoutRoutines/models/Slot";
+import i18n from 'i18next';
+import { Adapter } from "utils/Adapter";
+
+interface DayConstructorParams {
+    id?: number;
+    routineId: number | null;
+    order: number;
+    name: string;
+    description?: string;
+    isRest?: boolean;
+    needLogsToAdvance?: boolean;
+    type?: 'custom' | 'enom' | 'amrap' | 'hiit' | 'tabata' | 'edt' | 'rft' | 'afap';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    config?: any | null;
+    slots?: Slot[];
+}
+
+export class Day {
+
+    id: number | null = null;
+    // Note that this can only be null when loading the data from dayData. Perhaps we should include
+    // it there as well? Otherwise we just have to be a bit careful when editing regular day
+    // objects in forms or so
+    routineId: number | null = null;
+    order: number;
+    name: string;
+    description: string;
+    isRest: boolean;
+    needLogsToAdvance: boolean;
+    type: 'custom' | 'enom' | 'amrap' | 'hiit' | 'tabata' | 'edt' | 'rft' | 'afap';
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    config: any | null;
+
+    slots: Slot[] = [];
+
+    constructor(data: DayConstructorParams) {
+        this.id = data.id ?? null;
+        this.routineId = data.routineId ?? null;
+        this.order = data.order;
+        this.name = data.name;
+        this.description = data.description ?? '';
+        this.isRest = data.isRest ?? false;
+        this.needLogsToAdvance = data.needLogsToAdvance ?? false;
+        this.type = data.type ?? 'custom';
+        this.config = data.config ?? null;
+        this.slots = data.slots ?? [];
+    }
+
+    public get isSpecialType(): boolean {
+        return this.type !== 'custom';
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromJson(json: any): Day {
+        return adapter.fromJson(json);
+    }
+
+    static clone(other: Day, overrides?: Partial<DayConstructorParams>) {
+        return new Day({
+            id: overrides?.id ?? (other.id ?? undefined),
+            routineId: overrides?.routineId ?? other.routineId,
+            order: overrides?.order ?? other.order,
+            name: overrides?.name ?? other.name,
+            description: overrides?.description ?? other.description,
+            isRest: overrides?.isRest ?? other.isRest,
+            needLogsToAdvance: overrides?.needLogsToAdvance ?? other.needLogsToAdvance,
+            type: overrides?.type ?? other.type,
+            config: overrides?.config ?? other.config,
+            slots: overrides?.slots ?? other.slots,
+        });
+    }
+
+    public getDisplayName(): string {
+        return this.isRest ? i18n.t('routines.restDay') : this.name;
+    }
+
+    toJson() {
+        return adapter.toJson(this);
+    }
+
+}
+
+export const getDayName = (day: Day | null): string => day === null || day.isRest ? i18n.t('routines.restDay') : day.getDisplayName();
+
+
+class DayAdapter implements Adapter<Day> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fromJson = (item: any): Day => new Day({
+        id: item.id,
+        routineId: item.routine,
+        order: item.order,
+        name: item.name,
+        description: item.description,
+        isRest: item.is_rest,
+        needLogsToAdvance: item.need_logs_to_advance,
+        type: item.type,
+        config: item.config,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        slots: Object.hasOwn(item, 'slots') ? item.slots.map((slot: any) => Slot.fromJson(slot)) : [],
+    });
+
+    toJson = (item: Day) => ({
+        routine: item.routineId,
+        name: item.name,
+        order: item.order,
+        description: item.description,
+        is_rest: item.isRest,
+        need_logs_to_advance: item.needLogsToAdvance,
+        type: item.type,
+        config: item.config,
+    });
+}
+
+const adapter = new DayAdapter();

package/src/components/WorkoutRoutines/models/LogStats.test.ts

@@ -0,0 +1,44 @@
+import { LogData, RoutineStatsDataAdapter } from "components/WorkoutRoutines/models/LogStats";
+import { testRoutineStatistics } from "tests/workoutStatisticsTestData";
+
+describe('RoutineStatsDataAdapter parser tests', () => {
+
+
+    test('calls addQuery.mutate with correct data when creating a new entry', async () => {
+        const adapter = new RoutineStatsDataAdapter();
+
+        const result = adapter.fromJson(testRoutineStatistics);
+
+        expect(result.volume.mesocycle.total).toBe(150);
+        expect(result.volume.mesocycle).toStrictEqual(new LogData({
+            "exercises": {
+                "1": 20,
+                "2": 30,
+                "42": 50,
+            },
+            "muscle": {
+                "7": 70,
+                "8": 10,
+                "9": 20,
+            },
+            "upper_body": 7,
+            "lower_body": 8,
+            "total": 150
+        }));
+        expect(result.volume.daily['2024-12-01']).toStrictEqual(new LogData({
+            "exercises": {
+                "1": 20,
+                "2": 30,
+                "42": 50,
+            },
+            "muscle": {
+                "7": 70,
+                "8": 10,
+                "9": 20,
+            },
+            "upper_body": 7,
+            "lower_body": 8,
+            "total": 150
+        }));
+    });
+});

package/src/components/WorkoutRoutines/models/LogStats.ts

@@ -0,0 +1,110 @@
+import { Adapter } from "utils/Adapter";
+
+export class LogData {
+    exercises: { [exerciseId: number]: number } = {};
+    muscle: { [muscleId: number]: number } = {};
+    // eslint-disable-next-line camelcase
+    upper_body: number = 0;
+    // eslint-disable-next-line camelcase
+    lower_body: number = 0;
+    total: number = 0;
+
+    constructor(data?: Partial<LogData>) {
+        Object.assign(this, data);
+
+        // if (data) {
+        //     this.exercises = data.exercises || {};
+        //     this.muscle = data.muscle || {};
+        //     this.upperBody = parseFloat(data.upper_body);
+        //     this.lowerBody = parseFloat(data.lower_body);
+        //     this.total = parseFloat(data.total);
+        // }
+    }
+}
+
+export class GroupedLogData {
+    mesocycle: LogData = new LogData();
+    iteration: { [iteration: number]: LogData } = {};
+    weekly: { [week: number]: LogData } = {};
+    daily: { [date: string]: LogData } = {};
+
+    constructor(data?: Partial<GroupedLogData>) {
+        Object.assign(this, data);
+    }
+}
+
+export class RoutineStatsData {
+    volume: GroupedLogData = new GroupedLogData();
+    intensity: GroupedLogData = new GroupedLogData();
+    sets: GroupedLogData = new GroupedLogData();
+
+
+    constructor(data?: Partial<RoutineStatsData>) {
+        Object.assign(this, data);
+    }
+}
+
+
+export class RoutineStatsDataAdapter implements Adapter<RoutineStatsData> {
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fromJson(item: any): RoutineStatsData {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const convertLogDataToClass = (logData: any): LogData => {
+
+            const exercises: { [exerciseId: number]: number } = {};
+            for (const exerciseId in logData.exercises) {
+                exercises[parseInt(exerciseId)] = parseFloat(logData.exercises[exerciseId]);
+            }
+
+            const muscle: { [muscleId: number]: number } = {};
+            for (const muscleId in logData.muscle) {
+                muscle[parseInt(muscleId)] = parseFloat(logData.muscle[muscleId]);
+            }
+
+            return new LogData({
+                exercises: exercises,
+                muscle: muscle,
+                // eslint-disable-next-line camelcase
+                upper_body: parseFloat(logData.upper_body),
+                // eslint-disable-next-line camelcase
+                lower_body: parseFloat(logData.lower_body),
+                total: parseFloat(logData.total),
+            });
+        };
+
+        const convertGroupedLogDataToClass = (groupedLogData: GroupedLogData): GroupedLogData => {
+
+            const iteration: { [key: number]: LogData } = {};
+            for (const key in groupedLogData.iteration) {
+                iteration[key] = convertLogDataToClass(groupedLogData.iteration[key]);
+            }
+
+            const weekly: { [key: number]: LogData } = {};
+            for (const key in groupedLogData.weekly) {
+                weekly[key] = convertLogDataToClass(groupedLogData.weekly[key]);
+            }
+
+
+            const daily: { [key: string]: LogData } = {};
+            for (const key in groupedLogData.daily) {
+                daily[key] = convertLogDataToClass(groupedLogData.daily[key]);
+            }
+
+            return new GroupedLogData({
+                mesocycle: convertLogDataToClass(groupedLogData.mesocycle),
+                iteration: iteration,
+                weekly: weekly,
+                daily: daily
+            });
+        };
+
+
+        return new RoutineStatsData({
+            volume: convertGroupedLogDataToClass(item.volume),
+            intensity: convertGroupedLogDataToClass(item.intensity),
+            sets: convertGroupedLogDataToClass(item.sets)
+        });
+    }
+
+}

package/src/components/WorkoutRoutines/models/RepetitionUnit.ts

@@ -0,0 +1,22 @@
+import { Adapter } from "utils/Adapter";
+
+export class RepetitionUnit {
+    id: number;
+    name: string;
+
+    constructor(id: number, description: string) {
+        this.id = id;
+        this.name = description;
+    }
+}
+
+
+export class RepetitionUnitAdapter implements Adapter<RepetitionUnit> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fromJson(item: any): RepetitionUnit {
+        return new RepetitionUnit(
+            item.id,
+            item.name,
+        );
+    }
+}

package/src/components/WorkoutRoutines/models/Routine.test.ts

@@ -0,0 +1,113 @@
+import { DEFAULT_WORKOUT_DURATION, Routine } from "components/WorkoutRoutines/models/Routine";
+import { DateTime } from "luxon";
+import {
+    testMuscleBiggus,
+    testMuscleDacttilaris,
+    testMuscleDeltoid,
+    testMuscleRectusAbdominis
+} from "tests/exerciseTestdata";
+import { testRoutine1, testRoutineDayData1 } from "tests/workoutRoutinesTestData";
+import { isSameDay } from "utils/date";
+
+describe('Routine model tests', () => {
+
+    let routine: Routine;
+
+    beforeEach(() => {
+        routine = testRoutine1;
+    });
+
+
+    test('Correctly initialises the object with default values', () => {
+        // Arrange
+        const testRoutine = new Routine();
+
+        // Assert
+        expect(testRoutine.id).toEqual(null);
+        expect(testRoutine.name).toEqual('');
+        expect(testRoutine.description).toEqual('');
+        expect(isSameDay(testRoutine.created, new Date())).toBeTruthy();
+        expect(isSameDay(testRoutine.start, new Date())).toBeTruthy();
+        expect(isSameDay(
+            testRoutine.end,
+            DateTime.local().plus({ weeks: DEFAULT_WORKOUT_DURATION }).toJSDate()
+        )).toBeTruthy();
+        expect(testRoutine.fitInWeek).toEqual(true);
+        expect(testRoutine.isTemplate).toEqual(false);
+        expect(testRoutine.isPublic).toEqual(false);
+        expect(testRoutine.days).toEqual([]);
+        expect(testRoutine.dayData).toEqual([]);
+    });
+
+    test('correctly calculates the routine duration - less than 1 week', () => {
+        // Arrange
+        routine.start = new Date('2025-01-01');
+        routine.end = new Date('2025-01-02');
+
+        // Act
+        const duration = routine.duration;
+        const durationText = routine.durationText;
+
+        // Assert
+        expect(duration.days).toEqual(1);
+        expect(duration.weeks).toEqual(0);
+        expect(durationText).toEqual('durationWeeksDays');
+    });
+
+    test('correctly calculates the routine duration - exactly one week', () => {
+        // Arrange
+        routine.end = new Date('2025-01-08');
+
+        // Act
+        const duration = routine.duration;
+        const durationText = routine.durationText;
+
+        // Assert
+        expect(duration.days).toEqual(0);
+        expect(duration.weeks).toEqual(1);
+        expect(durationText).toEqual('durationWeeks');
+    });
+
+    test('correctly calculates the routine duration - more than one week', () => {
+        // Arrange
+        routine.end = new Date('2025-01-10');
+
+        // Act
+        const duration = routine.duration;
+        const durationText = routine.durationText;
+
+        // Assert
+        expect(duration.days).toEqual(2);
+        expect(duration.weeks).toEqual(1);
+        expect(durationText).toEqual('durationWeeksDays');
+    });
+
+    test('correctly returns all the trained muscles', () => {
+        // Act
+        const muscles = routine.mainMuscles;
+
+        // Assert
+        expect(muscles).toEqual([testMuscleBiggus, testMuscleRectusAbdominis, testMuscleDacttilaris, testMuscleDeltoid]);
+    });
+
+    test('correctly returns all the secondary trained muscles', () => {
+        // Act
+        const muscles = routine.secondaryMuscles;
+
+        // Assert
+        expect(muscles).toEqual([]);
+    });
+
+    test('correctly calculates the iteration for a date', () => {
+
+        // Assert
+        expect(routine.getIteration(new Date('2024-01-01'))).toEqual(null);
+        expect(routine.getIteration(new Date('2024-05-05'))).toEqual(1);
+    });
+
+    test('correctly returns the DayData for an iteration', () => {
+
+        // Assert
+        expect(routine.dayDataCurrentIteration).toEqual(testRoutineDayData1);
+    });
+});