feat: add mr/issue label join query, upadte files-changed api

jupiter/callisto/src/item_labels.rs

@@ -15,7 +15,48 @@ pub struct Model {
     pub item_type: String,
 }
 
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {}
+#[derive(Copy, Clone, Debug, EnumIter)]
+pub enum Relation {
+    MegaIssue,
+    MegaMr,
+    Label
+}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        match self {
+            Self::MegaIssue => Entity::belongs_to(super::mega_issue::Entity)
+                .from(Column::ItemId)
+                .to(super::mega_issue::Column::Id)
+                .into(),
+            Self::MegaMr => Entity::belongs_to(super::mega_mr::Entity)
+                .from(Column::ItemId)
+                .to(super::mega_mr::Column::Id)
+                .into(),
+            Self::Label => Entity::belongs_to(super::label::Entity)
+                .from(Column::LabelId)
+                .to(super::label::Column::Id)
+                .into(),
+        }
+    }
+}
+
+impl Related<super::label::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Label.def()
+    }
+}
+
+impl Related<super::mega_issue::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::MegaIssue.def()
+    }
+}
+
+impl Related<super::mega_mr::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::MegaMr.def()
+    }
+}
 
 impl ActiveModelBehavior for ActiveModel {}

jupiter/callisto/src/label.rs

@@ -15,7 +15,17 @@ pub struct Model {
     pub description: String,
 }
 
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {}
+#[derive(Copy, Clone, Debug, EnumIter)]
+pub enum Relation {
+    ItemLabels,
+}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        match self {
+            Self::ItemLabels => Entity::has_many(super::item_labels::Entity).into(),
+        }
+    }
+}
 
 impl ActiveModelBehavior for ActiveModel {}

jupiter/callisto/src/mega_issue.rs

@@ -18,7 +18,27 @@ pub struct Model {
     pub user_id: String,
 }
 
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {}
+#[derive(Copy, Clone, Debug, EnumIter)]
+pub enum Relation {
+    Label,
+}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        match self {
+            Self::Label => Entity::has_many(super::item_labels::Entity).into(),
+        }
+    }
+}
+
+impl Related<super::label::Entity> for Entity {
+    fn to() -> RelationDef {
+        super::item_labels::Relation::Label.def()
+    }
+
+    fn via() -> Option<RelationDef> {
+        Some(super::item_labels::Relation::MegaIssue.def().rev())
+    }
+}
 
 impl ActiveModelBehavior for ActiveModel {}

jupiter/callisto/src/mega_mr.rs

@@ -22,7 +22,27 @@ pub struct Model {
     pub updated_at: DateTime,
 }
 
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {}
+#[derive(Copy, Clone, Debug, EnumIter)]
+pub enum Relation {
+    Label,
+}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        match self {
+            Self::Label => Entity::has_many(super::item_labels::Entity).into(),
+        }
+    }
+}
+
+impl Related<super::label::Entity> for Entity {
+    fn to() -> RelationDef {
+        super::item_labels::Relation::Label.def()
+    }
+
+    fn via() -> Option<RelationDef> {
+        Some(super::item_labels::Relation::MegaMr.def().rev())
+    }
+}
 
 impl ActiveModelBehavior for ActiveModel {}

jupiter/src/storage/issue_storage.rs

