feat: add support for i64 type when serializing timestamp

Author: 7086cmd

Cargo.lock

@@ -14,6 +14,7 @@ b2-client = { version = "0.1.3", features = ["with_surf"] }
 base64 = "0.22.0"
 bcrypt = "0.15.1"
 bson = "2.10.0"
+bytes = { version = "1.6.0", features = ["serde"] }
 chrono = { version = "0.4.38", features = ["serde"] }
 futures = "0.3.30"
 hex = { version = "0.4.3", features = ["serde"] }
@@ -40,9 +41,3 @@ lto = true
 strip = true
 opt-level = 3
 codegen-units = 1
-
-[target.x86_64-unknown-linux-gnu]
-linker = "x86_64-linux-musl-gcc"
-
-[target.x86_64-pc-windows-gnu]
-linker = "x86_64-w64-mingw32-gcc"

Cargo.toml

@@ -1,22 +1,22 @@
 extern crate chrono;
 mod database;
+mod launch;
 mod models;
 mod routers;
-mod utils;
-mod launch;
 mod tests;
+mod utils;
 use axum::{
-    routing::{delete, get, post},
+    routing::{delete, get, post, put},
     Extension, Router,
 };
-use std::sync::Arc;
-use tokio::sync::Mutex;
-use serde_json::Value;
 use launch::{generate_aes_key, generate_rsa_keypair};
+use serde_json::Value;
 use socketioxide::{
     extract::{AckSender, Bin, Data, SocketRef},
     SocketIo,
 };
