Read important payment related preferences from session-store-1

browser/importer/brave_profile_writer.cc

@@ -67,6 +67,10 @@ void BraveProfileWriter::UpdateStats(const BraveStats& stats) {
   }
 }
 
+void StuffThatHappensAfterRecover () {
+  // TODO: ...
+}
+
 void BraveProfileWriter::UpdateLedger(const BraveLedger& ledger) {
   brave_rewards::RewardsService* rewards_service =
       brave_rewards::RewardsServiceFactory::GetForProfile(profile_);
@@ -76,11 +80,48 @@ void BraveProfileWriter::UpdateLedger(const BraveLedger& ledger) {
   }
 
   // Avoid overwriting Brave Rewards wallet if one already exists.
-  if (rewards_service->IsWalletCreated()) {
+  if (!ledger.clobber_wallet && rewards_service->IsWalletCreated()) {
+    // TODO: check if there are funds?
+
     LOG(ERROR) << "Brave Rewards wallet already exists, canceling Brave Payments import.";
     // TODO communicate this failure mode to the user
     return;
   }
 
-  LOG(INFO) << "ledger passphrase: " << ledger.passphrase;
-}
+  // Set the preferences read from session-store-1
+  auto* payments = &ledger.settings.payments;
+  rewards_service->SetPublisherAllowVideos(payments->allow_media_publishers);
+  rewards_service->SetPublisherAllowNonVerified(payments->allow_non_verified);
+  rewards_service->SetAutoContribute(payments->enabled);
+  rewards_service->SetContributionAmount(payments->contribution_amount);
+  rewards_service->SetPublisherMinVisitTime(payments->min_visit_time);
+  rewards_service->SetPublisherMinVisits(payments->min_visits);
+
+  // Set the excluded sites
+  for (const auto& publisher_key : ledger.excluded_publishers) {
+    rewards_service->ExcludePublisher(publisher_key);
+  }
+
+  // Set the recurring sites (formerly known as pinned sites)
+  for (const auto& item : ledger.pinned_publishers) {
+    const auto& publisher_key = item.first;
+    const auto& pin_percentage = item.second;
+    const int amount_in_bat = (int)((pin_percentage / 100.0) *
+      ledger.settings.payments.contribution_amount);
+
+    // TODO: revisit this logic
+    // Mandar will help find the appropriate way to handle
+
+    if (amount_in_bat > 0) {
+      rewards_service->OnDonate(publisher_key, amount_in_bat, true);
+    }
+  }
+
+  // TODO: register observer which can handle the work
+  // that needs to happen AFTER RecoverWallet (StuffThatHappensAfterRecover)
+  // see comment in components/brave_rewards/browser/rewards_service_impl.cc
+  // ...
+
+  // Start the wallet recovery
+  rewards_service->RecoverWallet(ledger.passphrase);
+}

browser/importer/brave_profile_writer.h

