openweathermap: github.com/briandowns/openweathermap Index | Files

package openweathermap

import "github.com/briandowns/openweathermap"

Package openweathermap is a library for use to access the http://openweathermap.org API. JSON is the only return format supported at this time.

Index

Package Files

conditions.go current.go doc.go forecast.go forecast16.go forecast5.go history.go openweathermap.go pollution.go station.go uv.go

Variables

var AdditionalConditions = []*ConditionData{
    {ID: 951, Meaning: "calm", Icon1: ""},
    {ID: 952, Meaning: "light breeze", Icon1: ""},
    {ID: 953, Meaning: "gentle breeze", Icon1: ""},
    {ID: 954, Meaning: "moderate breeze", Icon1: ""},
    {ID: 955, Meaning: "fresh breeze", Icon1: ""},
    {ID: 956, Meaning: "strong breeze", Icon1: ""},
    {ID: 957, Meaning: "high wind, near gale", Icon1: ""},
    {ID: 958, Meaning: "gale", Icon1: ""},
    {ID: 959, Meaning: "severe gale", Icon1: ""},
    {ID: 960, Meaning: "storm", Icon1: ""},
    {ID: 961, Meaning: "violent storm", Icon1: ""},
    {ID: 962, Meaning: "hurricane", Icon1: ""},
}

AdditionalConditions is a slive of ConditionData pointers

var AtmosphereConditions = []*ConditionData{
    {ID: 701, Meaning: "mist", Icon1: "50d.png"},
    {ID: 711, Meaning: "smoke", Icon1: "50d.png"},
    {ID: 721, Meaning: "haze", Icon1: "50d.png"},
    {ID: 731, Meaning: "sand, dust whirls", Icon1: "50d.png"},
    {ID: 741, Meaning: "fog", Icon1: "50d.png"},
    {ID: 751, Meaning: "sand", Icon1: "50d.png"},
    {ID: 761, Meaning: "dust", Icon1: "50d.png"},
    {ID: 762, Meaning: "volcanic ash", Icon1: "50d.png"},
    {ID: 771, Meaning: "squalls", Icon1: "50d.png"},
    {ID: 781, Meaning: "tornado", Icon1: "50d.png"},
}

AtmosphereConditions is a slice of ConditionData pointers

var CloudConditions = []*ConditionData{
    {ID: 800, Meaning: "clear sky", Icon1: "01d.png", Icon2: "01n.png"},
    {ID: 801, Meaning: "few clouds", Icon1: "02d.png", Icon2: " 02n.png"},
    {ID: 802, Meaning: "scattered clouds", Icon1: "03d.png", Icon2: "03d.png"},
    {ID: 803, Meaning: "broken clouds", Icon1: "04d.png", Icon2: "03d.png"},
    {ID: 804, Meaning: "overcast clouds", Icon1: "04d.png", Icon2: "04d.png"},
}

CloudConditions is a slice of ConditionData pointers

var DataUnits = map[string]string{"C": "metric", "F": "imperial", "K": "internal"}

DataUnits represents the character chosen to represent the temperature notation

var DateTimeAliases = []string{"current"}

DateTimeAliases holds the alias the pollution API supports in lieu of an ISO 8601 timestamp

var DrizzleConditions = []*ConditionData{
    {ID: 300, Meaning: "light intensity drizzle", Icon1: "09d.png"},
    {ID: 301, Meaning: "drizzle", Icon1: "09d.png"},
    {ID: 302, Meaning: "heavy intensity drizzle", Icon1: "09d.png"},
    {ID: 310, Meaning: "light intensity drizzle rain", Icon1: "09d.png"},
    {ID: 311, Meaning: "drizzle rain", Icon1: "09d.png"},
    {ID: 312, Meaning: "heavy intensity drizzle rain", Icon1: "09d.png"},
    {ID: 313, Meaning: "shower rain and drizzle", Icon1: "09d.png"},
    {ID: 314, Meaning: "heavy shower rain and drizzle", Icon1: "09d.png"},
    {ID: 321, Meaning: "shower drizzle", Icon1: "09d.png"},
}

DrizzleConditions is a slice of ConditionData pointers

var ExtremeConditions = []*ConditionData{
    {ID: 900, Meaning: "tornado", Icon1: ""},
    {ID: 901, Meaning: "tropical storm", Icon1: ""},
    {ID: 902, Meaning: "hurricane", Icon1: ""},
    {ID: 903, Meaning: "cold", Icon1: ""},
    {ID: 904, Meaning: "hot", Icon1: ""},
    {ID: 905, Meaning: "windy", Icon1: ""},
    {ID: 906, Meaning: "hail", Icon1: ""},
}

