dfkjhdsakljfhdskljh

changelog

···
 
 v0.2.1:
   - Fixed app using GPU while minimised, might use a tiny bit, but should be much better than before
-  - Fixed a load a bugs todo with 
+  - Fixed a load a bugs todo with (something? apparently i forgot to write this bit...)
+
+v0.2.2:
+  - Use more linux friendly directories
+  - Move away from localstorage and use the .config file

src-tauri/src/frontend_calls/change_final_path.rs

···
 
 #[tauri::command]
 pub fn change_final_path(new_path: &str) {
-  let config_path = dirs::home_dir()
+  let config_path = dirs::config_dir()
     .unwrap()
-    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.photos_path");
+    .join("PhazeDev\\VRChatPhotoManager\\.photos_path");
 
   fs::write(&config_path, new_path.as_bytes()).unwrap();
 

src-tauri/src/frontend_calls/config.rs

···
+use std::{ fs, path::PathBuf };
+
+use serde_json::Value;
+
+pub fn get_config_path() -> PathBuf{
+  let path = dirs::config_dir()
+    .unwrap()
+    .join("PhazeDev\\VRChatPhotoManager\\.config");
+
+  match fs::metadata(&path){
+    Ok(_) => {}
+    Err(_) => {
+      fs::write(&path, b"{}").unwrap();
+    }
+  }
+
+  path
+}
+
+#[tauri::command]
+pub fn set_config_value_string( key: String, value: String ){
+  let path = get_config_path();
+
+  let mut config: Value = serde_json::from_str(&fs::read_to_string(&path).unwrap()).unwrap();
+  config[key] = Value::from(value);
+
+  fs::write(path, config.to_string()).unwrap();
+}
+
+#[tauri::command]
+pub fn get_config_value_string( key: String ) -> Option<String>{
+  let config: Value = serde_json::from_str(&fs::read_to_string(get_config_path()).unwrap()).unwrap();
+  let string = config[key].as_str();
+
+  if string.is_some(){
+    Some(string.unwrap().to_owned())
+  } else{
+    None
+  }
+}
+
+#[tauri::command]
+pub fn set_config_value_int( key: String, value: i64 ){
+  let path = get_config_path();
+
+  let mut config: Value = serde_json::from_str(&fs::read_to_string(&path).unwrap()).unwrap();
+  config[key] = Value::from(value);
+
+  fs::write(path, config.to_string()).unwrap();
+}
+
+#[tauri::command]
+pub fn get_config_value_int( key: String ) -> Option<i64>{
+  let config: Value = serde_json::from_str(&fs::read_to_string(get_config_path()).unwrap()).unwrap();
+  config[key].as_i64()
+}

src-tauri/src/frontend_calls/mod.rs

···
 pub mod load_photo_meta;
 pub mod change_final_path;
 pub mod delete_photo;
-pub mod relaunch;
+pub mod relaunch;
+pub mod config;

src-tauri/src/frontend_calls/relaunch.rs

···
 
 #[tauri::command]
 pub fn relaunch() {
-  let container_folder = dirs::home_dir()
+  let container_folder = dirs::config_dir()
     .unwrap()
-    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager");
+    .join("PhazeDev\\VRChatPhotoManager");
 
   let mut cmd = Command::new(&container_folder.join("./vrchat-photo-manager.exe"));
   cmd.current_dir(container_folder);

src-tauri/src/frontend_calls/start_with_win.rs

···
 // create and delete the shortcut from the startup folder
 #[tauri::command]
 pub fn start_with_win(start: bool) {
-  thread::spawn(move || {
-    if start {
-      let target = dirs::home_dir()
-        .unwrap()
-        .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\vrchat-photo-manager.exe");
+  if cfg!(windows) {
+    thread::spawn(move || {
+      if start {
+        let target = dirs::config_dir()
+          .unwrap()
+          .join("PhazeDev\\VRChatPhotoManager\\vrchat-photo-manager.exe");
 
-      match fs::metadata(&target) {
-        Ok(_) => {
-          let lnk = dirs::home_dir().unwrap().join("AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\VRChat Photo Manager.lnk");
+        match fs::metadata(&target) {
+          Ok(_) => {
+            let lnk = dirs::home_dir().unwrap().join("AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\VRChat Photo Manager.lnk");
 
-          let sl = ShellLink::new(target).unwrap();
-          sl.create_lnk(lnk).unwrap();
+            let sl = ShellLink::new(target).unwrap();
+            sl.create_lnk(lnk).unwrap();
+          }
+          Err(_) => {}
         }
-        Err(_) => {}
+      } else {
+        let lnk = dirs::home_dir().unwrap().join("AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\VRChat Photo Manager.lnk");
+        fs::remove_file(lnk).unwrap();
       }
-    } else {
-      let lnk = dirs::home_dir().unwrap().join("AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\VRChat Photo Manager.lnk");
-      fs::remove_file(lnk).unwrap();
-    }
-  });
+    });
+  } else {
+    panic!("Cannot start with windows... on not windows...");
+  }
 }

src-tauri/src/main.rs

···
   tauri_plugin_deep_link::prepare("uk.phaz.vrcpm");
 
   // Double check the app has an install directory
-  let container_folder = dirs::home_dir()
+  let container_folder = dirs::config_dir()
     .unwrap()
-    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager");
+    .join("PhazeDev\\VRChatPhotoManager");
 
   match fs::metadata(&container_folder) {
     Ok(meta) => {
···
     }
   }
 
-  let sync_lock_path = dirs::home_dir()
+  let sync_lock_path = dirs::config_dir()
     .unwrap()
-    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.sync_lock");
+    .join("PhazeDev\\VRChatPhotoManager\\.sync_lock");
 
   match fs::metadata(&sync_lock_path) {
     Ok(_) => {
···
       change_final_path::change_final_path,
       sync_photos::sync_photos,
       util::get_version::get_version,
-      relaunch::relaunch
+      relaunch::relaunch,
+      config::set_config_value_string,
+      config::get_config_value_string,
+      config::set_config_value_int,
+      config::get_config_value_int
     ])
     .run(tauri::generate_context!())
     .expect("error while running tauri application");

src-tauri/src/photosync.rs

···
 }
 
 pub fn sync_photos(token: String, path: path::PathBuf, window: tauri::Window) {
-  let sync_lock_path = dirs::home_dir()
+  let sync_lock_path = dirs::config_dir()
     .unwrap()
-    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.sync_lock");
+    .join("PhazeDev\\VRChatPhotoManager\\.sync_lock");
 
   match fs::metadata(&sync_lock_path) {
     Ok(_) => {

src-tauri/src/util/get_photo_path.rs

···
 use std::{ fs, path };
 
 pub fn get_photo_path() -> path::PathBuf {
-  let config_path = dirs::home_dir()
+  let config_path = dirs::config_dir()
     .unwrap()
-    .join("AppData\\Roaming\\PhazeDev\\VRChatPhotoManager\\.photos_path");
+    .join("PhazeDev\\VRChatPhotoManager\\.photos_path");
 
   match fs::read_to_string(config_path) {
     Ok(path) => {

src/Components/App.tsx

···
 // TODO: Clean up frontend files, split up into smaller files PLEASE
 
 function App() {
-  if(!localStorage.getItem('start-in-bg')){
-    invoke('close_splashscreen')
-  }
+  invoke('get_config_value_string', { key: 'start-in-bg' })
+    .then(str => {
+      if(str === "false")invoke('close_splashscreen')
+    })
 
   let [ loggedIn, setLoggedIn ] = createSignal({ loggedIn: false, username: '', avatar: '', id: '', serverVersion: '0.0' });
   let [ storageInfo, setStorageInfo ] = createSignal({ storage: 0, used: 0, sync: false });
···
     confirmationBoxCallback = cb;
   }
 
-  if(localStorage.getItem('token')){
-    fetch('https://photos.phazed.xyz/api/v1/account?token='+localStorage.getItem('token'))
-      .then(data => data.json())
-      .then(data => {
-        if(!data.ok){
-          return console.error(data);
-        }
-
-        console.log(data.data);
-        setLoggedIn({ loggedIn: true, username: data.user.username, avatar: data.user.avatar, id: data.user._id, serverVersion: data.user.serverVersion });
-        setStorageInfo({ storage: data.user.storage, used: data.user.used, sync: data.user.settings.enableSync });
-
-        if(!isPhotosSyncing() && data.user.settings.enableSync){
-          setIsPhotosSyncing(true);
-          invoke('sync_photos', { token: localStorage.getItem('token') });
-        }
-      })
-      .catch(e => {
-        console.error(e);
-      })
-  }
+  invoke('get_config_value_string', { key: 'token' })
+    .then(token => {
+      if(token){
+        fetch('https://photos.phazed.xyz/api/v1/account?token='+token)
+          .then(data => data.json())
+          .then(data => {
+            if(!data.ok){
+              return console.error(data);
+            }
+    
+            console.log(data.data);
+            setLoggedIn({ loggedIn: true, username: data.user.username, avatar: data.user.avatar, id: data.user._id, serverVersion: data.user.serverVersion });
+            setStorageInfo({ storage: data.user.storage, used: data.user.used, sync: data.user.settings.enableSync });
+    
+            if(!isPhotosSyncing() && data.user.settings.enableSync){
+              setIsPhotosSyncing(true);
+              invoke('sync_photos', { token: token });
+            }
+          })
+          .catch(e => {
+            console.error(e);
+          })
+      }
+    })
 
   setTimeout(() => {
     setLoadingType('none');
···
         }
 
         console.log(data);
-        localStorage.setItem('token', token);
+        invoke('set_config_value_string', { key: 'token', value: token });
 
         setLoadingType('none');
         setLoggedIn({ loggedIn: true, username: data.user.username, avatar: data.user.avatar, id: data.user._id, serverVersion: data.user.serverVersion });
···
 
         if(!isPhotosSyncing() && data.user.settings.enableSync){
           setIsPhotosSyncing(true);
-          invoke('sync_photos', { token: localStorage.getItem('token') });
+          invoke('sync_photos', { token: token });
         }
       })
       .catch(e => {

src/Components/NavBar.tsx

···
       </div>
 
       <div class="dropdown" ref={( el ) => dropdown = el}>
-        <div class="dropdown-button" onClick={() => {
+        <div class="dropdown-button" onClick={async () => {
           anime.set('.settings', { display: 'block' });
           anime({
             targets: '.settings',
···
             duration: 250
           })
 
-          fetch('https://photos.phazed.xyz/api/v1/account?token='+localStorage.getItem('token')!)
+          fetch('https://photos.phazed.xyz/api/v1/account?token='+ (await invoke('get_config_value_string', { key: 'token' }))!)
             .then(data => data.json())
             .then(data => {
               if(!data.ok){
···
         }}>Settings</div>
 
         <Show when={props.loggedIn().loggedIn == false} fallback={
-          <div class="dropdown-button" onClick={() => {
-            fetch('https://photos.phazed.xyz/api/v1/deauth?token='+localStorage.getItem('token')!)
+          <div class="dropdown-button" onClick={async () => {
+            fetch('https://photos.phazed.xyz/api/v1/deauth?token='+(await invoke('get_config_value_string', { key: 'token' }))!)
               .then(data => data.json())
               .then(data => {
                 console.log(data);
 
-                localStorage.removeItem('token');
+                invoke('set_config_value_string', { key: 'token', value: '' });
                 window.location.reload();
 
                 setDropdownVisibility(false);
···
               .catch(e => {
                 console.error(e);
 
-                localStorage.removeItem('token');
+                invoke('set_config_value_string', { key: 'token', value: '' });
                 window.location.reload();
 
                 setDropdownVisibility(false);

src/Components/PhotoList.tsx

···
     }
   })
 
-  listen('photo_create', ( event: any ) => {
+  listen('photo_create', async ( event: any ) => {
     let photo = new Photo(event.payload);
 
     photos.splice(0, 0, photo);
···
 
     if(!props.isPhotosSyncing() && props.storageInfo().sync){
       props.setIsPhotosSyncing(true);
-      invoke('sync_photos', { token: localStorage.getItem('token') });
+      invoke('sync_photos', { token: (await invoke('get_config_value_string', { key: 'token' })) });
     }
   })
 

src/Components/PhotoViewer.tsx

···
   }
 }
 
-let worldCache: WorldCache[] = JSON.parse(localStorage.getItem('worldCache') || "[]");
+let worldCache: WorldCache[] = JSON.parse(await invoke('get_config_value_string', { key: 'worldcache' }) || "[]");
 
 let PhotoViewer = ( props: PhotoViewerProps ) => {
   let viewer: HTMLElement;
···
     }
 
     worldCache.push(worldData);
-    localStorage.setItem("worldCache", JSON.stringify(worldCache));
+    invoke('set_config_value_string', { key: 'worldcache', value: worldCache });
 
     loadWorldData(worldData);
   })
···
         <div class="viewer-button"
           onMouseOver={( el ) => anime({ targets: el.currentTarget, width: '40px', height: '40px', 'margin-left': '15px', 'margin-right': '15px', 'margin-top': '-10px' })}
           onMouseLeave={( el ) => anime({ targets: el.currentTarget, width: '30px', height: '30px', 'margin-left': '20px', 'margin-right': '20px', 'margin-top': '0px' })}
-          onClick={() => props.setConfirmationBox("Are you sure you want to delete this photo?", () => { invoke("delete_photo", {
+          onClick={() => props.setConfirmationBox("Are you sure you want to delete this photo?", async () => { invoke("delete_photo", {
             path: props.currentPhotoView().path,
-            token: localStorage.getItem("token") || "none",
+            token: (await invoke('get_config_value_string', { key: 'token' })) || "none",
             isSyncing: props.loggedIn().loggedIn ? props.storageInfo().sync : false
           });
         })}>

src/Components/SettingsMenu.tsx

···
     }
   }
 
-  onMount(() => {
-    if(localStorage.getItem('transparent')){
-      localStorage.setItem('transparent', 'true');
+  onMount(async () => {
+    if(await invoke('get_config_value_string', { key: 'transparent' }) === "true"){
+      invoke('set_config_value_string', { key: 'transparent', value: 'true' });
 
       anime({ targets: document.body, background: 'rgba(0, 0, 0, 0.5)', easing: 'linear', duration: 100 });
       anime({ targets: '.settings', background: 'rgba(0, 0, 0, 0.5)', easing: 'linear', duration: 100 });
     } else{
-      localStorage.removeItem('transparent')
+      invoke('set_config_value_string', { key: 'transparent', value: 'false' });
 
       anime({ targets: document.body, background: 'rgba(0, 0, 0, 1)', easing: 'linear', duration: 100 });
       anime({ targets: '.settings', background: 'rgba(0, 0, 0, 0)', easing: 'linear', duration: 100 });
···
     window.removeEventListener('keyup', closeWithKey);
   })
 
-  let refreshAccount = () => {
-    fetch('https://photos.phazed.xyz/api/v1/account?token='+localStorage.getItem('token')!)
+  let refreshAccount = async () => {
+    fetch('https://photos.phazed.xyz/api/v1/account?token='+(await invoke('get_config_value_string', { key: 'token' }))!)
       .then(data => data.json())
       .then(data => {
         if(!data.ok){
···
           <p>{ props.photoCount() } Photos ({ bytesToFormatted(props.photoSize(), 0) })</p>
 
           <div class="selector">
-            <input type="checkbox" id="start-in-bg-check" ref={( el ) => {
-              el.checked = localStorage.getItem('start-in-bg') ? true : false;
+            <input type="checkbox" id="start-in-bg-check" ref={async ( el ) => {
+              el.checked = await invoke('get_config_value_string', { key: 'start-in-bg' }) === "true" ? true : false;
             }} onChange={( el ) => {
               if(el.target.checked){
-                localStorage.setItem('start-in-bg', 'true');
+                invoke('set_config_value_string', { key: 'start-in-bg', value: 'true' });
               } else{
-                localStorage.removeItem('start-in-bg')
+                invoke('set_config_value_string', { key: 'start-in-bg', value: 'false' });
               }
             }} />
             Start in background
···
           </div>
 
           <div class="selector">
-            <input type="checkbox" id="start-with-win-check" ref={( el ) => {
-              el.checked = localStorage.getItem('start-with-win') ? true : false;
+            <input type="checkbox" id="start-with-win-check" ref={async ( el ) => {
+              el.checked = await invoke('get_config_value_string', { key: 'start-with-win' }) === "true" ? true : false;
             }} onChange={( el ) => {
               if(el.target.checked){
-                localStorage.setItem('start-with-win', 'true');
+                invoke('set_config_value_string', { key: 'start-with-win', value: 'true' });
                 invoke("start_with_win", { start: true });
               } else{
-                localStorage.removeItem('start-with-win')
+                invoke('set_config_value_string', { key: 'start-with-win', value: 'false' });
                 invoke("start_with_win", { start: false });
               }
             }} />
···
           </div>
 
           <div class="selector">
-            <input type="checkbox" id="transparent-check" ref={( el ) => {
-              el.checked = localStorage.getItem('transparent') ? true : false;
+            <input type="checkbox" id="transparent-check" ref={async ( el ) => {
+              el.checked = await invoke('get_config_value_string', { key: 'transparent' }) === "true" ? true : false;
             }} onChange={( el ) => {
               if(el.target.checked){
-                localStorage.setItem('transparent', 'true');
+                invoke('set_config_value_string', { key: 'transparent', value: 'true' });
 
                 anime({ targets: document.body, background: 'rgba(0, 0, 0, 0.5)', easing: 'linear', duration: 100 });
                 anime({ targets: '.settings', background: 'rgba(0, 0, 0, 0.5)', easing: 'linear', duration: 100 });
               } else{
-                localStorage.removeItem('transparent')
+                invoke('set_config_value_string', { key: 'transparent', value: 'false' });
 
                 anime({ targets: document.body, background: 'rgba(0, 0, 0, 1)', easing: 'linear', duration: 100 });
                 anime({ targets: '.settings', background: 'rgba(0, 0, 0, 0)', easing: 'linear', duration: 100 });
···
 
             <div class="account-notice" style={{ display: 'flex' }}>
               <Show when={!deletingPhotos()} fallback={ "We are deleting your photos, please leave this window open while we delete them." }>
-                <div class="button-danger" onClick={() => props.setConfirmationBox("You are about to delete all your photos from the cloud, and disable syncing. This will NOT delete any local files.", () => {
+                <div class="button-danger" onClick={() => props.setConfirmationBox("You are about to delete all your photos from the cloud, and disable syncing. This will NOT delete any local files.", async () => {
                   props.setStorageInfo({ used: 0, storage: 0, sync: false });
                   setDeletingPhotos(true);
 
                   fetch('https://photos-cdn.phazed.xyz/api/v1/allphotos', {
                     method: 'DELETE',
-                    headers: { auth: localStorage.getItem("token")! }
+                    headers: { auth: (await invoke('get_config_value_string', { key: 'token' }))! }
                   })
                     .then(data => data.json())
                     .then(data => {

src/index.tsx

···
 /* @refresh reload */
 import { render } from "solid-js/web";
 
-// TODO: Rewrite storage stuff localstorage is dumb.
-
 declare global{
   interface Window {
     CloseAllPopups: (() => void)[]