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(¤t, &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 }