package store import ( "context" "database/sql" "encoding/json" "errors" ) // Dashboard is owner-scoped presentation metadata. It never contains executable // widgets, URLs or private task content, and is versioned separately from mail. type DashboardWidget struct { ID string `json:"id"` Width int `json:"width"` Height int `json:"height"` Tab string `json:"tab,omitempty"` } func DefaultDashboard() []DashboardWidget { return []DashboardWidget{{ID: "progress", Width: 4, Height: 3}, {ID: "today", Width: 4, Height: 3}, {ID: "tomorrow", Width: 4, Height: 3}, {ID: "tasks", Width: 8, Height: 4, Tab: "inbox"}, {ID: "schedule", Width: 4, Height: 4}, {ID: "activity", Width: 12, Height: 5}} } func ValidateDashboard(items []DashboardWidget) error { if len(items) > 9 { return ErrTaskInvalid } seen := map[string]bool{} for _, item := range items { switch item.ID { case "progress", "today", "tomorrow", "tasks", "schedule", "tomorrow-schedule", "commands", "activity", "feeds": default: return ErrTaskInvalid } if seen[item.ID] || item.Width < 3 || item.Width > 12 || item.Height < 2 || item.Height > 10 { return ErrTaskInvalid } seen[item.ID] = true if item.ID == "tasks" { switch item.Tab { case "inbox", "backlog", "someday", "review", "all", "done": default: return ErrTaskInvalid } } else if item.Tab != "" { return ErrTaskInvalid } } return nil } type DashboardLayout struct { Version int64 `json:"version"` Widgets []DashboardWidget `json:"widgets"` } func normalizeDashboard(items []DashboardWidget) ([]DashboardWidget, error) { if len(items) > 100 { return nil, ErrTaskInvalid } out := make([]DashboardWidget, 0, len(items)) seen := map[string]bool{} for _, item := range items { if seen[item.ID] { continue } seen[item.ID] = true item.Width = max(3, min(12, item.Width)) item.Height = max(2, min(10, item.Height)) if item.ID == "tasks" { switch item.Tab { case "inbox", "backlog", "someday", "review", "all", "done": default: item.Tab = "inbox" } } else { item.Tab = "" } out = append(out, item) } return out, ValidateDashboard(out) } func (s *Store) Dashboard(ctx context.Context, domain, actor string) (DashboardLayout, error) { p := DashboardLayout{Widgets: DefaultDashboard()} if err := taskActor(ctx, s.DB, domain, actor, false); err != nil { return p, err } var raw string err := s.DB.QueryRowContext(ctx, `SELECT version,data FROM organizer_dashboard_layouts WHERE domain_uuid=? AND owner_uuid=?`, domain, actor).Scan(&p.Version, &raw) if errors.Is(err, sql.ErrNoRows) { return p, nil } if err != nil { return p, err } err = json.Unmarshal([]byte(raw), &p.Widgets) return p, err } // Layout updates do not invalidate in-flight email delivery consent/version. func (s *Store) SaveDashboard(ctx context.Context, domain, actor string, version int64, widgets []DashboardWidget) (DashboardLayout, error) { p := DashboardLayout{} if s.ReadOnly { return p, ErrReadOnly } if version < 0 { return p, ErrTaskInvalid } normalized, err := normalizeDashboard(widgets) if err != nil { return p, err } widgets = normalized tx, err := s.DB.BeginTx(ctx, nil) if err != nil { return p, err } defer tx.Rollback() if err = taskProductivityWriter(ctx, tx, domain, actor); err != nil { return p, err } err = tx.QueryRowContext(ctx, `SELECT version FROM organizer_dashboard_layouts WHERE domain_uuid=? AND owner_uuid=?`, domain, actor).Scan(&p.Version) if err != nil && !errors.Is(err, sql.ErrNoRows) { return p, err } if p.Version != version { return p, ErrTaskConflict } p.Version++ p.Widgets = widgets if p.Widgets == nil { p.Widgets = []DashboardWidget{} } data, err := json.Marshal(p.Widgets) if err != nil { return p, err } _, err = tx.ExecContext(ctx, `INSERT INTO organizer_dashboard_layouts(domain_uuid,owner_uuid,version,data) VALUES(?,?,?,?) ON CONFLICT(domain_uuid,owner_uuid) DO UPDATE SET version=excluded.version,data=excluded.data`, domain, actor, p.Version, string(data)) if err != nil { return p, err } return p, tx.Commit() } type DashboardProgress struct { Date string `json:"date"` Total int `json:"total"` Done int `json:"done"` } // Deliberately count all rows, not a truncated list response. Cancelled and // archived items are excluded from both numerator and denominator. func (s *Store) DashboardProgress(ctx context.Context, domain, actor, day string) (DashboardProgress, error) { p := DashboardProgress{Date: day} if !validTaskDate(day) || day == "" { return p, ErrTaskInvalid } if err := taskActor(ctx, s.DB, domain, actor, false); err != nil { return p, err } err := s.DB.QueryRowContext(ctx, `SELECT count(*),COALESCE(sum(status='done'),0) FROM organizer_items WHERE domain_uuid=? AND owner_uuid=? AND kind='task' AND archived=0 AND status!='cancelled' AND planned_on=?`, domain, actor, day).Scan(&p.Total, &p.Done) return p, err }