feat: add new modules for service and openapi

Author: lazhenyi

Cargo.lock

@@ -14,7 +14,7 @@ members = [
     "crates/jz-migration",
     "crates/jz-model",
     "crates/jz-module",
-    "crates/jz-openapi",
+    "crates/jz-openapi", "crates/jz-service",
     "crates/jz-smart",
     "crates/jz-ssh",
     "crates/jz-stream",

Cargo.toml

@@ -46,4 +46,7 @@ workspace = true
 workspace = true
 
 [dependencies.jz-smart]
+workspace = true
+
+[dependencies.jz-openapi]
 workspace = true

crates/jz-api/Cargo.toml

@@ -59,6 +59,7 @@ impl Api {
                 .route("/", actix_web::web::get().to(|| async { "Hello World!" }))
                 .service(scope("/api").configure(v1::v1_route))
                 .service(scope("/git").configure(jz_smart::git_router))
+                .service(scope("/openapi").configure(jz_openapi::openapi_router))
         })
         .bind(format!("0.0.0.0:{}", PROTS.to_string()))
         .context("Failed to apply actix settings")?

crates/jz-api/src/lib.rs

@@ -1,7 +1,27 @@
+use sea_orm::*;
+use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use uuid::Uuid;
+use jz_model::repository;
 use crate::AppModule;
 
+#[derive(Deserialize,Serialize)]
+pub struct RepositoryListParam {
+    pub r#type: String,
+    pub limit: Option<i64>,
+    pub offset: Option<i64>,
+}
+#[derive(Deserialize,Serialize)]
+pub struct RepositoryListResult {
+    creator: String, // owner name
+    description: Option<String>,
+    id: Uuid,
+    image: Option<String>,
+    runs: Option<i32>,
+    size: Option<String>,
+    r#type: String,
+}
+
 impl AppModule {
     pub async fn repo_list_info(&self,ops_uid: Option<Uuid>, owner_name: String) -> anyhow::Result<Vec<Value>> {
         let repos = self.repo_info_by_owner(owner_name).await?;
@@ -35,4 +55,57 @@ impl AppModule {
         }
         Ok(result)
     }
+    pub async fn repo_list(&self, parma: RepositoryListParam) -> anyhow::Result<serde_json::Value> {
+        let rtype = if parma.r#type == "all" {
+            None
+        } else {
+            let rf = parma.r#type.to_lowercase();
+            if rf == "code" {
+                Some("Code".to_string())
+            }else if rf == "data" {
+                Some("Data".to_string())
+            }else if rf == "model" {
+                Some("Model".to_string())
+            }else { 
+                return Err(anyhow::anyhow!("invalid rtype"));
+            }
+        };
+        let mut condition = Condition::all()
+            .add(repository::Column::IsPrivate.eq(false));
+        if let Some(ref rtype) = rtype {
+            condition = condition.add(repository::Column::Rtype.eq(rtype));
+        };
+        let repos = repository::Entity::find()
+            .filter(condition)
+            .order_by_desc(repository::Column::CreatedAt)
+            .limit(parma.limit.unwrap_or(20) as u64)
+            .offset(parma.offset.unwrap_or(0) as u64)
+            .all(&self.read)
+            .await?;
+        let mut result: Vec<RepositoryListResult> = Vec::new();
+        for i in repos {
+            result.push(RepositoryListResult {
+                creator: i.owner_name,
+                description: i.description,
+                id: i.uid,
+                image: None,
+                runs: None,
+                size: None,
+                r#type: i.rtype,
+            });
+        }
+        let total = repository::Entity::find()
+            .filter(repository::Column::Rtype.eq(parma.r#type))
+            .filter(repository::Column::IsPrivate.eq(false))
+            .count(&self.read)
+            .await?;
+        Ok(json!({
+            "data": result,
+            "limit": parma.limit,
+            "offset": parma.offset,
+            "total": total,
+            "type": rtype,
+        }))
+        
+    }
 }

crates/jz-module/src/repo/list.rs

@@ -132,4 +132,12 @@ impl AppModule {
             .await
             .map_err(|e| anyhow::anyhow!("{}", e))?)
     }
+    pub async fn token_find(&self, token: String) -> anyhow::Result<token::Model> {
+        token::Entity::find()
+            .filter(token::Column::Token.eq(token))
+            .one(&self.read)
+            .await
+            .map_err(|e| anyhow::anyhow!("{}", e))?
+            .ok_or(anyhow::anyhow!("token not found"))
+    }
 }

crates/jz-module/src/users/token.rs

@@ -12,3 +12,38 @@ description.workspace = true
 homepage.workspace = true
 
 [dependencies]
