Struct sendblue::SendblueClient

pub struct SendblueClient {
    pub api_key: String,
    pub api_secret: String,
    pub client: Client,
    /* private fields */
}

Client for the Sendblue API

The SendblueClient struct provides methods for interacting with the Sendblue API.

Examples

use sendblue::SendblueClient;

let client = SendblueClient::new("your_api_key".into(), "your_api_secret".into());

Fields

api_key: String

api_secret: String

client: Client

Implementations

impl SendblueClient

pub fn new(api_key: String, api_secret: String) -> Self

Creates a new Sendblue client with the default reqwest client

Arguments

• api_key - The API key for authentication
• api_secret - The API secret for authentication

Returns

• SendblueClient - A new Sendblue client instance

Examples

use sendblue::SendblueClient;

let client = SendblueClient::new("your_api_key".into(), "your_api_secret".into());

pub fn new_with_url( api_key: String, api_secret: String, base_url: String, ) -> Self

Creates a new Sendblue client with a custom base URL

Arguments

• api_key - The API key for authentication
• api_secret - The API secret for authentication
• base_url - The base URL for the API

Returns

• SendblueClient - A new Sendblue client instance

This is a private function and not intended for public use.

pub async fn send<T: SendableMessage>( &self, message: &T, ) -> Result<T::ResponseType, SendblueError>

Sends a message using the Sendblue API

Arguments

• message - The message to be sent

Returns

• MessageResponse - The response from the Sendblue API
• SendblueError - An error that occurred during the request

Examples

Sending a normal message:

use sendblue::SendblueClient;
use sendblue::models::MessageBuilder;

#[tokio::main]
async fn main() {
    let client = SendblueClient::new("your_api_key".into(), "your_api_secret".into());

    let message = MessageBuilder::new(phonenumber::parse(None, "+10722971673").unwrap())
        .content("Hello, world!".into())
        .build()
        .unwrap();

    match client.send(&message).await {
        Ok(response) => println!("Message sent: {:?}", response),
        Err(e) => eprintln!("Error sending message: {:?}", e),
    }
}

Sending a group message:

use sendblue::SendblueClient;
use sendblue::models::{MessageBuilder, GroupMessage};

#[tokio::main]
async fn main() {
    let client = SendblueClient::new("your_api_key".into(), "your_api_secret".into());

    let group_message = MessageBuilder::<GroupMessage>::new_group()
        .numbers(vec![phonenumber::parse(None, "+10722971673").unwrap(), phonenumber::parse(None, "+10722971673").unwrap()])
        .content("Hello, group!".into())
        .build()
        .unwrap();

    match client.send::<>(&group_message).await {
        Ok(response) => println!("Group message sent: {:?}", response),
        Err(e) => eprintln!("Error sending group message: {:?}", e),
    }
}

pub async fn get_messages( &self, params: GetMessagesParams, ) -> Result<GetMessagesResponse, SendblueError>

Retrieves messages using the Sendblue API

Arguments

• params - The parameters for filtering and paginating messages

Returns

• GetMessagesResponse - The response containing the retrieved messages
• SendblueError - An error that occurred during the request

Examples

use sendblue::SendblueClient;
use sendblue::models::{GetMessagesParamsBuilder};

#[tokio::main]
async fn main() {
    let client = SendblueClient::new("your_api_key".into(), "your_api_secret".into());

    let params = GetMessagesParamsBuilder::new()
        .limit(Some(50))
        .offset(Some(0))
        .number(Some(phonenumber::parse(None, "+10722971673").unwrap()))
        .from_date(Some("2023-06-15 12:00:00".into()))
        .cid(None)
        .build();

    match client.get_messages(params).await {
        Ok(response) => println!("Messages retrieved: {:?}", response.messages),
        Err(e) => eprintln!("Error retrieving messages: {:?}", e),
    }
}

pub async fn evaluate_service( &self, evaluate_service: &EvaluateService, ) -> Result<EvaluateServiceResponse, SendblueError>

Evaluates if a number can send/receive iMessages using the Sendblue API

Arguments

• evaluate_service - The evaluation request containing the phone number in E.164 format

Returns

• EvaluateServiceResponse - The response containing the evaluation result
• SendblueError - An error that occurred during the request

Examples

use sendblue::SendblueClient;
use sendblue::models::{EvaluateServiceBuilder};

#[tokio::main]
async fn main() {
    let client = SendblueClient::new("your_api_key".into(), "your_api_secret".into());

let evaluate_service = EvaluateServiceBuilder::new()
    .number(phonenumber::parse(None, "+10722971673").unwrap())
    .build();

    match client.evaluate_service(&evaluate_service).await {
        Ok(response) => println!("Evaluation result: {:?}", response),
        Err(e) => eprintln!("Error evaluating number: {:?}", e),
    }
}

pub async fn send_typing_indicator( &self, number: &PhoneNumber, ) -> Result<TypingIndicatorResponse, SendblueError>

Sends a typing indicator to a recipient using the Sendblue API

Arguments

• number - The recipient’s phone number in E.164 format

Returns

• TypingIndicatorResponse - The response from the Sendblue API
• SendblueError - An error that occurred during the request

Examples

use sendblue::SendblueClient;

#[tokio::main]
async fn main() {
    let client = SendblueClient::new("your_api_key".into(), "your_api_secret".into());

    let number = phonenumber::parse(None, "+10722971673").unwrap();

    match client.send_typing_indicator(&number).await {
        Ok(response) => println!("Typing indicator sent: {:?}", response),
        Err(e) => eprintln!("Error sending typing indicator: {:?}", e),
    }
}