flawless_slack/

lib.rs

#![doc = include_str!("../Readme.md")]

pub mod http_client;

use http_client::{HttpClient, HttpClientError};

use serde::Deserialize;

/// Represents a Slack client that interacts with the Slack API using the provided HTTP client.
pub struct SlackClient<T: HttpClient> {
    token: String,
    client: T,
}

/// Represents errors that can occur during interactions with the Slack API.
#[derive(Debug)]
pub enum SlackClientError {
    /// Error related to HTTP client operations.
    HttpClientError(HttpClientError),
    /// Error related to JSON deserialization.
    JsonError(serde_json::Error),
    /// Generic error with a descriptive string.
    Error(String),
}

impl From<serde_json::Error> for SlackClientError {
    fn from(err: serde_json::Error) -> Self {
        SlackClientError::JsonError(err)
    }
}

impl From<HttpClientError> for SlackClientError {
    fn from(err: HttpClientError) -> Self {
        SlackClientError::HttpClientError(err)
    }
}

/// Represents an element in a Slack message block.
#[derive(Debug, Deserialize)]
pub struct Element {
    /// The type of the element.
    #[serde(rename = "type")]
    pub element_type: String,
    /// The text content of the element.
    pub text: Option<String>,
}

/// Represents a block in a Slack message.
#[derive(Debug, Deserialize)]
pub struct Block {
    /// The type of the block.
    #[serde(rename = "type")]
    pub block_type: String,
    /// The unique identifier of the block.
    pub block_id: String,
    /// Elements within the block.
    pub elements: Vec<Element>,
}

/// Represents a Slack message.
#[derive(Debug, Deserialize)]
pub struct Message {
    #[serde(default)]
    /// The ID of the bot that sent the message.
    pub bot_id: Option<String>,
    /// The user who sent the message.
    pub user: String,
    /// The text content of the message.
    pub text: Option<String>,
    /// The timestamp of the message.
    pub ts: Option<String>,
}

/// Represents the response structure when getting messages from Slack.
#[derive(Debug, Deserialize)]
struct GetMessagesResponse {
    /// The list of messages retrieved from Slack.
    messages: Vec<Message>,
}

/// Represents a Slack channel.
#[derive(Debug, Deserialize)]
pub struct Channel {
    /// The unique identifier of the channel.
    id: String,
    /// The name of the channel.
    name: String,
}

#[derive(Debug, Deserialize)]
struct ListConversationsResponse {
    channels: Vec<Channel>,
}

impl<T: HttpClient> SlackClient<T> {
    /// Creates a new instance of `SlackClient` with the specified token and HTTP client.
    ///
    /// # Arguments
    ///
    /// * `token` - A String containing the Slack API token.
    /// * `client` - An HTTP client implementing the `HttpClient` trait.
    ///
    /// # Returns
    ///
    /// A new instance of `SlackClient`.
    pub fn new(token: String, client: T) -> SlackClient<T> {
        SlackClient { token, client }
    }

    /// Sends a message to a Slack channel.
    ///
    /// # Arguments
    ///
    /// * `channel` - The name or ID of the channel where the message will be sent.
    /// * `text` - The text of the message to be sent.
    ///
    /// # Returns
    ///
    /// Returns `Ok(())` on success, or an error of type `SlackClientError` on failure.
    pub fn send_message(&self, channel: &str, text: &str) -> Result<(), SlackClientError> {
        let url = "https://slack.com/api/chat.postMessage";

        let token = format!("Bearer {}", self.token);
        let params = [("Authorization", token.as_str()), ("Content-Type", "application/json")];

        let payload = format!("{{\"channel\": \"{}\", \"text\": \"{}\"}}", channel, text);

        let result = self.client.post(url, &params, &payload);

        result.map_err(SlackClientError::HttpClientError).map(|response| {
            if response.contains("\"ok\":false") {
                Err(SlackClientError::Error(response))
            } else {
                Ok(())
            }
        })?
    }

    /// Retrieves messages from a Slack channel.
    ///
    /// # Arguments
    ///
    /// * `channel` - The name or ID of the channel from which to retrieve messages.
    ///
    /// # Returns
    ///
    /// Returns a vector of `Message` on success, or an error of type `SlackClientError` on failure.
    pub fn get_messages(&self, channel: &str) -> Result<Vec<Message>, SlackClientError> {
        let url = "https://slack.com/api/conversations.history";

        let token = format!("Bearer {}", self.token);
        let params = [("Authorization", token.as_str()), ("Content-Type", "application/json")];

        let mut channel_id = channel.to_string();
        if channel.starts_with('#') {
            let channels = self.get_channels()?;
            channel_id = channels.iter().find(|c| c.name == channel[1..]).unwrap().id.clone();
        }

        let queries = [("channel", channel_id.as_str())];

        let response = self.client.get(url, &params, &queries)?;

        let result: GetMessagesResponse = serde_json::from_str(&response)?;

        Ok(result.messages)
    }

    /// Retrieves a list of Slack channels.
    ///
    /// # Returns
    ///
    /// Returns a vector of `Channel` on success, or an error of type `SlackClientError` on failure.
    pub fn get_channels(&self) -> Result<Vec<Channel>, SlackClientError> {
        let url = "https://slack.com/api/conversations.list";

        let token = format!("Bearer {}", self.token);
        let params = [("Authorization", token.as_str()), ("Content-Type", "application/json")];

        let response = self.client.get(url, &params, &[])?;

        let result: ListConversationsResponse = serde_json::from_str(&response)?;

        Ok(result.channels)
    }
}