@@ -15,6 +15,7 @@ struct BraveStats;
 struct BraveLedger;
 
 class BraveProfileWriter : public ProfileWriter {
+  //BSC: implement observer interface!!
  public:
   explicit BraveProfileWriter(Profile* profile);
 

common/importer/brave_ledger.h

@@ -7,6 +7,8 @@
 
 #include <string>
 #include <vector>
+#include <list>
+#include <map>
 
 struct BraveLedger {
   BraveLedger();
@@ -15,6 +17,22 @@ struct BraveLedger {
 
   std::vector<uint8_t> wallet_seed;
   std::string passphrase;
+  bool clobber_wallet;
+  std::list<std::string> excluded_publishers;
+  std::map<std::string, unsigned int> pinned_publishers;
+
+  // NOTE: if we need to read more data from session-store-1,
+  // we may consider moving this to brave_importer.h (or similar)
+  struct SessionStoreSettings {
+    struct PaymentSettings {
+      bool allow_media_publishers;
+      bool allow_non_verified;
+      bool enabled;
+      double contribution_amount;
+      uint64_t min_visit_time;
+      unsigned int min_visits;
+    } payments;
+  } settings;
 };
 
 #endif  // BRAVE_COMMON_IMPORTER_BRAVE_LEDGER_H_

components/brave_rewards/browser/rewards_service_impl.cc

@@ -1018,6 +1018,8 @@ void RewardsServiceImpl::TriggerOnRecoverWallet(ledger::Result result,
     newGrants.push_back(grant);
   }
   for (auto& observer : observers_)
+    // BSC: can register another observer
+    // the observer can then do the follow up work
     observer.OnRecoverWallet(this, result, balance, newGrants);
 }
 

utility/importer/brave_importer.cc

@@ -34,6 +34,8 @@
 #include "sql/statement.h"
 #include "url/gurl.h"
 
+#include "brave/vendor/bat-native-ledger/src/static_values.h"
+
 #if defined(OS_LINUX)
 #include "components/os_crypt/key_storage_config_linux.h"
 #endif
@@ -328,6 +330,7 @@ void BraveImporter::ImportStats() {
   bridge_->UpdateStats(stats);
 }
 
+// TODO: not used
 std::vector<uint8_t> ParseWalletSeed(const base::Value& ledger_state_json) {
   const base::Value* wallet_seed_json = ledger_state_json.FindPathOfType(
       {"properties", "wallet", "keyinfo", "seed"},
@@ -359,19 +362,172 @@ std::vector<uint8_t> ParseWalletSeed(const base::Value& ledger_state_json) {
   return wallet_seed;
 }
 
-std::string ParseWalletPassphrase(const base::Value& session_store_json) {
+bool ParseWalletPassphrase(BraveLedger& ledger, const base::Value& session_store_json) {
   const base::Value* wallet_passphrase_value = session_store_json.FindPathOfType(
       {"ledger", "info", "passphrase"},
       base::Value::Type::STRING);
   if (!wallet_passphrase_value) {
     LOG(ERROR) << "Wallet passphrase not found in session-store-1";
-    return {};
+    return false;
   }
 
-  return wallet_passphrase_value->GetString();
+  ledger.passphrase = wallet_passphrase_value->GetString();
+  return !ledger.passphrase.empty();
 }
 
-void BraveImporter::ImportLedger() {
+bool TryFindBoolKey(const base::Value* dict, const std::string key, bool& value_to_set) {
+  auto* value_read = dict->FindKeyOfType(key, base::Value::Type::BOOLEAN);
+  if (value_read) {
+    value_to_set = value_read->GetBool();
+    return true;
+  }
+  return false;
+}
+
+bool TryFindStringKey(const base::Value* dict, const std::string key, std::string& value_to_set) {
+  auto* value_read = dict->FindKeyOfType(key, base::Value::Type::STRING);
+  if (value_read) {
+    value_to_set = value_read->GetString();
+    return true;
+  }
+  return false;
+}
+
+bool TryFindIntKey(const base::Value* dict, const std::string key, int& value_to_set) {
+  auto* value_read = dict->FindKeyOfType(key, base::Value::Type::INTEGER);
+  if (value_read) {
+    value_to_set = value_read->GetInt();
+    return true;
+  }
+  return false;
+}
+
+bool ParsePaymentsPreferences(BraveLedger& ledger, const base::Value& session_store_json) {
+  const base::Value* settings = session_store_json.FindKeyOfType(
+    "settings",
+    base::Value::Type::DICTIONARY);
+  if (!settings) {
+    LOG(ERROR) << "No entry \"settings\" found in session-store-1";
+    return false;
+  }
+
+  auto* payments = &ledger.settings.payments;
+
+  TryFindBoolKey(settings, "payments.enabled", payments->enabled);
+  TryFindBoolKey(settings, "payments.allow-non-verified-publishers", payments->allow_non_verified);
+  TryFindBoolKey(settings, "payments.allow-media-publishers", payments->allow_media_publishers);
+
+  std::string contribution_amount = "";
+  TryFindStringKey(settings, "payments.contribution-amount", contribution_amount);
+  if (!contribution_amount.empty()) {
+    if (!base::StringToDouble(contribution_amount, &payments->contribution_amount)) {
+      LOG(ERROR) << "StringToDouble failed when converting \"settings.payments.contribution-amount\"; unable to convert value \"" << contribution_amount << "\"; defaulting value.";
+    }
+  }
+
+  std::string minimum_visits = "";
+  TryFindStringKey(settings, "payments.minimum-visits", minimum_visits);
+  if (!minimum_visits.empty()) {
+    if (!base::StringToUint(minimum_visits, &payments->min_visits)) {
+      LOG(ERROR) << "StringToUint failed when converting \"settings.payments.minimum-visits\"; unable to convert value \"" << minimum_visits << "\"; defaulting value.";
+    }
+  }
+  switch (payments->min_visits) {
+    // allowed values
+    case 1:
+    case 5:
+    case 10:
+    break;
+
+    default:
+      payments->min_visits = 1u;
+  }
+
+  std::string minumum_visit_time = "";
+  TryFindStringKey(settings, "payments.minimum-visit-time", minumum_visit_time);
+  if (!minumum_visit_time.empty()) {
+    if (!base::StringToUint64(minumum_visit_time, &payments->min_visit_time)) {
+      LOG(ERROR) << "StringToUint64 failed when converting \"settings.payments.minimum-visit-time\"; unable to convert value \"" << minumum_visit_time << "\"; defaulting value.";
+    }
+  }
+  switch (payments->min_visit_time) {
+    // allowed values
+    case 5000: payments->min_visit_time = 5; break;
+    case 8000: payments->min_visit_time = 8; break;
+    case 60000: payments->min_visit_time = 60; break;
+
+    default:
+      payments->min_visit_time = braveledger_ledger::_default_min_publisher_duration;
+  }
+
+  return true;
+}
+
+bool ParseExcludedSites(BraveLedger& ledger, const base::Value& session_store_json) {
+  const base::Value* site_settings = session_store_json.FindKeyOfType(
+    "siteSettings",
+    base::Value::Type::DICTIONARY);
+  if (!site_settings) {
+    LOG(ERROR) << "No entry \"siteSettings\" found in session-store-1";
+    return false;
+  }
+
+  ledger.excluded_publishers = std::list<std::string>();
+  bool host_pattern_included;
+
+  for (const auto& item : site_settings->DictItems()) {
+    const auto& host_pattern = item.first;
+    const auto& settings = item.second;
+
+    if (!settings.is_dict())
+      continue;
+
+    if (TryFindBoolKey(&settings, "ledgerPayments", host_pattern_included)) {
+      if (!host_pattern_included) {
+        // host pattern is in a format like: `https?://travis-ci.org`
+        // The protocol part can be removed (to get publisher key)
+        size_t protocol_index = host_pattern.find("//");
+        if (protocol_index != std::string::npos) {
+          ledger.excluded_publishers.push_back(host_pattern.substr(protocol_index + 2));
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+bool ParsePinnedSites(BraveLedger& ledger, const base::Value& session_store_json) {
+  const base::Value* publishers = session_store_json.FindPathOfType(
+      {"ledger", "synopsis", "publishers"},
+      base::Value::Type::DICTIONARY);
+  if (!publishers) {
+    LOG(ERROR) << "\"ledger\".\"synopsis\".\"publishers\" not found in session-store-1";
+    return false;
+  }
+
+  ledger.pinned_publishers = std::map<std::string, unsigned int>();
+  int pin_percentage;
+
+  for (const auto& item : publishers->DictItems()) {
+    const auto& domain = item.first;
+    const auto& settings = item.second;
+
+    if (!settings.is_dict())
+      continue;
+
+    if (TryFindIntKey(&settings, "pinPercentage", pin_percentage)) {
+      if (pin_percentage > 0) {
+        ledger.pinned_publishers.insert(
+          std::pair<std::string, unsigned int>(domain, pin_percentage));
+      }
+    }
+  }
+
+  return true;
+}
+
+void BraveImporter::ImportLedger(bool clobber_wallet) {
   std::unique_ptr<base::Value> session_store_json = ParseBraveStateFile(
       "session-store-1");
   std::unique_ptr<base::Value> ledger_state_json = ParseBraveStateFile(
@@ -379,12 +535,27 @@ void BraveImporter::ImportLedger() {
   if (!(session_store_json && ledger_state_json))
     return;
 
-  auto passphrase = ParseWalletPassphrase(*session_store_json);
-  if (passphrase.empty())
-    return;
-
   BraveLedger ledger;
-  ledger.passphrase = passphrase;
+  ledger.clobber_wallet = clobber_wallet;
+
+  // TODO: this processing might take a while;
+  // is this happening in the browser process?
+
+  if (!ParseWalletPassphrase(ledger, *session_store_json)) {
+    // TODO: ...
+  }
+
+  if (!ParsePaymentsPreferences(ledger, *session_store_json)) {
+    // TODO: ...
+  }
+
+  if (!ParseExcludedSites(ledger, *session_store_json)) {
+    // TODO: ...
+  }
+
+  if (!ParsePinnedSites(ledger, *session_store_json)) {
+    // TODO: ...
+  }
 
   bridge_->UpdateLedger(ledger);
-}
+}

utility/importer/brave_importer.h

@@ -33,8 +33,8 @@ class BraveImporter : public ChromeImporter {
   void ImportBookmarks() override;
   void ImportHistory() override;
   void ImportStats();
-  void ImportLedger();
-  
+  void ImportLedger(bool clobber_wallet=false);
+
   std::unique_ptr<base::Value> ParseBraveStateFile(
     const std::string& filename);