@wger-project/react-components 25.10.16

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

@@ -0,0 +1,218 @@
+import { Day } from "components/WorkoutRoutines/models/Day";
+import { RoutineDayData } from "components/WorkoutRoutines/models/RoutineDayData";
+import i18n from 'i18next';
+import { DateTime } from "luxon";
+import { Adapter } from "utils/Adapter";
+import { dateToYYYYMMDD, isSameDay } from "utils/date";
+
+export const NAME_MIN_LENGTH = 3;
+export const NAME_MAX_LENGTH = 25;
+export const DESCRIPTION_MAX_LENGTH = 1000;
+
+// Durations in weeks
+export const MIN_WORKOUT_DURATION = 1;
+export const MAX_WORKOUT_DURATION = 16;
+export const DEFAULT_WORKOUT_DURATION = 12;
+
+
+type RoutineConstructorParams = {
+    id?: number | null;
+    name?: string;
+    description?: string;
+    created?: Date;
+    start?: Date;
+    end?: Date;
+    fitInWeek?: boolean;
+    isTemplate?: boolean;
+    isPublic?: boolean;
+
+    days?: Day[];
+    dayData?: RoutineDayData[];
+};
+
+export class Routine {
+    id: number | null = null;
+    name: string = '';
+    description: string = '';
+    created: Date = new Date();
+    start: Date = new Date();
+    end: Date = DateTime.local().plus({ weeks: DEFAULT_WORKOUT_DURATION }).toJSDate();
+    fitInWeek: boolean = true;
+    isTemplate: boolean = false;
+    isPublic: boolean = false;
+
+    days: Day[] = [];
+    dayData: RoutineDayData[] = [];
+
+    constructor(params?: RoutineConstructorParams) {
+        Object.assign(this, params || {});
+    }
+
+    get isNotTemplate() {
+        return !this.isTemplate;
+    }
+
+    get exercises() {
+        return this.days.flatMap(day => day.slots.flatMap(slot => slot.entries.flatMap(config => config.exercise!)));
+    }
+
+    get dayDataCurrentIteration() {
+        const iteration = this.getIteration() ?? 1;
+        return this.dayData.filter(dayData => dayData.iteration === iteration);
+    }
+
+    /*
+     * Filter out dayData entries with null days
+     */
+    get dayDataCurrentIterationNoNulls() {
+        return this.dayDataCurrentIteration
+            .filter((dayData) => dayData.day !== null)
+            .sort((a, b) => a.day!.order - b.day!.order);
+    }
+
+    get groupedDayDataByIteration() {
+        const groupedDayData: { [key: number]: RoutineDayData[] } = {};
+        for (const dayData of this.dayData) {
+            if (!groupedDayData[dayData.iteration]) {
+                groupedDayData[dayData.iteration] = [];
+            }
+            groupedDayData[dayData.iteration].push(dayData);
+        }
+        return groupedDayData;
+    }
+
+    get duration() {
+        const duration = DateTime.fromJSDate(this.end).diff(DateTime.fromJSDate(this.start), ['weeks', 'days']);
+        const durationWeeks = Math.floor(duration.weeks);
+        const durationDays = Math.floor(duration.days);
+
+        return { weeks: durationWeeks, days: durationDays };
+    }
+
+    get durationText() {
+        const durationDays = this.duration.days;
+        const durationWeeks = this.duration.weeks;
+
+        return durationDays === 0 ? i18n.t('durationWeeks', { number: durationWeeks }) : i18n.t('durationWeeksDays', {
+            nrWeeks: durationWeeks,
+            nrDays: durationDays
+        });
+    }
+
+    get mainMuscles() {
+        const muscles = this.days.flatMap(day => day.slots.flatMap(slot => slot.entries.flatMap(config => config.exercise?.muscles || [])));
+        return muscles.filter((muscle, index, self) =>
+            index === self.findIndex((m) => m.id === muscle.id)
+        );
+    }
+
+    get secondaryMuscles() {
+        const muscles = this.days.flatMap(day => day.slots.flatMap(slot => slot.entries.flatMap(config => config.exercise?.musclesSecondary || [])));
+        return muscles.filter((muscle, index, self) =>
+            index === self.findIndex((m) => m.id === muscle.id)
+        );
+    }
+
+    /*
+     * Returns the length of the cycle in days
+     */
+    get cycleLength() {
+        return this.dayDataCurrentIteration.length;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromJson(json: any): Routine {
+        return routineAdapter.fromJson(json);
+    }
+
+    static clone(routine: Routine, overrides?: Partial<RoutineConstructorParams>): Routine {
+        return new Routine({
+            id: overrides?.id ?? routine.id,
+            name: overrides?.name ?? routine.name,
+            description: overrides?.description ?? routine.description,
+            created: overrides?.created ?? new Date(),
+            start: overrides?.start ?? routine.start,
+            end: overrides?.end ?? routine.end ?? undefined,
+            fitInWeek: overrides?.fitInWeek ?? routine.fitInWeek,
+            isTemplate: overrides?.isTemplate ?? routine.isTemplate,
+            isPublic: overrides?.isPublic ?? routine.isPublic,
+            days: overrides?.days ?? routine.days,
+            dayData: overrides?.dayData ?? routine.dayData,
+        });
+    }
+
+    toJson() {
+        return routineAdapter.toJson(this);
+    }
+
+    getIteration(date?: Date | undefined) {
+        const dateToCheck = date ?? new Date();
+
+        const currentDayData = this.dayData.find(dayData => isSameDay(dayData.date, dateToCheck));
+        return currentDayData ? currentDayData.iteration : null;
+    }
+
+    /*
+     * Returns the SetConfigData for the given dayId, iteration and slotId
+     */
+    getSetConfigData(dayId: number, iteration: number, slotEntryId: number) {
+        const dayData = this.dayData.find(dayData =>
+            dayData.day?.id === dayId && dayData.iteration === iteration
+        );
+
+        if (!dayData) {
+            return null;
+        }
+
+        const slotData = dayData.slots.find(slotData =>
+            slotData.setConfigs.some(setConfig => setConfig.slotEntryId === slotEntryId)
+        );
+
+        return slotData?.setConfigs.find(setConfig => setConfig.slotEntryId === slotEntryId) || null;
+    }
+
+    /*
+     * Returns the DayData for the given dayId and, optionally, iteration
+     */
+    getDayData(dayId: number, date: Date) {
+        return this.dayData.filter(dayData => dayData.day?.id === dayId
+            && dayData.date.getDate() === date.getDate()
+            && dayData.date.getMonth() === date.getMonth()
+            && dayData.date.getFullYear() === date.getFullYear(),
+        );
+    }
+}
+
+
+class RoutineAdapter implements Adapter<Routine> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fromJson(item: any) {
+        return new Routine({
+            id: item.id,
+            name: item.name,
+            description: item.description,
+            created: new Date(item.created),
+            start: new Date(item.start),
+            end: new Date(item.end),
+            fitInWeek: item.fit_in_week,
+            isTemplate: item.is_template,
+            isPublic: item.is_public,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            days: item.days ? item.days.map((day: any) => Day.fromJson(day)) : []
+        });
+    }
+
+    toJson(item: Routine) {
+        return {
+            name: item.name,
+            description: item.description,
+            start: dateToYYYYMMDD(item.start),
+            end: dateToYYYYMMDD(item.end),
+            "fit_in_week": item.fitInWeek,
+            "is_template": item.isTemplate,
+            "is_public": item.isPublic
+        };
+    }
+}
+
+const routineAdapter = new RoutineAdapter();

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

