Files
api-go/internal/api/handlers_data.go
T

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,
})
}