Struct slack_blocks::blocks::Input

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

Input Block

slack api docs 🔗

A block that collects information from users -

Read slack’s guide to using modals 🔗 to learn how input blocks pass information to your app.

Implementations

impl<'a> Input<'a>

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

Build a new input block

For example, see blocks::input::build::InputBuilder.

pub fn from_label_and_element(
    label: impl Into<Plain>,
    element: impl Into<SupportedElement<'a>>
) -> Self

Create an Input Block from a text Label and interactive element.

Arguments

• label - A label that appears above an input element in the form of a text object 🔗 that must have type of plain_text. Maximum length for the text in this field is 2000 characters.

• element - An interactive block_element that will be used to gather the input for this block. For the kinds of Elements supported by Input blocks, see the SupportedElement enum. For info about Block Elements in general, see the elems module.

Example

use slack_blocks::elems::Select;
use slack_blocks::blocks;

let label = "On a scale from 1 - 5, how angsty are you?";
let input = Select::from_placeholder_and_action_id("Pick a channel...", "ABC123")
    .choose_from_public_channels();

let block = blocks::Input::from_label_and_element(label, input);

// < 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 Input 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.

Example

use slack_blocks::elems::Select;
use slack_blocks::blocks;

let label = "On a scale from 1 - 5, how angsty are you?";
let input = Select::from_placeholder_and_action_id("Pick a channel...", "ABC123")
    .choose_from_public_channels();

let block = blocks::Input
    ::from_label_and_element(label, input)
    .with_block_id("angst_rating_12345");

// < send to slack API >

pub fn with_hint(self, hint: impl Into<Plain>) -> Self

Set the hint on this Input Block that appears below an input element in a lighter grey.

Arguments

• hint - An optional hint that appears below an input element in a lighter grey. It must be a a text object 🔗 with a type of plain_text. Maximum length for the text in this field is 2000 characters.

Example

use slack_blocks::elems::Select;
use slack_blocks::blocks;

let label = "On a scale from 1 - 5, how angsty are you?";
let input = Select::from_placeholder_and_action_id("Pick a channel...", "ABC123")
    .choose_from_public_channels();

let block = blocks::Input
    ::from_label_and_element(label, input)
    .with_hint("PSST hey! Don't let them know how angsty you are!");

// < send to slack API >

pub fn with_optional(self, optionality: bool) -> Self

Set whether or not this input is Optional.

Arguments

• optionality - A boolean that indicates whether the input element may be empty when a user submits the modal. Defaults to false.

Example

use slack_blocks::elems::Select;
use slack_blocks::blocks;

let label = "On a scale from 1 - 5, how angsty are you?";
let input = Select::from_placeholder_and_action_id("Pick a channel...", "ABC123")
    .choose_from_public_channels();

let block = blocks::Input
    ::from_label_and_element(label, input)
    .with_hint("PSST hey! Don't even answer that!")
    .with_optional(true);

// < send to slack API >

pub fn dispatch_block_actions(self) -> Self

Will allow the elements in this block to dispatch block_actions payloads. Defaults to false.

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

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

Errors

• If from_label_and_element was passed a Text object longer than 2000 chars
• If with_hint was called with a block id longer than 2000 chars
• If with_block_id was called with a block id longer than 256 chars

Example

use slack_blocks::elems::Select;
use slack_blocks::blocks;

let label = "On a scale from 1 - 5, how angsty are you?";
let input = Select::from_placeholder_and_action_id("Pick a channel...", "ABC123")
    .choose_from_public_channels();
let long_string = std::iter::repeat(' ').take(2001).collect::<String>();

let block = blocks::Input
    ::from_label_and_element(label, input)
    .with_block_id(long_string);

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

// < send to slack API >

Trait Implementations

impl<'a> Clone for Input<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Input<'a>

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

Formats the value using the given formatter.

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

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

Performs the conversion.

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

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

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

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

This method tests for !=.

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

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

impl<'a> StructuralPartialEq for Input<'a>