Lars
3898e8bc2c
All checks were successful
Deploy Development / deploy (push) Successful in 38s
Test Suite / pytest-backend (push) Successful in 35s
Test Suite / lint-backend (push) Successful in 0s
Test Suite / build-frontend (push) Successful in 11s
Test Suite / playwright-tests (push) Successful in 59s
- Integrated PsycopgJson for improved handling of planning method profiles in the backend. - Updated CombinationPlanBracket to display primary load labels for better clarity in the UI. - Enhanced TrainingUnitSectionsEditor and utility functions to ensure proper serialization of planning profiles, preventing potential errors during API interactions. - Improved CSS for combo plan brackets to enhance visual alignment and presentation. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
530 lines
19 KiB
JavaScript
530 lines
19 KiB
JavaScript
import api from './api'
|
||
import { sortCombinationSlotsForDisplay } from '../constants/combinationArchetypes'
|
||
|
||
export function defaultSection(title = 'Hauptteil') {
|
||
return { title, guidance_notes: '', items: [] }
|
||
}
|
||
|
||
function normalizeCatalogMethodProfile(cp) {
|
||
if (cp && typeof cp === 'object' && !Array.isArray(cp)) return { ...cp }
|
||
return {}
|
||
}
|
||
|
||
/** NULL = Planung folgt Katalogprofil der Übung (Reihenfolge beibehalten: zuerst String-JSON auflösen). */
|
||
function normalizePlanningMethodProfile(pm) {
|
||
if (pm == null) return null
|
||
if (typeof pm === 'string') {
|
||
const t = pm.trim()
|
||
if (!t || t === 'null') return null
|
||
try {
|
||
const p = JSON.parse(t)
|
||
if (p && typeof p === 'object' && !Array.isArray(p)) return { ...p }
|
||
return null
|
||
} catch {
|
||
return null
|
||
}
|
||
}
|
||
if (typeof pm === 'object' && !Array.isArray(pm)) return { ...pm }
|
||
return null
|
||
}
|
||
|
||
/** Reines JSON für PUT /training-units (vermeidet nicht serialisierbare Werte → 500). */
|
||
export function cloneJsonSerializablePlanningProfile(obj) {
|
||
if (obj == null || typeof obj !== 'object' || Array.isArray(obj)) return null
|
||
try {
|
||
return JSON.parse(JSON.stringify(obj))
|
||
} catch {
|
||
return {}
|
||
}
|
||
}
|
||
|
||
export function exerciseRow() {
|
||
return {
|
||
item_type: 'exercise',
|
||
exercise_id: '',
|
||
exercise_variant_id: '',
|
||
exercise_kind: 'simple',
|
||
exercise_title: '',
|
||
variants: [],
|
||
planned_duration_min: '',
|
||
actual_duration_min: '',
|
||
notes: '',
|
||
modifications: '',
|
||
source_training_module_id: '',
|
||
source_module_title: '',
|
||
catalog_method_archetype: '',
|
||
catalog_method_profile: {},
|
||
planning_method_profile: null,
|
||
}
|
||
}
|
||
|
||
export async function hydrateExercisePlanningRow(exercise) {
|
||
let variants = Array.isArray(exercise?.variants) ? exercise.variants : []
|
||
let title = exercise?.title || ''
|
||
let exerciseKind = exercise?.exercise_kind
|
||
const id = exercise?.id
|
||
if (!id) return null
|
||
let meta = {}
|
||
|
||
let full
|
||
|
||
async function ensureFull() {
|
||
if (full !== undefined) return full
|
||
try {
|
||
full = await api.getExercise(id)
|
||
} catch {
|
||
full = null
|
||
}
|
||
return full
|
||
}
|
||
|
||
if (!variants.length) {
|
||
await ensureFull()
|
||
if (full) {
|
||
variants = Array.isArray(full.variants) ? full.variants : []
|
||
title = full.title || title
|
||
if (exerciseKind == null) exerciseKind = full.exercise_kind
|
||
meta = {
|
||
exercise_visibility: full.visibility || 'private',
|
||
exercise_club_id: full.club_id ?? null,
|
||
exercise_created_by: full.created_by ?? null,
|
||
exercise_status: full.status || 'draft',
|
||
catalog_method_archetype: typeof full.method_archetype === 'string' ? full.method_archetype.trim() : '',
|
||
catalog_method_profile: normalizeCatalogMethodProfile(full.method_profile),
|
||
}
|
||
}
|
||
} else {
|
||
meta = {
|
||
exercise_visibility: exercise?.visibility ?? null,
|
||
exercise_club_id: exercise?.club_id ?? null,
|
||
exercise_created_by: exercise?.created_by ?? null,
|
||
exercise_status: exercise?.status ?? null,
|
||
}
|
||
if (
|
||
meta.exercise_visibility == null ||
|
||
meta.exercise_created_by == null ||
|
||
exerciseKind == null
|
||
) {
|
||
await ensureFull()
|
||
if (full) {
|
||
if (meta.exercise_visibility == null) meta.exercise_visibility = full.visibility || 'private'
|
||
if (meta.exercise_club_id == null) meta.exercise_club_id = full.club_id ?? null
|
||
if (meta.exercise_created_by == null) meta.exercise_created_by = full.created_by ?? null
|
||
if (meta.exercise_status == null) meta.exercise_status = full.status || 'draft'
|
||
if (exerciseKind == null) exerciseKind = full.exercise_kind
|
||
if (!variants.length) variants = Array.isArray(full.variants) ? full.variants : []
|
||
}
|
||
}
|
||
meta.exercise_visibility = meta.exercise_visibility || 'private'
|
||
meta.exercise_status = meta.exercise_status || 'draft'
|
||
}
|
||
|
||
const row = exerciseRow()
|
||
row.exercise_id = id
|
||
row.exercise_variant_id = ''
|
||
row.exercise_title = title
|
||
row.exercise_kind =
|
||
String(exerciseKind || 'simple').toLowerCase().trim() === 'combination' ? 'combination' : 'simple'
|
||
if (row.exercise_kind === 'combination') {
|
||
row.variants = []
|
||
row.exercise_variant_id = ''
|
||
} else {
|
||
row.variants = variants
|
||
}
|
||
Object.assign(row, meta)
|
||
if (row.exercise_kind === 'combination') {
|
||
if (full === undefined) await ensureFull()
|
||
if (full) {
|
||
row.catalog_method_archetype =
|
||
typeof full.method_archetype === 'string' ? full.method_archetype.trim() : ''
|
||
row.catalog_method_profile = normalizeCatalogMethodProfile(full.method_profile)
|
||
row.combination_slots = Array.isArray(full.combination_slots) ? full.combination_slots : []
|
||
}
|
||
}
|
||
row.planning_method_profile = null
|
||
return row
|
||
}
|
||
|
||
export function noteRow() {
|
||
return { item_type: 'note', note_body: '', source_training_module_id: '', source_module_title: '' }
|
||
}
|
||
|
||
/** Zur Serialisierung in die Planungs-API (persistente Modul-Herkunft). */
|
||
function parseOptionalSourceTrainingModuleIdForPayload(v) {
|
||
if (v === null || v === undefined || v === '') return null
|
||
const n = typeof v === 'number' ? v : parseInt(String(v).trim(), 10)
|
||
return Number.isFinite(n) && n >= 1 ? n : null
|
||
}
|
||
|
||
export function normalizeUnitToForm(fullUnit) {
|
||
if (fullUnit.sections && fullUnit.sections.length) {
|
||
return fullUnit.sections.map((sec) => ({
|
||
title: sec.title,
|
||
guidance_notes: sec.guidance_notes || '',
|
||
items: (sec.items || []).map((it) => {
|
||
if (it.item_type === 'note') {
|
||
const sm = parseOptionalSourceTrainingModuleIdForPayload(it.source_training_module_id)
|
||
const rowNote = {
|
||
item_type: 'note',
|
||
note_body: it.note_body || '',
|
||
source_training_module_id: '',
|
||
source_module_title: '',
|
||
}
|
||
if (sm != null) {
|
||
rowNote.source_training_module_id = sm
|
||
rowNote.source_module_title = (
|
||
it.source_module_title ||
|
||
it.source_training_module_title ||
|
||
''
|
||
).trim()
|
||
}
|
||
return rowNote
|
||
}
|
||
const smEx = parseOptionalSourceTrainingModuleIdForPayload(it.source_training_module_id)
|
||
const ek = String(it.exercise_kind || 'simple').toLowerCase().trim()
|
||
const isCombo = ek === 'combination'
|
||
return {
|
||
item_type: 'exercise',
|
||
exercise_id: it.exercise_id,
|
||
exercise_kind: isCombo ? 'combination' : 'simple',
|
||
exercise_variant_id: isCombo ? '' : it.exercise_variant_id ?? '',
|
||
exercise_title: it.exercise_title || '',
|
||
variants: [],
|
||
planned_duration_min:
|
||
it.planned_duration_min !== null && it.planned_duration_min !== undefined
|
||
? String(it.planned_duration_min)
|
||
: '',
|
||
actual_duration_min:
|
||
it.actual_duration_min !== null && it.actual_duration_min !== undefined
|
||
? String(it.actual_duration_min)
|
||
: '',
|
||
notes: it.notes ?? '',
|
||
modifications: it.modifications ?? '',
|
||
catalog_method_archetype: String(it.catalog_method_archetype ?? '').trim(),
|
||
catalog_method_profile: normalizeCatalogMethodProfile(it.catalog_method_profile),
|
||
planning_method_profile: normalizePlanningMethodProfile(it.planning_method_profile),
|
||
...(smEx != null
|
||
? {
|
||
source_training_module_id: smEx,
|
||
source_module_title: (
|
||
it.source_module_title ||
|
||
it.source_training_module_title ||
|
||
''
|
||
).trim(),
|
||
}
|
||
: {}),
|
||
}
|
||
}),
|
||
}))
|
||
}
|
||
if (fullUnit.exercises && fullUnit.exercises.length) {
|
||
return [
|
||
{
|
||
title: 'Übungen',
|
||
guidance_notes: '',
|
||
items: fullUnit.exercises.map((ex) => {
|
||
const ek = String(ex.exercise_kind || 'simple').toLowerCase().trim()
|
||
const isCombo = ek === 'combination'
|
||
return {
|
||
item_type: 'exercise',
|
||
exercise_kind: ek,
|
||
exercise_id: ex.exercise_id,
|
||
exercise_variant_id: isCombo ? '' : (ex.exercise_variant_id ?? ''),
|
||
exercise_title: ex.exercise_title || '',
|
||
variants: [],
|
||
planned_duration_min:
|
||
ex.planned_duration_min !== null && ex.planned_duration_min !== undefined
|
||
? String(ex.planned_duration_min)
|
||
: '',
|
||
actual_duration_min:
|
||
ex.actual_duration_min !== null && ex.actual_duration_min !== undefined
|
||
? String(ex.actual_duration_min)
|
||
: '',
|
||
notes: ex.notes ?? '',
|
||
modifications: ex.modifications ?? '',
|
||
catalog_method_archetype: String(ex.catalog_method_archetype ?? '').trim(),
|
||
catalog_method_profile: normalizeCatalogMethodProfile(ex.catalog_method_profile),
|
||
planning_method_profile: normalizePlanningMethodProfile(ex.planning_method_profile),
|
||
}
|
||
}),
|
||
},
|
||
]
|
||
}
|
||
return [defaultSection()]
|
||
}
|
||
|
||
export async function enrichSectionsWithVariants(sections) {
|
||
if (!sections?.length) return sections
|
||
const ids = []
|
||
for (const sec of sections) {
|
||
for (const it of sec.items || []) {
|
||
if (it.item_type === 'note') continue
|
||
if (it.exercise_id) ids.push(it.exercise_id)
|
||
}
|
||
}
|
||
const unique = [...new Set(ids)]
|
||
const cache = new Map()
|
||
await Promise.all(
|
||
unique.map(async (id) => {
|
||
try {
|
||
const ex = await api.getExercise(id)
|
||
const ek = String(ex.exercise_kind || 'simple').toLowerCase().trim()
|
||
cache.set(id, {
|
||
title: ex.title || '',
|
||
exercise_kind: ek,
|
||
variants: Array.isArray(ex.variants) ? ex.variants : [],
|
||
visibility: ex.visibility || 'private',
|
||
club_id: ex.club_id ?? null,
|
||
created_by: ex.created_by ?? null,
|
||
status: ex.status || 'draft',
|
||
method_archetype: typeof ex.method_archetype === 'string' ? ex.method_archetype.trim() : '',
|
||
method_profile: normalizeCatalogMethodProfile(ex.method_profile),
|
||
combination_slots: ek === 'combination' && Array.isArray(ex.combination_slots) ? ex.combination_slots : [],
|
||
})
|
||
} catch {
|
||
cache.set(id, {
|
||
title: '',
|
||
exercise_kind: 'simple',
|
||
variants: [],
|
||
visibility: 'private',
|
||
club_id: null,
|
||
created_by: null,
|
||
status: 'draft',
|
||
method_archetype: '',
|
||
method_profile: {},
|
||
combination_slots: [],
|
||
})
|
||
}
|
||
})
|
||
)
|
||
|
||
const titleById = new Map()
|
||
for (const id of unique) {
|
||
const row = cache.get(id)
|
||
const t = (row?.title || '').trim()
|
||
if (t) titleById.set(Number(id), t)
|
||
}
|
||
const comboCandidateExtra = new Set()
|
||
for (const id of unique) {
|
||
const row = cache.get(id)
|
||
if (String(row?.exercise_kind || '').toLowerCase().trim() !== 'combination') continue
|
||
for (const slot of row.combination_slots || []) {
|
||
for (const raw of slot.candidate_exercise_ids || []) {
|
||
const n = typeof raw === 'number' ? raw : parseInt(String(raw), 10)
|
||
if (Number.isFinite(n) && !titleById.has(n)) comboCandidateExtra.add(n)
|
||
}
|
||
}
|
||
}
|
||
await Promise.all(
|
||
[...comboCandidateExtra].map(async (cid) => {
|
||
try {
|
||
const ex = await api.getExercise(cid)
|
||
titleById.set(cid, ((ex.title || '').trim() || `Übung #${cid}`))
|
||
} catch {
|
||
titleById.set(cid, `Übung #${cid}`)
|
||
}
|
||
}),
|
||
)
|
||
|
||
function comboMemberTitleByIdForSlots(slots) {
|
||
const o = {}
|
||
for (const slot of slots || []) {
|
||
for (const raw of slot.candidate_exercise_ids || []) {
|
||
const n = typeof raw === 'number' ? raw : parseInt(String(raw), 10)
|
||
if (!Number.isFinite(n)) continue
|
||
const key = String(n)
|
||
if (!o[key]) o[key] = titleById.get(n) || `Übung #${n}`
|
||
}
|
||
}
|
||
return o
|
||
}
|
||
|
||
return sections.map((sec) => ({
|
||
...sec,
|
||
items: (sec.items || []).map((it) => {
|
||
if (it.item_type === 'note') return it
|
||
if (!it.exercise_id) return it
|
||
const c = cache.get(it.exercise_id)
|
||
if (!c) return it
|
||
const ek = String(c.exercise_kind || 'simple').toLowerCase().trim()
|
||
const isCombo = ek === 'combination'
|
||
const itemCatalog = normalizeCatalogMethodProfile(it.catalog_method_profile)
|
||
const catalog_method_profile =
|
||
Object.keys(itemCatalog).length > 0
|
||
? itemCatalog
|
||
: normalizeCatalogMethodProfile(c.method_profile)
|
||
const rowArche = String(it.catalog_method_archetype ?? '').trim()
|
||
const catalog_method_archetype = rowArche || String(c.method_archetype ?? '').trim()
|
||
return {
|
||
...it,
|
||
catalog_method_archetype,
|
||
catalog_method_profile,
|
||
planning_method_profile: normalizePlanningMethodProfile(it.planning_method_profile),
|
||
exercise_kind: isCombo ? 'combination' : 'simple',
|
||
exercise_title: it.exercise_title || c.title,
|
||
exercise_variant_id: isCombo ? '' : it.exercise_variant_id,
|
||
variants:
|
||
isCombo ? [] : Array.isArray(it.variants) && it.variants.length > 0 ? it.variants : c.variants,
|
||
exercise_visibility: c.visibility,
|
||
exercise_club_id: c.club_id,
|
||
exercise_created_by: c.created_by,
|
||
exercise_status: c.status,
|
||
...(isCombo ? { combination_slots: c.combination_slots || [], combo_member_title_by_id: comboMemberTitleByIdForSlots(c.combination_slots || []) } : {}),
|
||
}
|
||
}),
|
||
}))
|
||
}
|
||
|
||
/**
|
||
* Outline für CombinationMethodProfileEditor: pro‑Slot‑Zeiten nur sichtbar, wenn Stationen übergeben werden.
|
||
*/
|
||
export function comboSlotsOutlineForProfileEditor(combinationSlots) {
|
||
if (!Array.isArray(combinationSlots) || combinationSlots.length === 0) return null
|
||
const sorted = sortCombinationSlotsForDisplay(combinationSlots)
|
||
return sorted.map((s, i) => {
|
||
const rawIx = s.slot_index
|
||
const si =
|
||
rawIx === '' || rawIx == null ? null : typeof rawIx === 'number' ? rawIx : parseInt(String(rawIx), 10)
|
||
return {
|
||
slot_index: Number.isFinite(si) ? si : i,
|
||
title: (s.title != null ? String(s.title) : '').trim(),
|
||
}
|
||
})
|
||
}
|
||
|
||
export function parseMin(v) {
|
||
if (v === '' || v === null || v === undefined) return null
|
||
const n = parseInt(String(v), 10)
|
||
return Number.isFinite(n) ? n : null
|
||
}
|
||
|
||
export function buildSectionsPayload(sections) {
|
||
return sections.map((sec, si) => ({
|
||
order_index: si,
|
||
title: (sec.title || '').trim() || 'Abschnitt',
|
||
guidance_notes: sec.guidance_notes?.trim() ? sec.guidance_notes.trim() : null,
|
||
items: (sec.items || [])
|
||
.map((it, ii) => {
|
||
if (it.item_type === 'note') {
|
||
const sm = parseOptionalSourceTrainingModuleIdForPayload(it.source_training_module_id)
|
||
const row = {
|
||
item_type: 'note',
|
||
order_index: ii,
|
||
note_body: it.note_body ?? '',
|
||
}
|
||
if (sm != null) row.source_training_module_id = sm
|
||
return row
|
||
}
|
||
if (it.exercise_id === '' || it.exercise_id == null || Number.isNaN(Number(it.exercise_id))) {
|
||
return null
|
||
}
|
||
const isCombo = String(it.exercise_kind || 'simple').toLowerCase().trim() === 'combination'
|
||
const vid = isCombo ? null : it.exercise_variant_id
|
||
const smEx = parseOptionalSourceTrainingModuleIdForPayload(it.source_training_module_id)
|
||
const rowEx = {
|
||
item_type: 'exercise',
|
||
order_index: ii,
|
||
exercise_id: parseInt(it.exercise_id, 10),
|
||
exercise_variant_id:
|
||
vid !== '' && vid != null && !Number.isNaN(Number(vid)) ? parseInt(vid, 10) : null,
|
||
planned_duration_min: parseMin(it.planned_duration_min),
|
||
actual_duration_min: parseMin(it.actual_duration_min),
|
||
notes: it.notes?.trim() ? it.notes.trim() : null,
|
||
modifications: it.modifications?.trim() ? it.modifications.trim() : null,
|
||
}
|
||
if (isCombo) {
|
||
const pmp = it.planning_method_profile
|
||
if (pmp != null && typeof pmp === 'object' && !Array.isArray(pmp)) {
|
||
const cleaned = cloneJsonSerializablePlanningProfile(pmp)
|
||
if (cleaned && Object.keys(cleaned).length > 0) {
|
||
rowEx.planning_method_profile = cleaned
|
||
}
|
||
}
|
||
}
|
||
if (smEx != null) rowEx.source_training_module_id = smEx
|
||
return rowEx
|
||
})
|
||
.filter(Boolean),
|
||
}))
|
||
}
|
||
|
||
/** Fügt die Positionen eines Moduls in lokale Abschnitte ein (wie eine Übung, ohne Zwischenspeichern der Einheit). */
|
||
export async function insertTrainingModuleIntoPlanningSections({
|
||
sections,
|
||
moduleDetail,
|
||
sectionIndex,
|
||
insertBeforeItemIndex,
|
||
}) {
|
||
const secIx = typeof sectionIndex === 'number' ? sectionIndex : parseInt(String(sectionIndex), 10)
|
||
if (
|
||
!Array.isArray(sections) ||
|
||
!Number.isFinite(secIx) ||
|
||
secIx < 0 ||
|
||
secIx >= sections.length ||
|
||
!moduleDetail ||
|
||
typeof moduleDetail !== 'object'
|
||
) {
|
||
return sections
|
||
}
|
||
const prev = [...(sections[secIx].items || [])]
|
||
let beforeIx
|
||
if (insertBeforeItemIndex === null || insertBeforeItemIndex === undefined || insertBeforeItemIndex === 'end') {
|
||
beforeIx = prev.length
|
||
} else if (insertBeforeItemIndex === 'start') {
|
||
beforeIx = 0
|
||
} else {
|
||
const n = typeof insertBeforeItemIndex === 'number' ? insertBeforeItemIndex : parseInt(String(insertBeforeItemIndex), 10)
|
||
beforeIx = Number.isFinite(n) ? Math.min(Math.max(n, 0), prev.length) : prev.length
|
||
}
|
||
|
||
const midRaw = moduleDetail.id
|
||
const midNum = typeof midRaw === 'number' ? midRaw : parseInt(String(midRaw), 10)
|
||
if (!Number.isFinite(midNum) || midNum < 1) return sections
|
||
|
||
const modTitle = (moduleDetail.title || '').trim() || `Modul #${midNum}`
|
||
const modItems = [...(moduleDetail.items || [])].sort(
|
||
(a, b) => (a.order_index ?? 0) - (b.order_index ?? 0)
|
||
)
|
||
|
||
const appendRows = []
|
||
for (const mi of modItems) {
|
||
if (mi.item_type === 'note') {
|
||
appendRows.push({
|
||
item_type: 'note',
|
||
note_body: mi.note_body || '',
|
||
source_training_module_id: midNum,
|
||
source_module_title: modTitle,
|
||
})
|
||
continue
|
||
}
|
||
if (!mi.exercise_id) continue
|
||
const hydrated = await hydrateExercisePlanningRow({ id: mi.exercise_id })
|
||
if (!hydrated) continue
|
||
hydrated.source_training_module_id = midNum
|
||
hydrated.source_module_title = modTitle
|
||
if (
|
||
hydrated.exercise_kind !== 'combination' &&
|
||
mi.exercise_variant_id
|
||
) {
|
||
hydrated.exercise_variant_id = String(mi.exercise_variant_id)
|
||
}
|
||
hydrated.planned_duration_min =
|
||
mi.planned_duration_min !== null && mi.planned_duration_min !== undefined
|
||
? String(mi.planned_duration_min)
|
||
: ''
|
||
hydrated.notes = mi.notes ?? ''
|
||
appendRows.push(hydrated)
|
||
}
|
||
|
||
const mergedItems = [...prev.slice(0, beforeIx), ...appendRows, ...prev.slice(beforeIx)]
|
||
return sections.map((sec, idx) => (idx === secIx ? { ...sec, items: mergedItems } : sec))
|
||
}
|
||
|
||
export function sectionPlannedMinutes(sec) {
|
||
return (sec.items || []).reduce((sum, it) => {
|
||
if (it.item_type !== 'exercise') return sum
|
||
const m = parseMin(it.planned_duration_min)
|
||
return sum + (m || 0)
|
||
}, 0)
|
||
}
|