ExtremeConditions is a slice of ConditionData pointers

var IconList = []*IconData{
    {Condition: "clear sky", Day: "01d.png", Night: "01n.png"},
    {Condition: "few clouds", Day: "02d.png", Night: "02n.png"},
    {Condition: "scattered clouds", Day: "03d.png", Night: "03n.png"},
    {Condition: "broken clouds", Day: "04d.png", Night: "04n.png"},
    {Condition: "shower rain", Day: "09d.png", Night: "09n.png"},
    {Condition: "rain", Day: "10d.png", Night: "10n.png"},
    {Condition: "thunderstorm", Day: "11d.png", Night: "11n.png"},
    {Condition: "snow", Day: "13d.png", Night: "13n.png"},
    {Condition: "mist", Day: "50d.png", Night: "50n.png"},
}

IconList is a slice of IconData pointers

var LangCodes = map[string]string{
    "EN":    "English",
    "RU":    "Russian",
    "IT":    "Italian",
    "ES":    "Spanish",
    "SP":    "Spanish",
    "UK":    "Ukrainian",
    "UA":    "Ukrainian",
    "DE":    "German",
    "PT":    "Portuguese",
    "RO":    "Romanian",
    "PL":    "Polish",
    "FI":    "Finnish",
    "NL":    "Dutch",
    "FR":    "French",
    "BG":    "Bulgarian",
    "SV":    "Swedish",
    "SE":    "Swedish",
    "TR":    "Turkish",
    "HR":    "Croatian",
    "CA":    "Catalan",
    "ZH_TW": "Chinese Traditional",
    "ZH":    "Chinese Simplified",
    "ZH_CN": "Chinese Simplified",
}

LangCodes holds all supported languages to be used inspried and sourced from @bambocher (github.com/bambocher)

var RainConditions = []*ConditionData{
    {ID: 500, Meaning: "light rain", Icon1: "09d.png"},
    {ID: 501, Meaning: "moderate rain", Icon1: "09d.png"},
    {ID: 502, Meaning: "heavy intensity rain", Icon1: "09d.png"},
    {ID: 503, Meaning: "very heavy rain", Icon1: "09d.png"},
    {ID: 504, Meaning: "extreme rain", Icon1: "09d.png"},
    {ID: 511, Meaning: "freezing rain", Icon1: "13d.png"},
    {ID: 520, Meaning: "light intensity shower rain", Icon1: "09d.png"},
    {ID: 521, Meaning: "shower rain", Icon1: "09d.png"},
    {ID: 522, Meaning: "heavy intensity shower rain", Icon1: "09d.png"},
    {ID: 531, Meaning: "ragged shower rain", Icon1: "09d.png"},
}

RainConditions is a slice of ConditionData pointers

var SnowConditions = []*ConditionData{
    {ID: 600, Meaning: "light snow", Icon1: "13d.png"},
    {ID: 601, Meaning: "snow", Icon1: "13d.png"},
    {ID: 602, Meaning: "heavy snow", Icon1: "13d.png"},
    {ID: 611, Meaning: "sleet", Icon1: "13d.png"},
    {ID: 612, Meaning: "shower sleet", Icon1: "13d.png"},
    {ID: 615, Meaning: "light rain and snow", Icon1: "13d.png"},
    {ID: 616, Meaning: "rain and snow", Icon1: "13d.png"},
    {ID: 620, Meaning: "light shower snow", Icon1: "13d.png"},
    {ID: 621, Meaning: "shower snow", Icon1: "13d.png"},
    {ID: 622, Meaning: "heavy shower snow", Icon1: "13d.png"},
}

SnowConditions is a slice of ConditionData pointers

var StationDataParameters = []string{
    "wind_dir",
    "wind_speed",
    "wind_gust",
    "temp",
    "humidity",
    "pressure",
    "rain_1h",
    "rain_24h",
    "rain_today",
    "snow",
    "lum",
    "lat",
    "long",
    "alt",
    "radiation",
    "dewpoint",
    "uv",
    "name",
}

Slice of type string of the valid parameters to be sent from a station. The API refers to this data as the "Weather station data transmission protocol"

