Fix payment "receipts" cashed in between the 1st and 5th of the month…

… do not appear in ad totals

Fixes brave/brave-browser#4330

browser/ui/webui/brave_rewards_ui.cc

@@ -13,6 +13,8 @@
 
 #include "base/base64.h"
 #include "base/memory/weak_ptr.h"
+#include "base/time/time.h"
+#include "base/i18n/time_formatting.h"
 #include "brave/components/brave_ads/browser/ads_service.h"
 #include "brave/components/brave_ads/browser/ads_service_factory.h"
 #include "brave/components/brave_ads/browser/buildflags/buildflags.h"
@@ -105,15 +107,16 @@ class RewardsDOMHandler : public WebUIMessageHandler,
   void OnContentSiteUpdated(
       brave_rewards::RewardsService* rewards_service) override;
   void GetAddressesForPaymentId(const base::ListValue* args);
-  void GetTransactionHistoryForThisCycle(const base::ListValue* args);
+  void GetTransactionHistory(const base::ListValue* args);
   void GetRewardsMainEnabled(const base::ListValue* args);
   void OnGetRewardsMainEnabled(bool enabled);
 
   void GetExcludedPublishersNumber(const base::ListValue* args);
 
-  void OnTransactionHistoryForThisCycle(
-      int ads_notifications_received,
-      double estimated_earnings);
+  void OnTransactionHistory(
+      double estimated_pending_rewards,
+      uint64_t next_payment_date_in_seconds,
+      uint64_t ad_notifications_received_this_month);
 
   void OnGetRecurringTips(
     std::unique_ptr<brave_rewards::ContentSiteList> list);
@@ -162,7 +165,7 @@ class RewardsDOMHandler : public WebUIMessageHandler,
       brave_rewards::RewardsService* rewards_service,
       const brave_rewards::ContentSiteList& list) override;
 
