Merge remote-tracking branch 'origin/master'

# Conflicts:
#	scripty_bot_utils/Cargo.toml

Author: tazz4843

Cargo.lock

@@ -8,6 +8,7 @@ repository.workspace = true
 
 [dependencies]
 uuid.workspace = true
+http.workspace = true
 time.workspace = true
 sqlx.workspace = true
 tokio.workspace = true

scripty_bot_utils/Cargo.toml

@@ -1,3 +1,5 @@
+#![forbid(clippy::expect_used, clippy::unwrap_used)]
+
 use base64::{Engine, prelude::BASE64_STANDARD};
 use dashmap::DashMap;
 use reqwest::header::CONTENT_TYPE;
@@ -22,6 +24,8 @@ use serenity::{
 	},
 };
 
+use crate::Error;
+
 pub struct DmSupportStatus {
 	webhook_cache: DashMap<ChannelId, Webhook>,
 }
@@ -50,16 +54,22 @@ impl DmSupportStatus {
 			return;
 		}
 
-		if message.guild_id.is_none() {
-			self.handle_dm_message(ctx, message).await;
+		let msg_id = message.id;
+
+		let res = if message.guild_id.is_none() {
+			self.handle_dm_message(ctx, message).await
 		} else {
-			self.handle_guild_message(ctx, message).await;
+			self.handle_guild_message(ctx, message).await
+		};
+
+		if let Err(e) = res {
+			error!(%msg_id, "got error while handing DM support: {}", e);
 		}
 	}
 
-	async fn handle_dm_message(&self, ctx: Context, message: Message) {
-		let channel = self.get_or_create_channel(&ctx, &message.author).await;
-		let hook = self.get_webhook(&ctx, &channel.id).await;
+	async fn handle_dm_message(&self, ctx: Context, message: Message) -> Result<(), Error> {
+		let channel = self.get_or_create_channel(&ctx, &message.author).await?;
+		let hook = self.get_webhook(&ctx, &channel.id).await?;
 
 		let mut webhook_execute = ExecuteWebhook::default()
 			.avatar_url(message.author.face())
@@ -81,8 +91,7 @@ impl DmSupportStatus {
 						attachment.url.as_str(),
 						attachment.filename.to_string(),
 					)
-					.await
-					.expect("failed to handle message attachments"),
+					.await?,
 				);
 			}
 			webhook_execute = webhook_execute.files(attachments);
@@ -100,34 +109,35 @@ impl DmSupportStatus {
 
 		if let Err(e) = resp {
 			warn!("failed to send message to webhook: {:?}", e);
-			let _ = message
+			message
 				.reply(&ctx.http, format!("failed to send message: {}", e))
-				.await;
+				.await?;
 		}
+
+		Ok(())
 	}
 
-	async fn handle_guild_message(&self, ctx: Context, message: Message) {
+	async fn handle_guild_message(&self, ctx: Context, message: Message) -> Result<(), Error> {
 		let config = scripty_config::get_config();
 		if message.guild_id != Some(GuildId::new(config.dm_support.guild_id)) {
-			return;
+			return Ok(());
 		}
 		let message_channel = message
 			.channel(&ctx)
-			.await
-			.expect("failed to get message channel")
+			.await?
 			.guild()
-			.expect("should be in guild");
+			.ok_or_else(Error::expected_guild)?;
 
-		let category = get_forwarding_category(&ctx).await;
+		let category = get_forwarding_category(&ctx).await?;
 		if message_channel.parent_id != Some(category.id) {
-			return;
+			return Ok(());
 		}
 
 		let user_id = match message_channel.base.name.parse::<u64>() {
 			Ok(id) => id,
 			Err(e) => {
 				warn!("failed to parse user id from channel name: {:?}", e);
-				return;
+				return Ok(());
 			}
 		};
 
@@ -163,27 +173,33 @@ impl DmSupportStatus {
 				)
 				.await;
 		}
+
+		Ok(())
 	}
 