var ThunderstormConditions = []*ConditionData{
    {ID: 200, Meaning: "thunderstorm with light rain", Icon1: "11d.png"},
    {ID: 201, Meaning: "thunderstorm with rain", Icon1: "11d.png"},
    {ID: 202, Meaning: "thunderstorm with heavy rain", Icon1: "11d.png"},
    {ID: 210, Meaning: "light thunderstorm", Icon1: "11d.png"},
    {ID: 211, Meaning: "thunderstorm", Icon1: "11d.png"},
    {ID: 212, Meaning: "heavy thunderstorm", Icon1: "11d.png"},
    {ID: 221, Meaning: "ragged thunderstorm", Icon1: "11d.png"},
    {ID: 230, Meaning: "thunderstorm with light drizzle", Icon1: "11d.png"},
    {ID: 231, Meaning: "thunderstorm with drizzle", Icon1: "11d.png"},
    {ID: 232, Meaning: "thunderstorm with heavy drizzle", Icon1: "11d.png"},
}

ThunderstormConditions is a slice of ConditionData pointers

var UVData = []UVIndexInfo{
    {
        UVIndex: []float64{0, 2.9},
        MGC:     "Green",
        Risk:    "Low",
        RecommendedProtection: "" /* 147 byte string literal not displayed */,
    },
    {
        UVIndex: []float64{3, 5.9},
        MGC:     "Yellow",
        Risk:    "Moderate",
        RecommendedProtection: "Take precautions, such as covering up, if you will be outside. Stay in shade near midday when the sun is strongest.",
    },
    {
        UVIndex: []float64{6, 7.9},
        MGC:     "Orange",
        Risk:    "High",
        RecommendedProtection: "" /* 159 byte string literal not displayed */,
    },
    {
        UVIndex: []float64{8, 10.9},
        MGC:     "Red",
        Risk:    "Very high",
        RecommendedProtection: "Wear SPF 30+ sunscreen, a shirt, sunglasses, and a wide-brimmed hat. Do not stay in the sun for too long.",
    },
    {
        UVIndex: []float64{11},
        MGC:     "Violet",
        Risk:    "Extreme",
        RecommendedProtection: "" /* 164 byte string literal not displayed */,
    },
}

UVData contains data in regards to UV index ranges, rankings, and steps for protection

func ConvertToURLValues Uses

func ConvertToURLValues(data map[string]string) string

ConvertToURLValues will convert a map to a url.Values instance. We're taking a map[string]string instead of something more type specific since the url.Values instance only takes strings to create the URL values.

func RetrieveIcon Uses

func RetrieveIcon(destination, iconFile string) (int64, error)

RetrieveIcon will get the specified icon from the API.

func SendStationData Uses

func SendStationData(data url.Values)

SendStationData will send an instance the provided url.Values to the provided URL.

func ValidAPIKey Uses

func ValidAPIKey(key string) bool

ValidAPIKey makes sure that the key given is a valid one

func ValidAlias Uses

func ValidAlias(alias string) bool

ValidAlias checks to make sure the given alias is a valid one

func ValidDataUnit Uses

func ValidDataUnit(u string) bool

ValidDataUnit makes sure the string passed in is an accepted unit of measure to be used for the return data.

func ValidDataUnitSymbol Uses

func ValidDataUnitSymbol(u string) bool

ValidDataUnitSymbol makes sure the string passed in is an acceptable data unit symbol.

func ValidLangCode Uses

func ValidLangCode(c string) bool

ValidLangCode makes sure the string passed in is an acceptable lang code.

func ValidateStationDataParameter Uses

func ValidateStationDataParameter(param string) bool

ValidateStationDataParameter will make sure that whatever parameter supplied is one that can actually be used in the POST request.

type APIError Uses

type APIError struct {
    Message string `json:"message"`
    COD     string `json:"cod"`
}

APIError returned on failed API calls.

type City Uses

type City struct {
    ID         int         `json:"id"`
    Name       string      `json:"name"`
    Coord      Coordinates `json:"coord"`
    Country    string      `json:"country"`
    Population int         `json:"population"`
    Sys        ForecastSys `json:"sys"`
}

City data for given location

type Clouds Uses

type Clouds struct {
    All int `json:"all"`
}

Clouds struct holds data regarding cloud cover.

type ConditionData Uses

type ConditionData struct {
    ID      int
    Meaning string
    Icon1   string
    Icon2   string
}

ConditionData holds data structure for weather conditions information.

type Config Uses

type Config struct {
    Mode     string // user choice of JSON or XML
    Unit     string // measurement for results to be displayed.  F, C, or K
    Lang     string // should reference a key in the LangCodes map
    APIKey   string // API Key for connecting to the OWM
    Username string // Username for posting data
    Password string // Pasword for posting data
}

