weatherapi/internal/core/payload.go

package core

import (
	"time"

	"gitea.maximumdirect.net/ejr/weatherfeeder/model"
)

// WeatherObservationUS is the US-customary response shape for observations.
type WeatherObservationUS struct {
	StationID               string                 `json:"stationId,omitempty" xml:"stationId,omitempty"`
	StationName             string                 `json:"stationName,omitempty" xml:"stationName,omitempty"`
	Timestamp               time.Time              `json:"timestamp" xml:"timestamp"`
	ConditionCode           model.WMOCode          `json:"conditionCode" xml:"conditionCode"`
	IsDay                   *bool                  `json:"isDay,omitempty" xml:"isDay,omitempty"`
	TextDescription         string                 `json:"textDescription,omitempty" xml:"textDescription,omitempty"`
	TemperatureF            *float64               `json:"temperatureF,omitempty" xml:"temperatureF,omitempty"`
	DewpointF               *float64               `json:"dewpointF,omitempty" xml:"dewpointF,omitempty"`
	WindDirectionDegrees    *float64               `json:"windDirectionDegrees,omitempty" xml:"windDirectionDegrees,omitempty"`
	WindSpeedMph            *float64               `json:"windSpeedMph,omitempty" xml:"windSpeedMph,omitempty"`
	WindGustMph             *float64               `json:"windGustMph,omitempty" xml:"windGustMph,omitempty"`
	BarometricPressureInHg  *float64               `json:"barometricPressureInHg,omitempty" xml:"barometricPressureInHg,omitempty"`
	VisibilityMiles         *float64               `json:"visibilityMiles,omitempty" xml:"visibilityMiles,omitempty"`
	RelativeHumidityPercent *float64               `json:"relativeHumidityPercent,omitempty" xml:"relativeHumidityPercent,omitempty"`
	ApparentTemperatureF    *float64               `json:"apparentTemperatureF,omitempty" xml:"apparentTemperatureF,omitempty"`
	PresentWeather          []model.PresentWeather `json:"presentWeather,omitempty" xml:"presentWeather,omitempty"`
}

// WeatherForecastRunUS is the US-customary response shape for hourly forecasts.
type WeatherForecastRunUS struct {
	LocationID    string                    `json:"locationId,omitempty" xml:"locationId,omitempty"`
	LocationName  string                    `json:"locationName,omitempty" xml:"locationName,omitempty"`
	IssuedAt      time.Time                 `json:"issuedAt" xml:"issuedAt"`
	UpdatedAt     *time.Time                `json:"updatedAt,omitempty" xml:"updatedAt,omitempty"`
	Product       model.ForecastProduct     `json:"product" xml:"product"`
	Latitude      *float64                  `json:"latitude,omitempty" xml:"latitude,omitempty"`
	Longitude     *float64                  `json:"longitude,omitempty" xml:"longitude,omitempty"`
	ElevationFeet *float64                  `json:"elevationFeet,omitempty" xml:"elevationFeet,omitempty"`
	Periods       []WeatherForecastPeriodUS `json:"periods" xml:"periods"`
}

// WeatherForecastPeriodUS is the US-customary response shape for forecast periods.
type WeatherForecastPeriodUS struct {
	StartTime                         time.Time     `json:"startTime" xml:"startTime"`
	EndTime                           time.Time     `json:"endTime" xml:"endTime"`
	Name                              string        `json:"name,omitempty" xml:"name,omitempty"`
	IsDay                             *bool         `json:"isDay,omitempty" xml:"isDay,omitempty"`
	ConditionCode                     model.WMOCode `json:"conditionCode" xml:"conditionCode"`
	ConditionText                     string        `json:"conditionText,omitempty" xml:"conditionText,omitempty"`
	ProviderRawDescription            string        `json:"providerRawDescription,omitempty" xml:"providerRawDescription,omitempty"`
	TextDescription                   string        `json:"textDescription,omitempty" xml:"textDescription,omitempty"`
	DetailedText                      string        `json:"detailedText,omitempty" xml:"detailedText,omitempty"`
	IconURL                           string        `json:"iconUrl,omitempty" xml:"iconUrl,omitempty"`
	TemperatureF                      *float64      `json:"temperatureF,omitempty" xml:"temperatureF,omitempty"`
	TemperatureFMin                   *float64      `json:"temperatureFMin,omitempty" xml:"temperatureFMin,omitempty"`
	TemperatureFMax                   *float64      `json:"temperatureFMax,omitempty" xml:"temperatureFMax,omitempty"`
	DewpointF                         *float64      `json:"dewpointF,omitempty" xml:"dewpointF,omitempty"`
	RelativeHumidityPercent           *float64      `json:"relativeHumidityPercent,omitempty" xml:"relativeHumidityPercent,omitempty"`
	WindDirectionDegrees              *float64      `json:"windDirectionDegrees,omitempty" xml:"windDirectionDegrees,omitempty"`
	WindSpeedMph                      *float64      `json:"windSpeedMph,omitempty" xml:"windSpeedMph,omitempty"`
	WindGustMph                       *float64      `json:"windGustMph,omitempty" xml:"windGustMph,omitempty"`
	BarometricPressureInHg            *float64      `json:"barometricPressureInHg,omitempty" xml:"barometricPressureInHg,omitempty"`
	VisibilityMiles                   *float64      `json:"visibilityMiles,omitempty" xml:"visibilityMiles,omitempty"`
	ApparentTemperatureF              *float64      `json:"apparentTemperatureF,omitempty" xml:"apparentTemperatureF,omitempty"`
	CloudCoverPercent                 *float64      `json:"cloudCoverPercent,omitempty" xml:"cloudCoverPercent,omitempty"`
	ProbabilityOfPrecipitationPercent *float64      `json:"probabilityOfPrecipitationPercent,omitempty" xml:"probabilityOfPrecipitationPercent,omitempty"`
	PrecipitationAmountIn             *float64      `json:"precipitationAmountIn,omitempty" xml:"precipitationAmountIn,omitempty"`
	SnowfallDepthIn                   *float64      `json:"snowfallDepthIn,omitempty" xml:"snowfallDepthIn,omitempty"`
	UVIndex                           *float64      `json:"uvIndex,omitempty" xml:"uvIndex,omitempty"`
}

