Only create a SKU transaction if there doesn't already exist one. (up…

…lift to 1.50.x) (#17669)

Uplift of #17644 (squashed) to beta

chromium_presubmit_config.json5

@@ -179,6 +179,7 @@
       "vendor/bat-native-ledger/src/bat/ledger/internal/database/database_sku_order\\.h",
       "vendor/bat-native-ledger/src/bat/ledger/internal/database/database_sku_order_items\\.cc",
       "vendor/bat-native-ledger/src/bat/ledger/internal/database/database_sku_transaction\\.cc",
+      "vendor/bat-native-ledger/src/bat/ledger/internal/database/database_sku_transaction\\.h",
       "vendor/bat-native-ledger/src/bat/ledger/internal/database/database_unblinded_token\\.cc",
       "vendor/bat-native-ledger/src/bat/ledger/internal/endpoint/bitflyer/post_transaction/post_transaction_bitflyer\\.cc",
       "vendor/bat-native-ledger/src/bat/ledger/internal/endpoint/gemini/get_transaction/get_transaction_gemini\\.cc",
@@ -226,6 +227,7 @@
       "vendor/bat-native-ledger/src/bat/ledger/internal/sku/sku_merchant\\.h",
       "vendor/bat-native-ledger/src/bat/ledger/internal/sku/sku_order\\.cc",
       "vendor/bat-native-ledger/src/bat/ledger/internal/sku/sku_transaction\\.cc",
+      "vendor/bat-native-ledger/src/bat/ledger/internal/sku/sku_transaction\\.h",
       "vendor/bat-native-ledger/src/bat/ledger/internal/state/state_migration\\.cc",
       "vendor/bat-native-ledger/src/bat/ledger/internal/state/state_migration_v1\\.cc",
       "vendor/bat-native-ledger/src/bat/ledger/internal/state/state_migration_v10\\.cc",

vendor/bat-native-ledger/src/bat/ledger/internal/contribution/contribution.cc

@@ -663,9 +663,9 @@ void Contribution::SetRetryCounter(mojom::ContributionInfoPtr contribution) {
     return;
   }
 
-  if (contribution->retry_count == 3 &&
+  if (contribution->retry_count == 5 &&
       contribution->step != mojom::ContributionStep::STEP_PREPARE) {
-    BLOG(0, "Contribution failed after 3 retries");
+    BLOG(0, "Contribution failed after 5 retries");
     ContributionCompleted(mojom::Result::TOO_MANY_RESULTS,
                           std::move(contribution));
     return;

vendor/bat-native-ledger/src/bat/ledger/internal/database/database_sku_transaction.cc

@@ -107,7 +107,7 @@ void DatabaseSKUTransaction::GetRecordByOrderId(
     GetSKUTransactionCallback callback) {
   if (order_id.empty()) {
     BLOG(1, "Order id is empty");
-    callback(nullptr);
+    callback(base::unexpected(GetSKUTransactionError::kDatabaseError));
     return;
   }
   auto transaction = mojom::DBTransaction::New();
@@ -145,14 +145,19 @@ void DatabaseSKUTransaction::OnGetRecord(mojom::DBCommandResponsePtr response,
   if (!response ||
       response->status != mojom::DBCommandResponse::Status::RESPONSE_OK) {
     BLOG(0, "Response is wrong");
-    callback(nullptr);
+    callback(base::unexpected(GetSKUTransactionError::kDatabaseError));
     return;
   }
 
-  if (response->result->get_records().size() != 1) {
-    BLOG(1, "Record size is not correct: " <<
-        response->result->get_records().size());
-    callback(nullptr);
+  if (response->result->get_records().empty()) {
+    callback(base::unexpected(GetSKUTransactionError::kTransactionNotFound));
+    return;
+  }
+
+  if (response->result->get_records().size() > 1) {
+    BLOG(1, "Record size is not correct: "
+                << response->result->get_records().size());
+    callback(base::unexpected(GetSKUTransactionError::kDatabaseError));
     return;
   }
 

vendor/bat-native-ledger/src/bat/ledger/internal/database/database_sku_transaction.h

@@ -8,12 +8,16 @@
 
 #include <string>
 
+#include "base/types/expected.h"
 #include "bat/ledger/internal/database/database_table.h"
 
 namespace ledger {
 namespace database {
 
-using GetSKUTransactionCallback = std::function<void(mojom::SKUTransactionPtr)>;
+enum class GetSKUTransactionError { kDatabaseError, kTransactionNotFound };
+
+using GetSKUTransactionCallback = std::function<void(
+    base::expected<mojom::SKUTransactionPtr, GetSKUTransactionError>)>;
 
 class DatabaseSKUTransaction: public DatabaseTable {
  public:

vendor/bat-native-ledger/src/bat/ledger/internal/endpoint/payment/post_transaction_gemini/post_transaction_sku_gemini.cc

@@ -84,7 +84,7 @@ void PostTransactionGemini::Request(const mojom::SKUTransaction& transaction,
   request->content_type = "application/json; charset=utf-8";
   request->method = mojom::UrlMethod::POST;
   BLOG(0, "External Transaction ID: " << transaction.external_transaction_id
-                                      << "for " << transaction.amount);
+                                      << " for " << transaction.amount);
 
   ledger_->LoadURL(std::move(request), url_callback);
 }

vendor/bat-native-ledger/src/bat/ledger/internal/sku/sku_common.cc

@@ -44,11 +44,7 @@ void SKUCommon::CreateTransaction(mojom::SKUOrderPtr order,
       order->order_id,
       callback);
 
-  transaction_->Create(
-      order->Clone(),
-      destination,
-      wallet_type,
-      create_callback);
+  transaction_->Run(order->Clone(), destination, wallet_type, create_callback);
 }
 
 void SKUCommon::OnTransactionCompleted(const mojom::Result result,
@@ -80,22 +76,22 @@ void SKUCommon::SendExternalTransaction(
   ledger_->database()->GetSKUTransactionByOrderId(order_id, get_callback);
 }
 
-void SKUCommon::GetSKUTransactionByOrderId(mojom::SKUTransactionPtr transaction,
-                                           ledger::SKUOrderCallback callback) {
+void SKUCommon::GetSKUTransactionByOrderId(
+    base::expected<mojom::SKUTransactionPtr, database::GetSKUTransactionError>
+        result,
+    ledger::SKUOrderCallback callback) {
+  const auto transaction = std::move(result).value_or(nullptr);
   if (!transaction) {
-    BLOG(0, "Transaction is null");
-    callback(mojom::Result::LEDGER_ERROR, "");
-    return;
+    BLOG(0,
+         "Failed to get SKU transaction from database, or there's no "
+         "transaction with this order_id!");
+    return callback(mojom::Result::LEDGER_ERROR, "");
   }
 
-  auto create_callback = std::bind(&SKUCommon::OnTransactionCompleted,
-    this,
-    _1,
-    transaction->order_id,
-    callback);
-
-  transaction_->SendExternalTransaction(mojom::Result::LEDGER_OK, *transaction,
-                                        create_callback);
+  transaction_->SendExternalTransaction(
+      mojom::Result::LEDGER_OK, *transaction,
+      std::bind(&SKUCommon::OnTransactionCompleted, this, _1,
+                transaction->order_id, std::move(callback)));
 }
 
 }  // namespace sku

vendor/bat-native-ledger/src/bat/ledger/internal/sku/sku_common.h

@@ -10,6 +10,8 @@
 #include <string>
 #include <vector>
 
+#include "base/types/expected.h"
+#include "bat/ledger/internal/database/database_sku_transaction.h"
 #include "bat/ledger/internal/sku/sku_order.h"
 #include "bat/ledger/internal/sku/sku_transaction.h"
 #include "bat/ledger/ledger.h"
@@ -41,8 +43,10 @@ class SKUCommon {
                               const std::string& order_id,
                               ledger::SKUOrderCallback callback);
 
-  void GetSKUTransactionByOrderId(mojom::SKUTransactionPtr transaction,
-                                  ledger::SKUOrderCallback callback);
+  void GetSKUTransactionByOrderId(
+      base::expected<mojom::SKUTransactionPtr, database::GetSKUTransactionError>
+          result,
+      ledger::SKUOrderCallback callback);
 
   LedgerImpl* ledger_;  // NOT OWNED
   std::unique_ptr<SKUOrder> order_;

vendor/bat-native-ledger/src/bat/ledger/internal/sku/sku_transaction.cc

@@ -51,29 +51,67 @@ SKUTransaction::SKUTransaction(LedgerImpl* ledger) :
 
 SKUTransaction::~SKUTransaction() = default;
 
-void SKUTransaction::Create(mojom::SKUOrderPtr order,
-                            const std::string& destination,
-                            const std::string& wallet_type,
-                            ledger::LegacyResultCallback callback) {
+void SKUTransaction::Run(mojom::SKUOrderPtr order,
+                         const std::string& destination,
+                         const std::string& wallet_type,
+                         ledger::LegacyResultCallback callback) {
   if (!order) {
-    BLOG(0, "Order is null");
-    callback(mojom::Result::LEDGER_ERROR);
-    return;
+    BLOG(0, "Order is null!");
+    return callback(mojom::Result::LEDGER_ERROR);
+  }
+
+  DCHECK(!order->contribution_id.empty());
+  auto on_maybe_create_transaction =
+      std::bind(&SKUTransaction::OnTransactionSaved, this, _1, _2, destination,
+                wallet_type, order->contribution_id, std::move(callback));
+
+  MaybeCreateTransaction(std::move(order), wallet_type,
+                         std::move(on_maybe_create_transaction));
+}
+
+void SKUTransaction::MaybeCreateTransaction(
+    mojom::SKUOrderPtr order,
+    const std::string& wallet_type,
+    MaybeCreateTransactionCallback callback) {
+  DCHECK(order);
+  ledger_->database()->GetSKUTransactionByOrderId(
+      order->order_id, std::bind(&SKUTransaction::OnGetSKUTransactionByOrderId,
+                                 this, std::move(callback), order->order_id,
+                                 wallet_type, order->total_amount, _1));
+}
+
+void SKUTransaction::OnGetSKUTransactionByOrderId(
+    MaybeCreateTransactionCallback callback,
+    const std::string& order_id,
+    const std::string& wallet_type,
+    double total_amount,
+    base::expected<mojom::SKUTransactionPtr, database::GetSKUTransactionError>
+        result) {
+  if (result.has_value()) {
+    DCHECK(result.value());
+    return callback(mojom::Result::LEDGER_OK, *result.value());
+  }
+
+  switch (result.error()) {
+    case database::GetSKUTransactionError::kDatabaseError:
+      BLOG(0, "Failed to get SKU transaction from database!");
+      return callback(mojom::Result::LEDGER_ERROR, {});
+    case database::GetSKUTransactionError::kTransactionNotFound:
+      break;
   }
 
   auto transaction = mojom::SKUTransaction::New();
   transaction->transaction_id = base::GenerateGUID();
-  transaction->order_id = order->order_id;
+  transaction->order_id = order_id;
   transaction->type = GetTransactionTypeFromWalletType(wallet_type);
-  transaction->amount = order->total_amount;
+  transaction->amount = total_amount;
   transaction->status = mojom::SKUTransactionStatus::CREATED;
 
-  DCHECK(!order->contribution_id.empty());
-  auto save_callback =
-      std::bind(&SKUTransaction::OnTransactionSaved, this, _1, *transaction,
-                destination, wallet_type, order->contribution_id, callback);
+  auto on_save_sku_transaction =
+      std::bind(std::move(callback), _1, *transaction);
 
-  ledger_->database()->SaveSKUTransaction(transaction->Clone(), save_callback);
+  ledger_->database()->SaveSKUTransaction(std::move(transaction),
+                                          std::move(on_save_sku_transaction));
 }
 
 void SKUTransaction::OnTransactionSaved(

vendor/bat-native-ledger/src/bat/ledger/internal/sku/sku_transaction.h

@@ -12,6 +12,7 @@
 
 #include "base/types/expected.h"
 #include "bat/ledger/internal/database/database_external_transactions.h"
+#include "bat/ledger/internal/database/database_sku_transaction.h"
 #include "bat/ledger/internal/endpoint/payment/payment_server.h"
 #include "bat/ledger/ledger.h"
 
@@ -25,16 +26,31 @@ class SKUTransaction {
   explicit SKUTransaction(LedgerImpl* ledger);
   ~SKUTransaction();
 
-  void Create(mojom::SKUOrderPtr order,
-              const std::string& destination,
-              const std::string& wallet_type,
-              ledger::LegacyResultCallback callback);
+  void Run(mojom::SKUOrderPtr order,
+           const std::string& destination,
+           const std::string& wallet_type,
+           ledger::LegacyResultCallback callback);
 
   void SendExternalTransaction(mojom::Result result,
                                const mojom::SKUTransaction& transaction,
                                ledger::LegacyResultCallback callback);
 
  private:
+  using MaybeCreateTransactionCallback =
+      std::function<void(mojom::Result, const mojom::SKUTransaction&)>;
+
+  void MaybeCreateTransaction(mojom::SKUOrderPtr order,
+                              const std::string& wallet_type,
+                              MaybeCreateTransactionCallback callback);
+
+  void OnGetSKUTransactionByOrderId(
+      MaybeCreateTransactionCallback callback,
+      const std::string& order_id,
+      const std::string& wallet_type,
+      double total_amount,
+      base::expected<mojom::SKUTransactionPtr, database::GetSKUTransactionError>
+          result);
+
   void OnTransactionSaved(mojom::Result result,
                           const mojom::SKUTransaction& transaction,
                           const std::string& destination,