package store import ( "context" "database/sql" "encoding/base64" "encoding/json" "errors" "github.com/google/uuid" ) type taskQueryRow interface { QueryRowContext(context.Context, string, ...any) *sql.Row } func (s *Store) sqlScalarMin() string { if s.sqlBackend == storePostgreSQL { return "LEAST" } return "min" } func (s *Store) sqlScalarMax() string { if s.sqlBackend == storePostgreSQL { return "GREATEST" } return "max" } // Legacy callers remain SQLite-only until their own repositories are ported. func taskActor(ctx context.Context, q taskQueryRow, domain, actor string, write bool) error { return (&Store{}).taskActor(ctx, q, domain, actor, write) } func taskDAVCredentialAllowed(ctx context.Context, q taskQueryRow, domain, actor, id string, write bool) error { return (&Store{}).taskDAVCredentialAllowed(ctx, q, domain, actor, id, write) } func davCredentialAllowed(ctx context.Context, q taskQueryRow, domain, actor, id string, write bool, scope string) error { return (&Store{}).davCredentialAllowed(ctx, q, domain, actor, id, write, scope) } func taskDAVIndexKey(project, value string) string { return (&Store{}).taskDAVIndexKey(project, value) } func taskDAVProjectTx(ctx context.Context, tx *sql.Tx, domain, actor, project string) (string, error) { return (&Store{}).taskDAVProjectTx(ctx, tx, domain, actor, project) } // PostgreSQL text cannot contain SQLite's NUL-separated DAV index keys. Both // components are encoded, including the default collection, to avoid ambiguity. func nativeTaskDAVIndexKey(project, value string) string { return "v1:" + base64.RawURLEncoding.EncodeToString([]byte(project)) + ":" + base64.RawURLEncoding.EncodeToString([]byte(value)) } // These expressions accept only source-owned field names, never query text. func (s *Store) taskJSONText(field string) string { if s.sqlBackend == storePostgreSQL { return "COALESCE(data::jsonb->>'" + field + "','')" } return "COALESCE(json_extract(data,'$." + field + "'),'')" } func (s *Store) taskJSONInt(field string) string { if s.sqlBackend == storePostgreSQL { return "COALESCE((data::jsonb->>'" + field + "')::bigint,0)" } return "COALESCE(json_extract(data,'$." + field + "'),0)" } func (s *Store) taskReferenceCount() string { if s.sqlBackend == storePostgreSQL { return "CASE WHEN jsonb_typeof(data::jsonb->'references')='array' THEN jsonb_array_length(data::jsonb->'references') ELSE 0 END" } return "COALESCE(json_array_length(data,'$.references'),0)" } func (s *Store) taskTitleContains(param string) string { fn := "instr" if s.sqlBackend == storePostgreSQL { fn = "strpos" } return fn + "(lower(title),lower(" + param + "))>0" } func (s *Store) lockTaskWriter(ctx context.Context, tx *sql.Tx) error { if s.ReadOnly { return ErrReadOnly } if s.sqlBackend == storePostgreSQL { _, err := tx.ExecContext(ctx, `SELECT pg_advisory_xact_lock(1885431653,1853058931)`) return err } return nil } func (s *Store) taskReminderExtensionEnabled(ctx context.Context, tx *sql.Tx, domain string) (bool, error) { var raw string err := tx.QueryRowContext(ctx, `SELECT value FROM config WHERE domain_uuid=`+s.sqlParam(1)+` AND key='system_extension_states'`, domain).Scan(&raw) if err != nil && !errors.Is(err, sql.ErrNoRows) { return false, err } states := map[string]bool{} if raw != "" && json.Unmarshal([]byte(raw), &states) != nil { return false, nil } v, ok := states["organizer.tasks"] return !ok || v, nil } func (s *Store) validateTaskAssignee(ctx context.Context, tx *sql.Tx, domain, assignee string) error { if assignee == "" { return nil } if _, err := uuid.Parse(assignee); err != nil { return ErrTaskInvalid } if err := s.taskActor(ctx, tx, domain, assignee, false); err != nil { return ErrTaskInvalid } return nil }