553 lines
16 KiB
Rust
553 lines
16 KiB
Rust
use tdlib_rs::types::TextEntity;
|
||
|
||
use crate::types::{ChatId, MessageId};
|
||
|
||
#[derive(Debug, Clone)]
|
||
#[allow(dead_code)]
|
||
pub struct ChatInfo {
|
||
pub id: ChatId,
|
||
pub title: String,
|
||
pub username: Option<String>,
|
||
pub last_message: String,
|
||
pub last_message_date: i32,
|
||
pub unread_count: i32,
|
||
/// Количество непрочитанных упоминаний (@)
|
||
pub unread_mention_count: i32,
|
||
pub is_pinned: bool,
|
||
pub order: i64,
|
||
/// ID последнего прочитанного исходящего сообщения (для галочек)
|
||
pub last_read_outbox_message_id: MessageId,
|
||
/// ID папок, в которых находится чат
|
||
pub folder_ids: Vec<i32>,
|
||
/// Чат замьючен (уведомления отключены)
|
||
pub is_muted: bool,
|
||
/// Черновик сообщения
|
||
pub draft_text: Option<String>,
|
||
}
|
||
|
||
/// Информация о сообщении, на которое отвечают
|
||
#[derive(Debug, Clone)]
|
||
pub struct ReplyInfo {
|
||
/// ID сообщения, на которое отвечают
|
||
pub message_id: MessageId,
|
||
/// Имя отправителя оригинального сообщения
|
||
pub sender_name: String,
|
||
/// Текст оригинального сообщения (превью)
|
||
pub text: String,
|
||
}
|
||
|
||
/// Информация о пересланном сообщении
|
||
#[derive(Debug, Clone)]
|
||
pub struct ForwardInfo {
|
||
/// Имя оригинального отправителя
|
||
pub sender_name: String,
|
||
/// Дата оригинального сообщения (для будущего использования)
|
||
#[allow(dead_code)]
|
||
pub date: i32,
|
||
}
|
||
|
||
/// Информация о реакции на сообщение
|
||
#[derive(Debug, Clone)]
|
||
pub struct ReactionInfo {
|
||
/// Эмодзи реакции (например, "👍")
|
||
pub emoji: String,
|
||
/// Количество людей, поставивших эту реакцию
|
||
pub count: i32,
|
||
/// Поставил ли текущий пользователь эту реакцию
|
||
pub is_chosen: bool,
|
||
}
|
||
|
||
/// Метаданные сообщения (ID, отправитель, время)
|
||
#[derive(Debug, Clone)]
|
||
pub struct MessageMetadata {
|
||
pub id: MessageId,
|
||
pub sender_name: String,
|
||
pub date: i32,
|
||
/// Дата редактирования (0 если не редактировалось)
|
||
pub edit_date: i32,
|
||
}
|
||
|
||
/// Контент сообщения (текст и форматирование)
|
||
#[derive(Debug, Clone, PartialEq)]
|
||
pub struct MessageContent {
|
||
pub text: String,
|
||
/// Сущности форматирования (bold, italic, code и т.д.)
|
||
pub entities: Vec<TextEntity>,
|
||
}
|
||
|
||
/// Состояние и права доступа к сообщению
|
||
#[derive(Debug, Clone)]
|
||
pub struct MessageState {
|
||
pub is_outgoing: bool,
|
||
pub is_read: bool,
|
||
/// Можно ли редактировать сообщение
|
||
pub can_be_edited: bool,
|
||
/// Можно ли удалить только для себя
|
||
pub can_be_deleted_only_for_self: bool,
|
||
/// Можно ли удалить для всех
|
||
pub can_be_deleted_for_all_users: bool,
|
||
}
|
||
|
||
/// Взаимодействия с сообщением (reply, forward, reactions)
|
||
#[derive(Debug, Clone)]
|
||
pub struct MessageInteractions {
|
||
/// Информация о reply (если это ответ на сообщение)
|
||
pub reply_to: Option<ReplyInfo>,
|
||
/// Информация о forward (если сообщение переслано)
|
||
pub forward_from: Option<ForwardInfo>,
|
||
/// Реакции на сообщение
|
||
pub reactions: Vec<ReactionInfo>,
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
pub struct MessageInfo {
|
||
pub metadata: MessageMetadata,
|
||
pub content: MessageContent,
|
||
pub state: MessageState,
|
||
pub interactions: MessageInteractions,
|
||
}
|
||
|
||
impl MessageInfo {
|
||
/// Создать новое сообщение
|
||
pub fn new(
|
||
id: MessageId,
|
||
sender_name: String,
|
||
is_outgoing: bool,
|
||
content: String,
|
||
entities: Vec<TextEntity>,
|
||
date: i32,
|
||
edit_date: i32,
|
||
is_read: bool,
|
||
can_be_edited: bool,
|
||
can_be_deleted_only_for_self: bool,
|
||
can_be_deleted_for_all_users: bool,
|
||
reply_to: Option<ReplyInfo>,
|
||
forward_from: Option<ForwardInfo>,
|
||
reactions: Vec<ReactionInfo>,
|
||
) -> Self {
|
||
Self {
|
||
metadata: MessageMetadata {
|
||
id,
|
||
sender_name,
|
||
date,
|
||
edit_date,
|
||
},
|
||
content: MessageContent {
|
||
text: content,
|
||
entities,
|
||
},
|
||
state: MessageState {
|
||
is_outgoing,
|
||
is_read,
|
||
can_be_edited,
|
||
can_be_deleted_only_for_self,
|
||
can_be_deleted_for_all_users,
|
||
},
|
||
interactions: MessageInteractions {
|
||
reply_to,
|
||
forward_from,
|
||
reactions,
|
||
},
|
||
}
|
||
}
|
||
|
||
// Удобные getter'ы для частых операций
|
||
pub fn id(&self) -> MessageId {
|
||
self.metadata.id
|
||
}
|
||
|
||
pub fn sender_name(&self) -> &str {
|
||
&self.metadata.sender_name
|
||
}
|
||
|
||
pub fn date(&self) -> i32 {
|
||
self.metadata.date
|
||
}
|
||
|
||
pub fn edit_date(&self) -> i32 {
|
||
self.metadata.edit_date
|
||
}
|
||
|
||
pub fn is_edited(&self) -> bool {
|
||
self.metadata.edit_date > 0
|
||
}
|
||
|
||
pub fn text(&self) -> &str {
|
||
&self.content.text
|
||
}
|
||
|
||
pub fn entities(&self) -> &[TextEntity] {
|
||
&self.content.entities
|
||
}
|
||
|
||
pub fn is_outgoing(&self) -> bool {
|
||
self.state.is_outgoing
|
||
}
|
||
|
||
pub fn is_read(&self) -> bool {
|
||
self.state.is_read
|
||
}
|
||
|
||
pub fn can_be_edited(&self) -> bool {
|
||
self.state.can_be_edited
|
||
}
|
||
|
||
pub fn can_be_deleted_only_for_self(&self) -> bool {
|
||
self.state.can_be_deleted_only_for_self
|
||
}
|
||
|
||
pub fn can_be_deleted_for_all_users(&self) -> bool {
|
||
self.state.can_be_deleted_for_all_users
|
||
}
|
||
|
||
pub fn reply_to(&self) -> Option<&ReplyInfo> {
|
||
self.interactions.reply_to.as_ref()
|
||
}
|
||
|
||
pub fn forward_from(&self) -> Option<&ForwardInfo> {
|
||
self.interactions.forward_from.as_ref()
|
||
}
|
||
|
||
pub fn reactions(&self) -> &[ReactionInfo] {
|
||
&self.interactions.reactions
|
||
}
|
||
}
|
||
|
||
/// Builder для удобного создания MessageInfo с fluent API
|
||
///
|
||
/// # Примеры
|
||
///
|
||
/// ```
|
||
/// use tele_tui::tdlib::MessageBuilder;
|
||
/// use tele_tui::types::MessageId;
|
||
///
|
||
/// let message = MessageBuilder::new(MessageId::new(123))
|
||
/// .sender_name("Alice")
|
||
/// .text("Hello, world!")
|
||
/// .outgoing()
|
||
/// .date(1640000000)
|
||
/// .build();
|
||
/// ```
|
||
pub struct MessageBuilder {
|
||
id: MessageId,
|
||
sender_name: String,
|
||
is_outgoing: bool,
|
||
text: String,
|
||
entities: Vec<TextEntity>,
|
||
date: i32,
|
||
edit_date: i32,
|
||
is_read: bool,
|
||
can_be_edited: bool,
|
||
can_be_deleted_only_for_self: bool,
|
||
can_be_deleted_for_all_users: bool,
|
||
reply_to: Option<ReplyInfo>,
|
||
forward_from: Option<ForwardInfo>,
|
||
reactions: Vec<ReactionInfo>,
|
||
}
|
||
|
||
impl MessageBuilder {
|
||
/// Создать новый builder с обязательным ID сообщения
|
||
pub fn new(id: MessageId) -> Self {
|
||
Self {
|
||
id,
|
||
sender_name: String::new(),
|
||
is_outgoing: false,
|
||
text: String::new(),
|
||
entities: Vec::new(),
|
||
date: 0,
|
||
edit_date: 0,
|
||
is_read: false,
|
||
can_be_edited: false,
|
||
can_be_deleted_only_for_self: true,
|
||
can_be_deleted_for_all_users: false,
|
||
reply_to: None,
|
||
forward_from: None,
|
||
reactions: Vec::new(),
|
||
}
|
||
}
|
||
|
||
/// Установить имя отправителя
|
||
pub fn sender_name(mut self, name: impl Into<String>) -> Self {
|
||
self.sender_name = name.into();
|
||
self
|
||
}
|
||
|
||
/// Пометить сообщение как исходящее
|
||
pub fn outgoing(mut self) -> Self {
|
||
self.is_outgoing = true;
|
||
self.can_be_edited = true;
|
||
self.can_be_deleted_for_all_users = true;
|
||
self
|
||
}
|
||
|
||
/// Пометить сообщение как входящее
|
||
pub fn incoming(mut self) -> Self {
|
||
self.is_outgoing = false;
|
||
self.can_be_edited = false;
|
||
self.can_be_deleted_for_all_users = false;
|
||
self
|
||
}
|
||
|
||
/// Установить текст сообщения
|
||
pub fn text(mut self, text: impl Into<String>) -> Self {
|
||
self.text = text.into();
|
||
self
|
||
}
|
||
|
||
/// Установить entities для форматирования
|
||
pub fn entities(mut self, entities: Vec<TextEntity>) -> Self {
|
||
self.entities = entities;
|
||
self
|
||
}
|
||
|
||
/// Установить дату сообщения (unix timestamp)
|
||
pub fn date(mut self, date: i32) -> Self {
|
||
self.date = date;
|
||
self
|
||
}
|
||
|
||
/// Установить дату редактирования (unix timestamp)
|
||
pub fn edit_date(mut self, edit_date: i32) -> Self {
|
||
self.edit_date = edit_date;
|
||
self
|
||
}
|
||
|
||
/// Пометить сообщение как отредактированное (edit_date = date + 60)
|
||
pub fn edited(mut self) -> Self {
|
||
self.edit_date = self.date + 60;
|
||
self
|
||
}
|
||
|
||
/// Пометить сообщение как прочитанное
|
||
pub fn read(mut self) -> Self {
|
||
self.is_read = true;
|
||
self
|
||
}
|
||
|
||
/// Пометить сообщение как непрочитанное
|
||
pub fn unread(mut self) -> Self {
|
||
self.is_read = false;
|
||
self
|
||
}
|
||
|
||
/// Разрешить редактирование
|
||
pub fn editable(mut self) -> Self {
|
||
self.can_be_edited = true;
|
||
self
|
||
}
|
||
|
||
/// Разрешить удаление только для себя
|
||
pub fn deletable_for_self(mut self) -> Self {
|
||
self.can_be_deleted_only_for_self = true;
|
||
self
|
||
}
|
||
|
||
/// Разрешить удаление для всех
|
||
pub fn deletable_for_all(mut self) -> Self {
|
||
self.can_be_deleted_for_all_users = true;
|
||
self
|
||
}
|
||
|
||
/// Установить информацию об ответе
|
||
pub fn reply_to(mut self, reply: ReplyInfo) -> Self {
|
||
self.reply_to = Some(reply);
|
||
self
|
||
}
|
||
|
||
/// Установить информацию о пересылке
|
||
pub fn forward_from(mut self, forward: ForwardInfo) -> Self {
|
||
self.forward_from = Some(forward);
|
||
self
|
||
}
|
||
|
||
/// Установить реакции
|
||
pub fn reactions(mut self, reactions: Vec<ReactionInfo>) -> Self {
|
||
self.reactions = reactions;
|
||
self
|
||
}
|
||
|
||
/// Добавить одну реакцию
|
||
pub fn add_reaction(mut self, reaction: ReactionInfo) -> Self {
|
||
self.reactions.push(reaction);
|
||
self
|
||
}
|
||
|
||
/// Построить MessageInfo из данных builder'а
|
||
pub fn build(self) -> MessageInfo {
|
||
MessageInfo::new(
|
||
self.id,
|
||
self.sender_name,
|
||
self.is_outgoing,
|
||
self.text,
|
||
self.entities,
|
||
self.date,
|
||
self.edit_date,
|
||
self.is_read,
|
||
self.can_be_edited,
|
||
self.can_be_deleted_only_for_self,
|
||
self.can_be_deleted_for_all_users,
|
||
self.reply_to,
|
||
self.forward_from,
|
||
self.reactions,
|
||
)
|
||
}
|
||
}
|
||
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use crate::types::MessageId;
|
||
|
||
#[test]
|
||
fn test_message_builder_basic() {
|
||
let message = MessageBuilder::new(MessageId::new(123))
|
||
.sender_name("Alice")
|
||
.text("Hello, world!")
|
||
.date(1640000000)
|
||
.build();
|
||
|
||
assert_eq!(message.id(), MessageId::new(123));
|
||
assert_eq!(message.sender_name(), "Alice");
|
||
assert_eq!(message.text(), "Hello, world!");
|
||
assert_eq!(message.date(), 1640000000);
|
||
assert!(!message.is_outgoing());
|
||
}
|
||
|
||
#[test]
|
||
fn test_message_builder_outgoing() {
|
||
let message = MessageBuilder::new(MessageId::new(456))
|
||
.sender_name("Me")
|
||
.text("Test message")
|
||
.outgoing()
|
||
.read()
|
||
.build();
|
||
|
||
assert!(message.is_outgoing());
|
||
assert!(message.is_read());
|
||
assert!(message.can_be_edited());
|
||
assert!(message.can_be_deleted_for_all_users());
|
||
}
|
||
|
||
#[test]
|
||
fn test_message_builder_edited() {
|
||
let message = MessageBuilder::new(MessageId::new(789))
|
||
.text("Original text")
|
||
.date(1640000000)
|
||
.edited()
|
||
.build();
|
||
|
||
assert!(message.is_edited());
|
||
assert_eq!(message.edit_date(), 1640000060);
|
||
}
|
||
|
||
#[test]
|
||
fn test_message_builder_with_reply() {
|
||
let reply = ReplyInfo {
|
||
message_id: MessageId::new(100),
|
||
sender_name: "Bob".to_string(),
|
||
text: "Original message".to_string(),
|
||
};
|
||
|
||
let message = MessageBuilder::new(MessageId::new(200))
|
||
.text("Reply text")
|
||
.reply_to(reply)
|
||
.build();
|
||
|
||
assert!(message.reply_to().is_some());
|
||
assert_eq!(message.reply_to().unwrap().sender_name, "Bob");
|
||
}
|
||
|
||
#[test]
|
||
fn test_message_builder_with_reactions() {
|
||
let reaction = ReactionInfo {
|
||
emoji: "👍".to_string(),
|
||
count: 5,
|
||
is_chosen: true,
|
||
};
|
||
|
||
let message = MessageBuilder::new(MessageId::new(300))
|
||
.text("Cool message")
|
||
.add_reaction(reaction.clone())
|
||
.build();
|
||
|
||
assert_eq!(message.reactions().len(), 1);
|
||
assert_eq!(message.reactions()[0].emoji, "👍");
|
||
assert_eq!(message.reactions()[0].count, 5);
|
||
}
|
||
|
||
#[test]
|
||
fn test_message_builder_fluent_api() {
|
||
let message = MessageBuilder::new(MessageId::new(999))
|
||
.sender_name("Charlie")
|
||
.text("Complex message")
|
||
.date(1640000000)
|
||
.outgoing()
|
||
.read()
|
||
.editable()
|
||
.deletable_for_all()
|
||
.build();
|
||
|
||
assert_eq!(message.sender_name(), "Charlie");
|
||
assert_eq!(message.text(), "Complex message");
|
||
assert!(message.is_outgoing());
|
||
assert!(message.is_read());
|
||
assert!(message.can_be_edited());
|
||
assert!(message.can_be_deleted_for_all_users());
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
pub struct FolderInfo {
|
||
pub id: i32,
|
||
pub name: String,
|
||
}
|
||
|
||
/// Информация о профиле чата/пользователя
|
||
#[derive(Debug, Clone)]
|
||
pub struct ProfileInfo {
|
||
pub chat_id: ChatId,
|
||
pub title: String,
|
||
pub username: Option<String>,
|
||
pub bio: Option<String>,
|
||
pub phone_number: Option<String>,
|
||
pub chat_type: String, // "Личный чат", "Группа", "Канал"
|
||
pub member_count: Option<i32>,
|
||
pub description: Option<String>,
|
||
pub invite_link: Option<String>,
|
||
pub is_group: bool,
|
||
pub online_status: Option<String>,
|
||
}
|
||
|
||
/// Состояние сетевого соединения
|
||
#[derive(Debug, Clone, PartialEq)]
|
||
pub enum NetworkState {
|
||
/// Ожидание подключения к сети
|
||
WaitingForNetwork,
|
||
/// Подключение к прокси
|
||
ConnectingToProxy,
|
||
/// Подключение к серверам Telegram
|
||
Connecting,
|
||
/// Обновление данных
|
||
Updating,
|
||
/// Подключено
|
||
Ready,
|
||
}
|
||
|
||
/// Онлайн-статус пользователя
|
||
#[derive(Debug, Clone, PartialEq)]
|
||
pub enum UserOnlineStatus {
|
||
/// Онлайн
|
||
Online,
|
||
/// Был недавно (менее часа назад)
|
||
Recently,
|
||
/// Был на этой неделе
|
||
LastWeek,
|
||
/// Был в этом месяце
|
||
LastMonth,
|
||
/// Давно не был
|
||
LongTimeAgo,
|
||
/// Оффлайн с указанием времени (unix timestamp)
|
||
Offline(i32),
|
||
}
|