hookburn_slack/
service.rs1use crate::{
3 SlackBlock, SlackClient, SlackError, SlackMessage, SlackSectionBlock, SlackText, SlackTextType,
4};
5use async_trait::async_trait;
6use hookburn_core::{
7 BoxedWebhookSender, CoreError, GenericMessage, MessageConverter, Platform, ServiceBuilder,
8 ServiceConfig, ServiceInfo, WebhookSender,
9};
10use reqwest::Client;
11use std::sync::Arc;
12
13pub struct SlackService {
19 info: Arc<ServiceInfo>,
20}
21
22impl SlackService {
23 pub fn new() -> Self {
25 let info = ServiceInfo {
26 name: "slack".to_string(),
27 version: env!("CARGO_PKG_VERSION").to_string(),
28 description: "Slack webhook integration".to_string(),
29 webhook_url_format: "https://hooks.slack.com/services/{T}/{B}/{X}".to_string(),
30 supports_embeds: true,
31 max_content_length: 4000,
32 features: vec![
33 "blocks".to_string(),
34 "threads".to_string(),
35 "attachments".to_string(),
36 "markdown".to_string(),
37 "buttons".to_string(),
38 ],
39 rate_limit_retry_after: Some(std::time::Duration::from_secs(1)),
40 documentation_url: Some("https://api.slack.com/messaging/webhooks".to_string()),
41 icon_url: Some("https://slack.com/favicon.ico".to_string()),
42 platforms: vec![Platform::Slack],
43 };
44 Self { info: Arc::new(info) }
45 }
46}
47
48impl ServiceBuilder for SlackService {
49 fn build(
50 &self,
51 config: ServiceConfig,
52 ) -> Result<BoxedWebhookSender, Box<dyn std::error::Error + Send + Sync>> {
53 if !self.validate_url(&config.url) {
54 return Err(Box::new(SlackError::InvalidUrl {
55 reason: "Invalid Slack webhook URL".to_string(),
56 }));
57 }
58
59 let client = Client::builder().timeout(config.timeout).build()?;
60 let slack_client = SlackClient::with_client(config.url, client)?;
61
62 let wrapper = SlackSenderWrapper::new(slack_client);
64 let sender: BoxedWebhookSender = Box::new(wrapper);
65
66 Ok(sender)
67 }
68
69 fn info(&self) -> Arc<ServiceInfo> {
70 self.info.clone()
71 }
72
73 fn validate_url(&self, url: &str) -> bool {
74 url.starts_with("https://hooks.slack.com/services/")
75 }
76}
77
78pub struct SlackSenderWrapper {
84 inner: SlackClient,
85 converter: SlackMessageConverter,
86}
87impl SlackSenderWrapper {
89 pub fn new(inner: SlackClient) -> Self {
91 Self { inner, converter: SlackMessageConverter }
92 }
93}
94#[async_trait]
95impl WebhookSender for SlackSenderWrapper {
96 type Message = GenericMessage;
97 type Error = CoreError;
98
99 async fn send(&self, message: &Self::Message) -> Result<(), Self::Error> {
100 let slack_message = self
102 .converter
103 .to_service(message)
104 .map_err(|e| CoreError::MessageConversionFailed(e.to_string()))?;
105
106 self.inner
108 .send(&slack_message)
109 .await
110 .map_err(|e| CoreError::ServiceError(e.to_string()))
111 }
112}
113
114pub struct SlackMessageConverter;
120
121impl MessageConverter<SlackMessage> for SlackMessageConverter {
122 fn to_service(&self, generic: &GenericMessage) -> Result<SlackMessage, CoreError> {
123 let mut builder = SlackMessage::builder();
124
125 if let Some(content) = &generic.content {
126 builder = builder.text(content);
127 }
128 if let Some(username) = &generic.username {
129 builder = builder.username(username);
130 }
131 if let Some(avatar_url) = &generic.avatar_url {
132 builder = builder.icon_url(avatar_url);
133 }
134
135 for embed in &generic.embeds {
137 let mut text = String::new();
138 if let Some(title) = &embed.title {
139 text.push_str(&format!("*{}*\n", title));
140 }
141 if let Some(description) = &embed.description {
142 text.push_str(&format!("{}\n", description));
143 }
144 for field in &embed.fields {
145 text.push_str(&format!("*{}:* {}\n", field.name, field.value));
146 }
147
148 if !text.is_empty() {
149 builder = builder.block(SlackBlock::Section(SlackSectionBlock {
150 text: Some(SlackText { text_type: SlackTextType::Mrkdwn, text, emoji: None }),
151 fields: vec![],
152 accessory: None,
153 }));
154 }
155 }
156
157 builder
158 .build()
159 .map_err(|e| CoreError::MessageConversionFailed(e.to_string()))
160 }
161
162 fn to_generic(&self, service_msg: &SlackMessage) -> Result<GenericMessage, CoreError> {
163 let mut generic = GenericMessage::default();
164 generic.content = service_msg.text.clone();
165 generic.username = service_msg.username.clone();
166 generic.avatar_url = service_msg.icon_url.clone();
167 Ok(generic)
169 }
170}