Adds delays for suggestion api (uplift to 1.3)

browser/ui/webui/brave_rewards_page_ui.cc

@@ -251,6 +251,8 @@ class RewardsDOMHandler : public WebUIMessageHandler,
   void OnUnblindedTokensReady(
     brave_rewards::RewardsService* rewards_service) override;
 
+  void ReconcileStampReset() override;
+
   // RewardsNotificationsServiceObserver implementation
   void OnNotificationAdded(
       brave_rewards::RewardsNotificationService* rewards_notification_service,
@@ -1700,6 +1702,14 @@ void RewardsDOMHandler::OnUnblindedTokensReady(
   web_ui()->CallJavascriptFunctionUnsafe("brave_rewards.unblindedTokensReady");
 }
 
+void RewardsDOMHandler::ReconcileStampReset() {
+  if (!web_ui()->CanCallJavascript()) {
+    return;
+  }
+
+  web_ui()->CallJavascriptFunctionUnsafe("brave_rewards.reconcileStampReset");
+}
+
 }  // namespace
 
 BraveRewardsPageUI::BraveRewardsPageUI(content::WebUI* web_ui,

components/brave_rewards/browser/database/database_contribution_info.cc

@@ -331,7 +331,7 @@ bool DatabaseContributionInfo::InsertOrUpdate(
   statement.BindString(0, info->contribution_id);
   statement.BindDouble(1, info->amount);
   statement.BindInt(2, static_cast<int>(info->type));
-  statement.BindInt(3, info->step);
+  statement.BindInt(3, static_cast<int>(info->step));
   statement.BindInt(4, info->retry_count);
 
   if (info->created_at == 0) {
@@ -360,17 +360,18 @@ bool DatabaseContributionInfo::GetOneTimeTips(
     return false;
   }
 
-  const std::string query =
+  const std::string query = base::StringPrintf(
     "SELECT pi.publisher_id, pi.name, pi.url, pi.favIcon, "
     "ci.amount, ci.created_at, spi.status, pi.provider "
-    "FROM contribution_info as ci "
+    "FROM %s as ci "
     "INNER JOIN contribution_info_publishers AS cp "
     "ON cp.contribution_id = ci.contribution_id "
     "INNER JOIN publisher_info AS pi ON cp.publisher_key = pi.publisher_id "
     "LEFT JOIN server_publisher_info AS spi "
     "ON spi.publisher_key = pi.publisher_id "
-    "WHERE strftime('%m',  datetime(ci.created_at, 'unixepoch')) = ? AND "
-    "strftime('%Y', datetime(ci.created_at, 'unixepoch')) = ? AND ci.type = ?";
+    "WHERE strftime('%%m',  datetime(ci.created_at, 'unixepoch')) = ? AND "
+    "strftime('%%Y', datetime(ci.created_at, 'unixepoch')) = ? AND ci.type = ?",
+    table_name_);
 
   sql::Statement statement(db->GetUniqueStatement(query.c_str()));
 
@@ -399,4 +400,107 @@ bool DatabaseContributionInfo::GetOneTimeTips(
   return true;
 }
 
+bool DatabaseContributionInfo::GetNotCompletedRecords(
+    sql::Database* db,
+    ledger::ContributionInfoList* list) {
+  DCHECK(list && db);
+  if (!list || !db) {
+    return false;
+  }
+
+  const std::string query = base::StringPrintf(
+    "SELECT ci.contribution_id, ci.amount, ci.type, ci.step, ci.retry_count "
+    "FROM %s as ci WHERE ci.step > 0",
+    table_name_);
+
+  sql::Statement statement(db->GetUniqueStatement(query.c_str()));
+
+  while (statement.Step()) {
+    auto info = ledger::ContributionInfo::New();
+    info->contribution_id = statement.ColumnString(0);
+    info->amount = statement.ColumnDouble(1);
+    info->type = static_cast<ledger::RewardsType>(statement.ColumnInt64(2));
+    info->step = static_cast<ledger::ContributionStep>(statement.ColumnInt(3));
+    info->retry_count = statement.ColumnInt(4);
+    publishers_->GetRecords(
+        db,
+        info->contribution_id,
+        &info->publishers);
+
+    list->push_back(std::move(info));
+  }
+
+  return true;
+}
+
+ledger::ContributionInfoPtr DatabaseContributionInfo::GetRecord(
+    sql::Database* db,
+    const std::string& contribution_id) {
+  DCHECK(db);
+  if (!db || contribution_id.empty()) {
+    return nullptr;
+  }
+
+  const std::string query = base::StringPrintf(
+    "SELECT ci.contribution_id, ci.amount, ci.type, ci.step, ci.retry_count "
+    "FROM %s as ci "
+    "WHERE ci.contribution_id = ?",
+    table_name_);
+
+  sql::Statement statement(db->GetUniqueStatement(query.c_str()));
+
+  statement.BindString(0, contribution_id);
+
+  if (!statement.Step()) {
+    return nullptr;
+  }
+
+  auto info = ledger::ContributionInfo::New();
+  info->contribution_id = statement.ColumnString(0);
+  info->amount = statement.ColumnDouble(1);
+  info->type = static_cast<ledger::RewardsType>(statement.ColumnInt64(2));
+  info->step = static_cast<ledger::ContributionStep>(statement.ColumnInt(3));
+  info->retry_count = statement.ColumnInt(4);
+  publishers_->GetRecords(
+      db,
+      info->contribution_id,
+      &info->publishers);
+
+  return info;
+}
+
+bool DatabaseContributionInfo::UpdateStepAndCount(
+    sql::Database* db,
+    const std::string& contribution_id,
+    const ledger::ContributionStep step,
+    const int32_t retry_count) {
+  DCHECK(db);
+  if (!db || contribution_id.empty()) {
+    return false;
+  }
+
+  const std::string query = base::StringPrintf(
+    "UPDATE %s SET step=?, retry_count=? WHERE contribution_id = ?;",
+    table_name_);
+
+  sql::Statement statement(
+      db->GetCachedStatement(SQL_FROM_HERE, query.c_str()));
+
+  statement.BindInt(0, static_cast<int>(step));
+  statement.BindInt(1, retry_count);
+  statement.BindString(2, contribution_id);
+
+  return statement.Run();
+}
+
+bool DatabaseContributionInfo::UpdateContributedAmount(
+    sql::Database* db,
+    const std::string& contribution_id,
+    const std::string& publisher_key) {
+  return publishers_->UpdateContributedAmount(
+      db,
+      contribution_id,
+      publisher_key);
+}
+
 }  // namespace brave_rewards

components/brave_rewards/browser/database/database_contribution_info.h

@@ -38,6 +38,25 @@ class DatabaseContributionInfo: public DatabaseTable {
       const ledger::ActivityMonth month,
       const int year);
 
+  bool GetNotCompletedRecords(
+      sql::Database* db,
+      ledger::ContributionInfoList* list);
+
+  ledger::ContributionInfoPtr GetRecord(
+      sql::Database* db,
+      const std::string& contribution_id);
+
+  bool UpdateStepAndCount(
+      sql::Database* db,
+      const std::string& contribution_id,
+      const ledger::ContributionStep step,
+      const int32_t retry_count);
+
+  bool UpdateContributedAmount(
+      sql::Database* db,
+      const std::string& contribution_id,
+      const std::string& publisher_key);
+
  private:
   const char* table_name_ = "contribution_info";
   const int minimum_version_ = 2;

components/brave_rewards/browser/database/database_contribution_info_publishers.cc

@@ -119,8 +119,12 @@ bool DatabaseContributionInfoPublishers::InsertOrUpdate(
     return false;
   }
 
-  const std::string query = base::StringPrintf(
-    "INSERT OR REPLACE INTO %s "
+  const std::string query_delete = base::StringPrintf(
+    "DELETE FROM %s WHERE contribution_id = ? AND publisher_key = ?",
+    table_name_);
+
+  const std::string query_insert = base::StringPrintf(
+    "INSERT INTO %s "
     "(contribution_id, publisher_key, total_amount, contributed_amount) "
     "VALUES (?, ?, ?, ?)",
     table_name_);
@@ -131,14 +135,20 @@ bool DatabaseContributionInfoPublishers::InsertOrUpdate(
   }
 
   for (const auto& publisher : info->publishers) {
-    sql::Statement statement(
-      db->GetCachedStatement(SQL_FROM_HERE, query.c_str()));
-
-    statement.BindString(0, publisher->contribution_id);
-    statement.BindString(1, publisher->publisher_key);
-    statement.BindDouble(2, publisher->total_amount);
-    statement.BindDouble(3, publisher->contributed_amount);
-    statement.Run();
+    sql::Statement statement_delete(
+        db->GetUniqueStatement(query_delete.c_str()));
+
+    statement_delete.BindString(0, publisher->contribution_id);
+    statement_delete.BindString(1, publisher->publisher_key);
+    statement_delete.Run();
+
+    sql::Statement statement_insert(
+        db->GetUniqueStatement(query_insert.c_str()));
+    statement_insert.BindString(0, publisher->contribution_id);
+    statement_insert.BindString(1, publisher->publisher_key);
+    statement_insert.BindDouble(2, publisher->total_amount);
+    statement_insert.BindDouble(3, publisher->contributed_amount);
+    statement_insert.Run();
   }
 
   return transaction.Commit();
@@ -175,4 +185,30 @@ bool DatabaseContributionInfoPublishers::GetRecords(
   return true;
 }
 
+bool DatabaseContributionInfoPublishers::UpdateContributedAmount(
+    sql::Database* db,
+    const std::string& contribution_id,
+    const std::string& publisher_key) {
+  DCHECK(db);
+  if (!db || contribution_id.empty() || publisher_key.empty()) {
+    return false;
+  }
+
+  const std::string query = base::StringPrintf(
+    "UPDATE %s SET contributed_amount="
+    "(SELECT total_amount WHERE contribution_id = ? AND publisher_key = ?) "
+    "WHERE contribution_id = ? AND publisher_key = ?;",
+    table_name_);
+
+  sql::Statement statement(
+      db->GetCachedStatement(SQL_FROM_HERE, query.c_str()));
+
+  statement.BindString(0, contribution_id);
+  statement.BindString(1, publisher_key);
+  statement.BindString(2, contribution_id);
+  statement.BindString(3, publisher_key);
+
+  return statement.Run();
+}
+
 }  // namespace brave_rewards

components/brave_rewards/browser/database/database_contribution_info_publishers.h

@@ -38,6 +38,11 @@ class DatabaseContributionInfoPublishers: public DatabaseTable {
     const std::string& contribution_id,
     ledger::ContributionPublisherList* list);
 
+  bool UpdateContributedAmount(
+      sql::Database* db,
+      const std::string& contribution_id,
+      const std::string& publisher_key);
+
  private:
   const char* table_name_ = "contribution_info_publishers";
   const int minimum_version_ = 11;

components/brave_rewards/browser/database/publisher_info_database.cc

@@ -175,6 +175,53 @@ void PublisherInfoDatabase::GetOneTimeTips(
   contribution_info_->GetOneTimeTips(&GetDB(), list, month, year);
 }
 
+void PublisherInfoDatabase::GetIncompleteContributions(
+    ledger::ContributionInfoList* list) {
+  DCHECK(list);
+  if (!IsInitialized() || !list) {
+    return;
+  }
+
+  contribution_info_->GetNotCompletedRecords(&GetDB(), list);
+}
+
+ledger::ContributionInfoPtr PublisherInfoDatabase::GetContributionInfo(
+    const std::string& contribution_id) {
+  if (!IsInitialized()) {
+    return nullptr;
+  }
+
+  return contribution_info_->GetRecord(&GetDB(), contribution_id);
+}
+
+bool PublisherInfoDatabase::UpdateContributionInfoStepAndCount(
+    const std::string& contribution_id,
+    const ledger::ContributionStep step,
+    const int32_t retry_count) {
+  if (!IsInitialized()) {
+    return false;
+  }
+
+  return contribution_info_->UpdateStepAndCount(
+      &GetDB(),
+      contribution_id,
+      step,
+      retry_count);
+}
+
+bool PublisherInfoDatabase::UpdateContributionInfoContributedAmount(
+    const std::string& contribution_id,
+    const std::string& publisher_key) {
+  if (!IsInitialized()) {
+    return false;
+  }
+
+  return contribution_info_->UpdateContributedAmount(
+      &GetDB(),
+      contribution_id,
+      publisher_key);
+}
+
 /**
  *
  * PUBLISHER INFO

components/brave_rewards/browser/database/publisher_info_database.h

@@ -139,6 +139,21 @@ class PublisherInfoDatabase {
   bool DeleteActivityInfo(const std::string& publisher_key,
                           uint64_t reconcile_stamp);
 
+  void GetIncompleteContributions(
+      ledger::ContributionInfoList* list);
+
+  ledger::ContributionInfoPtr GetContributionInfo(
+      const std::string& contribution_id);
+
+  bool UpdateContributionInfoStepAndCount(
+      const std::string& contribution_id,
+      const ledger::ContributionStep step,
+      const int32_t retry_count);
+
+  bool UpdateContributionInfoContributedAmount(
+      const std::string& contribution_id,
+      const std::string& publisher_key);
+
   // Vacuums the database. This will cause sqlite to defragment and collect
   // unused space in the file. It can be VERY SLOW.
   void Vacuum();

components/brave_rewards/browser/database/publisher_info_database_unittest.cc

@@ -161,7 +161,7 @@ TEST_F(PublisherInfoDatabaseTest, InsertOrUpdateContributionInfo) {
   info->contribution_id = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   info->amount = 5.0;
   info->type = ledger::RewardsType::AUTO_CONTRIBUTE;
-  info->step = -1;
+  info->step = ledger::ContributionStep::STEP_COMPLETED;
   info->retry_count = -1;
   info->created_at = base::Time::Now().ToJsTime();
 
@@ -179,7 +179,7 @@ TEST_F(PublisherInfoDatabaseTest, InsertOrUpdateContributionInfo) {
   EXPECT_EQ(info_sql.ColumnString(0), info->contribution_id);
   EXPECT_EQ(info_sql.ColumnDouble(1), info->amount);
   EXPECT_EQ(info_sql.ColumnInt(2), static_cast<int>(info->type));
-  EXPECT_EQ(info_sql.ColumnInt(3), info->step);
+  EXPECT_EQ(info_sql.ColumnInt(3), static_cast<int>(info->step));
   EXPECT_EQ(info_sql.ColumnInt(4), info->retry_count);
   EXPECT_EQ(info_sql.ColumnInt64(5), static_cast<int64_t>(info->created_at));
 }