Noratrieb/discord-court-bot
1
0
Fork 0
mirror of https://github.com/Noratrieb/discord-court-bot.git synced 2026-01-17 03:15:01 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

lawsuit ctx

Browse source
This commit is contained in:
nora 2022-06-16 20:05:21 +02:00
parent 984125841c
commit 2a1d598cca
2 changed files with 121 additions and 109 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/handler.rs
View file

@ -15,6 +15,7 @@ use crate::{
model::SnowflakeId, model::SnowflakeId,
Mongo, WrapErr, Mongo, WrapErr,
}; };
use crate::lawsuit::LawsuitCtx;
fn slash_commands(commands: &mut CreateApplicationCommands) -> &mut CreateApplicationCommands { fn slash_commands(commands: &mut CreateApplicationCommands) -> &mut CreateApplicationCommands {
commands.create_application_command(|command| { commands.create_application_command(|command| {
@ -208,8 +209,15 @@ async fn lawsuit_command_handler(
court_room: SnowflakeId(0), court_room: SnowflakeId(0),
}; };
let response = lawsuit let lawsuit_ctx = LawsuitCtx {
.initialize(ctx.http.clone(), guild_id, mongo_client.clone()) lawsuit,
mongo_client: mongo_client.clone(),
http: ctx.http.clone(),
guild_id
};
let response = lawsuit_ctx
.initialize()
.await .await
.wrap_err("initialize lawsuit")?; .wrap_err("initialize lawsuit")?;

218
src/lawsuit.rs
View file

@ -34,14 +34,19 @@ pub struct Lawsuit {
pub court_room: SnowflakeId, pub court_room: SnowflakeId,
} }
impl Lawsuit { pub struct LawsuitCtx {
pub async fn initialize( pub lawsuit: Lawsuit,
mut self, pub mongo_client: Mongo,
http: Arc<Http>, pub http: Arc<Http>,
guild_id: GuildId, pub guild_id: GuildId,
mongo_client: Mongo, }
) -> Result<Response> {
let state = mongo_client.find_or_insert_state(guild_id.into()).await?; impl LawsuitCtx {
pub async fn initialize(mut self) -> Result<Response> {
let state = self
.mongo_client
.find_or_insert_state(self.guild_id.into())
.await?;
let free_room = state let free_room = state
.court_rooms .court_rooms
@ -54,15 +59,10 @@ impl Lawsuit {
(None, Some(category)) => { (None, Some(category)) => {
// create room // create room
let result = create_room( let result = self
&http, .create_room(state.court_rooms.len(), *category)
guild_id, .await
state.court_rooms.len(), .wrap_err("create new room")?;
*category,
&mongo_client,
)
.await
.wrap_err("create new room")?;
match result { match result {
Err(res) => return Ok(res), Err(res) => return Ok(res),
@ -76,7 +76,7 @@ impl Lawsuit {
}; };
let result = self let result = self
.send_process_open_message(&http, guild_id, &room) .send_process_open_message(&self.http, self.guild_id, &room)
.await .await
.wrap_err("send process open message")?; .wrap_err("send process open message")?;
@ -85,10 +85,10 @@ impl Lawsuit {
} }
let channel_id = room.channel_id; let channel_id = room.channel_id;
self.court_room = channel_id; self.lawsuit.court_room = channel_id;
tokio::spawn(async move { tokio::spawn(async move {
if let Err(err) = self.setup(guild_id, http, mongo_client, room).await { if let Err(err) = self.setup(room).await {
error!(?err, "Error setting up lawsuit"); error!(?err, "Error setting up lawsuit");
} }
}); });
@ -99,14 +99,16 @@ impl Lawsuit {
))) )))
} }
async fn setup( async fn setup(&self, room: CourtRoom) -> Result<()> {
&self, let Self {
guild_id: GuildId, mongo_client,
http: Arc<Http>, http,
mongo_client: Mongo, guild_id,
room: CourtRoom, lawsuit,
) -> Result<()> { } = self;
mongo_client.add_lawsuit(guild_id.into(), self).await?; let guild_id = *guild_id;
mongo_client.add_lawsuit(guild_id.into(), lawsuit).await?;
mongo_client mongo_client
.set_court_room( .set_court_room(
guild_id.into(), guild_id.into(),
@ -129,18 +131,17 @@ impl Lawsuit {
Ok(()) Ok(())
} }
assign_role(lawsuit.accused, &http, guild_id, room.role_id).await?;
assign_role(self.accused, &http, guild_id, room.role_id).await?; if let Some(accused_lawyer) = lawsuit.accused_lawyer {
if let Some(accused_lawyer) = self.accused_lawyer {
assign_role(accused_lawyer, &http, guild_id, room.role_id).await?; assign_role(accused_lawyer, &http, guild_id, room.role_id).await?;
} }
assign_role(self.plaintiff, &http, guild_id, room.role_id).await?; assign_role(lawsuit.plaintiff, &http, guild_id, room.role_id).await?;
if let Some(plaintiff_lawyer) = self.plaintiff_lawyer { if let Some(plaintiff_lawyer) = lawsuit.plaintiff_lawyer {
assign_role(plaintiff_lawyer, &http, guild_id, room.role_id).await?; assign_role(plaintiff_lawyer, &http, guild_id, room.role_id).await?;
} }
assign_role(self.judge, &http, guild_id, room.role_id).await?; assign_role(lawsuit.judge, &http, guild_id, room.role_id).await?;
info!(?self, "Created lawsuit"); info!(?lawsuit, "Created lawsuit");
Ok(()) Ok(())
} }
@ -166,28 +167,29 @@ impl Lawsuit {
.id .id
.send_message(http, |msg| { .send_message(http, |msg| {
msg.embed(|embed| { msg.embed(|embed| {
let lawsuit = &self.lawsuit;
embed embed
.title("Prozess") .title("Prozess")
.field("Grund", &self.reason, false) .field("Grund", &lawsuit.reason, false)
.field("Kläger", format!("<@{}>", self.plaintiff), false) .field("Kläger", format!("<@{}>", lawsuit.plaintiff), false)
.field( .field(
"Anwalt des Klägers", "Anwalt des Klägers",
match &self.plaintiff_lawyer { match &lawsuit.plaintiff_lawyer {
Some(lawyer) => format!("<@{}>", lawyer), Some(lawyer) => format!("<@{}>", lawyer),
None => "TBD".to_string(), None => "TBD".to_string(),
}, },
false, false,
) )
.field("Angeklagter", format!("<@{}>", self.accused), false) .field("Angeklagter", format!("<@{}>", lawsuit.accused), false)
.field( .field(
"Anwalt des Angeklagten", "Anwalt des Angeklagten",
match &self.accused_lawyer { match &lawsuit.accused_lawyer {
Some(lawyer) => format!("<@{}>", lawyer), Some(lawyer) => format!("<@{}>", lawyer),
None => "TBD".to_string(), None => "TBD".to_string(),
}, },
false, false,
) )
.field("Richter", format!("<@{}>", self.judge), false) .field("Richter", format!("<@{}>", lawsuit.judge), false)
}) })
}) })
.await .await
@ -203,78 +205,80 @@ impl Lawsuit {
Ok(Ok(())) Ok(Ok(()))
} }
}
async fn create_room( async fn create_room(
http: &Http, &self,
guild_id: GuildId, room_len: usize,
room_len: usize, category_id: SnowflakeId,
category_id: SnowflakeId, ) -> Result<Result<CourtRoom, Response>> {
mongo_client: &Mongo, let room_number = room_len + 1;
) -> Result<Result<CourtRoom, Response>> { let room_name = format!("gerichtsraum-{room_number}");
let room_number = room_len + 1; let role_name = format!("Gerichtsprozess {room_number}");
let room_name = format!("gerichtsraum-{room_number}");
let role_name = format!("Gerichtsprozess {room_number}");
let guild = guild_id let guild = self
.to_partial_guild(http) .guild_id
.await .to_partial_guild(&self.http)
.wrap_err("fetch partial guild")?; .await
.wrap_err("fetch partial guild")?;
let role_id = match guild.role_by_name(&role_name) { let role_id = match guild.role_by_name(&role_name) {
Some(role) => role.id, Some(role) => role.id,
None => { None => {
guild guild
.create_role(http, |role| { .create_role(&self.http, |role| {
role.name(role_name).permissions(Permissions::empty()) role.name(role_name).permissions(Permissions::empty())
}) })
.await .await
.wrap_err("create role")? .wrap_err("create role")?
.id .id
}
};
let channels = guild.channels(http).await.wrap_err("fetching channels")?;
let channel_id = match channels.values().find(|c| c.name() == room_name) {
Some(channel) => {
if channel.parent_id != Some(category_id.into()) {
return Ok(Err(Response::Simple(format!(
"de channel {room_name} isch i de falsche kategorie, man eh"
))));
} }
channel.id };
}
None => {
guild
.create_channel(http, |channel| {
channel
.name(room_name)
.category(category_id)
.permissions(vec![PermissionOverwrite {
allow: Permissions::SEND_MESSAGES,
deny: Permissions::empty(),
kind: PermissionOverwriteType::Role(role_id),
}])
})
.await
.wrap_err("create channel")?
.id
}
};
let room = CourtRoom { let channels = guild
channel_id: channel_id.into(), .channels(&self.http)
ongoing_lawsuit: false, .await
role_id: role_id.into(), .wrap_err("fetching channels")?;
};
mongo_client let channel_id = match channels.values().find(|c| c.name() == room_name) {
.add_court_room(guild_id.into(), &room) Some(channel) => {
.await if channel.parent_id != Some(category_id.into()) {
.wrap_err("add court room to database")?; return Ok(Err(Response::Simple(format!(
"de channel {room_name} isch i de falsche kategorie, man eh"
))));
}
channel.id
}
None => {
guild
.create_channel(&self.http, |channel| {
channel
.name(room_name)
.category(category_id)
.permissions(vec![PermissionOverwrite {
allow: Permissions::SEND_MESSAGES,
deny: Permissions::empty(),
kind: PermissionOverwriteType::Role(role_id),
}])
})
.await
.wrap_err("create channel")?
.id
}
};
info!(guild_id = %guild_id, channel_id = %channel_id, "Created new court room"); let room = CourtRoom {
channel_id: channel_id.into(),
ongoing_lawsuit: false,
role_id: role_id.into(),
};
Ok(Ok(room)) self.mongo_client
.add_court_room(self.guild_id.into(), &room)
.await
.wrap_err("add court room to database")?;
info!(guild_id = %self.guild_id, channel_id = %channel_id, "Created new court room");
Ok(Ok(room))
}
} }