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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
use std::{
fs::{create_dir_all, File},
io::Write,
path::Path,
};
use serde::{Deserialize, Serialize};
use crate::{
data::{
gameversion::{check_game_versions, VersionLevel},
modloader::Modloader,
},
db::setup,
errors::{Error, MLE},
};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Cfg {
pub data: String,
pub cache: String,
pub versions: String,
pub defaults: Defaults,
pub apis: Apis,
}
impl Default for Cfg {
fn default() -> Self {
let cache_dir = dirs::cache_dir()
.unwrap()
.join("modlist")
.to_string_lossy()
.to_string();
Self {
data: cache_dir.clone(),
cache: format!("{cache_dir}/cache"),
versions: cache_dir,
defaults: Defaults {
modloader: Modloader::Fabric,
version: VersionLevel::Release,
},
apis: Apis {
modrinth: String::from("https://api.modrinth.com/v2/"),
},
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Apis {
pub modrinth: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Defaults {
pub modloader: Modloader,
pub version: VersionLevel,
}
impl Cfg {
/// # Errors
pub async fn init(path: Option<String>) -> MLE<Self> {
let configfile = if let Some(cf) = path.clone() {
cf
} else {
let Some(config_dir) = dirs::config_dir() else {
return Err(Error::SysDirNotFound("config".to_string()));
};
config_dir
.join("modlist")
.join("config.toml")
.to_string_lossy()
.to_string()
};
if let Some(err) = File::open(&configfile).err() {
if err.kind() == std::io::ErrorKind::NotFound && path.is_none() {
create_config(&configfile)?;
} else {
return Err(err.into());
};
};
let config: Cfg = config::Config::builder()
.add_source(config::File::with_name(&configfile).required(false))
.add_source(
config::Environment::with_prefix("MODLIST").separator("_"),
)
.build()?
.try_deserialize()?;
//Check cache
if !Path::new(&config.cache).exists() {
create_cache(&config.cache)?;
};
//Check database
let datafile = format!("{}/data.db", config.data);
match File::open(&datafile) {
Ok(..) => (),
Err(..) => create_database(&datafile)?,
};
//Check versions
let versionfile = format!("{}/versions.json", config.versions);
if File::open(&versionfile).is_err() {
create_versions_dummy(&versionfile)?;
check_game_versions(&versionfile, true).await?;
}
Ok(config)
}
}
fn create_config(path: &str) -> MLE<()> {
create_dir_all(path.split("config.toml").collect::<Vec<&str>>()[0])?;
let mut file = File::create(path)?;
file.write_all(toml::to_string(&Cfg::default())?.as_bytes())?;
println!("Created default config ({path})");
Ok(())
}
fn create_database(path: &str) -> MLE<()> {
File::create(path)?;
setup(path)?;
println!("Created database ({path})");
Ok(())
}
fn create_cache(path: &str) -> MLE<()> {
create_dir_all(path)?;
println!("Created cache ({path})");
Ok(())
}
fn create_versions_dummy(path: &str) -> MLE<()> {
File::create(path)?;
println!("Created version file ({path})");
Ok(())
}
|
