feat：移除了弹窗，服务器添加sls

packages/app-lib/src/state/java_globals.rs

@@ -0,0 +1,209 @@
+use serde::{Deserialize, Serialize};
+use sqlx::Row;
+
+#[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Clone)]
+pub struct JavaVersion {
+    pub parsed_version: u32,
+    pub version: String,
+    pub architecture: String,
+    pub path: String,
+    pub distribution: Option<String>,
+}
+
+impl JavaVersion {
+    pub async fn get(
+        major_version: u32,
+        exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
+    ) -> crate::Result<Option<JavaVersion>> {
+        let row = sqlx::query(
+            "
+            SELECT
+                java_versions.major_version,
+                java_versions.full_version,
+                java_versions.architecture,
+                java_versions.path,
+                java_versions.distribution
+            FROM java_default_versions
+            INNER JOIN java_versions
+                ON java_versions.major_version = java_default_versions.major_version
+                AND java_versions.path = java_default_versions.path
+            WHERE java_default_versions.major_version = $1
+            ",
+        )
+        .bind(major_version as i64)
+        .fetch_optional(exec)
+        .await?;
+
+        Ok(row.map(|row| JavaVersion {
+            parsed_version: row.get::<i64, _>("major_version") as u32,
+            version: row.get("full_version"),
+            architecture: row.get("architecture"),
+            path: row.get("path"),
+            distribution: row.get("distribution"),
+        }))
+    }
+
+    pub async fn get_all_defaults(
+        exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
+    ) -> crate::Result<Vec<Self>> {
+        let rows = sqlx::query(
+            "
+            SELECT
+                java_versions.major_version,
+                java_versions.full_version,
+                java_versions.architecture,
+                java_versions.path,
+                java_versions.distribution
+            FROM java_default_versions
+            INNER JOIN java_versions
+                ON java_versions.major_version = java_default_versions.major_version
+                AND java_versions.path = java_default_versions.path
+            ORDER BY java_versions.major_version DESC
+            ",
+        )
+        .fetch_all(exec)
+        .await?;
+
+        Ok(rows
+            .into_iter()
+            .map(|row| JavaVersion {
+                parsed_version: row.get::<i64, _>("major_version") as u32,
+                version: row.get("full_version"),
+                architecture: row.get("architecture"),
+                path: row.get("path"),
+                distribution: row.get("distribution"),
+            })
+            .collect())
+    }
+
+    pub async fn get_all(
+        exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
+    ) -> crate::Result<Vec<Self>> {
+        let rows = sqlx::query!(
+            r#"SELECT major_version, full_version, architecture, path, distribution as "distribution?: String" FROM java_versions"#
+        )
+        .fetch_all(exec)
+        .await?;
+
+        Ok(rows
+            .into_iter()
+            .map(|x| JavaVersion {
+                parsed_version: x.major_version as u32,
+                version: x.full_version,
+                architecture: x.architecture,
+                path: x.path,
+                distribution: x.distribution,
+            })
+            .collect())
+    }
+
+    pub async fn upsert(
+        &self,
+        exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
+    ) -> crate::Result<()> {
+        let major_version = self.parsed_version as i32;
+
+        sqlx::query!(
+            "
+            INSERT INTO java_versions (major_version, full_version, architecture, path, distribution)
+            VALUES ($1, $2, $3, $4, $5)
+            ON CONFLICT (path) DO UPDATE SET
+                major_version = $1,
+                full_version = $2,
+                architecture = $3,
+                distribution = $5
+            ",
+            major_version,
+            self.version,
+            self.architecture,
+            self.path,
+            self.distribution,
+        )
+            .execute(exec)
+            .await?;
+
+        Ok(())
+    }
+
+    pub async fn set_default(
+        major_version: u32,
+        path: &str,
+        exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
+    ) -> crate::Result<()> {
+        sqlx::query(
+            "
+            INSERT INTO java_default_versions (major_version, path)
+            VALUES ($1, $2)
+            ON CONFLICT (major_version) DO UPDATE SET path = $2
+            ",
+        )
+        .bind(major_version as i64)
+        .bind(path)
+        .execute(exec)
+        .await?;
+
+        Ok(())
+    }
+
+    pub async fn remove_default(
+        major_version: u32,
+        exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
+    ) -> crate::Result<()> {
+        sqlx::query(
+            "DELETE FROM java_default_versions WHERE major_version = $1",
+        )
+        .bind(major_version as i64)
+        .execute(exec)
+        .await?;
+
+        Ok(())
+    }
+
+    pub async fn remove_default_for_path(
+        path: &str,
+        exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
+    ) -> crate::Result<()> {
+        sqlx::query("DELETE FROM java_default_versions WHERE path = $1")
+            .bind(path)
+            .execute(exec)
+            .await?;
+
+        Ok(())
+    }
+
+    pub async fn delete(
+        path: &str,
+        exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
+    ) -> crate::Result<()> {
+        sqlx::query!("DELETE FROM java_versions WHERE path = $1", path)
+            .execute(exec)
+            .await?;
+        Ok(())
+    }
+
+    pub async fn update_path(
+        old_path: &str,
+        new_path: &str,
+        exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
+    ) -> crate::Result<()> {
+        sqlx::query("UPDATE java_versions SET path = $1 WHERE path = $2")
+            .bind(new_path)
+            .bind(old_path)
+            .execute(exec)
+            .await?;
+
+        Ok(())
+    }
+
+    pub async fn remove(
+        major_version: u32,
+        exec: impl sqlx::Executor<'_, Database = sqlx::Sqlite>,
+    ) -> crate::Result<()> {
+        let version = major_version as i32;
+        sqlx::query("DELETE FROM java_versions WHERE major_version = $1")
+            .bind(version)
+            .execute(exec)
+            .await?;
+        Ok(())
+    }
+}