155 lines
3.9 KiB
Go
155 lines
3.9 KiB
Go
package api
|
|
|
|
import (
|
|
"math"
|
|
"net/http"
|
|
"sort"
|
|
"time"
|
|
|
|
"pulsecast/api/internal/model"
|
|
)
|
|
|
|
func (s *Server) handleHealthz(w http.ResponseWriter, _ *http.Request) {
|
|
writeJSON(w, http.StatusOK, map[string]bool{"ok": true})
|
|
}
|
|
|
|
func (s *Server) handleReadyz(w http.ResponseWriter, _ *http.Request) {
|
|
ready := s.store != nil && s.store.Ready()
|
|
dataOK := s.store != nil && s.store.Len() > 0 && !s.store.Context().UpdatedAt.IsZero()
|
|
modelOK := s.store != nil && s.store.Meta().ModelVersion != ""
|
|
status := http.StatusOK
|
|
if !ready {
|
|
status = http.StatusServiceUnavailable
|
|
}
|
|
writeJSON(w, status, map[string]bool{"ok": ready, "data": dataOK, "model": modelOK})
|
|
}
|
|
|
|
func (s *Server) handleMeta(w http.ResponseWriter, _ *http.Request) {
|
|
s.setVersions(w)
|
|
writeJSON(w, http.StatusOK, s.store.Meta())
|
|
}
|
|
|
|
func (s *Server) handleSensors(w http.ResponseWriter, _ *http.Request) {
|
|
s.setVersions(w)
|
|
writeJSON(w, http.StatusOK, s.store.Sensors())
|
|
}
|
|
|
|
func (s *Server) handleSeries(w http.ResponseWriter, r *http.Request) {
|
|
query := r.URL.Query()
|
|
sensor := query.Get("sensor")
|
|
if sensor == "" {
|
|
writeError(w, http.StatusBadRequest, "bad_request", "sensor is required")
|
|
return
|
|
}
|
|
if _, ok := s.store.Sensor(sensor); !ok {
|
|
writeError(w, http.StatusNotFound, "not_found", "unknown sensor")
|
|
return
|
|
}
|
|
step := query.Get("step")
|
|
if step == "" {
|
|
step = "1h"
|
|
}
|
|
if step != "15m" && step != "1h" {
|
|
writeError(w, http.StatusBadRequest, "bad_request", "step must be 15m or 1h")
|
|
return
|
|
}
|
|
|
|
raw, _ := s.store.Series(sensor)
|
|
if len(raw) == 0 {
|
|
s.setVersions(w)
|
|
writeJSON(w, http.StatusOK, map[string]any{"sensor": sensor, "step": step, "points": []model.Point{}})
|
|
return
|
|
}
|
|
|
|
to := time.Time{}
|
|
if rawTime := query.Get("to"); rawTime != "" {
|
|
parsed, err := time.Parse(time.RFC3339, rawTime)
|
|
if err != nil {
|
|
writeError(w, http.StatusBadRequest, "bad_request", "to must be RFC 3339")
|
|
return
|
|
}
|
|
to = parsed.UTC()
|
|
} else if len(raw) > 0 {
|
|
to = raw[len(raw)-1].T.UTC()
|
|
}
|
|
|
|
from := time.Time{}
|
|
if rawTime := query.Get("from"); rawTime != "" {
|
|
parsed, err := time.Parse(time.RFC3339, rawTime)
|
|
if err != nil {
|
|
writeError(w, http.StatusBadRequest, "bad_request", "from must be RFC 3339")
|
|
return
|
|
}
|
|
from = parsed.UTC()
|
|
} else {
|
|
from = to.AddDate(0, 0, -7)
|
|
}
|
|
if to.IsZero() || !from.Before(to) {
|
|
writeError(w, http.StatusBadRequest, "bad_request", "from must be before to and the series must not be empty")
|
|
return
|
|
}
|
|
|
|
points := filterSeries(raw, from, to)
|
|
if step == "1h" {
|
|
points = hourlyMean(points)
|
|
}
|
|
|
|
s.setVersions(w)
|
|
writeJSON(w, http.StatusOK, map[string]any{
|
|
"sensor": sensor,
|
|
"step": step,
|
|
"points": points,
|
|
})
|
|
}
|
|
|
|
func filterSeries(points []model.Point, from, to time.Time) []model.Point {
|
|
out := make([]model.Point, 0, len(points))
|
|
for _, point := range points {
|
|
if point.T.Before(from) || point.T.After(to) {
|
|
continue
|
|
}
|
|
out = append(out, point)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// hourlyMean aggregates 15-minute observations into clock hours (UTC buckets)
|
|
// using the mean of the density index, not the sum.
|
|
func hourlyMean(points []model.Point) []model.Point {
|
|
type bucket struct {
|
|
sum float64
|
|
count int
|
|
}
|
|
buckets := make(map[time.Time]bucket)
|
|
for _, point := range points {
|
|
key := point.T.UTC().Truncate(time.Hour)
|
|
b := buckets[key]
|
|
b.sum += point.V
|
|
b.count++
|
|
buckets[key] = b
|
|
}
|
|
keys := make([]time.Time, 0, len(buckets))
|
|
for key := range buckets {
|
|
keys = append(keys, key)
|
|
}
|
|
sort.Slice(keys, func(i, j int) bool { return keys[i].Before(keys[j]) })
|
|
|
|
out := make([]model.Point, 0, len(keys))
|
|
for _, key := range keys {
|
|
b := buckets[key]
|
|
out = append(out, model.Point{T: key, V: math.Round(b.sum/float64(b.count)*10) / 10})
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (s *Server) handleContext(w http.ResponseWriter, _ *http.Request) {
|
|
ctx := s.store.Context()
|
|
s.setVersions(w)
|
|
writeJSON(w, http.StatusOK, model.ContextResponse{
|
|
Weather: ctx.Weather,
|
|
Holidays: ctx.Holidays,
|
|
UpdatedAt: ctx.UpdatedAt,
|
|
Cached: false,
|
|
})
|
|
}
|