@@ -0,0 +1,38 @@
+import { Day } from "components/WorkoutRoutines/models/Day";
+import { SlotData, SlotDataAdapter } from "components/WorkoutRoutines/models/SlotData";
+import { Adapter } from "utils/Adapter";
+
+export class RoutineDayData {
+
+    slots: SlotData[] = [];
+
+    constructor(
+        public iteration: number,
+        public date: Date,
+        public label: string,
+        public day: Day | null,
+        slots?: SlotData[],
+    ) {
+        this.slots = slots ?? [];
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromJson(json: any) {
+        return adapter.fromJson(json);
+    }
+}
+
+
+class RoutineDayDataAdapter implements Adapter<RoutineDayData> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fromJson = (item: any) => new RoutineDayData(
+        item.iteration,
+        new Date(item.date),
+        item.label,
+        item.day != null ? Day.fromJson(item.day) : null,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        item.slots.map((slot: any) => new SlotDataAdapter().fromJson(slot))
+    );
+}
+
+const adapter = new RoutineDayDataAdapter();

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

@@ -0,0 +1,22 @@
+import { WorkoutLog, WorkoutLogAdapter } from "components/WorkoutRoutines/models/WorkoutLog";
+import { WorkoutSession, WorkoutSessionAdapter } from "components/WorkoutRoutines/models/WorkoutSession";
+import { Adapter } from "utils/Adapter";
+
+export class RoutineLogData {
+
+    constructor(
+        public session: WorkoutSession,
+        public logs: WorkoutLog[],
+    ) {
+    }
+}
+
+
+export class RoutineLogDataAdapter implements Adapter<RoutineLogData> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fromJson = (item: any) => new RoutineLogData(
+        new WorkoutSessionAdapter().fromJson(item.session),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        item.logs.map((log: any) => new WorkoutLogAdapter().fromJson(log)),
+    );
+}

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

