feat(mono): added reactions API

jupiter/callisto/src/entity_ext/mega_conversation.rs

@@ -10,6 +10,7 @@ use crate::{
 pub enum Relation {
     MegaIssue,
     MegaMr,
+    Reactions,
 }
 
 impl RelationTrait for Relation {
@@ -23,6 +24,7 @@ impl RelationTrait for Relation {
                 .from(Column::Link)
                 .to(crate::mega_mr::Column::Link)
                 .into(),
+            Self::Reactions => Entity::has_many(crate::reactions::Entity).into(),
         }
     }
 }
@@ -39,6 +41,15 @@ impl Related<crate::mega_mr::Entity> for Entity {
     }
 }
 
+impl Related<crate::reactions::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Reactions.def()
+    }
+    fn via() -> Option<RelationDef> {
+        None
+    }
+}
+
 impl mega_conversation::Model {
     pub fn new(
         link: &str,

jupiter/callisto/src/entity_ext/reactions.rs

@@ -1,5 +1,29 @@
+use sea_orm::entity::prelude::*;
+
 use crate::entity_ext::{generate_id, generate_public_id};
-use crate::reactions;
+use crate::reactions::{self, Entity};
+
+#[derive(Copy, Clone, Debug, EnumIter)]
+pub enum Relation {
+    Conversation,
+}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        match self {
+            Self::Conversation => Entity::belongs_to(crate::mega_conversation::Entity)
+                .from(reactions::Column::SubjectId)
+                .to(crate::mega_conversation::Column::Id)
+                .into(),
+        }
+    }
+}
+
+impl Related<crate::mega_conversation::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Conversation.def()
+    }
+}
 
 impl reactions::Model {
     pub fn new(

jupiter/src/model/conv_dto.rs

@@ -0,0 +1,6 @@
+use callisto::{mega_conversation, reactions};
+
+pub struct ConvWithReactions {
+    pub conversation: mega_conversation::Model,
+    pub reactions: Vec<reactions::Model>,
+}

jupiter/src/model/issue_dto.rs

@@ -1,13 +1,11 @@
-use callisto::{item_assignees, label, mega_conversation, mega_issue, reactions};
+use callisto::{item_assignees, label, mega_issue};
+
+use crate::model::conv_dto::ConvWithReactions;
 
 pub struct IssueDetails {
+    pub username: String,
     pub issue: mega_issue::Model,
     pub conversations: Vec<ConvWithReactions>,
     pub labels: Vec<label::Model>,
     pub assignees: Vec<item_assignees::Model>,
 }
-
-pub struct ConvWithReactions {
-    pub conversation: mega_conversation::Model,
-    pub reactions: Vec<reactions::Model>,
-}

jupiter/src/model/mod.rs

@@ -1,2 +1,4 @@
 pub mod common;
+pub mod conv_dto;
 pub mod issue_dto;
+pub mod mr_dto;

jupiter/src/model/mr_dto.rs

@@ -0,0 +1,11 @@
+use callisto::{item_assignees, label, mega_mr};
+
+use crate::model::conv_dto::ConvWithReactions;
+
+pub struct MRDetails {
+    pub username: String,
+    pub mr: mega_mr::Model,
+    pub conversations: Vec<ConvWithReactions>,
+    pub labels: Vec<label::Model>,
+    pub assignees: Vec<item_assignees::Model>,
+}

jupiter/src/service/issue_service.rs

@@ -1,6 +1,5 @@
 use crate::{
     model::issue_dto::IssueDetails,
-    service::IssueService,
     storage::{
         base_storage::{BaseStorage, StorageConnector},
         conversation_storage::ConversationStorage,
@@ -10,6 +9,13 @@ use crate::{
 
 use common::errors::MegaError;
 
+#[derive(Clone)]
+pub struct IssueService {
+    pub issue_storage: IssueStorage,
+    pub conversation_storage: ConversationStorage,
+}
+
+
 impl IssueService {
     pub fn new(issue_storage: IssueStorage, conversation_storage: ConversationStorage) -> Self {
         Self {
@@ -26,7 +32,11 @@ impl IssueService {
         }
     }
 
-    pub async fn get_issue_details(&self, link: &str) -> Result<IssueDetails, MegaError> {
+    pub async fn get_issue_details(
+        &self,
+        link: &str,
+        username: String,
+    ) -> Result<IssueDetails, MegaError> {
         let (issue, labels) = self
             .issue_storage
             .get_issue_labels(link)
@@ -49,6 +59,7 @@ impl IssueService {
             labels,
             conversations,
             assignees,
+            username,
         };
         Ok(res)
     }

jupiter/src/service/mod.rs

@@ -1,9 +1,5 @@
-use crate::storage::{conversation_storage::ConversationStorage, issue_storage::IssueStorage};
+// use crate::storage::{conversation_storage::ConversationStorage, issue_storage::IssueStorage};
 
 pub mod issue_service;
+pub mod mr_service;
 
-#[derive(Clone)]
-pub struct IssueService {
-    pub issue_storage: IssueStorage,
-    pub conversation_storage: ConversationStorage,
-}

jupiter/src/service/mr_service.rs

@@ -0,0 +1,65 @@
+use crate::{
+    model::mr_dto::MRDetails,
+    storage::{
+        base_storage::{BaseStorage, StorageConnector},
+        conversation_storage::ConversationStorage,
+        mr_storage::MrStorage,
+    },
+};
+
+use common::errors::MegaError;
+
+#[derive(Clone)]
+pub struct MRService {
+    pub mr_storage: MrStorage,
+    pub conversation_storage: ConversationStorage,
+}
+
+impl MRService {
+    pub fn new(mr_storage: MrStorage, conversation_storage: ConversationStorage) -> Self {
+        Self {
+            mr_storage,
+            conversation_storage,
+        }
+    }
+
+    pub fn mock() -> Self {
+        let mock = BaseStorage::mock();
+        Self {
+            mr_storage: MrStorage { base: mock.clone() },
+            conversation_storage: ConversationStorage { base: mock.clone() },
+        }
+    }
+
+    pub async fn get_mr_details(
+        &self,
+        link: &str,
+        username: String,
+    ) -> Result<MRDetails, MegaError> {
+        let (mr, labels) = self
+            .mr_storage
+            .get_mr_labels(link)
+            .await?
+            .ok_or_else(|| MegaError::with_message("MR not found"))?;
+
+        let conversations = self
+            .conversation_storage
+            .get_comments_with_reactions(link)
+            .await?;
+
+        let (_, assignees) = self
+            .mr_storage
+            .get_mr_assignees(link)
+            .await?
+            .unwrap_or((mr.clone(), vec![]));
+
+        let res = MRDetails {
+            mr,
+            labels,
+            conversations,
+            assignees,
+            username,
+        };
+        Ok(res)
+    }
+}

jupiter/src/storage/conversation_storage.rs

@@ -1,4 +1,3 @@
-use std::collections::HashMap;
 use std::ops::Deref;
 
 use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, IntoActiveModel, QueryFilter};
@@ -7,7 +6,7 @@ use callisto::sea_orm_active_enums::ConvTypeEnum;
 use callisto::{mega_conversation, reactions};
 use common::errors::MegaError;
 
-use crate::model::issue_dto::ConvWithReactions;
+use crate::model::conv_dto::ConvWithReactions;
 use crate::storage::base_storage::{BaseStorage, StorageConnector};
 
 #[derive(Clone)]
@@ -36,6 +35,14 @@ impl ConversationStorage {
         Ok(res.id)
     }
 
+    pub async fn remove_conversation(&self, id: i64) -> Result<(), MegaError> {
+        mega_conversation::Entity::delete_by_id(id)
+            .exec(self.get_connection())
+            .await
+            .unwrap();
+        Ok(())
+    }
+
     pub async fn add_reactions(
         &self,
         content: Option<String>,
@@ -55,32 +62,30 @@ impl ConversationStorage {
     ) -> Result<Vec<ConvWithReactions>, MegaError> {
         let conversations = mega_conversation::Entity::find()
             .filter(mega_conversation::Column::Link.eq(link))
+            .find_with_related(reactions::Entity)
             .all(self.get_connection())
             .await?;
 
-        let conv_ids = conversations.iter().map(|c| c.id).collect::<Vec<_>>();
+        let results = conversations
+            .into_iter()
+            .map(|(conversation, reactions)| ConvWithReactions {
+                conversation,
+                reactions,
+            })
+            .collect();
+        Ok(results)
+    }
 
-        let reactions = reactions::Entity::find()
-            .filter(reactions::Column::SubjectId.is_in(conv_ids.clone()))
-            .all(self.get_connection())
+    pub async fn delete_reaction(
+        &self,
+        pub_reaction_id: &str,
+        username: &str,
+    ) -> Result<(), MegaError> {
+        let _ = reactions::Entity::delete_many()
+            .filter(reactions::Column::PublicId.eq(pub_reaction_id))
+            .filter(reactions::Column::Username.eq(username))
+            .exec(self.get_connection())
             .await?;
-
-        let mut conv_map = HashMap::new();
-        for conversation in conversations {
-            let related = reactions
-                .iter()
-                .filter(|r| r.subject_id == conversation.id)
-                .cloned()
-                .collect();
-            conv_map.insert(
-                conversation.id,
-                ConvWithReactions {
-                    conversation,
-                    reactions: related,
-                },
-            );
-        }
-
-        Ok(conv_map.into_values().collect())
+        Ok(())
     }
 }

jupiter/src/storage/issue_storage.rs

@@ -181,25 +181,6 @@ impl IssueStorage {
         Ok(())
     }
 
-    pub async fn get_conversations(
-        &self,
-        link: &str,
-    ) -> Result<Vec<mega_conversation::Model>, MegaError> {
-        let model = mega_conversation::Entity::find()
-            .filter(mega_conversation::Column::Link.eq(link))
-            .all(self.get_connection())
-            .await;
-        Ok(model?)
-    }
-
-    pub async fn remove_conversation(&self, id: i64) -> Result<(), MegaError> {
-        mega_conversation::Entity::delete_by_id(id)
-            .exec(self.get_connection())
-            .await
-            .unwrap();
-        Ok(())
-    }
-
     pub async fn new_label(
         &self,
         name: &str,

jupiter/src/storage/mod.rs

@@ -17,7 +17,8 @@ use std::sync::{Arc, LazyLock, Weak};
 use common::config::Config;
 
 use crate::lfs_storage::{self, local_storage::LocalStorage, LfsFileStorage};
-use crate::service::IssueService;
+use crate::service::issue_service::IssueService;
+use crate::service::mr_service::MRService;
 use crate::storage::conversation_storage::ConversationStorage;
 use crate::storage::init::database_connection;
 use crate::storage::{
@@ -66,6 +67,7 @@ impl AppService {
 pub struct Storage {
     pub(crate) app_service: Arc<AppService>,
     pub issue_service: IssueService,
+    pub mr_service: MRService,
     pub config: Weak<Config>,
 }
 
@@ -94,15 +96,16 @@ impl Storage {
             relay_storage,
             user_storage,
             vault_storage,
-            mr_storage,
+            mr_storage: mr_storage.clone(),
             issue_storage: issue_storage.clone(),
             conversation_storage: conversation_storage.clone(),
             lfs_file_storage,
         };
         Storage {
             app_service: app_service.into(),
             config: Arc::downgrade(&config),
-            issue_service: IssueService::new(issue_storage, conversation_storage),
+            issue_service: IssueService::new(issue_storage, conversation_storage.clone()),
+            mr_service: MRService::new(mr_storage, conversation_storage),
         }
     }
 
@@ -162,6 +165,7 @@ impl Storage {
         Storage {
             app_service: AppService::mock(),
             issue_service: IssueService::mock(),
+            mr_service: MRService::mock(),
             config: Arc::downgrade(&*CONFIG),
         }
     }