Creating a new project will open it

Author: nomnomab

package.json

@@ -1,7 +1,7 @@
 {
   "name": "nomnom-unity-hub",
   "private": true,
-  "version": "1.0.5",
+  "version": "1.0.6",
   "type": "module",
   "scripts": {
     "dev": "vite",

src-tauri/src/generate.rs

@@ -116,7 +116,7 @@ pub fn generate_project(app: &tauri::AppHandle, app_state: &tauri::State<'_, App
 
   let editor_version = template_info.editor_version.version.clone();
   let editor_version = format!("m_EditorVersion: {}", editor_version);
-  std::fs::write(&editor_version_path, editor_version)?;
+  std::fs::write(&editor_version_path, &editor_version)?;
 
   create_gitignore(package_cache_dir_out)?;
 
@@ -149,6 +149,9 @@ pub fn generate_project(app: &tauri::AppHandle, app_state: &tauri::State<'_, App
     });
     std::fs::write(&package_lock_path, serde_json::to_string_pretty(&json_str)?)?;
   }
+
+  // crate::project::update_project_open_time(app_state, package_cache_dir_out.clone(), app)?;
+  // crate::project::cmd_open_project_in_editor(app.clone(), app_state.clone(), package_cache_dir_out.clone(), editor_version.clone())?;
 
   Ok(package_cache_dir_out.clone())
 }
