Struct slack_blocks::elems::select::Conversation

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

Select Conversation List

slack api docs 🔗

This select menu will populate its options with a list of public and private channels, DMs, and MPIMs visible to the current user in the active workspace.

Implementations

impl<'a> Conversation<'a>

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

Build a new conversation multi-select element

Examples

use std::convert::TryFrom;

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

let select: BlockElement =
  select::Conversation::builder().placeholder("Choose your favorite channel!")
                                 .action_id("fave_channel")
                                 .build()
                                 .into();

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

pub fn from_placeholder_and_action_id(
    placeholder: impl Into<Plain>,
    action_id: impl Into<Cow<'a, str>>
) -> Self

👎 Deprecated since 0.16.9:

use elems::select::Conversation::builder instead.

Construct a Select element, letting users choose a DM / Group DM / Public channel from their workspace.

Arguments

• placeholder - A plain_text only text object 🔗 that defines the placeholder text shown on the menu. Maximum length for the text in this field is 150 characters.

• action_id - An identifier for the action triggered when a menu option is selected. 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 used elsewhere by your app. Maximum length for this field is 255 characters.

Example

use std::convert::TryFrom;
use std::iter;

use slack_blocks::elems::{BlockElement, select};
use slack_blocks::blocks;
use slack_blocks::text;
use text::ToSlackPlaintext;

let select: BlockElement = select::Conversation
                                 ::from_placeholder_and_action_id("Channel", "ABC123")
                                  .into();

let title = "Pick a channel to send your poll to...".plaintext();

let blocks: Vec<blocks::Block> = vec![
    blocks::Section::from_text(title).into(),
    blocks::Actions::try_from(vec![select]).unwrap().into(),
];

// <send `blocks` to slack's API>

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

👎 Deprecated since 0.16.9:

use elems::select::Conversation::builder instead.

Optional method that allows you to add a confirmation dialog that appears after a menu item is selected.

Arguments

• confirm - A confirm object 🔗 that defines an optional confirmation dialog that appears after a menu item is selected.

Example

use std::iter;
use std::convert::TryFrom;

use slack_blocks::{
  blocks::{Block, Actions},
  elems::{BlockElement, select::Select},
  compose::{text, Confirm, text::ToSlackPlaintext},
};


let confirm = Confirm::from_parts(
  "Are you sure?",
  "Think hard about this.".plaintext(),
  "Yes",
  "No",
);

let select: BlockElement = Select::from_placeholder_and_action_id("Pick a channel to delete!", "delete_chan_select")
                                  .with_confirm(confirm)
                                  .choose_from_all_channels()
                                  .into();

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

// < send `block` to slack API >

pub fn with_filter(self, filter: ConversationFilter) -> Self

👎 Deprecated since 0.16.9:

use elems::select::Conversation::builder instead.

Optional method that allows you to filter the conversations available in the menu using ConversationFilter.

Arguments

• filter - A filter object 🔗 that defines an optional confirmation dialog that appears after a menu item is selected.

Example

use std::iter;
use std::convert::TryFrom;

use slack_blocks::{
  blocks::{Block, Actions},
  elems::{BlockElement, select::Select},
  compose::{
    text,
    Confirm,
    ConversationFilter,
    conversation_filter::ConversationKind::*,
    text::ToSlackPlaintext,
  },
};


let filter = ConversationFilter::new().include_conversation_kinds(vec![Dm, PrivateChannel]);

let select: BlockElement = Select::from_placeholder_and_action_id("Pick a channel to delete!", "delete_chan_select")
                                  .choose_from_all_channels()
                                  .with_filter(filter)
                                  .into();

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

// < send `block` to slack API >

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

👎 Deprecated since 0.16.9:

use elems::select::Conversation::builder instead.

Optional method that allows you to set a pre-selected channel in the select menu with the channel’s ID.

If default_to_current_conversation is also supplied, initial_channel will take precedence.

Arguments

• channel - The ID of any valid public channel to be pre-selected when the menu loads.

Example

use std::convert::TryFrom;

use slack_blocks::{
  blocks::{Block, Actions, Section},
  elems::{BlockElement, select::Select},
  compose::{text, Confirm, text::ToSlackPlaintext},
};

let confirm = Confirm::from_parts(
    "Confirm Poll Channel",
    "Are you sure this is the channel you want to send this to?".plaintext(),
    "Yep, I'm sure",
    "No way!"
);

let general = "C12345";
let select: BlockElement = Select::from_placeholder_and_action_id(
                                    "Pick a Channel...",
                                    "ABC123"
                                  )
                                  .with_confirm(confirm)
                                  .choose_from_all_channels()
                                  .with_initial_channel(general)
                                  .into();

let blocks: Vec<Block> = vec![
    Section::from_text("Pick a channel to send your poll to...".plaintext()).into(),
    Actions::try_from(select).unwrap().into(),
];

// <send to slack's API>

pub fn default_to_current_conversation(self) -> Self

👎 Deprecated since 0.16.9:

use elems::select::Conversation::builder instead.

Pre-populates the select menu with the conversation that the user was viewing when they opened the modal, if available.

Default is false.

pub fn no_default(self) -> Self

👎 Deprecated since 0.16.9:

use elems::select::Conversation::builder instead.

Undo default_to_current_conversation

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

Validate that this conversation 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
• If with_confirm was called with an invalid Confirm structure

Example

use slack_blocks::elems::select;

let select = select::Conversation::from_placeholder_and_action_id(
        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??"#,
        "ABC123"
    );

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

Trait Implementations

impl<'a> Clone for Conversation<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Conversation<'a>

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

Formats the value using the given formatter.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

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

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

This method tests for !=.

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

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

impl<'a> StructuralPartialEq for Conversation<'a>