131 lines
3.6 KiB
Go
131 lines
3.6 KiB
Go
// FILE: ./internal/sources/openmeteo/observation.go
|
|
package openmeteo
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"gitea.maximumdirect.net/ejr/feedkit/config"
|
|
"gitea.maximumdirect.net/ejr/feedkit/event"
|
|
"gitea.maximumdirect.net/ejr/weatherfeeder/internal/providers/openmeteo"
|
|
"gitea.maximumdirect.net/ejr/weatherfeeder/internal/sources/common"
|
|
"gitea.maximumdirect.net/ejr/weatherfeeder/internal/standards"
|
|
)
|
|
|
|
// ObservationSource polls an Open-Meteo endpoint and emits one RAW Observation Event.
|
|
type ObservationSource struct {
|
|
name string
|
|
url string
|
|
userAgent string
|
|
client *http.Client
|
|
}
|
|
|
|
func NewObservationSource(cfg config.SourceConfig) (*ObservationSource, error) {
|
|
const driver = "openmeteo_observation"
|
|
|
|
// We require params.user_agent for uniformity across sources (even though Open-Meteo
|
|
// itself does not strictly require a special User-Agent).
|
|
c, err := common.RequireHTTPSourceConfig(driver, cfg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &ObservationSource{
|
|
name: c.Name,
|
|
url: c.URL,
|
|
userAgent: c.UserAgent,
|
|
client: common.NewHTTPClient(common.DefaultHTTPTimeout),
|
|
}, nil
|
|
}
|
|
|
|
func (s *ObservationSource) Name() string { return s.name }
|
|
|
|
func (s *ObservationSource) Kind() event.Kind { return event.Kind("observation") }
|
|
|
|
// Poll fetches Open-Meteo "current" and emits exactly one RAW Event.
|
|
func (s *ObservationSource) Poll(ctx context.Context) ([]event.Event, error) {
|
|
raw, meta, err := s.fetchRaw(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
eventID := buildEventID(s.name, meta)
|
|
if strings.TrimSpace(eventID) == "" {
|
|
// Extremely defensive fallback: keep the envelope valid no matter what.
|
|
eventID = fmt.Sprintf("openmeteo:current:%s:%s", s.name, time.Now().UTC().Format(time.RFC3339Nano))
|
|
}
|
|
|
|
var effectiveAt *time.Time
|
|
if !meta.ParsedTimestamp.IsZero() {
|
|
t := meta.ParsedTimestamp.UTC()
|
|
effectiveAt = &t
|
|
}
|
|
|
|
return common.SingleRawEvent(
|
|
s.Kind(),
|
|
s.name,
|
|
standards.SchemaRawOpenMeteoCurrentV1,
|
|
eventID,
|
|
effectiveAt,
|
|
raw,
|
|
)
|
|
}
|
|
|
|
// ---- RAW fetch + minimal metadata decode ----
|
|
|
|
type openMeteoMeta struct {
|
|
Latitude float64 `json:"latitude"`
|
|
Longitude float64 `json:"longitude"`
|
|
Timezone string `json:"timezone"`
|
|
UTCOffsetSeconds int `json:"utc_offset_seconds"`
|
|
|
|
Current struct {
|
|
Time string `json:"time"`
|
|
} `json:"current"`
|
|
|
|
ParsedTimestamp time.Time `json:"-"`
|
|
}
|
|
|
|
func (s *ObservationSource) fetchRaw(ctx context.Context) (json.RawMessage, openMeteoMeta, error) {
|
|
b, err := common.FetchBody(ctx, s.client, s.url, s.userAgent, "application/json")
|
|
if err != nil {
|
|
return nil, openMeteoMeta{}, fmt.Errorf("openmeteo_observation %q: %w", s.name, err)
|
|
}
|
|
|
|
raw := json.RawMessage(b)
|
|
|
|
var meta openMeteoMeta
|
|
if err := json.Unmarshal(b, &meta); err != nil {
|
|
// If metadata decode fails, still return raw; envelope will fall back to computed ID without EffectiveAt.
|
|
return raw, openMeteoMeta{}, nil
|
|
}
|
|
|
|
// Best effort: compute a stable EffectiveAt + event ID component.
|
|
// If parsing fails, we simply omit EffectiveAt and fall back to time.Now() in buildEventID.
|
|
if t, err := openmeteo.ParseTime(meta.Current.Time, meta.Timezone, meta.UTCOffsetSeconds); err == nil {
|
|
meta.ParsedTimestamp = t.UTC()
|
|
}
|
|
|
|
return raw, meta, nil
|
|
}
|
|
|
|
func buildEventID(sourceName string, meta openMeteoMeta) string {
|
|
locKey := ""
|
|
if meta.Latitude != 0 || meta.Longitude != 0 {
|
|
locKey = fmt.Sprintf("coord:%.5f,%.5f", meta.Latitude, meta.Longitude)
|
|
} else {
|
|
locKey = "loc:unknown"
|
|
}
|
|
|
|
ts := meta.ParsedTimestamp
|
|
if ts.IsZero() {
|
|
ts = time.Now().UTC()
|
|
}
|
|
|
|
return fmt.Sprintf("openmeteo:current:%s:%s:%s", sourceName, locKey, ts.Format(time.RFC3339Nano))
|
|
}
|