Files
2026-11-15 05:47:14 +09:00

146 lines
5.0 KiB
Go

package store
import (
"context"
"database/sql"
"strings"
"time"
"github.com/google/uuid"
)
type Broadcast struct {
UUID string `json:"uuid"`
DomainUUID string `json:"domain_uuid"`
Title string `json:"title"`
Body string `json:"body"`
Severity string `json:"severity"`
StartsAtMS int64 `json:"starts_at_ms"`
EndsAtMS int64 `json:"ends_at_ms"`
CreatedAtMS int64 `json:"created_at_ms"`
UpdatedAtMS int64 `json:"updated_at_ms"`
}
func (s *Store) EnsureBroadcastSchema() error {
return s.ensureSchemaComponent("broadcasts")
}
const broadcastColumns = `uuid,domain_uuid,title,body,severity,starts_at_ms,ends_at_ms,created_at_ms,updated_at_ms`
func scanBroadcast(scanner interface{ Scan(...any) error }, b *Broadcast) error {
return scanner.Scan(&b.UUID, &b.DomainUUID, &b.Title, &b.Body, &b.Severity, &b.StartsAtMS, &b.EndsAtMS, &b.CreatedAtMS, &b.UpdatedAtMS)
}
func (s *Store) ListActiveBroadcasts(ctx context.Context, domain string, nowMS int64) (_ []Broadcast, resultErr error) {
defer func() { resultErr = s.sqlError("active broadcasts", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
if nowMS == 0 {
nowMS = time.Now().UnixMilli()
}
rows, err := s.DB.QueryContext(ctx, `SELECT `+broadcastColumns+` FROM broadcasts WHERE domain_uuid=`+s.sqlParam(1)+` AND (starts_at_ms=0 OR starts_at_ms<=`+s.sqlParam(2)+`) AND (ends_at_ms=0 OR ends_at_ms>`+s.sqlParam(3)+`) ORDER BY severity DESC,updated_at_ms DESC LIMIT 20`, domain, nowMS, nowMS)
if err != nil {
return nil, err
}
defer rows.Close()
out := []Broadcast{}
for rows.Next() {
var b Broadcast
if err := scanBroadcast(rows, &b); err != nil {
return nil, err
}
out = append(out, b)
}
return out, rows.Err()
}
func (s *Store) ListBroadcasts(ctx context.Context, domain string) (_ []Broadcast, resultErr error) {
defer func() { resultErr = s.sqlError("broadcast listing", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
rows, err := s.DB.QueryContext(ctx, `SELECT `+broadcastColumns+` FROM broadcasts WHERE domain_uuid=`+s.sqlParam(1)+` ORDER BY updated_at_ms DESC LIMIT 100`, domain)
if err != nil {
return nil, err
}
defer rows.Close()
out := []Broadcast{}
for rows.Next() {
var b Broadcast
if err := scanBroadcast(rows, &b); err != nil {
return nil, err
}
out = append(out, b)
}
return out, rows.Err()
}
func (s *Store) SaveBroadcast(b Broadcast) (resultErr error) {
defer func() { resultErr = s.sqlError("broadcast save", resultErr) }()
if s.ReadOnly {
return ErrReadOnly
}
b.DomainUUID = strings.TrimSpace(b.DomainUUID)
b.Title = strings.TrimSpace(b.Title)
b.Body = strings.TrimSpace(b.Body)
if b.UUID == "" {
b.UUID = uuid.NewString()
}
if b.Severity != "success" && b.Severity != "warning" && b.Severity != "critical" {
b.Severity = "info"
}
now := time.Now().UnixMilli()
if b.CreatedAtMS == 0 {
b.CreatedAtMS = now
}
b.UpdatedAtMS = now
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
if err = s.lockTaskWriter(ctx, tx); err != nil {
return err
}
result, err := tx.ExecContext(ctx, `INSERT INTO broadcasts(`+broadcastColumns+`) VALUES(`+s.sqlValues(9)+`) ON CONFLICT(uuid) DO UPDATE SET title=excluded.title,body=excluded.body,severity=excluded.severity,starts_at_ms=excluded.starts_at_ms,ends_at_ms=excluded.ends_at_ms,updated_at_ms=excluded.updated_at_ms WHERE broadcasts.domain_uuid=excluded.domain_uuid`, b.UUID, b.DomainUUID, b.Title, b.Body, b.Severity, b.StartsAtMS, b.EndsAtMS, b.CreatedAtMS, b.UpdatedAtMS)
if err != nil {
return err
}
n, err := result.RowsAffected()
if err != nil {
return err
}
if n != 1 {
return sql.ErrNoRows
}
return tx.Commit()
}
func (s *Store) DeleteBroadcast(domain, id string) (resultErr error) {
defer func() { resultErr = s.sqlError("broadcast deletion", resultErr) }()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
if err = s.lockTaskWriter(ctx, tx); err != nil {
return err
}
if _, err = tx.Exec(`DELETE FROM notification_inbox WHERE domain_uuid=`+s.sqlParam(1)+` AND event_uuid=`+s.sqlParam(2)+` AND kind='broadcast'`, domain, id); err != nil {
return err
}
if _, err = tx.Exec(`DELETE FROM broadcasts WHERE domain_uuid=`+s.sqlParam(1)+` AND uuid=`+s.sqlParam(2)+``, domain, id); err != nil {
return err
}
return tx.Commit()
}
func (s *Store) GetBroadcast(ctx context.Context, domain, id string) (_ Broadcast, resultErr error) {
defer func() { resultErr = s.sqlError("broadcast lookup", resultErr) }()
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
var b Broadcast
err := scanBroadcast(s.DB.QueryRowContext(ctx, `SELECT `+broadcastColumns+` FROM broadcasts WHERE domain_uuid=`+s.sqlParam(1)+` AND uuid=`+s.sqlParam(2)+``, domain, id), &b)
return b, err
}