pkg/alerting/rules/alertrules.go

@@ -1,36 +0,0 @@
-package rules
-
-import (
-	"time"
-
-	"dynatron.me/x/stillbox/internal/ruletime"
-)
-
-type AlertRules []AlertRule
-
-func (ars *AlertRules) Apply(t time.Time, coversOpts ...ruletime.CoversOption) float64 {
-	final := 1.0
-
-	for _, ar := range *ars {
-		if ar.MatchTime(t, coversOpts...) {
-			final *= float64(ar.ScoreMultiplier)
-		}
-	}
-
-	return final
-}
-
-type AlertRule struct {
-	Times           []ruletime.RuleTime `json:"times"`
-	ScoreMultiplier float32             `json:"mult"`
-}
-
-func (ar *AlertRule) MatchTime(t time.Time, coversOpts ...ruletime.CoversOption) bool {
-	for _, at := range ar.Times {
-		if at.Covers(t, coversOpts...) {
-			return true
-		}
-	}
-
-	return false
-}

pkg/database/models.go

@@ -7,7 +7,6 @@ package database
 import (
 	"time"
 
-	"dynatron.me/x/stillbox/pkg/alerting/rules"
 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5/pgtype"
 )
@@ -93,7 +92,7 @@ type Talkgroup struct {
 	Metadata    []byte   `json:"metadata"`
 	Tags        []string `json:"tags"`
 	Alert       bool     `json:"alert"`
-	AlertConfig rules.AlertRules `json:"alert_config"`
+	AlertConfig []byte   `json:"alert_config"`
 	Weight      float32  `json:"weight"`
 }
 

pkg/database/talkgroups.sql.go

