feat(watchlist): the DXHunter watchlist as an OpsLog tab
The concept, transplanted: a list of callsigns or prefixes being hunted, matched against the live spot stream, one card per entry with the spots underneath and the two questions that matter answered on every line — is this slot still needed, and what is it worth (the cluster's own NEW badges, read from the same status index). The file is DXHunter's own watchlist.json, field for field, ClubLog block included though phase 2 will fill it — a file that round-trips unchanged is the whole of 'same format', and a test pins it with a real DXHunter entry. Global (dataDir), not per profile. CONTEST is per entry, not the global mode DXHunter has: a contest entry is judged against the current UTC day — the boundary lives in the query's date bound, so midnight needs no timer and resets nothing. Normal entries read the same in-memory worked index the alerts use. Prefix matching is why RI0SP catches RI0SP/MM, pinned by test. Notify goes through the existing alert:fired event — the frontend already toasts and sounds it — throttled to one alert per entry per two minutes, because a DXpedition lights every skimmer on the planet. Tab wired like NET Control: opt-in from Tools, persisted, closable. Single click fills the callsign, double click works the spot — the cluster's own gesture, kept.
This commit is contained in:
@@ -2003,6 +2003,43 @@ func bandStatusCode(callWorked, callConfirmed, entityConfirmed bool) int {
|
||||
|
||||
// modeClass collapses ADIF modes into the three buckets DXers care about.
|
||||
// Anything not voice and not CW is treated as digital.
|
||||
// ModeClass is modeClass for callers outside the package — the watchlist
|
||||
// judges slots at the same grain the cluster does.
|
||||
func ModeClass(mode string) string { return modeClass(mode) }
|
||||
|
||||
// SlotRow is one (callsign, band, mode) triple from SlotsSince.
|
||||
type SlotRow struct {
|
||||
Callsign string
|
||||
Band string
|
||||
Mode string
|
||||
}
|
||||
|
||||
// SlotsSince lists the slots of every contact made since the given instant —
|
||||
// the contest watchlist's "worked today", where the day boundary lives in this
|
||||
// query's bound and nowhere else.
|
||||
func SlotsSince(r *Repo, ctx context.Context, since time.Time) ([]SlotRow, error) {
|
||||
return r.SlotsSince(ctx, since)
|
||||
}
|
||||
|
||||
func (r *Repo) SlotsSince(ctx context.Context, since time.Time) ([]SlotRow, error) {
|
||||
rows, err := r.db.QueryContext(ctx,
|
||||
"SELECT callsign, band, mode FROM qso WHERE qso_date >= ?",
|
||||
since.UTC().Format(isoMillis))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var out []SlotRow
|
||||
for rows.Next() {
|
||||
var sr SlotRow
|
||||
if err := rows.Scan(&sr.Callsign, &sr.Band, &sr.Mode); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, sr)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
func modeClass(mode string) string {
|
||||
switch strings.ToUpper(mode) {
|
||||
case "SSB", "USB", "LSB", "AM", "FM", "DIGITALVOICE", "PHONE":
|
||||
|
||||
@@ -0,0 +1,236 @@
|
||||
// Package watchlist is the DXHunter watchlist, transplanted: a list of
|
||||
// callsigns (or prefixes) the operator is hunting, matched against the live
|
||||
// spot stream, with per-entry state that survives restarts.
|
||||
//
|
||||
// The JSON file is DXHunter's OWN schema, field for field — including the
|
||||
// ClubLog expedition block this phase does not fill yet. Deliberate: the
|
||||
// operator asked to carry their watchlist.json across, and a file that
|
||||
// round-trips unchanged is the whole of "same format". The file is GLOBAL
|
||||
// (dataDir, beside nets.json), not per profile: a DXpedition worth hunting is
|
||||
// worth hunting whichever station is on.
|
||||
//
|
||||
// The CONTEST idea is per entry, not a global mode as in DXHunter: an entry
|
||||
// marked contest is judged against the CURRENT UTC DAY — at midnight UTC
|
||||
// yesterday's contacts stop counting and every slot reads "work today" again.
|
||||
// Nothing resets and nothing is stored for it: the day boundary lives in the
|
||||
// query, which is why it cannot drift or need a timer.
|
||||
package watchlist
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"sort"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Entry is one watched callsign. JSON tags match DXHunter's watchlist.json
|
||||
// exactly — see the package comment before renaming anything.
|
||||
type Entry struct {
|
||||
Callsign string `json:"callsign"`
|
||||
LastSeen time.Time `json:"lastSeen"`
|
||||
LastSeenStr string `json:"lastSeenStr"`
|
||||
AddedAt time.Time `json:"addedAt"`
|
||||
SpotCount int `json:"spotCount"`
|
||||
IsContest bool `json:"isContest"`
|
||||
Notify bool `json:"notify"`
|
||||
// ClubLog expedition enrichment — phase 2. Carried so a DXHunter file
|
||||
// round-trips; not filled by OpsLog yet.
|
||||
IsExpedition bool `json:"isExpedition"`
|
||||
ClubLogQSOs24h int `json:"clubLogQSOs24h"`
|
||||
ClubLogTotalQSOs int `json:"clubLogTotalQSOs"`
|
||||
ClubLogHasOQRS bool `json:"clubLogHasOQRS"`
|
||||
ClubLogLiveStream bool `json:"clubLogLiveStream"`
|
||||
ClubLogUpdatedAt time.Time `json:"clubLogUpdatedAt,omitempty"`
|
||||
}
|
||||
|
||||
// Store owns the file. All methods are safe for concurrent use; writes are
|
||||
// debounced so a burst of MarkSeen calls costs one disk write.
|
||||
type Store struct {
|
||||
mu sync.RWMutex
|
||||
entries map[string]*Entry
|
||||
path string
|
||||
|
||||
saveMu sync.Mutex
|
||||
saveTimer *time.Timer
|
||||
ioMu sync.Mutex
|
||||
}
|
||||
|
||||
func New(path string) *Store {
|
||||
s := &Store{entries: map[string]*Entry{}, path: path}
|
||||
s.load()
|
||||
return s
|
||||
}
|
||||
|
||||
func (s *Store) load() {
|
||||
data, err := os.ReadFile(s.path)
|
||||
if err != nil {
|
||||
return // absent on first run — created on first save
|
||||
}
|
||||
var list []Entry
|
||||
if err := json.Unmarshal(data, &list); err != nil {
|
||||
return // a corrupt file must not take the app down; it is left for repair
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
for i := range list {
|
||||
e := list[i]
|
||||
e.Callsign = strings.ToUpper(strings.TrimSpace(e.Callsign))
|
||||
if e.Callsign == "" {
|
||||
continue
|
||||
}
|
||||
s.entries[e.Callsign] = &e
|
||||
}
|
||||
}
|
||||
|
||||
// Entries returns a snapshot, watched-first ordering left to the UI.
|
||||
func (s *Store) Entries() []Entry {
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
out := make([]Entry, 0, len(s.entries))
|
||||
for _, e := range s.entries {
|
||||
c := *e
|
||||
c.LastSeenStr = lastSeenLabel(c.LastSeen)
|
||||
out = append(out, c)
|
||||
}
|
||||
sort.Slice(out, func(i, j int) bool { return out[i].Callsign < out[j].Callsign })
|
||||
return out
|
||||
}
|
||||
|
||||
// Add creates an entry; contest marks it as re-workable every UTC day.
|
||||
func (s *Store) Add(callsign string, contest bool) error {
|
||||
call := strings.ToUpper(strings.TrimSpace(callsign))
|
||||
if call == "" {
|
||||
return fmt.Errorf("callsign required")
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
if _, ok := s.entries[call]; ok {
|
||||
return fmt.Errorf("%s is already on the watchlist", call)
|
||||
}
|
||||
s.entries[call] = &Entry{Callsign: call, AddedAt: time.Now(), IsContest: contest}
|
||||
s.scheduleSave()
|
||||
return nil
|
||||
}
|
||||
|
||||
// Remove deletes an entry.
|
||||
func (s *Store) Remove(callsign string) error {
|
||||
call := strings.ToUpper(strings.TrimSpace(callsign))
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
if _, ok := s.entries[call]; !ok {
|
||||
return fmt.Errorf("%s is not on the watchlist", call)
|
||||
}
|
||||
delete(s.entries, call)
|
||||
s.scheduleSave()
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetNotify arms or disarms the alert for one entry.
|
||||
func (s *Store) SetNotify(callsign string, on bool) error {
|
||||
return s.patch(callsign, func(e *Entry) { e.Notify = on })
|
||||
}
|
||||
|
||||
// SetContest flips the per-entry contest rule.
|
||||
func (s *Store) SetContest(callsign string, on bool) error {
|
||||
return s.patch(callsign, func(e *Entry) { e.IsContest = on })
|
||||
}
|
||||
|
||||
func (s *Store) patch(callsign string, fn func(*Entry)) error {
|
||||
call := strings.ToUpper(strings.TrimSpace(callsign))
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
e, ok := s.entries[call]
|
||||
if !ok {
|
||||
return fmt.Errorf("%s is not on the watchlist", call)
|
||||
}
|
||||
fn(e)
|
||||
s.scheduleSave()
|
||||
return nil
|
||||
}
|
||||
|
||||
// Match returns the entry a spotted callsign belongs to, or "".
|
||||
//
|
||||
// Prefix match, exactly as DXHunter does it: an entry RI0SP must catch
|
||||
// RI0SP/MM and RI0SP/P — expeditions sign portable more often than not, and an
|
||||
// exact-only match left lastSeen stale while fresh spots scrolled past.
|
||||
func (s *Store) Match(callsign string) (string, bool) {
|
||||
call := strings.ToUpper(strings.TrimSpace(callsign))
|
||||
if call == "" {
|
||||
return "", false
|
||||
}
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
for pattern := range s.entries {
|
||||
if call == pattern || strings.HasPrefix(call, pattern) {
|
||||
return pattern, true
|
||||
}
|
||||
}
|
||||
return "", false
|
||||
}
|
||||
|
||||
// MarkSeen records a spot against the matching entry and reports whether the
|
||||
// entry wants an alert.
|
||||
func (s *Store) MarkSeen(callsign string) (entry string, notify bool, ok bool) {
|
||||
pattern, found := s.Match(callsign)
|
||||
if !found {
|
||||
return "", false, false
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
e := s.entries[pattern]
|
||||
if e == nil {
|
||||
return "", false, false
|
||||
}
|
||||
e.LastSeen = time.Now()
|
||||
e.SpotCount++
|
||||
s.scheduleSave()
|
||||
return e.Callsign, e.Notify, true
|
||||
}
|
||||
|
||||
// scheduleSave debounces the write: a burst of spots costs one file write two
|
||||
// seconds after the last of them. Callers hold s.mu.
|
||||
func (s *Store) scheduleSave() {
|
||||
s.saveMu.Lock()
|
||||
defer s.saveMu.Unlock()
|
||||
if s.saveTimer != nil {
|
||||
s.saveTimer.Stop()
|
||||
}
|
||||
s.saveTimer = time.AfterFunc(2*time.Second, func() { s.persist() })
|
||||
}
|
||||
|
||||
func (s *Store) persist() {
|
||||
list := s.Entries()
|
||||
data, err := json.MarshalIndent(list, "", " ")
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
s.ioMu.Lock()
|
||||
defer s.ioMu.Unlock()
|
||||
_ = os.WriteFile(s.path, data, 0o644)
|
||||
}
|
||||
|
||||
// Flush writes now — for shutdown, where the two-second debounce would lose
|
||||
// the last edits.
|
||||
func (s *Store) Flush() { s.persist() }
|
||||
|
||||
// lastSeenLabel is DXHunter's "Just now / 5m ago / 3h ago / 2d ago" string,
|
||||
// computed at read time so it never goes stale in the file.
|
||||
func lastSeenLabel(t time.Time) string {
|
||||
if t.IsZero() {
|
||||
return "Never"
|
||||
}
|
||||
d := time.Since(t)
|
||||
switch {
|
||||
case d < time.Minute:
|
||||
return "Just now"
|
||||
case d < time.Hour:
|
||||
return fmt.Sprintf("%dm ago", int(d.Minutes()))
|
||||
case d < 24*time.Hour:
|
||||
return fmt.Sprintf("%dh ago", int(d.Hours()))
|
||||
default:
|
||||
return fmt.Sprintf("%dd ago", int(d.Hours()/24))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
package watchlist
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestPrefixMatch(t *testing.T) {
|
||||
s := New(filepath.Join(t.TempDir(), "watchlist.json"))
|
||||
if err := s.Add("RI0SP", false); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// The reason prefix matching exists: expeditions sign portable.
|
||||
for _, call := range []string{"RI0SP", "RI0SP/MM", "RI0SP/P"} {
|
||||
if _, ok := s.Match(call); !ok {
|
||||
t.Errorf("Match(%q) = false, want true", call)
|
||||
}
|
||||
}
|
||||
if _, ok := s.Match("RI0S"); ok {
|
||||
t.Error("a SHORTER call must not match the entry")
|
||||
}
|
||||
if _, ok := s.Match("F4BPO"); ok {
|
||||
t.Error("an unrelated call matched")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDXHunterFileRoundTrips(t *testing.T) {
|
||||
// A real DXHunter entry, ClubLog block included. It must survive
|
||||
// load → save byte-meaningfully: same keys, values preserved.
|
||||
src := `[{"callsign":"C5SP","lastSeen":"0001-01-01T00:00:00Z","lastSeenStr":"Never",
|
||||
"addedAt":"2026-01-17T00:18:43.89Z","spotCount":7,"isContest":true,"notify":true,
|
||||
"isExpedition":true,"clubLogQSOs24h":120,"clubLogTotalQSOs":30500,
|
||||
"clubLogHasOQRS":true,"clubLogLiveStream":true,"clubLogUpdatedAt":"2026-08-28T22:32:18Z"}]`
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "watchlist.json")
|
||||
if err := os.WriteFile(path, []byte(src), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
s := New(path)
|
||||
s.Flush()
|
||||
out, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var list []map[string]any
|
||||
if err := json.Unmarshal(out, &list); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(list) != 1 {
|
||||
t.Fatalf("got %d entries", len(list))
|
||||
}
|
||||
e := list[0]
|
||||
for k, want := range map[string]any{
|
||||
"callsign": "C5SP", "isContest": true, "notify": true,
|
||||
"isExpedition": true, "clubLogQSOs24h": float64(120),
|
||||
"clubLogTotalQSOs": float64(30500), "clubLogHasOQRS": true,
|
||||
} {
|
||||
if e[k] != want {
|
||||
t.Errorf("%s = %v, want %v", k, e[k], want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMarkSeenAndNotify(t *testing.T) {
|
||||
s := New(filepath.Join(t.TempDir(), "watchlist.json"))
|
||||
_ = s.Add("HB040A", false)
|
||||
_ = s.SetNotify("HB040A", true)
|
||||
entry, notify, ok := s.MarkSeen("HB040A")
|
||||
if !ok || !notify || entry != "HB040A" {
|
||||
t.Fatalf("MarkSeen = %q %v %v", entry, notify, ok)
|
||||
}
|
||||
list := s.Entries()
|
||||
if list[0].SpotCount != 1 || list[0].LastSeenStr != "Just now" {
|
||||
t.Errorf("entry after MarkSeen: %+v", list[0])
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user