-  void OnTransactionHistoryForThisCycleChanged(
+  void OnTransactionHistoryChanged(
       brave_rewards::RewardsService* rewards_service) override;
 
   void OnRecurringTipSaved(brave_rewards::RewardsService* rewards_service,
@@ -289,8 +292,8 @@ void RewardsDOMHandler::RegisterMessages() {
       base::BindRepeating(&RewardsDOMHandler::GetAddressesForPaymentId,
       base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
-      "brave_rewards.getTransactionHistoryForThisCycle",
-      base::BindRepeating(&RewardsDOMHandler::GetTransactionHistoryForThisCycle,
+      "brave_rewards.getTransactionHistory",
+      base::BindRepeating(&RewardsDOMHandler::GetTransactionHistory,
       base::Unretained(this)));
   web_ui()->RegisterMessageCallback("brave_rewards.getRewardsMainEnabled",
       base::BindRepeating(&RewardsDOMHandler::GetRewardsMainEnabled,
@@ -996,32 +999,45 @@ void RewardsDOMHandler::GetAddressesForPaymentId(
   }
 }
 
-void RewardsDOMHandler::GetTransactionHistoryForThisCycle(
+void RewardsDOMHandler::GetTransactionHistory(
     const base::ListValue* args) {
-  rewards_service_->GetTransactionHistoryForThisCycle(base::Bind(
-      &RewardsDOMHandler::OnTransactionHistoryForThisCycle,
+  rewards_service_->GetTransactionHistory(base::Bind(
+      &RewardsDOMHandler::OnTransactionHistory,
       weak_factory_.GetWeakPtr()));
 }
 
-void RewardsDOMHandler::OnTransactionHistoryForThisCycle(
-    int ads_notifications_received,
-    double estimated_earnings) {
+void RewardsDOMHandler::OnTransactionHistory(
+    double estimated_pending_rewards,
+    uint64_t next_payment_date_in_seconds,
+    uint64_t ad_notifications_received_this_month) {
   if (web_ui()->CanCallJavascript()) {
     base::DictionaryValue history;
 
-    history.SetInteger("adsNotificationsReceived", ads_notifications_received);
-    history.SetDouble("adsEstimatedEarnings", estimated_earnings);
+    history.SetDouble("adsEstimatedPendingRewards",
+        estimated_pending_rewards);
+
+    if (next_payment_date_in_seconds == 0) {
+      history.SetString("adsNextPaymentDate", "");
+    } else {
+      base::Time next_payment_date =
+          base::Time::FromDoubleT(next_payment_date_in_seconds);
+      history.SetString("adsNextPaymentDate",
+          base::TimeFormatWithPattern(next_payment_date, "MMMd"));
+    }
+
+    history.SetInteger("adsAdNotificationsReceivedThisMonth",
+        ad_notifications_received_this_month);
 
     web_ui()->CallJavascriptFunctionUnsafe(
-        "brave_rewards.transactionHistoryForThisCycle", history);
+        "brave_rewards.transactionHistory", history);
   }
 }
 
-void RewardsDOMHandler::OnTransactionHistoryForThisCycleChanged(
+void RewardsDOMHandler::OnTransactionHistoryChanged(
     brave_rewards::RewardsService* rewards_service) {
   if (web_ui()->CanCallJavascript()) {
     web_ui()->CallJavascriptFunctionUnsafe(
-        "brave_rewards.transactionHistoryForThisCycleChanged");
+        "brave_rewards.transactionHistoryChanged");
   }
 }
 

components/brave_ads/browser/ads_service_impl_unittest.cc

@@ -137,8 +137,8 @@ class MockRewardsService : public RewardsService {
       void(brave_rewards::GetRewardsInternalsInfoCallback));
   MOCK_METHOD1(GetAddressesForPaymentId,
       void(const brave_rewards::GetAddressesCallback&));
-  MOCK_METHOD1(GetTransactionHistoryForThisCycle,
-      void(brave_rewards::GetTransactionHistoryForThisCycleCallback));
+  MOCK_METHOD1(GetTransactionHistory,
+      void(brave_rewards::GetTransactionHistoryCallback));
   MOCK_METHOD2(SaveRecurringTip, void(const std::string&, const int));
   MOCK_METHOD2(RefreshPublisher, void(const std::string&,
                                       brave_rewards::RefreshPublisherCallback));

components/brave_rewards/browser/rewards_service.h

@@ -69,8 +69,8 @@ using GetReconcileStampCallback = base::Callback<void(uint64_t)>;
 using IsWalletCreatedCallback = base::Callback<void(bool)>;
 using GetPendingContributionsTotalCallback = base::Callback<void(double)>;
 using GetRewardsMainEnabledCallback = base::Callback<void(bool)>;
-using GetTransactionHistoryForThisCycleCallback =
-    base::Callback<void(int, double)>;
+using GetTransactionHistoryCallback =
+    base::OnceCallback<void(double, uint64_t, uint64_t)>;
 using GetRewardsInternalsInfoCallback = base::OnceCallback<void(
     std::unique_ptr<brave_rewards::RewardsInternalsInfo>)>;
 using GetRecurringTipsCallback = base::OnceCallback<void(
@@ -191,8 +191,8 @@ class RewardsService : public KeyedService {
 
   virtual void GetAddressesForPaymentId(
       const GetAddressesCallback& callback) = 0;
-  virtual void GetTransactionHistoryForThisCycle(
-      GetTransactionHistoryForThisCycleCallback callback) = 0;
+  virtual void GetTransactionHistory(
+      GetTransactionHistoryCallback callback) = 0;
 
   virtual void RefreshPublisher(
       const std::string& publisher_key,

components/brave_rewards/browser/rewards_service_impl.cc

@@ -1550,44 +1550,29 @@ void RewardsServiceImpl::SetConfirmationsIsReady(const bool is_ready) {
 
 void RewardsServiceImpl::ConfirmationsTransactionHistoryDidChange() {
     for (auto& observer : observers_)
-    observer.OnTransactionHistoryForThisCycleChanged(this);
+    observer.OnTransactionHistoryChanged(this);
 }
 
-void RewardsServiceImpl::GetTransactionHistoryForThisCycle(
-    GetTransactionHistoryForThisCycleCallback callback) {
+void RewardsServiceImpl::GetTransactionHistory(
+    GetTransactionHistoryCallback callback) {
   if (!Connected()) {
     return;
   }
 
-  bat_ledger_->GetTransactionHistoryForThisCycle(
-      base::BindOnce(&RewardsServiceImpl::OnGetTransactionHistoryForThisCycle,
+  bat_ledger_->GetTransactionHistory(
+      base::BindOnce(&RewardsServiceImpl::OnGetTransactionHistory,
           AsWeakPtr(), std::move(callback)));
 }
 
-void RewardsServiceImpl::OnGetTransactionHistoryForThisCycle(
-    GetTransactionHistoryForThisCycleCallback callback,
+void RewardsServiceImpl::OnGetTransactionHistory(
+    GetTransactionHistoryCallback callback,
     const std::string& transactions) {
-  if (transactions.empty()) {
-    callback.Run(0, 0.0);
-    return;
-  }
-
   ledger::TransactionsInfo info;
   info.FromJson(transactions);
 
-  int ads_notifications_received = 0;
-  double estimated_earnings = 0.0;
-
-  for (const auto& transaction : info.transactions) {
-    if (transaction.estimated_redemption_value == 0.0) {
-      continue;
-    }
-
-    ads_notifications_received++;
-    estimated_earnings += transaction.estimated_redemption_value;
-  }
-
-  callback.Run(ads_notifications_received, estimated_earnings);
+  std::move(callback).Run(info.estimated_pending_rewards,
+      info.next_payment_date_in_seconds,
+      info.ad_notifications_received_this_month);
 }
 
 void RewardsServiceImpl::SaveState(const std::string& name,

components/brave_rewards/browser/rewards_service_impl.h

@@ -367,8 +367,8 @@ class RewardsServiceImpl : public RewardsService,
   void SetCatalogIssuers(const std::string& json) override;
   void ConfirmAd(const std::string& json) override;
   void SetConfirmationsIsReady(const bool is_ready) override;
-  void GetTransactionHistoryForThisCycle(
-      GetTransactionHistoryForThisCycleCallback callback) override;
+  void GetTransactionHistory(
+      GetTransactionHistoryCallback callback) override;
   void ConfirmationsTransactionHistoryDidChange() override;
 
   void OnExcludedSitesChanged(const std::string& publisher_id,
@@ -451,8 +451,8 @@ class RewardsServiceImpl : public RewardsService,
   void ShowNotificationTipsPaid(bool ac_enabled);
 
   // Mojo Proxy methods
-  void OnGetTransactionHistoryForThisCycle(
-      GetTransactionHistoryForThisCycleCallback callback,
+  void OnGetTransactionHistory(
+      GetTransactionHistoryCallback callback,
       const std::string& transactions);
   void OnGetAllBalanceReports(
       const GetAllBalanceReportsCallback& callback,

components/brave_rewards/browser/rewards_service_observer.h

@@ -70,7 +70,7 @@ class RewardsServiceObserver : public base::CheckedObserver {
   virtual void OnPublisherListNormalized(
       RewardsService* rewards_service,
       const brave_rewards::ContentSiteList& list) {}
-  virtual void OnTransactionHistoryForThisCycleChanged(
+  virtual void OnTransactionHistoryChanged(
       brave_rewards::RewardsService* rewards_service) {}
   virtual void OnRecurringTipSaved(
       brave_rewards::RewardsService* rewards_service,

components/brave_rewards/resources/ui/actions/rewards_actions.ts

@@ -175,14 +175,14 @@ export const onAddressesForPaymentId = (addresses: Record<Rewards.AddressesType,
     addresses
   })
 
-export const onTransactionHistoryForThisCycle = (data: {adsNotificationsReceived: number, adsEstimatedEarnings: number}) =>
-  action(types.ON_TRANSACTION_HISTORY_FOR_THIS_CYCLE, {
+export const onTransactionHistory = (data: {adsEstimatedPendingRewards: number, adsNextPaymentDate: string, adsNotificationsReceivedThisMonth: number}) =>
+  action(types.ON_TRANSACTION_HISTORY, {
     data
   })
 
-export const getTransactionHistoryForThisCycle = () => action(types.GET_TRANSACTION_HISTORY_FOR_THIS_CYCLE)
+export const getTransactionHistory = () => action(types.GET_TRANSACTION_HISTORY)
 
-export const onTransactionHistoryForThisCycleChanged = () => action(types.ON_TRANSACTION_HISTORY_FOR_THIS_CYCLE_CHANGED)
+export const onTransactionHistoryChanged = () => action(types.ON_TRANSACTION_HISTORY_CHANGED)
 
 export const getExcludedPublishersNumber = () => action(types.GET_EXCLUDED_PUBLISHERS_NUMBER)
 

components/brave_rewards/resources/ui/brave_rewards.tsx

@@ -147,12 +147,12 @@ window.cr.define('brave_rewards', function () {
     getActions().onAddressesForPaymentId(addresses)
   }
 
-  function transactionHistoryForThisCycle (totalPages: number, estimatedEarnings: number) {
-    getActions().onTransactionHistoryForThisCycle(totalPages, estimatedEarnings)
+  function transactionHistory (data: {adsEstimatedPendingRewards: number, adsNextPaymentDate: string, adsNotificationsReceivedThisMonth: number}) {
+    getActions().onTransactionHistory(data)
   }
 
-  function transactionHistoryForThisCycleChanged () {
-    getActions().onTransactionHistoryForThisCycleChanged()
+  function transactionHistoryChanged () {
+    getActions().onTransactionHistoryChanged()
   }
 
   function recurringTipSaved (success: boolean) {
@@ -193,8 +193,8 @@ window.cr.define('brave_rewards', function () {
     onPendingContributionSaved,
     rewardsEnabled,
     addressesForPaymentId,
-    transactionHistoryForThisCycle,
-    transactionHistoryForThisCycleChanged,
+    transactionHistory,
+    transactionHistoryChanged,
     recurringTipSaved,
     recurringTipRemoved,
     onContributionSaved

components/brave_rewards/resources/ui/components/adsBox.tsx

@@ -115,9 +115,10 @@ class AdsBox extends React.Component<Props, State> {
     // Default values from storage.ts
     let adsEnabled = false
     let adsUIEnabled = false
-    let notificationsReceived = 0
-    let estimatedEarnings = '0'
     let adsIsSupported = false
+    let estimatedPendingRewards = '0'
+    let nextPaymentDate = ''
+    let adNotificationsReceivedThisMonth = 0
 
     const {
       adsData,
@@ -129,9 +130,10 @@ class AdsBox extends React.Component<Props, State> {
     if (adsData) {
       adsEnabled = adsData.adsEnabled
       adsUIEnabled = adsData.adsUIEnabled
-      notificationsReceived = adsData.adsNotificationsReceived || 0
-      estimatedEarnings = (adsData.adsEstimatedEarnings || 0).toFixed(2)
       adsIsSupported = adsData.adsIsSupported
+      estimatedPendingRewards = (adsData.adsEstimatedPendingRewards || 0).toFixed(2)
+      nextPaymentDate = adsData.adsNextPaymentDate
+      adNotificationsReceivedThisMonth = adsData.adsAdNotificationsReceivedThisMonth || 0
     }
 
     const enabled = adsEnabled && adsIsSupported
@@ -155,18 +157,18 @@ class AdsBox extends React.Component<Props, State> {
       >
         <List title={getLocale('adsCurrentEarnings')}>
           <Tokens
-            value={estimatedEarnings}
-            converted={utils.convertBalance(estimatedEarnings, walletInfo.rates)}
+            value={estimatedPendingRewards}
+            converted={utils.convertBalance(estimatedPendingRewards, walletInfo.rates)}
           />
         </List>
         <List title={getLocale('adsPaymentDate')}>
           <NextContribution>
-            {'Monthly, 5th'}
+            {nextPaymentDate}
           </NextContribution>
         </List>
         <List title={getLocale('adsNotificationsReceived')}>
           <Tokens
-            value={notificationsReceived.toString()}
+            value={adNotificationsReceivedThisMonth.toString()}
             hideText={true}
           />
         </List>

components/brave_rewards/resources/ui/components/settingsPage.tsx

@@ -38,7 +38,7 @@ class SettingsPage extends React.Component<Props, {}> {
     this.actions.getContributeList()
     this.actions.getPendingContributionsTotal()
     this.actions.getReconcileStamp()
-    this.actions.getTransactionHistoryForThisCycle()
+    this.actions.getTransactionHistory()
     this.actions.getExcludedPublishersNumber()
     this.actions.getAdsData()
   }

components/brave_rewards/resources/ui/constants/rewards_types.ts

@@ -54,9 +54,9 @@ export const enum types {
   ON_REWARDS_ENABLED = '@@rewards/ON_REWARDS_ENABLED',
   GET_ADDRESSES_FOR_PAYMENT_ID = '@@rewards/GET_ADDRESSES_FOR_PAYMENT_ID',
   ON_ADDRESSES_FOR_PAYMENT_ID = '@@rewards/ON_ADDRESSES_FOR_PAYMENT_ID',
-  GET_TRANSACTION_HISTORY_FOR_THIS_CYCLE = '@@rewards/GET_TRANSACTION_HISTORY_FOR_THIS_CYCLE',
-  ON_TRANSACTION_HISTORY_FOR_THIS_CYCLE = '@@rewards/ON_TRANSACTION_HISTORY_FOR_THIS_CYCLE',
-  ON_TRANSACTION_HISTORY_FOR_THIS_CYCLE_CHANGED = '@@rewards/ON_TRANSACTION_HISTORY_FOR_THIS_CYCLE_CHANGED',
+  GET_TRANSACTION_HISTORY = '@@rewards/GET_TRANSACTION_HISTORY',
+  ON_TRANSACTION_HISTORY = '@@rewards/ON_TRANSACTION_HISTORY',
+  ON_TRANSACTION_HISTORY_CHANGED = '@@rewards/ON_TRANSACTION_HISTORY_CHANGED',
   GET_EXCLUDED_PUBLISHERS_NUMBER = '@@rewards/GET_EXCLUDED_PUBLISHERS_NUMBER',
   GET_REWARDS_MAIN_ENABLED = '@@rewards/GET_REWARDS_MAIN_ENABLED',
   ON_RECURRING_TIP_SAVED = '@@rewards/ON_RECURRING_TIP_SAVED',

components/brave_rewards/resources/ui/reducers/rewards_reducer.ts

@@ -149,12 +149,12 @@ const rewardsReducer: Reducer<Rewards.State | undefined> = (state: Rewards.State
       state.enabledMain = action.payload.enabled
       break
     }
-    case types.GET_TRANSACTION_HISTORY_FOR_THIS_CYCLE:
-    case types.ON_TRANSACTION_HISTORY_FOR_THIS_CYCLE_CHANGED: {
-      chrome.send('brave_rewards.getTransactionHistoryForThisCycle', [])
+    case types.GET_TRANSACTION_HISTORY:
+    case types.ON_TRANSACTION_HISTORY_CHANGED: {
+      chrome.send('brave_rewards.getTransactionHistory', [])
       break
     }
-    case types.ON_TRANSACTION_HISTORY_FOR_THIS_CYCLE: {
+    case types.ON_TRANSACTION_HISTORY: {
       if (!action.payload.data) {
         break
       }
@@ -166,8 +166,9 @@ const rewardsReducer: Reducer<Rewards.State | undefined> = (state: Rewards.State
       }
 
       const data = action.payload.data
-      state.adsData.adsNotificationsReceived = data.adsNotificationsReceived
-      state.adsData.adsEstimatedEarnings = data.adsEstimatedEarnings
+      state.adsData.adsEstimatedPendingRewards = data.adsEstimatedPendingRewards
+      state.adsData.adsNextPaymentDate = data.adsNextPaymentDate
+      state.adsData.adsAdNotificationsReceivedThisMonth = data.adsAdNotificationsReceivedThisMonth
       break
     }
     case types.GET_REWARDS_MAIN_ENABLED: {

components/brave_rewards/resources/ui/storage.ts

@@ -53,9 +53,10 @@ export const defaultState: Rewards.State = {
     adsEnabled: false,
     adsPerHour: 0,
     adsUIEnabled: false,
-    adsNotificationsReceived: 0,
-    adsEstimatedEarnings: 0,
-    adsIsSupported: false
+    adsIsSupported: false,
+    adsEstimatedPendingRewards: 0,
+    adsNextPaymentDate: '',
+    adsAdNotificationsReceivedThisMonth: 0
   },
   pendingContributionTotal: 0,
   grants: [],

components/definitions/rewards.d.ts

@@ -153,9 +153,10 @@ declare namespace Rewards {
     adsEnabled: boolean
     adsPerHour: number
     adsUIEnabled: boolean
-    adsNotificationsReceived: number
-    adsEstimatedEarnings: number
     adsIsSupported: boolean
+    adsEstimatedPendingRewards: number
+    adsNextPaymentDate: string
+    adsAdNotificationsReceivedThisMonth: number
   }
 
   export enum Category {