@@ -0,0 +1,121 @@
+import { Exercise } from "components/Exercises/models/exercise";
+import { RepetitionUnit } from "components/WorkoutRoutines/models/RepetitionUnit";
+import { WeightUnit } from "components/WorkoutRoutines/models/WeightUnit";
+import { Adapter } from "utils/Adapter";
+
+export type SetType = "normal" | "dropset" | "myo" | "partial" | "forced" | "tut" | "iso" | "jump";
+
+export class SetConfigData {
+
+    exercise?: Exercise;
+    weightUnit: WeightUnit | null = null;
+    repetitionsUnit: RepetitionUnit | null = null;
+
+    public exerciseId: number;
+    public slotEntryId: number;
+    public type: SetType;
+    public nrOfSets: number;
+    public maxNrOfSets: number | null;
+    public weight: number | null;
+    public maxWeight: number | null;
+    public weightUnitId: number | null = null;
+    public weightRounding: number | null = null;
+    public repetitions: number | null;
+    public maxRepetitions: number | null;
+    public repetitionsUnitId: number | null = null;
+    public repetitionsRounding: number | null = null;
+    public rir: number | null;
+    public maxRir: number | null;
+    public rpe: number | null;
+    public restTime: number | null;
+    public maxRestTime: number | null;
+    public textRepr: string;
+    public comment: string;
+
+    constructor(data: {
+        exercise?: Exercise,
+        exerciseId: number,
+        slotEntryId: number,
+        type: SetType,
+        nrOfSets: number,
+        maxNrOfSets?: number | null,
+
+        weight?: number | null,
+        maxWeight?: number | null,
+        weightUnitId: number | null,
+        weightUnit?: WeightUnit,
+        weightRounding: number | null,
+
+        repetitions?: number | null,
+        maxRepetitions?: number | null,
+        repetitionsUnitId: number | null,
+        repetitionsUnit?: RepetitionUnit,
+        repetitionsRounding: number | null,
+
+        rir?: number | null,
+        maxRir?: number | null,
+        rpe?: number | null,
+        restTime?: number | null,
+        maxRestTime?: number | null,
+        textRepr: string,
+        comment: string,
+    }) {
+        this.exerciseId = data.exerciseId;
+        this.exercise = data.exercise;
+        this.slotEntryId = data.slotEntryId;
+        this.type = data.type;
+        this.nrOfSets = data.nrOfSets;
+        this.maxNrOfSets = data.maxNrOfSets ?? null;
+
+        this.weight = data.weight ?? null;
+        this.maxWeight = data.maxWeight ?? null;
+        this.weightUnitId = data.weightUnitId;
+        this.weightUnit = data.weightUnit ?? null;
+        this.weightRounding = data.weightRounding;
+
+        this.repetitions = data.repetitions ?? null;
+        this.maxRepetitions = data.maxRepetitions ?? null;
+        this.repetitionsUnitId = data.repetitionsUnitId;
+        this.repetitionsUnit = data.repetitionsUnit ?? null;
+        this.repetitionsRounding = data.repetitionsRounding;
+
+        this.rir = data.rir ?? null;
+        this.maxRir = data.maxRir ?? null;
+        this.rpe = data.rpe ?? null;
+        this.restTime = data.restTime ?? null;
+        this.maxRestTime = data.maxRestTime ?? null;
+        this.textRepr = data.textRepr;
+        this.comment = data.comment;
+    }
+
+    public get isSpecialType(): boolean {
+        return this.type !== 'normal';
+    }
+}
+
+
+export class SetConfigDataAdapter implements Adapter<SetConfigData> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fromJson = (item: any) => new SetConfigData({
+        exerciseId: item.exercise,
+        slotEntryId: item.slot_entry_id,
+        type: item.type,
+        nrOfSets: item.sets,
+        maxNrOfSets: item.max_sets !== null ? parseInt(item.max_sets) : null,
+        weight: item.weight !== null ? parseFloat(item.weight) : null,
+        maxWeight: item.max_weight !== null ? parseFloat(item.max_weight) : null,
+        weightUnitId: item.weight_unit,
+        weightRounding: item.weight_rounding !== null ? parseFloat(item.weight_rounding) : null,
+        repetitions: item.repetitions !== null ? parseFloat(item.repetitions) : null,
+        maxRepetitions: item.max_repetitions !== null ? parseFloat(item.max_repetitions) : null,
+        repetitionsUnitId: item.repetitions_unit,
+        repetitionsRounding: item.repetitions_rounding !== null ? parseFloat(item.repetitions_rounding) : null,
+        rir: item.rir !== null ? parseFloat(item.rir) : null,
+        maxRir: item.max_rir !== null ? parseFloat(item.max_rir) : null,
+        rpe: item.rpe !== null ? parseFloat(item.rpe) : null,
+        restTime: item.rest !== null ? parseInt(item.rest) : null,
+        maxRestTime: item.max_rest !== null ? parseInt(item.max_rest) : null,
+        textRepr: item.text_repr,
+        comment: item.comment,
+    });
+}

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

