114 lines
3.7 KiB
Go
114 lines
3.7 KiB
Go
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
|
|
}
|