Struct slack_blocks::blocks::actions::Contents

pub struct Contents<'a> { /* fields omitted */ }

Actions Block

slack api docs 🔗

A block that is used to hold interactive elements 🔗

Implementations

impl<'a> Contents<'a>

pub fn new() -> Self

Create an empty Actions block (shorthand for Default::default())

Example

use slack_blocks::blocks::{actions, Block};

let actions = actions::Contents::new();
let block: Block = actions.into();
// < send block to slack's API >

pub fn with_block_id(self, block_id: impl ToString) -> Self

Set the block_id for interactions on an existing actions::Contents

Arguments

• block_id - A string acting as a unique identifier for a block. You can use this block_id when you receive an interaction payload to identify the source of the action 🔗. If not specified, a block_id will be generated. Maximum length for this field is 255 characters.

Example

use slack_blocks::blocks::{actions, Block};

let actions = actions::Contents::new().with_block_id("tally_ho");
let block: Block = actions.into();
// < send block to slack's API >

pub fn from_elements<Iter>(elements: Iter) -> Result<Self, ()> where
    Iter: IntoIterator<Item = BlockElement<'a>>, 

Populate an Actions block with a collection of elems::BlockElements, which may not be supported by Actions blocks.

If you can create a collection of actions::BlockElement, either by creating them directly or invoking elems::BlockElement::into, use from_action_elements.

Arguments

• elements - An array of interactive element objects 🔗 For a list of BlockElement types that are, see BlockElement. There is a maximum of 5 elements in each action block.

Errors

Errors if the elems::BlockElement is one that is not supported by Actions blocks.

For a list of BlockElement types that are supported, see ::blocks::actions::BlockElement.

Runtime Validation

only validates that the block elements are compatible with Actions, for full runtime model validation see the validate method.

Example

use slack_blocks::{blocks::{actions, Block},
                   compose,
                   elems};

let btn = elems::Button::from_text_and_action_id("Button", "123");
let actions = actions::Contents::from_elements(vec![btn.into()])?;
let block: Block = actions.into();
// < send block to slack's API >

pub fn from_action_elements<Iter>(elements: Iter) -> Self where
    Iter: IntoIterator<Item = BlockElement<'a>>, 

Populate an Actions block with a collection of BlockElements that are supported by Actions blocks.

This also can be called via the From<Vec<self::BlockElement>> implementation.

If you have a collection of elements that may not be supported, see from_elements.

Arguments

• elements - An array of interactive element objects 🔗 For a list of BlockElement types that are supported, see BlockElement. There is a maximum of 5 elements in each action block. Note that if you only ever want 1 item you can choose to pass it Some(element) OR std::iter::once(element) instead of a Vec, bypassing an expensive allocation. Iterator and Option implement IntoIterator 🔗.

Errors

Errors if the elems::BlockElement is one that is not supported by Actions blocks.

Runtime Validation

only validates that the block elements are compatible with Actions, for full runtime model validation see the validate method.

Example

use slack_blocks::{blocks::{actions, Block},
                   compose,
                   elems};

let btn = elems::Button::from_text_and_action_id("Button", "123");
let actions = actions::Contents::from_action_elements(vec![btn.into()]);
let block: Block = actions.into();

// < send block to slack's API >

pub fn validate(&self) -> Result<(), ValidationErrors>

Validate that this Section block agrees with Slack’s model requirements

Errors

• If with_block_id was called with a block id longer than 255 chars
• If from_elements or from_action_elements was called with more than 5 elements.

Example

use slack_blocks::{blocks, compose};

let long_string = std::iter::repeat(' ').take(256).collect::<String>();

let block = blocks::actions
    ::Contents
    ::from_action_elements(vec![])
    .with_block_id(long_string);

assert!(matches!(block.validate(), Err(_)));

Trait Implementations

impl<'a> Clone for Contents<'a>

fn clone(&self) -> Contents<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Contents<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Default for Contents<'a>

fn default() -> Contents<'a>

Returns the “default value” for a type.

impl<'de, 'a> Deserialize<'de> for Contents<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'a> From<Contents<'a>> for Block<'a>

fn from(src: Actions<'a>) -> Self

Performs the conversion.

impl<'a> From<Vec<BlockElement<'a>, Global>> for Contents<'a>

fn from(src: Vec<BlockElement<'a>>) -> Self

Performs the conversion.

impl<'a> Hash for Contents<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq<Contents<'a>> for Contents<'a>

fn eq(&self, other: &Contents<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Contents<'a>) -> bool

This method tests for !=.

impl<'a> Serialize for Contents<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'a> TryFrom<BlockElement<'a>> for Contents<'a>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(element: BlockElement<'a>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<Vec<BlockElement<'a>, Global>> for Contents<'a>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(elements: Vec<BlockElement<'a>>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> Validate for Contents<'a>

fn validate(&self) -> Result<(), ValidationErrors>

impl<'a> StructuralPartialEq for Contents<'a>