JHHM

lol-cal

terminal lolesports schedule viewer
git clone https://jhhm.no/repos/lol-cal.git

lol-cal/src/resources.rs

get raw file: resources.rs

1use std::path::PathBuf;
2
3use chrono::{DateTime, Duration, Local, Utc};
4use reqwest::Client;
5use serde::Serialize;
6use serde::de::DeserializeOwned;
7use tokio::fs;
8use tokio::io::{AsyncReadExt, AsyncWriteExt};
9use tracing::{error, info};
10
11use crate::net;
12use crate::widgets::events::{Event, MatchResult, Strategy, Team};
13use crate::widgets::leagues::League;
14
15#[derive(Debug, Clone)]
16pub struct ResourceManager {
17    cache_dir: PathBuf,
18}
19
20impl ResourceManager {
21    pub fn new(data_dir: PathBuf) -> Self {
22        Self {
23            cache_dir: data_dir.join("cache"),
24        }
25    }
26
27    async fn cache_data<T: Serialize>(&self, name: &str, data: &T) -> std::io::Result<()> {
28        let cache_path = self.cache_dir.join(name);
29
30        if let Some(parent) = cache_path.parent() {
31            fs::create_dir_all(parent).await?;
32        }
33
34        let serialized = serde_json::to_vec(data)
35            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
36
37        let mut file = fs::File::create(&cache_path).await?;
38        file.write_all(&serialized).await?;
39
40        Ok(())
41    }
42
43    async fn load_from_cache<T: DeserializeOwned>(
44        &self,
45        name: &str,
46    ) -> std::io::Result<(T, DateTime<Local>)> {
47        let cache_path = self.cache_dir.join(name);
48
49        let mut file = fs::File::open(&cache_path).await?;
50        let mut contents = Vec::new();
51        file.read_to_end(&mut contents).await?;
52
53        let metadata = fs::metadata(&cache_path).await?;
54        let modified_time = metadata.modified()?;
55        let modified_datetime: DateTime<Local> = modified_time.into();
56
57        let data = serde_json::from_slice(&contents)
58            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
59
60        Ok((data, modified_datetime))
61    }
62
63    pub async fn get_leagues(&self) -> Option<Vec<League>> {
64        match self.load_from_cache("leagues.json").await {
65            Ok((leagues, cached_time)) => 'fetch: {
66                info!("Successfully loaded cached leagues");
67                let now = Local::now();
68
69                if cached_time < now - Duration::days(7) {
70                    info!("Cached leagues is older then 7 days, fetching new list");
71                    break 'fetch;
72                }
73                return Some(leagues);
74            }
75            Err(e) => info!("Failed to load cached leagues: {:?}", e),
76        }
77
78        let client = Client::new();
79
80        match net::leagues::fetch_leagues(&client).await {
81            Ok(leagues) => {
82                info!(
83                    "Successfully fetched leagues from API, total leagues: {}",
84                    leagues.len()
85                );
86                let leagues = leagues.into_iter().map(League::from).collect();
87                match self.cache_data("leagues.json", &leagues).await {
88                    Ok(_) => info!("Successfully cached leagues"),
89                    Err(e) => error!("Failed to cache leagues: {:?}", e),
90                }
91                return Some(leagues);
92            }
93            Err(e) => error!("Failed to fetch leagues: {:?}", e),
94        }
95        return None;
96    }
97
98    pub async fn get_schedule(&self, slug: &str) -> Option<Vec<Event>> {
99        // TODO: Currently paging is ignored, would probably make sense to handle
100        // this outside of get_schedule, so that we don't have to wait for all
101        // pages to be gotten.
102
103        let cache_path = format!("{}.json", slug);
104
105        match self.load_from_cache(&cache_path).await {
106            Ok((events, cached_time)) => 'fetch: {
107                info!("Successfully loaded cached schedule '{}'", slug);
108                let now = Local::now();
109
110                if cached_time < now - Duration::days(3) {
111                    info!("Cached schedule is older then 3 days, need to fetch newer");
112                    break 'fetch;
113                }
114
115                if cached_time > now - Duration::minutes(5) {
116                    info!("Cached schedule is younger then 5 minutes, accepting cached data");
117                    return Some(events);
118                }
119
120                let events: Vec<Event> = events;
121                let has_invalid_event = events
122                    .iter()
123                    .any(|e| e.state.get_string() == "Unstarted" && e.start_time < now);
124
125                if has_invalid_event {
126                    info!("Cached schedule is outdated due to unstarted past events");
127                    break 'fetch;
128                }
129                return Some(events);
130            }
131            Err(e) => info!("Failed to load cached schedule '{}': {:?}", slug, e),
132        }
133
134        let client = Client::new();
135
136        match net::schedule::fetch_schedule(&client, slug, None).await {
137            Ok(schedule) => {
138                info!(
139                    "Successfully fetched schedule from API, slug: {}, pages: (before: {:?} after: {:?}) total events: {}",
140                    slug,
141                    schedule.pages.older,
142                    schedule.pages.newer,
143                    schedule.events.len()
144                );
145                let events = schedule.events.into_iter().map(Event::from).collect();
146                match self.cache_data(&cache_path, &events).await {
147                    Ok(_) => info!("Successfully cached schedule '{}'", slug),
148                    Err(e) => error!("Failed to cache schedule '{}': {:?}", slug, e),
149                }
150                return Some(events);
151            }
152            Err(e) => error!("Failed to fetch schedule: {:?}", e),
153        }
154        return None;
155    }
156}
157
158impl From<net::leagues::League> for League {
159    fn from(net_league: net::leagues::League) -> Self {
160        Self {
161            id: net_league.id,
162            name: net_league.name,
163            region: net_league.region,
164            selected: false,
165        }
166    }
167}
168
169impl From<net::schedule::Event> for Event {
170    fn from(net_event: net::schedule::Event) -> Self {
171        Self {
172            start_time: net_event
173                .start_time
174                .parse::<DateTime<Utc>>()
175                .unwrap()
176                .with_timezone(&Local),
177            league_name: net_event.league.name,
178            block_name: net_event.block_name,
179            strategy: Strategy {
180                strat_type: net_event.match_field.strategy.type_field.clone().into(),
181                count: net_event.match_field.strategy.count as u16,
182            },
183            state: net_event.state.into(),
184            result: (&net_event.match_field).into(),
185            teams: net_event
186                .match_field
187                .teams
188                .into_iter()
189                .map(|team| Team {
190                    name: team.name,
191                    short: team.code,
192                })
193                .collect(),
194        }
195    }
196}
197
198impl From<&net::schedule::Match> for Option<MatchResult> {
199    fn from(net_match: &net::schedule::Match) -> Option<MatchResult> {
200        if let (Some(rec0), Some(rec1)) = (&net_match.teams[0].result, &net_match.teams[1].result) {
201            Some(MatchResult {
202                game_wins: (rec0.game_wins as u16, rec1.game_wins as u16),
203            })
204        } else {
205            None
206        }
207    }
208}