feat: add pyo3 for excel transforming

Author: 7086cmd

.github/workflows/test.yml

@@ -13,10 +13,40 @@ jobs:
   build:
 
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.11]
 
     steps:
     - uses: actions/checkout@v4
 
+    # Set up Python environment
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Create and activate virtual environment
+      run: |
+        python -m venv venv
+        source venv/bin/activate
+
+    # Install Python dependencies (if any)
+    - name: Install Python dependencies
+      run: |
+        python -m pip install --upgrade pip
+        # Add any dependencies here, for example:
+        pip install maturin pandas
+
+    # Set up Rust environment
+    - name: Set up Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: stable
+        components: rustfmt, clippy
+        override: true
+
     - name: Run tests
       run: cargo test
       env:

.gitignore

@@ -20,3 +20,4 @@ private.pem
 public.pem
 config.json
 aes256.key
+init.sh

Cargo.lock

@@ -29,6 +29,7 @@ mongodb = { version = "2.8.2", features = ["async-std"] }
 once_cell = "1.19.0"
 pem = { version = "3.0.4", features = ["serde"] }
 polars = "0.39.2"
+pyo3 = { version = "0.16", features = ["auto-initialize"] }
 rand = "0.8.5"
 reqwest = "0.12.3"
 rsa = "0.9.6"

Cargo.toml

@@ -13,3 +13,11 @@ Technologies used:
 - `axum`: Web framework
 - `tokio`: Async runtime
 - `mongodb`: Database
+
+> Remember to export the Python DLIB path before running the project.
+
+For example:
+
+```bash
+export DYLD_LIBRARY_PATH=/opt/anaconda3/envs/zvms/lib:$DYLD_LIBRARY_PATH
+```

README.md

@@ -94,6 +94,14 @@ async fn main() {
             put(routers::activities::members::update::update_member_impression),
         )
         .route("/user/auth", post(routers::auth::login))
+        .route(
+            "/user/:user_id/activity",
+            get(routers::users::activity::read_user_activities),
+        )
+        .route(
+            "/user/:user_id/time",
+            get(routers::users::time::calculate_user_activity_time),
+        )
         .layer(Extension(shared_client.clone()));
 
     // Run the server

src/main.rs

@@ -12,7 +12,7 @@ pub enum ResponseStatus {
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
 pub struct SuccessResponse<T, M> {
     pub status: ResponseStatus,
-    pub code: i32,
+    pub code: u16,
     pub data: T,
     pub metadata: Option<M>,
 }

src/models/response.rs

@@ -1,2 +1,3 @@
-pub mod activities;
-pub mod auth;
+pub mod activities;
+pub mod auth;
+pub mod users;

src/routers/mod.rs

@@ -0,0 +1,154 @@
+use crate::{
+    models::{
+        activities::Activity,
+        groups::GroupPermission,
+        response::{create_error, MetadataSize, ResponseStatus, SuccessResponse},
+    },
+    routers::activities::read::ReadActivityQuery,
+    utils::{groups::same_class::validate_same_class, jwt::UserData},
+};
+use axum::{
+    extract::{Extension, Path, Query},
+    http::StatusCode,
+    response::{IntoResponse, Json},
+};
+use bson::{doc, from_document, oid::ObjectId};
+use futures::stream::TryStreamExt;
+use mongodb::{Collection, Database};
+use std::{str::FromStr, sync::Arc};
+use tokio::sync::Mutex;
+
+pub async fn read_user_activities(
+    Extension(db): Extension<Arc<Mutex<Database>>>,
+    user: UserData,
+    Query(ReadActivityQuery {
+        page,
+        perpage,
+        query,
+    }): Query<ReadActivityQuery>,
+    Path(user_id): Path<String>,
+) -> impl IntoResponse {
+    let page = page.unwrap_or(1);
+    let perpage = perpage.unwrap_or(10);
+    let query = query.unwrap_or("".to_string());
+    let user_id = ObjectId::from_str(&user_id);
+    if let Err(_) = user_id {
+        return create_error(StatusCode::BAD_REQUEST, "Invalid user ID".to_string());
+    }
+    let user_id = user_id.unwrap();
+    let is_same_class = validate_same_class(
+        db.clone(),
+        ObjectId::from_str(user.id.as_str()).unwrap(),
+        user_id.clone(),
+    )
+    .await;
+    let db = db.lock().await;
+    let collection: Collection<Activity> = db.collection("activities");
+    if user.perms.contains(&GroupPermission::Admin)
+        || user.perms.contains(&GroupPermission::Auditor)
+        || user.perms.contains(&GroupPermission::Department)
+    {
+    } else if user.perms.contains(&GroupPermission::Secretary) {
+        if let Ok(true) = is_same_class {
+        } else {
+            return create_error(StatusCode::FORBIDDEN, "Permission denied".to_string());
+        }
+    } else if user.id != user_id.clone().to_hex() {
+        return create_error(StatusCode::FORBIDDEN, "Permission denied".to_string());
+    }
+    let counts = collection
+        .count_documents(
+            doc! {
+                "_id": user_id
+            },
+            None,
+        )
+        .await;
+    if let Err(_) = counts {
+        return create_error(
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "Failed to count documents".to_string(),
+        );
+    }
+    let counts = counts.unwrap();
+    let pipeline = [
+        doc! {
+            "$match": {
+                "user": user_id
+            }
+        },
+        doc! {
+            "$match": {
+                "$or": [
+                    {
+                        "name": {
+                            "$regex": &query,
+                            "$options": "i"
+                        }
+                    },
+                ]
+            }
+        },
+        doc! {
+            "$project": {
+                // Only display `members._id == user_id` for `members` array
+                "members": {
+                    "$filter": {
+                        "input": "$members",
+                        "as": "member",
+                        "cond": {
+                            "$eq": [
+                                "$$member._id",
+                                user_id
+                            ]
+                        }
+                    }
+                },
+            }
+        },
+        doc! {
+            "$project": {
+                "members": 1,
+                "name": 1,
+                "description": 1,
+                "start": 1,
+                "end": 1,
+                "created_at": 1,
+                "updated_at": 1,
+                "deleted_at": 1,
+            }
+        },
+        doc! {
+            "$sort": {
+                "_id": -1
+            }
+        },
+        doc! {
+            "$skip": (page - 1) * perpage
+        },
+        doc! {
+            "$limit": perpage
+        },
+    ];
+    let cursor = collection.aggregate(pipeline, None).await;
+    if let Err(_) = cursor {
+        return create_error(
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "Failed to fetch documents".to_string(),
+        );
+    }
+    let mut cursor = cursor.unwrap();
+    let mut activities: Vec<Activity> = Vec::new();
+    let metadata = MetadataSize { size: counts };
+    while let Some(activity) = cursor.try_next().await.unwrap() {
+        activities.push(from_document(activity).unwrap());
+    }
+    let response = SuccessResponse {
+        status: ResponseStatus::Success,
+        code: 200,
+        data: activities,
+        metadata: Some(metadata),
+    };
+    let response = serde_json::to_string(&response).unwrap();
+    (StatusCode::OK, Json(response))
+}

src/routers/users/activity.rs

@@ -0,0 +1,2 @@
+pub mod activity;
+pub mod time;