@@ -399,12 +402,12 @@ fn modify_package_json(json_root: &PathBuf, packages: &Vec<MinimalPackage>, outp
   // read any local packages
   let local_packages = packages
     .iter()
-    .filter(|x| x._type == package::PackageType::Local)
+    .filter(|x| x._type == package::PackageType::Local && !x.name.starts_with("com.unity.template."))
     .collect::<Vec<_>>();
 
   let rest_packages = packages
     .iter()
-    .filter(|x| x._type != package::PackageType::Local)
+    .filter(|x| x._type != package::PackageType::Local && !x.name.starts_with("com.unity.template."))
     .collect::<Vec<_>>();
 
   let manifest_json_contents = {

src-tauri/src/project.rs

@@ -159,6 +159,41 @@ pub fn get_projects_on_page(app_state: &tauri::State<AppState>, page: usize, per
   Ok(projects)
 }
 
+pub fn update_project_open_time(app_state: &tauri::State<AppState>, project_path: PathBuf, app_handle: &tauri::AppHandle) -> Result<(), errors::AnyError> {
+  let time = std::time::UNIX_EPOCH
+    .elapsed()
+    .unwrap_or(std::time::Duration::from_secs(0));
+  let millis = time.as_millis();
+
+  let mut projects = app_state.projects.lock()
+    .map_err(|_| errors::str_error("Failed to get projects. Is it locked?"))?;
+  let project = projects
+    .iter_mut()
+    .find(|x| x.path == project_path)
+    .ok_or(errors::str_error(format!("Project not found at {:?}", project_path).as_str()))?;
+  project.last_opened_at = millis;
+
+  app::save_projects_to_disk(&projects, &app_handle)?;
+
+  Ok(())
+}
+
+pub fn open_project(project_path: PathBuf, editor_version: String, app_state: &tauri::State<AppState>, app_handle: &tauri::AppHandle) -> Result<(), errors::AnyError> {
+  if !project_path.exists() {
+    return Err(errors::io_not_found("Invalid project path"));
+  }
+  
+  let project_path_str = project_path.to_str()
+    .ok_or(errors::str_error("Invalid project path"))?
+    .to_string();
+  
+  let args = vec!["-projectPath".to_string(), project_path_str];
+  crate::editor::open(editor_version, args, &app_state, false)?;
+
+  update_project_open_time(&app_state, project_path, &app_handle)?;
+  Ok(())
+}
+
 // commands
 
 #[tauri::command]
@@ -181,26 +216,38 @@ pub async fn cmd_remove_missing_projects(app_handle: tauri::AppHandle, app_state
 }
 
 #[tauri::command]
-pub fn cmd_add_project(project_path: PathBuf, app_handle: tauri::AppHandle, app_state: tauri::State<AppState>) -> Result<Project, errors::AnyError> {
+pub fn cmd_add_project(project_path: PathBuf, and_open: bool, app_handle: tauri::AppHandle, app_state: tauri::State<AppState>) -> Result<Project, errors::AnyError> {
   if !Path::new(&project_path).exists() {
     return Err(errors::io_not_found("Invalid project path"));
   }
 
-  let mut projects = app_state.projects.lock()
-    .map_err(|_| errors::str_error("Failed to get projects. Is it locked?"))?;
-  if projects.iter().any(|x| x.path == project_path) {
-    return Err(errors::str_error("Project already exists"));
+  {
+    let projects = app::get_projects(&app_state)?;
+    if projects.iter().any(|x| x.path == project_path) {
+      return Err(errors::str_error("Project already exists"));
+    }
   }
 
-  let mut project = load(project_path)?;
+  let mut project = load(project_path.clone())?;
   project.added_at = std::time::UNIX_EPOCH
     .elapsed()
     .unwrap_or(std::time::Duration::from_secs(0))
     .as_millis();
-  projects.insert(0, project.clone());
-  
-  app::save_projects_to_disk(&projects, &app_handle)?;
-  
+
+  {
+    let mut projects = app_state.projects.lock()
+      .map_err(|_| errors::str_error("Failed to get projects. Is it locked?"))?;
+    projects.insert(0, project.clone());
+
+    app::save_projects_to_disk(&projects, &app_handle)?;
+  }
+
+  if and_open {
+    let editor_version = &project.version;
+    update_project_open_time(&app_state, project_path.clone(), &app_handle)?;
+    open_project(project_path, editor_version.to_string(), &app_state, &app_handle)?;
+  }
+
   Ok(project)
 }
 
@@ -237,32 +284,7 @@ pub async fn cmd_get_projects_on_page(app_state: tauri::State<'_, AppState>, pag
 
 #[tauri::command]
 pub fn cmd_open_project_in_editor(app_handle: tauri::AppHandle, app_state: tauri::State<AppState>, project_path: PathBuf, editor_version: String) -> Result<(), errors::AnyError> {
-  if !project_path.exists() {
-    return Err(errors::io_not_found("Invalid project path"));
-  }
-  
-  let project_path_str = project_path.to_str()
-    .ok_or(errors::str_error("Invalid project path"))?
-    .to_string();
-  
-  let args = vec!["-projectPath".to_string(), project_path_str];
-  crate::editor::open(editor_version, args, &app_state, false)?;
-
-  let time = std::time::UNIX_EPOCH
-    .elapsed()
-    .unwrap_or(std::time::Duration::from_secs(0));
-  let millis = time.as_millis();
-
-  let mut projects = app_state.projects.lock()
-    .map_err(|_| errors::str_error("Failed to get projects. Is it locked?"))?;
-  let project = projects
-    .iter_mut()
-    .find(|x| x.path == project_path)
-    .ok_or(errors::str_error("Project not found"))?;
-  project.last_opened_at = millis;
-
-  app::save_projects_to_disk(&projects, &app_handle)?;
-  
+  open_project(project_path, editor_version, &app_state, &app_handle)?;
   Ok(())
 }
 

src-tauri/tauri.conf.json

@@ -7,7 +7,7 @@
   },
   "package": {
     "productName": "Nomnoms Unity Hub",
-    "version": "1.0.5"
+    "version": "1.0.6"
   },
   "tauri": {
     "allowlist": {

src/utils/tauri-router.ts

@@ -108,9 +108,11 @@ export namespace TauriRouter {
   }
 
   export async function add_project(
-    projectPath: string
+    projectPath: string,
+    andOpen?: boolean
   ): Promise<TauriTypes.Project> {
-    return invoke("cmd_add_project", { projectPath });
+    const andOpenBool = andOpen ? true : false;
+    return invoke("cmd_add_project", { projectPath, andOpen: andOpenBool });
   }
 
   export async function remove_project(projectPath: string): Promise<void> {

src/views/new-project/new-project-body.tsx

@@ -13,6 +13,7 @@ import Popup from "reactjs-popup";
 import LoadingSpinner from "../../components/svg/loading-spinner";
 import NewTemplateView from "./new-template-view";
 import { routeErrorToToast } from "../../utils/toast-utils";
+import { ValidateInputContext } from "../../components/validate-input";
 
 export type NewProjectData = {
   projectName: string;
@@ -75,8 +76,6 @@ export default function NewProjectBody() {
         if (globalContext.state.templateFromProject) {
           try {
             const project = globalContext.state.templateFromProject!;
-            console.log(project);
-            console.log(newProjectContext);
             const template: TauriTypes.TemplateInfoForGeneration = {
               editorVersion: {
                 version: project.version,
@@ -186,6 +185,14 @@ export default function NewProjectBody() {
         const pack = newProjectContext.state.packageInfo;
         const files = newProjectContext.state.filesInfo;
 
+        const path = basicInfo.path + "\\" + basicInfo.name;
+        if (await TauriRouter.is_valid_dir(path)) {
+          routeErrorToToast(new Error(`${path} is already in use.`));
+
+          isLoading.set(false);
+          return;
+        }
+
         const packages = await TauriRouter.get_default_editor_packages(
           template.editorVersion.version
         ).then((x) => x.concat(pack.gitPackages).concat(pack.localPackages));
@@ -229,7 +236,7 @@ export default function NewProjectBody() {
 
           // console.log(output);
 
-          await TauriRouter.add_project(output);
+          await TauriRouter.add_project(output, true);
           await new Promise((resolve) => setTimeout(resolve, 1000));
 
           isLoading.set(false);