@@ -34,7 +34,7 @@ impl IssueStorage {
         &self,
         status: &str,
         page: Pagination,
-    ) -> Result<(Vec<mega_issue::Model>, u64), MegaError> {
+    ) -> Result<(Vec<(mega_issue::Model, Vec<label::Model>)>, u64), MegaError> {
         let paginator = mega_issue::Entity::find()
             .filter(mega_issue::Column::Status.eq(status))
             .order_by_desc(mega_issue::Column::CreatedAt)
@@ -45,14 +45,16 @@ impl IssueStorage {
             .await
             .map(|m| (m, num_pages))?;
 
-        // let issue_ids: Vec<i64> = issues.iter().map(|i| i.id).collect();
-        // let item_label_with_labels = item_labels::Entity::find()
-        //     .filter(item_labels::Column::ItemId.is_in(issue_ids.clone()))
-        //     .find_also_related(label::Entity)
-        //     .all(self.get_connection())
-        //     .await?;
+        let issues_with_label: Vec<(mega_issue::Model, Vec<label::Model>)> =
+            mega_issue::Entity::find()
+                .filter(
+                    mega_issue::Column::Id.is_in(issues.iter().map(|i| i.id).collect::<Vec<_>>()),
+                )
+                .find_with_related(label::Entity)
+                .all(self.get_connection())
+                .await?;
 
-        Ok((issues, page))
+        Ok((issues_with_label, page))
     }
 
     pub async fn get_issue(&self, link: &str) -> Result<Option<mega_issue::Model>, MegaError> {

jupiter/src/storage/mr_storage.rs

@@ -1,11 +1,12 @@
 use std::sync::Arc;
 
+use common::model::Pagination;
 use sea_orm::{
     ActiveModelTrait, ColumnTrait, DatabaseConnection, EntityTrait, IntoActiveModel,
     PaginatorTrait, QueryFilter, QueryOrder, Set,
 };
 
-use callisto::mega_mr;
+use callisto::{label, mega_mr};
 use callisto::sea_orm_active_enums::MergeStatusEnum;
 use common::errors::MegaError;
 use common::utils::generate_id;
@@ -46,18 +47,28 @@ impl MrStorage {
     pub async fn get_mr_by_status(
         &self,
         status: Vec<MergeStatusEnum>,
-        page: u64,
-        per_page: u64,
-    ) -> Result<(Vec<mega_mr::Model>, u64), MegaError> {
+        page: Pagination,
+    ) -> Result<(Vec<(mega_mr::Model, Vec<label::Model>)>, u64), MegaError> {
         let paginator = mega_mr::Entity::find()
             .filter(mega_mr::Column::Status.is_in(status))
             .order_by_desc(mega_mr::Column::CreatedAt)
-            .paginate(self.get_connection(), per_page);
+            .paginate(self.get_connection(), page.per_page);
         let num_pages = paginator.num_items().await?;
-        Ok(paginator
-            .fetch_page(page - 1)
+
+        let (mr_list, page) = paginator
+            .fetch_page(page.page - 1)
             .await
-            .map(|m| (m, num_pages))?)
+            .map(|m| (m, num_pages))?;
+
+        let mr_with_label: Vec<(mega_mr::Model, Vec<label::Model>)> =
+            mega_mr::Entity::find()
+                .filter(
+                    mega_mr::Column::Id.is_in(mr_list.iter().map(|i| i.id).collect::<Vec<_>>()),
+                )
+                .find_with_related(label::Entity)
+                .all(self.get_connection())
+                .await?;
+        Ok((mr_with_label, page))
     }
 
     pub async fn get_mr(&self, link: &str) -> Result<Option<mega_mr::Model>, MegaError> {
@@ -129,5 +140,4 @@ impl MrStorage {
         a_model.update(self.get_connection()).await.unwrap();
         Ok(())
     }
-
 }

mono/Cargo.toml

@@ -54,6 +54,8 @@ cedar-policy = { workspace = true }
 utoipa = { workspace = true, features = ["axum_extras"] }
 utoipa-axum = { workspace = true }
 utoipa-swagger-ui = { workspace = true, features = ["axum"] }
+uuid = { workspace = true, features = ["v4"] }
+
 
 [target.'cfg(not(windows))'.dependencies]
 jemallocator = { workspace = true }

mono/src/api/issue/mod.rs

@@ -1,4 +1,4 @@
-use callisto::mega_issue;
+use callisto::{label, mega_issue};
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 
@@ -18,17 +18,17 @@ pub struct IssueItem {
     pub updated_at: i64,
 }
 
-impl From<mega_issue::Model> for IssueItem {
-    fn from(value: mega_issue::Model) -> Self {
+impl From<(mega_issue::Model, Vec<label::Model>)> for IssueItem {
+    fn from(value: (mega_issue::Model, Vec<label::Model>)) -> Self {
         Self {
-            link: value.link,
-            title: value.title,
-            status: value.status.to_string(),
-            user_id: value.user_id,
-            open_timestamp: value.created_at.and_utc().timestamp(),
-            closed_at: value.closed_at.map(|dt| dt.and_utc().timestamp()),
-            updated_at: value.updated_at.and_utc().timestamp(),
-            labels: vec![]
+            link: value.0.link,
+            title: value.0.title,
+            status: value.0.status.to_string(),
+            user_id: value.0.user_id,
+            open_timestamp: value.0.created_at.and_utc().timestamp(),
+            closed_at: value.0.closed_at.map(|dt| dt.and_utc().timestamp()),
+            updated_at: value.0.updated_at.and_utc().timestamp(),
+            labels: value.1.into_iter().map(|m| m.into()).collect()
         }
     }
 }

mono/src/api/mr/mod.rs

@@ -1,10 +1,13 @@
 use serde::{Deserialize, Serialize};
 
 use callisto::{
-    mega_conversation, mega_mr,
+    label, mega_conversation, mega_mr,
     sea_orm_active_enums::{ConvTypeEnum, MergeStatusEnum},
 };
 use utoipa::ToSchema;
+use uuid::Uuid;
+
+use crate::api::label::LabelItem;
 
 pub mod mr_router;
 
@@ -21,17 +24,19 @@ pub struct MrInfoItem {
     pub open_timestamp: i64,
     pub merge_timestamp: Option<i64>,
     pub updated_at: i64,
+    pub labels: Vec<LabelItem>,
 }
 
-impl From<mega_mr::Model> for MrInfoItem {
-    fn from(value: mega_mr::Model) -> Self {
+impl From<(mega_mr::Model, Vec<label::Model>)> for MrInfoItem {
+    fn from(value: (mega_mr::Model, Vec<label::Model>)) -> Self {
         Self {
-            link: value.link,
-            title: value.title,
-            status: value.status,
-            open_timestamp: value.created_at.and_utc().timestamp(),
-            merge_timestamp: value.merge_date.map(|dt| dt.and_utc().timestamp()),
-            updated_at: value.updated_at.and_utc().timestamp(),
+            link: value.0.link,
+            title: value.0.title,
+            status: value.0.status,
+            open_timestamp: value.0.created_at.and_utc().timestamp(),
+            merge_timestamp: value.0.merge_date.map(|dt| dt.and_utc().timestamp()),
+            updated_at: value.0.updated_at.and_utc().timestamp(),
+            labels: value.1.into_iter().map(|m| m.into()).collect(),
         }
     }
 }
@@ -84,18 +89,51 @@ impl From<mega_conversation::Model> for MegaConversation {
     }
 }
 
-#[derive(Serialize, Deserialize, ToSchema)]
-pub struct FilesChangedItem {
-    pub path: String,
-    pub status: String,
-}
-
-#[derive(Serialize, Deserialize, ToSchema)]
+#[derive(Serialize, ToSchema)]
 pub struct FilesChangedList {
-    pub files: Vec<FilesChangedItem>,
+    pub mui_trees: Vec<MuiTreeNode>,
     pub content: String,
 }
 
+#[derive(Serialize, Debug, ToSchema)]
+pub struct MuiTreeNode {
+    id: String,
+    label: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[schema(no_recursion)]
+    children: Option<Vec<MuiTreeNode>>,
+}
+
+impl MuiTreeNode {
+    fn new(label: &str) -> Self {
+        Self {
+            id: Uuid::new_v4().to_string(),
+            label: label.to_string(),
+            children: None,
+        }
+    }
+
+    fn insert_path(&mut self, parts: &[&str]) {
+        if parts.is_empty() {
+            return;
+        }
+
+        if self.children.is_none() {
+            self.children = Some(Vec::new());
+        }
+
+        let children = self.children.as_mut().unwrap();
+
+        if let Some(existing) = children.iter_mut().find(|c| c.label == parts[0]) {
+            existing.insert_path(&parts[1..]);
+        } else {
+            let mut new_node = MuiTreeNode::new(parts[0]);
+            new_node.insert_path(&parts[1..]);
+            children.push(new_node);
+        }
+    }
+}
+
 #[derive(Deserialize, ToSchema)]
 pub struct SaveCommentRequest {
     pub content: String,