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}