Config will hold default settings to be passed into the "NewCurrent, NewForecast, etc}" functions.

func (*Config) CheckAPIKeyExists Uses

func (c *Config) CheckAPIKeyExists() bool

CheckAPIKeyExists will see if an API key has been set.

type Coordinates Uses

type Coordinates struct {
    Longitude float64 `json:"lon"`
    Latitude  float64 `json:"lat"`
}

Coordinates struct holds longitude and latitude data in returned JSON or as parameter data for requests using longitude and latitude.

type CurrentWeatherData Uses

type CurrentWeatherData struct {
    GeoPos  Coordinates `json:"coord"`
    Sys     Sys         `json:"sys"`
    Base    string      `json:"base"`
    Weather []Weather   `json:"weather"`
    Main    Main        `json:"main"`
    Wind    Wind        `json:"wind"`
    Clouds  Clouds      `json:"clouds"`
    Rain    Rain        `json:"rain"`
    Snow    Snow        `json:"snow"`
    Dt      int         `json:"dt"`
    ID      int         `json:"id"`
    Name    string      `json:"name"`
    Cod     int         `json:"cod"`
    Unit    string
    Lang    string
    Key     string
    *Settings
}

CurrentWeatherData struct contains an aggregate view of the structs defined above for JSON to be unmarshaled into.

func NewCurrent Uses

func NewCurrent(unit, lang, key string, options ...Option) (*CurrentWeatherData, error)

NewCurrent returns a new CurrentWeatherData pointer with the supplied parameters

func (*CurrentWeatherData) CurrentByArea Uses

func (w *CurrentWeatherData) CurrentByArea()

CurrentByArea will provide the current weather for the provided area.

func (*CurrentWeatherData) CurrentByCoordinates Uses

func (w *CurrentWeatherData) CurrentByCoordinates(location *Coordinates) error

CurrentByCoordinates will provide the current weather with the provided location coordinates.

func (*CurrentWeatherData) CurrentByID Uses

func (w *CurrentWeatherData) CurrentByID(id int) error

CurrentByID will provide the current weather with the provided location ID.

func (*CurrentWeatherData) CurrentByName Uses

func (w *CurrentWeatherData) CurrentByName(location string) error

CurrentByName will provide the current weather with the provided location name.

func (*CurrentWeatherData) CurrentByZip Uses

func (w *CurrentWeatherData) CurrentByZip(zip int, countryCode string) error

CurrentByZip will provide the current weather for the provided zip code.

type DtTxt Uses

type DtTxt struct {
    time.Time
}

func (*DtTxt) MarshalJSON Uses

func (t *DtTxt) MarshalJSON() ([]byte, error)

func (*DtTxt) UnmarshalJSON Uses

func (dt *DtTxt) UnmarshalJSON(b []byte) error

type Forecast16WeatherData Uses

type Forecast16WeatherData struct {
    COD     int                     `json:"cod"`
    Message string                  `json:"message"`
    City    City                    `json:"city"`
    Cnt     int                     `json:"cnt"`
    List    []Forecast16WeatherList `json:"list"`
}

Forecast16WeatherData will hold returned data from queries

func (*Forecast16WeatherData) Decode Uses

func (f *Forecast16WeatherData) Decode(r io.Reader) error

type Forecast16WeatherList Uses

type Forecast16WeatherList struct {
    Dt       int         `json:"dt"`
    Temp     Temperature `json:"temp"`
    Pressure float64     `json:"pressure"`
    Humidity int         `json:"humidity"`
    Weather  []Weather   `json:"weather"`
    Speed    float64     `json:"speed"`
    Deg      int         `json:"deg"`
    Clouds   int         `json:"clouds"`
    Snow     float64     `json:"snow"`
    Rain     float64     `json:"rain"`
}

Forecast16WeatherList holds specific query data

type Forecast5WeatherData Uses

type Forecast5WeatherData struct {
    // COD     string                `json:"cod"`
    // Message float64               `json:"message"`
    City City                   `json:"city"`
    Cnt  int                    `json:"cnt"`
    List []Forecast5WeatherList `json:"list"`
}

Forecast5WeatherData will hold returned data from queries

func (*Forecast5WeatherData) Decode Uses

func (f *Forecast5WeatherData) Decode(r io.Reader) error

type Forecast5WeatherList Uses

