171 lines
5.5 KiB
Rust
171 lines
5.5 KiB
Rust
|
use std::ops::Deref;
|
||
|
use std::path::PathBuf;
|
||
|
use std::rc::Rc;
|
||
|
use std::{fs, process};
|
||
|
|
||
|
use directories::ProjectDirs;
|
||
|
|
||
|
use crate::m3u8::M3u8;
|
||
|
|
||
|
const MAX_TRIES: usize = 4;
|
||
|
|
||
|
pub struct Parser {
|
||
|
watched_name: Rc<PathBuf>,
|
||
|
m3u8_items: Vec<M3u8>,
|
||
|
}
|
||
|
|
||
|
impl Parser {
|
||
|
fn should_update(file_name: &PathBuf) -> bool {
|
||
|
fs::metadata(&file_name)
|
||
|
.and_then(|metadata| {
|
||
|
Ok({
|
||
|
let seconds = metadata.modified()?;
|
||
|
seconds
|
||
|
.elapsed()
|
||
|
.expect("Failed to get systemtime")
|
||
|
.as_secs()
|
||
|
> 60 * 60 * 24 * 3
|
||
|
})
|
||
|
})
|
||
|
.map_or_else(
|
||
|
|_| {
|
||
|
println!("Could not find playlist-file, Downloading a new one");
|
||
|
false
|
||
|
},
|
||
|
|x| x,
|
||
|
)
|
||
|
}
|
||
|
|
||
|
pub fn new(file_name: String, iptv_url: String, watched_name: String) -> Self {
|
||
|
let project_dirs = ProjectDirs::from("com", "billenius", "iptvnator_rs").unwrap();
|
||
|
let cache = project_dirs.cache_dir();
|
||
|
let _ = fs::create_dir_all(&cache);
|
||
|
|
||
|
let file_name = Rc::new(cache.join(file_name));
|
||
|
let iptv_url = Rc::new(iptv_url);
|
||
|
let watched_name = Rc::new(cache.join(watched_name));
|
||
|
|
||
|
Self {
|
||
|
watched_name: watched_name.clone(),
|
||
|
m3u8_items: Self::get_parsed_content(&iptv_url, &file_name, &watched_name),
|
||
|
}
|
||
|
}
|
||
|
|
||
|
pub fn find(&self, name: &str) -> Vec<&M3u8> {
|
||
|
let name = name.to_uppercase();
|
||
|
self.m3u8_items
|
||
|
.iter()
|
||
|
.filter(|item| item.name.to_uppercase().contains(&name) || item.tvg_id.contains(&name))
|
||
|
.collect()
|
||
|
}
|
||
|
|
||
|
pub fn save_watched(&self) {
|
||
|
let project_dirs = ProjectDirs::from("com", "billenius", "iptvnator_rs").unwrap();
|
||
|
let cache_dir = project_dirs.cache_dir();
|
||
|
let watched_cache_file = cache_dir.join(&*self.watched_name);
|
||
|
|
||
|
let watched_items = self
|
||
|
.m3u8_items
|
||
|
.iter()
|
||
|
.filter(|item| item.watched)
|
||
|
.map(|item| item.link.clone())
|
||
|
.collect::<Vec<String>>();
|
||
|
|
||
|
let _ = fs::create_dir_all(cache_dir);
|
||
|
|
||
|
match fs::write(watched_cache_file, watched_items.join("\n")) {
|
||
|
Ok(_) => {
|
||
|
println!("Saved watched")
|
||
|
}
|
||
|
Err(e) => {
|
||
|
eprintln!("Failed to write downloaded m3u8file {:?}", e);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fn get_parsed_content(link: &String, file_name: &PathBuf, watched_name: &PathBuf) -> Vec<M3u8> {
|
||
|
let saved_watches = fs::read_to_string(&watched_name);
|
||
|
let saved_watches = if saved_watches.is_ok() {
|
||
|
saved_watches.unwrap()
|
||
|
} else {
|
||
|
String::from("")
|
||
|
};
|
||
|
|
||
|
let watched: Vec<String> = saved_watches.lines().map(String::from).collect();
|
||
|
|
||
|
let mut m3u8_items: Vec<M3u8> = Vec::new();
|
||
|
let interesting_lines: Vec<String> = Self::get_stringcontent(link, file_name, 0)
|
||
|
.replacen("#EXTM3U\n", "", 1)
|
||
|
.lines()
|
||
|
.map(str::trim)
|
||
|
.map(String::from)
|
||
|
.collect();
|
||
|
|
||
|
for i in (0..interesting_lines.len()).step_by(2) {
|
||
|
let mut items = Vec::new();
|
||
|
for to_find in ["tvg-id", "tvg-name", "tvg-logo", "group-title"] {
|
||
|
let offset: usize = format!("{}=", to_find).bytes().len();
|
||
|
let start: usize =
|
||
|
interesting_lines[i].find(&format!("{}=", to_find)).unwrap() as usize + offset;
|
||
|
|
||
|
let end: usize = interesting_lines[i].rfind("=").unwrap();
|
||
|
items.push(&interesting_lines[i][start..=end])
|
||
|
}
|
||
|
let name_start = interesting_lines[i].rfind(",").unwrap() + 1;
|
||
|
let name = &interesting_lines[i][name_start..];
|
||
|
let link = &interesting_lines[i + 1];
|
||
|
let is_watched = watched.contains(link);
|
||
|
let m3u8_item = M3u8 {
|
||
|
tvg_id: items[0].to_owned(),
|
||
|
tvg_name: items[1].to_owned(),
|
||
|
tvg_logo: items[2].to_owned(),
|
||
|
group_title: items[3].to_owned(),
|
||
|
name: name.to_owned(),
|
||
|
link: link.to_string(),
|
||
|
watched: is_watched,
|
||
|
};
|
||
|
m3u8_items.push(m3u8_item);
|
||
|
}
|
||
|
m3u8_items
|
||
|
}
|
||
|
|
||
|
fn get_stringcontent(link: &String, file_name: &PathBuf, tried: usize) -> String {
|
||
|
if !Self::should_update(file_name) {
|
||
|
let content = fs::read_to_string(&file_name);
|
||
|
if content.is_ok() {
|
||
|
return content.unwrap();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
let content = Self::download(link);
|
||
|
if content.is_err() && tried < 4 {
|
||
|
println!("Retrying {}/{}", tried + 1, MAX_TRIES);
|
||
|
Self::get_stringcontent(link, file_name, tried + 1);
|
||
|
}
|
||
|
|
||
|
match content {
|
||
|
Ok(s) => {
|
||
|
let _ = fs::write(&file_name, s.as_bytes());
|
||
|
s
|
||
|
}
|
||
|
Err(_) => {
|
||
|
println!("Couldn't get m3u8 file!");
|
||
|
process::exit(-1);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fn download(link: &String) -> Result<String, reqwest::Error> {
|
||
|
reqwest::blocking::get(link.clone())
|
||
|
.and_then(|resp| Ok(resp.text().expect("Could not get m3u8 from server")))
|
||
|
}
|
||
|
}
|
||
|
|
||
|
impl Deref for Parser {
|
||
|
type Target = Vec<M3u8>;
|
||
|
|
||
|
fn deref(&self) -> &Self::Target {
|
||
|
&self.m3u8_items
|
||
|
}
|
||
|
}
|