f1 0.2.0

Get historical and live Formula 1 (F1) data
Documentation 
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

#![allow(dead_code, unused_imports)]
mod ergast;
mod historical;
mod livetiming;
mod season;
mod weekend;

pub use season::Season;
pub use weekend::Weekend;

use chrono::prelude::*;
use std::collections::HashMap;
use std::fmt;
use std::sync::MutexGuard;
use std::sync::PoisonError;
use thiserror::Error;

const EARLIEST_SEASON: i32 = 1950;

#[derive(Error, Debug)]
pub enum F1Error {
    #[error("API JSON deserialization problem")]
    JsonDeserialization,
    #[error("API not reachable")]
    ApiNotReachable,
    #[error("Cache Error")]
    Cache,
}

#[derive(PartialEq, Debug, Clone)]
pub enum SessionType {
    Practice1,
    Practice2,
    Practice3,
    Qualifying,
    Sprint,
    Race,
}

impl Default for SessionType {
    fn default() -> Self {
        Self::Race
    }
}

impl fmt::Display for SessionType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

#[derive(Debug, Default, Clone)]
pub struct Constructor {
    id: String,
    name: String,
}

#[derive(Clone, Debug, Default)]
pub struct Driver {
    id: String,
    first_name: String,
    last_name: String,
    pub screen_name: String,
}

#[derive(Clone, Debug)]
pub struct Standing {
    pub driver: Driver,
    constructor: Constructor,
    pub position: i32,
    pub lap_time: chrono::NaiveTime,
}

impl Default for Standing {
    fn default() -> Self {
        Self {
            driver: Default::default(),
            constructor: Default::default(),
            position: Default::default(),
            lap_time: NaiveTime::from_hms(0, 0, 0),
        }
    }
}

#[derive(Clone, Debug, Default)]
pub struct Session {
    pub r#type: SessionType,
    finished: bool,
    pub standings: Vec<Standing>,
}

#[derive(Clone, Debug, Default)]
pub struct Circuit {
    id: String,
    pub name: String,
    pub latitude: f32,
    pub longitude: f32,
    pub locality: String,
    pub country: String,
}

pub fn get_available_seasons() -> Vec<i32> {
    (EARLIEST_SEASON..Utc::now().year() + 1).rev().collect()
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::*;

    #[test]
    fn test_type_to_string() {
        let quali = SessionType::Qualifying;
        assert_eq!(quali.to_string(), "Qualifying".to_string());

        let race = SessionType::Race;
        assert_eq!(race.to_string(), "Race".to_string());
    }
}