feat: Super Check Partial + N+1 helper; fix Flex binding to SmartSDR CAT; telemetry callsign wait
- SCP/N+1: new internal/scp downloads the community MASTER.SCP master list and a docked two-column widget shows, as you type a call, the known calls containing it (Partial) and the calls one edit away (N+1) — click to fix a busted call. Opt-in in Settings → General; top-bar toggle; queried debounced on callsign input. - Flex: OpsLog's GUI-client detection was too loose and could bind to "SmartSDR CAT" (or DAX) — both carry "smartsdr" in the program name — instead of the real GUI client, making SmartSDR CAT drop and reconnect in a loop while OpsLog was open. Now it binds only to a real SmartSDR/Maestro GUI client (e.g. a FLEX-8600M's integrated screen) and excludes cat/dax; dropped the risky empty-program fallback. - Telemetry: on a fresh install the callsign isn't set at launch, so the once-a-day heartbeat recorded the machine UUID. Now it waits (~10 min) for the operator to enter their callsign before sending, falling back to the UUID only if none appears.
This commit is contained in:
@@ -0,0 +1,270 @@
|
||||
// Package scp provides Super Check Partial (SCP) and N+1 callsign suggestions
|
||||
// from the community MASTER.SCP master file (supercheckpartial.com) — the same
|
||||
// aid contest loggers (N1MM, DXLog, Log4OM) show to catch/correct a busted call.
|
||||
//
|
||||
// - Partial (SCP): every master call that CONTAINS what you've typed, so a
|
||||
// mistyped or half-copied call surfaces the real ones.
|
||||
// - N+1: master calls exactly one edit away (one char substituted, added or
|
||||
// removed) from the full call you typed — the classic "did I bust it?" check.
|
||||
//
|
||||
// The list is downloaded once and cached on disk so it survives restarts.
|
||||
package scp
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// masterURL is the community Super Check Partial master file: one callsign per
|
||||
// line, '#'-prefixed header lines. ~50k+ active contest/DX calls.
|
||||
const masterURL = "https://www.supercheckpartial.com/MASTER.SCP"
|
||||
|
||||
const cacheFile = "MASTER.SCP"
|
||||
|
||||
// Result is the two suggestion lists for a typed fragment.
|
||||
type Result struct {
|
||||
Partial []string `json:"partial"` // master calls containing the fragment
|
||||
NPlus1 []string `json:"nplus1"` // master calls one edit away from the full call
|
||||
}
|
||||
|
||||
// Manager holds the parsed call list + cache location.
|
||||
type Manager struct {
|
||||
mu sync.RWMutex
|
||||
calls []string // UPPER, de-duplicated, sorted
|
||||
updated time.Time // when the cache was last refreshed
|
||||
dir string
|
||||
client *http.Client
|
||||
}
|
||||
|
||||
// NewManager loads any on-disk cache and returns a ready manager.
|
||||
func NewManager(dataDir string) *Manager {
|
||||
m := &Manager{
|
||||
dir: dataDir,
|
||||
client: &http.Client{Timeout: 60 * time.Second},
|
||||
}
|
||||
m.loadCache()
|
||||
return m
|
||||
}
|
||||
|
||||
func (m *Manager) path() string { return filepath.Join(m.dir, cacheFile) }
|
||||
|
||||
func (m *Manager) loadCache() {
|
||||
data, err := os.ReadFile(m.path())
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
m.parse(data)
|
||||
if fi, e := os.Stat(m.path()); e == nil {
|
||||
m.mu.Lock()
|
||||
m.updated = fi.ModTime()
|
||||
m.mu.Unlock()
|
||||
}
|
||||
}
|
||||
|
||||
// Download fetches the latest MASTER.SCP, caches it and replaces the in-memory
|
||||
// list. Returns the number of callsigns loaded.
|
||||
func (m *Manager) Download(ctx context.Context) (int, error) {
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, masterURL, nil)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
req.Header.Set("User-Agent", "OpsLog")
|
||||
resp, err := m.client.Do(req)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("scp: request failed: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return 0, fmt.Errorf("scp: http %d", resp.StatusCode)
|
||||
}
|
||||
body, err := io.ReadAll(io.LimitReader(resp.Body, 32*1024*1024))
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("scp: read: %w", err)
|
||||
}
|
||||
n := m.parse(body)
|
||||
if n == 0 {
|
||||
return 0, fmt.Errorf("scp: file parsed to 0 callsigns")
|
||||
}
|
||||
_ = os.WriteFile(m.path(), body, 0o644) // best-effort cache
|
||||
m.mu.Lock()
|
||||
m.updated = time.Now()
|
||||
m.mu.Unlock()
|
||||
return n, nil
|
||||
}
|
||||
|
||||
// parse loads the SCP bytes into the sorted call slice and returns the count.
|
||||
func (m *Manager) parse(data []byte) int {
|
||||
seen := make(map[string]struct{}, 1<<17)
|
||||
sc := bufio.NewScanner(bytes.NewReader(data))
|
||||
sc.Buffer(make([]byte, 1024*1024), 1024*1024)
|
||||
for sc.Scan() {
|
||||
line := strings.ToUpper(strings.TrimSpace(sc.Text()))
|
||||
if line == "" || strings.HasPrefix(line, "#") {
|
||||
continue // blank / header comment
|
||||
}
|
||||
// A call token only (the master file is one call per line, but guard
|
||||
// against stray trailing fields).
|
||||
if i := strings.IndexAny(line, " \t,;"); i >= 0 {
|
||||
line = line[:i]
|
||||
}
|
||||
if !plausibleCall(line) {
|
||||
continue
|
||||
}
|
||||
seen[line] = struct{}{}
|
||||
}
|
||||
if len(seen) == 0 {
|
||||
return 0
|
||||
}
|
||||
calls := make([]string, 0, len(seen))
|
||||
for c := range seen {
|
||||
calls = append(calls, c)
|
||||
}
|
||||
sort.Strings(calls)
|
||||
m.mu.Lock()
|
||||
m.calls = calls
|
||||
m.mu.Unlock()
|
||||
return len(calls)
|
||||
}
|
||||
|
||||
// plausibleCall keeps a token that looks like a callsign: length 3–12, at least
|
||||
// one digit and one letter, only A–Z/0–9//.
|
||||
func plausibleCall(s string) bool {
|
||||
if len(s) < 3 || len(s) > 12 {
|
||||
return false
|
||||
}
|
||||
hasDigit, hasAlpha := false, false
|
||||
for i := 0; i < len(s); i++ {
|
||||
c := s[i]
|
||||
switch {
|
||||
case c >= '0' && c <= '9':
|
||||
hasDigit = true
|
||||
case c >= 'A' && c <= 'Z':
|
||||
hasAlpha = true
|
||||
case c == '/':
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
return hasDigit && hasAlpha
|
||||
}
|
||||
|
||||
// Lookup returns the Partial (substring) and N+1 (one-edit) suggestions for the
|
||||
// typed fragment. limit caps EACH list. Partial needs ≥2 chars; N+1 needs ≥3
|
||||
// (a plausible whole call) and is skipped otherwise.
|
||||
func (m *Manager) Lookup(fragment string, limit int) Result {
|
||||
q := strings.ToUpper(strings.TrimSpace(fragment))
|
||||
if len(q) < 2 {
|
||||
return Result{}
|
||||
}
|
||||
if limit <= 0 {
|
||||
limit = 50
|
||||
}
|
||||
m.mu.RLock()
|
||||
calls := m.calls
|
||||
m.mu.RUnlock()
|
||||
|
||||
wantN1 := len(q) >= 3
|
||||
type pm struct {
|
||||
call string
|
||||
prefix bool
|
||||
}
|
||||
var partial []pm
|
||||
var nplus1 []string
|
||||
for _, c := range calls {
|
||||
if c == q {
|
||||
partial = append(partial, pm{c, true}) // exact = strongest match
|
||||
continue
|
||||
}
|
||||
if idx := strings.Index(c, q); idx >= 0 {
|
||||
partial = append(partial, pm{c, idx == 0})
|
||||
}
|
||||
if wantN1 && len(nplus1) < limit*2 && editDistanceOne(q, c) {
|
||||
nplus1 = append(nplus1, c)
|
||||
}
|
||||
}
|
||||
// Prefix matches first, then the rest (both already alphabetical since `calls`
|
||||
// is sorted and we scanned in order).
|
||||
sort.SliceStable(partial, func(i, j int) bool {
|
||||
if partial[i].prefix != partial[j].prefix {
|
||||
return partial[i].prefix
|
||||
}
|
||||
return false
|
||||
})
|
||||
out := Result{Partial: []string{}, NPlus1: []string{}}
|
||||
for _, p := range partial {
|
||||
if len(out.Partial) >= limit {
|
||||
break
|
||||
}
|
||||
out.Partial = append(out.Partial, p.call)
|
||||
}
|
||||
if len(nplus1) > limit {
|
||||
nplus1 = nplus1[:limit]
|
||||
}
|
||||
out.NPlus1 = append(out.NPlus1, nplus1...)
|
||||
return out
|
||||
}
|
||||
|
||||
// editDistanceOne reports whether a and b are exactly one edit apart (one
|
||||
// substitution, insertion or deletion) — never equal (distance 0 returns false).
|
||||
func editDistanceOne(a, b string) bool {
|
||||
la, lb := len(a), len(b)
|
||||
if la == lb {
|
||||
diff := 0
|
||||
for i := 0; i < la; i++ {
|
||||
if a[i] != b[i] {
|
||||
diff++
|
||||
if diff > 1 {
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
return diff == 1
|
||||
}
|
||||
// Ensure a is the shorter one; lengths must differ by exactly 1.
|
||||
if la > lb {
|
||||
a, b = b, a
|
||||
la, lb = lb, la
|
||||
}
|
||||
if lb-la != 1 {
|
||||
return false
|
||||
}
|
||||
// b is a with one extra char: walk both, allowing a single skip in b.
|
||||
i, j, skipped := 0, 0, false
|
||||
for i < la && j < lb {
|
||||
if a[i] == b[j] {
|
||||
i++
|
||||
j++
|
||||
continue
|
||||
}
|
||||
if skipped {
|
||||
return false
|
||||
}
|
||||
skipped = true
|
||||
j++ // skip the extra char in the longer string
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// Count returns how many callsigns are loaded.
|
||||
func (m *Manager) Count() int {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
return len(m.calls)
|
||||
}
|
||||
|
||||
// Updated returns when the list was last refreshed (zero if never).
|
||||
func (m *Manager) Updated() time.Time {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
return m.updated
|
||||
}
|
||||
Reference in New Issue
Block a user