feat: complete activity reading projections

7086cmd · 7086cmd · commit d840274e4b3c · 2024-05-01T17:02:06.000+08:00
diff --git a/aes256.key b/aes256.key
@@ -1 +1 @@
-d765fcb8ae87f29c4de1645728ff57e7668e4c6be695fdf38d5cdd90a23f6456
+a3f3447d8dd79340400452d75fcf6c7d89134b65bb1c217f334773c79712b8e3
diff --git a/src/models/activities.rs b/src/models/activities.rs
@@ -1,8 +1,11 @@
-use std::fmt;
-
+use crate::utils::config::load_config_sync;
 use bson::oid::ObjectId;
-use chrono::DateTime;
-use serde::{de::{self, Visitor}, Deserialize, Deserializer, Serialize};
+use chrono::{DateTime, NaiveDateTime, TimeZone};
+use serde::{
+    de::{self, Visitor},
+    Deserialize, Deserializer, Serialize, Serializer,
+};
+use std::{fmt, str::FromStr};
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
 #[serde(rename_all = "kebab-case")]
@@ -49,10 +52,10 @@ pub enum SpecialActivityCategory {
     Other,
 }
 
-
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 pub struct ActivityMember {
-    pub _id: String, // ObjectId
+    #[serde(serialize_with = "objectid_to_string", deserialize_with = "string_to_objectid")]
+    pub _id: ObjectId, // ObjectId
     pub status: ActivityMemberStatus,
     pub impression: Option<String>,
     pub duration: f64,
@@ -66,10 +69,53 @@ pub struct ActivityMemberHistory {
     pub impression: String,
     pub duration: f64,
     pub time: String,
-    pub actioner: String, // ObjectId
+    #[serde(serialize_with = "objectid_to_string", deserialize_with = "string_to_objectid")]
+    pub actioner: ObjectId, // ObjectId
     pub action: ActivityMemberStatus,
 }
 
+pub fn objectid_to_string<S>(value: &ObjectId, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    serializer.serialize_str(&value.to_hex())
+}
+
+pub fn string_to_objectid<'de, D>(deserializer: D) -> Result<ObjectId, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    struct ObjectIdOrStringVisitor;
+
+    impl<'de> Visitor<'de> for ObjectIdOrStringVisitor {
+        type Value = ObjectId;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("string or ObjectId")
+        }
+
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            ObjectId::from_str(v).map_err(de::Error::custom)
+        }
+
+        fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+        where
+            M: de::MapAccess<'de>,
+        {
+            if let Some((key, value)) = map.next_entry::<String, String>()? {
+                if key == "$oid" {
+                    return self.visit_str(&value);
+                }
+            }
+            Err(de::Error::custom("expected a map with a key of '$oid'"))
+        }
+    }
+
+    deserializer.deserialize_any(ObjectIdOrStringVisitor)
+}
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 #[serde(rename_all = "camelCase")]
@@ -80,13 +126,13 @@ pub struct Activity {
     pub activity_type: ActivityType,
     pub name: String,
     pub description: Option<String>,
-    pub duration: Option<f64>,
     #[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,
+    #[serde(serialize_with = "objectid_to_string", deserialize_with = "string_to_objectid")]
     pub creator: ObjectId, // ObjectId
     pub status: ActivityStatus,
     pub members: Option<Vec<ActivityMember>>,
@@ -98,7 +144,9 @@ pub fn datetime_or_u64<'de, D>(deserializer: D) -> Result<u64, D::Error>
 where
     D: Deserializer<'de>,
 {
-    struct DateTimeOrU64;
+    struct DateTimeOrU64 {
+        timezone: chrono::FixedOffset,
+    }
 
     impl<'de> Visitor<'de> for DateTimeOrU64 {
         type Value = u64;
@@ -125,11 +173,26 @@ where
         where
             E: de::Error,
         {
-            DateTime::parse_from_rfc3339(value)
-                .map_err(de::Error::custom)
-                .and_then(|dt| Ok(dt.timestamp() as u64))
+            if let Ok(dt) = DateTime::parse_from_rfc3339(value) {
+                Ok(dt.timestamp() as u64)
+            } else if let Ok(naive_dt) = NaiveDateTime::parse_from_str(value, "%Y-%m-%d %H:%M:%S") {
+                let dt = self
+                    .timezone
+                    .from_local_datetime(&naive_dt)
+                    .single()
+                    .ok_or_else(|| {
+                        de::Error::custom("Invalid datetime for the specified timezone")
+                    })?;
+                Ok(dt.timestamp() as u64)
+            } else {
+                Err(de::Error::custom("Invalid datetime format"))
+            }
         }
     }
 
-    deserializer.deserialize_any(DateTimeOrU64)
+    let config = load_config_sync().unwrap();
+    let offset: i32 = config.timezone.parse().unwrap();
+    let timezone = chrono::FixedOffset::east_opt(offset * 3600).unwrap();
+    let visitor = DateTimeOrU64 { timezone };
+    deserializer.deserialize_any(visitor)
 }
diff --git a/src/models/users.rs b/src/models/users.rs
@@ -6,6 +6,7 @@ use bson::oid::ObjectId;
 use mongodb::Collection;
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
+// use crate::models::activities::{objectid_to_string, string_to_objectid};
 
 #[derive(Debug, Serialize, Deserialize, Clone, Eq, PartialEq, Hash)]
 #[serde(rename_all = "kebab-case")]
diff --git a/src/routers/activities/insert.rs b/src/routers/activities/insert.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, Path, Query},
+    extract::{Extension, Query},
     http::StatusCode,
     response::{IntoResponse, Json},
 };
