Update assignees for issue

jirs-server/src/db/issue_assignees.rs

@@ -0,0 +1,34 @@
+use actix::{Handler, Message};
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+
+use crate::db::DbExecutor;
+use crate::errors::ServiceErrors;
+use crate::models::IssueAssignee;
+
+#[derive(Serialize, Deserialize)]
+pub struct LoadAssignees {
+    pub issue_id: i32,
+}
+
+impl Message for LoadAssignees {
+    type Result = Result<Vec<IssueAssignee>, ServiceErrors>;
+}
+
+impl Handler<LoadAssignees> for DbExecutor {
+    type Result = Result<Vec<IssueAssignee>, ServiceErrors>;
+
+    fn handle(&mut self, msg: LoadAssignees, _ctx: &mut Self::Context) -> Self::Result {
+        use crate::schema::issue_assignees::dsl::*;
+
+        let conn = &self
+            .0
+            .get()
+            .map_err(|_| ServiceErrors::DatabaseConnectionLost)?;
+        issue_assignees
+            .distinct_on(id)
+            .filter(issue_id.eq(msg.issue_id))
+            .load::<IssueAssignee>(conn)
+            .map_err(|_| ServiceErrors::RecordNotFound("issue users".to_string()))
+    }
+}

jirs-server/src/db/issues.rs

@@ -84,6 +84,7 @@ pub struct UpdateIssue {
     pub time_remaining: Option<Option<i32>>,
     pub project_id: Option<i32>,
     pub user_ids: Option<Vec<i32>>,
+    pub reporter_id: Option<i32>,
 }
 
 impl Message for UpdateIssue {
@@ -121,6 +122,8 @@ impl Handler<UpdateIssue> for DbExecutor {
                 .map(|time_remaining| dsl::time_remaining.eq(time_remaining)),
             msg.project_id
                 .map(|project_id| dsl::project_id.eq(project_id)),
+            msg.reporter_id
+                .map(|reporter_id| dsl::reporter_id.eq(reporter_id)),
             dsl::updated_at.eq(chrono::Utc::now().naive_utc()),
         ));
         debug!(

jirs-server/src/db/mod.rs

@@ -7,6 +7,7 @@ use crate::db::dev::VerboseConnection;
 
 pub mod authorize_user;
 pub mod comments;
+pub mod issue_assignees;
 pub mod issues;
 pub mod projects;
 pub mod users;

jirs-server/src/routes/issues.rs

@@ -99,7 +99,7 @@ pub async fn update(
         Ok(Ok(_)) => (),
         _ => return crate::errors::ServiceErrors::Unauthorized.into_http_response(),
     };
-    let signal = UpdateIssue {
+    let msg = UpdateIssue {
         issue_id,
         title: Some(payload.title.clone()),
         issue_type: Some(payload.issue_type.clone()),
@@ -113,8 +113,9 @@ pub async fn update(
         time_remaining: Some(payload.time_remaining.clone()),
         project_id: Some(payload.project_id.clone()),
         user_ids: Some(payload.user_ids.clone()),
+        reporter_id: Some(payload.reporter_id),
     };
-    match db.send(signal).await {
+    match db.send(msg).await {
         Ok(Ok(_)) => (),
         Ok(Err(e)) => return e.into_http_response(),
         _ => return ServiceErrors::DatabaseConnectionLost.into_http_response(),

jirs-server/src/ws/mod.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use actix::{Actor, Addr, StreamHandler};
 use actix_web::web::Data;
 use actix_web::{get, web, Error, HttpRequest, HttpResponse};
@@ -6,6 +8,7 @@ use actix_web_actors::ws;
 use jirs_data::WsMsg;
 
 use crate::db::authorize_user::AuthorizeUser;
+use crate::db::issue_assignees::LoadAssignees;
 use crate::db::issues::{LoadProjectIssues, UpdateIssue};
 use crate::db::projects::LoadCurrentProject;
 use crate::db::users::LoadProjectUsers;
@@ -96,12 +99,39 @@ impl WebSocketActor {
 
     async fn load_issues(&mut self) -> WsResult {
         let project_id = self.current_user().map(|u| u.project_id)?;
-        match self.db.send(LoadProjectIssues { project_id }).await {
-            Ok(Ok(v)) => Ok(Some(WsMsg::ProjectIssuesLoaded(
-                v.into_iter().map(|i| i.into()).collect(),
-            ))),
-            _ => Ok(None),
+
+        let issues: Vec<jirs_data::Issue> =
+            match self.db.send(LoadProjectIssues { project_id }).await {
+                Ok(Ok(v)) => v.into_iter().map(|i| i.into()).collect(),
+                _ => return Ok(None),
+            };
+        let mut issue_map = HashMap::new();
+        let mut queue = vec![];
+        for issue in issues.into_iter() {
+            let f = self.db.send(LoadAssignees {
+                issue_id: issue.id.clone(),
+            });
+            queue.push(f);
+            issue_map.insert(issue.id.clone(), issue);
         }
+        for f in queue {
+            match f.await {
+                Ok(Ok(assignees)) => {
+                    for assignee in assignees {
+                        if let Some(issue) = issue_map.get_mut(&assignee.issue_id) {
+                            issue.user_ids.push(assignee.user_id);
+                        }
+                    }
+                }
+                _ => {}
+            };
+        }
+        let mut issues = vec![];
+        for (_, issue) in issue_map.into_iter() {
+            issues.push(issue);
+        }
+
+        Ok(Some(WsMsg::ProjectIssuesLoaded(issues)))
     }
 
     async fn load_project_users(&mut self) -> WsResult {
@@ -121,7 +151,7 @@ impl WebSocketActor {
         payload: jirs_data::UpdateIssuePayload,
     ) -> WsResult {
         self.current_user()?;
-        let m = match self
+        let mut issue: jirs_data::Issue = match self
             .db
             .send(UpdateIssue {
                 issue_id,
@@ -137,13 +167,29 @@ impl WebSocketActor {
                 time_remaining: Some(payload.time_remaining),
                 project_id: Some(payload.project_id),
                 user_ids: Some(payload.user_ids),
+                reporter_id: Some(payload.reporter_id),
             })
             .await
         {
-            Ok(Ok(issue)) => Some(WsMsg::IssueUpdated(issue.into())),
-            _ => None,
+            Ok(Ok(issue)) => issue.into(),
+            _ => return Ok(None),
         };
-        Ok(m)
+
+        let assignees = match self
+            .db
+            .send(LoadAssignees {
+                issue_id: issue.id.clone(),
+            })
+            .await
+        {
+            Ok(Ok(v)) => v,
+            _ => vec![],
+        };
+        for assignee in assignees {
+            issue.user_ids.push(assignee.user_id);
+        }
+
+        Ok(Some(WsMsg::IssueUpdated(issue.into())))
     }
 
     async fn add_issue(&mut self, payload: jirs_data::CreateIssuePayload) -> WsResult {