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) (scanned int, publishedCount int, resultErr error) { defer func() { resultErr = s.sqlError("task activity bridge", resultErr) }() 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 = s.lockTaskWriter(ctx, tx); err != nil { return 0, 0, err } 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,CASE WHEN d.item_uuid IS NOT NULL THEN 'task' ELSE '' END) FROM organizer_changes c LEFT JOIN organizer_items i ON i.domain_uuid=c.domain_uuid AND i.uuid=c.item_uuid LEFT JOIN organizer_task_deletions d ON d.domain_uuid=c.domain_uuid AND d.item_uuid=c.item_uuid WHERE c.sequence>(SELECT last_sequence FROM organizer_activity_bridge WHERE id=1) ORDER BY c.sequence LIMIT `+s.sqlParam(1)+``, 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=`+s.sqlParam(1)+` 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 { if s.sqlBackend == storePostgreSQL { return s.ensureNativeBuiltinEvent("builtin.task.activity.publish", "Task activity journal bridge", TaskActivityBridgeEventType, 60, -5, 3) } 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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,'interval',60,`+s.sqlParam(6)+`,1,-5,3,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`)`, "builtin.task.activity.publish", "Task activity journal bridge", TaskActivityBridgeEventType, "local", "{}", now, now, now) return err }