+actix-web = { version = "4", features = ["cookies"] }
+actix-session = { version = "0.10.1", features = ["redis-pool","redis-session"] }
+actix-files = { version = "0.6.6", features = ["tokio-uring"] }
+actix-multipart = { version = "0.7.2", features = ["derive"] }
+actix-web-lab = { version = "0.24.1", features = ["derive"] }
+actix-settings = { version = "0.8.0", features = [] }
+actix-web-httpauth = { version = "0.8.2", features = [] }
+
+tokio = { version = "1", features = ["full"] }
+
+serde = { version = "1", features = ["derive"] }
+serde_json = { version = "1", features = ["raw_value"] }
+uuid = { version = "1"}
+chrono = { version = "0.4"}
+
+anyhow = { version = "1", features = ["backtrace"] }
+
+captcha-rs = { version = "0.2.11", features = [] }
+log = "0.4.26"
+lazy_static = "1.5.0"
+sha256 = { version = "1.6.0", features = [] }
+[dependencies.jz-module]
+workspace = true
+
+[dependencies.jz-model]
+workspace = true
+
+[dependencies.jz-git]
+workspace = true
+
+[dependencies.jz-dragonfly]
+workspace = true
+
+[dependencies.jz-smart]
+workspace = true

crates/jz-openapi/Cargo.toml

@@ -1,14 +1,14 @@
-pub fn add(left: u64, right: u64) -> u64 {
-    left + right
-}
+use actix_web::web::{get, scope};
+use crate::repo::repo_list;
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+pub mod repo;
+pub mod bare;
 
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
-}
+pub fn openapi_router(cfg: &mut actix_web::web::ServiceConfig) {
+    cfg
+        .service(
+            scope("/repo")
+                .route("",get().to(repo_list))
+        )
+    ;
+}

crates/jz-openapi/src/bare.rs

@@ -0,0 +1,29 @@
+use actix_web::web::Data;
+use actix_web_httpauth::extractors::bearer::BearerAuth;
+use jz_module::AppModule;
+use jz_module::repo::list::RepositoryListParam;
+
+pub async fn repo_list(
+    service: Data<AppModule>,
+    query: actix_web::web::Query<RepositoryListParam>,
+    credentials: Option<BearerAuth>,
+)
+    -> actix_web::Result<actix_web::HttpResponse>
+{
+    let Some(credentials) = credentials else {
+        return Ok(actix_web::HttpResponse::Unauthorized().body("token invalid"))
+    };
+    let Ok(token) = service.token_find(credentials.token().to_string()).await else {
+        return Ok(actix_web::HttpResponse::Unauthorized().body("token invalid"))
+    };
+    let _access = token.access;
+    let result = service.repo_list(query.into_inner()).await;
+    match result {
+        Ok(data) => {
+            Ok(actix_web::HttpResponse::Ok().json(data))
+        }
+        Err(err) => {
+            Ok(actix_web::HttpResponse::InternalServerError().body(err.to_string()))
+        }
+    }
+}

crates/jz-openapi/src/lib.rs

@@ -0,0 +1,39 @@
+[package]
+name = "jz-service"
+version = "0.1.0"
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+documentation.workspace = true
+readme.workspace = true
+keywords.workspace = true
+categories.workspace = true
+description.workspace = true
+homepage.workspace = true
+
+[dependencies]
+jz-model = { workspace = true }
+serde = { version = "1", features = ["derive"] }
+sea-orm = { version = "1", features = ["sqlx-all", "runtime-tokio"] }
+uuid = { version = "1", features = ["v7","v4"] }
+chrono = { version = "0.4", features = ["clock","serde"] }
+tokio = { version = "1", features = ["full"] }
+dotenv = { version = "0.15.0" ,features = [] }
+anyhow = { version = "1", features = ["backtrace"] }
+sha256 = { version = "1", features = ["tokio"] }
+serde_json = "1.0.140"
+log = "0.4.26"
+rand = "0.8.5"
+
+
+[dependencies.jz-git]
+workspace = true
+
+[dependencies.jz-jobs]
+workspace = true
+
+[dependencies.jz-email]
+workspace = true
+
+[dependencies.jz-dragonfly]
+workspace = true

crates/jz-openapi/src/repo.rs

@@ -0,0 +1,49 @@
+use std::any::Any;
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug, Clone)]
+pub struct ContainerIOC {
+    inner: Arc<Mutex<Vec<Box<dyn Send + Sync + 'static + Any>>>>,
+}
+
+impl ContainerIOC {
+    pub async fn init() -> ContainerIOC {
+        Self {
+            inner: Arc::new(Mutex::new(vec![])),
+        }
+    }
+
+    pub async fn take<T: 'static>(&self) -> Option<Arc<T>> {
+        let inner = self.inner.lock().unwrap();
+        for item in inner.iter() {
+            if let Some(arc_item) = item.downcast_ref::<Arc<T>>() {
+                return Some(arc_item.clone());
+            }
+        }
+        drop(inner);
+        None
+    }
+
+    pub fn inject<T: 'static + Send + Sync>(&self, item: T) {
+        let mut inner = self.inner.lock().unwrap();
+        inner.push(Box::new(Arc::new(item)));
+        drop(inner);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_ioc() {
+        let ioc = ContainerIOC::init().await;
+        ioc.inject("str".to_string());
+        ioc.inject(2_i32);
+        assert_eq!(
+            ioc.take::<String>().await,
+            Some(Arc::new("str".to_string()))
+        );
+        assert_eq!(ioc.take::<i32>().await, Some(Arc::new(2_i32)));
+    }
+}