Return vote date in getPollVoters.

Author: levlam

td/generate/scheme/td_api.tl

@@ -2525,7 +2525,7 @@ messageSenderUser user_id:int53 = MessageSender;
 messageSenderChat chat_id:int53 = MessageSender;
 
 
-//@description Represents a list of message senders @total_count Approximate total number of messages senders found @senders List of message senders
+//@description Represents a list of message senders @total_count Approximate total number of message senders found @senders List of message senders
 messageSenders total_count:int32 senders:vector<MessageSender> = MessageSenders;
 
 
@@ -2536,6 +2536,15 @@ chatMessageSender sender:MessageSender needs_premium:Bool = ChatMessageSender;
 chatMessageSenders senders:vector<chatMessageSender> = ChatMessageSenders;
 
 
+//@description Represents a poll voter
+//@voter_id The voter identifier
+//@date Point in time (Unix timestamp) when the vote was added
+pollVoter voter_id:MessageSender date:int32 = PollVoter;
+
+//@description Represents a list of poll voters @total_count Approximate total number of poll voters found @voters List of poll voters
+pollVoters total_count:int32 voters:vector<pollVoter> = PollVoters;
+
+
 //@class MessageReadDate @description Describes read date of a recent outgoing message in a private chat
 
 //@description Contains read date of the message @read_date Point in time (Unix timestamp) when the message was read by the other user
@@ -11797,7 +11806,7 @@ setPollAnswer chat_id:int53 message_id:int53 option_ids:vector<int32> = Ok;
 //@option_id 0-based identifier of the answer option
 //@offset Number of voters to skip in the result; must be non-negative
 //@limit The maximum number of voters to be returned; must be positive and can't be greater than 50. For optimal performance, the number of returned voters is chosen by TDLib and can be smaller than the specified limit, even if the end of the voter list has not been reached
-getPollVoters chat_id:int53 message_id:int53 option_id:int32 offset:int32 limit:int32 = MessageSenders;
+getPollVoters chat_id:int53 message_id:int53 option_id:int32 offset:int32 limit:int32 = PollVoters;
 
 //@description Stops a poll
 //@chat_id Identifier of the chat to which the poll belongs

td/telegram/MessageContent.cpp

