Struct slack_blocks::blocks::Section

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

Section Block

slack api docs 🔗

Available in surfaces:

• modals 🔗
• messages 🔗
• home tabs 🔗

A section is one of the most flexible blocks available - it can be used as a simple text block, in combination with text fields, or side-by-side with any of the available block elements 🔗

Implementations

impl<'a> Section<'a>

pub fn builder() -> SectionBuilderInit<'a>

Build a new section block

For example, see blocks::section::build::SectionBuilder.

pub fn from_fields<I>(fields: I) -> Self where
    I: Into<Cow<'a, [Text]>>, 

Construct a Section block from a collection of text objects

Arguments

• fields - A collection of text objects 🔗. Any text objects included with fields will be rendered in a compact format that allows for 2 columns of side-by-side text. Maximum number of items is 10. Maximum length for the text in each item is 2000 characters.

Errors

Doesn’t error. To validate your model against the length requirements, use the validate method.

Example

use slack_blocks::{blocks, compose::text};

let fields = vec!["Left column", "Right column"].into_iter()
                                                .map(|s: &str| -> text::Text {
                                                  text::Plain::from(s).into()
                                                })
                                                .collect::<Vec<_>>();

let block = blocks::Section::from_fields(&fields);

// < send to slack API >

pub fn from_text(text: impl Into<Text>) -> Self

Construct a Section block from a text object

Arguments

• text - The text for the block, in the form of a text object 🔗. Maximum length for the text in this field is 3000 characters.

Errors

Doesn’t error. To validate your model against the length requirements, use the validate method.

Example

use slack_blocks::{blocks, compose::text};

let block = blocks::Section::from_text(text::Plain::from("I am a section!"));

// < send to slack API >

pub fn with_block_id(self, block_id: impl Into<Cow<'a, str>>) -> Self

Set a unique block_id to identify this instance of an Section Block.

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, one will be generated. Maximum length for this field is 255 characters. block_id should be unique for each message and each iteration of a message. If a message is updated, use a new block_id.

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

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

Errors

• If from_fields was called with more than 10 fields, or one of the fields contains text longer than 2000 chars
• If from_fields was called with one of the fields containing text longer than 2000 chars
• If from_text was called with text longer than 3000 chars
• If with_block_id was called with a block id longer than 255 chars

Example

use slack_blocks::{blocks, compose::text};

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

let block = blocks::Section
    ::from_text(text::Plain::from("file_id"))
    .with_block_id(long_string);

assert_eq!(true, matches!(block.validate(), Err(_)));

// < send to slack API >

Trait Implementations

impl<'a> Clone for Section<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Section<'a>

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

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for Section<'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<Section<'a>> for Block<'a>

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

Performs the conversion.

impl<'a> Hash for Section<'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<Section<'a>> for Section<'a>

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

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

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

This method tests for !=.

impl<'a> Serialize for Section<'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> Validate for Section<'a>

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

impl<'a> StructuralPartialEq for Section<'a>