diff --git a/src/routers/activities/read.rs b/src/routers/activities/read.rs
@@ -2,7 +2,7 @@ use crate::{
     models::{
         activities::Activity,
         groups::GroupPermission,
-        response::{ErrorResponse, Response as ZVMSResponse, ResponseStatus, SuccessResponse},
+        response::{ErrorResponse, ResponseStatus, SuccessResponse},
     },
     utils::jwt::UserData,
 };
@@ -13,7 +13,7 @@ use axum::{
 };
 use bson::{doc, from_document, oid::ObjectId};
 use futures::stream::TryStreamExt;
-use mongodb::{Collection, Database};
+use mongodb::{options::FindOneOptions, Collection, Database};
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use tokio::sync::Mutex;
@@ -53,15 +53,64 @@ pub async fn read_all(
     let query = query.unwrap_or("".to_string());
     let db = db.lock().await;
     let collection: Collection<Activity> = db.collection("activities");
+    let target = if user.perms.contains(&GroupPermission::Auditor) || user.perms.contains(&GroupPermission::Admin) {
+        "pending"
+    } else {
+        ""
+    };
     let pipeline = vec![
         doc! {"$match": {"name": {"$regex": query, "$options": "i"}}},
+        doc! {"$sort": {"_id": -1}},
+        doc! {"$project": {
+                "name": 1,
+                "type": 1,
+                "status": 1,
+                "date": 1,
+                "createdAt": 1,
+                "updatedAt": 1,
+                "creator": 1,
+                "members": {
+                    "$filter": {
+                        "input": "$members",
+                        "as": "member",
+                        "cond": {"$eq": ["$$member.status", target]}
+                    }
+                }
+            }
+        },
+        doc! {"$project": {
+            "members.history": 0,
+            "members.impression": 0,
+            "members.images": 0,
+        }},
         doc! {"$skip": (page - 1) * perpage},
         doc! {"$limit": perpage},
     ];
-    let mut cursor = collection.aggregate(pipeline, None).await.unwrap();
+    let cursor = collection.aggregate(pipeline, None).await;
+    if let Err(e) = cursor {
+        let response: ErrorResponse = ErrorResponse {
+            status: ResponseStatus::Error,
+            code: 500,
+            message: "Failed to read activity: ".to_string() + &e.to_string(),
+        }
+        .into();
+        let response = serde_json::to_string(&response).unwrap();
+        return (StatusCode::INTERNAL_SERVER_ERROR, Json(response));
+    }
+    let mut cursor = cursor.unwrap();
     let mut activities = Vec::new();
     loop {
         let doc_result = cursor.try_next().await;
+        if let Err(e) = doc_result {
+            let response: ErrorResponse = ErrorResponse {
+                status: ResponseStatus::Error,
+                code: 500,
+                message: "Failed to read activity: ".to_string() + &e.to_string(),
+            }
+            .into();
+            let response = serde_json::to_string(&response).unwrap();
+            return (StatusCode::INTERNAL_SERVER_ERROR, Json(response));
+        }
         if let Ok(Some(document)) = doc_result {
             match from_document::<Activity>(document) {
                 Ok(activity) => activities.push(activity),
@@ -72,7 +121,6 @@ pub async fn read_all(
                         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));
                 }
@@ -86,9 +134,7 @@ pub async fn read_all(
             status: ResponseStatus::Error,
             code: 404,
             message: "No activities found".to_string(),
-        }
-        .into();
-        let response = ZVMSResponse::<(), ()>::Error(response);
+        };
         let response = serde_json::to_string(&response).unwrap();
         (StatusCode::NOT_FOUND, Json(response))
     } else {
@@ -97,9 +143,7 @@ pub async fn read_all(
             code: 200,
             data: activities,
             metadata: None,
-        }
-        .into();
-        let response = ZVMSResponse::Success(response);
+        };
         let response = serde_json::to_string(&response).unwrap();
         (StatusCode::OK, Json(response))
     }