func ObservationPayload(obs *model.WeatherObservation, units Units) any {
	if obs == nil {
		return nil
	}
	if units == UnitsUS {
		converted := WeatherObservationUS{
			StationID:               obs.StationID,
			StationName:             obs.StationName,
			Timestamp:               obs.Timestamp,
			ConditionCode:           obs.ConditionCode,
			IsDay:                   copyBoolPtr(obs.IsDay),
			TextDescription:         obs.TextDescription,
			TemperatureF:            celsiusToFahrenheitPtr(obs.TemperatureC),
			DewpointF:               celsiusToFahrenheitPtr(obs.DewpointC),
			WindDirectionDegrees:    copyFloat64Ptr(obs.WindDirectionDegrees),
			WindSpeedMph:            scalePtr(obs.WindSpeedKmh, kmhToMphFactor),
			WindGustMph:             scalePtr(obs.WindGustKmh, kmhToMphFactor),
			BarometricPressureInHg:  scalePtr(obs.BarometricPressurePa, paToInHgFactor),
			VisibilityMiles:         scalePtr(obs.VisibilityMeters, metersToMilesFactor),
			RelativeHumidityPercent: copyFloat64Ptr(obs.RelativeHumidityPercent),
			ApparentTemperatureF:    celsiusToFahrenheitPtr(obs.ApparentTemperatureC),
			PresentWeather:          append([]model.PresentWeather(nil), obs.PresentWeather...),
		}
		return converted
	}
	return obs
}

func ForecastPayload(run *model.WeatherForecastRun, units Units) any {
	if run == nil {
		return nil
	}
	if units == UnitsUS {
		out := WeatherForecastRunUS{
			LocationID:    run.LocationID,
			LocationName:  run.LocationName,
			IssuedAt:      run.IssuedAt,
			UpdatedAt:     copyTimePtr(run.UpdatedAt),
			Product:       run.Product,
			Latitude:      copyFloat64Ptr(run.Latitude),
			Longitude:     copyFloat64Ptr(run.Longitude),
			ElevationFeet: scalePtr(run.ElevationMeters, metersToFeetFactor),
			Periods:       make([]WeatherForecastPeriodUS, 0, len(run.Periods)),
		}
		for _, p := range run.Periods {
			out.Periods = append(out.Periods, WeatherForecastPeriodUS{
				StartTime:                         p.StartTime,
				EndTime:                           p.EndTime,
				Name:                              p.Name,
				IsDay:                             copyBoolPtr(p.IsDay),
				ConditionCode:                     p.ConditionCode,
				ConditionText:                     p.ConditionText,
				ProviderRawDescription:            p.ProviderRawDescription,
				TextDescription:                   p.TextDescription,
				DetailedText:                      p.DetailedText,
				IconURL:                           p.IconURL,
				TemperatureF:                      celsiusToFahrenheitPtr(p.TemperatureC),
				TemperatureFMin:                   celsiusToFahrenheitPtr(p.TemperatureCMin),
				TemperatureFMax:                   celsiusToFahrenheitPtr(p.TemperatureCMax),
				DewpointF:                         celsiusToFahrenheitPtr(p.DewpointC),
				RelativeHumidityPercent:           copyFloat64Ptr(p.RelativeHumidityPercent),
				WindDirectionDegrees:              copyFloat64Ptr(p.WindDirectionDegrees),
				WindSpeedMph:                      scalePtr(p.WindSpeedKmh, kmhToMphFactor),
				WindGustMph:                       scalePtr(p.WindGustKmh, kmhToMphFactor),
				BarometricPressureInHg:            scalePtr(p.BarometricPressurePa, paToInHgFactor),
				VisibilityMiles:                   scalePtr(p.VisibilityMeters, metersToMilesFactor),
				ApparentTemperatureF:              celsiusToFahrenheitPtr(p.ApparentTemperatureC),
				CloudCoverPercent:                 copyFloat64Ptr(p.CloudCoverPercent),
				ProbabilityOfPrecipitationPercent: copyFloat64Ptr(p.ProbabilityOfPrecipitationPercent),
				PrecipitationAmountIn:             scalePtr(p.PrecipitationAmountMm, mmToInchesFactor),
				SnowfallDepthIn:                   scalePtr(p.SnowfallDepthMM, mmToInchesFactor),
				UVIndex:                           copyFloat64Ptr(p.UVIndex),
			})
		}
		return out
	}
	return run
}

func AlertsPayload(run *model.WeatherAlertRun, _ Units) any {
	if run == nil {
		return nil
	}
	return run
}

func celsiusToFahrenheitPtr(v *float64) *float64 {
	if v == nil {
		return nil
	}
	out := (*v * celsiusToFahrenheitScale) + celsiusToFahrenheitOffset
	return &out
}

func scalePtr(v *float64, factor float64) *float64 {
	if v == nil {
		return nil
	}
	out := *v * factor
	return &out
}

func copyFloat64Ptr(v *float64) *float64 {
	if v == nil {
		return nil
	}
	out := *v
	return &out
}

func copyBoolPtr(v *bool) *bool {
	if v == nil {
		return nil
	}
	out := *v
	return &out
}

func copyTimePtr(v *time.Time) *time.Time {
	if v == nil {
		return nil
	}
	out := *v
	return &out
}