Method discord_webhook_execute

components/runtime/src/extensions/discord.rs:1526–1586

(
        &self,
        arg: OpExecuteWebhook,
    )

    #[allow(async_fn_in_trait)]
    async fn discord_webhook_execute(
        &self,
        arg: OpExecuteWebhook,
    ) -> Result<Message, anyhow::Error> {
        let rt_ctx = get_rt_ctx(&self.state);

        let parsed_id: Id<WebhookMarker> = parse_str_snowflake_id(&arg.webhook_id)?.cast();

        let attachments = convert_attachments(arg.fields.attachments.unwrap_or_default())?;

        let message = discord_request_any(&self.state, async move {
            let maybe_embeds = arg
                .fields
                .embeds
                .unwrap_or_default()
                .into_iter()
                .map(Into::into)
                .collect::<Vec<_>>();

            let components = arg
                .fields
                .components
                .unwrap_or_default()
                .into_iter()
                .map(TryInto::try_into)
                .collect::<Result<Vec<_>, _>>()?;

            let mut mc = rt_ctx
                .discord_config
                .client
                .execute_webhook(parsed_id, &arg.token)
                .embeds(&maybe_embeds)
                .components(&components);

            if let Some(content) = &arg.fields.content {
                mc = mc.content(content)
            }

            let mentions = arg.fields.allowed_mentions.map(Into::into);
            if mentions.is_some() {
                mc = mc.allowed_mentions(mentions.as_ref());
            }

            if attachments.len() > 0 {
                mc = mc.attachments(&attachments);
            }

            if let Some(avatar_url) = &arg.avatar_url {
                mc = mc.avatar_url(avatar_url)
            }

            if let Some(username) = &arg.username {
                mc = mc.username(username)
            }

            Ok(mc.wait().await?.model().await?)
        })
        .await?;