Struct slack_blocks::elems::select::static_::Static

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

Select menu with static options

slack api docs 🔗

This is the simplest form of select menu, with a static list of options passed in when defining the element.

Implementations

impl<'a> Static<'a>

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

Build a new static select element

Examples

use std::convert::TryFrom;

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

struct City {
  name: String,
  short_code: String,
}

impl City {
  pub fn new(name: impl ToString, short_code: impl ToString) -> Self {
    Self { name: name.to_string(),
           short_code: short_code.to_string() }
  }
}

let cities = vec![City::new("Seattle", "SEA"),
                  City::new("Portland", "PDX"),
                  City::new("Phoenix", "PHX")];

let options =
  cities.iter().map(|City { name, short_code }| {
                 Opt::builder().text_plain(name).value(short_code).build()
               });

let select: BlockElement =
  Static::builder().placeholder("Choose your favorite city!")
                   .action_id("fave_city")
                   .options(options)
                   .build()
                   .into();

let block: Block = Actions::try_from(select).unwrap().into();

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

Validate that this select element 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 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??"#;

let select = select::Static::builder().placeholder(placeholder)
                                      .action_id("abc123")
                                      .options(std::iter::empty())
                                      .build();

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

Trait Implementations

impl<'a> Clone for Static<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Static<'a>

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

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for Static<'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<Static<'a>> for SupportedElement<'a>

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

Performs the conversion.

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

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

Performs the conversion.

impl<'a> From<Static<'a>> for Select<'a>

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

Performs the conversion.

impl<'a> From<Static<'a>> for BlockElement<'a>

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

Performs the conversion.

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

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

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

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

This method tests for !=.

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

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

impl<'a> StructuralPartialEq for Static<'a>