Files
pages/internal/store/organizer_dashboard.go
2026-11-15 05:47:14 +09:00

170 lines
5.4 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"time"
)
// 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) (result0 DashboardLayout, resultErr error) {
defer func() { resultErr = s.sqlError("organizer repository", resultErr) }()
p := DashboardLayout{Widgets: DefaultDashboard()}
if err := s.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=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+``, 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) (result0 DashboardLayout, resultErr error) {
defer func() { resultErr = s.sqlError("organizer repository", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
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 = s.taskProductivityWriter(ctx, tx, domain, actor); err != nil {
return p, err
}
err = tx.QueryRowContext(ctx, `SELECT version FROM organizer_dashboard_layouts WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+``, 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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`) 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) (result0 DashboardProgress, resultErr error) {
defer func() { resultErr = s.sqlError("organizer repository", resultErr) }()
p := DashboardProgress{Date: day}
if !validTaskDate(day) || day == "" {
return p, ErrTaskInvalid
}
if err := s.taskActor(ctx, s.DB, domain, actor, false); err != nil {
return p, err
}
err := s.DB.QueryRowContext(ctx, `SELECT count(*),COALESCE(sum(CASE WHEN status='done' THEN 1 ELSE 0 END),0) FROM organizer_items WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND kind='task' AND archived=0 AND status!='cancelled' AND planned_on=`+s.sqlParam(3)+``, domain, actor, day).Scan(&p.Total, &p.Done)
return p, err
}