Files
pages/internal/store/task_blocks.go
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

192 lines
6.9 KiB
Go

package store
import (
"context"
"database/sql"
"errors"
"time"
"github.com/google/uuid"
)
type TaskBlock struct {
UUID string `json:"uuid"`
TaskUUID string `json:"task_uuid"`
CalendarUUID string `json:"calendar_uuid"`
EventUID string `json:"event_uid"`
Start time.Time `json:"start"`
End time.Time `json:"end"`
State string `json:"state"`
Title string `json:"-"` // Snapshot approved for the calendar summary.
}
func (s *Store) ensureTaskBlocksSchema() error {
_, err := s.DB.Exec(`CREATE TABLE IF NOT EXISTS organizer_time_blocks(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,uuid TEXT NOT NULL,task_uuid TEXT NOT NULL,calendar_uuid TEXT NOT NULL,event_uid TEXT NOT NULL,start TEXT NOT NULL,end TEXT NOT NULL,state TEXT NOT NULL,created_at_ms INTEGER NOT NULL,PRIMARY KEY(domain_uuid,uuid)); CREATE INDEX IF NOT EXISTS organizer_time_blocks_live ON organizer_time_blocks(domain_uuid,owner_uuid,task_uuid,created_at_ms,uuid) WHERE state!='unlinked'`)
if err != nil {
return err
}
cols, err := tableColumns(s.DB, "organizer_time_blocks")
if err != nil {
return err
}
if !cols["title"] {
_, err = s.DB.Exec(`ALTER TABLE organizer_time_blocks ADD COLUMN title TEXT NOT NULL DEFAULT ''`)
}
return err
}
const taskBlockColumns = `uuid,task_uuid,calendar_uuid,event_uid,start,end,state,title`
func scanTaskBlock(row interface{ Scan(...any) error }) (TaskBlock, error) {
var b TaskBlock
var start, end string
err := row.Scan(&b.UUID, &b.TaskUUID, &b.CalendarUUID, &b.EventUID, &start, &end, &b.State, &b.Title)
if err != nil {
return b, err
}
b.Start, err = time.Parse(time.RFC3339, start)
if err != nil {
return b, err
}
b.End, err = time.Parse(time.RFC3339, end)
return b, err
}
// Reserve before touching canonical calendar files. This durable intent bridges
// the two commit domains; the caller can safely retry using the same UUID.
func (s *Store) ReserveTaskBlock(ctx context.Context, domain, actor string, b TaskBlock, version int64) (TaskBlock, error) {
for _, id := range []string{b.UUID, b.TaskUUID, b.CalendarUUID} {
if _, err := uuid.Parse(id); err != nil {
return b, ErrTaskInvalid
}
}
if b.Start.Year() < 1900 || b.End.Year() > 9999 || !b.End.After(b.Start) || b.End.Sub(b.Start) > 24*time.Hour || version < 1 {
return b, ErrTaskInvalid
}
b.Start = b.Start.UTC().Truncate(time.Second)
b.End = b.End.UTC().Truncate(time.Second)
b.EventUID = uuid.NewSHA1(uuid.NameSpaceOID, []byte("pageswiki-task-block:"+domain+":"+b.UUID)).String()
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return b, err
}
defer tx.Rollback()
if _, err = tx.ExecContext(ctx, `UPDATE domain_memberships SET state=state WHERE domain_uuid=? AND principal_uuid=?`, domain, actor); err != nil {
return b, err
}
if err = taskActor(ctx, tx, domain, actor, true); err != nil {
return b, err
}
enabled, err := taskReminderExtensionEnabled(ctx, tx, domain)
if err != nil {
return b, err
}
if !enabled {
return b, ErrAccessDenied
}
var current int64
err = tx.QueryRowContext(ctx, `SELECT version,title FROM organizer_items WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND kind='task' AND archived=0 AND status NOT IN ('done','cancelled')`, domain, actor, b.TaskUUID).Scan(&current, &b.Title)
if err != nil {
return b, err
}
old, err := scanTaskBlock(tx.QueryRowContext(ctx, `SELECT `+taskBlockColumns+` FROM organizer_time_blocks WHERE domain_uuid=? AND owner_uuid=? AND uuid=?`, domain, actor, b.UUID))
if err == nil {
if old.TaskUUID != b.TaskUUID || old.CalendarUUID != b.CalendarUUID || !old.Start.Equal(b.Start) || !old.End.Equal(b.End) || old.State == "unlinked" {
return b, ErrTaskConflict
}
if old.Title == "" && old.State == "pending" {
old.Title = b.Title
if _, err = tx.ExecContext(ctx, `UPDATE organizer_time_blocks SET title=? WHERE domain_uuid=? AND uuid=?`, old.Title, domain, old.UUID); err != nil {
return b, err
}
}
return old, tx.Commit()
}
if !errors.Is(err, sql.ErrNoRows) {
return b, err
}
if current != version {
return b, ErrTaskConflict
}
var count int
if err = tx.QueryRowContext(ctx, `SELECT count(*) FROM organizer_time_blocks WHERE domain_uuid=? AND owner_uuid=? AND task_uuid=? AND state!='unlinked'`, domain, actor, b.TaskUUID).Scan(&count); err != nil {
return b, err
}
if count >= 100 {
return b, ErrTaskInvalid
}
b.State = "pending"
res, err := tx.ExecContext(ctx, `INSERT OR IGNORE INTO organizer_time_blocks(domain_uuid,owner_uuid,uuid,task_uuid,calendar_uuid,event_uid,start,end,state,created_at_ms,title) VALUES(?,?,?,?,?,?,?,?,?,?,?)`, domain, actor, b.UUID, b.TaskUUID, b.CalendarUUID, b.EventUID, b.Start.Format(time.RFC3339), b.End.Format(time.RFC3339), b.State, time.Now().UnixMilli(), b.Title)
if err != nil {
return b, err
}
if n, _ := res.RowsAffected(); n != 1 {
return b, sql.ErrNoRows
}
return b, tx.Commit()
}
func (s *Store) TaskBlocks(ctx context.Context, domain, actor, task string) ([]TaskBlock, error) {
if _, err := s.GetTask(ctx, domain, actor, task); err != nil {
return nil, err
}
rows, err := s.DB.QueryContext(ctx, `SELECT `+taskBlockColumns+` FROM organizer_time_blocks WHERE domain_uuid=? AND owner_uuid=? AND task_uuid=? AND state!='unlinked' ORDER BY created_at_ms,uuid LIMIT 100`, domain, actor, task)
if err != nil {
return nil, err
}
defer rows.Close()
out := []TaskBlock{}
for rows.Next() {
b, err := scanTaskBlock(rows)
if err != nil {
return nil, err
}
out = append(out, b)
}
return out, rows.Err()
}
func (s *Store) SetTaskBlockState(ctx context.Context, domain, actor, id, state string) error {
if state != "active" && state != "unlinked" {
return ErrTaskInvalid
}
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
if _, err = tx.ExecContext(ctx, `UPDATE domain_memberships SET state=state WHERE domain_uuid=? AND principal_uuid=?`, domain, actor); err != nil {
return err
}
if err = taskActor(ctx, tx, domain, actor, true); err != nil {
return err
}
enabled, err := taskReminderExtensionEnabled(ctx, tx, domain)
if err != nil {
return err
}
if !enabled {
return ErrAccessDenied
}
res, err := tx.ExecContext(ctx, `UPDATE organizer_time_blocks SET state=? WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND (state!='unlinked' OR ?='unlinked')`, state, domain, actor, id, state)
if err != nil {
return err
}
if n, _ := res.RowsAffected(); n != 1 {
return sql.ErrNoRows
}
return tx.Commit()
}
func (s *Store) GetTaskBlock(ctx context.Context, domain, actor, id string) (TaskBlock, error) {
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
return TaskBlock{}, err
}
b, err := scanTaskBlock(s.DB.QueryRowContext(ctx, `SELECT `+taskBlockColumns+` FROM organizer_time_blocks WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND state!='unlinked'`, domain, actor, id))
if err != nil {
return b, err
}
_, err = s.GetTask(ctx, domain, actor, b.TaskUUID)
return b, err
}