@@ -110,7 +154,6 @@ pub async fn read_one(
     _: UserData,
     Path(id): Path<String>,
 ) -> impl IntoResponse {
-    println!("ID: {:?}", id);
     let db = client.lock().await;
     let collection = db.collection("activities");
     let id = ObjectId::parse_str(&id);
@@ -125,9 +168,18 @@ pub async fn read_one(
     }
     let id = id.unwrap();
     let filter = doc! {"_id": id};
-    let result = collection.find_one(filter, None).await;
+    let projection = doc! {
+        "members.history": 0,
+        "members.impression": 0,
+        "members.images": 0,
+    };
+    let result = collection
+        .find_one(
+            filter,
+            Some(FindOneOptions::builder().projection(projection).build()),
+        )
+        .await;
     if let Err(e) = result {
-        println!("Failed to read activity: {:?}", e);
         let response = ErrorResponse {
             status: ResponseStatus::Error,
             code: 500,
@@ -139,7 +191,6 @@ 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,
@@ -150,7 +201,6 @@ pub async fn read_one(
             (StatusCode::OK, Json(response))
         }
         None => {
-            println!("Activity not found");
             let response = ErrorResponse {
                 status: ResponseStatus::Error,
                 code: 404,
diff --git a/src/tests/apis/activity.rs b/src/tests/apis/activity.rs
@@ -53,7 +53,6 @@ mod tests {
             ),
             creator: ObjectId::from_str("65e6fa210edc81d012ec45e3").unwrap(),
             status: ActivityStatus::Pending,
-            duration: Some(1.0),
             date: SystemTime::now()
                 .duration_since(SystemTime::UNIX_EPOCH)
                 .unwrap()
diff --git a/src/tests/auth.rs b/src/tests/auth.rs
@@ -50,6 +50,7 @@ mod tests {
         ];
         let token = generate_token(sub.as_str(), TokenType::LongTerm, perms.clone());
         let token = token.as_str();
+        println!("Token: {:?}", token);
         let result = verify_token(token.to_string());
         if let Err(_) = result {
             assert!(false);
diff --git a/src/utils/config.rs b/src/utils/config.rs
@@ -7,6 +7,8 @@ use tokio::fs::{read, write};
 pub struct Config {
     pub server: String,
     pub database: String,
+    pub timezone: String,
+    pub port: u16,
 }
 
 pub async fn load_config() -> Result<Config, Box<dyn std::error::Error>> {
@@ -26,6 +28,8 @@ pub async fn init_config() -> Result<(), Box<dyn std::error::Error>> {
     let config = Config {
         server: url,
         database: "zvms".to_string(),
+        timezone: "0".to_string(),
+        port: 8080,
     };
     save_config(config).await?;
     Ok(())
@@ -41,3 +45,13 @@ pub async fn load_or_init_config() -> Result<Config, Box<dyn std::error::Error>>
         }
     }
 }
+
+pub fn load_config_sync() -> Result<Config, Box<dyn std::error::Error>> {
+    let config = std::fs::read("config.json");
+    if let Err(_) = config {
+        return Err("Failed to read config file".into());
+    }
+    let config = config.unwrap();
+    let config: Config = serde_json::from_slice(&config)?;
+    Ok(config)
+}

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-d765fcb8ae87f29c4de1645728ff57e7668e4c6be695fdf38d5cdd90a23f6456`
	`1`	`+a3f3447d8dd79340400452d75fcf6c7d89134b65bb1c217f334773c79712b8e3`