feat: added extra stats for contests
This commit is contained in:
+109
-22
@@ -163,6 +163,21 @@ type Stats struct {
|
||||
Best60 int `json:"best_60"` // best ROLLING 60 min — the number contesters quote
|
||||
Gaps []Gap `json:"gaps"` // the silences that make up OffAirMinutes, longest first
|
||||
Rate []Bucket `json:"rate"` // QSO per clock hour across the window ("MM-DD HH")
|
||||
|
||||
// The contest RATE SHEET: hour by hour, who made the QSOs.
|
||||
// RateOps are the operators, busiest first — that fixed order is also the
|
||||
// colour/legend order, so an operator keeps their hue across the whole page.
|
||||
// RateByOp[h][o] is operator o's count in hour h; rows align 1:1 with Rate, so
|
||||
// the per-operator numbers always sum to the hour's total.
|
||||
RateOps []string `json:"rate_ops"`
|
||||
RateByOp [][]int `json:"rate_by_op"`
|
||||
}
|
||||
|
||||
// entry is one dated QSO with the operator who made it — the pair the contest
|
||||
// rate sheet needs. A bare timestamp can tell you HOW MANY, never BY WHOM.
|
||||
type entry struct {
|
||||
t time.Time
|
||||
op string
|
||||
}
|
||||
|
||||
// bandOrder sorts bands by frequency (160m → 70cm) rather than alphabetically,
|
||||
@@ -219,7 +234,7 @@ func (r *Repo) Stats(ctx context.Context, from, to time.Time, contestID string,
|
||||
entityC = map[string]int{}
|
||||
yearC = map[string]int{}
|
||||
monthC = map[string]int{}
|
||||
times []time.Time // every dated QSO, for the rate / gap maths
|
||||
times []entry // every dated QSO (+ its operator), for the rate / gap maths
|
||||
first, last time.Time
|
||||
)
|
||||
|
||||
@@ -318,7 +333,7 @@ func (r *Repo) Stats(ctx context.Context, from, to time.Time, contestID string,
|
||||
}
|
||||
yearC[t.Format("2006")]++
|
||||
monthC[t.Format("2006-01")]++
|
||||
times = append(times, t)
|
||||
times = append(times, entry{t: t, op: op})
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return s, err
|
||||
@@ -404,6 +419,12 @@ func (s *Stats) ensureNonNil() {
|
||||
if s.Gaps == nil {
|
||||
s.Gaps = []Gap{}
|
||||
}
|
||||
if s.RateOps == nil {
|
||||
s.RateOps = []string{}
|
||||
}
|
||||
if s.RateByOp == nil {
|
||||
s.RateByOp = [][]int{}
|
||||
}
|
||||
}
|
||||
|
||||
// periodMetrics derives the rate / off-air figures that make a contest window
|
||||
@@ -415,11 +436,11 @@ func (s *Stats) ensureNonNil() {
|
||||
// • AvgPerActive = QSOs ÷ the hours actually operated. Flatters, but tells you
|
||||
// how fast you go when you ARE at the radio.
|
||||
// Quoting only the second is how an 8-hour effort gets sold as a 48-hour score.
|
||||
func (s *Stats) periodMetrics(times []time.Time, from, to, first, last time.Time) {
|
||||
func (s *Stats) periodMetrics(times []entry, from, to, first, last time.Time) {
|
||||
if len(times) == 0 {
|
||||
return
|
||||
}
|
||||
sort.Slice(times, func(i, j int) bool { return times[i].Before(times[j]) })
|
||||
sort.Slice(times, func(i, j int) bool { return times[i].t.Before(times[j].t) })
|
||||
|
||||
winStart, winEnd := from, to
|
||||
if winStart.IsZero() {
|
||||
@@ -441,8 +462,8 @@ func (s *Stats) periodMetrics(times []time.Time, from, to, first, last time.Time
|
||||
// Clock-hour buckets — for the rate chart and the best clock hour only. NOT for
|
||||
// "hours on air": a single QSO at 08:05 would book the whole 08:00 hour.
|
||||
hourly := map[string]int{}
|
||||
for _, t := range times {
|
||||
hourly[t.Format("2006-01-02 15")]++
|
||||
for _, e := range times {
|
||||
hourly[e.t.Format("2006-01-02 15")]++
|
||||
}
|
||||
for k, v := range hourly {
|
||||
if v > s.PeakHourCount || (v == s.PeakHourCount && k < s.PeakHourKey) {
|
||||
@@ -455,7 +476,7 @@ func (s *Stats) periodMetrics(times []time.Time, from, to, first, last time.Time
|
||||
// actually quote. Two pointers over the sorted times: O(n).
|
||||
lo := 0
|
||||
for hi := range times {
|
||||
for times[hi].Sub(times[lo]) >= time.Hour {
|
||||
for times[hi].t.Sub(times[lo].t) >= time.Hour {
|
||||
lo++
|
||||
}
|
||||
if n := hi - lo + 1; n > s.Best60 {
|
||||
@@ -481,11 +502,11 @@ func (s *Stats) periodMetrics(times []time.Time, from, to, first, last time.Time
|
||||
Minutes: int(d.Minutes()),
|
||||
})
|
||||
}
|
||||
addGap(winStart, times[0]) // lead-in
|
||||
for i := 1; i < len(times); i++ { // the silences between QSOs
|
||||
addGap(times[i-1], times[i])
|
||||
addGap(winStart, times[0].t) // lead-in
|
||||
for i := 1; i < len(times); i++ { // the silences between QSOs
|
||||
addGap(times[i-1].t, times[i].t)
|
||||
}
|
||||
addGap(times[len(times)-1], winEnd) // tail
|
||||
addGap(times[len(times)-1].t, winEnd) // tail
|
||||
|
||||
s.OnAirMinutes = int(winEnd.Sub(winStart).Minutes()) - s.OffAirMinutes
|
||||
if s.OnAirMinutes < 0 {
|
||||
@@ -499,21 +520,87 @@ func (s *Stats) periodMetrics(times []time.Time, from, to, first, last time.Time
|
||||
s.Gaps = s.Gaps[:10] // the long ones are the story; the tail is noise
|
||||
}
|
||||
|
||||
// Per-hour rate timeline — the classic contest rate chart. Every hour of the
|
||||
// window, zeros included, so the silences are visible as silences.
|
||||
if s.WindowHours <= rateMaxHours {
|
||||
cur := winStart.Truncate(time.Hour)
|
||||
end := winEnd.Truncate(time.Hour)
|
||||
for !cur.After(end) {
|
||||
s.Rate = append(s.Rate, Bucket{
|
||||
Key: cur.Format("01-02 15"),
|
||||
Count: hourly[cur.Format("2006-01-02 15")],
|
||||
})
|
||||
cur = cur.Add(time.Hour)
|
||||
// Per-hour rate timeline + the RATE SHEET (who made those QSOs, hour by hour).
|
||||
// Every hour of the window, zeros included, so the silences read as silences.
|
||||
if s.WindowHours > rateMaxHours {
|
||||
return
|
||||
}
|
||||
|
||||
// Operators, busiest first. That order is fixed and reused as the colour/legend
|
||||
// order, so an operator keeps the same hue everywhere on the page — a chart that
|
||||
// repaints its series when the filter changes is a chart nobody can trust.
|
||||
opTotals := map[string]int{}
|
||||
for _, e := range times {
|
||||
opTotals[e.op]++
|
||||
}
|
||||
s.RateOps = make([]string, 0, len(opTotals))
|
||||
for op := range opTotals {
|
||||
s.RateOps = append(s.RateOps, op)
|
||||
}
|
||||
sort.Slice(s.RateOps, func(i, j int) bool {
|
||||
a, b := s.RateOps[i], s.RateOps[j]
|
||||
if opTotals[a] != opTotals[b] {
|
||||
return opTotals[a] > opTotals[b]
|
||||
}
|
||||
return a < b
|
||||
})
|
||||
// Never invent a 9th colour: past 8 operators the tail folds into "Other", which
|
||||
// is honest and still sums correctly.
|
||||
const maxOps = 8
|
||||
folded := false
|
||||
if len(s.RateOps) > maxOps {
|
||||
s.RateOps = append(s.RateOps[:maxOps:maxOps], otherOp)
|
||||
folded = true
|
||||
}
|
||||
opIdx := map[string]int{}
|
||||
for i, op := range s.RateOps {
|
||||
opIdx[op] = i
|
||||
}
|
||||
slotFor := func(op string) int {
|
||||
if i, ok := opIdx[op]; ok {
|
||||
return i
|
||||
}
|
||||
if folded {
|
||||
return len(s.RateOps) - 1 // the "Other" bucket
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
// hourOps[hourKey][slot] — built from the same `times` as `hourly`, so the
|
||||
// per-operator numbers ALWAYS sum to the hour's total. Deriving them separately
|
||||
// is how a rate sheet ends up not adding up to its own total row.
|
||||
hourOps := map[string][]int{}
|
||||
for _, e := range times {
|
||||
k := e.t.Format("2006-01-02 15")
|
||||
row, ok := hourOps[k]
|
||||
if !ok {
|
||||
row = make([]int, len(s.RateOps))
|
||||
hourOps[k] = row
|
||||
}
|
||||
if i := slotFor(e.op); i >= 0 {
|
||||
row[i]++
|
||||
}
|
||||
}
|
||||
|
||||
cur := winStart.Truncate(time.Hour)
|
||||
end := winEnd.Truncate(time.Hour)
|
||||
for !cur.After(end) {
|
||||
k := cur.Format("2006-01-02 15")
|
||||
s.Rate = append(s.Rate, Bucket{Key: cur.Format("01-02 15"), Count: hourly[k]})
|
||||
row := hourOps[k]
|
||||
if row == nil {
|
||||
row = make([]int, len(s.RateOps)) // a silent hour is zeros, not a missing row
|
||||
}
|
||||
s.RateByOp = append(s.RateByOp, row)
|
||||
cur = cur.Add(time.Hour)
|
||||
}
|
||||
}
|
||||
|
||||
// otherOp is where operators past the 8th are folded. Generating a 9th colour is
|
||||
// never the answer: under colour-blindness it is indistinguishable from one of the
|
||||
// existing eight.
|
||||
const otherOp = "Other"
|
||||
|
||||
// topBuckets sorts a count map most → least (ties alphabetical) and optionally
|
||||
// keeps only the top n.
|
||||
func topBuckets(m map[string]int, n int) []Bucket {
|
||||
|
||||
@@ -57,7 +57,7 @@ func TestStatsNoNilSlices(t *testing.T) {
|
||||
// The realistic trigger: a short, gap-free run. No silence ≥ 30 min and a
|
||||
// window that yields no hourly chart must still produce [] and not null.
|
||||
base := time.Date(2026, 5, 30, 12, 0, 0, 0, time.UTC)
|
||||
times := []time.Time{base, base.Add(2 * time.Minute), base.Add(5 * time.Minute)}
|
||||
times := []entry{{t: base, op: "A"}, {t: base.Add(2 * time.Minute), op: "A"}, {t: base.Add(5 * time.Minute), op: "B"}}
|
||||
var s2 Stats
|
||||
s2.periodMetrics(times, time.Time{}, time.Time{}, base, base.Add(5*time.Minute))
|
||||
s2.ensureNonNil()
|
||||
@@ -82,12 +82,12 @@ func TestContestPeriodMetrics(t *testing.T) {
|
||||
|
||||
// A run straddling the clock hour: 10 QSOs from 12:40 to 13:20 (within 60 min),
|
||||
// then a 2-hour silence, then 3 more.
|
||||
var times []time.Time
|
||||
var times []entry
|
||||
for i := 0; i < 10; i++ {
|
||||
times = append(times, at(40+i*4)) // 12:40 … 13:16
|
||||
times = append(times, entry{t: at(40 + i*4), op: "F4BPO"}) // 12:40 … 13:16
|
||||
}
|
||||
for i := 0; i < 3; i++ {
|
||||
times = append(times, at(240+i*5)) // 16:00 …
|
||||
times = append(times, entry{t: at(240 + i*5), op: "F5XYZ"}) // 16:00 …
|
||||
}
|
||||
|
||||
from := base // 12:00
|
||||
@@ -139,6 +139,51 @@ func TestContestPeriodMetrics(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// The contest RATE SHEET: hour by hour, who made the QSOs.
|
||||
//
|
||||
// The invariant that matters: for EVERY hour, the per-operator numbers must sum to
|
||||
// that hour's total. Derive the two separately and a rate sheet quietly stops
|
||||
// adding up to its own total row — the sort of error nobody spots until someone
|
||||
// checks the score by hand.
|
||||
func TestRateSheetSumsToHourTotal(t *testing.T) {
|
||||
base := time.Date(2026, 5, 30, 12, 0, 0, 0, time.UTC)
|
||||
at := func(min int) time.Time { return base.Add(time.Duration(min) * time.Minute) }
|
||||
|
||||
times := []entry{
|
||||
{t: at(5), op: "F4BPO"}, {t: at(10), op: "F4BPO"}, {t: at(20), op: "F5XYZ"}, // hour 12: 3
|
||||
{t: at(70), op: "F5XYZ"}, {t: at(80), op: "F5XYZ"}, // hour 13: 2
|
||||
// hour 14 silent
|
||||
{t: at(185), op: "F4BPO"}, // hour 15: 1
|
||||
}
|
||||
var s Stats
|
||||
s.periodMetrics(times, base, base.Add(4*time.Hour), time.Time{}, time.Time{})
|
||||
|
||||
if len(s.Rate) != len(s.RateByOp) {
|
||||
t.Fatalf("rate rows (%d) and rate-sheet rows (%d) must align 1:1", len(s.Rate), len(s.RateByOp))
|
||||
}
|
||||
// Both operators present, busiest first (they tie at 3 → alphabetical).
|
||||
if len(s.RateOps) != 2 || s.RateOps[0] != "F4BPO" {
|
||||
t.Fatalf("rate ops = %v, want [F4BPO F5XYZ]", s.RateOps)
|
||||
}
|
||||
for h := range s.Rate {
|
||||
sum := 0
|
||||
for _, n := range s.RateByOp[h] {
|
||||
sum += n
|
||||
}
|
||||
if sum != s.Rate[h].Count {
|
||||
t.Errorf("hour %s: operators sum to %d but the hour total is %d — the rate sheet doesn't add up",
|
||||
s.Rate[h].Key, sum, s.Rate[h].Count)
|
||||
}
|
||||
if len(s.RateByOp[h]) != len(s.RateOps) {
|
||||
t.Errorf("hour %s: row has %d columns, want %d (one per operator)", s.Rate[h].Key, len(s.RateByOp[h]), len(s.RateOps))
|
||||
}
|
||||
}
|
||||
// The silent hour is a row of zeros, not a missing row.
|
||||
if s.Rate[2].Count != 0 || s.RateByOp[2][0] != 0 || s.RateByOp[2][1] != 0 {
|
||||
t.Errorf("the silent 14:00 hour must be zeros, got total=%d row=%v", s.Rate[2].Count, s.RateByOp[2])
|
||||
}
|
||||
}
|
||||
|
||||
// A quiet decade must appear on the trend as a decade AT ZERO. Emitting only the
|
||||
// months that have QSOs would put 2012 next to 2022 as if consecutive — the chart
|
||||
// would invent activity that never happened.
|
||||
|
||||
Reference in New Issue
Block a user