Implement EvaluateStepPayload and SlotContentEntry for Enhanced Planning Features
Deploy Development / deploy (push) Successful in 42s
Test Suite / pytest-backend (push) Failing after 45s
Test Suite / lint-backend (push) Successful in 0s
Test Suite / build-frontend (push) Successful in 15s
Test Suite / k6 /health Baseline (push) Successful in 34s
Test Suite / playwright-tests (push) Successful in 1m21s
Deploy Development / deploy (push) Successful in 42s
Test Suite / pytest-backend (push) Failing after 45s
Test Suite / lint-backend (push) Successful in 0s
Test Suite / build-frontend (push) Successful in 15s
Test Suite / k6 /health Baseline (push) Successful in 34s
Test Suite / playwright-tests (push) Successful in 1m21s
- Introduced EvaluateStepPayload class to facilitate evaluation of exercise steps with optional attributes for AI proposals and roadmap details. - Added SlotContentEntry and SlotExerciseContent classes to manage exercise content within the progression graph planning artifact. - Updated GraphPlanningRoadmapArtifact to include new slot contents and last findings attributes for improved data handling. - Enhanced Exercise Progression Graph Panel with links to the new Slot Editor for streamlined editing of progression graphs. - Incremented application version to reflect these updates.
This commit is contained in:
1 parent
8d5f0b533c
commit
97efe66306
10 files changed
+1719
-4
No files matched your search
@@ -0,0 +1,541 @@
|
||||
/**
|
||||
* Progressionsgraph Slot-Editor — Draft-Hydration und Speichern (Phase B).
|
||||
*/
|
||||
|
||||
const ROADMAP_PHASES = ['einstieg', 'grundlage', 'vertiefung', 'anwendung', 'perfektion']
|
||||
export const PLANNING_ARTIFACT_SCHEMA = 1
|
||||
|
||||
export function emptySlotExercise() {
|
||||
return {
|
||||
kind: 'empty',
|
||||
exerciseId: null,
|
||||
variantId: null,
|
||||
exerciseTitle: '',
|
||||
variantName: null,
|
||||
proposalKey: null,
|
||||
aiSuggestion: null,
|
||||
}
|
||||
}
|
||||
|
||||
export function librarySlotExercise({ exerciseId, exerciseTitle, variantId = null, variantName = null }) {
|
||||
return {
|
||||
kind: 'library',
|
||||
exerciseId: Number(exerciseId),
|
||||
variantId: variantId != null ? Number(variantId) : null,
|
||||
exerciseTitle: exerciseTitle || `Übung #${exerciseId}`,
|
||||
variantName: variantName || null,
|
||||
proposalKey: null,
|
||||
aiSuggestion: null,
|
||||
}
|
||||
}
|
||||
|
||||
export function proposalSlotExercise({ title, proposalKey = null, aiSuggestion = null }) {
|
||||
return {
|
||||
kind: 'proposal',
|
||||
exerciseId: null,
|
||||
variantId: null,
|
||||
exerciseTitle: (title || 'KI-Vorschlag').trim(),
|
||||
variantName: null,
|
||||
proposalKey: proposalKey || `proposal-${Date.now()}`,
|
||||
aiSuggestion: aiSuggestion || null,
|
||||
}
|
||||
}
|
||||
|
||||
export function slotExerciseFromApi(raw) {
|
||||
if (!raw || typeof raw !== 'object') return emptySlotExercise()
|
||||
const kind = raw.kind || (raw.exercise_id != null ? 'library' : raw.ai_suggestion ? 'proposal' : 'empty')
|
||||
if (kind === 'proposal' || raw.ai_suggestion) {
|
||||
return proposalSlotExercise({
|
||||
title: raw.title || raw.exercise_title,
|
||||
proposalKey: raw.proposal_key,
|
||||
aiSuggestion: raw.ai_suggestion,
|
||||
})
|
||||
}
|
||||
if (kind === 'library' && raw.exercise_id != null) {
|
||||
return librarySlotExercise({
|
||||
exerciseId: raw.exercise_id,
|
||||
exerciseTitle: raw.title || raw.exercise_title,
|
||||
variantId: raw.variant_id,
|
||||
variantName: raw.variant_name,
|
||||
})
|
||||
}
|
||||
return emptySlotExercise()
|
||||
}
|
||||
|
||||
export function slotExerciseToApi(entry) {
|
||||
if (!entry || entry.kind === 'empty') {
|
||||
return { kind: 'empty' }
|
||||
}
|
||||
if (entry.kind === 'proposal') {
|
||||
return {
|
||||
kind: 'proposal',
|
||||
title: entry.exerciseTitle || 'KI-Vorschlag',
|
||||
proposal_key: entry.proposalKey || null,
|
||||
ai_suggestion: entry.aiSuggestion || null,
|
||||
}
|
||||
}
|
||||
return {
|
||||
kind: 'library',
|
||||
exercise_id: entry.exerciseId,
|
||||
variant_id: entry.variantId || null,
|
||||
title: entry.exerciseTitle || null,
|
||||
variant_name: entry.variantName || null,
|
||||
}
|
||||
}
|
||||
|
||||
export function mapMajorStepsFromApi(apiRoadmap) {
|
||||
const raw = apiRoadmap?.roadmap?.major_steps
|
||||
if (!Array.isArray(raw)) return []
|
||||
const rows = raw.map((s, i) => ({
|
||||
index: i,
|
||||
phase: s.phase || 'vertiefung',
|
||||
learning_goal: (s.learning_goal || '').trim(),
|
||||
consolidates: Array.isArray(s.consolidates) ? s.consolidates : [],
|
||||
rationale: s.rationale || '',
|
||||
load_profile: [],
|
||||
success_criteria: [],
|
||||
anti_patterns: [],
|
||||
exercise_type: '',
|
||||
}))
|
||||
const specs = apiRoadmap?.stage_specs
|
||||
if (!Array.isArray(specs) || !rows.length) return rows
|
||||
return rows.map((row, i) => {
|
||||
const spec =
|
||||
specs.find((s) => Number(s.major_step_index) === i) ||
|
||||
specs.find((s) => Number(s.major_step_index) === row.index) ||
|
||||
specs[i]
|
||||
if (!spec) return row
|
||||
return {
|
||||
...row,
|
||||
load_profile: Array.isArray(spec.load_profile) ? [...spec.load_profile] : [],
|
||||
success_criteria: Array.isArray(spec.success_criteria) ? [...spec.success_criteria] : [],
|
||||
anti_patterns: Array.isArray(spec.anti_patterns) ? [...spec.anti_patterns] : [],
|
||||
exercise_type: (spec.exercise_type || '').trim(),
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
export function reindexMajorSteps(rows) {
|
||||
return rows.map((row, i) => ({ ...row, index: i }))
|
||||
}
|
||||
|
||||
export function majorStepsToOverridePayload(rows) {
|
||||
const indexed = reindexMajorSteps(rows)
|
||||
return {
|
||||
major_steps: indexed.map((row) => ({
|
||||
index: row.index,
|
||||
phase: row.phase || 'vertiefung',
|
||||
learning_goal: row.learning_goal.trim(),
|
||||
consolidates: row.consolidates || [],
|
||||
rationale: row.rationale || '',
|
||||
})),
|
||||
stage_specs: indexed.map((row, i) => ({
|
||||
major_step_index: i,
|
||||
learning_goal: row.learning_goal.trim(),
|
||||
load_profile: Array.isArray(row.load_profile) ? row.load_profile : [],
|
||||
exercise_type: (row.exercise_type || '').trim(),
|
||||
success_criteria: Array.isArray(row.success_criteria) ? row.success_criteria : [],
|
||||
anti_patterns: Array.isArray(row.anti_patterns) ? row.anti_patterns : [],
|
||||
})),
|
||||
}
|
||||
}
|
||||
|
||||
function nodeKey(exerciseId, variantId) {
|
||||
return `${exerciseId}:${variantId ?? ''}`
|
||||
}
|
||||
|
||||
/** Maximale lineare Segmente aus next_exercise-Kanten. */
|
||||
export function maximalLinearChains(nextEdges) {
|
||||
if (!nextEdges?.length) return []
|
||||
const outMap = new Map()
|
||||
const inMap = new Map()
|
||||
|
||||
for (const e of nextEdges) {
|
||||
const f = nodeKey(e.from_exercise_id, e.from_exercise_variant_id)
|
||||
const t = nodeKey(e.to_exercise_id, e.to_exercise_variant_id)
|
||||
if (!outMap.has(f)) outMap.set(f, [])
|
||||
outMap.get(f).push(e)
|
||||
if (!inMap.has(t)) inMap.set(t, [])
|
||||
inMap.get(t).push(e)
|
||||
}
|
||||
|
||||
const used = new Set()
|
||||
const chains = []
|
||||
|
||||
for (const startEdge of nextEdges) {
|
||||
if (used.has(startEdge.id)) continue
|
||||
const edgesSeq = [startEdge]
|
||||
|
||||
let fk = nodeKey(startEdge.from_exercise_id, startEdge.from_exercise_variant_id)
|
||||
while (true) {
|
||||
const preds = inMap.get(fk)
|
||||
if (!preds || preds.length !== 1) break
|
||||
const pred = preds[0]
|
||||
if (used.has(pred.id)) break
|
||||
edgesSeq.unshift(pred)
|
||||
fk = nodeKey(pred.from_exercise_id, pred.from_exercise_variant_id)
|
||||
}
|
||||
|
||||
let tk = nodeKey(startEdge.to_exercise_id, startEdge.to_exercise_variant_id)
|
||||
while (true) {
|
||||
const outs = outMap.get(tk)
|
||||
if (!outs || outs.length !== 1) break
|
||||
const nx = outs[0]
|
||||
if (used.has(nx.id)) break
|
||||
edgesSeq.push(nx)
|
||||
tk = nodeKey(nx.to_exercise_id, nx.to_exercise_variant_id)
|
||||
}
|
||||
|
||||
edgesSeq.forEach((ed) => used.add(ed.id))
|
||||
const first = edgesSeq[0]
|
||||
const nodes = [
|
||||
{
|
||||
exercise_id: first.from_exercise_id,
|
||||
variant_id: first.from_exercise_variant_id ?? null,
|
||||
title: first.from_exercise_title,
|
||||
variant_name: first.from_variant_name ?? null,
|
||||
},
|
||||
]
|
||||
for (const ed of edgesSeq) {
|
||||
nodes.push({
|
||||
exercise_id: ed.to_exercise_id,
|
||||
variant_id: ed.to_exercise_variant_id ?? null,
|
||||
title: ed.to_exercise_title,
|
||||
variant_name: ed.to_variant_name ?? null,
|
||||
})
|
||||
}
|
||||
chains.push({ nodes, edges: edgesSeq })
|
||||
}
|
||||
return chains
|
||||
}
|
||||
|
||||
function chainNodeToLibrary(node) {
|
||||
if (!node?.exercise_id) return emptySlotExercise()
|
||||
return librarySlotExercise({
|
||||
exerciseId: node.exercise_id,
|
||||
exerciseTitle: node.title || `Übung #${node.exercise_id}`,
|
||||
variantId: node.variant_id,
|
||||
variantName: node.variant_name,
|
||||
})
|
||||
}
|
||||
|
||||
function buildSlotsFromSources({ majorSteps, slotContents, primaryChain, siblingEdges }) {
|
||||
const slotCount = Math.max(majorSteps.length, primaryChain?.nodes?.length || 0, 2)
|
||||
const slots = []
|
||||
|
||||
for (let i = 0; i < slotCount; i += 1) {
|
||||
const major = majorSteps[i] || {
|
||||
index: i,
|
||||
phase: ROADMAP_PHASES[Math.min(i, ROADMAP_PHASES.length - 1)],
|
||||
learning_goal: '',
|
||||
consolidates: [],
|
||||
rationale: '',
|
||||
load_profile: [],
|
||||
success_criteria: [],
|
||||
anti_patterns: [],
|
||||
exercise_type: '',
|
||||
}
|
||||
const saved = Array.isArray(slotContents)
|
||||
? slotContents.find((s) => Number(s.major_step_index) === i)
|
||||
: null
|
||||
|
||||
let primary = saved?.primary
|
||||
? slotExerciseFromApi(saved.primary)
|
||||
: chainNodeToLibrary(primaryChain?.nodes?.[i])
|
||||
|
||||
if (primary.kind === 'empty' && saved?.primary) {
|
||||
primary = slotExerciseFromApi(saved.primary)
|
||||
}
|
||||
|
||||
const siblings = []
|
||||
const seenSiblingKeys = new Set()
|
||||
|
||||
if (Array.isArray(saved?.siblings)) {
|
||||
for (const sib of saved.siblings) {
|
||||
const entry = slotExerciseFromApi(sib)
|
||||
if (entry.kind !== 'empty') {
|
||||
const key = entry.kind === 'library' ? `lib-${entry.exerciseId}` : `prop-${entry.proposalKey}`
|
||||
if (!seenSiblingKeys.has(key)) {
|
||||
seenSiblingKeys.add(key)
|
||||
siblings.push(entry)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (primary.kind === 'library' && Array.isArray(siblingEdges)) {
|
||||
const pid = primary.exerciseId
|
||||
for (const edge of siblingEdges) {
|
||||
let other = null
|
||||
if (Number(edge.from_exercise_id) === pid) {
|
||||
other = librarySlotExercise({
|
||||
exerciseId: edge.to_exercise_id,
|
||||
exerciseTitle: edge.to_exercise_title,
|
||||
variantId: edge.to_exercise_variant_id,
|
||||
variantName: edge.to_variant_name,
|
||||
})
|
||||
} else if (Number(edge.to_exercise_id) === pid) {
|
||||
other = librarySlotExercise({
|
||||
exerciseId: edge.from_exercise_id,
|
||||
exerciseTitle: edge.from_exercise_title,
|
||||
variantId: edge.from_exercise_variant_id,
|
||||
variantName: edge.from_variant_name,
|
||||
})
|
||||
}
|
||||
if (other) {
|
||||
const key = `lib-${other.exerciseId}`
|
||||
if (!seenSiblingKeys.has(key)) {
|
||||
seenSiblingKeys.add(key)
|
||||
siblings.push(other)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
slots.push({
|
||||
majorStepIndex: i,
|
||||
phase: major.phase,
|
||||
learning_goal: major.learning_goal,
|
||||
consolidates: major.consolidates,
|
||||
rationale: major.rationale,
|
||||
load_profile: major.load_profile,
|
||||
success_criteria: major.success_criteria,
|
||||
anti_patterns: major.anti_patterns,
|
||||
exercise_type: major.exercise_type,
|
||||
primary,
|
||||
siblings,
|
||||
})
|
||||
}
|
||||
|
||||
return slots
|
||||
}
|
||||
|
||||
export function hydrateProgressionGraphDraft({
|
||||
artifact = null,
|
||||
edges = [],
|
||||
graphName = '',
|
||||
}) {
|
||||
const nextEdges = (edges || []).filter((e) => (e.edge_type || 'next_exercise') === 'next_exercise')
|
||||
const siblingEdges = (edges || []).filter((e) => e.edge_type === 'sibling')
|
||||
const chains = maximalLinearChains(nextEdges)
|
||||
const primaryChain = chains.sort((a, b) => b.nodes.length - a.nodes.length)[0] || null
|
||||
|
||||
const majorSteps = artifact?.progression_roadmap
|
||||
? mapMajorStepsFromApi(artifact.progression_roadmap)
|
||||
: []
|
||||
|
||||
const slots = buildSlotsFromSources({
|
||||
majorSteps,
|
||||
slotContents: artifact?.slot_contents,
|
||||
primaryChain,
|
||||
siblingEdges,
|
||||
})
|
||||
|
||||
return {
|
||||
graphName: graphName || '',
|
||||
goalQuery: artifact?.goal_query || '',
|
||||
startSituation: artifact?.start_situation || '',
|
||||
targetState: artifact?.target_state || '',
|
||||
roadmapNotes: artifact?.roadmap_notes || '',
|
||||
maxSteps: Number(artifact?.max_steps) || Math.max(slots.length, 5),
|
||||
majorSteps: majorSteps.length ? majorSteps : slots.map((s, i) => ({
|
||||
index: i,
|
||||
phase: s.phase,
|
||||
learning_goal: s.learning_goal,
|
||||
consolidates: s.consolidates,
|
||||
rationale: s.rationale,
|
||||
load_profile: s.load_profile,
|
||||
success_criteria: s.success_criteria,
|
||||
anti_patterns: s.anti_patterns,
|
||||
exercise_type: s.exercise_type,
|
||||
})),
|
||||
slots,
|
||||
pathSkillExpectations: artifact?.path_skill_expectations || null,
|
||||
progressionRoadmap: artifact?.progression_roadmap || null,
|
||||
lastFindings: artifact?.last_findings || null,
|
||||
primaryChainEdgeIds: primaryChain?.edges?.map((e) => e.id) || [],
|
||||
siblingEdgeIds: siblingEdges.map((e) => e.id),
|
||||
dirty: false,
|
||||
}
|
||||
}
|
||||
|
||||
export function buildPlanningArtifactFromDraft(draft, { lastFindings = undefined } = {}) {
|
||||
const q = (draft.goalQuery || '').trim()
|
||||
const progressionRoadmap = draft.progressionRoadmap || null
|
||||
if (!q && !progressionRoadmap && !draft.slots?.length) return null
|
||||
|
||||
const slot_contents = (draft.slots || []).map((slot) => ({
|
||||
major_step_index: slot.majorStepIndex,
|
||||
primary: slotExerciseToApi(slot.primary),
|
||||
siblings: (slot.siblings || []).map(slotExerciseToApi).filter((s) => s.kind !== 'empty'),
|
||||
}))
|
||||
|
||||
const artifact = {
|
||||
schema_version: PLANNING_ARTIFACT_SCHEMA,
|
||||
goal_query: q,
|
||||
start_situation: (draft.startSituation || '').trim() || null,
|
||||
target_state: (draft.targetState || '').trim() || null,
|
||||
roadmap_notes: (draft.roadmapNotes || '').trim() || null,
|
||||
max_steps: Number(draft.maxSteps) || draft.slots?.length || 5,
|
||||
progression_roadmap: progressionRoadmap,
|
||||
path_skill_expectations: draft.pathSkillExpectations || null,
|
||||
slot_contents,
|
||||
}
|
||||
|
||||
const findings = lastFindings !== undefined ? lastFindings : draft.lastFindings
|
||||
if (findings) artifact.last_findings = findings
|
||||
|
||||
return artifact
|
||||
}
|
||||
|
||||
/** Befüllte Primärkette (nur library) für edges/sequence. */
|
||||
export function draftPrimaryChainSteps(draft) {
|
||||
const steps = []
|
||||
for (const slot of draft.slots || []) {
|
||||
if (slot.primary?.kind === 'library' && slot.primary.exerciseId != null) {
|
||||
steps.push({
|
||||
exerciseId: slot.primary.exerciseId,
|
||||
variantId: slot.primary.variantId,
|
||||
exerciseTitle: slot.primary.exerciseTitle,
|
||||
majorStepIndex: slot.majorStepIndex,
|
||||
phase: slot.phase,
|
||||
learningGoal: slot.learning_goal,
|
||||
})
|
||||
}
|
||||
}
|
||||
return steps
|
||||
}
|
||||
|
||||
export function draftSiblingEdgePairs(draft) {
|
||||
const pairs = []
|
||||
for (const slot of draft.slots || []) {
|
||||
if (slot.primary?.kind !== 'library' || slot.primary.exerciseId == null) continue
|
||||
for (const sib of slot.siblings || []) {
|
||||
if (sib.kind !== 'library' || sib.exerciseId == null) continue
|
||||
pairs.push({
|
||||
from: { exerciseId: slot.primary.exerciseId, variantId: slot.primary.variantId },
|
||||
to: { exerciseId: sib.exerciseId, variantId: sib.variantId },
|
||||
})
|
||||
}
|
||||
}
|
||||
return pairs
|
||||
}
|
||||
|
||||
export function slotsToEvaluateSteps(draft) {
|
||||
return (draft.slots || []).map((slot) => {
|
||||
const p = slot.primary
|
||||
if (p.kind === 'proposal') {
|
||||
return {
|
||||
exercise_id: null,
|
||||
variant_id: null,
|
||||
title: p.exerciseTitle,
|
||||
is_ai_proposal: true,
|
||||
ai_suggestion: p.aiSuggestion,
|
||||
proposal_key: p.proposalKey,
|
||||
roadmap_major_step_index: slot.majorStepIndex,
|
||||
roadmap_phase: slot.phase,
|
||||
roadmap_learning_goal: slot.learning_goal,
|
||||
}
|
||||
}
|
||||
if (p.kind === 'library' && p.exerciseId != null) {
|
||||
return {
|
||||
exercise_id: p.exerciseId,
|
||||
variant_id: p.variantId || null,
|
||||
title: p.exerciseTitle,
|
||||
is_ai_proposal: false,
|
||||
roadmap_major_step_index: slot.majorStepIndex,
|
||||
roadmap_phase: slot.phase,
|
||||
roadmap_learning_goal: slot.learning_goal,
|
||||
}
|
||||
}
|
||||
return {
|
||||
exercise_id: null,
|
||||
variant_id: null,
|
||||
title: `(leer: ${slot.learning_goal || `Slot ${slot.majorStepIndex + 1}`})`,
|
||||
is_ai_proposal: true,
|
||||
roadmap_major_step_index: slot.majorStepIndex,
|
||||
roadmap_phase: slot.phase,
|
||||
roadmap_learning_goal: slot.learning_goal,
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
export function applyMatchStepsToSlots(draft, apiSteps) {
|
||||
const steps = Array.isArray(apiSteps) ? apiSteps : []
|
||||
const nextSlots = (draft.slots || []).map((slot) => ({ ...slot, primary: { ...slot.primary }, siblings: [...(slot.siblings || [])] }))
|
||||
|
||||
for (const step of steps) {
|
||||
const idx =
|
||||
step.roadmap_major_step_index != null
|
||||
? Number(step.roadmap_major_step_index)
|
||||
: steps.indexOf(step)
|
||||
if (!Number.isFinite(idx) || idx < 0 || idx >= nextSlots.length) continue
|
||||
|
||||
const isProposal = Boolean(step.is_ai_proposal) || step.exercise_id == null
|
||||
if (isProposal) {
|
||||
nextSlots[idx].primary = proposalSlotExercise({
|
||||
title: step.title,
|
||||
proposalKey: step.proposal_key,
|
||||
aiSuggestion: step.ai_suggestion,
|
||||
})
|
||||
} else {
|
||||
nextSlots[idx].primary = librarySlotExercise({
|
||||
exerciseId: step.exercise_id,
|
||||
exerciseTitle: step.title || `Übung #${step.exercise_id}`,
|
||||
variantId: step.variant_id,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
return { ...draft, slots: nextSlots, dirty: true }
|
||||
}
|
||||
|
||||
export function applyGapOfferToSlot(draft, slotIndex, offer, aiSuggestion = null) {
|
||||
const nextSlots = (draft.slots || []).map((s) => ({ ...s, primary: { ...s.primary }, siblings: [...(s.siblings || [])] }))
|
||||
if (slotIndex < 0 || slotIndex >= nextSlots.length) return draft
|
||||
nextSlots[slotIndex].primary = proposalSlotExercise({
|
||||
title: offer?.title_hint || offer?.title || 'KI-Vorschlag',
|
||||
proposalKey: offer?.offer_id || offer?.proposal_key,
|
||||
aiSuggestion: aiSuggestion || offer?.ai_suggestion || null,
|
||||
})
|
||||
return { ...draft, slots: nextSlots, dirty: true }
|
||||
}
|
||||
|
||||
export async function saveProgressionGraphDraft(api, graphId, draft) {
|
||||
const primarySteps = draftPrimaryChainSteps(draft)
|
||||
const siblingPairs = draftSiblingEdgePairs(draft)
|
||||
const artifact = buildPlanningArtifactFromDraft(draft)
|
||||
const edgeIds = [
|
||||
...(draft.primaryChainEdgeIds || []),
|
||||
...(draft.siblingEdgeIds || []),
|
||||
].filter((id) => Number.isFinite(Number(id)))
|
||||
|
||||
if (edgeIds.length > 0) {
|
||||
await api.deleteExerciseProgressionEdgesBatch(Number(graphId), edgeIds)
|
||||
}
|
||||
|
||||
if (primarySteps.length >= 2) {
|
||||
await api.createExerciseProgressionSequence(Number(graphId), {
|
||||
steps: primarySteps.map((s) => ({
|
||||
exercise_id: s.exerciseId,
|
||||
variant_id: s.variantId || null,
|
||||
})),
|
||||
segment_notes: primarySteps.slice(1).map(() => null),
|
||||
...(artifact ? { planning_roadmap: artifact } : {}),
|
||||
})
|
||||
} else if (artifact) {
|
||||
await api.updateExerciseProgressionGraph(Number(graphId), { planning_roadmap: artifact })
|
||||
}
|
||||
|
||||
for (const pair of siblingPairs) {
|
||||
await api.createExerciseProgressionEdge(Number(graphId), {
|
||||
from_exercise_id: pair.from.exerciseId,
|
||||
from_exercise_variant_id: pair.from.variantId,
|
||||
to_exercise_id: pair.to.exerciseId,
|
||||
to_exercise_variant_id: pair.to.variantId,
|
||||
edge_type: 'sibling',
|
||||
})
|
||||
}
|
||||
|
||||
return { primaryCount: primarySteps.length, siblingCount: siblingPairs.length }
|
||||
}
|
||||
Reference in new issue
Block a user