Struct slack_blocks::elems::checkboxes::build::CheckboxesBuilder

pub struct CheckboxesBuilder<'a, A, O> { /* fields omitted */ }

Checkbox group builder

Allows you to construct safely, with compile-time checks on required setter methods.

Required Methods

CheckboxesBuilder::build() is only available if these methods have been called:

• action_id
• options

Example

use std::convert::TryFrom;

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

mod usa {
  pub struct State {
    pub name: String,
    pub abbrev: String,
  }

  pub fn arizona() -> State {
    State { name: String::from("Arizona"),
            abbrev: String::from("AZ") }
  }

  pub fn get_states() -> Vec<State> {
    // ...
  }
}

let state_opt = |state: usa::State| {
  Opt::builder().text_plain(state.name)
                .value(state.abbrev)
                .build()
};

let states: Vec<Opt<_, _>> =
  usa::get_states().into_iter().map(state_opt).collect();

let boxes: BlockElement =
  Checkboxes::builder().action_id("state_picker")
                       .options(&states)
                       .initial_options(vec![state_opt(usa::arizona())])
                       .build()
                       .into();

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

// <send block to slack API>

Implementations

impl<'a, A, O> CheckboxesBuilder<'a, A, O>

pub fn new() -> Self

Create a new builder

pub fn action_id<S>(
    self,
    action_id: S
) -> CheckboxesBuilder<'a, Set<action_id>, O> where
    S: Into<Cow<'a, str>>, 

Set action_id (Optional)

An identifier for the action triggered when the checkbox group is changed.

You can use this when you receive an interaction payload to identify the source of the action 🔗.

Should be unique among all other action_ids in the containing block.

Maximum length for this field is 255 characters.

pub fn options<I, Op>(
    self,
    options: I
) -> CheckboxesBuilder<'a, A, Set<options>> where
    I: Into<Cow<'a, [Op]>>,
    Op: 'a + Into<Opt<'a, AnyText, NoUrl>> + Clone, 

Set options (Required)

An array of option objects 🔗.

A maximum of 10 options are allowed.

pub fn initial_options<I, Op>(self, options: I) -> Self where
    I: Into<Cow<'a, [Op]>>,
    Op: 'a + Into<Opt<'a, AnyText, NoUrl>> + Clone, 

Set initial_options (Optional)

An array of option objects 🔗 that exactly matches one or more of the options within options.

These options will be selected when the checkbox group initially loads.

pub fn confirm(self, confirm: Confirm) -> Self

Set confirm (Optional)

A confirm object 🔗 that defines an optional confirmation dialog that appears after clicking one of the checkboxes in this element.

impl<'a> CheckboxesBuilder<'a, Set<action_id>, Set<options>>

pub fn build(self) -> Checkboxes<'a>

All done building, now give me a darn checkbox group!

no method name 'build' found for struct 'CheckboxesBuilder<...>'? Make sure all required setter methods have been called. See docs for CheckboxesBuilder.

use slack_blocks::elems::Checkboxes;

let foo = Checkboxes::builder().build(); // Won't compile!

use slack_blocks::{compose::Opt, elems::Checkboxes};

let foo = Checkboxes::builder().action_id("foo")
                               .options(vec![Opt::builder().text_plain("foo")
                                                           .value("bar")
                                                           .build()])
                               .build();

Trait Implementations

impl<'a, A: Debug, O: Debug> Debug for CheckboxesBuilder<'a, A, O>

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

Formats the value using the given formatter.