Refactored spells import, working on level_1

service/src/db/spells/mod.rs

@@ -2,46 +2,57 @@ mod model;
 mod routes;
 mod types;
 
+use std::{fs::{metadata, File, read_dir}, path::Path, io::BufReader};
+
+use log::{warn, trace};
 pub use model::*;
 pub use types::*;
 pub use routes::init_routes;
 
-pub fn load_data() {
-  let root_path = std::env::current_dir().unwrap();
-  let files = [
-    "cantrips.json", "level_1.json", "level_2.json", "level_3.json", "level_4.json", "level_5.json", "level_6.json", "level_7.json", "level_8.json", "level_9.json"
-  ];
-  let mut spells: Vec<Spell> = vec![];
-  for file in files {
-    let mut data_path = std::path::PathBuf::from(&root_path);
-    data_path.push(format!("data/spells/{}", file));
-    let path = data_path.to_str().unwrap();
-    match std::fs::read_to_string(path) {
-      Ok(data) => {
-        log::debug!("Loading spells from {}", path);
-        match serde_json::from_str::<serde_json::Value>(&data) {
-          Ok(json) => {
-            match serde_json::from_value::<Vec<Spell>>(json) {
-              Ok(mut new_spells) => spells.append(&mut new_spells),
-              Err(err) => log::error!("Failed to parse spells data: {}", err)
+pub fn load_data(data_dir_path: &str) {
+  if Path::new(data_dir_path).exists() {
+    let meta = metadata(data_dir_path).unwrap();
+    if meta.is_dir() {
+      let spells_dir_path = format!("{}/spells", data_dir_path);
+      if Path::new(&spells_dir_path).exists() {
+        let meta = metadata(&spells_dir_path).unwrap();
+        if meta.is_dir() {
+          for entry in read_dir(&spells_dir_path).unwrap() {
+            let entry = entry.unwrap();
+            let path = entry.path();
+            if path.is_file() {
+              let file = File::open(path).unwrap();
+              let reader = BufReader::new(file);
+              let result: Result<Vec<Spell>, serde_json::Error> = serde_json::from_reader(reader);
+              match result {
+                Ok(spells) => {
+                  for spell in spells {
+                    let mut filters = QueryFilters::default();
+                    filters.by_name = Some(spell.name.clone());
+                    match QuerySpell::get_all(&filters, 100, 1) {
+                      Ok(spells) => {
+                        if spells.len() > 0 {
+                          trace!("Spell '{}' already exists", spell.name);
+                          continue;
+                        }
+                      },
+                      Err(err) => {
+                        warn!("Error checking if spell '{}' exists: {}", spell.name, err);
+                        continue;
+                      }
+                    };
+                    let spell = InsertSpell::insert(spell.into()).unwrap();
+                    trace!("Inserted spell: {}", spell.name);
+                  }
+                },
+                Err(err) => warn!("Error reading spells from file: {}", err)
+            };
             }
-          },
-          Err(err) => log::error!("Failed to parse spells data to value: {}", err)
-        };
-      },
-      Err(err) => log::error!("Failed to read from {}: {}", file, err)
-    };
-  }
-  let count = QuerySpell::get_count(&QueryFilters::default()).unwrap();
-  if count >= spells.len() as i64 {
-    log::warn!("Spell data is already loaded");
-    return;
-  }
-  for spell in spells {
-    let spell_name = spell.name.clone();
-    match InsertSpell::insert(spell.into()) {
-      Ok(_) => {},
-      Err(err) => log::error!("Failed to insert '{}' spell: {}", spell_name, err)
+          }
+        }
+      }
     }
+  } else {
+    warn!("Data path '{}' does not exist, no data imported", data_dir_path);
   }
 }