150 lines
3.6 KiB
Go
150 lines
3.6 KiB
Go
package storage
|
|
|
|
import (
|
|
"fmt"
|
|
"math/rand"
|
|
"net/url"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type SensorValueType string
|
|
|
|
const (
|
|
Temperature SensorValueType = "temperature"
|
|
Pressure SensorValueType = "pressure"
|
|
Humidity SensorValueType = "humidity"
|
|
Co2Level SensorValueType = "co2level"
|
|
)
|
|
|
|
func GetSensorValueTypes() []SensorValueType {
|
|
return []SensorValueType{Temperature, Pressure, Humidity, Co2Level}
|
|
}
|
|
|
|
//WeatherStorage interface for different storage-implementations of weather data
|
|
type WeatherStorage interface {
|
|
Save(WeatherData) error
|
|
GetData(*WeatherQuery) ([]*WeatherData, error)
|
|
Close() error
|
|
}
|
|
|
|
type SensorRegistry interface {
|
|
RegisterSensorByName(string) (*WeatherSensor, error)
|
|
ExistSensor(*WeatherSensor) (bool, error)
|
|
ResolveSensorById(uuid.UUID) (*WeatherSensor, error)
|
|
GetSensors() ([]*WeatherSensor, error)
|
|
Close() error
|
|
}
|
|
|
|
//WeatherData type
|
|
type WeatherData struct {
|
|
Values map[SensorValueType]float64
|
|
SensorId uuid.UUID `json:"sensorId"`
|
|
TimeStamp time.Time `json:"timestamp"`
|
|
}
|
|
|
|
func (data *WeatherData) OnlyQueriedValues(query *WeatherQuery) *WeatherData {
|
|
for _, sensorValueType := range GetSensorValueTypes() {
|
|
if !query.Values[sensorValueType] {
|
|
delete(data.Values, sensorValueType)
|
|
}
|
|
}
|
|
return data
|
|
}
|
|
|
|
func (data *WeatherData) ToStringMap() map[string]string {
|
|
mappedData := map[string]string{
|
|
"sensorId": data.SensorId.String(),
|
|
"timeStamp": data.TimeStamp.String(),
|
|
}
|
|
|
|
for sensorValueType, value := range data.Values {
|
|
mappedData[string(sensorValueType)] = strconv.FormatFloat(value, 'f', -1, 64)
|
|
}
|
|
|
|
return mappedData
|
|
}
|
|
|
|
func GetOnlyQueriedFields(dataPoints []*WeatherData, query *WeatherQuery) []map[string]string {
|
|
var result []map[string]string
|
|
for _, data := range dataPoints {
|
|
result = append(result, data.OnlyQueriedValues(query).ToStringMap())
|
|
}
|
|
return result
|
|
}
|
|
|
|
//WeatherSensor is the data for a new Sensorregistration
|
|
type WeatherSensor struct {
|
|
Name string
|
|
Id uuid.UUID
|
|
Location string
|
|
Longitude float64
|
|
Latitude float64
|
|
}
|
|
|
|
type WeatherQuery struct {
|
|
Start time.Time
|
|
End time.Time
|
|
SensorId uuid.UUID
|
|
Values map[SensorValueType]bool
|
|
}
|
|
|
|
func (query *WeatherQuery) Init() {
|
|
query.Start = time.Now().Add(-1 * time.Hour * 24 * 14)
|
|
query.End = time.Now()
|
|
query.SensorId = uuid.Nil
|
|
query.Values = make(map[SensorValueType]bool)
|
|
for _, sensorValueType := range GetSensorValueTypes() {
|
|
query.Values[sensorValueType] = true
|
|
}
|
|
}
|
|
|
|
func ParseFromUrlQuery(query url.Values) (*WeatherQuery, error) {
|
|
result := new(WeatherQuery)
|
|
result.Init()
|
|
|
|
start := query.Get("start")
|
|
end := query.Get("end")
|
|
|
|
if len(start) != 0 {
|
|
if tval, err := time.Parse(time.RFC3339, start); err == nil {
|
|
result.Start = tval
|
|
} else if err != nil {
|
|
fmt.Println(err)
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if len(end) != 0 {
|
|
if tval, err := time.Parse(time.RFC3339, end); err == nil {
|
|
result.End = tval
|
|
} else if err != nil {
|
|
fmt.Println(err)
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
for _, sensorValueType := range GetSensorValueTypes() {
|
|
queryParam := query.Get(string(sensorValueType))
|
|
if bval, err := strconv.ParseBool(queryParam); err == nil {
|
|
result.Values[sensorValueType] = bval
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
//NewRandomWeatherData creates random WeatherData with given Location
|
|
func NewRandomWeatherData(sensorId uuid.UUID) WeatherData {
|
|
rand.Seed(time.Now().UnixNano())
|
|
var data WeatherData
|
|
data.Values[Humidity] = rand.Float64() * 100
|
|
data.Values[Pressure] = rand.Float64()*80 + 960
|
|
data.Values[Temperature] = rand.Float64()*40 - 5
|
|
data.Values[Co2Level] = rand.Float64()*50 + 375
|
|
data.SensorId = sensorId
|
|
data.TimeStamp = time.Now()
|
|
return data
|
|
}
|