use crate::{
SlackBlock, SlackClient, SlackError, SlackMessage, SlackSectionBlock, SlackText, SlackTextType,
};
use async_trait::async_trait;
use hookburn_core::{
BoxedWebhookSender, CoreError, GenericMessage, MessageConverter, Platform, ServiceBuilder,
ServiceConfig, ServiceInfo, WebhookSender,
};
use reqwest::Client;
use std::sync::Arc;
pub struct SlackService {
info: Arc<ServiceInfo>,
}
impl SlackService {
pub fn new() -> Self {
let info = ServiceInfo {
name: "slack".to_string(),
version: env!("CARGO_PKG_VERSION").to_string(),
description: "Slack webhook integration".to_string(),
webhook_url_format: "https://hooks.slack.com/services/{T}/{B}/{X}".to_string(),
supports_embeds: true,
max_content_length: 4000,
features: vec![
"blocks".to_string(),
"threads".to_string(),
"attachments".to_string(),
"markdown".to_string(),
"buttons".to_string(),
],
rate_limit_retry_after: Some(std::time::Duration::from_secs(1)),
documentation_url: Some("https://api.slack.com/messaging/webhooks".to_string()),
icon_url: Some("https://slack.com/favicon.ico".to_string()),
platforms: vec![Platform::Slack],
};
Self { info: Arc::new(info) }
}
}
impl ServiceBuilder for SlackService {
fn build(
&self,
config: ServiceConfig,
) -> Result<BoxedWebhookSender, Box<dyn std::error::Error + Send + Sync>> {
if !self.validate_url(&config.url) {
return Err(Box::new(SlackError::InvalidUrl {
reason: "Invalid Slack webhook URL".to_string(),
}));
}
let client = Client::builder().timeout(config.timeout).build()?;
let slack_client = SlackClient::with_client(config.url, client)?;
let wrapper = SlackSenderWrapper::new(slack_client);
let sender: BoxedWebhookSender = Box::new(wrapper);
Ok(sender)
}
fn info(&self) -> Arc<ServiceInfo> {
self.info.clone()
}
fn validate_url(&self, url: &str) -> bool {
url.starts_with("https://hooks.slack.com/services/")
}
}
pub struct SlackSenderWrapper {
inner: SlackClient,
converter: SlackMessageConverter,
}
impl SlackSenderWrapper {
pub fn new(inner: SlackClient) -> Self {
Self { inner, converter: SlackMessageConverter }
}
}
#[async_trait]
impl WebhookSender for SlackSenderWrapper {
type Message = GenericMessage;
type Error = CoreError;
async fn send(&self, message: &Self::Message) -> Result<(), Self::Error> {
let slack_message = self
.converter
.to_service(message)
.map_err(|e| CoreError::MessageConversionFailed(e.to_string()))?;
self.inner
.send(&slack_message)
.await
.map_err(|e| CoreError::ServiceError(e.to_string()))
}
}
pub struct SlackMessageConverter;
impl MessageConverter<SlackMessage> for SlackMessageConverter {
fn to_service(&self, generic: &GenericMessage) -> Result<SlackMessage, CoreError> {
let mut builder = SlackMessage::builder();
if let Some(content) = &generic.content {
builder = builder.text(content);
}
if let Some(username) = &generic.username {
builder = builder.username(username);
}
if let Some(avatar_url) = &generic.avatar_url {
builder = builder.icon_url(avatar_url);
}
for embed in &generic.embeds {
let mut text = String::new();
if let Some(title) = &embed.title {
text.push_str(&format!("*{}*\n", title));
}
if let Some(description) = &embed.description {
text.push_str(&format!("{}\n", description));
}
for field in &embed.fields {
text.push_str(&format!("*{}:* {}\n", field.name, field.value));
}
if !text.is_empty() {
builder = builder.block(SlackBlock::Section(SlackSectionBlock {
text: Some(SlackText { text_type: SlackTextType::Mrkdwn, text, emoji: None }),
fields: vec![],
accessory: None,
}));
}
}
builder
.build()
.map_err(|e| CoreError::MessageConversionFailed(e.to_string()))
}
fn to_generic(&self, service_msg: &SlackMessage) -> Result<GenericMessage, CoreError> {
let mut generic = GenericMessage::default();
generic.content = service_msg.text.clone();
generic.username = service_msg.username.clone();
generic.avatar_url = service_msg.icon_url.clone();
Ok(generic)
}
}