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
|
use std::{fs::{File, read_dir, remove_file, rename}, io::Write, collections::HashMap};
use futures_util::StreamExt;
use reqwest::Client;
use crate::{List, modrinth::Version, db::{userlist_add_disabled_versions, mods_get_name}, config::Cfg, error::{MLE, MLError, ErrorType}};
pub async fn download_versions(list: List, config: Cfg, versions: Vec<Version>) -> MLE<String> {
let dl_path = String::from(&list.download_folder);
println!("Download to directory from: {} ({})", list.id, dl_path);
for ver in versions {
let project_name = mods_get_name(config.clone(), &ver.project_id)?;
print!("\t({})Download version {}", project_name, ver.id);
std::io::stdout().flush().unwrap();
let primary_file = ver.files.into_iter().find(|file| file.primary).unwrap();
let mut splitname: Vec<&str> = primary_file.filename.split('.').collect();
let extension = match splitname.pop().ok_or("") {
Ok(e) => e,
Err(..) => return Err(MLError::new(ErrorType::Other, "NO_FILE_EXTENSION")),
};
let filename = format!("{}.mr.{}.{}.{}", splitname.join("."), ver.project_id, ver.id, extension);
download_file(primary_file.url, list.clone().download_folder, filename).await?;
tokio::time::sleep(std::time::Duration::new(3, 0)).await;
println!(" ✓");
}
Ok(dl_path)
}
async fn download_file(url: String, path: String, name: String) -> MLE<()> {
let dl_path_file = format!("{}/{}", path, name);
let res = Client::new()
.get(String::from(&url))
.send()
.await?;
// download chunks
let mut file = File::create(&dl_path_file)?;
let mut stream = res.bytes_stream();
while let Some(item) = stream.next().await {
let chunk = item?;
file.write_all(&chunk)?;
}
Ok(())
}
pub fn disable_version(config: Cfg, current_list: List, versionid: String, mod_id: String) -> MLE<()> {
//println!("Disabling version {} for mod {}", versionid, mod_id);
let file = get_file_path(current_list.clone(), String::from(&versionid))?;
let disabled = format!("{}.disabled", file);
rename(file, disabled)?;
userlist_add_disabled_versions(config, current_list.id, versionid, mod_id)?;
Ok(())
}
pub fn delete_version(list: List, version: String) -> MLE<()> {
let file = get_file_path(list, version)?;
remove_file(file)?;
Ok(())
}
pub fn get_file_path(list: List, versionid: String) -> MLE<String> {
let mut names: HashMap<String, String> = HashMap::new();
for file in read_dir(list.download_folder)? {
let path = file?.path();
if path.is_file() {
let pathstr = match path.to_str().ok_or("") {
Ok(s) => s,
Err(..) => return Err(MLError::new(ErrorType::Other, "INVALID_PATH"))
};
let namesplit: Vec<&str> = pathstr.split('.').collect();
let ver_id = namesplit[namesplit.len() - 2];
names.insert(String::from(ver_id), String::from(pathstr));
}
};
let filename = match names.get(&versionid).ok_or("") {
Ok(n) => n,
Err(..) => return Err(MLError::new(ErrorType::ArgumentError, "VERSION_NOT_FOUND_IN_FILES"))
};
Ok(filename.to_owned())
}
pub fn get_downloaded_versions(list: List) -> MLE<HashMap<String, String>> {
let mut versions: HashMap<String, String> = HashMap::new();
for file in read_dir(&list.download_folder)? {
let path = file?.path();
if path.is_file() && path.extension().ok_or("BAH").unwrap() == "jar" {
let pathstr = path.to_str().ok_or("BAH").unwrap();
let namesplit: Vec<&str> = pathstr.split('.').collect();
versions.insert(String::from(namesplit[namesplit.len() - 3]), String::from(namesplit[namesplit.len() - 2]));
}
}
Ok(versions)
}
pub fn clean_list_dir(list: &List) -> MLE<()> {
let dl_path = &list.download_folder;
println!("Clean directory for: {}", list.id);
for entry in std::fs::read_dir(dl_path)? {
let entry = entry?;
std::fs::remove_file(entry.path())?;
};
Ok(())
}
|
