// // Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2020 // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #pragma once #include "td/telegram/secret_api.h" #include "td/telegram/td_api.h" #include "td/telegram/telegram_api.h" #include "td/telegram/AccessRights.h" #include "td/telegram/ChannelId.h" #include "td/telegram/Dependencies.h" #include "td/telegram/DialogAdministrator.h" #include "td/telegram/DialogDate.h" #include "td/telegram/DialogDb.h" #include "td/telegram/DialogId.h" #include "td/telegram/DialogLocation.h" #include "td/telegram/DialogParticipant.h" #include "td/telegram/files/FileId.h" #include "td/telegram/files/FileSourceId.h" #include "td/telegram/FolderId.h" #include "td/telegram/FullMessageId.h" #include "td/telegram/Global.h" #include "td/telegram/MessageContent.h" #include "td/telegram/MessageEntity.h" #include "td/telegram/MessageId.h" #include "td/telegram/MessagesDb.h" #include "td/telegram/net/NetQuery.h" #include "td/telegram/Notification.h" #include "td/telegram/NotificationGroupId.h" #include "td/telegram/NotificationGroupKey.h" #include "td/telegram/NotificationGroupType.h" #include "td/telegram/NotificationId.h" #include "td/telegram/NotificationSettings.h" #include "td/telegram/ReplyMarkup.h" #include "td/telegram/RestrictionReason.h" #include "td/telegram/ScheduledServerMessageId.h" #include "td/telegram/SecretChatId.h" #include "td/telegram/SecretInputMedia.h" #include "td/telegram/ServerMessageId.h" #include "td/telegram/UserId.h" #include "td/actor/actor.h" #include "td/actor/MultiPromise.h" #include "td/actor/PromiseFuture.h" #include "td/actor/SignalSlot.h" #include "td/actor/Timeout.h" #include "td/utils/buffer.h" #include "td/utils/ChangesProcessor.h" #include "td/utils/common.h" #include "td/utils/Heap.h" #include "td/utils/Hints.h" #include "td/utils/logging.h" #include "td/utils/Slice.h" #include "td/utils/Status.h" #include "td/utils/StringBuilder.h" #include "td/utils/tl_storers.h" #include #include #include #include #include #include #include #include namespace td { struct BinlogEvent; class Td; class MultiSequenceDispatcher; class DraftMessage; class dummyUpdate : public telegram_api::Update { public: static constexpr int32 ID = 1234567891; int32 get_id() const override { return ID; } void store(TlStorerUnsafe &s) const override { UNREACHABLE(); } void store(TlStorerCalcLength &s) const override { UNREACHABLE(); } void store(TlStorerToString &s, const char *field_name) const override; }; class updateSentMessage : public telegram_api::Update { public: int64 random_id_; MessageId message_id_; int32 date_; updateSentMessage(int64 random_id, MessageId message_id, int32 date) : random_id_(random_id), message_id_(message_id), date_(date) { } static constexpr int32 ID = 1234567890; int32 get_id() const override { return ID; } void store(TlStorerUnsafe &s) const override { UNREACHABLE(); } void store(TlStorerCalcLength &s) const override { UNREACHABLE(); } void store(TlStorerToString &s, const char *field_name) const override { s.store_class_begin(field_name, "updateSentMessage"); s.store_field("random_id", random_id_); s.store_field("message_id", message_id_.get()); s.store_field("date", date_); s.store_class_end(); } }; class MessagesManager : public Actor { public: // static constexpr int32 MESSAGE_FLAG_IS_UNREAD = 1 << 0; static constexpr int32 MESSAGE_FLAG_IS_OUT = 1 << 1; static constexpr int32 MESSAGE_FLAG_IS_FORWARDED = 1 << 2; static constexpr int32 MESSAGE_FLAG_IS_REPLY = 1 << 3; static constexpr int32 MESSAGE_FLAG_HAS_MENTION = 1 << 4; static constexpr int32 MESSAGE_FLAG_HAS_UNREAD_CONTENT = 1 << 5; static constexpr int32 MESSAGE_FLAG_HAS_REPLY_MARKUP = 1 << 6; static constexpr int32 MESSAGE_FLAG_HAS_ENTITIES = 1 << 7; static constexpr int32 MESSAGE_FLAG_HAS_FROM_ID = 1 << 8; static constexpr int32 MESSAGE_FLAG_HAS_MEDIA = 1 << 9; static constexpr int32 MESSAGE_FLAG_HAS_VIEWS = 1 << 10; static constexpr int32 MESSAGE_FLAG_IS_SENT_VIA_BOT = 1 << 11; static constexpr int32 MESSAGE_FLAG_IS_SILENT = 1 << 13; static constexpr int32 MESSAGE_FLAG_IS_POST = 1 << 14; static constexpr int32 MESSAGE_FLAG_HAS_EDIT_DATE = 1 << 15; static constexpr int32 MESSAGE_FLAG_HAS_AUTHOR_SIGNATURE = 1 << 16; static constexpr int32 MESSAGE_FLAG_HAS_MEDIA_ALBUM_ID = 1 << 17; static constexpr int32 MESSAGE_FLAG_IS_FROM_SCHEDULED = 1 << 18; static constexpr int32 MESSAGE_FLAG_IS_LEGACY = 1 << 19; static constexpr int32 MESSAGE_FLAG_HIDE_EDIT_DATE = 1 << 21; static constexpr int32 MESSAGE_FLAG_IS_RESTRICTED = 1 << 22; static constexpr int32 SEND_MESSAGE_FLAG_IS_REPLY = 1 << 0; static constexpr int32 SEND_MESSAGE_FLAG_DISABLE_WEB_PAGE_PREVIEW = 1 << 1; static constexpr int32 SEND_MESSAGE_FLAG_HAS_REPLY_MARKUP = 1 << 2; static constexpr int32 SEND_MESSAGE_FLAG_HAS_ENTITIES = 1 << 3; // static constexpr int32 SEND_MESSAGE_FLAG_IS_POST = 1 << 4; static constexpr int32 SEND_MESSAGE_FLAG_DISABLE_NOTIFICATION = 1 << 5; static constexpr int32 SEND_MESSAGE_FLAG_FROM_BACKGROUND = 1 << 6; static constexpr int32 SEND_MESSAGE_FLAG_CLEAR_DRAFT = 1 << 7; static constexpr int32 SEND_MESSAGE_FLAG_WITH_MY_SCORE = 1 << 8; static constexpr int32 SEND_MESSAGE_FLAG_GROUP_MEDIA = 1 << 9; static constexpr int32 SEND_MESSAGE_FLAG_HAS_SCHEDULE_DATE = 1 << 10; static constexpr int32 SEND_MESSAGE_FLAG_HAS_MESSAGE = 1 << 11; static constexpr int32 ONLINE_MEMBER_COUNT_CACHE_EXPIRE_TIME = 30 * 60; MessagesManager(Td *td, ActorShared<> parent); MessagesManager(const MessagesManager &) = delete; MessagesManager &operator=(const MessagesManager &) = delete; MessagesManager(MessagesManager &&) = delete; MessagesManager &operator=(MessagesManager &&) = delete; ~MessagesManager() override; static vector get_message_ids(const vector &input_message_ids); static vector get_server_message_ids(const vector &message_ids); static vector get_scheduled_server_message_ids(const vector &message_ids); DialogId get_message_dialog_id(const tl_object_ptr &message_ptr) const; tl_object_ptr get_input_peer(DialogId dialog_id, AccessRights access_rights) const; vector> get_input_peers(const vector &dialog_ids, AccessRights access_rights) const; tl_object_ptr get_input_dialog_peer(DialogId dialog_id, AccessRights access_rights) const; vector> get_input_dialog_peers(const vector &dialog_ids, AccessRights access_rights) const; tl_object_ptr get_input_encrypted_chat(DialogId dialog_id, AccessRights access_rights) const; bool have_input_peer(DialogId dialog_id, AccessRights access_rights) const; struct MessagesInfo { vector> messages; int32 total_count = 0; bool is_channel_messages = false; }; MessagesInfo on_get_messages(tl_object_ptr &&messages_ptr, const char *source); void on_get_messages(vector> &&messages, bool is_channel_message, bool is_scheduled, const char *source); void on_get_history(DialogId dialog_id, MessageId from_message_id, int32 offset, int32 limit, bool from_the_end, vector> &&messages); void on_get_public_dialogs_search_result(const string &query, vector> &&my_peers, vector> &&peers); void on_failed_public_dialogs_search(const string &query, Status &&error); void on_get_dialog_messages_search_result(DialogId dialog_id, const string &query, UserId sender_user_id, MessageId from_message_id, int32 offset, int32 limit, SearchMessagesFilter filter, int64 random_id, int32 total_count, vector> &&messages); void on_failed_dialog_messages_search(DialogId dialog_id, int64 random_id); void on_get_messages_search_result(const string &query, int32 offset_date, DialogId offset_dialog_id, MessageId offset_message_id, int32 limit, int64 random_id, int32 total_count, vector> &&messages); void on_failed_messages_search(int64 random_id); void on_get_scheduled_server_messages(DialogId dialog_id, uint32 generation, vector> &&messages, bool is_not_modified); void on_get_recent_locations(DialogId dialog_id, int32 limit, int64 random_id, int32 total_count, vector> &&messages); void on_get_recent_locations_failed(int64 random_id); // if message is from_update, flags have_previous and have_next are ignored and should be both true FullMessageId on_get_message(tl_object_ptr message_ptr, bool from_update, bool is_channel_message, bool is_scheduled, bool have_previous, bool have_next, const char *source); void open_secret_message(SecretChatId secret_chat_id, int64 random_id, Promise<>); void on_send_secret_message_success(int64 random_id, MessageId message_id, int32 date, tl_object_ptr file_ptr, Promise<> promise); void on_send_secret_message_error(int64 random_id, Status error, Promise<> promise); void delete_secret_messages(SecretChatId secret_chat_id, std::vector random_ids, Promise<> promise); void delete_secret_chat_history(SecretChatId secret_chat_id, MessageId last_message_id, Promise<> promise); void read_secret_chat_outbox(SecretChatId secret_chat_id, int32 up_to_date, int32 read_date); void on_update_secret_chat_state(SecretChatId secret_chat_id, SecretChatState state); void on_get_secret_message(SecretChatId secret_chat_id, UserId user_id, MessageId message_id, int32 date, tl_object_ptr file, tl_object_ptr message, Promise<> promise); void on_secret_chat_screenshot_taken(SecretChatId secret_chat_id, UserId user_id, MessageId message_id, int32 date, int64 random_id, Promise<> promise); void on_secret_chat_ttl_changed(SecretChatId secret_chat_id, UserId user_id, MessageId message_id, int32 date, int32 ttl, int64 random_id, Promise<> promise); void on_update_sent_text_message(int64 random_id, tl_object_ptr message_media, vector> &&entities); void on_update_message_web_page(FullMessageId full_message_id, bool have_web_page); void on_get_dialogs(FolderId folder_id, vector> &&dialog_folders, int32 total_count, vector> &&messages, Promise &&promise); void on_get_common_dialogs(UserId user_id, int32 offset_chat_id, vector> &&chats, int32 total_count); bool on_update_message_id(int64 random_id, MessageId new_message_id, const string &source); bool on_update_scheduled_message_id(int64 random_id, ScheduledServerMessageId new_message_id, const string &source); void on_update_dialog_draft_message(DialogId dialog_id, tl_object_ptr &&draft_message); void on_update_dialog_is_pinned(FolderId folder_id, DialogId dialog_id, bool is_pinned); void on_update_pinned_dialogs(FolderId folder_id); void on_update_dialog_is_marked_as_unread(DialogId dialog_id, bool is_marked_as_unread); void on_update_dialog_pinned_message_id(DialogId dialog_id, MessageId pinned_message_id); void on_update_dialog_has_scheduled_server_messages(DialogId dialog_id, bool has_scheduled_server_messages); void on_update_dialog_folder_id(DialogId dialog_id, FolderId folder_id); void on_update_service_notification(tl_object_ptr &&update, bool skip_new_entities, Promise &&promise); void on_update_new_channel_message(tl_object_ptr &&update); void on_update_edit_channel_message(tl_object_ptr &&update); void on_update_read_channel_inbox(tl_object_ptr &&update); void on_update_read_channel_outbox(tl_object_ptr &&update); void on_update_read_channel_messages_contents( tl_object_ptr &&update); void on_update_channel_too_long(tl_object_ptr &&update, bool force_apply); void on_update_message_views(FullMessageId full_message_id, int32 views); void on_update_live_location_viewed(FullMessageId full_message_id); void on_update_some_live_location_viewed(Promise &&promise); void on_update_message_content(FullMessageId full_message_id); void on_read_channel_inbox(ChannelId channel_id, MessageId max_message_id, int32 server_unread_count, int32 pts, const char *source); void on_read_channel_outbox(ChannelId channel_id, MessageId max_message_id); void on_update_channel_max_unavailable_message_id(ChannelId channel_id, MessageId max_unavailable_message_id); void on_update_dialog_online_member_count(DialogId dialog_id, int32 online_member_count, bool is_from_server); void on_update_delete_scheduled_messages(DialogId dialog_id, vector &&server_message_ids); void on_update_include_sponsored_dialog_to_unread_count(); void on_user_dialog_action(DialogId dialog_id, UserId user_id, tl_object_ptr &&action, int32 date, MessageContentType message_content_type = MessageContentType::None); void read_history_inbox(DialogId dialog_id, MessageId max_message_id, int32 unread_count, const char *source); void delete_messages(DialogId dialog_id, const vector &message_ids, bool revoke, Promise &&promise); void delete_dialog_history(DialogId dialog_id, bool remove_from_dialog_list, bool revoke, Promise &&promise); void delete_dialog_messages_from_user(DialogId dialog_id, UserId user_id, Promise &&promise); void delete_dialog(DialogId dialog_id); void read_all_dialog_mentions(DialogId dialog_id, Promise &&promise); Status add_recently_found_dialog(DialogId dialog_id) TD_WARN_UNUSED_RESULT; Status remove_recently_found_dialog(DialogId dialog_id) TD_WARN_UNUSED_RESULT; void clear_recently_found_dialogs(); DialogId resolve_dialog_username(const string &username) const; DialogId search_public_dialog(const string &username_to_search, bool force, Promise &&promise); Result send_message( DialogId dialog_id, MessageId reply_to_message_id, tl_object_ptr &&options, tl_object_ptr &&reply_markup, tl_object_ptr &&input_message_content) TD_WARN_UNUSED_RESULT; Result> send_message_group( DialogId dialog_id, MessageId reply_to_message_id, tl_object_ptr &&options, vector> &&input_message_contents) TD_WARN_UNUSED_RESULT; Result send_bot_start_message(UserId bot_user_id, DialogId dialog_id, const string ¶meter) TD_WARN_UNUSED_RESULT; Result send_inline_query_result_message(DialogId dialog_id, MessageId reply_to_message_id, tl_object_ptr &&options, int64 query_id, const string &result_id, bool hide_via_bot) TD_WARN_UNUSED_RESULT; Result> forward_messages(DialogId to_dialog_id, DialogId from_dialog_id, vector message_ids, tl_object_ptr &&options, bool in_game_share, bool as_album, bool send_copy, bool remove_caption) TD_WARN_UNUSED_RESULT; Result> resend_messages(DialogId dialog_id, vector message_ids) TD_WARN_UNUSED_RESULT; Result send_dialog_set_ttl_message(DialogId dialog_id, int32 ttl); Status send_screenshot_taken_notification_message(DialogId dialog_id); Result add_local_message( DialogId dialog_id, UserId sender_user_id, MessageId reply_to_message_id, bool disable_notification, tl_object_ptr &&input_message_content) TD_WARN_UNUSED_RESULT; void edit_message_text(FullMessageId full_message_id, tl_object_ptr &&reply_markup, tl_object_ptr &&input_message_content, Promise &&promise); void edit_message_live_location(FullMessageId full_message_id, tl_object_ptr &&reply_markup, tl_object_ptr &&input_location, Promise &&promise); void edit_message_media(FullMessageId full_message_id, tl_object_ptr &&reply_markup, tl_object_ptr &&input_message_content, Promise &&promise); void edit_message_caption(FullMessageId full_message_id, tl_object_ptr &&reply_markup, tl_object_ptr &&input_caption, Promise &&promise); void edit_message_reply_markup(FullMessageId full_message_id, tl_object_ptr &&reply_markup, Promise &&promise); void edit_inline_message_text(const string &inline_message_id, tl_object_ptr &&reply_markup, tl_object_ptr &&input_message_content, Promise &&promise); void edit_inline_message_live_location(const string &inline_message_id, tl_object_ptr &&reply_markup, tl_object_ptr &&input_location, Promise &&promise); void edit_inline_message_media(const string &inline_message_id, tl_object_ptr &&reply_markup, tl_object_ptr &&input_message_content, Promise &&promise); void edit_inline_message_caption(const string &inline_message_id, tl_object_ptr &&reply_markup, tl_object_ptr &&input_caption, Promise &&promise); void edit_inline_message_reply_markup(const string &inline_message_id, tl_object_ptr &&reply_markup, Promise &&promise); void edit_message_scheduling_state(FullMessageId full_message_id, td_api::object_ptr &&scheduling_state, Promise &&promise); void set_game_score(FullMessageId full_message_id, bool edit_message, UserId user_id, int32 score, bool force, Promise &&promise); void set_inline_game_score(const string &inline_message_id, bool edit_message, UserId user_id, int32 score, bool force, Promise &&promise); int64 get_game_high_scores(FullMessageId full_message_id, UserId user_id, Promise &&promise); int64 get_inline_game_high_scores(const string &inline_message_id, UserId user_id, Promise &&promise); void on_get_game_high_scores(int64 random_id, tl_object_ptr &&high_scores); tl_object_ptr get_game_high_scores_object(int64 random_id); void send_dialog_action(DialogId dialog_id, const tl_object_ptr &action, Promise &&promise); void set_dialog_folder_id(DialogId dialog_id, FolderId folder_id, Promise &&promise); void set_dialog_photo(DialogId dialog_id, const tl_object_ptr &photo, Promise &&promise); void set_dialog_title(DialogId dialog_id, const string &title, Promise &&promise); void set_dialog_description(DialogId dialog_id, const string &description, Promise &&promise); void set_dialog_permissions(DialogId dialog_id, const td_api::object_ptr &permissions, Promise &&promise); void pin_dialog_message(DialogId dialog_id, MessageId message_id, bool disable_notification, bool is_unpin, Promise &&promise); void add_dialog_participant(DialogId dialog_id, UserId user_id, int32 forward_limit, Promise &&promise); void add_dialog_participants(DialogId dialog_id, const vector &user_ids, Promise &&promise); void set_dialog_participant_status(DialogId dialog_id, UserId user_id, const tl_object_ptr &chat_member_status, Promise &&promise); DialogParticipant get_dialog_participant(DialogId dialog_id, UserId user_id, int64 &random_id, bool force, Promise &&promise); std::pair> search_dialog_participants(DialogId dialog_id, const string &query, int32 limit, DialogParticipantsFilter filter, int64 &random_id, bool force, Promise &&promise); vector get_dialog_administrators(DialogId dialog_id, int left_tries, Promise &&promise); void export_dialog_invite_link(DialogId dialog_id, Promise &&promise); string get_dialog_invite_link(DialogId dialog_id); void get_dialog_info_full(DialogId dialog_id, Promise &&promise); int64 get_dialog_event_log(DialogId dialog_id, const string &query, int64 from_event_id, int32 limit, const tl_object_ptr &filters, const vector &user_ids, Promise &&promise); void on_get_event_log(ChannelId channel_id, int64 random_id, tl_object_ptr &&events); tl_object_ptr get_chat_events_object(int64 random_id); bool have_dialog(DialogId dialog_id) const; bool have_dialog_force(DialogId dialog_id); bool load_dialog(DialogId dialog_id, int left_tries, Promise &&promise); void load_dialogs(vector dialog_ids, Promise &&promise); vector get_dialogs(FolderId folder_id, DialogDate offset, int32 limit, bool force, Promise &&promise); vector search_public_dialogs(const string &query, Promise &&promise); std::pair> search_dialogs(const string &query, int32 limit, Promise &&promise); vector search_dialogs_on_server(const string &query, int32 limit, Promise &&promise); void drop_common_dialogs_cache(UserId user_id); vector get_common_dialogs(UserId user_id, DialogId offset_dialog_id, int32 limit, bool force, Promise &&promise); bool have_message_force(FullMessageId full_message_id, const char *source); void get_message(FullMessageId full_message_id, Promise &&promise); MessageId get_replied_message(DialogId dialog_id, MessageId message_id, bool force, Promise &&promise); MessageId get_dialog_pinned_message(DialogId dialog_id, Promise &&promise); bool get_messages(DialogId dialog_id, const vector &message_ids, Promise &&promise); void get_message_from_server(FullMessageId full_message_id, Promise &&promise, tl_object_ptr input_message = nullptr); void get_messages_from_server(vector &&message_ids, Promise &&promise, tl_object_ptr input_message = nullptr); bool is_message_edited_recently(FullMessageId full_message_id, int32 seconds); std::pair get_public_message_link(FullMessageId full_message_id, bool for_group, Promise &&promise); void on_get_public_message_link(FullMessageId full_message_id, bool for_group, string url, string html); string get_message_link(FullMessageId full_message_id, Promise &&promise); struct MessageLinkInfo { string username; // or ChannelId channel_id; MessageId message_id; bool is_single = false; }; void get_message_link_info(Slice url, Promise &&promise); td_api::object_ptr get_message_link_info_object(const MessageLinkInfo &info) const; Status delete_dialog_reply_markup(DialogId dialog_id, MessageId message_id) TD_WARN_UNUSED_RESULT; Status set_dialog_draft_message(DialogId dialog_id, tl_object_ptr &&draft_message) TD_WARN_UNUSED_RESULT; void clear_all_draft_messages(bool exclude_secret_chats, Promise &&promise); void set_dialog_is_pinned(DialogId dialog_id, bool is_pinned); Status toggle_dialog_is_pinned(DialogId dialog_id, bool is_pinned) TD_WARN_UNUSED_RESULT; Status toggle_dialog_is_marked_as_unread(DialogId dialog_id, bool is_marked_as_unread) TD_WARN_UNUSED_RESULT; Status toggle_dialog_silent_send_message(DialogId dialog_id, bool silent_send_message) TD_WARN_UNUSED_RESULT; Status set_pinned_dialogs(FolderId folder_id, vector dialog_ids) TD_WARN_UNUSED_RESULT; Status set_dialog_client_data(DialogId dialog_id, string &&client_data) TD_WARN_UNUSED_RESULT; void create_dialog(DialogId dialog_id, bool force, Promise &&promise); DialogId create_new_group_chat(const vector &user_ids, const string &title, int64 &random_id, Promise &&promise); DialogId create_new_channel_chat(const string &title, bool is_megagroup, const string &description, const DialogLocation &location, int64 &random_id, Promise &&promise); void create_new_secret_chat(UserId user_id, Promise &&promise); DialogId migrate_dialog_to_megagroup(DialogId dialog_id, Promise &&promise); Status open_dialog(DialogId dialog_id) TD_WARN_UNUSED_RESULT; Status close_dialog(DialogId dialog_id) TD_WARN_UNUSED_RESULT; Status view_messages(DialogId dialog_id, const vector &message_ids, bool force_read) TD_WARN_UNUSED_RESULT; Status open_message_content(FullMessageId full_message_id) TD_WARN_UNUSED_RESULT; td_api::object_ptr get_update_scope_notification_settings_object( NotificationSettingsScope scope) const; vector get_dialog_notification_settings_exceptions(NotificationSettingsScope scope, bool filter_scope, bool compare_sound, bool force, Promise &&promise); const ScopeNotificationSettings *get_scope_notification_settings(NotificationSettingsScope scope, Promise &&promise); Status set_dialog_notification_settings(DialogId dialog_id, tl_object_ptr &¬ification_settings) TD_WARN_UNUSED_RESULT; Status set_scope_notification_settings(NotificationSettingsScope scope, tl_object_ptr &¬ification_settings) TD_WARN_UNUSED_RESULT; void reset_all_notification_settings(); tl_object_ptr get_chat_object(DialogId dialog_id) const; static tl_object_ptr get_chats_object(const vector &dialogs); tl_object_ptr get_dialog_history(DialogId dialog_id, MessageId from_message_id, int32 offset, int32 limit, int left_tries, bool only_local, Promise &&promise); std::pair> search_dialog_messages(DialogId dialog_id, const string &query, UserId sender_user_id, MessageId from_message_id, int32 offset, int32 limit, const tl_object_ptr &filter, int64 &random_id, bool use_db, Promise &&promise); std::pair> offline_search_messages( DialogId dialog_id, const string &query, int64 from_search_id, int32 limit, const tl_object_ptr &filter, int64 &random_id, Promise<> &&promise); std::pair> search_messages(FolderId folder_id, bool ignore_folder_id, const string &query, int32 offset_date, DialogId offset_dialog_id, MessageId offset_message_id, int32 limit, int64 &random_id, Promise &&promise); std::pair> search_call_messages(MessageId from_message_id, int32 limit, bool only_missed, int64 &random_id, bool use_db, Promise &&promise); std::pair> search_dialog_recent_location_messages(DialogId dialog_id, int32 limit, int64 &random_id, Promise &&promise); vector get_active_live_location_messages(Promise &&promise); int64 get_dialog_message_by_date(DialogId dialog_id, int32 date, Promise &&promise); void on_get_dialog_message_by_date_success(DialogId dialog_id, int32 date, int64 random_id, vector> &&messages); void on_get_dialog_message_by_date_fail(int64 random_id); int32 get_dialog_message_count(DialogId dialog_id, const tl_object_ptr &filter, bool return_local, int64 &random_id, Promise &&promise); vector get_dialog_scheduled_messages(DialogId dialog_id, Promise &&promise); tl_object_ptr get_dialog_message_by_date_object(int64 random_id); tl_object_ptr get_message_object(FullMessageId full_message_id); tl_object_ptr get_messages_object(int32 total_count, DialogId dialog_id, const vector &message_ids); tl_object_ptr get_messages_object(int32 total_count, const vector &full_message_ids); void add_pending_update(tl_object_ptr &&update, int32 new_pts, int32 pts_count, bool force_apply, const char *source); void add_pending_channel_update(DialogId dialog_id, tl_object_ptr &&update, int32 new_pts, int32 pts_count, const char *source, bool is_postponed_update = false); bool is_update_about_username_change_received(DialogId dialog_id) const; void on_dialog_bots_updated(DialogId dialog_id, vector bot_user_ids); void on_dialog_photo_updated(DialogId dialog_id); void on_dialog_title_updated(DialogId dialog_id); void on_dialog_username_updated(DialogId dialog_id, const string &old_username, const string &new_username); void on_dialog_permissions_updated(DialogId dialog_id); void on_dialog_user_is_contact_updated(DialogId dialog_id, bool is_contact); void on_dialog_user_is_blocked_updated(DialogId dialog_id, bool is_blocked); void on_dialog_user_is_deleted_updated(DialogId dialog_id, bool is_deleted); void on_resolved_username(const string &username, DialogId dialog_id); void drop_username(const string &username); static tl_object_ptr get_input_messages_filter(SearchMessagesFilter filter); static SearchMessagesFilter get_search_messages_filter(const tl_object_ptr &filter); tl_object_ptr get_input_notify_peer(DialogId dialogId) const; void on_update_dialog_notify_settings(DialogId dialog_id, tl_object_ptr &&peer_notify_settings, const char *source); void on_update_scope_notify_settings(NotificationSettingsScope scope, tl_object_ptr &&peer_notify_settings); void hide_dialog_action_bar(DialogId dialog_id); void remove_dialog_action_bar(DialogId dialog_id, Promise &&promise); void repair_dialog_action_bar(DialogId dialog_id, const char *source); void report_dialog(DialogId dialog_id, const tl_object_ptr &reason, const vector &message_ids, Promise &&promise); void on_get_peer_settings(DialogId dialog_id, tl_object_ptr &&peer_settings, bool ignore_privacy_exception = false); void get_dialog_statistics_url(DialogId dialog_id, const string ¶meters, bool is_dark, Promise> &&promise); void get_login_url_info(DialogId dialog_id, MessageId message_id, int32 button_id, Promise> &&promise); void get_login_url(DialogId dialog_id, MessageId message_id, int32 button_id, bool allow_write_access, Promise> &&promise); void before_get_difference(); void after_get_difference(); bool on_get_dialog_error(DialogId dialog_id, const Status &status, const string &source); void on_send_message_get_quick_ack(int64 random_id); void check_send_message_result(int64 random_id, DialogId dialog_id, const telegram_api::Updates *updates_ptr, const char *source); FullMessageId on_send_message_success(int64 random_id, MessageId new_message_id, int32 date, FileId new_file_id, const char *source); void on_send_message_file_part_missing(int64 random_id, int bad_part); void on_send_message_file_reference_error(int64 random_id); void on_send_media_group_file_reference_error(DialogId dialog_id, vector random_ids); void on_send_message_fail(int64 random_id, Status error); void on_upload_message_media_success(DialogId dialog_id, MessageId message_id, tl_object_ptr &&media); void on_upload_message_media_file_part_missing(DialogId dialog_id, MessageId message_id, int bad_part); void on_upload_message_media_fail(DialogId dialog_id, MessageId message_id, Status error); void on_create_new_dialog_success(int64 random_id, tl_object_ptr &&updates, DialogType expected_type, Promise &&promise); void on_create_new_dialog_fail(int64 random_id, Status error, Promise &&promise); void on_get_channel_difference(DialogId dialog_id, int32 request_pts, int32 request_limit, tl_object_ptr &&difference_ptr); void force_create_dialog(DialogId dialog_id, const char *source, bool expect_no_access = false, bool force_update_dialog_pos = false); void send_get_dialog_notification_settings_query(DialogId dialog_id, Promise &&promise); void send_get_scope_notification_settings_query(NotificationSettingsScope scope, Promise &&promise); void on_get_dialog_notification_settings_query_finished(DialogId dialog_id, Status &&status); void on_get_dialog_query_finished(DialogId dialog_id, Status &&status); void on_get_sponsored_dialog_id(tl_object_ptr peer, vector> users, vector> chats); FileSourceId get_message_file_source_id(FullMessageId full_message_id); struct MessagePushNotificationInfo { NotificationGroupId group_id; NotificationGroupType group_type = NotificationGroupType::Calls; DialogId settings_dialog_id; }; Result get_message_push_notification_info(DialogId dialog_id, MessageId message_id, int64 random_id, UserId sender_user_id, int32 date, bool is_from_scheduled, bool contains_mention, bool is_pinned, bool is_from_binlog); struct MessageNotificationGroup { DialogId dialog_id; NotificationGroupType type = NotificationGroupType::Calls; int32 total_count = 0; vector notifications; }; MessageNotificationGroup get_message_notification_group_force(NotificationGroupId group_id); vector get_message_notification_group_keys_from_database(NotificationGroupKey from_group_key, int32 limit); void get_message_notifications_from_database(DialogId dialog_id, NotificationGroupId group_id, NotificationId from_notification_id, MessageId from_message_id, int32 limit, Promise> promise); void remove_message_notification(DialogId dialog_id, NotificationGroupId group_id, NotificationId notification_id); void remove_message_notifications_by_message_ids(DialogId dialog_id, const vector &message_ids); void remove_message_notifications(DialogId dialog_id, NotificationGroupId group_id, NotificationId max_notification_id, MessageId max_message_id); void upload_dialog_photo(DialogId dialog_id, FileId file_id, Promise &&promise); void on_binlog_events(vector &&events); void set_poll_answer(FullMessageId full_message_id, vector &&option_ids, Promise &&promise); void get_poll_voters(FullMessageId full_message_id, int32 option_id, int32 offset, Promise>> &&promise); void stop_poll(FullMessageId full_message_id, td_api::object_ptr &&reply_markup, Promise &&promise); void get_payment_form(FullMessageId full_message_id, Promise> &&promise); void validate_order_info(FullMessageId full_message_id, tl_object_ptr order_info, bool allow_save, Promise> &&promise); void send_payment_form(FullMessageId full_message_id, const string &order_info_id, const string &shipping_option_id, const tl_object_ptr &credentials, Promise> &&promise); void get_payment_receipt(FullMessageId full_message_id, Promise> &&promise); void get_current_state(vector> &updates) const; static void add_dialog_dependencies(Dependencies &dependencies, DialogId dialog_id); void resolve_dependencies_force(const Dependencies &dependencies); ActorOwn sequence_dispatcher_; private: class PendingPtsUpdate { public: tl_object_ptr update; int32 pts; int32 pts_count; PendingPtsUpdate(tl_object_ptr &&update, int32 pts, int32 pts_count) : update(std::move(update)), pts(pts), pts_count(pts_count) { } }; struct MessageInfo { DialogId dialog_id; MessageId message_id; UserId sender_user_id; int32 date = 0; int32 ttl = 0; int64 random_id = 0; tl_object_ptr forward_header; MessageId reply_to_message_id; UserId via_bot_user_id; int32 views = 0; int32 flags = 0; int32 edit_date = 0; vector restriction_reasons; string author_signature; int64 media_album_id = 0; unique_ptr content; tl_object_ptr reply_markup; }; struct MessageForwardInfo { UserId sender_user_id; int32 date = 0; DialogId dialog_id; MessageId message_id; string author_signature; string sender_name; DialogId from_dialog_id; MessageId from_message_id; MessageForwardInfo() = default; MessageForwardInfo(UserId sender_user_id, int32 date, DialogId dialog_id, MessageId message_id, string author_signature, string sender_name, DialogId from_dialog_id, MessageId from_message_id) : sender_user_id(sender_user_id) , date(date) , dialog_id(dialog_id) , message_id(message_id) , author_signature(std::move(author_signature)) , sender_name(std::move(sender_name)) , from_dialog_id(from_dialog_id) , from_message_id(from_message_id) { } bool operator==(const MessageForwardInfo &rhs) const { return sender_user_id == rhs.sender_user_id && date == rhs.date && dialog_id == rhs.dialog_id && message_id == rhs.message_id && author_signature == rhs.author_signature && sender_name == rhs.sender_name && from_dialog_id == rhs.from_dialog_id && from_message_id == rhs.from_message_id; } bool operator!=(const MessageForwardInfo &rhs) const { return !(*this == rhs); } friend StringBuilder &operator<<(StringBuilder &string_builder, const MessageForwardInfo &forward_info) { return string_builder << "MessageForwardInfo[sender " << forward_info.sender_user_id << "(" << forward_info.author_signature << "/" << forward_info.sender_name << "), source " << forward_info.dialog_id << ", source " << forward_info.message_id << ", from " << forward_info.from_dialog_id << ", from " << forward_info.from_message_id << " at " << forward_info.date << "]"; } }; // Do not forget to update MessagesManager::update_message and all make_unique when this class is changed struct Message { int32 random_y; MessageId message_id; UserId sender_user_id; int32 date = 0; int32 edit_date = 0; int32 send_date = 0; int64 random_id = 0; unique_ptr forward_info; MessageId reply_to_message_id; int64 reply_to_random_id = 0; // for send_message UserId via_bot_user_id; vector restriction_reasons; string author_signature; bool is_channel_post = false; bool is_outgoing = false; bool is_failed_to_send = false; bool disable_notification = false; bool contains_mention = false; bool contains_unread_mention = false; bool hide_edit_date = false; bool had_reply_markup = false; // had non-inline reply markup? bool had_forward_info = false; bool is_content_secret = false; // should be shown only while tapped bool is_mention_notification_disabled = false; bool is_from_scheduled = false; bool is_copy = false; // for send_message bool from_background = false; // for send_message bool disable_web_page_preview = false; // for send_message bool clear_draft = false; // for send_message bool in_game_share = false; // for send_message bool hide_via_bot = false; // for resend_message bool is_bot_start_message = false; // for resend_message bool have_previous = false; bool have_next = false; bool from_database = false; DialogId real_forward_from_dialog_id; // for resend_message MessageId real_forward_from_message_id; // for resend_message NotificationId notification_id; NotificationId removed_notification_id; int32 views = 0; int32 legacy_layer = 0; int32 send_error_code = 0; string send_error_message; double try_resend_at = 0; int32 ttl = 0; double ttl_expires_at = 0; int64 media_album_id = 0; unique_ptr content; unique_ptr reply_markup; int32 edited_schedule_date = 0; unique_ptr edited_content; unique_ptr edited_reply_markup; uint64 edit_generation = 0; Promise edit_promise; unique_ptr left; unique_ptr right; mutable int32 last_access_date = 0; mutable uint64 send_message_logevent_id = 0; mutable NetQueryRef send_query_ref; template void store(StorerT &storer) const; template void parse(ParserT &parser); }; struct NotificationGroupInfo { NotificationGroupId group_id; int32 last_notification_date = 0; // date of last notification in the group NotificationId last_notification_id; // identifier of last notification in the group NotificationId max_removed_notification_id; // notification identifier, up to which all notifications are removed MessageId max_removed_message_id; // message identifier, up to which all notifications are removed bool is_changed = false; // true, if the group needs to be saved to database bool try_reuse = false; // true, if the group needs to be deleted from database and tried to be reused template void store(StorerT &storer) const; template void parse(ParserT &parser); }; struct Dialog { DialogId dialog_id; MessageId last_new_message_id; // identifier of the last known server message received from update, there should be // no server messages after it MessageId last_message_id; // identifier of the message after which currently there is no any message, i.e. a // message without a gap after it, memory only MessageId first_database_message_id; // identifier of the first message in the database, needed // until there is no gaps in the database MessageId last_database_message_id; // identifier of the last local or server message, if last_database_message_id // is known and last_message_id is known, then last_database_message_id <= // last_message_id std::array first_database_message_id_by_index; // use struct Count? std::array message_count_by_index; int32 server_unread_count = 0; int32 local_unread_count = 0; int32 unread_mention_count = 0; MessageId last_read_inbox_message_id; int32 last_read_inbox_message_date = 0; // secret chats only MessageId last_read_outbox_message_id; MessageId pinned_message_id; MessageId reply_markup_message_id; DialogNotificationSettings notification_settings; unique_ptr draft_message; uint64 save_draft_message_logevent_id = 0; uint64 save_draft_message_logevent_id_generation = 0; uint64 save_notification_settings_logevent_id = 0; uint64 save_notification_settings_logevent_id_generation = 0; uint64 read_history_logevent_id = 0; uint64 read_history_logevent_id_generation = 0; uint64 set_folder_id_logevent_id = 0; uint64 set_folder_id_logevent_id_generation = 0; FolderId folder_id; MessageId last_read_all_mentions_message_id; // all mentions with a message identifier not greater than it are implicitly read MessageId max_unavailable_message_id; // maximum unavailable message identifier for dialogs with cleared/unavailable history int32 last_clear_history_date = 0; MessageId last_clear_history_message_id; int64 order = DEFAULT_ORDER; int64 pinned_order = DEFAULT_ORDER; int32 delete_last_message_date = 0; MessageId deleted_last_message_id; int32 pending_last_message_date = 0; MessageId pending_last_message_id; MessageId max_notification_message_id; MessageId last_edited_message_id; uint32 scheduled_messages_sync_generation = 0; MessageId max_added_message_id; MessageId being_added_message_id; MessageId being_updated_last_new_message_id; MessageId being_updated_last_database_message_id; MessageId being_deleted_message_id; const char *debug_being_deleted_message_id_source = ""; bool debug_being_added_need_update = false; // TODO remove MessageId debug_preloaded_pinned_message_id; // TODO remove MessageId debug_added_pinned_message_id; // TODO remove const char *debug_add_message_to_dialog_fail_reason = ""; NotificationGroupInfo message_notification_group; NotificationGroupInfo mention_notification_group; NotificationId new_secret_chat_notification_id; // secret chats only MessageId pinned_message_notification_message_id; bool has_contact_registered_message = false; bool is_last_message_deleted_locally = false; bool know_can_report_spam = false; bool can_report_spam = false; bool know_action_bar = false; bool can_add_contact = false; bool can_block_user = false; bool can_share_phone_number = false; bool can_report_location = false; bool is_opened = false; bool need_restore_reply_markup = true; bool have_full_history = false; bool is_empty = false; bool is_last_read_inbox_message_id_inited = false; bool is_last_read_outbox_message_id_inited = false; bool is_pinned_message_id_inited = false; bool is_folder_id_inited = false; bool need_repair_server_unread_count = false; bool is_marked_as_unread = false; bool last_sent_has_scheduled_messages = false; bool has_scheduled_server_messages = false; bool has_scheduled_database_messages = false; bool is_has_scheduled_database_messages_checked = false; bool has_loaded_scheduled_messages_from_database = false; bool increment_view_counter = false; bool is_update_new_chat_sent = false; int32 pts = 0; // for channels only std::multimap postponed_channel_updates; // for channels only int32 retry_get_difference_timeout = 1; // for channels only int32 pending_read_channel_inbox_pts = 0; // for channels only MessageId pending_read_channel_inbox_max_message_id; // for channels only int32 pending_read_channel_inbox_server_unread_count = 0; // for channels only std::unordered_map random_id_to_message_id; // for secret chats only MessageId last_assigned_message_id; // identifier of the last local or yet unsent message, assigned after // application start, used to guarantee that all assigned message identifiers // are different std::unordered_map scheduled_message_date; std::unordered_map yet_unsent_message_id_to_persistent_message_id; std::unordered_set deleted_message_ids; std::unordered_set deleted_scheduled_server_message_ids; std::vector> pending_new_message_notifications; std::vector> pending_new_mention_notifications; std::unordered_map notification_id_to_message_id; string client_data; // Load from newest to oldest message MessageId suffix_load_first_message_id_; // identifier of some message such all suffix messages in range // [suffix_load_first_message_id_, last_message_id] are loaded MessageId suffix_load_query_message_id_; std::vector, std::function>> suffix_load_queries_; bool suffix_load_done_ = false; bool suffix_load_has_query_ = false; std::unordered_map pending_viewed_live_locations; // message_id -> task_id std::unordered_set pending_viewed_message_ids; unique_ptr messages; unique_ptr scheduled_messages; struct MessageOp { enum : int8 { Add, SetPts, Delete, DeleteAll } type; bool from_update = false; bool have_previous = false; bool have_next = false; MessageContentType content_type = MessageContentType::None; int32 pts = 0; MessageId message_id; const char *source = nullptr; double date = 0; MessageOp(decltype(type) type, MessageId message_id, MessageContentType content_type, bool from_update, bool have_previous, bool have_next, const char *source) : type(type) , from_update(from_update) , have_previous(have_previous) , have_next(have_next) , content_type(content_type) , message_id(message_id) , source(source) , date(G()->server_time()) { } MessageOp(decltype(type) type, int32 pts, const char *source) : type(type), pts(pts), source(source), date(G()->server_time()) { } }; const char *debug_set_dialog_last_database_message_id = "Unknown"; // to be removed soon vector debug_message_op; // message identifiers loaded from database, to be removed soon MessageId debug_last_new_message_id; MessageId debug_first_database_message_id; MessageId debug_last_database_message_id; Dialog() = default; Dialog(const Dialog &) = delete; Dialog &operator=(const Dialog &) = delete; Dialog(Dialog &&other) = delete; Dialog &operator=(Dialog &&other) = delete; ~Dialog(); template void store(StorerT &storer) const; template void parse(ParserT &parser); }; struct DialogList { FolderId folder_id; bool is_message_unread_count_inited_ = false; bool is_dialog_unread_count_inited_ = false; bool need_unread_count_recalc_ = true; int32 unread_message_total_count_ = 0; int32 unread_message_muted_count_ = 0; int32 unread_dialog_total_count_ = 0; int32 unread_dialog_muted_count_ = 0; int32 unread_dialog_marked_count_ = 0; int32 unread_dialog_muted_marked_count_ = 0; int32 in_memory_dialog_total_count_ = 0; int32 server_dialog_total_count_ = -1; int32 secret_chat_total_count_ = -1; std::set ordered_dialogs_; // all dialogs with date <= last_dialog_date_ std::set ordered_server_dialogs_; // all known dialogs, including with default order // date of last dialog in the dialog list // last_dialog_date_ == min(last_server_dialog_date_, last_secret_chat_dialog_date_) DialogDate last_dialog_date_ = MIN_DIALOG_DATE; // in memory // date of last known user/group/channel dialog in the right order DialogDate last_server_dialog_date_ = MIN_DIALOG_DATE; DialogDate last_loaded_database_dialog_date_ = MIN_DIALOG_DATE; DialogDate last_database_server_dialog_date_ = MIN_DIALOG_DATE; MultiPromiseActor load_dialog_list_multipromise_{ "LoadDialogListMultiPromiseActor"}; // should be defined before pending_on_get_dialogs_ int32 load_dialog_list_limit_max_ = 0; }; class MessagesIteratorBase { vector stack_; protected: MessagesIteratorBase() = default; // points iterator to message with greatest id which is less or equal than message_id MessagesIteratorBase(const Message *root, MessageId message_id) { size_t last_right_pos = 0; while (root != nullptr) { // LOG(DEBUG) << "Have root->message_id = " << root->message_id; stack_.push_back(root); if (root->message_id <= message_id) { // LOG(DEBUG) << "Go right"; last_right_pos = stack_.size(); root = root->right.get(); } else { // LOG(DEBUG) << "Go left"; root = root->left.get(); } } stack_.resize(last_right_pos); } const Message *operator*() const { return stack_.empty() ? nullptr : stack_.back(); } ~MessagesIteratorBase() = default; public: MessagesIteratorBase(const MessagesIteratorBase &) = delete; MessagesIteratorBase &operator=(const MessagesIteratorBase &) = delete; MessagesIteratorBase(MessagesIteratorBase &&other) = default; MessagesIteratorBase &operator=(MessagesIteratorBase &&other) = default; void operator++() { if (stack_.empty()) { return; } const Message *cur = stack_.back(); if (!cur->have_next) { stack_.clear(); return; } if (cur->right == nullptr) { while (true) { stack_.pop_back(); if (stack_.empty()) { return; } const Message *new_cur = stack_.back(); if (new_cur->left.get() == cur) { return; } cur = new_cur; } } cur = cur->right.get(); while (cur != nullptr) { stack_.push_back(cur); cur = cur->left.get(); } } void operator--() { if (stack_.empty()) { return; } const Message *cur = stack_.back(); if (!cur->have_previous) { stack_.clear(); return; } if (cur->left == nullptr) { while (true) { stack_.pop_back(); if (stack_.empty()) { return; } const Message *new_cur = stack_.back(); if (new_cur->right.get() == cur) { return; } cur = new_cur; } } cur = cur->left.get(); while (cur != nullptr) { stack_.push_back(cur); cur = cur->right.get(); } } }; class MessagesIterator : public MessagesIteratorBase { public: MessagesIterator() = default; MessagesIterator(Dialog *d, MessageId message_id) : MessagesIteratorBase(message_id.is_scheduled() ? d->scheduled_messages.get() : d->messages.get(), message_id) { } Message *operator*() const { return const_cast(MessagesIteratorBase::operator*()); } }; class MessagesConstIterator : public MessagesIteratorBase { public: MessagesConstIterator() = default; MessagesConstIterator(const Dialog *d, MessageId message_id) : MessagesIteratorBase(message_id.is_scheduled() ? d->scheduled_messages.get() : d->messages.get(), message_id) { } const Message *operator*() const { return MessagesIteratorBase::operator*(); } }; struct PendingSecretMessage { enum class Type : int32 { NewMessage, DeleteMessages, DeleteHistory }; Type type = Type::NewMessage; // for NewMessage MessageInfo message_info; MultiPromiseActor load_data_multipromise{"LoadPendingSecretMessageDataMultiPromiseActor"}; // for DeleteMessages/DeleteHistory DialogId dialog_id; vector random_ids; MessageId last_message_id; Promise<> success_promise; }; struct SendMessageOptions { bool disable_notification = false; bool from_background = false; int32 schedule_date = 0; SendMessageOptions() = default; SendMessageOptions(bool disable_notification, bool from_background, int32 schedule_date) : disable_notification(disable_notification), from_background(from_background), schedule_date(schedule_date) { } }; class ChangeDialogReportSpamStateOnServerLogEvent; class DeleteAllChannelMessagesFromUserOnServerLogEvent; class DeleteDialogHistoryFromServerLogEvent; class DeleteMessageLogEvent; class DeleteMessagesFromServerLogEvent; class DeleteScheduledMessagesFromServerLogEvent; class ForwardMessagesLogEvent; class GetChannelDifferenceLogEvent; class GetDialogFromServerLogEvent; class ReadAllDialogMentionsOnServerLogEvent; class ReadHistoryOnServerLogEvent; class ReadHistoryInSecretChatLogEvent; class ReadMessageContentsOnServerLogEvent; class ReorderPinnedDialogsOnServerLogEvent; class ResetAllNotificationSettingsOnServerLogEvent; class SaveDialogDraftMessageOnServerLogEvent; class SendBotStartMessageLogEvent; class SendInlineQueryResultMessageLogEvent; class SendMessageLogEvent; class SendScreenshotTakenNotificationMessageLogEvent; class SetDialogFolderIdOnServerLogEvent; class ToggleDialogIsPinnedOnServerLogEvent; class ToggleDialogIsMarkedAsUnreadOnServerLogEvent; class UpdateDialogNotificationSettingsOnServerLogEvent; class UpdateScopeNotificationSettingsOnServerLogEvent; static constexpr size_t MAX_GROUPED_MESSAGES = 10; // server side limit static constexpr int32 MAX_GET_DIALOGS = 100; // server side limit static constexpr int32 MAX_GET_HISTORY = 100; // server side limit static constexpr int32 MAX_SEARCH_MESSAGES = 100; // server side limit static constexpr int32 MIN_SEARCH_PUBLIC_DIALOG_PREFIX_LEN = 5; // server side limit static constexpr int32 MIN_CHANNEL_DIFFERENCE = 10; static constexpr int32 MAX_CHANNEL_DIFFERENCE = 100; static constexpr int32 MAX_BOT_CHANNEL_DIFFERENCE = 100000; // server side limit static constexpr int32 MAX_RECENT_FOUND_DIALOGS = 20; // some reasonable value static constexpr size_t MAX_TITLE_LENGTH = 128; // server side limit for chat title static constexpr size_t MAX_DESCRIPTION_LENGTH = 255; // server side limit for chat description static constexpr int64 SPONSORED_DIALOG_ORDER = static_cast(2147483647) << 32; static constexpr int32 MIN_PINNED_DIALOG_DATE = 2147000000; // some big date static constexpr int32 MAX_PRIVATE_MESSAGE_TTL = 60; // server side limit static constexpr int32 UPDATE_CHANNEL_TO_LONG_FLAG_HAS_PTS = 1 << 0; static constexpr int32 CHANNEL_DIFFERENCE_FLAG_IS_FINAL = 1 << 0; static constexpr int32 CHANNEL_DIFFERENCE_FLAG_HAS_TIMEOUT = 1 << 1; static constexpr int32 DIALOG_FLAG_HAS_PTS = 1 << 0; static constexpr int32 DIALOG_FLAG_HAS_DRAFT = 1 << 1; static constexpr int32 DIALOG_FLAG_IS_PINNED = 1 << 2; static constexpr int32 DIALOG_FLAG_HAS_FOLDER_ID = 1 << 4; static constexpr int32 MAX_MESSAGE_VIEW_DELAY = 1; // seconds static constexpr int32 MIN_SAVE_DRAFT_DELAY = 1; // seconds static constexpr int32 MIN_READ_HISTORY_DELAY = 3; // seconds static constexpr int32 MAX_SAVE_DIALOG_DELAY = 0; // seconds static constexpr int32 LIVE_LOCATION_VIEW_PERIOD = 60; // seconds, server-side limit static constexpr int32 USERNAME_CACHE_EXPIRE_TIME = 3 * 86400; static constexpr int32 USERNAME_CACHE_EXPIRE_TIME_SHORT = 900; static constexpr int32 ONLINE_MEMBER_COUNT_UPDATE_TIME = 5 * 60; static constexpr int32 MAX_RESEND_DELAY = 86400; // seconds, some resonable limit static constexpr int32 MAX_PRELOADED_DIALOGS = 1000; static constexpr int32 SCHEDULE_WHEN_ONLINE_DATE = 2147483646; static constexpr double DIALOG_ACTION_TIMEOUT = 5.5; static constexpr const char *DELETE_MESSAGE_USER_REQUEST_SOURCE = "user request"; static constexpr bool DROP_UPDATES = false; static MessageId get_message_id(const tl_object_ptr &message_ptr, bool is_scheduled); FullMessageId get_full_message_id(const tl_object_ptr &message_ptr, bool is_scheduled) const; static int32 get_message_date(const tl_object_ptr &message_ptr); static tl_object_ptr get_input_message(MessageId message_id); static bool is_dialog_inited(const Dialog *d); int32 get_dialog_mute_until(const Dialog *d) const; bool is_dialog_muted(const Dialog *d) const; bool is_dialog_pinned_message_notifications_disabled(const Dialog *d) const; bool is_dialog_mention_notifications_disabled(const Dialog *d) const; void open_dialog(Dialog *d); void close_dialog(Dialog *d); DialogId get_my_dialog_id() const; void add_secret_message(unique_ptr pending_secret_message, Promise lock_promise = Auto()); void finish_add_secret_message(unique_ptr pending_secret_message); void finish_delete_secret_messages(DialogId dialog_id, std::vector random_ids, Promise<> promise); void finish_delete_secret_chat_history(DialogId dialog_id, MessageId last_message_id, Promise<> promise); void fix_message_info_dialog_id(MessageInfo &message_info) const; MessageInfo parse_telegram_api_message(tl_object_ptr message_ptr, bool is_scheduled, const char *source) const; std::pair> create_message(MessageInfo &&message_info, bool is_channel_message); MessageId find_old_message_id(DialogId dialog_id, MessageId message_id) const; FullMessageId on_get_message(MessageInfo &&message_info, bool from_update, bool is_channel_message, bool have_previous, bool have_next, const char *source); Result process_input_message_content( DialogId dialog_id, tl_object_ptr &&input_message_content); Result process_send_message_options(DialogId dialog_id, tl_object_ptr &&options) const; static Status can_use_send_message_options(const SendMessageOptions &options, const unique_ptr &content, int32 ttl); static Status can_use_send_message_options(const SendMessageOptions &options, const InputMessageContent &content); Message *get_message_to_send(Dialog *d, MessageId reply_to_message_id, const SendMessageOptions &options, unique_ptr &&content, bool *need_update_dialog_pos, unique_ptr forward_info = nullptr, bool is_copy = false); int64 begin_send_message(DialogId dialog_id, const Message *m); Status can_send_message(DialogId dialog_id) const TD_WARN_UNUSED_RESULT; Status can_send_message_content(DialogId dialog_id, const MessageContent *content, bool is_forward) const TD_WARN_UNUSED_RESULT; bool can_resend_message(const Message *m) const; bool can_edit_message(DialogId dialog_id, const Message *m, bool is_editing, bool only_reply_markup = false) const; bool can_report_dialog(DialogId dialog_id) const; void cancel_edit_message_media(DialogId dialog_id, Message *m, Slice error_message); void on_message_media_edited(DialogId dialog_id, MessageId message_id, FileId file_id, FileId thumbnail_file_id, bool was_uploaded, bool was_thumbnail_uploaded, string file_reference, int32 scheduled_date, uint64 generation, Result &&result); MessageId get_persistent_message_id(const Dialog *d, MessageId message_id) const; static MessageId get_replied_message_id(const Message *m); MessageId get_reply_to_message_id(Dialog *d, MessageId message_id); bool can_set_game_score(DialogId dialog_id, const Message *m) const; bool check_update_dialog_id(const tl_object_ptr &update, DialogId dialog_id); void process_update(tl_object_ptr &&update); void process_channel_update(tl_object_ptr &&update); void on_message_edited(FullMessageId full_message_id); void delete_messages_from_updates(const vector &message_ids); void delete_dialog_messages_from_updates(DialogId dialog_id, const vector &message_ids); void do_forward_messages(DialogId to_dialog_id, DialogId from_dialog_id, const vector &messages, const vector &message_ids, uint64 logevent_id); Result forward_message(DialogId to_dialog_id, DialogId from_dialog_id, MessageId message_id, tl_object_ptr &&options, bool in_game_share, bool send_copy, bool remove_caption) TD_WARN_UNUSED_RESULT; void do_send_media(DialogId dialog_id, Message *m, FileId file_id, FileId thumbnail_file_id, tl_object_ptr input_file, tl_object_ptr input_thumbnail); void do_send_secret_media(DialogId dialog_id, Message *m, FileId file_id, FileId thumbnail_file_id, tl_object_ptr input_encrypted_file, BufferSlice thumbnail); void do_send_message(DialogId dialog_id, const Message *m, vector bad_parts = {}); void on_message_media_uploaded(DialogId dialog_id, const Message *m, tl_object_ptr &&input_media, FileId file_id, FileId thumbnail_file_id); void on_secret_message_media_uploaded(DialogId dialog_id, const Message *m, SecretInputMedia &&secret_input_media, FileId file_id, FileId thumbnail_file_id); void on_upload_message_media_finished(int64 media_album_id, DialogId dialog_id, MessageId message_id, Status result); void do_send_message_group(int64 media_album_id); void on_media_message_ready_to_send(DialogId dialog_id, MessageId message_id, Promise &&promise); void on_yet_unsent_media_queue_updated(DialogId dialog_id); void save_send_bot_start_message_logevent(UserId bot_user_id, DialogId dialog_id, const string ¶meter, const Message *m); void do_send_bot_start_message(UserId bot_user_id, DialogId dialog_id, const string ¶meter, const Message *m); void save_send_inline_query_result_message_logevent(DialogId dialog_id, const Message *m, int64 query_id, const string &result_id); void do_send_inline_query_result_message(DialogId dialog_id, const Message *m, int64 query_id, const string &result_id); uint64 save_send_screenshot_taken_notification_message_logevent(DialogId dialog_id, const Message *m); void do_send_screenshot_taken_notification_message(DialogId dialog_id, const Message *m, uint64 logevent_id); Message *continue_send_message(DialogId dialog_id, unique_ptr &&m, uint64 logevent_id); bool is_message_unload_enabled() const; int64 generate_new_media_album_id(); static bool can_forward_message(DialogId from_dialog_id, const Message *m); static bool can_delete_channel_message(DialogParticipantStatus status, const Message *m, bool is_bot); bool can_revoke_message(DialogId dialog_id, const Message *m) const; bool can_unload_message(const Dialog *d, const Message *m) const; void unload_message(Dialog *d, MessageId message_id); unique_ptr delete_message(Dialog *d, MessageId message_id, bool is_permanently_deleted, bool *need_update_dialog_pos, const char *source); unique_ptr do_delete_message(Dialog *d, MessageId message_id, bool is_permanently_deleted, bool only_from_memory, bool *need_update_dialog_pos, const char *source); unique_ptr do_delete_scheduled_message(Dialog *d, MessageId message_id, bool is_permanently_deleted, const char *source); void on_message_deleted(Dialog *d, Message *m, bool is_permanently_deleted, const char *source); int32 get_unload_dialog_delay() const; void unload_dialog(DialogId dialog_id); void delete_all_dialog_messages(Dialog *d, bool remove_from_dialog_list, bool is_permanently_deleted); void do_delete_all_dialog_messages(Dialog *d, unique_ptr &message, bool is_permanently_deleted, vector &deleted_message_ids); void delete_message_from_server(DialogId dialog_id, MessageId message_ids, bool revoke); void delete_messages_from_server(DialogId dialog_id, vector message_ids, bool revoke, uint64 logevent_id, Promise &&promise); void delete_scheduled_messages_from_server(DialogId dialog_id, vector message_ids, uint64 logevent_id, Promise &&promise); void delete_dialog_history_from_server(DialogId dialog_id, MessageId max_message_id, bool remove_from_dialog_list, bool revoke, bool allow_error, uint64 logevent_id, Promise &&promise); void delete_all_channel_messages_from_user_on_server(ChannelId channel_id, UserId user_id, uint64 logevent_id, Promise &&promise); void read_all_dialog_mentions_on_server(DialogId dialog_id, uint64 logevent_id, Promise &&promise); static MessageId find_message_by_date(const Message *m, int32 date); static void find_messages_from_user(const Message *m, UserId user_id, vector &message_ids); static void find_unread_mentions(const Message *m, vector &message_ids); static void find_old_messages(const Message *m, MessageId max_message_id, vector &message_ids); void find_unloadable_messages(const Dialog *d, int32 unload_before_date, const Message *m, vector &message_ids, int32 &left_to_unload) const; void on_pending_message_views_timeout(DialogId dialog_id); bool update_message_views(DialogId dialog_id, Message *m, int32 views); bool update_message_contains_unread_mention(Dialog *d, Message *m, bool contains_unread_mention, const char *source); void read_message_content_from_updates(MessageId message_id); void read_channel_message_content_from_updates(Dialog *d, MessageId message_id); bool read_message_content(Dialog *d, Message *m, bool is_local_read, const char *source); void read_message_contents_on_server(DialogId dialog_id, vector message_ids, uint64 logevent_id, Promise &&promise, bool skip_logevent = false); bool has_incoming_notification(DialogId dialog_id, const Message *m) const; int32 calc_new_unread_count_from_last_unread(Dialog *d, MessageId max_message_id, MessageType type) const; int32 calc_new_unread_count_from_the_end(Dialog *d, MessageId max_message_id, MessageType type, int32 hint_unread_count) const; int32 calc_new_unread_count(Dialog *d, MessageId max_message_id, MessageType type, int32 hint_unread_count) const; void repair_server_unread_count(DialogId dialog_id, int32 unread_count); void repair_channel_server_unread_count(Dialog *d); void read_history_outbox(DialogId dialog_id, MessageId max_message_id, int32 read_date = -1); void read_history_on_server(Dialog *d, MessageId max_message_id); void read_history_on_server_impl(DialogId dialog_id, MessageId max_message_id); void on_read_history_finished(DialogId dialog_id, uint64 generation); void read_secret_chat_outbox_inner(DialogId dialog_id, int32 up_to_date, int32 read_date); void set_dialog_max_unavailable_message_id(DialogId dialog_id, MessageId max_unavailable_message_id, bool from_update, const char *source); void set_dialog_online_member_count(DialogId dialog_id, int32 online_member_count, bool is_from_server, const char *source); void on_update_dialog_online_member_count_timeout(DialogId dialog_id); void preload_newer_messages(const Dialog *d, MessageId max_message_id); void preload_older_messages(const Dialog *d, MessageId min_message_id); void on_get_history_from_database(DialogId dialog_id, MessageId from_message_id, int32 offset, int32 limit, bool from_the_end, bool only_local, vector &&messages, Promise &&promise); void get_history_from_the_end(DialogId dialog_id, bool from_database, bool only_local, Promise &&promise); void get_history(DialogId dialog_id, MessageId from_message_id, int32 offset, int32 limit, bool from_database, bool only_local, Promise &&promise); void load_messages(DialogId dialog_id, MessageId from_message_id, int32 offset, int32 limit, int left_tries, bool only_local, Promise &&promise); void load_dialog_scheduled_messages(DialogId dialog_id, bool from_database, int32 hash, Promise &&promise); void on_get_scheduled_messages_from_database(DialogId dialog_id, vector &&messages); static int32 get_random_y(MessageId message_id); static void set_message_id(unique_ptr &message, MessageId message_id); bool is_allowed_useless_update(const tl_object_ptr &update) const; bool is_message_auto_read(DialogId dialog_id, bool is_outgoing) const; void fail_send_message(FullMessageId full_message_id, int error_code, const string &error_message); void fail_send_message(FullMessageId full_message_id, Status error); void fail_edit_message_media(FullMessageId full_message_id, Status &&error); void on_dialog_updated(DialogId dialog_id, const char *source); BufferSlice get_dialog_database_value(const Dialog *d); void save_dialog_to_database(DialogId dialog_id); void on_save_dialog_to_database(DialogId dialog_id, bool can_reuse_notification_group, bool success); void try_reuse_notification_group(NotificationGroupInfo &group_info); void load_dialog_list(FolderId folder_id, int32 limit, bool only_local, Promise &&promise); void load_dialog_list_from_database(FolderId folder_id, int32 limit, Promise &&promise); void preload_dialog_list(FolderId folderId); void update_message_count_by_index(Dialog *d, int diff, const Message *m); void update_message_count_by_index(Dialog *d, int diff, int32 index_mask); int32 get_message_index_mask(DialogId dialog_id, const Message *m) const; Message *add_message_to_dialog(DialogId dialog_id, unique_ptr message, bool from_update, bool *need_update, bool *need_update_dialog_pos, const char *source); Message *add_message_to_dialog(Dialog *d, unique_ptr message, bool from_update, bool *need_update, bool *need_update_dialog_pos, const char *source); Message *add_scheduled_message_to_dialog(Dialog *d, unique_ptr message, bool from_update, bool *need_update, const char *source); void on_message_changed(const Dialog *d, const Message *m, bool need_send_update, const char *source); bool need_delete_file(FullMessageId full_message_id, FileId file_id) const; bool need_delete_message_files(DialogId dialog_id, const Message *m) const; void add_message_to_database(const Dialog *d, const Message *m, const char *source); void delete_all_dialog_messages_from_database(Dialog *d, MessageId max_message_id, const char *source); void delete_message_from_database(Dialog *d, MessageId message_id, const Message *m, bool is_permanently_deleted); void delete_message_files(DialogId dialog_id, const Message *m) const; static void add_random_id_to_message_id_correspondence(Dialog *d, int64 random_id, MessageId message_id); static void delete_random_id_to_message_id_correspondence(Dialog *d, int64 random_id, MessageId message_id); static void add_notification_id_to_message_id_correspondence(Dialog *d, NotificationId notification_id, MessageId message_id); static void delete_notification_id_to_message_id_correspondence(Dialog *d, NotificationId notification_id, MessageId message_id); void remove_message_notification_id(Dialog *d, Message *m, bool is_permanent, bool force_update, bool ignore_pinned_message_notification_removal = false); void remove_new_secret_chat_notification(Dialog *d, bool is_permanent); void fix_dialog_last_notification_id(Dialog *d, bool from_mentions, MessageId message_id); void do_fix_dialog_last_notification_id(DialogId dialog_id, bool from_mentions, NotificationId prev_last_notification_id, Result> result); void do_delete_message_logevent(const DeleteMessageLogEvent &logevent) const; void attach_message_to_previous(Dialog *d, MessageId message_id, const char *source); void attach_message_to_next(Dialog *d, MessageId message_id, const char *source); bool update_message(Dialog *d, Message *old_message, unique_ptr new_message, bool *need_update_dialog_pos); static bool need_message_changed_warning(const Message *old_message); bool update_message_content(DialogId dialog_id, Message *old_message, unique_ptr new_content, bool need_send_update_message_content, bool need_merge_files, bool is_message_in_dialog); void send_update_new_message(const Dialog *d, const Message *m); static bool is_from_mention_notification_group(const Dialog *d, const Message *m); static bool is_message_notification_active(const Dialog *d, const Message *m); static NotificationGroupInfo &get_notification_group_info(Dialog *d, const Message *m); NotificationGroupId get_dialog_notification_group_id(DialogId dialog_id, NotificationGroupInfo &group_info); NotificationId get_next_notification_id(Dialog *d, NotificationGroupId notification_group_id, MessageId message_id); void try_add_pinned_message_notification(Dialog *d, vector &res, NotificationId max_notification_id, int32 limit); vector get_message_notifications_from_database_force(Dialog *d, bool from_mentions, int32 limit); Result> do_get_message_notifications_from_database_force(Dialog *d, bool from_mentions, NotificationId from_notification_id, MessageId from_message_id, int32 limit); void do_get_message_notifications_from_database(Dialog *d, bool from_mentions, NotificationId initial_from_notification_id, NotificationId from_notification_id, MessageId from_message_id, int32 limit, Promise> promise); void on_get_message_notifications_from_database(DialogId dialog_id, bool from_mentions, NotificationId initial_from_notification_id, int32 limit, Result> result, Promise> promise); void do_remove_message_notification(DialogId dialog_id, bool from_mentions, NotificationId notification_id, vector result); int32 get_dialog_pending_notification_count(const Dialog *d, bool from_mentions) const; void update_dialog_mention_notification_count(const Dialog *d); bool is_message_notification_disabled(const Dialog *d, const Message *m) const; bool is_dialog_message_notification_disabled(DialogId dialog_id, int32 message_date) const; bool may_need_message_notification(const Dialog *d, const Message *m) const; bool add_new_message_notification(Dialog *d, Message *m, bool force); void flush_pending_new_message_notifications(DialogId dialog_id, bool from_mentions, DialogId settings_dialog_id); void remove_all_dialog_notifications(Dialog *d, bool from_mentions, const char *source); void remove_message_dialog_notifications(Dialog *d, MessageId max_message_id, bool from_mentions, const char *source); void send_update_message_send_succeeded(Dialog *d, MessageId old_message_id, const Message *m) const; void send_update_message_content(DialogId dialog_id, MessageId message_id, const MessageContent *content, int32 message_date, bool is_content_secret, const char *source) const; void send_update_message_edited(DialogId dialog_id, const Message *m); void send_update_message_live_location_viewed(FullMessageId full_message_id); void send_update_delete_messages(DialogId dialog_id, vector &&message_ids, bool is_permanent, bool from_cache) const; void send_update_new_chat(Dialog *d); void send_update_chat_draft_message(const Dialog *d); void send_update_chat_last_message(Dialog *d, const char *source); void send_update_chat_last_message_impl(const Dialog *d, const char *source) const; void send_update_unread_message_count(FolderId folder_id, DialogId dialog_id, bool force, const char *source); void send_update_unread_chat_count(FolderId folder_id, DialogId dialog_id, bool force, const char *source); void send_update_chat_read_inbox(const Dialog *d, bool force, const char *source); void send_update_chat_read_outbox(const Dialog *d); void send_update_chat_unread_mention_count(const Dialog *d); void send_update_chat_is_sponsored(const Dialog *d) const; void send_update_chat_online_member_count(DialogId dialog_id, int32 online_member_count) const; void send_update_chat_chat_list(const Dialog *d) const; void send_update_secret_chats_with_user_action_bar(const Dialog *d) const; void send_update_chat_action_bar(const Dialog *d); void send_update_chat_has_scheduled_messages(Dialog *d); void hide_dialog_action_bar(Dialog *d); static Result get_message_schedule_date(td_api::object_ptr &&scheduling_state); tl_object_ptr get_message_sending_state_object(const Message *m) const; static tl_object_ptr get_message_scheduling_state_object(int32 send_date); tl_object_ptr get_message_object(DialogId dialog_id, const Message *m, bool for_event_log = false) const; static tl_object_ptr get_messages_object(int32 total_count, vector> &&messages); vector sort_dialogs_by_order(const vector &dialog_ids, int32 limit) const; vector get_peers_dialog_ids(vector> &&peers); static bool need_unread_counter(int64 dialog_order); static int32 get_dialog_total_count(const DialogList &list); void repair_server_dialog_total_count(FolderId folder_id); void repair_secret_chat_total_count(FolderId folder_id); void on_get_secret_chat_total_count(FolderId folder_id, int32 total_count); void recalc_unread_count(FolderId folder_id); td_api::object_ptr get_update_unread_message_count_object( FolderId folder_id, const DialogList &list) const; td_api::object_ptr get_update_unread_chat_count_object(FolderId folder_id, const DialogList &list) const; void set_dialog_last_read_inbox_message_id(Dialog *d, MessageId message_id, int32 server_unread_count, int32 local_unread_count, bool force_update, const char *source); void set_dialog_last_read_outbox_message_id(Dialog *d, MessageId message_id); void set_dialog_last_message_id(Dialog *d, MessageId last_message_id, const char *source); void set_dialog_first_database_message_id(Dialog *d, MessageId first_database_message_id, const char *source); void set_dialog_last_database_message_id(Dialog *d, MessageId last_database_message_id, const char *source, bool is_loaded_from_database = false); void set_dialog_last_new_message_id(Dialog *d, MessageId last_new_message_id, const char *source); void set_dialog_last_clear_history_date(Dialog *d, int32 date, MessageId last_clear_history_message_id, const char *source, bool is_loaded_from_database = false); void set_dialog_is_empty(Dialog *d, const char *source); static int32 get_pinned_dialogs_limit(FolderId folder_id); static vector