Commit 6941a45

db_.get_statement("DELETE FROM messages WHERE dialog_id = ?1 AND message_id = ?2"));

TRY_RESULT_ASSIGN(delete_all_dialog_messages_stmt_,

db_.get_statement("DELETE FROM messages WHERE dialog_id = ?1 AND message_id <= ?2"));

db_.get_statement("DELETE FROM messages WHERE dialog_id = ?1 AND sender_user_id == ?2"));

TRY_RESULT_ASSIGN(

return Status::OK();

}

int64 random_id, int32 ttl_expires_at, int32 index_mask, int64 search_id, string text,

NotificationId notification_id, MessageId top_thread_message_id, BufferSlice data) final {

LOG(INFO) << "Add " << full_message_id << " to database";

add_message_stmt_.bind_null(3).ensure();

}

} else {

add_message_stmt_.bind_null(4).ensure();

}

return status;

}

CHECK(dialog_id.is_valid());

SCOPE_EXIT {

};

return Status::OK();

}

SqliteStatement delete_message_stmt_;

SqliteStatement delete_all_dialog_messages_stmt_;

SqliteStatement get_message_stmt_;

SqliteStatement get_message_by_random_id_stmt_;

impl_ = create_actor_on_scheduler<Impl>("MessagesDbActor", scheduler_id, std::move(sync_db));

}

int64 random_id, int32 ttl_expires_at, int32 index_mask, int64 search_id, string text,

NotificationId notification_id, MessageId top_thread_message_id, BufferSlice data,

Promise<> promise) final {

ttl_expires_at, index_mask, search_id, std::move(text), notification_id, top_thread_message_id,

std::move(data), std::move(promise));

}

void delete_all_dialog_messages(DialogId dialog_id, MessageId from_message_id, Promise<> promise) final {

send_closure_later(impl_, &Impl::delete_all_dialog_messages, dialog_id, from_message_id, std::move(promise));

}

}

void get_message(FullMessageId full_message_id, Promise<MessagesDbDialogMessage> promise) final {

public:

explicit Impl(std::shared_ptr<MessagesDbSyncSafeInterface> sync_db_safe) : sync_db_safe_(std::move(sync_db_safe)) {

}

int64 random_id, int32 ttl_expires_at, int32 index_mask, int64 search_id, string text,

NotificationId notification_id, MessageId top_thread_message_id, BufferSlice data,

Promise<> promise) {

data = std::move(data), promise = std::move(promise)](Unit) mutable {

on_write_result(std::move(promise),

ttl_expires_at, index_mask, search_id, std::move(text), notification_id,

top_thread_message_id, std::move(data)));

});

add_read_query();

promise.set_result(sync_db_->delete_all_dialog_messages(dialog_id, from_message_id));

}

add_read_query();

}

void get_message(FullMessageId full_message_id, Promise<MessagesDbDialogMessage> promise) {

MessagesDbSyncInterface &operator=(const MessagesDbSyncInterface &) = delete;

virtual ~MessagesDbSyncInterface() = default;

virtual Status add_scheduled_message(FullMessageId full_message_id, BufferSlice data) = 0;

virtual Status delete_message(FullMessageId full_message_id) = 0;

virtual Status delete_all_dialog_messages(DialogId dialog_id, MessageId from_message_id) = 0;

virtual Result<MessagesDbDialogMessage> get_message(FullMessageId full_message_id) = 0;

virtual Result<MessagesDbMessage> get_message_by_unique_message_id(ServerMessageId unique_message_id) = 0;

MessagesDbAsyncInterface &operator=(const MessagesDbAsyncInterface &) = delete;

virtual ~MessagesDbAsyncInterface() = default;

int64 random_id, int32 ttl_expires_at, int32 index_mask, int64 search_id, string text,

NotificationId notification_id, MessageId top_thread_message_id, BufferSlice data,

Promise<> promise) = 0;

virtual void add_scheduled_message(FullMessageId full_message_id, BufferSlice data, Promise<> promise) = 0;

virtual void delete_message(FullMessageId full_message_id, Promise<> promise) = 0;

virtual void delete_all_dialog_messages(DialogId dialog_id, MessageId from_message_id, Promise<> promise) = 0;

virtual void get_message(FullMessageId full_message_id, Promise<MessagesDbDialogMessage> promise) = 0;

virtual void get_message_by_unique_message_id(ServerMessageId unique_message_id,

return promise.set_value(Unit());

}

LOG(INFO) << "Delete all messages from " << sender_dialog_id << " in " << dialog_id << " from database";

Auto()); // TODO Promise

}

delete_all_channel_messages_by_sender_on_server(channel_id, sender_dialog_id, 0, std::move(promise));

}

public:

ChannelId channel_id_;

DialogId sender_dialog_id_;

uint64 MessagesManager::save_delete_all_channel_messages_by_sender_on_server_log_event(ChannelId channel_id,

DialogId sender_dialog_id) {

get_log_event_storer(log_event));

}

if (m->ttl_period != 0 && (ttl_expires_at == 0 || m->date + m->ttl_period < ttl_expires_at)) {

ttl_expires_at = m->date + m->ttl_period;

}

random_id, ttl_expires_at, get_message_index_mask(d->dialog_id, m),

search_id, text, m->notification_id, m->top_thread_message_id,

log_event_store(*m),

Auto());

break;

}

if (!G()->parameters().use_chat_info_db) {

binlog_erase(G()->td_db()->get_binlog(), event.id_);

break;

}

log_event_parse(log_event, event.data_).ensure();

auto channel_id = log_event.channel_id_;

class BlockMessageSenderFromRepliesOnServerLogEvent;

class DeleteAllCallMessagesOnServerLogEvent;

class DeleteDialogHistoryOnServerLogEvent;

class DeleteDialogMessagesByDateOnServerLogEvent;

class DeleteMessageLogEvent;

case LogEvent::HandlerType::SendInlineQueryResultMessage:

case LogEvent::HandlerType::DeleteDialogHistoryOnServer:

case LogEvent::HandlerType::ReadAllDialogMentionsOnServer:

case LogEvent::HandlerType::ToggleDialogIsPinnedOnServer:

case LogEvent::HandlerType::ReorderPinnedDialogsOnServer:

case LogEvent::HandlerType::SaveDialogDraftMessageOnServer:

SendInlineQueryResultMessage = 0x108,

DeleteDialogHistoryOnServer = 0x109,

ReadAllDialogMentionsOnServer = 0x10a,

ToggleDialogIsPinnedOnServer = 0x10c,

ReorderPinnedDialogsOnServer = 0x10d,

SaveDialogDraftMessageOnServer = 0x10e,