use std::{
future::{Future, IntoFuture},
pin::Pin,
};
use serde::Serialize;
use crate::{
api::API,
entities::{
message_entity::MessageEntity,
message_id::MessageId,
misc::{chat_id::ChatId, reply_markup::ReplyMarkup},
reply_parameters::ReplyParameters,
},
errors::ConogramError,
impl_into_future,
request::RequestT,
utils::deserialize_utils::is_false,
};
#[derive(Debug, Clone, Serialize)]
pub struct CopyMessageParams {
pub chat_id: ChatId,
#[serde(skip_serializing_if = "Option::is_none")]
pub message_thread_id: Option<i64>,
pub from_chat_id: ChatId,
pub message_id: i64,
#[serde(skip_serializing_if = "Option::is_none")]
pub caption: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub parse_mode: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub caption_entities: Vec<MessageEntity>,
#[serde(default, skip_serializing_if = "is_false")]
pub show_caption_above_media: bool,
#[serde(default, skip_serializing_if = "is_false")]
pub disable_notification: bool,
#[serde(default, skip_serializing_if = "is_false")]
pub protect_content: bool,
#[serde(default, skip_serializing_if = "is_false")]
pub allow_paid_broadcast: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub reply_parameters: Option<ReplyParameters>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reply_markup: Option<ReplyMarkup>,
}
impl_into_future!(CopyMessageRequest<'a>);
///Use this method to copy messages of any kind. Service messages, paid media messages, giveaway messages, giveaway winners messages, and invoice messages can't be copied. A quiz [poll](https://core.telegram.org/bots/api/#poll) can be copied only if the value of the field *correct\_option\_id* is known to the bot. The method is analogous to the method [forwardMessage](https://core.telegram.org/bots/api/#forwardmessage), but the copied message doesn't have a link to the original message. Returns the [MessageId](https://core.telegram.org/bots/api/#messageid) of the sent message on success.
#[derive(Clone)]
pub struct CopyMessageRequest<'a> {
api: &'a API,
params: CopyMessageParams,
}
impl<'a> RequestT for CopyMessageRequest<'a> {
type ParamsType = CopyMessageParams;
type ReturnType = MessageId;
fn get_name() -> &'static str {
"copyMessage"
}
fn get_api_ref(&self) -> &API {
self.api
}
fn get_params_ref(&self) -> &Self::ParamsType {
&self.params
}
fn is_multipart() -> bool {
false
}
}
impl<'a> CopyMessageRequest<'a> {
pub fn new(
api: &'a API,
chat_id: impl Into<ChatId>,
from_chat_id: impl Into<ChatId>,
message_id: impl Into<i64>,
) -> Self {
Self {
api,
params: CopyMessageParams {
chat_id: chat_id.into(),
from_chat_id: from_chat_id.into(),
message_id: message_id.into(),
message_thread_id: Option::default(),
caption: Option::default(),
parse_mode: Option::default(),
caption_entities: Vec::default(),
show_caption_above_media: bool::default(),
disable_notification: bool::default(),
protect_content: bool::default(),
allow_paid_broadcast: bool::default(),
reply_parameters: Option::default(),
reply_markup: Option::default(),
},
}
}
///Unique identifier for the target chat or username of the target channel (in the format `@channelusername`)
#[must_use]
pub fn chat_id(mut self, chat_id: impl Into<ChatId>) -> Self {
self.params.chat_id = chat_id.into();
self
}
///Unique identifier for the target message thread (topic) of the forum; for forum supergroups only
#[must_use]
pub fn message_thread_id(mut self, message_thread_id: impl Into<i64>) -> Self {
self.params.message_thread_id = Some(message_thread_id.into());
self
}
///Unique identifier for the chat where the original message was sent (or channel username in the format `@channelusername`)
#[must_use]
pub fn from_chat_id(mut self, from_chat_id: impl Into<ChatId>) -> Self {
self.params.from_chat_id = from_chat_id.into();
self
}
///Message identifier in the chat specified in *from\_chat\_id*
#[must_use]
pub fn message_id(mut self, message_id: impl Into<i64>) -> Self {
self.params.message_id = message_id.into();
self
}
///New caption for media, 0-1024 characters after entities parsing. If not specified, the original caption is kept
#[must_use]
pub fn caption(mut self, caption: impl Into<String>) -> Self {
self.params.caption = Some(caption.into());
self
}
///Mode for parsing entities in the new caption. See [formatting options](https://core.telegram.org/bots/api/#formatting-options) for more details.
#[must_use]
pub fn parse_mode(mut self, parse_mode: impl Into<String>) -> Self {
self.params.parse_mode = Some(parse_mode.into());
self
}
///A JSON-serialized list of special entities that appear in the new caption, which can be specified instead of *parse\_mode*
#[must_use]
pub fn caption_entities(
mut self,
caption_entities: impl IntoIterator<Item = impl Into<MessageEntity>>,
) -> Self {
self.params.caption_entities = caption_entities.into_iter().map(Into::into).collect();
self
}
///Pass *True*, if the caption must be shown above the message media. Ignored if a new caption isn't specified.
#[must_use]
pub fn show_caption_above_media(mut self, show_caption_above_media: impl Into<bool>) -> Self {
self.params.show_caption_above_media = show_caption_above_media.into();
self
}
///Sends the message [silently](https://telegram.org/blog/channels-2-0#silent-messages). Users will receive a notification with no sound.
#[must_use]
pub fn disable_notification(mut self, disable_notification: impl Into<bool>) -> Self {
self.params.disable_notification = disable_notification.into();
self
}
///Protects the contents of the sent message from forwarding and saving
#[must_use]
pub fn protect_content(mut self, protect_content: impl Into<bool>) -> Self {
self.params.protect_content = protect_content.into();
self
}
///Pass *True* to allow up to 1000 messages per second, ignoring [broadcasting limits](https://core.telegram.org/bots/faq#how-can-i-message-all-of-my-bot-39s-subscribers-at-once) for a fee of 0.1 Telegram Stars per message. The relevant Stars will be withdrawn from the bot's balance
#[must_use]
pub fn allow_paid_broadcast(mut self, allow_paid_broadcast: impl Into<bool>) -> Self {
self.params.allow_paid_broadcast = allow_paid_broadcast.into();
self
}
///Description of the message to reply to
#[must_use]
pub fn reply_parameters(mut self, reply_parameters: impl Into<ReplyParameters>) -> Self {
self.params.reply_parameters = Some(reply_parameters.into());
self
}
///Additional interface options. A JSON-serialized object for an [inline keyboard](https://core.telegram.org/bots/features#inline-keyboards), [custom reply keyboard](https://core.telegram.org/bots/features#keyboards), instructions to remove a reply keyboard or to force a reply from the user
#[must_use]
pub fn reply_markup(mut self, reply_markup: impl Into<ReplyMarkup>) -> Self {
self.params.reply_markup = Some(reply_markup.into());
self
}
}
impl API {
///Use this method to copy messages of any kind. Service messages, paid media messages, giveaway messages, giveaway winners messages, and invoice messages can't be copied. A quiz [poll](https://core.telegram.org/bots/api/#poll) can be copied only if the value of the field *correct\_option\_id* is known to the bot. The method is analogous to the method [forwardMessage](https://core.telegram.org/bots/api/#forwardmessage), but the copied message doesn't have a link to the original message. Returns the [MessageId](https://core.telegram.org/bots/api/#messageid) of the sent message on success.
pub fn copy_message(
&self,
chat_id: impl Into<ChatId>,
from_chat_id: impl Into<ChatId>,
message_id: impl Into<i64>,
) -> CopyMessageRequest {
CopyMessageRequest::new(self, chat_id, from_chat_id, message_id)
}
}
// Divider: all content below this line will be preserved after code regen