1 files changed, 126 insertions, 90 deletions

diff --git a/src/db.rs b/src/db.rs
index 8fd21b1..49db2fd 100644
--- a/src/db.rs
+++ b/src/db.rs
@@ -9,7 +9,7 @@ use crate::{
 };
 
 //MODS
-pub fn mods_insert(config: Cfg, id: &str, slug: &str, name: &str) -> MLE<()> {
+pub fn mods_insert(config: &Cfg, id: &str, slug: &str, name: &str) -> MLE<()> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
@@ -21,7 +21,9 @@ pub fn mods_insert(config: Cfg, id: &str, slug: &str, name: &str) -> MLE<()> {
     Ok(())
 }
 
-pub fn mods_get_all_ids(config: Cfg) -> Result<Vec<String>, Box<dyn std::error::Error>> {
+pub fn mods_get_all_ids(
+    config: &Cfg,
+) -> Result<Vec<String>, Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data).unwrap();
 
@@ -64,8 +66,10 @@ pub fn mods_get_id(data: &str, slug: &str) -> MLE<String> {
     }
     //get from id if no slug found
     if mod_id.is_empty() {
-        let mut stmt = connection.prepare("SELECT id FROM mods WHERE id = ?")?;
-        let id_iter = stmt.query_map([slug], |row| row.get::<usize, String>(0))?;
+        let mut stmt =
+            connection.prepare("SELECT id FROM mods WHERE id = ?")?;
+        let id_iter =
+            stmt.query_map([slug], |row| row.get::<usize, String>(0))?;
 
         for id in id_iter {
             mod_id = id?;
@@ -73,8 +77,10 @@ pub fn mods_get_id(data: &str, slug: &str) -> MLE<String> {
     }
     //get from title if no id found from slug
     if mod_id.is_empty() {
-        let mut stmt = connection.prepare("SELECT id FROM mods WHERE title = ?")?;
-        let id_iter = stmt.query_map([slug], |row| row.get::<usize, String>(0))?;
+        let mut stmt =
+            connection.prepare("SELECT id FROM mods WHERE title = ?")?;
+        let id_iter =
+            stmt.query_map([slug], |row| row.get::<usize, String>(0))?;
 
         for id in id_iter {
             mod_id = id?;
@@ -93,12 +99,13 @@ pub struct ModInfo {
     pub title: String,
 }
 
-pub fn mods_get_info(config: Cfg, id: &str) -> MLE<ModInfo> {
+pub fn mods_get_info(config: &Cfg, id: &str) -> MLE<ModInfo> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
     let mut mod_info: Option<ModInfo> = None;
-    let mut stmt = connection.prepare("SELECT title, slug FROM mods WHERE id = ?")?;
+    let mut stmt =
+        connection.prepare("SELECT title, slug FROM mods WHERE id = ?")?;
     let name_iter = stmt.query_map([id], |row| {
         Ok(vec![
             row.get::<usize, String>(0)?,
@@ -120,9 +127,7 @@ pub fn mods_get_info(config: Cfg, id: &str) -> MLE<ModInfo> {
     }
 }
 
-pub fn mods_remove(config: Cfg, id: String) -> MLE<()> {
-    println!("Removing mod {} from database", id);
-
+pub fn mods_remove(config: &Cfg, id: &str) -> MLE<()> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
@@ -137,7 +142,10 @@ pub struct DBModlistVersions {
     pub versions: String,
 }
 
-pub fn mods_get_versions(config: Cfg, mods: Vec<String>) -> MLE<Vec<DBModlistVersions>> {
+pub fn mods_get_versions(
+    config: &Cfg,
+    mods: Vec<String>,
+) -> MLE<Vec<DBModlistVersions>> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
@@ -155,8 +163,9 @@ pub fn mods_get_versions(config: Cfg, mods: Vec<String>) -> MLE<Vec<DBModlistVer
     }
 
     let mut versionmaps: Vec<DBModlistVersions> = Vec::new();
-    let mut stmt = connection
-        .prepare(format!("SELECT id, versions, title FROM mods {}", wherestr).as_str())?;
+    let mut stmt = connection.prepare(
+        format!("SELECT id, versions, title FROM mods {}", wherestr).as_str(),
+    )?;
     let id_iter = stmt.query_map([], |row| {
         Ok(vec![
             row.get::<usize, String>(0)?,
@@ -167,11 +176,6 @@ pub fn mods_get_versions(config: Cfg, mods: Vec<String>) -> MLE<Vec<DBModlistVer
 
     for ver in id_iter {
         let version = ver?;
-        println!(
-            "\t({}) Get versions from the database",
-            String::from(&version[2])
-        );
-        //println!("Found versions {} for mod {}", version[1], version[0]);
         versionmaps.push(DBModlistVersions {
             mod_id: String::from(&version[0]),
             versions: String::from(&version[1]),
@@ -186,7 +190,7 @@ pub fn mods_get_versions(config: Cfg, mods: Vec<String>) -> MLE<Vec<DBModlistVer
 
 //userlist
 pub fn userlist_insert(
-    config: Cfg,
+    config: &Cfg,
     list_id: &str,
     mod_id: &str,
     current_version: &str,
@@ -220,26 +224,29 @@ pub fn userlist_insert(
     Ok(())
 }
 
-pub fn userlist_get_all_ids(config: Cfg, list_id: &str) -> MLE<Vec<String>> {
+pub fn userlist_get_all_ids(config: &Cfg, list_id: &str) -> MLE<Vec<String>> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data).unwrap();
 
     let mut mod_ids: Vec<String> = Vec::new();
-    let mut stmt = connection.prepare(format!("SELECT mod_id FROM {}", list_id).as_str())?;
+    let mut stmt = connection
+        .prepare(format!("SELECT mod_id FROM {}", list_id).as_str())?;
     let id_iter = stmt.query_map([], |row| row.get::<usize, String>(0))?;
 
     for id in id_iter {
-        //println!("Found id {:?}", id.as_ref().unwrap());
         mod_ids.push(id?)
     }
 
     match mod_ids.is_empty() {
-        true => Err(MLError::new(ErrorType::DBError, "NO_MODS_USERLIST")),
+        true => Err(MLError::new(
+            ErrorType::DBError,
+            &format!("NO_MODS_USERLIST{}", list_id),
+        )),
         false => Ok(mod_ids),
     }
 }
 
-pub fn userlist_remove(config: Cfg, list_id: &str, mod_id: &str) -> MLE<()> {
+pub fn userlist_remove(config: &Cfg, list_id: &str, mod_id: &str) -> MLE<()> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
@@ -251,7 +258,7 @@ pub fn userlist_remove(config: Cfg, list_id: &str, mod_id: &str) -> MLE<()> {
 }
 
 pub fn userlist_get_applicable_versions(
-    config: Cfg,
+    config: &Cfg,
     list_id: String,
     mod_id: String,
 ) -> MLE<String> {
@@ -266,7 +273,8 @@ pub fn userlist_get_applicable_versions(
         )
         .as_str(),
     )?;
-    let ver_iter = stmt.query_map([mod_id], |row| row.get::<usize, String>(0))?;
+    let ver_iter =
+        stmt.query_map([mod_id], |row| row.get::<usize, String>(0))?;
 
     for ver in ver_iter {
         version = ver?;
@@ -279,15 +287,16 @@ pub fn userlist_get_applicable_versions(
 }
 
 pub fn userlist_get_all_applicable_versions_with_mods(
-    config: Cfg,
+    config: &Cfg,
     list_id: String,
 ) -> MLE<Vec<(String, String)>> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
     let mut versions: Vec<(String, String)> = Vec::new();
-    let mut stmt = connection
-        .prepare(format!("SELECT mod_id, applicable_versions FROM {}", list_id).as_str())?;
+    let mut stmt = connection.prepare(
+        format!("SELECT mod_id, applicable_versions FROM {}", list_id).as_str(),
+    )?;
     let id_iter = stmt.query_map([], |row| {
         Ok(vec![
             row.get::<usize, String>(0)?,
@@ -307,14 +316,21 @@ pub fn userlist_get_all_applicable_versions_with_mods(
     Ok(versions)
 }
 
-pub fn userlist_get_current_version(config: Cfg, list_id: &str, mod_id: &str) -> MLE<String> {
+pub fn userlist_get_current_version(
+    config: &Cfg,
+    list_id: &str,
+    mod_id: &str,
+) -> MLE<String> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data).unwrap();
 
     let mut version: String = String::new();
-    let mut stmt = connection
-        .prepare(format!("SELECT current_version FROM {} WHERE mod_id = ?", list_id).as_str())?;
-    let ver_iter = stmt.query_map([&mod_id], |row| row.get::<usize, String>(0))?;
+    let mut stmt = connection.prepare(
+        format!("SELECT current_version FROM {} WHERE mod_id = ?", list_id)
+            .as_str(),
+    )?;
+    let ver_iter =
+        stmt.query_map([&mod_id], |row| row.get::<usize, String>(0))?;
 
     for ver in ver_iter {
         version = ver?;
@@ -327,15 +343,15 @@ pub fn userlist_get_current_version(config: Cfg, list_id: &str, mod_id: &str) ->
 }
 
 pub fn userlist_get_all_current_version_ids(
-    config: Cfg,
+    config: &Cfg,
     list_id: String,
 ) -> MLE<Vec<String>> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
     let mut versions: Vec<String> = Vec::new();
-    let mut stmt =
-        connection.prepare(format!("SELECT current_version FROM {}", list_id).as_str())?;
+    let mut stmt = connection
+        .prepare(format!("SELECT current_version FROM {}", list_id).as_str())?;
     let id_iter = stmt.query_map([], |row| row.get::<usize, String>(0))?;
 
     for id in id_iter {
@@ -343,25 +359,23 @@ pub fn userlist_get_all_current_version_ids(
     }
 
     if versions.is_empty() {
-        return Err(MLError::new(
-            ErrorType::DBError,
-            "NO_MODS_ON_LIST",
-        ));
+        return Err(MLError::new(ErrorType::DBError, "NO_MODS_ON_LIST"));
     };
 
     Ok(versions)
 }
 
 pub fn userlist_get_all_current_versions_with_mods(
-    config: Cfg,
+    config: &Cfg,
     list_id: String,
 ) -> Result<Vec<(String, String)>, Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
     let mut versions: Vec<(String, String)> = Vec::new();
-    let mut stmt =
-        connection.prepare(format!("SELECT mod_id, current_version FROM {}", list_id).as_str())?;
+    let mut stmt = connection.prepare(
+        format!("SELECT mod_id, current_version FROM {}", list_id).as_str(),
+    )?;
     let id_iter = stmt.query_map([], |row| {
         Ok(vec![
             row.get::<usize, String>(0)?,
@@ -384,14 +398,21 @@ pub fn userlist_get_all_current_versions_with_mods(
     Ok(versions)
 }
 
-pub fn userlist_get_set_version(config: Cfg, list_id: &str, mod_id: &str) -> MLE<bool> {
+pub fn userlist_get_set_version(
+    config: &Cfg,
+    list_id: &str,
+    mod_id: &str,
+) -> MLE<bool> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data).unwrap();
 
     let mut set_version: bool = false;
-    let mut stmt = connection
-        .prepare(format!("SELECT set_version FROM {} WHERE mod_id = ?", list_id).as_str())?;
-    let ver_iter = stmt.query_map([&mod_id], |row| row.get::<usize, bool>(0))?;
+    let mut stmt = connection.prepare(
+        format!("SELECT set_version FROM {} WHERE mod_id = ?", list_id)
+            .as_str(),
+    )?;
+    let ver_iter =
+        stmt.query_map([&mod_id], |row| row.get::<usize, bool>(0))?;
 
     for ver in ver_iter {
         set_version = ver?;
@@ -401,7 +422,7 @@ pub fn userlist_get_set_version(config: Cfg, list_id: &str, mod_id: &str) -> MLE
 }
 
 pub fn userlist_change_versions(
-    config: Cfg,
+    config: &Cfg,
     list_id: String,
     current_version: String,
     versions: String,
@@ -416,7 +437,7 @@ pub fn userlist_change_versions(
 }
 
 pub fn userlist_add_disabled_versions(
-    config: Cfg,
+    config: &Cfg,
     list_id: String,
     disabled_version: String,
     mod_id: String,
@@ -424,11 +445,16 @@ pub fn userlist_add_disabled_versions(
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
-    let currently_disabled_versions =
-        userlist_get_disabled_versions(config, String::from(&list_id), String::from(&mod_id))?;
+    let currently_disabled_versions = userlist_get_disabled_versions(
+        config,
+        String::from(&list_id),
+        String::from(&mod_id),
+    )?;
     let disabled_versions = match currently_disabled_versions == "NONE" {
         true => disabled_version,
-        false => format!("{}|{}", currently_disabled_versions, disabled_version),
+        false => {
+            format!("{}|{}", currently_disabled_versions, disabled_version)
+        }
     };
 
     connection.execute(
@@ -442,14 +468,21 @@ pub fn userlist_add_disabled_versions(
     Ok(())
 }
 
-pub fn userlist_get_disabled_versions(config: Cfg, list_id: String, mod_id: String) -> MLE<String> {
+pub fn userlist_get_disabled_versions(
+    config: &Cfg,
+    list_id: String,
+    mod_id: String,
+) -> MLE<String> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data).unwrap();
 
     let mut version: String = String::new();
-    let mut stmt = connection
-        .prepare(format!("SELECT disabled_versions FROM {} WHERE mod_id = ?", list_id).as_str())?;
-    let ver_iter = stmt.query_map([mod_id], |row| row.get::<usize, String>(0))?;
+    let mut stmt = connection.prepare(
+        format!("SELECT disabled_versions FROM {} WHERE mod_id = ?", list_id)
+            .as_str(),
+    )?;
+    let ver_iter =
+        stmt.query_map([mod_id], |row| row.get::<usize, String>(0))?;
 
     for ver in ver_iter {
         version = ver?;
@@ -462,20 +495,20 @@ pub fn userlist_get_disabled_versions(config: Cfg, list_id: String, mod_id: Stri
 }
 
 pub fn userlist_get_all_downloads(
-    config: Cfg,
+    config: &Cfg,
     list_id: String,
 ) -> Result<Vec<String>, Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data).unwrap();
 
     let mut links: Vec<String> = Vec::new();
-    let mut stmt =
-        connection.prepare(format!("SELECT current_download FROM {}", list_id).as_str())?;
+    let mut stmt = connection.prepare(
+        format!("SELECT current_download FROM {}", list_id).as_str(),
+    )?;
     let link_iter = stmt.query_map([], |row| row.get::<usize, String>(0))?;
 
     for link in link_iter {
         let l = link?;
-        println!("Found link {}", String::from(&l));
         links.push(l)
     }
 
@@ -492,32 +525,25 @@ pub fn userlist_get_all_downloads(
 //lists
 ///Inserts into lists table and creates new table
 pub fn lists_insert(
-    config: Cfg,
-    id: String,
-    mc_version: String,
-    mod_loader: Modloader,
-    download_folder: String,
+    config: &Cfg,
+    id: &str,
+    mc_version: &str,
+    mod_loader: &Modloader,
+    download_folder: &str,
 ) -> MLE<()> {
-    println!("Creating list {}", id);
-
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
     connection.execute(
         "INSERT INTO lists VALUES (?1, ?2, ?3, ?4)",
-        [
-            id.clone(),
-            mc_version,
-            mod_loader.to_string(),
-            download_folder,
-        ],
+        [id, mc_version, &mod_loader.to_string(), download_folder],
     )?;
     connection.execute(format!("CREATE TABLE {}( 'mod_id' TEXT, 'current_version' TEXT, 'applicable_versions' BLOB, 'current_download' TEXT, 'disabled_versions' TEXT DEFAULT 'NONE', 'set_version' INTEGER, CONSTRAINT {}_PK PRIMARY KEY (mod_id) )", id, id).as_str(), [])?;
 
     Ok(())
 }
 
-pub fn lists_remove(config: Cfg, id: String) -> MLE<()> {
+pub fn lists_remove(config: &Cfg, id: &str) -> MLE<()> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
@@ -526,7 +552,7 @@ pub fn lists_remove(config: Cfg, id: String) -> MLE<()> {
     Ok(())
 }
 
-pub fn lists_get(config: Cfg, list_id: String) -> MLE<List> {
+pub fn lists_get(config: &Cfg, list_id: &str) -> MLE<List> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data).unwrap();
 
@@ -536,8 +562,9 @@ pub fn lists_get(config: Cfg, list_id: String) -> MLE<List> {
         modloader: Modloader::Fabric,
         download_folder: String::new(),
     };
-    let mut stmt = connection
-        .prepare("SELECT mc_version, modloader, download_folder FROM lists WHERE id = ?")?;
+    let mut stmt = connection.prepare(
+        "SELECT mc_version, modloader, download_folder FROM lists WHERE id = ?",
+    )?;
 
     let list_iter = stmt.query_map([&list_id], |row| {
         Ok(vec![
@@ -550,7 +577,7 @@ pub fn lists_get(config: Cfg, list_id: String) -> MLE<List> {
     for l in list_iter {
         let li = l?;
         list = List {
-            id: String::from(&list_id),
+            id: list_id.to_string(),
             mc_version: String::from(&li[0]),
             modloader: Modloader::from(&li[1])?,
             download_folder: String::from(&li[2]),
@@ -564,7 +591,7 @@ pub fn lists_get(config: Cfg, list_id: String) -> MLE<List> {
     Ok(list)
 }
 
-pub fn lists_version(config: Cfg, list_id: &str, version: &str) -> MLE<()> {
+pub fn lists_version(config: &Cfg, list_id: &str, version: &str) -> MLE<()> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data).unwrap();
 
@@ -575,7 +602,7 @@ pub fn lists_version(config: Cfg, list_id: &str, version: &str) -> MLE<()> {
     Ok(())
 }
 
-pub fn lists_get_all_ids(config: Cfg) -> MLE<Vec<String>> {
+pub fn lists_get_all_ids(config: &Cfg) -> MLE<Vec<String>> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data).unwrap();
 
@@ -594,7 +621,7 @@ pub fn lists_get_all_ids(config: Cfg) -> MLE<Vec<String>> {
 }
 
 //config
-pub fn config_change_current_list(config: Cfg, id: String) -> MLE<()> {
+pub fn config_change_current_list(config: &Cfg, id: &str) -> MLE<()> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
@@ -605,12 +632,13 @@ pub fn config_change_current_list(config: Cfg, id: String) -> MLE<()> {
     Ok(())
 }
 
-pub fn config_get_current_list(config: Cfg) -> MLE<String> {
+pub fn config_get_current_list(config: &Cfg) -> MLE<String> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data).unwrap();
 
     let mut list_id = String::new();
-    let mut stmt = connection.prepare("SELECT value FROM user_config WHERE id = 'current_list'")?;
+    let mut stmt = connection
+        .prepare("SELECT value FROM user_config WHERE id = 'current_list'")?;
     let list_iter = stmt.query_map([], |row| row.get::<usize, String>(0))?;
 
     for list in list_iter {
@@ -626,7 +654,7 @@ pub fn config_get_current_list(config: Cfg) -> MLE<String> {
 
 //SETUP(UPDATES)
 pub fn s_userlist_update_download(
-    config: Cfg,
+    config: &Cfg,
     list_id: String,
     mod_id: String,
     link: String,
@@ -645,7 +673,9 @@ pub fn s_userlist_update_download(
     Ok(())
 }
 
-pub fn s_config_create_version(config: Cfg) -> Result<(), Box<dyn std::error::Error>> {
+pub fn s_config_create_version(
+    config: &Cfg,
+) -> Result<(), Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
@@ -656,7 +686,10 @@ pub fn s_config_create_version(config: Cfg) -> Result<(), Box<dyn std::error::Er
     Ok(())
 }
 
-pub fn s_config_update_version(config: Cfg, ver: String) -> Result<(), Box<dyn std::error::Error>> {
+pub fn s_config_update_version(
+    config: &Cfg,
+    ver: String,
+) -> Result<(), Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
@@ -667,12 +700,15 @@ pub fn s_config_update_version(config: Cfg, ver: String) -> Result<(), Box<dyn s
     Ok(())
 }
 
-pub fn s_config_get_version(config: Cfg) -> Result<String, Box<dyn std::error::Error>> {
+pub fn s_config_get_version(
+    config: &Cfg,
+) -> Result<String, Box<dyn std::error::Error>> {
     let data = format!("{}/data.db", config.data);
     let connection = Connection::open(data)?;
 
     let mut version: String = String::new();
-    let mut stmt = connection.prepare("SELECT value FROM user_config WHERE id = 'db_version'")?;
+    let mut stmt = connection
+        .prepare("SELECT value FROM user_config WHERE id = 'db_version'")?;
     let ver_iter = stmt.query_map([], |row| row.get::<usize, String>(0))?;
 
     for ver in ver_iter {
@@ -689,7 +725,7 @@ pub fn s_config_get_version(config: Cfg) -> Result<String, Box<dyn std::error::E
 }
 
 pub fn s_insert_column(
-    config: Cfg,
+    config: &Cfg,
     table: String,
     column: String,
     c_type: String,