Should basically be back to working as it did before the refactoring.

src-tauri/src/main.rs

@@ -102,6 +102,11 @@ fn save_plan_at_path(path: PathBuf, plan: Plan) -> bool {
     false
 }
 
+#[tauri::command]
+fn save_plan_at_store(name: String, plan: Plan) -> Option<PathBuf> {
+    Storage::save_plan_at_store_path(&name, plan).ok()
+}
+
 #[tauri::command]
 fn base_plan() -> Plan {
     const BASE_PLAN_STRING: &str = include_str!("../../data/base_plan.json");
@@ -159,6 +164,7 @@ fn main() {
             enumerate_stored_plans,
             load_plan_at_path,
             save_plan_at_path,
+            save_plan_at_store,
             base_plan,
         ])
         .system_tray(system_tray)

src-tauri/src/plan.rs

@@ -3,7 +3,8 @@ use std::{collections::HashMap, path::PathBuf};
 use serde::{ser::SerializeStruct, Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Plan {
+pub struct 
+Plan {
     plan: Vec<PlanElement>,
     current: usize,
     #[serde(flatten)]

src-tauri/src/storage.rs

@@ -4,6 +4,7 @@ use std::path::PathBuf;
 use directories::ProjectDirs;
 use serde::{Deserialize, Serialize};
 
+
 use crate::config::Config;
 use crate::plan::{convert_old, Plan, PlanMetadata};
 
@@ -101,13 +102,13 @@ impl Storage {
         Some(plan)
     }
 
-    pub fn save_plan_at_store_path(file_name: &str, plan: Plan) -> Result<(), Box<dyn Error>> {
+    pub fn save_plan_at_store_path(file_name: &str, mut plan: Plan) -> Result<PathBuf, Box<dyn Error>> {
         let plan_dir = match Self::plan_dir() {
             Some(dir) => dir,
             None => return Err("No plan dir".into()),
         };
 
-        let file_path = plan_dir.with_file_name(file_name).with_extension("json");
+        let file_path = plan_dir.join(file_name).with_extension("json");
 
         //Disallow overwriting.
         if file_path.exists() {
@@ -115,11 +116,11 @@ impl Storage {
         }
 
         //TODO: Determine necessity
-        // plan.set_stored_path(file_path.clone());
+        plan.set_stored_path(Some(file_path.clone()));
 
-        std::fs::write(file_path, serde_json::to_string(&plan)?)?;
+        std::fs::write(&file_path, serde_json::to_string(&plan)?)?;
 
-        Ok(())
+        Ok(file_path.clone())
     }
 
     pub fn enumerate_plans() -> Vec<PlanMetadata> {

src/app/_models/plan.ts

@@ -51,6 +51,15 @@ export class Plan {
         }
     }
 
+    toInterface(): PlanInterface {
+        return {
+            plan: this.plan,
+            current: this.current,
+            stored_path: this.path,
+            update_url: this.update_url,
+        };
+    }
+
     private requestSelfSave() {
         if (this.path) {
             this.selfSaveSubject.next();
@@ -58,12 +67,7 @@ export class Plan {
     }
 
     private directSelfSave() {
-        invoke('save_plan', {
-            plan: {
-                plan: this.plan,
-                current: this.current
-            }, path: this.path
-        });
+        invoke('save_plan_at_path', {path: this.path, plan: this.toInterface()});
     }
 
 }

src/app/_services/plan.service.ts

@@ -35,7 +35,7 @@ export class PlanService {
   }
 
   public loadPlanFromPath(path: string, save_local: boolean = true): Observable<Plan> {
-    return from(invoke<PlanInterface>('load_plan_at_path', { path, save_local })).pipe(map(plan => {return new Plan(plan)}));
+    return from(invoke<PlanInterface>('load_plan_at_path', { path, saveLocal: save_local })).pipe(map(plan => { return new Plan(plan) }));
   }
 
   public loadFromUrl(url?: string, name?: string): Observable<Plan> {
@@ -61,7 +61,15 @@ export class PlanService {
   }
 
   public savePlanAtPath(path: string, plan: Plan) {
-    return from(invoke('save_plan_at_path', { path, plan: plan }));
+    plan.plan.forEach(elem => {
+      if (!elem.notes) { elem.notes = "" }
+    });
+
+    return from(invoke('save_plan_at_path', { path, plan: plan.toInterface() }));
+  }
+
+  public savePlanAtStore(name: string, plan: Plan) {
+    return from(invoke<string>('save_plan_at_store', { name, plan: plan.toInterface() }));
   }
 
   private _loadFromUrl(url: string, name: string): Observable<Plan> {
@@ -70,7 +78,7 @@ export class PlanService {
       url,
       {
         method: 'GET',
-        timeout: 30
+        timeout: 10
       })).pipe(map(response => {
         return new Plan(response.data as PlanInterface);
       })).pipe(tap(plan => {

src/app/plan-display/plan-display.component.ts

@@ -253,6 +253,7 @@ export class PlanDisplayComponent implements AfterViewInit, OnInit {
       if (file) {
         this.planService.loadPlanFromPath(file as string).subscribe(plan => {
           if (plan) {
+            this.planService.setCurrentPlan(plan);
             this.settingsOpen = false;
           }
         });
@@ -298,6 +299,17 @@ export class PlanDisplayComponent implements AfterViewInit, OnInit {
   }
 
   loadFromUrl() {
-    this.planService.loadFromUrl().subscribe();
+    this.planService.loadFromUrl().subscribe(plan => {
+      console.log("plan", plan);
+      if (plan) {
+        this.planService.savePlanAtStore(plan.name!, plan).subscribe((path) => {
+          console.log("path", path);
+          if(path) {
+            plan.setPath(path);
+          }
+        });
+        this.planService.setCurrentPlan(plan);
+      }
+    });
   }
 }