@@ -0,0 +1,19 @@
+import { Slot } from "components/WorkoutRoutines/models/Slot";
+
+describe('Slot model tests', () => {
+
+
+    test('Correctly initialises the object with default values', () => {
+        // Arrange
+        const slot = new Slot({ dayId: 1234 });
+
+        // Assert
+        expect(slot.id).toEqual(null);
+        expect(slot.dayId).toEqual(1234);
+        expect(slot.order).toEqual(1);
+        expect(slot.comment).toEqual('');
+        expect(slot.config).toEqual(null);
+        expect(slot.entries).toEqual([]);
+    });
+
+});

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

@@ -0,0 +1,83 @@
+import { SlotEntry } from "components/WorkoutRoutines/models/SlotEntry";
+import { Adapter } from "utils/Adapter";
+
+export type SlotApiData = {
+    id: number,
+    day: number,
+    order: number,
+    comment: string,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    config: any,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    entries?: any[],
+}
+
+type SlotConstructorParams = {
+    id?: number;
+    dayId: number;
+    order?: number;
+    comment?: string;
+    config?: object | null;
+    entries?: SlotEntry[];
+};
+
+export class Slot {
+
+    id: number | null = null;
+    dayId: number;
+    order: number = 1;
+    comment: string = '';
+    config: object | null = null;
+
+    entries: SlotEntry[] = [];
+
+    constructor(data: SlotConstructorParams) {
+        this.dayId = data.dayId;
+
+        Object.assign(this, data || {});
+    }
+
+    static clone(other: Slot, overrides?: Partial<SlotConstructorParams>): Slot {
+        return new Slot({
+            id: overrides?.id ?? other.id ?? undefined,
+            dayId: overrides?.dayId ?? other.dayId,
+            order: overrides?.order ?? other.order,
+            comment: overrides?.comment ?? other.comment,
+            config: overrides?.config ?? other.config,
+            // entries: overrides?.entries ?? other.entries.map(entry => SlotEntry.clone(entry))
+        });
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromJson(json: any): Slot {
+        return adapter.fromJson(json);
+    }
+
+    toJson() {
+        return adapter.toJson(this);
+    }
+}
+
+
+class SlotAdapter implements Adapter<Slot> {
+    fromJson = (item: SlotApiData) => new Slot({
+        id: item.id,
+        dayId: item.day,
+        order: item.order,
+        comment: item.comment,
+        config: item.config,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        entries: Object.hasOwn(item, 'entries') ? item.entries!.map((entry: any) => SlotEntry.fromJson(entry)) : []
+    });
+
+    toJson(item: Slot): Partial<SlotApiData> {
+        return {
+            day: item.dayId,
+            order: item.order,
+            comment: item.comment,
+            config: item.config,
+        };
+    }
+}
+
+const adapter = new SlotAdapter();

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

@@ -0,0 +1,30 @@
+import { Exercise } from "components/Exercises/models/exercise";
+import { SetConfigData, SetConfigDataAdapter } from "components/WorkoutRoutines/models/SetConfigData";
+import { Adapter } from "utils/Adapter";
+
+export class SlotData {
+
+    exercises: Exercise[] = [];
+
+    constructor(
+        public comment: string,
+        public isSuperset: boolean,
+        public exerciseIds: number[],
+        public setConfigs: SetConfigData[],
+        exercises?: Exercise[],
+    ) {
+        this.exercises = exercises ?? [];
+    }
+}
+
+
+export class SlotDataAdapter implements Adapter<SlotData> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fromJson = (item: any) => new SlotData(
+        item.comment,
+        item.is_superset,
+        item.exercises,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        item.sets.map((item: any) => new SetConfigDataAdapter().fromJson(item))
+    );
+}

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

