feat: 初始化gotify-ws项目并添加websocket和sea-orm集成

packages/gotify-ws/Cargo.toml

@@ -4,15 +4,18 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-diesel = { version = "2.2.12", features = ["r2d2", "serde_json", "sqlite"] }
+#diesel = { version = "2.2.12", features = ["r2d2", "serde_json", "sqlite"] }
 env_logger = "0.11.8"
 futures = "0.3.31"
 log = "0.4.27"
-r2d2 = "0.8.10"
+#r2d2 = "0.8.10"
 #r2d2_sqlite = "0.31.0"
-rusqlite = { version = "0.37.0", features = ["bundled"] }
+#libsqlite3-sys = { version = "0.35.0", features = ["bundled"] }
+# 或如果是通过 rusqlite 依赖：
+rusqlite = { version = "0.32.1", features = ["bundled"] }
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.142"
-tokio = { version = "1.47.0", features = ["full"] }
+tokio = { version = "1.47.1", features = ["full"] }
 tokio-tungstenite = { version = "0.27.0", features = ["native-tls"] }
 regex = "1.11.1"
+sea-orm = "1.1.14"

packages/gotify-ws/src/main.rs

@@ -6,16 +6,16 @@ use crate::model::ws::WsMessage;
 use futures::StreamExt;
 use log::{info, warn};
 use tokio_tungstenite::connect_async;
+use tokio_tungstenite::tungstenite::client::IntoClientRequest;
 use utils::logger;
