1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

use chrono::{DateTime, Datelike, Local, NaiveDateTime, Utc, Date, TimeZone};
use fastly::geo::Geo;
use maplit::hashmap;

pub enum Season {
    Summer,
    Autumn,
    Winter,
    Spring,
}

// Transform the OpenWeather icons to the template ones.
pub fn get_feather_weather_icon(icon: &str) -> String {
    let map = hashmap! {
        "01d" => "sun",
        "02d" => "cloud",
        "03d" => "cloud",
        "04d" => "cloud",
        "09d" => "cloud-drizzle",
        "10d" => "cloud-rain",
        "11d" => "cloud-lightning",
        "13d" => "cloud-snow",
        "50d" => "align-center",
        "01n" => "sun",
        "02n" => "cloud",
        "03n" => "cloud",
        "04n" => "cloud",
        "09n" => "cloud-drizzle",
        "10n" => "cloud-rain",
        "11n" => "cloud-lightning",
        "13n" => "cloud-snow",
        "50n" => "align-center",
    };

    match map.get(icon.replace("\"", "").as_str()) {
        Some(i) => String::from(i.trim()),
        None => String::from("sun"),
    }
}

// Don't know why Chrono doesn't have this option.
pub fn weekday_full(weekday: String) -> String {
    match weekday.as_str() {
        "Mon" => String::from("Monday"),
        "Tue" => String::from("Tuesday"),
        "Wed" => String::from("Wednesday"),
        "Thu" => String::from("Thursday"),
        "Fri" => String::from("Friday"),
        "Sat" => String::from("Saturday"),
        "Sun" => String::from("Sunday"),
        _ => String::from("Error day"),
    }
}

pub fn datetime_to_day(datetime: String) -> String {
    let naive = NaiveDateTime::from_timestamp(datetime.parse::<i64>().unwrap(), 0);
    let datetime: DateTime<Utc> = DateTime::from_utc(naive, Utc);
    let local = datetime.with_timezone(&Local);
    local.weekday().to_string()
}

// Get your current season depending in your location.
// Season start dates are fixed despite varying in real life by 1 day depending on the year.
pub fn get_season(location: Geo, local: Date<Local>) -> Season {
    let spring_start = Local.ymd(local.year(), 3, 20);
    let summer_start = Local.ymd(local.year(), 6, 21);
    let autumn_start = Local.ymd(local.year(), 9, 22);
    let winter_start = Local.ymd(local.year(), 12, 21);

    // Let's make winter the default season, why not.
    let mut output = Season::Winter;

    if (local >= spring_start) && (local < summer_start) {
        if location.latitude().is_sign_positive() {
            output = Season::Spring
        } else {
            output = Season::Autumn
        }
    } else if (local >= summer_start) && (local < autumn_start) {
        if location.latitude().is_sign_positive() {
            output = Season::Summer
        } else {
            output = Season::Winter
        }
    } else if (local >= autumn_start) && (local < winter_start) {
        if location.latitude().is_sign_positive() {
            output = Season::Autumn
        } else {
            output = Season::Spring
        }
    } else if (local >= winter_start) && (local < spring_start) {
        if location.latitude().is_sign_positive() {
            output = Season::Winter
        } else {
            output = Season::Summer
        }
    }

    output
}