@@ -0,0 +1,31 @@
+import { SlotEntry } from "components/WorkoutRoutines/models/SlotEntry";
+import { testSlotEntryApiResponse } from "tests/slotEntryApiResponse";
+
+describe('SlotEntry model tests', () => {
+
+
+    test('correctly parses the JSON response', () => {
+        // Act
+        const result = SlotEntry.fromJson(testSlotEntryApiResponse);
+
+        // Assert
+        expect(result.id).toEqual(143);
+        expect(result.nrOfSetsConfigs[0].id).toEqual(145);
+        expect(result.nrOfSetsConfigs[0].value).toEqual(2);
+
+        expect(result.maxNrOfSetsConfigs[0].id).toEqual(222);
+        expect(result.maxNrOfSetsConfigs[0].value).toEqual(4);
+
+        expect(result.weightConfigs[0].id).toEqual(142);
+        expect(result.weightConfigs[0].value).toEqual(102.5);
+
+        expect(result.maxWeightConfigs[0].id).toEqual(143);
+        expect(result.maxWeightConfigs[0].value).toEqual(120);
+
+        expect(result.restTimeConfigs[0].id).toEqual(54);
+        expect(result.restTimeConfigs[0].value).toEqual(120);
+
+        expect(result.maxRestTimeConfigs[0].id).toEqual(45);
+        expect(result.maxRestTimeConfigs[0].value).toEqual(150);
+    });
+});