jsr-io · AugustinMauroy · May 8, 2025 · May 8, 2025 · May 30, 2025 · May 30, 2025
diff --git a/api/.sqlx/query-1a5aa7ce4a5d4e1406709fbe9b9f551649fe57c3ee47629d9c62455c7ee3e764.json b/api/.sqlx/query-1a5aa7ce4a5d4e1406709fbe9b9f551649fe57c3ee47629d9c62455c7ee3e764.json
diff --git a/api/src/api/tickets.rs b/api/src/api/tickets.rs
@@ -24,6 +24,8 @@ use crate::util::decode_json;
 use super::ApiError;
 use super::ApiTicket;
 use super::ApiTicketMessage;
+use super::ApiTicketMessageOrAuditLog;
+use super::ApiTicketOverview;
 
 pub fn tickets_router() -> Router<Body, ApiError> {
   Router::builder()
@@ -35,18 +37,60 @@ pub fn tickets_router() -> Router<Body, ApiError> {
 }
 
 #[instrument(name = "GET /api/tickets/:id", skip(req), err, fields(id))]
-pub async fn get_handler(req: Request<Body>) -> ApiResult<ApiTicket> {
-  let id = req.param_uuid("id")?;
+pub async fn get_handler(req: Request<Body>) -> ApiResult<ApiTicketOverview> {
+  let id = match req.param_uuid("id") {
+    Ok(id) => id,
+    Err(_) => {
+      return Err(ApiError::MalformedRequest {
+        msg: "Invalid ID".into(),
+      })
+    }
+  };
   Span::current().record("id", field::display(id));
 
-  let db = req.data::<Database>().unwrap();
-  let ticket = db.get_ticket(id).await?.ok_or(ApiError::TicketNotFound)?;
+  let db = match req.data::<Database>() {
+    Some(db) => db,
+    None => return Err(ApiError::InternalServerError),
+  };
 
-  let iam = req.iam();
+  let ticket = match db.get_ticket(id).await {
+    Ok(Some(ticket)) => ticket,
+    Ok(None) => return Err(ApiError::TicketNotFound),
+    Err(_) => return Err(ApiError::InternalServerError),
+  };
+
+  let ticket_audit = db.get_ticket_audit_logs(id).await;
 
+  let iam = req.iam();
   let current_user = iam.check_current_user_access()?;
+
   if current_user == &ticket.1 || iam.check_admin_access().is_ok() {
-    Ok(ticket.into())
+    let mut events: Vec<ApiTicketMessageOrAuditLog> = Vec::new();
+
+    for message in ticket.2 {
+      events.push(ApiTicketMessageOrAuditLog::Message {
+        message: message.0,
+        user: message.1,
+      });
+    }
+
+    if let Ok(audit_logs) = ticket_audit {
+      for audit_log in audit_logs {
+        events.push(ApiTicketMessageOrAuditLog::AuditLog {
+          audit_log: audit_log.0,
+          user: audit_log.1,
+        });
+      }
+    }
+
+    events.sort_by_key(|event| match event {
+      ApiTicketMessageOrAuditLog::Message { message, .. } => message.created_at,
+      ApiTicketMessageOrAuditLog::AuditLog { audit_log, .. } => {
+        audit_log.created_at
+      }
+    });
+
+    Ok((ticket.0, ticket.1, events).into())
   } else {
     Err(ApiError::TicketNotFound)
   }
@@ -206,9 +250,22 @@ mod test {
       .call()
       .await
       .unwrap();
-    let ticket: ApiTicket = resp.expect_ok().await;
-    assert_eq!(ticket.messages[0].message, "test");
-    assert_eq!(ticket.messages[1].message, "test2");
+    let ticket_overview: super::ApiTicketOverview = resp.expect_ok().await;
+
+    let mut message_contents: Vec<String> = Vec::new();
+    for event in &ticket_overview.events {
+      if let super::ApiTicketMessageOrAuditLog::Message { message, .. } = event
+      {
+        message_contents.push(message.message.clone());
+      }
+    }
+    assert!(
+      message_contents.len() >= 2,
+      "Expected at least 2 messages, found {}",
+      message_contents.len()
+    );
+    assert_eq!(message_contents[0], "test");
+    assert_eq!(message_contents[1], "test2");
 
     let other_user_token = t.user2.token.clone();
     let mut resp = t
@@ -228,6 +285,22 @@ mod test {
       .call()
       .await
       .unwrap();
-    let _ticket: ApiTicket = resp.expect_ok().await;
+    let staff_ticket_overview: super::ApiTicketOverview =
+      resp.expect_ok().await;
+
+    let mut staff_message_contents: Vec<String> = Vec::new();
+    for event in &staff_ticket_overview.events {
+      if let super::ApiTicketMessageOrAuditLog::Message { message, .. } = event
+      {
+        staff_message_contents.push(message.message.clone());
+      }
+    }
+    assert!(
+      staff_message_contents.len() >= 2,
+      "Expected at least 2 messages for staff view, found {}",
+      staff_message_contents.len()
+    );
+    assert_eq!(staff_message_contents[0], "test");
+    assert_eq!(staff_message_contents[1], "test2");
   }
 }
diff --git a/api/src/api/types.rs b/api/src/api/types.rs
@@ -1025,6 +1025,52 @@ pub struct ApiPackageDownloadsRecentVersion {
   pub downloads: Vec<ApiDownloadDataPoint>,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", tag = "kind")]
+pub enum ApiTicketMessageOrAuditLog {
+  Message {
+    message: TicketMessage,
+    user: UserPublic,
+  },
+  #[serde(rename_all = "camelCase")]
+  AuditLog {
+    audit_log: AuditLog,
+    user: UserPublic,
+  },
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApiTicketOverview {
+  pub id: Uuid,
+  pub kind: TicketKind,
+  pub creator: ApiUser,
+  pub meta: serde_json::Value,
+  pub closed: bool,
+  pub events: Vec<ApiTicketMessageOrAuditLog>,
+  pub updated_at: DateTime<Utc>,
+  pub created_at: DateTime<Utc>,
+}
+
+impl From<(Ticket, User, Vec<ApiTicketMessageOrAuditLog>)>
+  for ApiTicketOverview
+{
+  fn from(
+    (value, user, events): (Ticket, User, Vec<ApiTicketMessageOrAuditLog>),
+  ) -> Self {
+    Self {
+      id: value.id,
+      kind: value.kind,
+      creator: user.into(),
+      meta: value.meta,
+      closed: value.closed,
+      events,
+      updated_at: value.updated_at,
+      created_at: value.created_at,
+    }
+  }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ApiTicket {

diff --git a/api/src/db/database.rs b/api/src/db/database.rs
@@ -4564,6 +4564,65 @@ impl Database {
     Ok(Some((ticket, user, messages)))
   }
 
+  #[instrument(name = "Database::get_ticket_audit_logs", skip(self), err)]
+  pub async fn get_ticket_audit_logs(
+    &self,
+    ticket_id: Uuid,
+  ) -> Result<Vec<(AuditLog, UserPublic)>> {
+    let mut tx = self.pool.begin().await?;
+
+    let audit_logs = sqlx::query!(
+      r#"
+        SELECT
+          audit_logs.actor_id as "audit_actor_id",
+          audit_logs.is_sudo as "audit_is_sudo",
+          audit_logs.action as "audit_action",
+          audit_logs.meta as "audit_meta",
+          audit_logs.created_at as "audit_created_at",
+          users.id as "user_id",
+          users.name as "user_name",
+          users.avatar_url as "user_avatar_url",
+          users.github_id as "user_github_id",
+          users.updated_at as "user_updated_at",
+          users.created_at as "user_created_at"
+        FROM
+          audit_logs
+        LEFT JOIN
+          users ON audit_logs.actor_id = users.id
+        WHERE 
+          audit_logs.meta::text LIKE $1
+        ORDER BY audit_logs.created_at DESC;
+        "#,
+      format!("%\"ticket_id\": \"{}\"%", ticket_id),
+    )
+    .map(|r| {
+      let audit_log = AuditLog {
+        actor_id: r.audit_actor_id,
+        is_sudo: r.audit_is_sudo,
+        action: r.audit_action,
+        meta: r.audit_meta,
+        created_at: r.audit_created_at,
+      };
+
+      let user = UserPublic {
+        id: r.user_id,
+        name: r.user_name,
+        avatar_url: r.user_avatar_url,
+        github_id: r.user_github_id,
+        updated_at: r.user_updated_at,
+        created_at: r.user_created_at,
+      };
+
+      (audit_log, user)
+    })
+    .fetch_all(&mut *tx)
+    .await?;
+
+    tx.commit().await?;
+
+    Ok(audit_logs)
+  }
+
   #[instrument(name = "Database::ticket_add_message", skip(self), err)]
   pub async fn ticket_add_message(
     &self,

diff --git a/api/src/db/models.rs b/api/src/db/models.rs
@@ -60,7 +60,8 @@ impl FromRow<'_, sqlx::postgres::PgRow> for User {
   }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct UserPublic {
   pub id: Uuid,
   pub name: String,
@@ -992,7 +993,8 @@ pub struct NewTicketMessage {
   pub message: String,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct TicketMessage {
   pub ticket_id: Uuid,
   pub author: Uuid,
@@ -1003,7 +1005,8 @@ pub struct TicketMessage {
 
 pub type FullTicket = (Ticket, User, Vec<(TicketMessage, UserPublic)>);
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct AuditLog {
   pub actor_id: Uuid,
   pub is_sudo: bool,