fix: copy bundled navigation data

Author: pepperoni505

src/wasm/src/consts.rs

@@ -1,2 +1,3 @@
 pub const NAVIGATION_DATA_DEFAULT_LOCATION: &str = ".\\NavigationData";
-pub const NAVIGATION_DATA_DOWNLOADED_LOCATION: &str = "\\work/NavigationData";
+pub const NAVIGATION_DATA_WORK_LOCATION: &str = "\\work/NavigationData";
+pub const NAVIGATION_DATA_INTERNAL_CONFIG_LOCATION: &str = "\\work/navigraph_navigation_data_interface_config.json";

src/wasm/src/dispatcher.rs

@@ -11,7 +11,7 @@ use crate::{
         functions::{CallFunction, FunctionResult, FunctionStatus, FunctionType},
         params,
     },
-    meta,
+    meta::{self, InternalState},
     network_helper::NetworkHelper,
     util::{self, path_exists},
 };
@@ -117,23 +117,73 @@ impl<'a> Dispatcher<'a> {
 
     fn load_database(&mut self) {
         println!("[NAVIGRAPH] Loading database");
-        // First check if we have a database in the downloaded location
-        let found_downloaded = self
-            .set_database_if_exists(consts::NAVIGATION_DATA_DOWNLOADED_LOCATION)
-            .is_ok();
 
-        if found_downloaded {
-            println!("[NAVIGRAPH] Loaded database from downloaded location");
-            return;
+        // Are we bundled? None means we haven't installed anything yet
+        let is_bundled = meta::get_internal_state()
+            .map(|internal_state| Some(internal_state.is_bundled))
+            .unwrap_or(None);
+
+        // Get the installed cycle
+        let installed_cycle = match meta::get_installed_cycle_from_json(
+            &Path::new(consts::NAVIGATION_DATA_WORK_LOCATION).join("cycle.json"),
+        ) {
+            Ok(cycle) => Some(cycle.cycle),
+            Err(_) => None,
+        };
+
+        // Get the bundled cycle
+        let bundled_cycle = match meta::get_installed_cycle_from_json(
+            &Path::new(consts::NAVIGATION_DATA_DEFAULT_LOCATION).join("cycle.json"),
+        ) {
+            Ok(cycle) => Some(cycle.cycle),
+            Err(_) => None,
+        };
+
+        let bundled_updated = if is_bundled.is_some() && is_bundled.unwrap() {
+            // If we are bundled, we need to check if the bundled cycle is newer than the installed cycle
+            if installed_cycle.is_some() && bundled_cycle.is_some() {
+                bundled_cycle.unwrap() > installed_cycle.unwrap()
+            } else {
+                false
+            }
+        } else {
+            false
+        };
+
+        let need_to_copy = is_bundled.is_none();
+
+        // If we are bundled and the installed cycle is older than the bundled cycle, we need to copy the bundled database to the work location. Or if we haven't installed anything yet, we need to copy the bundled database to the work location
+        if bundled_updated || need_to_copy {
+            // we need to copy to the work location
+            match util::copy_files_to_folder(
+                &Path::new(consts::NAVIGATION_DATA_DEFAULT_LOCATION),
+                &Path::new(consts::NAVIGATION_DATA_WORK_LOCATION),
+            ) {
+                Ok(_) => {
+                    let res = meta::set_internal_state(InternalState { is_bundled: true });
+                    if let Err(e) = res {
+                        println!("[NAVIGRAPH] Failed to set internal state: {}", e);
+                    }
+                },
+                Err(e) => {
+                    println!(
+                        "[NAVIGRAPH] Failed to copy database from default location to work location: {}",
+                        e
+                    );
+                    return;
+                },
+            }
         }
 
-        // If we didn't find a database in the downloaded location, check the default location
-        let found_default = self
-            .set_database_if_exists(consts::NAVIGATION_DATA_DEFAULT_LOCATION)
+        // Finally, set the active database
+        let found_work = self
+            .set_database_if_exists(consts::NAVIGATION_DATA_WORK_LOCATION)
             .is_ok();
 
-        if !found_default {
-            println!("[NAVIGRAPH] No database found in default location, not loading any database");
+        if found_work {
+            println!("[NAVIGRAPH] Loaded database");
+        } else {
+            println!("[NAVIGRAPH] Failed to load database");
         }
     }
 
@@ -146,7 +196,7 @@ impl<'a> Dispatcher<'a> {
     }
 
     fn on_download_finish(&mut self) {
-        match navigation_database::util::find_sqlite_file(consts::NAVIGATION_DATA_DOWNLOADED_LOCATION) {
+        match navigation_database::util::find_sqlite_file(consts::NAVIGATION_DATA_WORK_LOCATION) {
             Ok(path) => {
                 match self.database.set_active_database(path) {
                     Ok(_) => {},

src/wasm/src/download/downloader.rs

@@ -7,6 +7,7 @@ use crate::{
     dispatcher::{Dispatcher, Task, TaskStatus},
     download::zip_handler::{BatchReturn, ZipFileHandler},
     json_structs::{events, params},
+    meta::{self, InternalState},
 };
 
 pub struct DownloadOptions {
@@ -63,6 +64,11 @@ impl NavigationDataDownloader {
                         borrowed_task.status = TaskStatus::Success(None);
                     }
                     self.download_status.replace(DownloadStatus::Downloaded);
+                    // Update the internal state
+                    let res = meta::set_internal_state(InternalState { is_bundled: false });
+                    if let Err(e) = res {
+                        println!("[NAVIGRAPH] Failed to set internal state: {}", e);
+                    }
                 },
                 Ok(BatchReturn::MoreFilesToDelete) => {
                     self.download_status.replace(DownloadStatus::CleaningDestination);
@@ -181,7 +187,7 @@ impl NavigationDataDownloader {
             return;
         }
 
-        let path = PathBuf::from(consts::NAVIGATION_DATA_DOWNLOADED_LOCATION);
+        let path = PathBuf::from(consts::NAVIGATION_DATA_WORK_LOCATION);
 
         // Check the data from the request
         let data = request.data();

src/wasm/src/meta.rs

@@ -1,5 +1,6 @@
 use std::{
     cell::RefCell,
+    error::Error,
     path::{Path, PathBuf},
     rc::Rc,
 };
@@ -13,7 +14,18 @@ use crate::{
     util::path_exists,
 };
 
-#[derive(serde::Serialize, Clone, Copy, Debug)]
+#[derive(serde::Serialize, serde::Deserialize, Debug)]
+pub struct InternalState {
+    pub is_bundled: bool,
+}
+
+impl Default for InternalState {
+    fn default() -> Self {
+        Self { is_bundled: false }
+    }
+}
+
+#[derive(serde::Serialize, Clone, Copy, Debug, PartialEq, Eq)]
 pub enum InstallStatus {
     Bundled,
     Manual,
@@ -55,6 +67,26 @@ pub struct InstalledNavigationDataCycleInfo {
     pub validity_period: String,
 }
 
+pub fn get_internal_state() -> Result<InternalState, Box<dyn Error>> {
+    let config_path = Path::new(consts::NAVIGATION_DATA_INTERNAL_CONFIG_LOCATION);
+    if !path_exists(&config_path) {
+        return Err("Internal config file does not exist")?;
+    }
+
+    let config_file = std::fs::File::open(config_path)?;
+    let internal_state: InternalState = serde_json::from_reader(config_file)?;
+
+    Ok(internal_state)
+}
+
+pub fn set_internal_state(internal_state: InternalState) -> Result<(), Box<dyn Error>> {
+    let config_path = Path::new(consts::NAVIGATION_DATA_INTERNAL_CONFIG_LOCATION);
+    let config_file = std::fs::File::create(config_path)?;
+    serde_json::to_writer(config_file, &internal_state)?;
+
+    Ok(())
+}
+
 pub fn start_network_request(task: Rc<RefCell<Task>>) {
     let request = NetworkHelper::make_request("https://navdata.api.navigraph.com/info", Method::Get, None, None);
     let request = match request {
@@ -67,6 +99,13 @@ pub fn start_network_request(task: Rc<RefCell<Task>>) {
     task.borrow_mut().associated_network_request = Some(request);
 }
 
+pub fn get_installed_cycle_from_json(path: &Path) -> Result<InstalledNavigationDataCycleInfo, Box<dyn Error>> {
+    let json_file = std::fs::File::open(path)?;
+    let installed_cycle_info: InstalledNavigationDataCycleInfo = serde_json::from_reader(json_file)?;
+
+    Ok(installed_cycle_info)
+}
+
 pub fn get_navigation_data_install_status(task: Rc<RefCell<Task>>) {
     let response_bytes = match task.borrow().associated_network_request.as_ref() {
         Some(request) => {
@@ -98,23 +137,26 @@ pub fn get_navigation_data_install_status(task: Rc<RefCell<Task>>) {
     };
 
     // figure out install status
-    let found_downloaded = path_exists(Path::new(consts::NAVIGATION_DATA_DOWNLOADED_LOCATION));
+    let found_downloaded = path_exists(Path::new(consts::NAVIGATION_DATA_WORK_LOCATION));
 
-    let found_bundled = path_exists(Path::new(consts::NAVIGATION_DATA_DEFAULT_LOCATION));
+    let found_bundled = get_internal_state()
+        .map(|internal_state| internal_state.is_bundled)
+        .unwrap_or(false);
 
-    let status = if found_downloaded {
-        InstallStatus::Manual
-    } else if found_bundled {
+    // Check bundled first, as downloaded and bundled are both possible
+    let status = if found_bundled {
         InstallStatus::Bundled
+    } else if found_downloaded {
+        InstallStatus::Manual
     } else {
         InstallStatus::None
     };
 
     // Open JSON
-    let json_path = match status {
-        InstallStatus::Manual => Some(PathBuf::from(consts::NAVIGATION_DATA_DOWNLOADED_LOCATION).join("cycle.json")),
-        InstallStatus::Bundled => Some(PathBuf::from(consts::NAVIGATION_DATA_DEFAULT_LOCATION).join("cycle.json")),
-        InstallStatus::None => None,
+    let json_path = if status != InstallStatus::None {
+        Some(PathBuf::from(consts::NAVIGATION_DATA_WORK_LOCATION).join("cycle.json"))
+    } else {
+        None
     };
 
     let installed_cycle_info = match json_path {
@@ -154,10 +196,10 @@ pub fn get_navigation_data_install_status(task: Rc<RefCell<Task>>) {
             Some(installed_cycle_info) => Some(installed_cycle_info.cycle.clone()),
             None => None,
         },
-        install_path: match status {
-            InstallStatus::Manual => Some(consts::NAVIGATION_DATA_DOWNLOADED_LOCATION.to_string()),
-            InstallStatus::Bundled => Some(consts::NAVIGATION_DATA_DEFAULT_LOCATION.to_string()),
-            InstallStatus::None => None,
+        install_path: if status == InstallStatus::Manual {
+            Some(consts::NAVIGATION_DATA_WORK_LOCATION.to_string())
+        } else {
+            None
         },
         validity_period: match &installed_cycle_info {
             Some(installed_cycle_info) => Some(installed_cycle_info.validity_period.clone()),

src/wasm/src/util.rs

@@ -49,6 +49,34 @@ pub fn delete_folder_recursively(path: &Path, batch_size: Option<usize>) -> io::
     Ok(())
 }
 
+pub fn copy_files_to_folder(from: &Path, to: &Path) -> io::Result<()> {
+    // Make sure we are copying a directory (and in turn that it exists)
+    if get_path_type(from) != PathType::Directory {
+        return Ok(());
+    }
+    // Let's clear the directory we are copying to
+    delete_folder_recursively(to, None)?;
+    // Create the directory we are copying to
+    fs::create_dir(to)?;
+    // Collect the entries that we will copy
+    let entries = fs::read_dir(from)?.collect::<Result<Vec<_>, _>>()?;
+    // Copy the entries
+    for entry in entries {
+        let path = entry.path();
+        let path_type = get_path_type(&path);
+
+        if path_type == PathType::Directory {
+            let new_dir = to.join(path.file_name().unwrap());
+            fs::create_dir(&new_dir)?;
+            copy_files_to_folder(&path, &new_dir)?;
+        } else if path_type == PathType::File {
+            fs::copy(&path, to.join(path.file_name().unwrap()))?;
+        }
+    }
+
+    Ok(())
+}
+
 pub fn trim_null_terminator(s: &str) -> &str {
     s.trim_end_matches(char::from(0))
 }