feat: Bot Installation (#2019)

* feat: add bot install router

* fix: reslove cr problems

Author: ztygod

ceres/src/model/bots.rs

@@ -0,0 +1,90 @@
+use callisto::{
+    bot_installations,
+    sea_orm_active_enums::{InstallationBotStatusEnum, InstallationTargetTypeEnum},
+};
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct BotRes {
+    pub id: i64,
+    pub bot_id: i64,
+    pub target_type: InstallationTargetType,
+    pub target_id: i64,
+    pub status: InstallationBotStatus,
+    pub installed_by: i64,
+}
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct InstallBotReq {
+    pub target_type: InstallationTargetType,
+    pub target_id: i64,
+    pub installed_by: i64,
+}
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub struct ChangeInstallationStatus {
+    pub target_type: InstallationTargetType,
+    pub status: InstallationBotStatus,
+}
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub enum InstallationBotStatus {
+    Disabled,
+    Enabled,
+}
+
+#[derive(Serialize, Deserialize, ToSchema)]
+pub enum InstallationTargetType {
+    Organization,
+    Repository,
+}
+
+impl From<bot_installations::Model> for BotRes {
+    fn from(value: bot_installations::Model) -> Self {
+        Self {
+            id: value.id,
+            bot_id: value.bot_id,
+            target_type: value.target_type.into(),
+            target_id: value.target_id,
+            status: value.status.into(),
+            installed_by: value.installed_by,
+        }
+    }
+}
+
+impl From<InstallationBotStatusEnum> for InstallationBotStatus {
+    fn from(value: InstallationBotStatusEnum) -> Self {
+        match value {
+            InstallationBotStatusEnum::Disabled => InstallationBotStatus::Disabled,
+            InstallationBotStatusEnum::Enabled => InstallationBotStatus::Enabled,
+        }
+    }
+}
+
+impl From<InstallationTargetTypeEnum> for InstallationTargetType {
+    fn from(value: InstallationTargetTypeEnum) -> Self {
+        match value {
+            InstallationTargetTypeEnum::Organization => InstallationTargetType::Organization,
+            InstallationTargetTypeEnum::Repository => InstallationTargetType::Repository,
+        }
+    }
+}
+
+impl From<InstallationBotStatus> for InstallationBotStatusEnum {
+    fn from(value: InstallationBotStatus) -> Self {
+        match value {
+            InstallationBotStatus::Disabled => InstallationBotStatusEnum::Disabled,
+            InstallationBotStatus::Enabled => InstallationBotStatusEnum::Enabled,
+        }
+    }
+}
+
+impl From<InstallationTargetType> for InstallationTargetTypeEnum {
+    fn from(value: InstallationTargetType) -> Self {
+        match value {
+            InstallationTargetType::Organization => InstallationTargetTypeEnum::Organization,
+            InstallationTargetType::Repository => InstallationTargetTypeEnum::Repository,
+        }
+    }
+}

ceres/src/model/mod.rs

@@ -1,4 +1,5 @@
 pub mod blame;
+pub mod bots;
 pub mod buck;
 pub mod change_list;
 pub mod cl;

jupiter/callisto/src/entity_ext/bot_installations.rs

@@ -0,0 +1,29 @@
+use chrono::Utc;
+
+use crate::{
+    bot_installations,
+    entity_ext::generate_id,
+    sea_orm_active_enums::{InstallationBotStatusEnum, InstallationTargetTypeEnum},
+};
+
+impl bot_installations::Model {
+    pub fn new(
+        bot_id: i64,
+        target_type: InstallationTargetTypeEnum,
+        target_id: i64,
+        status: InstallationBotStatusEnum,
+        installed_by: i64,
+    ) -> Self {
+        let now = Utc::now().into();
+
+        Self {
+            id: generate_id(),
+            bot_id,
+            target_type,
+            target_id,
+            status,
+            installed_by,
+            installed_at: now,
+        }
+    }
+}

jupiter/callisto/src/entity_ext/mod.rs

@@ -1,3 +1,4 @@
+pub mod bot_installations;
 pub mod bot_keys;
 pub mod bots;
 pub mod buck_session;

jupiter/src/storage/bots_storage.rs

@@ -1,16 +1,20 @@
 use std::ops::Deref;
 
 use callisto::{
-    bot_keys, bots,
-    sea_orm_active_enums::{BotStatusEnum, PermissionScopeEnum},
+    bot_installations, bot_keys, bots,
+    sea_orm_active_enums::{
+        BotStatusEnum, InstallationBotStatusEnum, InstallationTargetTypeEnum, PermissionScopeEnum,
+    },
 };
 use common::errors::MegaError;
 use rsa::{
     RsaPrivateKey,
     pkcs8::{EncodePrivateKey, EncodePublicKey},
     rand_core::OsRng,
 };
-use sea_orm::{ActiveModelTrait, IntoActiveModel};
+use sea_orm::{
+    ActiveModelTrait, ActiveValue::Set, ColumnTrait, EntityTrait, IntoActiveModel, QueryFilter,
+};
 
 use crate::storage::base_storage::{BaseStorage, StorageConnector};
 
@@ -73,6 +77,101 @@ impl BotsStorage {
         Ok((bot, private_pem))
     }
 
+    pub async fn get_installed_bot_by_id(
+        &self,
+        bot_id: i64,
+    ) -> Result<Vec<bot_installations::Model>, MegaError> {
+        let installations = bot_installations::Entity::find()
+            .filter(bot_installations::Column::BotId.eq(bot_id))
+            .all(self.get_connection())
+            .await?;
+
+        Ok(installations)
+    }
+
+    /// Install a bot to a target (organization or repository)
+    pub async fn install_bot(
+        &self,
+        bot_id: i64,
+        target_type: InstallationTargetTypeEnum,
+        target_id: i64,
+        installed_by: i64,
+    ) -> Result<bot_installations::Model, MegaError> {
+        // Check if already installed
+        if (bot_installations::Entity::find()
+            .filter(bot_installations::Column::BotId.eq(bot_id))
+            .filter(bot_installations::Column::TargetType.eq(target_type.clone()))
+            .filter(bot_installations::Column::TargetId.eq(target_id))
+            .one(self.get_connection())
+            .await?)
+            .is_some()
+        {
+            return Err(MegaError::Other(
+                "Bot already installed on this target".into(),
+            ));
+        }
+
+        // Insert installation record
+        let model = bot_installations::Model::new(
+            bot_id,
+            target_type,
+            target_id,
+            InstallationBotStatusEnum::Enabled,
+            installed_by,
+        );
+
+        let active_model = model.into_active_model();
+
+        let res = active_model.insert(self.get_connection()).await?;
+        Ok(res)
+    }
+
+    /// Uninstall a bot from a target
+    pub async fn uninstall_bot(
+        &self,
+        bot_id: i64,
+        target_type: InstallationTargetTypeEnum,
+        target_id: i64,
+    ) -> Result<(), MegaError> {
+        let installation = bot_installations::Entity::find()
+            .filter(bot_installations::Column::BotId.eq(bot_id))
+            .filter(bot_installations::Column::TargetType.eq(target_type.clone()))
+            .filter(bot_installations::Column::TargetId.eq(target_id))
+            .one(self.get_connection())
+            .await?
+            .ok_or_else(|| MegaError::Other("Bot installation not found".into()))?
+            .into_active_model();
+
+        installation
+            .into_active_model()
+            .delete(self.get_connection())
+            .await?;
+
+        Ok(())
+    }
+
+    /// Change the status of an installed bot (Enabled / Disabled)
+    pub async fn change_installed_bot_status(
+        &self,
+        bot_id: i64,
+        target_type: InstallationTargetTypeEnum,
+        target_id: i64,
+        status: InstallationBotStatusEnum,
+    ) -> Result<bot_installations::Model, MegaError> {
+        let mut installation = bot_installations::Entity::find()
+            .filter(bot_installations::Column::BotId.eq(bot_id))
+            .filter(bot_installations::Column::TargetType.eq(target_type.clone()))
+            .filter(bot_installations::Column::TargetId.eq(target_id))
+            .one(self.get_connection())
+            .await?
+            .ok_or_else(|| MegaError::Other("Bot installation not found".into()))?
+            .into_active_model();
+
+        installation.status = Set(status);
+        let res = installation.update(self.get_connection()).await?;
+        Ok(res)
+    }
+
     pub async fn new_bot_model(
         &self,
         name: &str,

jupiter/src/storage/mod.rs

@@ -432,6 +432,10 @@ impl Storage {
         self.app_service.webhook_storage.clone()
     }
 
+    pub fn bots_storage(&self) -> BotsStorage {
+        self.app_service.bots_storage.clone()
+    }
+
     pub fn mock() -> Self {
         // During test time, we don't need a AppContext,
         // Put config in a leaked static variable thus the weak reference will always be valid.

mono/src/api/api_router.rs

@@ -16,10 +16,10 @@ use crate::{
         error::ApiError,
         notes::note_router,
         router::{
-            admin_router, buck_router, build_trigger_router, cl_router, code_review_router,
-            commit_router, conv_router, dynamic_sidebar_router, gpg_router, group_router,
-            issue_router, label_router, merge_queue_router, permission_router, preview_router,
-            repo_router, reviewer_router, tag_router, user_router, webhook_router,
+            admin_router, bot_router, buck_router, build_trigger_router, cl_router,
+            code_review_router, commit_router, conv_router, dynamic_sidebar_router, gpg_router,
+            group_router, issue_router, label_router, merge_queue_router, permission_router,
+            preview_router, repo_router, reviewer_router, tag_router, user_router, webhook_router,
         },
     },
     server::http_server::SYSTEM_COMMON,
@@ -51,6 +51,7 @@ pub fn routers() -> OpenApiRouter<MonoApiServiceState> {
         .merge(code_review_router::routers())
         .merge(build_trigger_router::routers())
         .merge(webhook_router::routers())
+        .merge(bot_router::routers())
 }
 
 /// Health Check