Files
2026-11-15 05:47:14 +09:00

137 lines
6.0 KiB
Go

package store
import (
"context"
"database/sql"
"time"
)
// Spans are an indexed projection of running transitions. They are committed
// with the session/audit, never with a per-second timer write.
func (s *Store) ensureTaskFocusSpans() error {
if s.sqlBackend == storePostgreSQL {
return s.ensurePostgreSQLTaskProductivity(context.Background())
}
_, err := s.DB.Exec(`CREATE TABLE IF NOT EXISTS organizer_focus_spans(session_uuid TEXT NOT NULL,version INTEGER NOT NULL,domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,task_uuid TEXT NOT NULL,phase TEXT NOT NULL,start_ms INTEGER NOT NULL,end_ms INTEGER NOT NULL,closed INTEGER NOT NULL,PRIMARY KEY(session_uuid,version));
CREATE INDEX IF NOT EXISTS organizer_focus_spans_day ON organizer_focus_spans(domain_uuid,owner_uuid,start_ms);
CREATE INDEX IF NOT EXISTS organizer_time_blocks_calendar ON organizer_time_blocks(domain_uuid,owner_uuid,calendar_uuid,event_uid) WHERE state='active';
INSERT OR IGNORE INTO organizer_focus_spans SELECT uuid,version,domain_uuid,owner_uuid,task_uuid,phase,max(created_at_ms,deadline_ms-remaining_ms),deadline_ms,0 FROM organizer_focus WHERE state='running'`)
return err
}
func (s *Store) recordFocusSpanTx(ctx context.Context, tx *sql.Tx, f TaskFocus) error {
if f.State == "running" {
_, err := tx.ExecContext(ctx, `INSERT INTO organizer_focus_spans SELECT uuid,version,domain_uuid,owner_uuid,task_uuid,phase,updated_at_ms,deadline_ms,0 FROM organizer_focus WHERE uuid=`+s.sqlParam(1)+``, f.UUID)
return err
}
_, err := tx.ExecContext(ctx, `UPDATE organizer_focus_spans SET end_ms=`+s.sqlScalarMin()+`(end_ms,`+s.sqlScalarMax()+`(start_ms,`+s.sqlParam(1)+`)),closed=1 WHERE session_uuid=`+s.sqlParam(2)+` AND closed=0`, f.UpdatedMS, f.UUID)
return err
}
type TaskDaySummary struct {
TaskCount int `json:"task_count"`
EstimateMinutes int `json:"estimate_minutes"`
FocusMS int64 `json:"focus_ms"`
TasksPartial bool `json:"tasks_partial"`
FocusPartial bool `json:"focus_partial"`
}
func (s *Store) TaskDaySummary(ctx context.Context, domain, actor string, start, end, now time.Time) (result0 TaskDaySummary, resultErr error) {
defer func() { resultErr = s.sqlError("organizer repository", resultErr) }()
var out TaskDaySummary
if !end.After(start) || end.Sub(start) > 26*time.Hour {
return out, ErrTaskInvalid
}
items, next, err := s.ListTasks(ctx, domain, actor, TaskQuery{Kind: "task", View: "today", Today: start.Format("2006-01-02"), Limit: 100})
if err != nil {
return out, err
}
out.TaskCount = len(items)
out.TasksPartial = next != ""
for _, item := range items {
out.EstimateMinutes += item.Estimate
}
// Each running interval is at most 180 minutes, including resumed ones.
rows, err := s.DB.QueryContext(ctx, `SELECT start_ms,end_ms FROM organizer_focus_spans WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND start_ms>=`+s.sqlParam(3)+` AND start_ms<`+s.sqlParam(4)+` AND end_ms>`+s.sqlParam(5)+` AND phase='focus' ORDER BY start_ms,session_uuid,version LIMIT 1001`, domain, actor, start.Add(-180*time.Minute).UnixMilli(), end.UnixMilli(), start.UnixMilli())
if err != nil {
return out, err
}
defer rows.Close()
n := 0
for rows.Next() {
var a, b int64
if err = rows.Scan(&a, &b); err != nil {
return out, err
}
n++
if n > 1000 {
out.FocusPartial = true
break
}
out.FocusMS += max(int64(0), min(b, end.UnixMilli(), now.UnixMilli())-max(a, start.UnixMilli()))
}
return out, rows.Err()
}
func (s *Store) TaskBlockCalendars(ctx context.Context, domain, actor string) (result0 []string, result1 bool, resultErr error) {
defer func() { resultErr = s.sqlError("organizer repository", resultErr) }()
if err := s.taskActor(ctx, s.DB, domain, actor, false); err != nil {
return nil, false, err
}
rows, err := s.DB.QueryContext(ctx, `SELECT calendar_uuid FROM organizer_time_blocks WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND state='active' GROUP BY calendar_uuid ORDER BY calendar_uuid LIMIT 21`, domain, actor)
if err != nil {
return nil, false, err
}
defer rows.Close()
out := []string{}
for rows.Next() {
var id string
if err = rows.Scan(&id); err != nil {
return nil, false, err
}
out = append(out, id)
}
more := len(out) > 20
if more {
out = out[:20]
}
return out, more, rows.Err()
}
type TaskDayBlock struct {
UUID string `json:"uuid"`
TaskUUID string `json:"task_uuid"`
Title string `json:"title"`
Start int64 `json:"start_ms"`
End int64 `json:"end_ms"`
EventUID string `json:"-"`
Href string `json:"href"`
}
// Call ONLY inside Repository.ReadPersonalLocalIndex: that lock enforces the
// current calendar policy and keeps this cache at the canonical manifest head.
func (s *Store) TaskDayBlocks(ctx context.Context, domain, actor, calendar string, start, end time.Time) (result0 []TaskDayBlock, result1 bool, resultErr error) {
defer func() { resultErr = s.sqlError("organizer repository", resultErr) }()
if err := s.taskActor(ctx, s.DB, domain, actor, false); err != nil {
return nil, false, err
}
rows, err := s.DB.QueryContext(ctx, `SELECT b.uuid,b.task_uuid,i.title,e.start*1000,e."end"*1000,b.event_uid FROM calendar_event_cache e JOIN organizer_time_blocks b ON b.domain_uuid=e.domain AND b.calendar_uuid=e.calendar AND b.event_uid=e.uid JOIN organizer_items i ON i.domain_uuid=b.domain_uuid AND i.uuid=b.task_uuid AND i.owner_uuid=b.owner_uuid WHERE b.domain_uuid=`+s.sqlParam(1)+` AND b.owner_uuid=`+s.sqlParam(2)+` AND b.calendar_uuid=`+s.sqlParam(3)+` AND b.state='active' AND e.start<`+s.sqlParam(4)+` AND e."end">`+s.sqlParam(5)+` ORDER BY e.start,b.uuid LIMIT 101`, domain, actor, calendar, end.Unix(), start.Unix())
if err != nil {
return nil, false, err
}
defer rows.Close()
out := []TaskDayBlock{}
for rows.Next() {
var b TaskDayBlock
if err = rows.Scan(&b.UUID, &b.TaskUUID, &b.Title, &b.Start, &b.End, &b.EventUID); err != nil {
return nil, false, err
}
out = append(out, b)
}
more := len(out) > 100
if more {
out = out[:100]
}
return out, more, rows.Err()
}