type Forecast5WeatherList struct {
    Dt      int       `json:"dt"`
    Main    Main      `json:"main"`
    Weather []Weather `json:"weather"`
    Clouds  Clouds    `json:"clouds"`
    Wind    Wind      `json:"wind"`
    Rain    Rain      `json:"rain"`
    Snow    Snow      `json:"snow"`
    DtTxt   DtTxt     `json:"dt_txt"`
}

Forecast5WeatherList holds specific query data

type ForecastSys Uses

type ForecastSys struct {
    Population int `json:"population"`
}

ForecastSys area population

type ForecastWeather Uses

type ForecastWeather interface {
    DailyByName(location string, days int) error
    DailyByCoordinates(location *Coordinates, days int) error
    DailyByID(id, days int) error
}

type ForecastWeatherData Uses

type ForecastWeatherData struct {
    Unit string
    Lang string
    Key  string

    *Settings
    ForecastWeatherJson
    // contains filtered or unexported fields
}

func NewForecast Uses

func NewForecast(forecastType, unit, lang, key string, options ...Option) (*ForecastWeatherData, error)

NewForecast returns a new HistoricalWeatherData pointer with the supplied arguments.

func (*ForecastWeatherData) DailyByCoordinates Uses

func (f *ForecastWeatherData) DailyByCoordinates(location *Coordinates, days int) error

DailyByCoordinates will provide a forecast for the coordinates ID give for the number of days given.

func (*ForecastWeatherData) DailyByID Uses

func (f *ForecastWeatherData) DailyByID(id, days int) error

DailyByID will provide a forecast for the location ID give for the number of days given.

func (*ForecastWeatherData) DailyByName Uses

func (f *ForecastWeatherData) DailyByName(location string, days int) error

DailyByName will provide a forecast for the location given for the number of days given.

type ForecastWeatherJson Uses

type ForecastWeatherJson interface {
    Decode(r io.Reader) error
}

json served by OWM API can take different forms, so all of them must be matched by corresponding data type and unmarshall method

type HistoricalParameters Uses

type HistoricalParameters struct {
    Start int64 // Data start (unix time, UTC time zone)
    End   int64 // Data end (unix time, UTC time zone)
    Cnt   int   // Amount of returned data (one per hour, can be used instead of Data end)
}

HistoricalParameters struct holds the (optional) fields to be supplied for historical data requests.

type HistoricalWeatherData Uses

type HistoricalWeatherData struct {
    Message  string           `json:"message"`
    Cod      int              `json:"cod"`
    CityData int              `json:"city_data"`
    CalcTime float64          `json:"calctime"`
    Cnt      int              `json:"cnt"`
    List     []WeatherHistory `json:"list"`
    Unit     string
    Key      string
    *Settings
}

HistoricalWeatherData struct is where the JSON is unmarshaled to when receiving data for a historical request.

func NewHistorical Uses

func NewHistorical(unit, key string, options ...Option) (*HistoricalWeatherData, error)

NewHistorical returns a new HistoricalWeatherData pointer with the supplied arguments.

func (*HistoricalWeatherData) HistoryByCoord Uses

func (h *HistoricalWeatherData) HistoryByCoord(location *Coordinates, hp *HistoricalParameters) error

HistoryByCoord will return the history for the provided coordinates

func (*HistoricalWeatherData) HistoryByID Uses

func (h *HistoricalWeatherData) HistoryByID(id int, hp ...*HistoricalParameters) error

HistoryByID will return the history for the provided location ID

func (*HistoricalWeatherData) HistoryByName Uses

func (h *HistoricalWeatherData) HistoryByName(location string) error

HistoryByName will return the history for the provided location

type IconData Uses

type IconData struct {
    Condition string
    Day       string
    Night     string
}

IconData holds the relevant info for linking icons to conditions.

type Main Uses

type Main struct {
    Temp      float64 `json:"temp"`
    TempMin   float64 `json:"temp_min"`
    TempMax   float64 `json:"temp_max"`
    Pressure  float64 `json:"pressure"`
    SeaLevel  float64 `json:"sea_level"`
    GrndLevel float64 `json:"grnd_level"`
    Humidity  int     `json:"humidity"`
}

Main struct contains the temperates, humidity, pressure for the request.

type Option Uses

type Option func(s *Settings) error

Optional client settings

func WithHttpClient Uses

func WithHttpClient(c *http.Client) Option

WithHttpClient sets custom http client when creating a new Client.

type Pollution Uses

type Pollution struct {
    Time     string          `json:"time"`
    Location Coordinates     `json:"location"`
    Data     []PollutionData `json:"data"`
    Key      string
    *Settings
}

