167 lines
6.4 KiB
Go
167 lines
6.4 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
// ErrNoClass means no class has that id.
|
|
var ErrNoClass = errors.New("no such action class")
|
|
|
|
// Class is one action class and the level it stands at.
|
|
type Class struct {
|
|
ID uuid.UUID `db:"id"`
|
|
OrgID string `db:"org_id"`
|
|
Connector string `db:"connector"`
|
|
Action string `db:"action"`
|
|
TargetKind string `db:"target_kind"`
|
|
Environment string `db:"environment"`
|
|
ReadOnly bool `db:"read_only"`
|
|
Level string `db:"level"`
|
|
CreatedAt time.Time `db:"created_at"`
|
|
ResetAt sql.NullTime `db:"reset_at"`
|
|
// TightenedAt and TightenedBecause say when and why the class last lost
|
|
// autonomy; the count of approvals restarts there.
|
|
TightenedAt sql.NullTime `db:"tightened_at"`
|
|
TightenedBecause sql.NullString `db:"tightened_because"`
|
|
}
|
|
|
|
// ClassSummary is a class with how many decisions it holds.
|
|
type ClassSummary struct {
|
|
Class
|
|
Decisions int `db:"decisions"`
|
|
LastAt sql.NullTime `db:"last_at"`
|
|
Streak int `db:"streak"`
|
|
}
|
|
|
|
// Reset is one return of a class to its default.
|
|
type Reset struct {
|
|
ID uuid.UUID `db:"id"`
|
|
FromLevel string `db:"from_level"`
|
|
ToLevel string `db:"to_level"`
|
|
By string `db:"by"`
|
|
At time.Time `db:"at"`
|
|
}
|
|
|
|
const classColumns = `id, org_id, connector, action, target_kind, environment, read_only, level, created_at, reset_at, tightened_at, tightened_because`
|
|
|
|
// EnsureClass returns the class c names, creating it at c.Level when it is
|
|
// new. An existing class keeps its level.
|
|
func (s *Store) EnsureClass(ctx context.Context, c Class) (Class, error) {
|
|
var out Class
|
|
err := s.db.GetContext(ctx, &out, `
|
|
INSERT INTO judgement.classes (id, org_id, connector, action, target_kind, environment, read_only, level)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
|
|
ON CONFLICT (org_id, connector, action, target_kind, environment)
|
|
DO UPDATE SET read_only = judgement.classes.read_only
|
|
RETURNING `+classColumns,
|
|
c.ID, c.OrgID, c.Connector, c.Action, c.TargetKind, c.Environment, c.ReadOnly, c.Level)
|
|
if err != nil {
|
|
return Class{}, fmt.Errorf("ensure class: %w", err)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// Classes returns every class, most recently decided first.
|
|
func (s *Store) Classes(ctx context.Context, orgID string) ([]ClassSummary, error) {
|
|
var out []ClassSummary
|
|
err := s.db.SelectContext(ctx, &out, `
|
|
SELECT c.id, c.org_id, c.connector, c.action, c.target_kind, c.environment, c.read_only, c.level,
|
|
c.created_at, c.reset_at, c.tightened_at, c.tightened_because,
|
|
count(d.id) AS decisions, max(d.created_at) AS last_at,
|
|
(SELECT count(*) FROM judgement.class_approvals a WHERE a.class_id = c.id AND a.counted) AS streak
|
|
FROM judgement.classes c
|
|
LEFT JOIN judgement.decisions d ON d.org_id = c.org_id AND d.connector = c.connector
|
|
AND d.action = c.action AND d.target_kind = c.target_kind AND d.environment = c.environment AND NOT d.dry
|
|
WHERE c.org_id = $1
|
|
GROUP BY c.id
|
|
ORDER BY coalesce(max(d.created_at), c.created_at) DESC, c.id`, orgID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list classes: %w", err)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ClassByID returns one class.
|
|
func (s *Store) ClassByID(ctx context.Context, orgID string, id uuid.UUID) (Class, error) {
|
|
var out Class
|
|
err := s.db.GetContext(ctx, &out, `SELECT `+classColumns+` FROM judgement.classes WHERE org_id = $1 AND id = $2`, orgID, id)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return Class{}, ErrNoClass
|
|
}
|
|
if err != nil {
|
|
return Class{}, fmt.Errorf("read class: %w", err)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ClassDecisions returns a class's newest decisions, newest first.
|
|
func (s *Store) ClassDecisions(ctx context.Context, c Class, limit int) ([]Decision, error) {
|
|
var out []Decision
|
|
err := s.db.SelectContext(ctx, &out, `
|
|
SELECT id, org_id, run_id, key, connector, action, target_kind, environment, level, body, created_at
|
|
FROM judgement.decisions
|
|
WHERE org_id = $1 AND connector = $2 AND action = $3 AND target_kind = $4 AND environment = $5 AND NOT dry
|
|
ORDER BY created_at DESC, id LIMIT $6`,
|
|
c.OrgID, c.Connector, c.Action, c.TargetKind, c.Environment, limit)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list class decisions: %w", err)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ClassResets returns a class's resets, newest first.
|
|
func (s *Store) ClassResets(ctx context.Context, id uuid.UUID) ([]Reset, error) {
|
|
var out []Reset
|
|
err := s.db.SelectContext(ctx, &out, `
|
|
SELECT id, from_level, to_level, by, at FROM judgement.class_resets
|
|
WHERE class_id = $1 ORDER BY at DESC, id`, id)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("list class resets: %w", err)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ResetClass sets a class to level and records the reset, in one transaction.
|
|
func (s *Store) ResetClass(ctx context.Context, orgID string, id uuid.UUID, level, by string, at time.Time) (Class, error) {
|
|
tx, err := s.db.BeginTxx(ctx, nil)
|
|
if err != nil {
|
|
return Class{}, fmt.Errorf("reset class: %w", err)
|
|
}
|
|
defer func() { _ = tx.Rollback() }()
|
|
var before Class
|
|
err = tx.GetContext(ctx, &before, `SELECT `+classColumns+` FROM judgement.classes WHERE org_id = $1 AND id = $2 FOR UPDATE`, orgID, id)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return Class{}, ErrNoClass
|
|
}
|
|
if err != nil {
|
|
return Class{}, fmt.Errorf("reset class: %w", err)
|
|
}
|
|
var out Class
|
|
if err := tx.GetContext(ctx, &out, `
|
|
UPDATE judgement.classes SET level = $2, reset_at = $3 WHERE id = $1 RETURNING `+classColumns, id, level, at); err != nil {
|
|
return Class{}, fmt.Errorf("reset class: %w", err)
|
|
}
|
|
// A reset starts the count again and withdraws a raise that was waiting.
|
|
if _, err := tx.ExecContext(ctx, `UPDATE judgement.class_approvals SET counted = false WHERE class_id = $1 AND counted`, id); err != nil {
|
|
return Class{}, fmt.Errorf("reset class: %w", err)
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `UPDATE judgement.class_raises SET state = 'superseded' WHERE class_id = $1 AND state = 'pending'`, id); err != nil {
|
|
return Class{}, fmt.Errorf("reset class: %w", err)
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `
|
|
INSERT INTO judgement.class_resets (id, org_id, class_id, from_level, to_level, by, at)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7)`, uuid.New(), orgID, id, before.Level, level, by, at); err != nil {
|
|
return Class{}, fmt.Errorf("record reset: %w", err)
|
|
}
|
|
if err := tx.Commit(); err != nil {
|
|
return Class{}, fmt.Errorf("reset class: %w", err)
|
|
}
|
|
return out, nil
|
|
}
|