Move relevant functions to StarManager.

td/telegram/Payments.cpp

@@ -868,34 +868,6 @@ class ExportInvoiceQuery final : public Td::ResultHandler {
   }
 };
 
-class RefundStarsChargeQuery final : public Td::ResultHandler {
-  Promise<Unit> promise_;
-
- public:
-  explicit RefundStarsChargeQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
-  }
-
-  void send(telegram_api::object_ptr<telegram_api::InputUser> &&input_user, const string &telegram_payment_charge_id) {
-    send_query(G()->net_query_creator().create(
-        telegram_api::payments_refundStarsCharge(std::move(input_user), telegram_payment_charge_id)));
-  }
-
-  void on_result(BufferSlice packet) final {
-    auto result_ptr = fetch_result<telegram_api::payments_refundStarsCharge>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(result_ptr.move_as_error());
-    }
-
-    auto ptr = result_ptr.move_as_ok();
-    LOG(DEBUG) << "Receive result for RefundStarsChargeQuery: " << to_string(ptr);
-    td_->updates_manager_->on_get_updates(std::move(ptr), std::move(promise_));
-  }
-
-  void on_error(Status status) final {
-    promise_.set_error(std::move(status));
-  }
-};
-
 class GetBankCardInfoQuery final : public Td::ResultHandler {
   Promise<td_api::object_ptr<td_api::bankCardInfo>> promise_;
 
@@ -1158,12 +1130,6 @@ void export_invoice(Td *td, td_api::object_ptr<td_api::InputMessageContent> &&in
   td->create_handler<ExportInvoiceQuery>(std::move(promise))->send(std::move(input_media));
 }
 
-void refund_star_payment(Td *td, UserId user_id, const string &telegram_payment_charge_id, Promise<Unit> &&promise) {
-  TRY_RESULT_PROMISE(promise, input_user, td->user_manager_->get_input_user(user_id));
-  td->create_handler<RefundStarsChargeQuery>(std::move(promise))
-      ->send(std::move(input_user), telegram_payment_charge_id);
-}
-
 void get_bank_card_info(Td *td, const string &bank_card_number,
                         Promise<td_api::object_ptr<td_api::bankCardInfo>> &&promise) {
   td->create_handler<GetBankCardInfoQuery>(std::move(promise))->send(bank_card_number);

td/telegram/Payments.h

@@ -49,8 +49,6 @@ void delete_saved_credentials(Td *td, Promise<Unit> &&promise);
 
 void export_invoice(Td *td, td_api::object_ptr<td_api::InputMessageContent> &&invoice, Promise<string> &&promise);
 
-void refund_star_payment(Td *td, UserId user_id, const string &telegram_payment_charge_id, Promise<Unit> &&promise);
-
 void get_bank_card_info(Td *td, const string &bank_card_number,
                         Promise<td_api::object_ptr<td_api::bankCardInfo>> &&promise);
 

td/telegram/Premium.cpp

@@ -609,139 +609,6 @@ class GetGiveawayInfoQuery final : public Td::ResultHandler {
   }
 };
 
-class GetStarsTopupOptionsQuery final : public Td::ResultHandler {
-  Promise<td_api::object_ptr<td_api::starPaymentOptions>> promise_;
-
- public:
-  explicit GetStarsTopupOptionsQuery(Promise<td_api::object_ptr<td_api::starPaymentOptions>> &&promise)
-      : promise_(std::move(promise)) {
-  }
-
-  void send() {
-    send_query(G()->net_query_creator().create(telegram_api::payments_getStarsTopupOptions()));
-  }
-
-  void on_result(BufferSlice packet) final {
-    auto result_ptr = fetch_result<telegram_api::payments_getStarsTopupOptions>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(result_ptr.move_as_error());
-    }
-
-    auto results = result_ptr.move_as_ok();
-    vector<td_api::object_ptr<td_api::starPaymentOption>> options;
-    for (auto &result : results) {
-      options.push_back(td_api::make_object<td_api::starPaymentOption>(
-          result->currency_, result->amount_, result->stars_, result->store_product_, result->extended_));
-    }
-
-    promise_.set_value(td_api::make_object<td_api::starPaymentOptions>(std::move(options)));
-  }
-
-  void on_error(Status status) final {
-    promise_.set_error(std::move(status));
-  }
-};
-
-class GetStarsTransactionsQuery final : public Td::ResultHandler {
-  Promise<td_api::object_ptr<td_api::starTransactions>> promise_;
-
- public:
-  explicit GetStarsTransactionsQuery(Promise<td_api::object_ptr<td_api::starTransactions>> &&promise)
-      : promise_(std::move(promise)) {
-  }
-
-  void send(const string &offset, td_api::object_ptr<td_api::StarTransactionDirection> &&direction) {
-    int32 flags = 0;
-    if (direction != nullptr) {
-      switch (direction->get_id()) {
-        case td_api::starTransactionDirectionIncoming::ID:
-          flags |= telegram_api::payments_getStarsTransactions::INBOUND_MASK;
-          break;
-        case td_api::starTransactionDirectionOutgoing::ID:
-          flags |= telegram_api::payments_getStarsTransactions::OUTBOUND_MASK;
-          break;
-        default:
-          UNREACHABLE();
-      }
-    }
-    send_query(G()->net_query_creator().create(telegram_api::payments_getStarsTransactions(
-        flags, false /*ignored*/, false /*ignored*/, false /*ignored*/,
-        telegram_api::make_object<telegram_api::inputPeerSelf>(), offset, 100)));
-  }
-
-  void on_result(BufferSlice packet) final {
-    auto result_ptr = fetch_result<telegram_api::payments_getStarsTransactions>(packet);
-    if (result_ptr.is_error()) {
-      return on_error(result_ptr.move_as_error());
-    }
-
-    auto result = result_ptr.move_as_ok();
-    td_->user_manager_->on_get_users(std::move(result->users_), "GetStarsTransactionsQuery");
-    td_->chat_manager_->on_get_chats(std::move(result->chats_), "GetStarsTransactionsQuery");
-
-    vector<td_api::object_ptr<td_api::starTransaction>> transactions;
-    for (auto &transaction : result->history_) {
-      td_api::object_ptr<td_api::productInfo> product_info;
-      if (!transaction->title_.empty() || !transaction->description_.empty() || transaction->photo_ != nullptr) {
-        auto photo = get_web_document_photo(td_->file_manager_.get(), std::move(transaction->photo_), DialogId());
-        product_info = get_product_info_object(td_, transaction->title_, transaction->description_, photo);
-      }
-      auto source = [&]() -> td_api::object_ptr<td_api::StarTransactionSource> {
-        switch (transaction->peer_->get_id()) {
-          case telegram_api::starsTransactionPeerUnsupported::ID:
-            return td_api::make_object<td_api::starTransactionSourceUnsupported>();
-          case telegram_api::starsTransactionPeerPremiumBot::ID:
-            return td_api::make_object<td_api::starTransactionSourceTelegram>();
-          case telegram_api::starsTransactionPeerAppStore::ID:
-            return td_api::make_object<td_api::starTransactionSourceAppStore>();
-          case telegram_api::starsTransactionPeerPlayMarket::ID:
-            return td_api::make_object<td_api::starTransactionSourceGooglePlay>();
-          case telegram_api::starsTransactionPeerFragment::ID: {
-            auto state = [&]() -> td_api::object_ptr<td_api::RevenueWithdrawalState> {
-              if (transaction->transaction_date_ > 0) {
-                return td_api::make_object<td_api::revenueWithdrawalStateCompleted>(transaction->transaction_date_,
-                                                                                    transaction->transaction_url_);
-              }
-              if (transaction->pending_) {
-                return td_api::make_object<td_api::revenueWithdrawalStatePending>();
-              }
-              if (transaction->failed_) {
-                return td_api::make_object<td_api::revenueWithdrawalStateFailed>();
-              }
-              if (!transaction->refund_) {
-                LOG(ERROR) << "Receive " << to_string(transaction);
-              }
-              return nullptr;
-            }();
-            return td_api::make_object<td_api::starTransactionSourceFragment>(std::move(state));
-          }
-          case telegram_api::starsTransactionPeer::ID: {
-            DialogId dialog_id(
-                static_cast<const telegram_api::starsTransactionPeer *>(transaction->peer_.get())->peer_);
-            if (dialog_id.get_type() == DialogType::User) {
-              return td_api::make_object<td_api::starTransactionSourceUser>(
-                  td_->user_manager_->get_user_id_object(dialog_id.get_user_id(), "starTransactionSourceUser"),
-                  std::move(product_info));
-            }
-            return td_api::make_object<td_api::starTransactionSourceUnsupported>();
-          }
-          default:
-            UNREACHABLE();
-        }
-      }();
-      transactions.push_back(td_api::make_object<td_api::starTransaction>(
-          transaction->id_, transaction->stars_, transaction->refund_, transaction->date_, std::move(source)));
-    }
-
-    promise_.set_value(
-        td_api::make_object<td_api::starTransactions>(result->balance_, std::move(transactions), result->next_offset_));
-  }
-
-  void on_error(Status status) final {
-    promise_.set_error(std::move(status));
-  }
-};
-
 class CanPurchasePremiumQuery final : public Td::ResultHandler {
   Promise<Unit> promise_;
 
@@ -1294,16 +1161,6 @@ void get_premium_giveaway_info(Td *td, MessageFullId message_full_id,
       ->send(message_full_id.get_dialog_id(), server_message_id);
 }
 
-void get_star_payment_options(Td *td, Promise<td_api::object_ptr<td_api::starPaymentOptions>> &&promise) {
-  td->create_handler<GetStarsTopupOptionsQuery>(std::move(promise))->send();
-}
-
-void get_star_transactions(Td *td, const string &offset,
-                           td_api::object_ptr<td_api::StarTransactionDirection> &&direction,
-                           Promise<td_api::object_ptr<td_api::starTransactions>> &&promise) {
-  td->create_handler<GetStarsTransactionsQuery>(std::move(promise))->send(offset, std::move(direction));
-}
-
 void can_purchase_premium(Td *td, td_api::object_ptr<td_api::StorePaymentPurpose> &&purpose, Promise<Unit> &&promise) {
   td->create_handler<CanPurchasePremiumQuery>(std::move(promise))->send(std::move(purpose));
 }

td/telegram/Premium.h

@@ -54,12 +54,6 @@ void launch_prepaid_premium_giveaway(Td *td, int64 giveaway_id,
 void get_premium_giveaway_info(Td *td, MessageFullId message_full_id,
                                Promise<td_api::object_ptr<td_api::PremiumGiveawayInfo>> &&promise);
 
-void get_star_payment_options(Td *td, Promise<td_api::object_ptr<td_api::starPaymentOptions>> &&promise);
-
-void get_star_transactions(Td *td, const string &offset,
-                           td_api::object_ptr<td_api::StarTransactionDirection> &&direction,
-                           Promise<td_api::object_ptr<td_api::starTransactions>> &&promise);
-
 void can_purchase_premium(Td *td, td_api::object_ptr<td_api::StorePaymentPurpose> &&purpose, Promise<Unit> &&promise);
 
 void assign_app_store_transaction(Td *td, const string &receipt,

td/telegram/StarManager.cpp

@@ -6,8 +6,182 @@
 //
 #include "td/telegram/StarManager.h"
 
+#include "td/telegram/ChatManager.h"
+#include "td/telegram/DialogId.h"
+#include "td/telegram/Global.h"
+#include "td/telegram/InputInvoice.h"
+#include "td/telegram/Photo.h"
+#include "td/telegram/Td.h"
+#include "td/telegram/telegram_api.h"
+#include "td/telegram/UpdatesManager.h"
+#include "td/telegram/UserManager.h"
+
+#include "td/utils/buffer.h"
+#include "td/utils/logging.h"
+
 namespace td {
 
+class GetStarsTopupOptionsQuery final : public Td::ResultHandler {
+  Promise<td_api::object_ptr<td_api::starPaymentOptions>> promise_;
+
+ public:
+  explicit GetStarsTopupOptionsQuery(Promise<td_api::object_ptr<td_api::starPaymentOptions>> &&promise)
+      : promise_(std::move(promise)) {
+  }
+
+  void send() {
+    send_query(G()->net_query_creator().create(telegram_api::payments_getStarsTopupOptions()));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::payments_getStarsTopupOptions>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    auto results = result_ptr.move_as_ok();
+    vector<td_api::object_ptr<td_api::starPaymentOption>> options;
+    for (auto &result : results) {
+      options.push_back(td_api::make_object<td_api::starPaymentOption>(
+          result->currency_, result->amount_, result->stars_, result->store_product_, result->extended_));
+    }
+
+    promise_.set_value(td_api::make_object<td_api::starPaymentOptions>(std::move(options)));
+  }
+
+  void on_error(Status status) final {
+    promise_.set_error(std::move(status));
+  }
+};
+
+class GetStarsTransactionsQuery final : public Td::ResultHandler {
+  Promise<td_api::object_ptr<td_api::starTransactions>> promise_;
+
+ public:
+  explicit GetStarsTransactionsQuery(Promise<td_api::object_ptr<td_api::starTransactions>> &&promise)
+      : promise_(std::move(promise)) {
+  }
+
+  void send(const string &offset, td_api::object_ptr<td_api::StarTransactionDirection> &&direction) {
+    int32 flags = 0;
+    if (direction != nullptr) {
+      switch (direction->get_id()) {
+        case td_api::starTransactionDirectionIncoming::ID:
+          flags |= telegram_api::payments_getStarsTransactions::INBOUND_MASK;
+          break;
+        case td_api::starTransactionDirectionOutgoing::ID:
+          flags |= telegram_api::payments_getStarsTransactions::OUTBOUND_MASK;
+          break;
+        default:
+          UNREACHABLE();
+      }
+    }
+    send_query(G()->net_query_creator().create(telegram_api::payments_getStarsTransactions(
+        flags, false /*ignored*/, false /*ignored*/, false /*ignored*/,
+        telegram_api::make_object<telegram_api::inputPeerSelf>(), offset, 100)));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::payments_getStarsTransactions>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    auto result = result_ptr.move_as_ok();
+    td_->user_manager_->on_get_users(std::move(result->users_), "GetStarsTransactionsQuery");
+    td_->chat_manager_->on_get_chats(std::move(result->chats_), "GetStarsTransactionsQuery");
+
+    vector<td_api::object_ptr<td_api::starTransaction>> transactions;
+    for (auto &transaction : result->history_) {
+      td_api::object_ptr<td_api::productInfo> product_info;
+      if (!transaction->title_.empty() || !transaction->description_.empty() || transaction->photo_ != nullptr) {
+        auto photo = get_web_document_photo(td_->file_manager_.get(), std::move(transaction->photo_), DialogId());
+        product_info = get_product_info_object(td_, transaction->title_, transaction->description_, photo);
+      }
+      auto source = [&]() -> td_api::object_ptr<td_api::StarTransactionSource> {
+        switch (transaction->peer_->get_id()) {
+          case telegram_api::starsTransactionPeerUnsupported::ID:
+            return td_api::make_object<td_api::starTransactionSourceUnsupported>();
+          case telegram_api::starsTransactionPeerPremiumBot::ID:
+            return td_api::make_object<td_api::starTransactionSourceTelegram>();
+          case telegram_api::starsTransactionPeerAppStore::ID:
+            return td_api::make_object<td_api::starTransactionSourceAppStore>();
+          case telegram_api::starsTransactionPeerPlayMarket::ID:
+            return td_api::make_object<td_api::starTransactionSourceGooglePlay>();
+          case telegram_api::starsTransactionPeerFragment::ID: {
+            auto state = [&]() -> td_api::object_ptr<td_api::RevenueWithdrawalState> {
+              if (transaction->transaction_date_ > 0) {
+                return td_api::make_object<td_api::revenueWithdrawalStateCompleted>(transaction->transaction_date_,
+                                                                                    transaction->transaction_url_);
+              }
+              if (transaction->pending_) {
+                return td_api::make_object<td_api::revenueWithdrawalStatePending>();
+              }
+              if (transaction->failed_) {
+                return td_api::make_object<td_api::revenueWithdrawalStateFailed>();
+              }
+              if (!transaction->refund_) {
+                LOG(ERROR) << "Receive " << to_string(transaction);
+              }
+              return nullptr;
+            }();
+            return td_api::make_object<td_api::starTransactionSourceFragment>(std::move(state));
+          }
+          case telegram_api::starsTransactionPeer::ID: {
+            DialogId dialog_id(
+                static_cast<const telegram_api::starsTransactionPeer *>(transaction->peer_.get())->peer_);
+            if (dialog_id.get_type() == DialogType::User) {
+              return td_api::make_object<td_api::starTransactionSourceUser>(
+                  td_->user_manager_->get_user_id_object(dialog_id.get_user_id(), "starTransactionSourceUser"),
+                  std::move(product_info));
+            }
+            return td_api::make_object<td_api::starTransactionSourceUnsupported>();
+          }
+          default:
+            UNREACHABLE();
+        }
+      }();
+      transactions.push_back(td_api::make_object<td_api::starTransaction>(
+          transaction->id_, transaction->stars_, transaction->refund_, transaction->date_, std::move(source)));
+    }
+
+    promise_.set_value(
+        td_api::make_object<td_api::starTransactions>(result->balance_, std::move(transactions), result->next_offset_));
+  }
+
+  void on_error(Status status) final {
+    promise_.set_error(std::move(status));
+  }
+};
+
+class RefundStarsChargeQuery final : public Td::ResultHandler {
+  Promise<Unit> promise_;
+
+ public:
+  explicit RefundStarsChargeQuery(Promise<Unit> &&promise) : promise_(std::move(promise)) {
+  }
+
+  void send(telegram_api::object_ptr<telegram_api::InputUser> &&input_user, const string &telegram_payment_charge_id) {
+    send_query(G()->net_query_creator().create(
+        telegram_api::payments_refundStarsCharge(std::move(input_user), telegram_payment_charge_id)));
+  }
+
+  void on_result(BufferSlice packet) final {
+    auto result_ptr = fetch_result<telegram_api::payments_refundStarsCharge>(packet);
+    if (result_ptr.is_error()) {
+      return on_error(result_ptr.move_as_error());
+    }
+
+    auto ptr = result_ptr.move_as_ok();
+    LOG(DEBUG) << "Receive result for RefundStarsChargeQuery: " << to_string(ptr);
+    td_->updates_manager_->on_get_updates(std::move(ptr), std::move(promise_));
+  }
+
+  void on_error(Status status) final {
+    promise_.set_error(std::move(status));
+  }
+};
+
 StarManager::StarManager(Td *td, ActorShared<> parent) : td_(td), parent_(std::move(parent)) {
 }
 
@@ -15,4 +189,21 @@ void StarManager::tear_down() {
   parent_.reset();
 }
 
+void StarManager::get_star_payment_options(Promise<td_api::object_ptr<td_api::starPaymentOptions>> &&promise) {
+  td_->create_handler<GetStarsTopupOptionsQuery>(std::move(promise))->send();
+}
+
+void StarManager::get_star_transactions(const string &offset,
+                                        td_api::object_ptr<td_api::StarTransactionDirection> &&direction,
+                                        Promise<td_api::object_ptr<td_api::starTransactions>> &&promise) {
+  td_->create_handler<GetStarsTransactionsQuery>(std::move(promise))->send(offset, std::move(direction));
+}
+
+void StarManager::refund_star_payment(UserId user_id, const string &telegram_payment_charge_id,
+                                      Promise<Unit> &&promise) {
+  TRY_RESULT_PROMISE(promise, input_user, td_->user_manager_->get_input_user(user_id));
+  td_->create_handler<RefundStarsChargeQuery>(std::move(promise))
+      ->send(std::move(input_user), telegram_payment_charge_id);
+}
+
 }  // namespace td

td/telegram/StarManager.h

@@ -6,9 +6,13 @@
 //
 #pragma once
 
+#include "td/telegram/td_api.h"
+#include "td/telegram/UserId.h"
+
 #include "td/actor/actor.h"
 
 #include "td/utils/common.h"
+#include "td/utils/Promise.h"
 
 namespace td {
 
@@ -18,6 +22,13 @@ class StarManager final : public Actor {
  public:
   StarManager(Td *td, ActorShared<> parent);
 
+  void get_star_payment_options(Promise<td_api::object_ptr<td_api::starPaymentOptions>> &&promise);
+
+  void get_star_transactions(const string &offset, td_api::object_ptr<td_api::StarTransactionDirection> &&direction,
+                             Promise<td_api::object_ptr<td_api::starTransactions>> &&promise);
+
+  void refund_star_payment(UserId user_id, const string &telegram_payment_charge_id, Promise<Unit> &&promise);
+
  private:
   void tear_down() final;
 

td/telegram/Td.cpp

@@ -9156,7 +9156,7 @@ void Td::on_request(uint64 id, td_api::refundStarPayment &request) {
   CHECK_IS_BOT();
   CLEAN_INPUT_STRING(request.telegram_payment_charge_id_);
   CREATE_OK_REQUEST_PROMISE();
-  refund_star_payment(this, UserId(request.user_id_), request.telegram_payment_charge_id_, std::move(promise));
+  star_manager_->refund_star_payment(UserId(request.user_id_), request.telegram_payment_charge_id_, std::move(promise));
 }
 
 void Td::on_request(uint64 id, td_api::getPassportElement &request) {
@@ -9480,14 +9480,14 @@ void Td::on_request(uint64 id, const td_api::getPremiumGiveawayInfo &request) {
 void Td::on_request(uint64 id, const td_api::getStarPaymentOptions &request) {
   CHECK_IS_USER();
   CREATE_REQUEST_PROMISE();
-  get_star_payment_options(this, std::move(promise));
+  star_manager_->get_star_payment_options(std::move(promise));
 }
 
 void Td::on_request(uint64 id, td_api::getStarTransactions &request) {
   CHECK_IS_USER();
   CLEAN_INPUT_STRING(request.offset_);
   CREATE_REQUEST_PROMISE();
-  get_star_transactions(this, request.offset_, std::move(request.direction_), std::move(promise));
+  star_manager_->get_star_transactions(request.offset_, std::move(request.direction_), std::move(promise));
 }
 
 void Td::on_request(uint64 id, td_api::canPurchaseFromStore &request) {