Struct External 

pub struct External<'a> { /* private fields */ }

Select menu with external data source

slack api docs 🔗

This select menu will load its options from an external data source, allowing for a dynamic list of options.

Setup

Slack API doc guide for setting up an external data source 🔗

Implementations

impl<'a> External<'a>

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

Build a new external select element

Examples

use std::convert::TryFrom;

use slack_blocks::{blocks::{Actions, Block},
                   compose::Opt,
                   elems::{select, BlockElement},
                   text};

let select =
  select::External::builder().placeholder("Choose your favorite city!")
                             .action_id("fave_city")
                             .build();

let block: Block = Actions::builder().element(select).build().into();

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

Available on crate feature validation only.

Validate that this user select agrees with Slack’s model requirements

Errors

• If from_placeholder_and_action_id was called with placeholder longer than 150 chars
• If from_placeholder_and_action_id was called with action_id longer than 255 chars

Example

use slack_blocks::elems::select;

let select = select::External::builder().placeholder(
                          r#"Hey I really would appreciate it if you chose
        a channel relatively soon, so that we can figure out
        where we need to send this poll, ok? it's kind of
        important that you specify where this poll should be
        sent, in case we haven't made that super clear.
        If you understand, could you pick a channel, already??"#,
)
             .action_id("ABC123")
             .build();

assert!(matches!(select.validate(), Err(_)))

Trait Implementations

impl<'a> Clone for External<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for External<'a>

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

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for External<'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<External<'a>> for BlockElement<'a>

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

Converts to this type from the input type.

impl<'a> From<External<'a>> for SupportedElement<'a>

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

Converts to this type from the input type.

impl<'a> From<External<'a>> for SupportedElement<'a>

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

Converts to this type from the input type.

impl<'a> Hash for External<'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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for External<'a>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

impl<'a> StructuralPartialEq for External<'a>