use std::ops::Not;
use crate::types::*;
#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize)]
#[serde(untagged)]
pub enum ReplyMarkup {
InlineKeyboardMarkup(InlineKeyboardMarkup),
ReplyKeyboardMarkup(ReplyKeyboardMarkup),
ReplyKeyboardRemove(ReplyKeyboardRemove),
ForceReply(ForceReply),
}
impl From<InlineKeyboardMarkup> for ReplyMarkup {
fn from(value: InlineKeyboardMarkup) -> ReplyMarkup {
ReplyMarkup::InlineKeyboardMarkup(value)
}
}
impl From<Vec<Vec<InlineKeyboardButton>>> for ReplyMarkup {
fn from(value: Vec<Vec<InlineKeyboardButton>>) -> ReplyMarkup {
ReplyMarkup::InlineKeyboardMarkup(value.into())
}
}
impl From<ReplyKeyboardMarkup> for ReplyMarkup {
fn from(value: ReplyKeyboardMarkup) -> ReplyMarkup {
ReplyMarkup::ReplyKeyboardMarkup(value)
}
}
impl From<ReplyKeyboardRemove> for ReplyMarkup {
fn from(value: ReplyKeyboardRemove) -> ReplyMarkup {
ReplyMarkup::ReplyKeyboardRemove(value)
}
}
impl From<ForceReply> for ReplyMarkup {
fn from(value: ForceReply) -> ReplyMarkup {
ReplyMarkup::ForceReply(value)
}
}
#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize)]
pub struct ReplyKeyboardMarkup {
keyboard: Vec<Vec<KeyboardButton>>,
#[serde(skip_serializing_if = "Not::not")]
resize_keyboard: bool,
#[serde(skip_serializing_if = "Not::not")]
one_time_keyboard: bool,
#[serde(skip_serializing_if = "Not::not")]
selective: bool,
}
impl ReplyKeyboardMarkup {
pub fn new() -> Self {
ReplyKeyboardMarkup {
keyboard: Vec::new(),
resize_keyboard: false,
one_time_keyboard: false,
selective: false,
}
}
fn init(rows: Vec<Vec<KeyboardButton>>) -> Self {
let mut keyboard = Self::new();
keyboard.keyboard = rows;
keyboard
}
pub fn resize_keyboard(&mut self) -> &mut Self {
self.resize_keyboard = true;
self
}
pub fn one_time_keyboard(&mut self) -> &mut Self {
self.one_time_keyboard = true;
self
}
pub fn selective(&mut self) -> &mut Self {
self.selective = true;
self
}
pub fn add_row(&mut self, row: Vec<KeyboardButton>) -> &mut Vec<KeyboardButton> {
self.keyboard.push(row);
self.keyboard.last_mut().unwrap()
}
pub fn add_empty_row(&mut self) -> &mut Vec<KeyboardButton> {
self.add_row(Default::default())
}
}
impl From<Vec<Vec<KeyboardButton>>> for ReplyKeyboardMarkup {
fn from(value: Vec<Vec<KeyboardButton>>) -> Self {
Self::init(value)
}
}
#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize)]
pub struct KeyboardButton {
text: String,
#[serde(skip_serializing_if = "Not::not")]
request_contact: bool,
#[serde(skip_serializing_if = "Not::not")]
request_location: bool,
}
impl KeyboardButton {
pub fn new<S: AsRef<str>>(text: S) -> Self {
Self {
text: text.as_ref().to_string(),
request_contact: false,
request_location: false,
}
}
pub fn request_contact(&mut self) -> &mut Self {
self.request_location = false;
self.request_contact = true;
self
}
pub fn request_location(&mut self) -> &mut Self {
self.request_contact = false;
self.request_location = true;
self
}
}
impl<'a> From<&'a str> for KeyboardButton {
fn from(value: &'a str) -> KeyboardButton {
KeyboardButton::new(value)
}
}
impl From<String> for KeyboardButton {
fn from(value: String) -> KeyboardButton {
KeyboardButton::new(value)
}
}
#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize)]
pub struct ReplyKeyboardRemove {
remove_keyboard: True,
#[serde(skip_serializing_if = "Not::not")]
selective: bool,
}
impl ReplyKeyboardRemove {
pub fn new() -> Self {
Self {
remove_keyboard: True,
selective: false,
}
}
pub fn selective(&mut self) -> &mut Self {
self.selective = true;
self
}
}
#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize)]
pub struct InlineKeyboardMarkup {
inline_keyboard: Vec<Vec<InlineKeyboardButton>>,
}
impl InlineKeyboardMarkup {
pub fn new() -> Self {
Self {
inline_keyboard: Default::default(),
}
}
fn init(inline_keyboard: Vec<Vec<InlineKeyboardButton>>) -> Self {
Self { inline_keyboard }
}
pub fn add_row(&mut self, row: Vec<InlineKeyboardButton>) -> &mut Vec<InlineKeyboardButton> {
self.inline_keyboard.push(row);
self.inline_keyboard.last_mut().unwrap()
}
pub fn add_empty_row(&mut self) -> &mut Vec<InlineKeyboardButton> {
self.add_row(Default::default())
}
}
impl From<Vec<Vec<InlineKeyboardButton>>> for InlineKeyboardMarkup {
fn from(value: Vec<Vec<InlineKeyboardButton>>) -> Self {
Self::init(value)
}
}
#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize)]
pub struct InlineKeyboardButton {
text: String,
#[serde(flatten)]
kind: InlineKeyboardButtonKind,
}
impl InlineKeyboardButton {
pub fn callback<T: AsRef<str>, C: AsRef<str>>(text: T, callback: C) -> Self {
Self {
text: text.as_ref().to_string(),
kind: InlineKeyboardButtonKind::CallbackData(callback.as_ref().to_string()),
}
}
pub fn url<T: AsRef<str>, U: AsRef<str>>(text: T, url: U) -> Self {
Self {
text: text.as_ref().to_string(),
kind: InlineKeyboardButtonKind::Url(url.as_ref().to_string()),
}
}
pub fn switch_inline_query<T: AsRef<str>, Q: AsRef<str>>(text: T, query: Q) -> Self {
Self {
text: text.as_ref().to_string(),
kind: InlineKeyboardButtonKind::SwitchInlineQuery(query.as_ref().to_string()),
}
}
pub fn switch_inline_query_current_chat<T: AsRef<str>, Q: AsRef<str>>(
text: T,
query: Q,
) -> Self {
Self {
text: text.as_ref().to_string(),
kind: InlineKeyboardButtonKind::SwitchInlineQueryCurrentChat(
query.as_ref().to_string(),
),
}
}
}
#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize)]
pub enum InlineKeyboardButtonKind {
#[serde(rename = "url")]
Url(String), #[serde(rename = "callback_data")]
CallbackData(String), #[serde(rename = "switch_inline_query")]
SwitchInlineQuery(String),
#[serde(rename = "switch_inline_query_current_chat")]
SwitchInlineQueryCurrentChat(String),
}
#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize)]
pub struct ForceReply {
force_reply: True,
#[serde(skip_serializing_if = "Not::not")]
selective: bool,
}
impl ForceReply {
pub fn new() -> Self {
Self {
force_reply: True,
selective: false,
}
}
pub fn selective(&mut self) -> &mut Self {
self.selective = true;
self
}
}