372 lines
19 KiB
Go
372 lines
19 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"strings"
|
|
"time"
|
|
|
|
"pageswiki/internal/schutzaria"
|
|
)
|
|
|
|
var ErrLocalityAccessEnforcing = errors.New("city.access.enforcing_error")
|
|
var ErrLocalityAccessAlias = errors.New("city.access.alias_error")
|
|
|
|
type LocalityAccessEntry struct {
|
|
Kind string `json:"kind"`
|
|
Name string `json:"name"`
|
|
Permission string `json:"permission"`
|
|
ID string `json:"id,omitempty"`
|
|
}
|
|
type LocalityAccess struct {
|
|
AuthorityRank int `json:"authority_rank"`
|
|
Epoch int64 `json:"epoch"`
|
|
TopologyVersion int64 `json:"topology_version"`
|
|
Mode string `json:"mode"`
|
|
Entries []LocalityAccessEntry `json:"entries"`
|
|
GrantsAccess bool `json:"grants_access"`
|
|
ScopePath string `json:"scope_path"`
|
|
}
|
|
|
|
func (s *Store) ensureLocalityAccessSchema() error {
|
|
if s.sqlBackend == storePostgreSQL {
|
|
return s.ensurePostgreSQLLocalityFoundation(context.Background())
|
|
}
|
|
for _, query := range []string{
|
|
`CREATE TABLE IF NOT EXISTS locality_access_policies(domain_uuid TEXT NOT NULL,node_kind TEXT NOT NULL,node_uuid TEXT NOT NULL,scope_path TEXT NOT NULL,grants_access INTEGER NOT NULL CHECK(grants_access IN (0,1)),actor_uuid TEXT NOT NULL,authority_rank INTEGER NOT NULL CHECK(authority_rank BETWEEN 1 AND 3),PRIMARY KEY(domain_uuid,node_kind,node_uuid))`,
|
|
`CREATE INDEX IF NOT EXISTS idx_locality_access_scope ON locality_access_policies(domain_uuid,scope_path)`,
|
|
`CREATE TABLE IF NOT EXISTS locality_access_entries(domain_uuid TEXT NOT NULL,node_kind TEXT NOT NULL,node_uuid TEXT NOT NULL,subject_kind TEXT NOT NULL CHECK(subject_kind IN ('user','group')),subject_uuid TEXT NOT NULL,subject_name TEXT NOT NULL,permission TEXT NOT NULL CHECK(permission IN ('read','read_write')),PRIMARY KEY(domain_uuid,node_kind,node_uuid,subject_kind,subject_uuid))`,
|
|
} {
|
|
if _, err := s.DB.Exec(query); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type localityAccessSnapshot = schutzaria.LocalityAccess
|
|
|
|
func (s *Store) CheckLocalityAccessCaps(domain, principal, capability, path string) error {
|
|
p, err := s.loadLocalityAccess(s.DB, domain, principal)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !p.Decide(path, capability, true) {
|
|
return ErrAccessDenied
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Store) CheckObjectLocalityAccessCaps(domain, principal, capability, object string) error {
|
|
return s.policyRead(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
|
|
return s.checkObjectLocalityAccessCaps(ctx, tx, domain, principal, capability, object)
|
|
})
|
|
}
|
|
|
|
func (s *Store) checkObjectLocalityAccessCaps(ctx context.Context, tx *sql.Tx, domain, principal, capability, object string) error {
|
|
// An exceptional foreign Object grant must not bypass the source Domain's
|
|
// restricted audience. Cross-Domain delegation of these new ACLs is not
|
|
// implemented. Check before the local administrator/empty-policy shortcut.
|
|
var foreign bool
|
|
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM locality_access_policies WHERE domain_uuid!=`+s.sqlParam(1)+`)`, domain).Scan(&foreign); err != nil {
|
|
return err
|
|
}
|
|
if foreign {
|
|
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM paths p JOIN locality_access_policies a ON a.domain_uuid=p.domain_uuid WHERE p.object_uuid=`+s.sqlParam(1)+` AND p.domain_uuid!=`+s.sqlParam(2)+` AND `+s.pathScopeSQL("a.scope_path", "p.path")+`)`, object, domain).Scan(&foreign); err != nil {
|
|
return err
|
|
}
|
|
if foreign {
|
|
return ErrAccessDenied
|
|
}
|
|
}
|
|
p, err := s.loadLocalityAccess(cityReadQuery{ctx, tx}, domain, principal)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !p.RequiresPathChecks() {
|
|
return nil
|
|
}
|
|
rows, err := tx.QueryContext(ctx, `SELECT path FROM paths WHERE domain_uuid=`+s.sqlParam(1)+` AND object_uuid=`+s.sqlParam(2)+` LIMIT 10001`, domain, object)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer rows.Close()
|
|
count := 0
|
|
for rows.Next() {
|
|
count++
|
|
if count > 10000 {
|
|
return ErrAccessDenied
|
|
}
|
|
var path string
|
|
if err = rows.Scan(&path); err != nil {
|
|
return err
|
|
}
|
|
if !p.Decide(path, capability, true) {
|
|
return ErrAccessDenied
|
|
}
|
|
}
|
|
return rows.Err()
|
|
}
|
|
|
|
// Until namespace impact/approval exists, protected bindings cannot be removed,
|
|
// retargeted or aliased. New objects may still be created and inherit the ACL.
|
|
// These SQLite guards cover CLI/import/background writers, not only HTTP.
|
|
func installLocalityAccessGuards(ctx context.Context, tx *sql.Tx) error {
|
|
scope := func(candidate string) string {
|
|
return `EXISTS(SELECT 1 FROM locality_access_policies a WHERE a.domain_uuid=OLD.domain_uuid AND ` + cityPathScopeSQL("a.scope_path", candidate) + `)`
|
|
}
|
|
statements := []string{
|
|
`CREATE TRIGGER IF NOT EXISTS locality_access_config_update BEFORE UPDATE ON config WHEN OLD.key='authorization_mode' AND (NEW.key!=OLD.key OR NEW.domain_uuid!=OLD.domain_uuid OR NEW.value!='enforcing') AND EXISTS(SELECT 1 FROM locality_access_policies WHERE domain_uuid=OLD.domain_uuid) BEGIN SELECT RAISE(ABORT,'locality_access_requires_enforcing'); END`,
|
|
`CREATE TRIGGER IF NOT EXISTS locality_access_config_delete BEFORE DELETE ON config WHEN OLD.key='authorization_mode' AND EXISTS(SELECT 1 FROM locality_access_policies WHERE domain_uuid=OLD.domain_uuid) BEGIN SELECT RAISE(ABORT,'locality_access_requires_enforcing'); END`,
|
|
`CREATE TRIGGER IF NOT EXISTS locality_access_config_insert BEFORE INSERT ON config WHEN NEW.key='authorization_mode' AND NEW.value!='enforcing' AND EXISTS(SELECT 1 FROM locality_access_policies WHERE domain_uuid=NEW.domain_uuid) BEGIN SELECT RAISE(ABORT,'locality_access_requires_enforcing'); END`,
|
|
`CREATE TRIGGER IF NOT EXISTS locality_access_path_delete BEFORE DELETE ON paths WHEN ` + scope("OLD.path") + ` BEGIN SELECT RAISE(ABORT,'locality_access_protected_namespace'); END`,
|
|
`CREATE TRIGGER IF NOT EXISTS locality_access_path_update BEFORE UPDATE OF path,object_uuid,domain_uuid ON paths WHEN (OLD.path!=NEW.path OR OLD.object_uuid!=NEW.object_uuid OR OLD.domain_uuid!=NEW.domain_uuid) AND (` + scope("OLD.path") + ` OR EXISTS(SELECT 1 FROM locality_access_policies a WHERE a.domain_uuid=NEW.domain_uuid AND ` + cityPathScopeSQL("a.scope_path", "NEW.path") + `) OR EXISTS(SELECT 1 FROM paths p JOIN locality_access_policies a ON a.domain_uuid=p.domain_uuid WHERE p.object_uuid=NEW.object_uuid AND ` + cityPathScopeSQL("a.scope_path", "p.path") + `)) BEGIN SELECT RAISE(ABORT,'locality_access_protected_namespace'); END`,
|
|
`CREATE TRIGGER IF NOT EXISTS locality_access_path_insert BEFORE INSERT ON paths WHEN (EXISTS(SELECT 1 FROM revisions WHERE object_uuid=NEW.object_uuid) OR EXISTS(SELECT 1 FROM paths WHERE object_uuid=NEW.object_uuid)) AND (EXISTS(SELECT 1 FROM locality_access_policies a WHERE a.domain_uuid=NEW.domain_uuid AND ` + cityPathScopeSQL("a.scope_path", "NEW.path") + `) OR EXISTS(SELECT 1 FROM paths p JOIN locality_access_policies a ON a.domain_uuid=p.domain_uuid WHERE p.object_uuid=NEW.object_uuid AND ` + cityPathScopeSQL("a.scope_path", "p.path") + `)) BEGIN SELECT RAISE(ABORT,'locality_access_protected_namespace'); END`,
|
|
}
|
|
for _, table := range []string{"zones", "spots"} {
|
|
columns := "path_prefix,state"
|
|
if table == "zones" {
|
|
columns += ",parent_uuid"
|
|
}
|
|
statements = append(statements, `CREATE TRIGGER IF NOT EXISTS locality_access_`+table+`_structure BEFORE UPDATE OF `+columns+` ON `+table+` WHEN EXISTS(SELECT 1 FROM locality_access_policies WHERE domain_uuid=OLD.domain_uuid) BEGIN SELECT RAISE(ABORT,'locality_access_protected_namespace'); END`,
|
|
`CREATE TRIGGER IF NOT EXISTS locality_access_`+table+`_delete BEFORE DELETE ON `+table+` WHEN EXISTS(SELECT 1 FROM locality_access_policies WHERE domain_uuid=OLD.domain_uuid) BEGIN SELECT RAISE(ABORT,'locality_access_protected_namespace'); END`)
|
|
}
|
|
for _, op := range []string{"INSERT", "DELETE", "UPDATE"} {
|
|
ref := "OLD"
|
|
if op == "INSERT" {
|
|
ref = "NEW"
|
|
}
|
|
statements = append(statements, `CREATE TRIGGER IF NOT EXISTS locality_access_street_spots_`+strings.ToLower(op)+` BEFORE `+op+` ON street_spots WHEN EXISTS(SELECT 1 FROM spots s JOIN locality_access_policies a ON a.domain_uuid=s.domain_uuid WHERE s.uuid=`+ref+`.spot_uuid) BEGIN SELECT RAISE(ABORT,'locality_access_protected_namespace'); END`)
|
|
}
|
|
for _, query := range statements {
|
|
if _, err := tx.ExecContext(ctx, query); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func loadLocalityAccess(q pathQueryer, domain, principal string) (*localityAccessSnapshot, error) {
|
|
// Existing SQLite-only mutation transactions retain this entry point.
|
|
return (&Store{}).loadLocalityAccess(q, domain, principal)
|
|
}
|
|
|
|
func (s *Store) loadLocalityAccess(q pathQueryer, domain, principal string) (*localityAccessSnapshot, error) {
|
|
var layers []schutzaria.AccessLayer
|
|
var admin bool
|
|
rows, err := q.Query(`SELECT a.scope_path,a.grants_access,
|
|
EXISTS(SELECT 1 FROM locality_access_entries e JOIN domain_memberships m ON m.domain_uuid=e.domain_uuid AND m.principal_uuid=`+s.sqlParam(1)+` AND m.state='active' JOIN principals u ON u.uuid=m.principal_uuid AND u.state IN ('active','readonly') WHERE e.domain_uuid=a.domain_uuid AND e.node_kind=a.node_kind AND e.node_uuid=a.node_uuid AND ((e.subject_kind='user' AND e.subject_uuid=m.uuid) OR (e.subject_kind='group' AND EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid AND gm.membership_uuid=m.uuid WHERE g.uuid=e.subject_uuid AND g.domain_uuid=m.domain_uuid AND g.state='active')))),
|
|
EXISTS(SELECT 1 FROM locality_access_entries e JOIN domain_memberships m ON m.domain_uuid=e.domain_uuid AND m.principal_uuid=`+s.sqlParam(2)+` AND m.state='active' JOIN principals u ON u.uuid=m.principal_uuid AND u.state='active' WHERE e.domain_uuid=a.domain_uuid AND e.node_kind=a.node_kind AND e.node_uuid=a.node_uuid AND e.permission='read_write' AND ((e.subject_kind='user' AND e.subject_uuid=m.uuid) OR (e.subject_kind='group' AND EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid AND gm.membership_uuid=m.uuid WHERE g.uuid=e.subject_uuid AND g.domain_uuid=m.domain_uuid AND g.state='active')))),
|
|
EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid AND m.state='active' JOIN principals u ON u.uuid=m.principal_uuid AND u.state='active' WHERE g.domain_uuid=a.domain_uuid AND g.builtin_key='domain_admin' AND g.state='active' AND gm.member_role IN ('owner','manager') AND m.principal_uuid=`+s.sqlParam(3)+`)
|
|
FROM locality_access_policies a WHERE a.domain_uuid=`+s.sqlParam(4)+` LIMIT 4097`, principal, principal, principal, domain)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
count := 0
|
|
for rows.Next() {
|
|
count++
|
|
if count > 4096 {
|
|
return nil, ErrGovernanceInvalid
|
|
}
|
|
var path string
|
|
var layer schutzaria.AccessLayer
|
|
if err = rows.Scan(&path, &layer.Grant, &layer.Read, &layer.Write, &admin); err != nil {
|
|
return nil, err
|
|
}
|
|
layer.Path = path
|
|
layers = append(layers, layer)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return schutzaria.NewLocalityAccess(admin, layers), nil
|
|
}
|
|
|
|
func (s *Store) readLocalityAccess(ctx context.Context, tx *sql.Tx, domain, kind, id string, g CityGovernance) (LocalityAccess, error) {
|
|
a := LocalityAccess{Epoch: g.Epoch, TopologyVersion: g.TopologyVersion, Mode: "inherit", Entries: []LocalityAccessEntry{}}
|
|
err := tx.QueryRowContext(ctx, `SELECT scope_path,grants_access,authority_rank FROM locality_access_policies WHERE domain_uuid=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+``, domain, kind, id).Scan(&a.ScopePath, &a.GrantsAccess, &a.AuthorityRank)
|
|
if err == sql.ErrNoRows {
|
|
return a, nil
|
|
}
|
|
if err != nil {
|
|
return a, err
|
|
}
|
|
a.Mode = "restricted"
|
|
rows, err := tx.QueryContext(ctx, `SELECT e.subject_kind,e.subject_uuid,CASE WHEN e.subject_kind='user' THEN COALESCE((SELECT i.subject FROM domain_memberships m JOIN principal_identities i ON i.principal_uuid=m.principal_uuid AND i.provider_type='password' WHERE m.uuid=e.subject_uuid AND m.domain_uuid=e.domain_uuid LIMIT 1),e.subject_name) ELSE COALESCE((SELECT name FROM groups WHERE uuid=e.subject_uuid AND domain_uuid=e.domain_uuid),e.subject_name) END,e.permission FROM locality_access_entries e WHERE e.domain_uuid=`+s.sqlParam(1)+` AND e.node_kind=`+s.sqlParam(2)+` AND e.node_uuid=`+s.sqlParam(3)+` ORDER BY e.subject_kind,e.subject_name LIMIT 65`, domain, kind, id)
|
|
if err != nil {
|
|
return a, err
|
|
}
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var entry LocalityAccessEntry
|
|
if err = rows.Scan(&entry.Kind, &entry.ID, &entry.Name, &entry.Permission); err != nil {
|
|
return a, err
|
|
}
|
|
a.Entries = append(a.Entries, entry)
|
|
}
|
|
if len(a.Entries) > 64 {
|
|
return a, ErrGovernanceInvalid
|
|
}
|
|
return a, rows.Err()
|
|
}
|
|
|
|
func (s *Store) LocalityAccess(ctx context.Context, domain, actor, kind, id string, change *LocalityAccess) (result LocalityAccess, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("locality access policy", resultErr) }()
|
|
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
|
|
defer cancel()
|
|
options := s.policyReadOptions()
|
|
if change != nil {
|
|
options = &sql.TxOptions{Isolation: sql.LevelReadCommitted}
|
|
}
|
|
tx, err := s.DB.BeginTx(ctx, options)
|
|
if err != nil {
|
|
return LocalityAccess{}, err
|
|
}
|
|
defer tx.Rollback()
|
|
if change != nil {
|
|
if err = s.lockPolicyWrite(ctx, tx); err != nil {
|
|
return LocalityAccess{}, err
|
|
}
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_epochs(domain_uuid,version) VALUES(`+s.sqlParam(1)+`,0) ON CONFLICT(domain_uuid) DO UPDATE SET version=city_governance_epochs.version`, domain); err != nil {
|
|
return LocalityAccess{}, err
|
|
}
|
|
}
|
|
g, err := s.governanceSnapshot(ctx, tx, domain, actor, kind, id)
|
|
if err != nil {
|
|
return LocalityAccess{}, err
|
|
}
|
|
before, err := s.readLocalityAccess(ctx, tx, domain, kind, id, g)
|
|
if err != nil || change == nil {
|
|
return before, err
|
|
}
|
|
if change.Epoch != g.Epoch || change.TopologyVersion != g.TopologyVersion {
|
|
return before, ErrGovernanceConflict
|
|
}
|
|
if change.Mode != "inherit" && change.Mode != "restricted" || len(change.Entries) > 64 || change.Mode == "inherit" && len(change.Entries) > 0 {
|
|
return before, ErrGovernanceInvalid
|
|
}
|
|
var admin bool
|
|
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid WHERE g.domain_uuid=`+s.sqlParam(1)+` AND g.builtin_key='domain_admin' AND g.state='active' AND gm.member_role IN ('owner','manager') AND m.principal_uuid=`+s.sqlParam(2)+` AND m.state='active')`, domain, actor).Scan(&admin); err != nil {
|
|
return before, err
|
|
}
|
|
path := "/"
|
|
if kind != "domain" {
|
|
table := "zones"
|
|
if kind == "spot" {
|
|
table = "spots"
|
|
}
|
|
if err = tx.QueryRowContext(ctx, `SELECT path_prefix FROM `+table+` WHERE uuid=`+s.sqlParam(1)+` AND domain_uuid=`+s.sqlParam(2)+``, id, domain).Scan(&path); err != nil {
|
|
return before, err
|
|
}
|
|
}
|
|
if change.Mode == "restricted" {
|
|
var mode string
|
|
if err = tx.QueryRowContext(ctx, `SELECT value FROM config WHERE domain_uuid=`+s.sqlParam(1)+` AND key='authorization_mode'`, domain).Scan(&mode); err != nil {
|
|
return before, err
|
|
}
|
|
if mode != "enforcing" {
|
|
return before, ErrLocalityAccessEnforcing
|
|
}
|
|
var crossAlias bool
|
|
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM paths p JOIN paths other ON other.object_uuid=p.object_uuid CROSS JOIN (SELECT `+s.sqlParam(1)+` AS scope) input WHERE p.domain_uuid=`+s.sqlParam(2)+` AND `+s.pathScopeSQL("input.scope", "p.path")+` AND (other.domain_uuid!=p.domain_uuid OR NOT `+s.pathScopeSQL("input.scope", "other.path")+`))`, path, domain).Scan(&crossAlias); err != nil {
|
|
return before, err
|
|
}
|
|
if crossAlias {
|
|
return before, ErrLocalityAccessAlias
|
|
}
|
|
}
|
|
entries := append([]LocalityAccessEntry{}, change.Entries...)
|
|
rank := 1
|
|
if kind == "quartier" || kind == "street" || g.CanAppoint {
|
|
rank = 2
|
|
}
|
|
if admin {
|
|
rank = 3
|
|
}
|
|
grant := admin
|
|
if before.AuthorityRank > rank && before.Mode == "restricted" && change.Mode != "restricted" {
|
|
return before, ErrGovernanceCeiling
|
|
}
|
|
seen := map[string]bool{}
|
|
for i := range entries {
|
|
e := &entries[i]
|
|
previousID := e.ID
|
|
e.Name = strings.ToLower(strings.TrimSpace(e.Name))
|
|
if (e.Kind != "user" && e.Kind != "group") || (e.Permission != "read" && e.Permission != "read_write") || len(e.Name) > 64 || e.Name == "" {
|
|
return before, ErrGovernanceInvalid
|
|
}
|
|
if e.Kind == "user" {
|
|
err = tx.QueryRowContext(ctx, `SELECT m.uuid FROM domain_memberships m JOIN principals p ON p.uuid=m.principal_uuid AND p.state IN ('active','readonly') JOIN principal_identities i ON i.principal_uuid=p.uuid AND i.provider_type='password' WHERE m.domain_uuid=`+s.sqlParam(1)+` AND m.state='active' AND i.subject=`+s.sqlParam(2)+``, domain, e.Name).Scan(&e.ID)
|
|
} else {
|
|
err = tx.QueryRowContext(ctx, `SELECT uuid FROM groups WHERE domain_uuid=`+s.sqlParam(1)+` AND name=`+s.sqlParam(2)+` AND state='active'`, domain, e.Name).Scan(&e.ID)
|
|
}
|
|
if err != nil {
|
|
return before, ErrGovernanceInvalid
|
|
}
|
|
if previousID != "" && previousID != e.ID {
|
|
return before, ErrGovernanceInvalid
|
|
}
|
|
key := e.Kind + ":" + e.ID
|
|
if seen[key] {
|
|
return before, ErrGovernanceInvalid
|
|
}
|
|
seen[key] = true
|
|
}
|
|
if before.AuthorityRank > rank && before.Mode == "restricted" {
|
|
for _, e := range entries {
|
|
allowed := false
|
|
for _, old := range before.Entries {
|
|
if old.Kind == e.Kind && old.ID == e.ID && (old.Permission == "read_write" || e.Permission == "read") {
|
|
allowed = true
|
|
break
|
|
}
|
|
}
|
|
if !allowed {
|
|
return before, ErrGovernanceCeiling
|
|
}
|
|
}
|
|
rank = before.AuthorityRank
|
|
grant = before.GrantsAccess
|
|
}
|
|
if _, err = tx.ExecContext(ctx, `DELETE FROM locality_access_entries WHERE domain_uuid=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+``, domain, kind, id); err != nil {
|
|
return before, err
|
|
}
|
|
if _, err = tx.ExecContext(ctx, `DELETE FROM locality_access_policies WHERE domain_uuid=`+s.sqlParam(1)+` AND node_kind=`+s.sqlParam(2)+` AND node_uuid=`+s.sqlParam(3)+``, domain, kind, id); err != nil {
|
|
return before, err
|
|
}
|
|
if change.Mode == "restricted" {
|
|
if err = s.installLocalityAccessGuards(ctx, tx); err != nil {
|
|
return before, err
|
|
}
|
|
grantValue := 0
|
|
if grant {
|
|
grantValue = 1
|
|
}
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO locality_access_policies VALUES(`+s.sqlValues(7)+`)`, domain, kind, id, path, grantValue, actor, rank); err != nil {
|
|
return before, err
|
|
}
|
|
for _, e := range entries {
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO locality_access_entries VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`)`, domain, kind, id, e.Kind, e.ID, e.Name, e.Permission); err != nil {
|
|
return before, err
|
|
}
|
|
}
|
|
}
|
|
if _, err = tx.ExecContext(ctx, `UPDATE city_governance_epochs SET version=version+1 WHERE domain_uuid=`+s.sqlParam(1)+``, domain); err != nil {
|
|
return before, err
|
|
}
|
|
g.Epoch++
|
|
after, err := s.readLocalityAccess(ctx, tx, domain, kind, id, g)
|
|
if err != nil {
|
|
return before, err
|
|
}
|
|
b, _ := json.Marshal(before)
|
|
a, _ := json.Marshal(after)
|
|
if _, err = tx.ExecContext(ctx, `INSERT INTO city_governance_events(domain_uuid,epoch,actor_uuid,node_kind,node_uuid,before_json,after_json,created_at_ms) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`,`+s.sqlParam(6)+`,`+s.sqlParam(7)+`,`+s.sqlParam(8)+`)`, domain, g.Epoch, actor, kind, id, string(b), string(a), time.Now().UnixMilli()); err != nil {
|
|
return before, err
|
|
}
|
|
return after, tx.Commit()
|
|
}
|