-use utils::sql::sqlite::SqliteDB;
+
 #[tokio::main]
 async fn main() {
   logger::init_logger();
-  const ADDR: &str = "wss://home.hzer.xyz/gotify/stream?token=CDIwYlYJuxWxVr5";
-  let (stream, _) = connect_async(ADDR).await.unwrap();
-  info!("Connected to Gotify server {ADDR}");
-  let db = SqliteDB::new("db.sqlite").unwrap();
-  db.create_table();
+  let addr  = "wss://home.hzer.xyz/gotify/stream?token=CDIwYlYJuxWxVr5".into_client_request().unwrap();
+  let (stream, _) = connect_async(addr.clone()).await.unwrap();
+
+  // info!("Connected to Gotify server {addr}");
 
   let (_, mut read) = stream.split();
   while let Some(msg) = read.next().await {

packages/gotify-ws/src/model/mod.rs

@@ -1 +1,3 @@
-pub mod ws;
+pub mod ws;
+pub mod student;
+mod test;

packages/gotify-ws/src/model/student.rs

@@ -0,0 +1,26 @@
+use sea_orm::entity::prelude::*;
+
+#[derive(Debug, Clone, DeriveEntityModel)]
+#[sea_orm(table_name = "student")]
+pub struct Model {
+  #[sea_orm(primary_key)]
+  pub id: u32,
+  pub name: String,
+  pub age: i32,
+  pub sex: Sex,
+  pub class: u8,
+  pub score: f32,
+}
+
+#[derive(EnumIter, Copy, Clone, Debug, DeriveRelation)]
+pub enum Relation {}
+#[derive(Debug, Clone, PartialEq, EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "Text")]
+pub enum Sex {
+  #[sea_orm(string_value = "male")]
+  Male,
+  #[sea_orm(string_value = "female")]
+  Female,
+}
+
+impl ActiveModelBehavior for ActiveModel {}

packages/gotify-ws/src/model/test/mod.rs

@@ -0,0 +1 @@
+mod student;

packages/gotify-ws/src/model/test/student.rs

@@ -0,0 +1,32 @@
+#[cfg(test)]
+mod student {
+  use crate::model::student;
+  use log::info;
+  use sea_orm::{Database, DbBackend, Schema, sea_query::Table};
+
+  #[tokio::test]
+  async fn db_test() {
+    db_connect().await;
+    println!("-----------");
+  }
+
+  async fn db_connect() {
+    if let Ok(db) = Database::connect("test.sqlite").await {
+      println!("DB connected {db:?}");
+
+      let stmt = Table::create().table(student::Entity).if_not_exists();
+      println!("{}",1);
+    }
+  }
+
+  #[test]
+  fn print_sql() {
+    let db = DbBackend::Sqlite;
+    let schema = Schema::new(db);
+
+    let stmt = schema.create_table_from_entity(student::Entity);
+    let sql = db.build(&stmt);
+    println!("sql print {}", sql.sql);
+    println!("-------------------------------------------------")
+  }
+}

packages/gotify-ws/src/model/ws.rs

@@ -1,7 +1,6 @@
-use diesel::Queryable;
 use serde::Deserialize;
 
-#[derive(Debug, Deserialize, Queryable)]
+#[derive(Debug, Deserialize, Clone, PartialEq)]
 pub struct WsMessage {
   id: u64,
   appid: u64,

packages/gotify-ws/src/utils/sql/sqlite/mod.rs

@@ -1,39 +1,8 @@
-mod sql_line;
-
-use crate::utils::sql::sqlite::sql_line::CREATE_TABLE;
-use diesel::RunQueryDsl;
-use diesel::r2d2::ConnectionManager;
-use diesel::sqlite::SqliteConnection;
-use log::warn;
-use r2d2::Pool;
-
-// #[derive(Debug)]
-pub struct SqliteDB {
-  pub connection_pool: Pool<ConnectionManager<SqliteConnection>>,
-}
-
-impl SqliteDB {
-  pub fn new(address: &str) -> Option<Self> {
-    let manager = ConnectionManager::<SqliteConnection>::new(address);
-    match Pool::builder().build(manager) {
-      Ok(pool) => Some(SqliteDB {
-        connection_pool: pool,
-      }),
-      Err(e) => {
-        warn!("Failed to create connection pool: {}", e);
-        None
-      }
-    }
-  }
-
-  pub fn create_table(&self) {
-    let mut conn = self
-      .connection_pool
-      .get()
-      .expect("无法连接，数据库连接池未初始化");
-
-    diesel::sql_query(CREATE_TABLE)
-      .execute(&mut conn)
-      .expect("创建表失败");
-  }
-}
+// use sea_orm::Database;
+//
+// const ADDR: &str = "db.sqlite";
+// static mut db = async || {
+//     Database::connect(ADDR).await
+// };
+//
+//

packages/gotify-ws/src/utils/sql/tests/sqlite.rs

@@ -1,32 +1,32 @@
-#[cfg(test)]
-mod sqlite_test {
-  use std::fs::remove_file;
-  use std::path::Path;
-
-  use crate::utils::sql::sqlite::SqliteDB;
-
-  #[test]
-  fn new_database() {
-    let file_path: &str = "test.sqlite";
-    SqliteDB::new(&file_path).unwrap();
-
-    let file = Path::new(&file_path);
-    assert!(file.exists());
-
-    if file.exists() {
-      remove_file(file).unwrap();
-    }
-  }
-
-  #[test]
-  fn create_table() {
-    let file_path: &str = "test.sqlite";
-    let db = SqliteDB::new(&file_path).unwrap();
-    db.create_table();
-    drop(db.connection_pool);
-
-    if Path::new(&file_path).exists() {
-      remove_file(file_path).unwrap();
-    }
-  }
-}
+// #[cfg(test)]
+// mod sqlite_test {
+//   use std::fs::remove_file;
+//   use std::path::Path;
+//
+//   use crate::utils::sql::sqlite::SqliteDB;
+//
+//   #[test]
+//   fn new_database() {
+//     let file_path: &str = "test.sqlite";
+//     SqliteDB::new(&file_path).unwrap();
+//
+//     let file = Path::new(&file_path);
+//     assert!(file.exists());
+//
+//     if file.exists() {
+//       remove_file(file).unwrap();
+//     }
+//   }
+//
+//   #[test]
+//   fn create_table() {
+//     let file_path: &str = "test.sqlite";
+//     let db = SqliteDB::new(&file_path).unwrap();
+//     db.create_table();
+//     drop(db.connection_pool);
+//
+//     if Path::new(&file_path).exists() {
+//       remove_file(file_path).unwrap();
+//     }
+//   }
+// }