Enum ApiCreateMyAddressResponse 

#[non_exhaustive]
pub enum ApiCreateMyAddressResponse {
    UserContactLinkCreated(UserContactLinkCreatedResponse),
    ChatCmdError(ChatCmdErrorResponse),
    Undocumented(BTreeMap<String, Value>),
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

UserContactLinkCreated(UserContactLinkCreatedResponse)

UserContactLinkCreated: User contact address created.

ChatCmdError(ChatCmdErrorResponse)

ChatCmdError: Command error.

Undocumented(BTreeMap<String, Value>)

Implementations

impl ApiCreateMyAddressResponse

pub fn user_contact_link_created( &self, ) -> Option<&UserContactLinkCreatedResponse>

Examples found in repository

examples/multi_user_bot.rs (line 47)

async fn main() -> Result<(), Box<dyn Error>> {
    let (client, mut events) = simploxide_client::connect("ws://127.0.0.1:5225").await?;

    // Use destructuring to extract data from the expected response
    let ShowActiveUserResponse::ActiveUser(ActiveUserResponse { ref user, .. }) =
        *client.show_active_user().await?
    else {
        return Err("No active user profile".into());
    };

    println!(
        "Bot profile: {} ({})",
        user.profile.display_name, user.profile.full_name
    );

    println!("{user:#?}");

    // Alternatively, use response getters
    let (address_long, address_short) = match client
        .api_show_my_address(user.user_id)
        .await?
        .user_contact_link()
    {
        Some(resp) => (
            resp.contact_link.conn_link_contact.conn_full_link.clone(),
            resp.contact_link.conn_link_contact.conn_short_link.clone(),
        ),
        None => client
            .api_create_my_address(user.user_id)
            .await?
            .user_contact_link_created()
            .map(|resp| {
                (
                    resp.conn_link_contact.conn_full_link.clone(),
                    resp.conn_link_contact.conn_short_link.clone(),
                )
            })
            .ok_or("Failed to create bot address")?,
    };

    println!("Bot long address: {address_long}");
    println!("Bot short address: {address_short:?}");

    let mut counter = 0;
    'reactor: while let Some(ev) = events.try_next().await? {
        match ev.as_ref() {
            // Got the message -> square the number
            Event::NewChatItems(new_msgs) => {
                counter += 1;
                if counter > 10 {
                    break 'reactor;
                }
            }
            // Ignore all other events
            _ => (),
        }
    }

    client
        .api_set_address_settings(
            user.user_id,
            AddressSettings {
                business_address: false,
                auto_accept: None,
                auto_reply: None,
                undocumented: Default::default(),
            },
        )
        .await?;

    client
        .api_set_profile_address(ApiSetProfileAddress {
            user_id: user.user_id,
            enable: false,
        })
        .await?;

    Ok(())
}

pub fn chat_cmd_error(&self) -> Option<&ChatCmdErrorResponse>

pub fn undocumented(&self) -> Option<&BTreeMap<String, Value>>

Trait Implementations

impl Clone for ApiCreateMyAddressResponse

fn clone(&self) -> ApiCreateMyAddressResponse

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ApiCreateMyAddressResponse

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ApiCreateMyAddressResponse

fn deserialize<__D>( __deserializer: __D, ) -> Result<ApiCreateMyAddressResponse, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ApiCreateMyAddressResponse

fn eq(&self, other: &ApiCreateMyAddressResponse) -> 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 Serialize for ApiCreateMyAddressResponse

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ApiCreateMyAddressResponse