Pollution holds the data returnd from the pollution API

func NewPollution Uses

func NewPollution(key string, options ...Option) (*Pollution, error)

NewPollution creates a new reference to Pollution

func (*Pollution) PollutionByParams Uses

func (p *Pollution) PollutionByParams(params *PollutionParameters) error

PollutionByParams gets the pollution data based on the given parameters

type PollutionData Uses

type PollutionData struct {
    Precision float64 `json:"precision"`
    Pressure  float64 `json:"pressure"`
    Value     float64 `json:"value"`
}

PollutionData holds the pollution specific data from the call

type PollutionParameters Uses

type PollutionParameters struct {
    Location Coordinates
    Datetime string // this should be either ISO 8601 or an alias
}

PollutionParameters holds the parameters needed to make a call to the pollution API

type Rain Uses

type Rain struct {
    ThreeH float64 `json:"3h"`
}

Rain struct contains 3 hour data

type Settings Uses

type Settings struct {
    // contains filtered or unexported fields
}

Settings holds the client settings

func NewSettings Uses

func NewSettings() *Settings

NewSettings returns a new Setting pointer with default http client.

type Snow Uses

type Snow struct {
    ThreeH float64 `json:"3h"`
}

Snow struct contains 3 hour data

type Sys Uses

type Sys struct {
    Type    int     `json:"type"`
    ID      int     `json:"id"`
    Message float64 `json:"message"`
    Country string  `json:"country"`
    Sunrise int     `json:"sunrise"`
    Sunset  int     `json:"sunset"`
}

Sys struct contains general information about the request and the surrounding area for where the request was made.

type Temperature Uses

type Temperature struct {
    Day   float64 `json:"day"`
    Min   float64 `json:"min"`
    Max   float64 `json:"max"`
    Night float64 `json:"night"`
    Eve   float64 `json:"eve"`
    Morn  float64 `json:"morn"`
}

Temperature holds returned termperate sure stats

type UV Uses

type UV struct {
    Coord []float64      `json:"coord"`
    Data  []UVDataPoints `json:"data,omitempty"`
    /*Data  []struct {
    	DT    int64   `json:"dt"`
    	Value float64 `json:"value"`
    } `json:"data,omitempty"`*/
    DT    int64   `json:"dt,omitempty"`
    Value float64 `json:"value,omitempty"`
    Key   string
    *Settings
}

UV contains the response from the OWM UV API

func NewUV Uses

func NewUV(key string, options ...Option) (*UV, error)

NewUV creates a new reference to UV

func (*UV) Current Uses

func (u *UV) Current(coord *Coordinates) error

Current gets the current UV data for the given coordinates

func (*UV) Historical Uses

func (u *UV) Historical(coord *Coordinates, start, end time.Time) error

Historical gets the historical UV data for the coordinates and times

func (*UV) UVInformation Uses

func (u *UV) UVInformation() ([]UVIndexInfo, error)

UVInformation provides information on the given UV data which includes the severity and "Recommended protection"

type UVDataPoints Uses

type UVDataPoints struct {
    DT    int64   `json:"dt"`
    Value float64 `json:"value"`
}

UVDataPoints holds the UV specific data

type UVIndexInfo Uses

type UVIndexInfo struct {
    // UVIndex holds the range of the index
    UVIndex []float64

    // MGC represents the Media graphic color
    MGC string

    // Risk of harm from unprotected sun exposure, for the average adult
    Risk string

    // RecommendedProtection contains information on what a person should
    // do when outside in the associated UVIndex
    RecommendedProtection string
}

UVIndexInfo

type Weather Uses

type Weather struct {
    ID          int    `json:"id"`
    Main        string `json:"main"`
    Description string `json:"description"`
    Icon        string `json:"icon"`
}

Weather struct holds high-level, basic info on the returned data.

type WeatherHistory Uses

type WeatherHistory struct {
    Main    Main      `json:"main"`
    Wind    Wind      `json:"wind"`
    Clouds  Clouds    `json:"clouds"`
    Weather []Weather `json:"weather"`
    Rain    Rain      `json:"rain"`
    Dt      int       `json:"dt"`
}

WeatherHistory struct contains aggregate fields from the above structs.

type Wind Uses

type Wind struct {
    Speed float64 `json:"speed"`
    Deg   float64 `json:"deg"`
}

Wind struct contains the speed and degree of the wind.

Package openweathermap imports 11 packages (graph) and is imported by 3 packages. Updated 2017-10-23. Refresh now. Tools for package owners.