Files
pages/internal/store/tasks_activity.go
T
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

95 lines
3.4 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"strconv"
"time"
)
const TaskActivityBridgeEventType = "task.activity.publish"
// No title, notes, Wiki path or dates are copied into the common journal.
// Consumers must reload the item and verify current authority before delivery.
func (s *Store) appendTaskActivityTx(tx *sql.Tx, domain, actor, id, kind string, version, occurred int64) (bool, error) {
if (kind != "task" && kind != "project") || version < 1 {
return false, ErrTaskInvalid
}
payload, err := json.Marshal(struct {
Version int64 `json:"version"`
OccurredMS int64 `json:"occurred_at_ms"`
}{version, occurred})
if err != nil {
return false, err
}
_, created, err := s.AppendActivityOutboxTx(tx, ActivityOutboxEvent{DomainUUID: domain, ActorUUID: actor, EventType: "organizer." + kind + ".changed", TargetKind: kind, TargetUUID: id, Payload: string(payload), IdempotencyKey: "organizer:" + kind + ":" + id + ":" + strconv.FormatInt(version, 10)})
return created, err
}
// PublishTaskActivity migrates the existing compact journal in bounded,
// restartable batches. New mutations already append directly and atomically;
// their idempotency key also makes this repair path safe to replay.
func (s *Store) PublishTaskActivity(ctx context.Context, limit int) (int, int, error) {
if limit < 1 || limit > 100 {
limit = 100
}
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return 0, 0, err
}
defer tx.Rollback()
if _, err = tx.ExecContext(ctx, `UPDATE organizer_activity_bridge SET last_sequence=last_sequence WHERE id=1`); err != nil {
return 0, 0, err
}
rows, err := tx.QueryContext(ctx, `SELECT c.sequence,c.domain_uuid,c.item_uuid,c.version,c.actor_uuid,c.created_at_ms,COALESCE(i.kind,'') FROM organizer_changes c LEFT JOIN organizer_items i ON i.domain_uuid=c.domain_uuid AND i.uuid=c.item_uuid WHERE c.sequence>(SELECT last_sequence FROM organizer_activity_bridge WHERE id=1) ORDER BY c.sequence LIMIT ?`, limit)
if err != nil {
return 0, 0, err
}
type change struct {
sequence, version, occurred int64
domain, id, actor, kind string
}
changes := []change{}
for rows.Next() {
var c change
if err = rows.Scan(&c.sequence, &c.domain, &c.id, &c.version, &c.actor, &c.occurred, &c.kind); err != nil {
rows.Close()
return 0, 0, err
}
changes = append(changes, c)
}
err = rows.Err()
rows.Close()
if err != nil {
return 0, 0, err
}
published := 0
for _, c := range changes {
created, e := s.appendTaskActivityTx(tx, c.domain, c.actor, c.id, c.kind, c.version, c.occurred)
if e != nil {
return 0, 0, e
}
if created {
published++
}
}
if len(changes) > 0 {
if _, err = tx.ExecContext(ctx, `UPDATE organizer_activity_bridge SET last_sequence=? WHERE id=1`, changes[len(changes)-1].sequence); err != nil {
return 0, 0, err
}
}
if err = tx.Commit(); err != nil {
return 0, 0, err
}
return len(changes), published, nil
}
func (s *Store) EnsureTaskActivityBridgeEvent() error {
now := time.Now().UnixMilli()
_, err := s.DB.Exec(`INSERT OR IGNORE INTO event_definitions(uuid,name,event_type,event_key,payload,schedule_kind,interval_seconds,next_run_at_ms,enabled,priority,max_attempts,created_at_ms,updated_at_ms) VALUES(?,?,?,?,?,'interval',60,?,1,-5,3,?,?)`, "builtin.task.activity.publish", "Task activity journal bridge", TaskActivityBridgeEventType, "local", "{}", now, now, now)
return err
}