Files
homeschool-dashboard/frontend/src/stores/schedule.js
T
derekcandClaude Sonnet 4.6 a8e1b322f1 Tie break timer and main block timer together
- Starting break now pauses the main block timer (frontend optimistic +
  backend implicit pause event recorded before break_start)
- Resuming/starting the main block while break is active pauses the
  break timer and exits break mode on all clients including TV
- Timer display counts negative past zero so overtime is visible while
  label stays "Done!"
- Fixed WS start handler incorrectly skipping break-mode clear when
  restarting the same block; resume handler now also clears break mode

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>
2026-03-03 14:24:50 -08:00

384 lines
14 KiB
JavaScript

import { defineStore } from 'pinia'
import { ref, computed } from 'vue'
import api from '@/composables/useApi'
export const useScheduleStore = defineStore('schedule', () => {
const session = ref(null)
const blocks = ref([])
const completedBlockIds = ref([])
const child = ref(null)
const isPaused = ref(false)
const blockStartedAt = ref(null) // Date.now() ms when current counting period started
const blockElapsedOffset = ref(0) // seconds already elapsed before blockStartedAt
const blockElapsedCache = ref({}) // blockId → total elapsed seconds (survives block switches)
const morningRoutine = ref([]) // list of text strings shown during greeting state
const breakActivities = ref([]) // list of text strings shown during break time
// Break timer state (per-block break time at end of block)
const isBreakMode = ref(false) // currently in break time
const breakStartedAt = ref(null) // Date.now() ms when break counting started
const breakElapsedOffset = ref(0) // break seconds already elapsed
const breakElapsedCache = ref({}) // blockId → total break elapsed seconds
const currentBlock = computed(() =>
session.value?.current_block_id
? blocks.value.find((b) => b.id === session.value.current_block_id) || null
: null
)
const progressPercent = computed(() => {
if (!blocks.value.length) return 0
return Math.round((completedBlockIds.value.length / blocks.value.length) * 100)
})
function sortBlocksByTime(arr) {
return (arr || []).slice().sort((a, b) => {
const toMin = (t) => { if (!t) return 0; const [h, m] = t.split(':').map(Number); return h * 60 + m }
return toMin(a.time_start) - toMin(b.time_start)
})
}
function applySnapshot(snapshot) {
session.value = snapshot.session
blocks.value = sortBlocksByTime(snapshot.blocks)
completedBlockIds.value = snapshot.completed_block_ids || []
isPaused.value = snapshot.is_paused || false
if (snapshot.child) child.value = snapshot.child
morningRoutine.value = snapshot.morning_routine || []
breakActivities.value = snapshot.break_activities || []
// Restore elapsed time from server-computed value and seed the per-block cache
const serverElapsed = snapshot.block_elapsed_seconds || 0
if (snapshot.session?.current_block_id) {
blockElapsedCache.value[snapshot.session.current_block_id] = serverElapsed
blockElapsedOffset.value = serverElapsed
// Start the live counter only when the block is actually running (not paused).
// Use serverElapsed == 0 is fine here — a just-reset block is still running.
blockStartedAt.value = isPaused.value ? null : Date.now()
} else {
blockElapsedOffset.value = 0
blockStartedAt.value = null
}
// Reset break state on snapshot (not persisted across page loads)
isBreakMode.value = false
breakStartedAt.value = null
breakElapsedOffset.value = 0
breakElapsedCache.value = {}
}
function applyWsEvent(event) {
if (event.event === 'session_update') {
applySnapshot(event)
return
}
if (event.event === 'strikes_update') {
if (child.value) child.value = { ...child.value, strikes: event.strikes }
return
}
// Session ended
if (event.is_active === false) {
session.value = null
blocks.value = []
completedBlockIds.value = []
isPaused.value = false
blockStartedAt.value = null
blockElapsedOffset.value = 0
blockElapsedCache.value = {}
isBreakMode.value = false
breakStartedAt.value = null
breakElapsedOffset.value = 0
breakElapsedCache.value = {}
return
}
// Break timer events
if (event.event === 'break_start') {
const elapsed = event.break_elapsed_seconds ?? breakElapsedCache.value[event.block_id] ?? 0
breakElapsedOffset.value = elapsed
if (event.block_id) breakElapsedCache.value[event.block_id] = elapsed
breakStartedAt.value = Date.now()
isBreakMode.value = true
// Sync main block timer to server-authoritative elapsed and mark paused
const blockElapsed = event.block_elapsed_seconds ?? blockElapsedCache.value[event.block_id] ?? blockElapsedOffset.value
blockElapsedOffset.value = blockElapsed
if (event.block_id) blockElapsedCache.value[event.block_id] = blockElapsed
blockStartedAt.value = null
isPaused.value = true
}
if (event.event === 'break_pause') {
if (breakStartedAt.value) {
breakElapsedOffset.value += Math.floor((Date.now() - breakStartedAt.value) / 1000)
}
if (event.block_id) breakElapsedCache.value[event.block_id] = breakElapsedOffset.value
breakStartedAt.value = null
isBreakMode.value = true
}
if (event.event === 'break_resume') {
breakStartedAt.value = Date.now()
isBreakMode.value = true
}
if (event.event === 'break_reset') {
if (event.block_id) breakElapsedCache.value[event.block_id] = 0
breakElapsedOffset.value = 0
breakStartedAt.value = Date.now()
isBreakMode.value = true
}
if (['break_start', 'break_pause', 'break_resume', 'break_reset'].includes(event.event)) {
return
}
// Pause — accumulate elapsed, save to cache, stop counting
if (event.event === 'pause') {
if (blockStartedAt.value) {
blockElapsedOffset.value += Math.floor((Date.now() - blockStartedAt.value) / 1000)
}
if (event.block_id) {
blockElapsedCache.value[event.block_id] = blockElapsedOffset.value
}
blockStartedAt.value = null
isPaused.value = true
}
// Start — use server-provided elapsed (authoritative for all clients incl. TV),
// fall back to local cache, then 0 for a fresh block
if (event.event === 'start') {
const elapsed = event.block_elapsed_seconds ?? blockElapsedCache.value[event.block_id] ?? 0
blockElapsedOffset.value = elapsed
if (event.block_id) blockElapsedCache.value[event.block_id] = elapsed
// Sync the previous block's cache so TV sidebar doesn't reset to full duration
if (event.prev_block_id != null) {
blockElapsedCache.value[event.prev_block_id] = event.prev_block_elapsed_seconds ?? blockElapsedCache.value[event.prev_block_id] ?? 0
}
blockStartedAt.value = Date.now()
isPaused.value = false
isBreakMode.value = false
breakStartedAt.value = null
breakElapsedOffset.value = breakElapsedCache.value[event.block_id] ?? 0
}
// Reset — clear elapsed to 0 and start counting immediately
if (event.event === 'reset') {
if (event.block_id) blockElapsedCache.value[event.block_id] = 0
blockElapsedOffset.value = 0
blockStartedAt.value = Date.now()
isPaused.value = false
}
// Select — switch current block but keep timer stopped (manual start required)
if (event.event === 'select') {
// Sync the previous block's cache
if (event.prev_block_id != null) {
blockElapsedCache.value[event.prev_block_id] = event.prev_block_elapsed_seconds ?? blockElapsedCache.value[event.prev_block_id] ?? 0
}
// Restore new block's accumulated elapsed but don't start counting
const elapsed = event.block_elapsed_seconds ?? blockElapsedCache.value[event.block_id] ?? 0
blockElapsedOffset.value = elapsed
if (event.block_id) blockElapsedCache.value[event.block_id] = elapsed
blockStartedAt.value = null
isPaused.value = true
// Switching blocks clears break mode
isBreakMode.value = false
breakStartedAt.value = null
breakElapsedOffset.value = breakElapsedCache.value[event.block_id] ?? 0
}
// Resume — continue from where we left off
if (event.event === 'resume') {
blockStartedAt.value = Date.now()
isPaused.value = false
isBreakMode.value = false
breakStartedAt.value = null
}
// Timer events update session state
if (event.current_block_id !== undefined && session.value) {
session.value.current_block_id = event.current_block_id
}
if (event.event === 'complete' && event.block_id) {
if (!completedBlockIds.value.includes(event.block_id)) {
completedBlockIds.value.push(event.block_id)
}
}
}
async function fetchDashboard(childId) {
const res = await api.get(`/api/dashboard/${childId}`)
applySnapshot(res.data)
}
async function startSession(childId, templateId) {
const res = await api.post('/api/sessions', {
child_id: childId,
template_id: templateId,
})
session.value = res.data
completedBlockIds.value = []
}
async function sendTimerAction(sessionId, eventType, blockId = null) {
await api.post(`/api/sessions/${sessionId}/timer`, {
event_type: eventType,
block_id: blockId,
})
}
// Switch to a different block in one atomic operation (no separate pause request).
// The backend records an implicit pause for the previous block.
function switchBlock(sessionId, newBlockId) {
if (!session.value) return
const prevBlockId = session.value.current_block_id
// Save elapsed seconds for the block we're leaving
if (prevBlockId && blockStartedAt.value) {
blockElapsedCache.value[prevBlockId] =
blockElapsedOffset.value + Math.floor((Date.now() - blockStartedAt.value) / 1000)
}
// Optimistic update — UI responds immediately
session.value.current_block_id = newBlockId
isPaused.value = false
blockElapsedOffset.value = blockElapsedCache.value[newBlockId] ?? 0
blockStartedAt.value = Date.now()
// Single HTTP call; WS start event will confirm with authoritative elapsed
sendTimerAction(sessionId, 'start', newBlockId)
}
// Select a block without starting its timer (requires explicit Start/Resume).
// The backend records an implicit pause for the previous block if it was running.
function selectBlock(sessionId, newBlockId) {
if (!session.value) return
const prevBlockId = session.value.current_block_id
if (prevBlockId === newBlockId) return
// Save elapsed seconds for the block we're leaving (if timer was running)
if (prevBlockId && blockStartedAt.value) {
blockElapsedCache.value[prevBlockId] =
blockElapsedOffset.value + Math.floor((Date.now() - blockStartedAt.value) / 1000)
}
// Optimistic update — switch block, stay paused, stop counting
session.value.current_block_id = newBlockId
isPaused.value = true
blockElapsedOffset.value = blockElapsedCache.value[newBlockId] ?? 0
blockStartedAt.value = null
// Single HTTP call; WS select event will confirm with authoritative elapsed
sendTimerAction(sessionId, 'select', newBlockId)
}
// Start the timer for the currently selected block (optimistic).
function startCurrentBlock(sessionId) {
if (!session.value?.current_block_id) return
const blockId = session.value.current_block_id
if (isBreakMode.value) {
if (breakStartedAt.value) {
breakElapsedOffset.value += Math.floor((Date.now() - breakStartedAt.value) / 1000)
}
breakElapsedCache.value[blockId] = breakElapsedOffset.value
breakStartedAt.value = null
isBreakMode.value = false
sendTimerAction(sessionId, 'break_pause', blockId)
}
isPaused.value = false
blockStartedAt.value = Date.now()
sendTimerAction(sessionId, 'start', blockId)
}
// Resume the timer for the currently selected block (optimistic).
function resumeCurrentBlock(sessionId) {
if (!session.value?.current_block_id) return
const blockId = session.value.current_block_id
if (isBreakMode.value) {
if (breakStartedAt.value) {
breakElapsedOffset.value += Math.floor((Date.now() - breakStartedAt.value) / 1000)
}
breakElapsedCache.value[blockId] = breakElapsedOffset.value
breakStartedAt.value = null
isBreakMode.value = false
sendTimerAction(sessionId, 'break_pause', blockId)
}
blockStartedAt.value = Date.now()
isPaused.value = false
sendTimerAction(sessionId, 'resume')
}
// Break timer actions
function startBreak(sessionId) {
if (!session.value?.current_block_id) return
const blockId = session.value.current_block_id
// Pause the main block timer
if (blockStartedAt.value) {
blockElapsedOffset.value += Math.floor((Date.now() - blockStartedAt.value) / 1000)
}
blockElapsedCache.value[blockId] = blockElapsedOffset.value
blockStartedAt.value = null
isPaused.value = true
// Start break timer
isBreakMode.value = true
breakElapsedOffset.value = breakElapsedCache.value[blockId] ?? 0
breakStartedAt.value = Date.now()
sendTimerAction(sessionId, 'break_start', blockId)
}
function pauseBreak(sessionId) {
if (!session.value?.current_block_id) return
if (breakStartedAt.value) {
breakElapsedOffset.value += Math.floor((Date.now() - breakStartedAt.value) / 1000)
}
breakStartedAt.value = null
sendTimerAction(sessionId, 'break_pause', session.value.current_block_id)
}
function resumeBreak(sessionId) {
if (!session.value?.current_block_id) return
breakStartedAt.value = Date.now()
sendTimerAction(sessionId, 'break_resume', session.value.current_block_id)
}
function resetBreak(sessionId) {
if (!session.value?.current_block_id) return
const blockId = session.value.current_block_id
breakElapsedCache.value[blockId] = 0
breakElapsedOffset.value = 0
breakStartedAt.value = Date.now()
isBreakMode.value = true
sendTimerAction(sessionId, 'break_reset', blockId)
}
// Reset the current block's timer to 0 and start counting immediately.
function resetCurrentBlock(sessionId) {
if (!session.value?.current_block_id) return
const blockId = session.value.current_block_id
blockElapsedCache.value[blockId] = 0
blockElapsedOffset.value = 0
isPaused.value = false
blockStartedAt.value = Date.now()
sendTimerAction(sessionId, 'reset', blockId)
}
return {
session,
blocks,
completedBlockIds,
child,
isPaused,
blockStartedAt,
blockElapsedOffset,
blockElapsedCache,
morningRoutine,
breakActivities,
isBreakMode,
breakStartedAt,
breakElapsedOffset,
breakElapsedCache,
currentBlock,
progressPercent,
applySnapshot,
applyWsEvent,
fetchDashboard,
startSession,
sendTimerAction,
switchBlock,
selectBlock,
startCurrentBlock,
resumeCurrentBlock,
resetCurrentBlock,
startBreak,
pauseBreak,
resumeBreak,
resetBreak,
}
})