@@ -6681,7 +6681,7 @@ void set_message_content_poll_answer(Td *td, const MessageContent *content, Mess
 
 void get_message_content_poll_voters(Td *td, const MessageContent *content, MessageFullId message_full_id,
                                      int32 option_id, int32 offset, int32 limit,
-                                     Promise<td_api::object_ptr<td_api::messageSenders>> &&promise) {
+                                     Promise<td_api::object_ptr<td_api::pollVoters>> &&promise) {
   CHECK(content->get_type() == MessageContentType::Poll);
   td->poll_manager_->get_poll_voters(static_cast<const MessagePoll *>(content)->poll_id, message_full_id, option_id,
                                      offset, limit, std::move(promise));

td/telegram/MessageContent.h

@@ -208,7 +208,7 @@ void set_message_content_poll_answer(Td *td, const MessageContent *content, Mess
 
 void get_message_content_poll_voters(Td *td, const MessageContent *content, MessageFullId message_full_id,
                                      int32 option_id, int32 offset, int32 limit,
-                                     Promise<td_api::object_ptr<td_api::messageSenders>> &&promise);
+                                     Promise<td_api::object_ptr<td_api::pollVoters>> &&promise);
 
 void stop_message_content_poll(Td *td, const MessageContent *content, MessageFullId message_full_id,
                                unique_ptr<ReplyMarkup> &&reply_markup, Promise<Unit> &&promise);

td/telegram/MessagesManager.cpp

@@ -35593,7 +35593,7 @@ void MessagesManager::set_poll_answer(MessageFullId message_full_id, vector<int3
 }
 
 void MessagesManager::get_poll_voters(MessageFullId message_full_id, int32 option_id, int32 offset, int32 limit,
-                                      Promise<td_api::object_ptr<td_api::messageSenders>> &&promise) {
+                                      Promise<td_api::object_ptr<td_api::pollVoters>> &&promise) {
   auto m = get_message_force(message_full_id, "get_poll_voters");
   if (m == nullptr) {
     return promise.set_error(400, "Message not found");

td/telegram/MessagesManager.h

@@ -955,7 +955,7 @@ class MessagesManager final : public Actor {
   void set_poll_answer(MessageFullId message_full_id, vector<int32> &&option_ids, Promise<Unit> &&promise);
 
   void get_poll_voters(MessageFullId message_full_id, int32 option_id, int32 offset, int32 limit,
-                       Promise<td_api::object_ptr<td_api::messageSenders>> &&promise);
+                       Promise<td_api::object_ptr<td_api::pollVoters>> &&promise);
 
   void stop_poll(MessageFullId message_full_id, td_api::object_ptr<td_api::ReplyMarkup> &&reply_markup,
                  Promise<Unit> &&promise);

td/telegram/PollManager.cpp

@@ -1090,21 +1090,21 @@ PollManager::PollOptionVoters &PollManager::get_poll_option_voters(const Poll *p
   return poll_voters[index];
 }
 
-td_api::object_ptr<td_api::messageSenders> PollManager::get_poll_voters_object(
-    int32 total_count, const vector<DialogId> &voter_dialog_ids) const {
-  auto result = td_api::make_object<td_api::messageSenders>();
+td_api::object_ptr<td_api::pollVoters> PollManager::get_poll_voters_object(
+    int32 total_count, const vector<std::pair<DialogId, int32>> &voters) const {
+  auto result = td_api::make_object<td_api::pollVoters>();
   result->total_count_ = total_count;
-  for (auto dialog_id : voter_dialog_ids) {
-    auto message_sender = get_min_message_sender_object(td_, dialog_id, "get_poll_voters_object");
+  for (auto &voter : voters) {
+    auto message_sender = get_min_message_sender_object(td_, voter.first, "get_poll_voters_object");
     if (message_sender != nullptr) {
-      result->senders_.push_back(std::move(message_sender));
+      result->voters_.push_back(td_api::make_object<td_api::pollVoter>(std::move(message_sender), voter.second));
     }
   }
   return result;
 }
 
 void PollManager::get_poll_voters(PollId poll_id, MessageFullId message_full_id, int32 option_id, int32 offset,
-                                  int32 limit, Promise<td_api::object_ptr<td_api::messageSenders>> &&promise) {
+                                  int32 limit, Promise<td_api::object_ptr<td_api::pollVoters>> &&promise) {
   if (is_local_poll_id(poll_id)) {
     return promise.set_error(400, "Poll results can't be received");
   }
@@ -1129,27 +1129,27 @@ void PollManager::get_poll_voters(PollId poll_id, MessageFullId message_full_id,
 
   auto &voters = get_poll_option_voters(poll, poll_id, option_id);
   if (voters.pending_queries_.empty() && voters.was_invalidated_ && offset == 0) {
-    voters.voter_dialog_ids_.clear();
+    voters.voters_.clear();
     voters.next_offset_.clear();
     voters.was_invalidated_ = false;
   }
 
-  auto cur_offset = narrow_cast<int32>(voters.voter_dialog_ids_.size());
+  auto cur_offset = narrow_cast<int32>(voters.voters_.size());
 
   if (offset > cur_offset) {
     return promise.set_error(400, "Too big offset specified; voters can be received only consequently");
   }
   if (offset < cur_offset) {
-    vector<DialogId> result;
+    vector<std::pair<DialogId, int32>> result;
     for (int32 i = offset; i != cur_offset && i - offset < limit; i++) {
-      result.push_back(voters.voter_dialog_ids_[i]);
+      result.push_back(voters.voters_[i]);
     }
     return promise.set_value(
         get_poll_voters_object(max(poll->options_[option_id].voter_count_, cur_offset), std::move(result)));
   }
 
   if (poll->options_[option_id].voter_count_ == 0 || (voters.next_offset_.empty() && cur_offset > 0)) {
-    return promise.set_value(get_poll_voters_object(0, vector<DialogId>()));
+    return promise.set_value(get_poll_voters_object(0, Auto()));
   }
 
   voters.pending_queries_.push_back(std::move(promise));
@@ -1212,9 +1212,10 @@ void PollManager::on_get_poll_voters(PollId poll_id, int32 option_id, string off
     update_poll_timeout_.set_timeout_in(poll_id.get(), 0.0);
   }
 
-  vector<DialogId> dialog_ids;
+  vector<std::pair<DialogId, int32>> voter_ids;
   for (auto &peer_vote : vote_list->votes_) {
     DialogId dialog_id;
+    int32 date = 0;
     switch (peer_vote->get_id()) {
       case telegram_api::messagePeerVote::ID: {
         auto voter = telegram_api::move_object_as<telegram_api::messagePeerVote>(peer_vote);
@@ -1223,11 +1224,13 @@ void PollManager::on_get_poll_voters(PollId poll_id, int32 option_id, string off
         }
 
         dialog_id = DialogId(voter->peer_);
+        date = voter->date_;
         break;
       }
       case telegram_api::messagePeerVoteInputOption::ID: {
         auto voter = telegram_api::move_object_as<telegram_api::messagePeerVoteInputOption>(peer_vote);
         dialog_id = DialogId(voter->peer_);
+        date = voter->date_;
         break;
       }
       case telegram_api::messagePeerVoteMultiple::ID: {
@@ -1237,29 +1240,31 @@ void PollManager::on_get_poll_voters(PollId poll_id, int32 option_id, string off
         }
 
         dialog_id = DialogId(voter->peer_);
+        date = voter->date_;
         break;
       }
       default:
         UNREACHABLE();
     }
     if (dialog_id.is_valid()) {
-      dialog_ids.push_back(dialog_id);
+      voter_ids.emplace_back(dialog_id, date);
     } else {
       LOG(ERROR) << "Receive " << dialog_id << " as voter in " << poll_id;
     }
   }
-  append(voters.voter_dialog_ids_, dialog_ids);
-  if (static_cast<int32>(dialog_ids.size()) > limit) {
-    dialog_ids.resize(limit);
+  append(voters.voters_, voter_ids);
+  if (static_cast<int32>(voter_ids.size()) > limit) {
+    voter_ids.resize(limit);
   }
-  auto known_voter_count = narrow_cast<int32>(voters.voter_dialog_ids_.size());
+  auto known_voter_count = narrow_cast<int32>(voters.voters_.size());
   if (voters.next_offset_.empty() && known_voter_count != vote_list->count_) {
     // invalidate_poll_option_voters(poll, poll_id, option_id);
     voters.was_invalidated_ = true;
   }
 
   for (auto &promise : promises) {
-    promise.set_value(get_poll_voters_object(max(vote_list->count_, known_voter_count), vector<DialogId>(dialog_ids)));
+    promise.set_value(get_poll_voters_object(max(vote_list->count_, known_voter_count),
+                                             vector<std::pair<DialogId, int32>>(voter_ids)));
   }
 }
 

td/telegram/PollManager.h

@@ -71,7 +71,7 @@ class PollManager final : public Actor {
                        Promise<Unit> &&promise);
 
   void get_poll_voters(PollId poll_id, MessageFullId message_full_id, int32 option_id, int32 offset, int32 limit,
-                       Promise<td_api::object_ptr<td_api::messageSenders>> &&promise);
+                       Promise<td_api::object_ptr<td_api::pollVoters>> &&promise);
 
   void stop_poll(PollId poll_id, MessageFullId message_full_id, unique_ptr<ReplyMarkup> &&reply_markup,
                  Promise<Unit> &&promise);
@@ -138,9 +138,9 @@ class PollManager final : public Actor {
   };
 
   struct PollOptionVoters {
-    vector<DialogId> voter_dialog_ids_;
+    vector<std::pair<DialogId, int32>> voters_;
     string next_offset_;
-    vector<Promise<td_api::object_ptr<td_api::messageSenders>>> pending_queries_;
+    vector<Promise<td_api::object_ptr<td_api::pollVoters>>> pending_queries_;
     bool was_invalidated_ = false;  // the list needs to be invalidated when voters are changed
   };
 
@@ -218,8 +218,8 @@ class PollManager final : public Actor {
 
   PollOptionVoters &get_poll_option_voters(const Poll *poll, PollId poll_id, int32 option_id);
 
-  td_api::object_ptr<td_api::messageSenders> get_poll_voters_object(int32 total_count,
-                                                                    const vector<DialogId> &voter_dialog_ids) const;
+  td_api::object_ptr<td_api::pollVoters> get_poll_voters_object(int32 total_count,
+                                                                const vector<std::pair<DialogId, int32>> &voters) const;
 
   void on_get_poll_voters(PollId poll_id, int32 option_id, string offset, int32 limit,
                           Result<tl_object_ptr<telegram_api::messages_votesList>> &&result);