-	async fn get_or_create_channel(&self, ctx: &Context, user: &User) -> GuildChannel {
+	async fn get_or_create_channel(
+		&self,
+		ctx: &Context,
+		user: &User,
+	) -> Result<GuildChannel, Error> {
 		let config = scripty_config::get_config();
-		let category = get_forwarding_category(ctx).await;
+		let category = get_forwarding_category(ctx).await?;
 		let guild_id = GuildId::new(config.dm_support.guild_id);
 
 		let user_id_str = user.id.to_string();
 
 		let channel = {
 			ctx.cache
 				.guild(guild_id)
-				.expect("failed to get guild")
+				.ok_or_else(Error::expected_guild)?
 				.channels
 				.iter()
 				.find(|c| c.parent_id == Some(category.id) && c.base.name == user_id_str)
 				.cloned()
 		};
 
 		if let Some(channel) = channel {
-			return channel;
+			return Ok(channel);
 		}
 
 		let channel = guild_id
@@ -193,35 +209,26 @@ impl DmSupportStatus {
 					.category(category.id)
 					.kind(ChannelType::Text),
 			)
-			.await
-			.expect("failed to create channel");
+			.await?;
 
 		let user_face_url = user.face();
-		let resp = reqwest::get(user_face_url)
-			.await
-			.expect("failed to fetch url");
+		let resp = reqwest::get(user_face_url).await?;
 		let content_type = resp
 			.headers()
 			.get(CONTENT_TYPE)
-			.expect("expected Content-Type header")
-			.to_str()
-			.expect("not ASCII string");
+			.ok_or_else(|| Error::custom("expected Content-Type header".to_string()))?
+			.to_str()?;
 
 		let hook = channel
 			.create_webhook(
 				&ctx.http,
-				CreateWebhook::new(user.tag()).avatar(
-					ImageData::from_base64(format!(
-						"data:{};base64,{}",
-						content_type.to_ascii_lowercase(),
-						BASE64_STANDARD
-							.encode(resp.bytes().await.expect("failed to download image bytes"))
-					))
-					.expect("should always be valid image data"),
-				),
+				CreateWebhook::new(user.tag()).avatar(ImageData::from_base64(format!(
+					"data:{};base64,{}",
+					content_type.to_ascii_lowercase(),
+					BASE64_STANDARD.encode(resp.bytes().await?)
+				))?),
 			)
-			.await
-			.expect("failed to create webhook");
+			.await?;
 		self.webhook_cache.insert(channel.id, hook);
 
 		if let Err(e) = self.handle_opening(ctx, user.id).await {
@@ -231,11 +238,10 @@ impl DmSupportStatus {
 					&ctx.http,
 					CreateMessage::default().content(format!("failed to handle opening: {}", e)),
 				)
-				.await
-				.expect("failed to send message");
+				.await?;
 		}
 
-		channel
+		Ok(channel)
 	}
 
 	async fn handle_opening(&self, ctx: &Context, user: UserId) -> serenity::Result<()> {
@@ -254,45 +260,39 @@ impl DmSupportStatus {
 		.map(|_| ())
 	}
 
-	async fn get_webhook(&self, ctx: &Context, channel: &ChannelId) -> Webhook {
+	async fn get_webhook(&self, ctx: &Context, channel: &ChannelId) -> Result<Webhook, Error> {
 		let hook = self.webhook_cache.get(channel).map(|x| x.clone());
 		if let Some(hook) = hook {
-			return hook;
+			return Ok(hook);
 		}
 
-		if let Some(hook) = channel
-			.webhooks(&ctx.http)
-			.await
-			.expect("error fetching hooks")
-			.pop()
-		{
-			return hook;
+		if let Some(hook) = channel.webhooks(&ctx.http).await?.pop() {
+			return Ok(hook);
 		}
 
 		let hook = channel
 			.create_webhook(&ctx.http, CreateWebhook::new("Scripty"))
-			.await
-			.expect("failed to create webhook");
+			.await?;
 		self.webhook_cache.insert(*channel, hook.clone());
-		hook
+		Ok(hook)
 	}
 
-	pub async fn close_ticket(&self, ctx: &Context, channel: GuildChannel) {
+	pub async fn close_ticket(&self, ctx: &Context, channel: GuildChannel) -> Result<(), Error> {
 		let config = scripty_config::get_config();
 		if channel.base.guild_id != GuildId::new(config.dm_support.guild_id) {
-			return;
+			return Ok(());
 		}
 
-		let category = get_forwarding_category(ctx).await;
+		let category = get_forwarding_category(ctx).await?;
 		if channel.parent_id != Some(category.id) {
-			return;
+			return Ok(());
 		}
 
 		let user_id = match channel.base.name.parse::<u64>() {
 			Ok(id) => UserId::new(id),
 			Err(e) => {
 				warn!("failed to parse user id from channel name: {:?}", e);
-				return;
+				return Ok(());
 			}
 		};
 
@@ -313,15 +313,17 @@ impl DmSupportStatus {
 
 		self.webhook_cache.remove(&channel.id);
 
-		let _ = channel
+		channel
 			.delete(&ctx.http, Some("DM support ticket closed"))
-			.await;
+			.await?;
+
+		Ok(())
 	}
 }
 
-async fn get_forwarding_category(ctx: &Context) -> GuildChannel {
+async fn get_forwarding_category(ctx: &Context) -> Result<GuildChannel, Error> {
 	ChannelId::new(scripty_config::get_config().dm_support.forwarding_category)
 		.to_guild_channel(&ctx, None)
 		.await
-		.expect("failed to get forwarding category")
+		.map_err(Error::from)
 }

scripty_bot_utils/src/dm_support.rs

@@ -5,6 +5,7 @@ use std::{
 };
 
 use backtrace::Backtrace;
+use http::header::ToStrError;
 use scripty_stt::{ModelError, OpusSourceError};
 use serenity::{http::JsonErrorCode, model::channel::ChannelType, prelude::SerenityError};
 
@@ -35,6 +36,8 @@ pub enum ErrorEnum {
 	ExpectedGuild,
 	ExpectedChannel,
 	Join(scripty_audio_handler::JoinError),
+	Reqwest(reqwest::Error),
+	ToStr(ToStrError),
 	ManualError,
 	Redis(scripty_redis::redis::RedisError),
 	RedisPool(scripty_redis::PoolError),
@@ -100,6 +103,20 @@ impl Error {
 		}
 	}
 
+	pub fn reqwest(err: reqwest::Error) -> Self {
+		Error {
+			bt:  Backtrace::new_unresolved(),
+			err: ErrorEnum::Reqwest(err),
+		}
+	}
+
+	pub fn to_str(err: ToStrError) -> Self {
+		Error {
+			bt:  Backtrace::new_unresolved(),
+			err: ErrorEnum::ToStr(err),
+		}
+	}
+
 	#[inline]
 	pub fn manual() -> Self {
 		Error {
@@ -245,6 +262,8 @@ impl Display for Error {
 			ExpectedGuild => "expected this to be in a guild".into(),
 			ExpectedChannel => "expected this to be in a channel".into(),
 			Join(e) => format!("failed to join VC: {}", e).into(),
+			Reqwest(e) => format!("error while sending http request: {}", e).into(),
+			ToStr(e) => format!("error decoding http headers into string: {}", e).into(),
 			ManualError => "manual error".into(),
 			Redis(e) => format!("Redis returned an error: {}", e).into(),
 			RedisPool(e) => format!("Redis pool returned an error: {}", e).into(),
@@ -283,6 +302,8 @@ impl StdError for Error {
 			ExpectedGuild => None,
 			ExpectedChannel => None,
 			Join(e) => Some(e),
+			Reqwest(e) => Some(e),
+			ToStr(e) => Some(e),
 			ManualError => None,
 			Redis(e) => Some(e),
 			RedisPool(e) => Some(e),
@@ -356,6 +377,24 @@ impl From<scripty_audio_handler::JoinError> for Error {
 	}
 }
 
+impl From<reqwest::Error> for Error {
+	fn from(e: reqwest::Error) -> Self {
+		Self {
+			err: ErrorEnum::Reqwest(e),
+			bt:  Backtrace::new_unresolved(),
+		}
+	}
+}
+
+impl From<ToStrError> for Error {
+	fn from(e: ToStrError) -> Self {
+		Self {
+			err: ErrorEnum::ToStr(e),
+			bt:  Backtrace::new_unresolved(),
+		}
+	}
+}
+
 impl From<scripty_redis::redis::RedisError> for Error {
 	#[inline]
 	fn from(e: scripty_redis::redis::RedisError) -> Self {

scripty_bot_utils/src/error/error_type.rs

@@ -265,5 +265,17 @@ fn format_transcript_msg<'a>(
 
 			msg
 		}
+
+		TranscriptResultEnum::DiscordError { error } => {
+			msg_content.push('\n');
+			msg_content.push_str(&format_message!(
+				resolved_language,
+				"transcribe-message-discord-error",
+				filename: filename.to_string(),
+				error: format!("{:?}", error)
+			));
+
+			msg
+		}
 	}
 }