Overhaul notifs + threads fixes (#573)

* Overhaul notifs + threads fixes

* fix lang

src/models/notifications.rs

@@ -1,5 +1,11 @@
 use super::ids::Base62Id;
 use super::users::UserId;
+use crate::database::models::notification_item::Notification as DBNotification;
+use crate::database::models::notification_item::NotificationAction as DBNotificationAction;
+use crate::models::ids::{
+    ProjectId, ReportId, TeamId, ThreadId, ThreadMessageId, VersionId,
+};
+use crate::models::projects::ProjectStatus;
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 
@@ -13,35 +19,176 @@ pub struct Notification {
     pub id: NotificationId,
     pub user_id: UserId,
     #[serde(rename = "type")]
+    pub read: bool,
+    pub created: DateTime<Utc>,
+    pub body: NotificationBody,
+
+    // DEPRECATED: use body field instead
     pub type_: Option<String>,
     pub title: String,
     pub text: String,
     pub link: String,
-    pub read: bool,
-    pub created: DateTime<Utc>,
     pub actions: Vec<NotificationAction>,
 }
 
-use crate::database::models::notification_item::Notification as DBNotification;
-use crate::database::models::notification_item::NotificationAction as DBNotificationAction;
+#[derive(Serialize, Deserialize, Clone)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum NotificationBody {
+    ProjectUpdate {
+        project_id: ProjectId,
+        version_id: VersionId,
+    },
+    TeamInvite {
+        project_id: ProjectId,
+        team_id: TeamId,
+        invited_by: UserId,
+        role: String,
+    },
+    StatusChange {
+        project_id: ProjectId,
+        old_status: ProjectStatus,
+        new_status: ProjectStatus,
+    },
+    ModeratorMessage {
+        thread_id: ThreadId,
+        message_id: ThreadMessageId,
+
+        project_id: Option<ProjectId>,
+        report_id: Option<ReportId>,
+    },
+    LegacyMarkdown {
+        notification_type: Option<String>,
+        title: String,
+        text: String,
+        link: String,
+        actions: Vec<NotificationAction>,
+    },
+    Unknown,
+}
 
 impl From<DBNotification> for Notification {
     fn from(notif: DBNotification) -> Self {
+        let (type_, title, text, link, actions) = {
+            match &notif.body {
+                NotificationBody::ProjectUpdate {
+                    project_id,
+                    version_id,
+                } => (
+                    Some("project_update".to_string()),
+                    "A project you follow has been updated!".to_string(),
+                    format!(
+                        "The project {} has released a new version: {}",
+                        project_id, version_id
+                    ),
+                    format!("/project/{}/version/{}", project_id, version_id),
+                    vec![],
+                ),
+                NotificationBody::TeamInvite {
+                    project_id,
+                    role,
+                    team_id,
+                    ..
+                } => (
+                    Some("team_invite".to_string()),
+                    "You have been invited to join a team!".to_string(),
+                    format!(
+                        "An invite has been sent for you to be {} of a team",
+                        role
+                    ),
+                    format!("/project/{}", project_id),
+                    vec![
+                        NotificationAction {
+                            title: "Accept".to_string(),
+                            action_route: (
+                                "POST".to_string(),
+                                format!("team/{team_id}/join"),
+                            ),
+                        },
+                        NotificationAction {
+                            title: "Deny".to_string(),
+                            action_route: (
+                                "DELETE".to_string(),
+                                format!(
+                                    "team/{team_id}/members/{}",
+                                    UserId::from(notif.user_id)
+                                ),
+                            ),
+                        },
+                    ],
+                ),
+                NotificationBody::StatusChange {
+                    old_status,
+                    new_status,
+                    project_id,
+                } => (
+                    Some("status_change".to_string()),
+                    "Project status has changed".to_string(),
+                    format!(
+                        "Status has changed from {} to {}",
+                        old_status.as_friendly_str(),
+                        new_status.as_friendly_str()
+                    ),
+                    format!("/project/{}", project_id),
+                    vec![],
+                ),
+                NotificationBody::ModeratorMessage {
+                    project_id,
+                    report_id,
+                    ..
+                } => (
+                    Some("moderator_message".to_string()),
+                    "A moderator has sent you a message!".to_string(),
+                    "Click on the link to read more.".to_string(),
+                    if let Some(project_id) = project_id {
+                        format!("/project/{}", project_id)
+                    } else if let Some(report_id) = report_id {
+                        format!("/project/{}", report_id)
+                    } else {
+                        "#".to_string()
+                    },
+                    vec![],
+                ),
+                NotificationBody::LegacyMarkdown {
+                    notification_type,
+                    title,
+                    text,
+                    link,
+                    actions,
+                } => (
+                    notification_type.clone(),
+                    title.clone(),
+                    text.clone(),
+                    link.clone(),
+                    actions.clone().into_iter().map(Into::into).collect(),
+                ),
+                NotificationBody::Unknown => (
+                    None,
+                    "".to_string(),
+                    "".to_string(),
+                    "#".to_string(),
+                    vec![],
+                ),
+            }
+        };
+
         Self {
             id: notif.id.into(),
             user_id: notif.user_id.into(),
-            type_: notif.notification_type,
-            title: notif.title,
-            text: notif.text,
-            link: notif.link,
+            body: notif.body,
             read: notif.read,
             created: notif.created,
-            actions: notif.actions.into_iter().map(Into::into).collect(),
+
+            // DEPRECATED
+            type_,
+            title,
+            text,
+            link,
+            actions,
         }
     }
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct NotificationAction {
     pub title: String,
     /// The route to call when this notification action is called. Formatted HTTP Method, route

src/models/threads.rs

@@ -1,4 +1,5 @@
 use super::ids::Base62Id;
+use crate::models::ids::{ProjectId, ReportId};
 use crate::models::projects::ProjectStatus;
 use crate::models::users::{User, UserId};
 use chrono::{DateTime, Utc};
@@ -21,6 +22,9 @@ pub struct Thread {
     pub type_: ThreadType,
     pub messages: Vec<ThreadMessage>,
     pub members: Vec<User>,
+
+    pub project_id: Option<ProjectId>,
+    pub report_id: Option<ReportId>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -45,6 +49,7 @@ pub enum MessageBody {
         old_status: ProjectStatus,
     },
     ThreadClosure,
+    ThreadReopen,
     Deleted,
 }