guild member removal logs

bulbbot.Gateway/src/events/handler/guild_member_removal.rs

@@ -43,7 +43,7 @@ impl Handler {
             .expect("[EVENT/GUILD_MEMBER_REMOVAL] failed to get the Rabbit MQ Channel");
 
         let event = GuildMemberRemovalEvent {
-            event: EventType::GuildMemberAddition,
+            event: EventType::GuildMemberRemoval,
             shard_id: ctx.shard_id.0,
             timestamp: Handler::get_unix_time(),
             content: GuildMemberRemovalEventContent { guild_id, user },

bulbbot.GatewayHandler/src/events/guild_member_addition.rs

@@ -12,7 +12,6 @@ impl Handler {
         span: &mut BoxedSpan,
         cx: &Context,
     ) -> bool {
-        println!("{:#?}", event_data);
         let message: GuildMemberAdditionEvent = serde_json::from_str(event_data)
             .expect("Failed to parse data as guild member add event");
 

bulbbot.GatewayHandler/src/events/guild_member_removal.rs

@@ -12,6 +12,7 @@ impl Handler {
         span: &mut BoxedSpan,
         cx: &Context,
     ) -> bool {
+        println!("hi");
         let message: GuildMemberRemovalEvent = serde_json::from_str(event_data)
             .expect("Failed to parse data as guild member removal event");
 

bulbbot.GuildService/src/app_config.rs

@@ -18,13 +18,13 @@ pub fn config_app(cfg: &mut web::ServiceConfig) {
                     .service(web::scope("/add").service(web::resource("").route(
                         web::post().to(add_guild_member_command::add_guild_member_command_handler),
                     )))
-                    .service(
-                        web::resource("/remove").route(
+                    .service(web::scope("/remove").service(
+                        web::resource("").route(
                             web::post().to(
                                 remove_guild_member_command::remove_guild_member_command_handler,
                             ),
                         ),
-                    ),
+                    )),
             ),
     );
 }

bulbbot.GuildService/src/handlers/guild_member/add_guild_member_command.rs

@@ -36,20 +36,15 @@ pub async fn add_guild_member_command_handler(
 
         let log_table: Result<Logging, _> = logging.find(guild_id).get_result::<Logging>(&mut conn);
 
-        println!("{:#?}", log_table);
-
         if log_table.is_err() {
             return None;
         }
 
-        println!("{:#?}", log_table);
-
         Some(log_table.unwrap())
     })
     .await
     .expect("Blocking failed in guild create");
 
-    println!("{:#?}", response);
     if response.is_none() {
         return Ok(HttpResponse::NotFound());
     }

bulbbot.GuildService/src/handlers/guild_member/remove_guild_member_command.rs

@@ -1,13 +1,22 @@
 use crate::database::DbPool;
-use crate::models::guilds::Guilds;
 use crate::models::logging::Logging;
-use crate::schema::guilds::dsl::*;
+use crate::schema::logging::dsl::logging;
 use actix_web::{web, HttpRequest, HttpResponse, Responder};
-use diesel::{BelongingToDsl, QueryDsl, RunQueryDsl};
-use lapin::Channel;
+use common::telemetry::extractor_actix_web::ActixWebExtractor;
+use common::telemetry::injector_rabbitmq::RabbitMqInjector;
+use diesel::query_dsl::methods::FindDsl;
+use diesel::RunQueryDsl;
+use lapin::options::BasicPublishOptions;
+use lapin::types::FieldTable;
+use lapin::{BasicProperties, Channel};
 use models::event_type::EventType;
+use models::guild::guild_member::guild_member_add_log::AddGuildMemberLog;
+use models::guild::guild_member::guild_member_addition_event::GuildMemberAdditionEventContent;
+use models::guild::guild_member::guild_member_remove_log::RemoveGuildMemberLog;
+use opentelemetry::global;
 use serde::{Deserialize, Serialize};
 use serenity::all::{GuildId, User};
+use tracing::debug;
 
 #[derive(Serialize, Deserialize)]
 pub struct RemoveGuildMemberContent {
@@ -26,29 +35,71 @@ pub struct RemoveGuildMemberCommand {
 pub async fn remove_guild_member_command_handler(
     request: HttpRequest,
     pool: web::Data<DbPool>,
-    path: web::Path<i64>,
     channel: web::Data<Channel>,
     request_body: web::Json<RemoveGuildMemberCommand>,
 ) -> actix_web::Result<impl Responder> {
-    let guild_id = path.into_inner();
-    /*
-        web::block(move || {
-            let mut conn = pool.get().expect("Failed to get connection");
+    let guild_id: i64 = request_body.content.guild_id.into();
+    let response = web::block(move || {
+        let mut conn = pool.get().expect("Failed to get connection");
 
-            let guild_query: Result<Guilds, _> = guilds.find(guild_id).get_result::<Guilds>(&mut conn);
+        let log_table: Result<Logging, _> = logging.find(guild_id).get_result::<Logging>(&mut conn);
 
-            if guild_query.is_err() {
-                return;
-            }
+        if log_table.is_err() {
+            return None;
+        }
 
-            let guild = guild_query.unwrap();
+        Some(log_table.unwrap())
+    })
+    .await
+    .expect("Blocking failed in guild create");
 
-            let logging_tables: Vec<Logging> = Logging::belonging_to(&guild)
-                .load::<Logging>(&mut conn)
-                .unwrap();
+    if response.is_none() {
+        return Ok(HttpResponse::NotFound());
+    }
+    let response = response.unwrap();
+
+    if response.join_leave.is_none() {
+        return Ok(HttpResponse::Ok());
+    }
+
+    let cx = global::get_text_map_propagator(|propagator| {
+        propagator.extract(&ActixWebExtractor {
+            headers: request.headers(),
         })
+    });
+
+    let mut headers = FieldTable::default();
+    global::get_text_map_propagator(|propagator| {
+        propagator.inject_context(&cx, &mut RabbitMqInjector(&mut headers))
+    });
+
+    let log = RemoveGuildMemberLog {
+        event: EventType::GuildMemberRemoval,
+        shard_id: request_body.shard_id,
+        guild_id: request_body.content.guild_id,
+        user_id: request_body.content.user.id,
+        content: request_body.content.user.clone(),
+    };
+
+    let serialized =
+        serde_json::to_string(&log).expect("[REMOVE_GUILD_MEMBER] failed to serialize event");
+
+    let payload = serialized.as_bytes();
+
+    let confirm = channel
+        .basic_publish(
+            "",
+            "bulbbot.logging",
+            BasicPublishOptions::default(),
+            payload,
+            BasicProperties::default().with_headers(headers),
+        )
+        .await
+        .expect("[REMOVE_GUILD_MEMBER] failed to publish to channel")
         .await
-        .expect("Blocking failed in guild create");
-    */
+        .expect("[REMOVE_GUILD_MEMBER] failed to get confirmation message from channel");
+
+    debug!("Rabbit MQ channel publish return message: {:#?}", confirm);
+
     Ok(HttpResponse::Ok())
 }

bulbbot.Models/src/guild/guild_member/guild_member_remove_log.rs

@@ -0,0 +1,12 @@
+use crate::event_type::EventType;
+use serde::{Deserialize, Serialize};
+use serenity::all::{GuildId, User, UserId};
+
+#[derive(Serialize, Deserialize)]
+pub struct RemoveGuildMemberLog {
+    pub event: EventType,
+    pub shard_id: u32,
+    pub guild_id: GuildId,
+    pub user_id: UserId,
+    pub content: User,
+}

bulbbot.Models/src/guild/guild_member/mod.rs

@@ -1,3 +1,4 @@
 pub mod guild_member_add_log;
 pub mod guild_member_addition_event;
 pub mod guild_member_removal_event;
+pub mod guild_member_remove_log;