feat: serialization for unexpected String / u64 type of timestamp

Author: 7086cmd

Cargo.lock

@@ -33,6 +33,7 @@ tower = "0.4.13"
 tower-http = "0.5.2"
 tracing-subscriber = { version = "0.3.18", features = ["tracing", "time", "serde", "serde_json", "json", "regex"] }
 uuid = "1.8.0"
+zerocopy = "0.7.32"
 
 [profile.release]
 lto = true

Cargo.toml

@@ -0,0 +1 @@
+d765fcb8ae87f29c4de1645728ff57e7668e4c6be695fdf38d5cdd90a23f6456

aes256.key

@@ -1,5 +1,8 @@
+use std::fmt;
+
 use bson::oid::ObjectId;
-use serde::{Deserialize, Serialize};
+use chrono::DateTime;
+use serde::{de::{self, Visitor}, Deserialize, Deserializer, Serialize};
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
 #[serde(rename_all = "kebab-case")]
@@ -36,6 +39,17 @@ pub enum ActivityMode {
     SocialPractice,
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
+#[serde(rename_all = "kebab-case")]
+pub enum SpecialActivityCategory {
+    Prize,
+    Import,
+    Club,
+    Deduction,
+    Other,
+}
+
+
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 pub struct ActivityMember {
     pub _id: String, // ObjectId
@@ -56,7 +70,9 @@ pub struct ActivityMemberHistory {
     pub action: ActivityMemberStatus,
 }
 
+
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+#[serde(rename_all = "camelCase")]
 pub struct Activity {
     #[serde(rename = "_id")]
     pub _id: ObjectId,
@@ -65,10 +81,48 @@ pub struct Activity {
     pub name: String,
     pub description: Option<String>,
     pub duration: Option<f64>,
-    pub date: u128,
-    pub created_at: u128,
-    pub updated_at: u128,
+    #[serde(deserialize_with = "datetime_or_u64")]
+    pub date: u64,
+    #[serde(deserialize_with = "datetime_or_u64")]
+    pub created_at: u64,
+    #[serde(deserialize_with = "datetime_or_u64")]
+    pub updated_at: u64,
     pub creator: ObjectId, // ObjectId
     pub status: ActivityStatus,
     pub members: Option<Vec<ActivityMember>>,
+    pub location: Option<String>,
+    pub category: Option<SpecialActivityCategory>,
+}
+
+fn datetime_or_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    struct DateTimeOrU64;
+
+    impl<'de> Visitor<'de> for DateTimeOrU64 {
+        type Value = u64;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a UNIX timestamp as a u64 or a datetime string")
+        }
+
+        fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(value)
+        }
+
+        fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            DateTime::parse_from_rfc3339(value)
+                .map_err(de::Error::custom)
+                .and_then(|dt| Ok(dt.timestamp() as u64))
+        }
+    }
+
+    deserializer.deserialize_any(DateTimeOrU64)
 }

src/models/activities.rs

@@ -20,9 +20,9 @@ use tokio::sync::Mutex;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct ReadActivityQuery {
-    page: Option<u32>,
-    perpage: Option<u32>,
-    query: Option<String>,
+    pub page: Option<u32>,
+    pub perpage: Option<u32>,
+    pub query: Option<String>,
 }
 
 pub async fn read_all(
@@ -63,10 +63,19 @@ pub async fn read_all(
     loop {
         let doc_result = cursor.try_next().await;
         if let Ok(Some(document)) = doc_result {
-            if let Ok(activity) = from_document::<Activity>(document) {
-                activities.push(activity);
-            } else {
-                break;
+            match from_document::<Activity>(document) {
+                Ok(activity) => activities.push(activity),
+                Err(e) => {
+                    let response: ErrorResponse = ErrorResponse {
+                        status: ResponseStatus::Error,
+                        code: 500,
+                        message: "Failed to read activity: ".to_string() + &e.to_string(),
+                    }
+                    .into();
+                    println!("{:?}", response);
+                    let response = serde_json::to_string(&response).unwrap();
+                    return (StatusCode::INTERNAL_SERVER_ERROR, Json(response));
+                }
             }
         } else {
             break;

src/routers/activities/read.rs

@@ -0,0 +1,41 @@
+#[cfg(test)]
+mod tests {
+    use crate::{
+        database,
+        models::groups::GroupPermission,
+        routers::activities::{self, read::ReadActivityQuery},
+        utils::jwt::{TokenType, UserData},
+    };
+    use axum::{extract::Query, response::IntoResponse, Extension};
+    use bson::oid::ObjectId;
+    use std::sync::Arc;
+    use tokio::sync::Mutex;
+    #[tokio::test]
+    async fn get_activities() {
+        let id = ObjectId::new().to_hex();
+        let token = UserData {
+            id: id.clone(),
+            perms: vec![GroupPermission::Student, GroupPermission::Admin],
+            term: TokenType::LongTerm,
+        };
+        let client = database::create_client().await;
+        if let Err(_) = client {
+            assert!(false);
+        }
+        let client = client.unwrap();
+        let extension = Arc::new(Mutex::new(client));
+        let extension = Extension(extension);
+        let result = activities::read::read_all(
+            extension,
+            token,
+            Query(ReadActivityQuery {
+                page: Some(1),
+                perpage: Some(10),
+                query: Some("".to_string()),
+            }),
+        )
+        .await;
+        let result = result.into_response();
+        assert!(result.status().is_success());
+    }
+}

src/tests/apis/activity.rs

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

src/tests/apis/auth.rs

@@ -1,6 +1,10 @@
 #[cfg(test)]
 mod tests {
     use std::time::{SystemTime, UNIX_EPOCH};
+    use bson::oid::ObjectId;
+
+    use crate::models::groups::GroupPermission;
+    use crate::utils::jwt::{generate_token, verify_token, TokenType};
     use crate::utils::rsa::{generate_keypair, encrypt, decrypt};
     use crate::routers::auth::LoginCredentials;
     #[tokio::test]
@@ -28,14 +32,31 @@ mod tests {
         let credential = credential.unwrap();
         let (private_key, public_key) = generate_keypair().await;
         let encrypted = encrypt(&public_key, credential.as_str());
-        println!("Encrypted: {:?}", &encrypted);
         let decrypted = decrypt(&private_key, &encrypted).await;
-        println!("Decrypted: {:?}", &decrypted);
         let decrypted = serde_json::from_str(&decrypted.as_str());
         if let Err(_) = decrypted {
             assert!(false);
         }
         let decrypted = decrypted.unwrap();
+        println!("Decrypted: {:#?}", &decrypted);
         assert_eq!(payload, decrypted);
     }
+    #[tokio::test]
+    async fn token_validation() {
+        let sub = ObjectId::new().to_hex();
+        let perms = vec![
+            GroupPermission::Student,
+            GroupPermission::Admin
+        ];
+        let token = generate_token(sub.as_str(), TokenType::LongTerm, perms.clone());
+        let token = token.as_str();
+        let result = verify_token(token.to_string());
+        if let Err(_) = result {
+            assert!(false);
+        }
+        let result = result.unwrap();
+        assert_eq!(result.sub, sub);
+        assert_eq!(result.perms, perms);
+        assert_eq!(result.term, TokenType::LongTerm);
+    }
 }

src/tests/apis/mod.rs

@@ -1 +1,2 @@
 mod auth;
+mod apis;