- 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]>
384 lines
14 KiB
JavaScript
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,
|
|
}
|
|
})
|