use crate::error::SlackError;
use serde::Serialize;
#[derive(Debug, Clone, Serialize, Default)]
pub struct SlackMessage {
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub blocks: Vec<SlackBlock>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub attachments: Vec<SlackAttachment>,
#[serde(skip_serializing_if = "Option::is_none")]
pub thread_ts: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reply_broadcast: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub icon_emoji: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub icon_url: Option<String>,
}
impl SlackMessage {
pub fn builder() -> SlackMessageBuilder {
SlackMessageBuilder::default()
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(tag = "type")]
pub enum SlackBlock {
#[serde(rename = "section")]
Section(SlackSectionBlock),
#[serde(rename = "divider")]
Divider,
#[serde(rename = "header")]
Header(SlackHeaderBlock),
#[serde(rename = "actions")]
Actions(SlackActionsBlock),
#[serde(rename = "context")]
Context(SlackContextBlock),
}
#[derive(Debug, Clone, Serialize)]
pub struct SlackSectionBlock {
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<SlackText>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub fields: Vec<SlackText>,
#[serde(skip_serializing_if = "Option::is_none")]
pub accessory: Option<SlackAccessory>,
}
#[derive(Debug, Clone, Serialize)]
pub struct SlackHeaderBlock {
pub text: SlackText,
}
#[derive(Debug, Clone, Serialize)]
pub struct SlackActionsBlock {
pub elements: Vec<SlackElement>,
}
#[derive(Debug, Clone, Serialize)]
pub struct SlackContextBlock {
pub elements: Vec<SlackText>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(tag = "type")]
pub enum SlackElement {
#[serde(rename = "button")]
Button(SlackButton),
#[serde(rename = "datepicker")]
DatePicker(SlackDatePicker),
}
#[derive(Debug, Clone, Serialize)]
pub struct SlackButton {
pub text: SlackText,
pub value: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub style: Option<String>,
}
#[derive(Debug, Clone, Serialize)]
pub struct SlackDatePicker {
pub placeholder: SlackText,
pub action_id: String,
}
#[derive(Debug, Clone, Serialize)]
pub struct SlackText {
#[serde(rename = "type")]
pub text_type: SlackTextType,
pub text: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub emoji: Option<bool>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum SlackTextType {
PlainText,
Mrkdwn,
}
#[derive(Debug, Clone, Serialize)]
pub struct SlackAccessory {
#[serde(rename = "type")]
pub accessory_type: String,
pub image_url: String,
pub alt_text: String,
}
#[derive(Debug, Clone, Serialize)]
pub struct SlackAttachment {
pub color: Option<String>,
pub pretext: Option<String>,
pub text: Option<String>,
pub fields: Vec<SlackAttachmentField>,
}
#[derive(Debug, Clone, Serialize)]
pub struct SlackAttachmentField {
pub title: String,
pub value: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub short: Option<bool>,
}
#[derive(Default)]
pub struct SlackMessageBuilder {
inner: SlackMessage,
}
impl SlackMessageBuilder {
pub fn text(mut self, text: impl Into<String>) -> Self {
self.inner.text = Some(text.into());
self
}
pub fn block(mut self, block: SlackBlock) -> Self {
self.inner.blocks.push(block);
self
}
pub fn blocks(mut self, blocks: Vec<SlackBlock>) -> Self {
self.inner.blocks = blocks;
self
}
pub fn username(mut self, username: impl Into<String>) -> Self {
self.inner.username = Some(username.into());
self
}
pub fn icon_emoji(mut self, emoji: impl Into<String>) -> Self {
self.inner.icon_emoji = Some(emoji.into());
self
}
pub fn icon_url(mut self, url: impl Into<String>) -> Self {
self.inner.icon_url = Some(url.into());
self
}
pub fn thread_ts(mut self, ts: impl Into<String>) -> Self {
self.inner.thread_ts = Some(ts.into());
self
}
pub fn reply_broadcast(mut self, broadcast: bool) -> Self {
self.inner.reply_broadcast = Some(broadcast);
self
}
pub fn build(self) -> Result<SlackMessage, SlackError> {
if self.inner.text.is_none() && self.inner.blocks.is_empty() {
return Err(SlackError::EmptyMessage);
}
Ok(self.inner)
}
}