@@ -7,8 +7,6 @@ package database
 
 import (
 	"context"
-
-	"dynatron.me/x/stillbox/pkg/alerting/rules"
 )
 
 const bulkSetTalkgroupTags = `-- name: BulkSetTalkgroupTags :exec
@@ -499,7 +497,7 @@ type UpdateTalkgroupParams struct {
 	Metadata    []byte   `json:"metadata"`
 	Tags        []string `json:"tags"`
 	Alert       *bool    `json:"alert"`
-	AlertConfig rules.AlertRules `json:"alert_config"`
+	AlertConfig []byte   `json:"alert_config"`
 	Weight      *float32 `json:"weight"`
 	ID          int64    `json:"id"`
 }

pkg/database/talkgroups.sql_test.go

@@ -6,7 +6,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-const getTalkgroupsWithLearnedByPackedIDsTest = `-- name: GetTalkgroupsWithLearnedByPackedIDs :many
+const getTalkgroupWithLearnedByPackedIDsTest = `-- name: GetTalkgroupWithLearnedByPackedIDs :many
 SELECT
 tg.id, tg.system_id, tg.tgid, tg.name, tg.alpha_tag, tg.tg_group, tg.frequency, tg.metadata, tg.tags, tg.alert, tg.alert_config, tg.weight, sys.id, sys.name,
 FALSE learned
@@ -59,7 +59,7 @@ TRUE, NULL::JSONB, 1.0, sys.id, sys.name,
 TRUE learned
 FROM talkgroups_learned tgl
 JOIN systems sys ON tgl.system_id = sys.id
-WHERE tgl.system_id = $1 AND ignored IS NOT TRUE
+WHERE tg.system_id = $1 AND ignored IS NOT TRUE
 `
 
 const getTalkgroupsWithLearnedTest = `-- name: GetTalkgroupsWithLearned :many
@@ -81,7 +81,7 @@ WHERE ignored IS NOT TRUE
 `
 
 func TestQueryColumnsMatch(t *testing.T) {
-	require.Equal(t, getTalkgroupsWithLearnedByPackedIDsTest, getTalkgroupsWithLearnedByPackedIDs)
+	require.Equal(t, getTalkgroupsWithLearnedByPackedIDsTest, getTalkgroupWithLearnedByPackedIDs)
 	require.Equal(t, getTalkgroupWithLearnedTest, getTalkgroupWithLearned)
 	require.Equal(t, getTalkgroupsWithLearnedBySystemTest, getTalkgroupsWithLearnedBySystem)
 	require.Equal(t, getTalkgroupsWithLearnedTest, getTalkgroupsWithLearned)

pkg/rest/api.go

@@ -43,6 +43,7 @@ type errResponse struct {
 func (e *errResponse) Render(w http.ResponseWriter, r *http.Request) error {
 	switch e.Code {
 	case http.StatusNotFound:
+	case http.StatusBadRequest:
 	default:
 		log.Error().Str("path", r.URL.Path).Err(e.Err).Int("code", e.Code).Str("msg", e.Error).Msg("request failed")
 	}

pkg/talkgroups/alertconfig.go

@@ -1,39 +1,54 @@
 package talkgroups
 
 import (
+	"encoding/json"
 	"sync"
 	"time"
 
 	"dynatron.me/x/stillbox/internal/ruletime"
-	"dynatron.me/x/stillbox/pkg/alerting/rules"
 )
 
 type AlertConfig struct {
 	sync.RWMutex
-	m map[ID]rules.AlertRules
+	m map[ID][]AlertRule
+}
+
+type AlertRule struct {
+	Times           []ruletime.RuleTime `json:"times"`
+	ScoreMultiplier float32             `json:"mult"`
 }
 
 func NewAlertConfig() AlertConfig {
 	return AlertConfig{
-		m: make(map[ID]rules.AlertRules),
+		m: make(map[ID][]AlertRule),
 	}
 }
 
-func (ac *AlertConfig) Add(tg ID, r rules.AlertRules) error {
-	ac.Lock()
-	defer ac.Unlock()
-
-	ac.m[tg] = r
-	return nil
-}
-
-func (ac *AlertConfig) GetRules(tg ID) rules.AlertRules {
+func (ac *AlertConfig) GetRules(tg ID) []AlertRule {
 	ac.RLock()
 	defer ac.RUnlock()
 
 	return ac.m[tg]
 }
 
+func (ac *AlertConfig) UnmarshalTGRules(tg ID, confBytes []byte) error {
+	ac.Lock()
+	defer ac.Unlock()
+
+	if len(confBytes) == 0 {
+		return nil
+	}
+
+	var rules []AlertRule
+	err := json.Unmarshal(confBytes, &rules)
+	if err != nil {
+		return err
+	}
+
+	ac.m[tg] = rules
+	return nil
+}
+
 func (ac *AlertConfig) ApplyAlertRules(id ID, t time.Time, coversOpts ...ruletime.CoversOption) float64 {
 	ac.RLock()
 	s, has := ac.m[id]
@@ -42,7 +57,15 @@ func (ac *AlertConfig) ApplyAlertRules(id ID, t time.Time, coversOpts ...ruletim
 		return 1.0
 	}
 
-	return s.Apply(t, coversOpts...)
+	final := 1.0
+
+	for _, ar := range s {
+		if ar.MatchTime(t, coversOpts...) {
+			final *= float64(ar.ScoreMultiplier)
+		}
+	}
+
+	return final
 }
 
 func (ac *AlertConfig) Invalidate() {
@@ -51,3 +74,13 @@ func (ac *AlertConfig) Invalidate() {
 
 	clear(ac.m)
 }
+
+func (ar *AlertRule) MatchTime(t time.Time, coversOpts ...ruletime.CoversOption) bool {
+	for _, at := range ar.Times {
+		if at.Covers(t, coversOpts...) {
+			return true
+		}
+	}
+
+	return false
+}

pkg/talkgroups/alertconfig_test.go

@@ -1,7 +1,6 @@
-package rules_test
+package talkgroups_test
 
 import (
-	"encoding/json"
 	"errors"
 	"math"
 	"testing"
@@ -9,7 +8,6 @@ import (
 
 	"dynatron.me/x/stillbox/internal/ruletime"
 	"dynatron.me/x/stillbox/internal/trending"
-	"dynatron.me/x/stillbox/pkg/alerting/rules"
 	"dynatron.me/x/stillbox/pkg/talkgroups"
 
 	"github.com/stretchr/testify/assert"
@@ -22,14 +20,14 @@ func TestAlertConfig(t *testing.T) {
 		name      string
 		tg        talkgroups.ID
 		conf      string
-		compare   rules.AlertRules
+		compare   []talkgroups.AlertRule
 		expectErr error
 	}{
 		{
 			name: "base case",
 			tg:   talkgroups.TG(197, 3),
 			conf: `[{"times":["7:00+2h","01:00+1h","16:00+1h","19:00+4h"],"mult":0.2},{"times":["11:00+1h","15:00+30m","16:03+20m"],"mult":2.0}]`,
-			compare: rules.AlertRules{
+			compare: []talkgroups.AlertRule{
 				{
 					Times: []ruletime.RuleTime{
 						ruletime.Must(ruletime.New("7:00+2h")),
@@ -59,13 +57,11 @@ func TestAlertConfig(t *testing.T) {
 
 	for _, tc := range parseTests {
 		t.Run(tc.name, func(t *testing.T) {
-			var ar rules.AlertRules
-			err := json.Unmarshal([]byte(tc.conf), &ar)
+			err := ac.UnmarshalTGRules(tc.tg, []byte(tc.conf))
 			if tc.expectErr != nil {
 				require.Error(t, err)
 				assert.Contains(t, err.Error(), tc.expectErr.Error())
 			} else {
-				ac.Add(tc.tg, ar)
 				assert.Equal(t, tc.compare, ac.GetRules(tc.tg))
 			}
 		})

pkg/talkgroups/cache.go

@@ -139,9 +139,7 @@ func (t *cache) add(rec *Talkgroup) error {
 	t.tgs[tg] = rec
 	t.systems[int32(rec.System.ID)] = rec.System.Name
 
-	t.AlertConfig.Add(tg, rec.AlertConfig)
-
-	return nil
+	return t.AlertConfig.UnmarshalTGRules(tg, rec.Talkgroup.AlertConfig)
 }
 
 type row interface {

sql/sqlc.yaml

@@ -27,8 +27,3 @@ sql:
             go_type: "time.Time"
           - db_type: "pg_catalog.text"
             go_type: "string"
-          - column: "talkgroups.alert_config"
-            go_type:
-              import: "dynatron.me/x/stillbox/pkg/alerting/rules"
-              type: "AlertRules"
-            nullable: true