+use std::sync::Arc;
+use tokio::sync::Mutex;
 
 fn on_connect(socket: SocketRef, Data(data): Data<Value>) {
     socket.emit("auth", data).ok();
@@ -58,10 +58,24 @@ async fn main() {
 
     // Set up the router
     let app = Router::new()
-        .route("/activity/:id", get(routers::activities::read::read_one))
-        .route("/activity/:id", delete(routers::activities::remove::remove_activity))
         .route("/activity/", get(routers::activities::read::read_all))
-        .route("/activity/", post(routers::activities::insert::insert_activity))
+        .route(
+            "/activity/",
+            post(routers::activities::insert::insert_activity),
+        )
+        .route("/activity/:id", get(routers::activities::read::read_one))
+        .route(
+            "/activity/:id/name",
+            put(routers::activities::update::update_activity_name),
+        )
+        .route(
+            "/activity/:id/description",
+            put(routers::activities::update::update_activity_description),
+        )
+        .route(
+            "/activity/:id",
+            delete(routers::activities::remove::remove_activity),
+        )
         .route("/user/auth", post(routers::auth::login))
         .layer(Extension(shared_client.clone()));
 

src/main.rs

@@ -94,7 +94,7 @@ pub struct Activity {
     pub category: Option<SpecialActivityCategory>,
 }
 
-fn datetime_or_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
+pub fn datetime_or_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
 where
     D: Deserializer<'de>,
 {
@@ -114,6 +114,13 @@ where
             Ok(value)
         }
 
+        fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(value as u64)
+        }
+
         fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
         where
             E: de::Error,

src/models/activities.rs

@@ -1,5 +1,6 @@
 use bson::oid::ObjectId;
 use serde::{Deserialize, Serialize};
+use crate::models::activities::datetime_or_u64;
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
 #[serde(rename_all = "kebab-case")]
@@ -13,13 +14,15 @@ pub enum NotificationType {
 pub struct Notification {
     pub _id: ObjectId,
     pub title: String,
-    pub content: String,
-    pub time: u128,
+    pub content: Option<String>,
+    #[serde(deserialize_with = "datetime_or_u64")]
+    pub time: u64,
     #[serde(rename = "type")]
     pub notification_type: NotificationType,
     pub publisher: ObjectId,
     pub receivers: Option<Vec<ObjectId>>,
     pub anoymous: bool,
     pub global: bool,
-    pub expire: u128,
+    #[serde(deserialize_with = "datetime_or_u64")]
+    pub expire: u64,
 }

src/models/notifications.rs

@@ -2,7 +2,7 @@ use crate::{models::{
     activities::{Activity, ActivityStatus, ActivityType}, groups::GroupPermission, response::{ErrorResponse, ResponseStatus, SuccessResponse}
 }, utils::jwt::UserData};
 use axum::{
-    extract::Extension,
+    extract::{Extension, Path, Query},
     http::StatusCode,
     response::{IntoResponse, Json},
 };
@@ -14,8 +14,10 @@ use tokio::sync::Mutex;
 pub async fn insert_activity(
     Extension(db): Extension<Arc<Mutex<Database>>>,
     user: UserData,
+    Query(renew_object_id): Query<Option<bool>>,
     Json(mut activity): Json<Activity>,
 ) -> impl IntoResponse {
+    let renew_object_id = renew_object_id.unwrap_or(true);
     let db = db.lock().await;
     let collection = db.collection("activities");
     if user.perms.contains(&GroupPermission::Admin) {
@@ -55,7 +57,9 @@ pub async fn insert_activity(
     }
     // Remove the _id field if it exists
     let mut activity = activity;
-    activity._id = ObjectId::new();
+    if renew_object_id {
+        activity._id = ObjectId::new();
+    }
     let activity = bson::to_document(&activity);
     if let Ok(activity) = activity {
         if let Ok(_) = collection.insert_one(activity, None).await {

src/routers/activities/insert.rs

@@ -107,6 +107,7 @@ pub async fn read_all(
 
 pub async fn read_one(
     Extension(client): Extension<Arc<Mutex<Database>>>,
+    _: UserData,
     Path(id): Path<String>,
 ) -> impl IntoResponse {
     println!("ID: {:?}", id);
@@ -126,6 +127,7 @@ pub async fn read_one(
     let filter = doc! {"_id": id};
     let result = collection.find_one(filter, None).await;
     if let Err(e) = result {
+        println!("Failed to read activity: {:?}", e);
         let response = ErrorResponse {
             status: ResponseStatus::Error,
             code: 500,
@@ -137,6 +139,7 @@ pub async fn read_one(
     let result: Option<Activity> = result.unwrap();
     match result {
         Some(document) => {
+            println!("{:?}", document);
             let response: SuccessResponse<Activity, ()> = SuccessResponse {
                 status: ResponseStatus::Success,
                 code: 200,
@@ -147,6 +150,7 @@ pub async fn read_one(
             (StatusCode::OK, Json(response))
         }
         None => {
+            println!("Activity not found");
             let response = ErrorResponse {
                 status: ResponseStatus::Error,
                 code: 404,

src/routers/activities/read.rs

@@ -0,0 +1,170 @@
+use crate::{models::{
+    activities::{Activity, ActivityStatus}, groups::GroupPermission, response::{ErrorResponse, ResponseStatus, SuccessResponse}
+}, utils::jwt::UserData};
+use axum::{
+    extract::{Extension, Path},
+    http::StatusCode,
+    response::{IntoResponse, Json},
+};
+use bson::{doc, oid::ObjectId};
+use mongodb::{Database, Collection};
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
+pub struct UpdateActivityName {
+    pub name: String,
+}
+
+pub async fn update_activity_name(
+    Extension(db): Extension<Arc<Mutex<Database>>>,
+    user: UserData,
+    Path(id): Path<String>,
+    Json(data): Json<UpdateActivityName>,
+) -> impl IntoResponse {
+    let db = db.lock().await;
+    let collection: Collection<Activity> = db.collection("activities");
+    let id = ObjectId::parse_str(&id);
+    if let Err(_) = id {
+        let response = ErrorResponse {
+            status: ResponseStatus::Error,
+            code: 400,
+            message: "Invalid activity id".to_string(),
+        };
+        let response = serde_json::to_string(&response).unwrap();
+        return (StatusCode::BAD_REQUEST, Json(response));
+    }
+    let id = id.unwrap();
+    let activity = collection.find_one(doc! {"_id": id}, None).await;
+    if let Err(e) = activity {
+        let response = ErrorResponse {
+            status: ResponseStatus::Error,
+            code: 500,
+            message: "Failed to find activity: ".to_string() + &e.to_string(),
+        };
+        let response = serde_json::to_string(&response).unwrap();
+        return (StatusCode::INTERNAL_SERVER_ERROR, Json(response));
+    }
+    let activity = activity.unwrap();
+    if let None = activity {
+        let response = ErrorResponse {
+            status: ResponseStatus::Error,
+            code: 404,
+            message: "Activity not found".to_string(),
+        };
+        let response = serde_json::to_string(&response).unwrap();
+        return (StatusCode::NOT_FOUND, Json(response));
+    }
+    let activity = activity.unwrap();
+    let creator = activity.creator;
+    if user.perms.contains(&GroupPermission::Admin) || user.perms.contains(&GroupPermission::Department) || id == creator {
+        let result = collection.update_one(doc! {"_id": id}, doc! {"$set": {"name": data.name}}, None).await;
+        if let Err(e) = result {
+            let response = ErrorResponse {
+                status: ResponseStatus::Error,
+                code: 500,
+                message: "Failed to update activity: ".to_string() + &e.to_string(),
+            };
+            let response = serde_json::to_string(&response).unwrap();
+            return (StatusCode::INTERNAL_SERVER_ERROR, Json(response));
+        }
+        let response: SuccessResponse<Vec<Activity>, ()> = SuccessResponse {
+            status: ResponseStatus::Success,
+            code: 200,
+            data: vec![],
+            metadata: None,
+        };
+        let response = serde_json::to_string(&response).unwrap();
+        return (StatusCode::OK, Json(response));
+    } else {
+        let response = ErrorResponse {
+            status: ResponseStatus::Error,
+            code: 403,
+            message: "Permission denied".to_string(),
+        };
+        let response = serde_json::to_string(&response).unwrap();
+        return (StatusCode::FORBIDDEN, Json(response));
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
+pub struct UpdateActivityDescription {
+    pub description: String,
+}
+
+pub async fn update_activity_description(
+    Extension(db): Extension<Arc<Mutex<Database>>>,
+    user: UserData,
+    Path(id): Path<String>,
+    Json(data): Json<UpdateActivityDescription>,
+) -> impl IntoResponse {
+    let db = db.lock().await;
+    let collection: Collection<Activity> = db.collection("activities");
+    let id = ObjectId::parse_str(&id);
+    if let Err(_) = id {
+        let response = ErrorResponse {
+            status: ResponseStatus::Error,
+            code: 400,
+            message: "Invalid activity id".to_string(),
+        };
+        let response = serde_json::to_string(&response).unwrap();
+        return (StatusCode::BAD_REQUEST, Json(response));
+    }
+    let id = id.unwrap();
+    let activity = collection.find_one(doc! {"_id": id}, None).await;
+    if let Err(e) = activity {
+        let response = ErrorResponse {
+            status: ResponseStatus::Error,
+            code: 500,
+            message: "Failed to find activity: ".to_string() + &e.to_string(),
+        };
+        let response = serde_json::to_string(&response).unwrap();
+        return (StatusCode::INTERNAL_SERVER_ERROR, Json(response));
+    }
+    let activity = activity.unwrap();
+    if let None = activity {
+        let response = ErrorResponse {
+            status: ResponseStatus::Error,
+            code: 404,
+            message: "Activity not found".to_string(),
+        };
+        let response = serde_json::to_string(&response).unwrap();
+        return (StatusCode::NOT_FOUND, Json(response));
+    }
+    let activity = activity.unwrap();
+    let creator = activity.creator;
+    if user.perms.contains(&GroupPermission::Admin) || user.perms.contains(&GroupPermission::Department) || id == creator {
+        let result = collection.update_one(doc! {"_id": id}, doc! {"$set": {"description": data.description}}, None).await;
+        if let Err(e) = result {
+            let response = ErrorResponse {
+                status: ResponseStatus::Error,
+                code: 500,
+                message: "Failed to update activity: ".to_string() + &e.to_string(),
+            };
+            let response = serde_json::to_string(&response).unwrap();
+            return (StatusCode::INTERNAL_SERVER_ERROR, Json(response));
+        }
+        let response: SuccessResponse<Vec<Activity>, ()> = SuccessResponse {
+            status: ResponseStatus::Success,
+            code: 200,
+            data: vec![],
+            metadata: None,
+        };
+        let response = serde_json::to_string(&response).unwrap();
+        return (StatusCode::OK, Json(response));
+    } else {
+        let response = ErrorResponse {
+            status: ResponseStatus::Error,
+            code: 403,
+            message: "Permission denied".to_string(),
+        };
+        let response = serde_json::to_string(&response).unwrap();
+        return (StatusCode::FORBIDDEN, Json(response));
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
+pub struct UpdateActivityStatus {
+    status: ActivityStatus,
+}