Add notification policies and notification requests (#29366)

app/models/concerns/account/associations.rb

@@ -15,10 +15,15 @@ module Account::Associations
     has_many :favourites, inverse_of: :account, dependent: :destroy
     has_many :bookmarks, inverse_of: :account, dependent: :destroy
     has_many :mentions, inverse_of: :account, dependent: :destroy
-    has_many :notifications, inverse_of: :account, dependent: :destroy
     has_many :conversations, class_name: 'AccountConversation', dependent: :destroy, inverse_of: :account
     has_many :scheduled_statuses, inverse_of: :account, dependent: :destroy
 
+    # Notifications
+    has_many :notifications, inverse_of: :account, dependent: :destroy
+    has_one :notification_policy, inverse_of: :account, dependent: :destroy
+    has_many :notification_permissions, inverse_of: :account, dependent: :destroy
+    has_many :notification_requests, inverse_of: :account, dependent: :destroy
+
     # Pinned statuses
     has_many :status_pins, inverse_of: :account, dependent: :destroy
     has_many :pinned_statuses, -> { reorder('status_pins.created_at DESC') }, through: :status_pins, class_name: 'Status', source: :status

app/models/notification.rb

@@ -12,6 +12,7 @@
 #  account_id      :bigint(8)        not null
 #  from_account_id :bigint(8)        not null
 #  type            :string
+#  filtered        :boolean          default(FALSE), not null
 #
 
 class Notification < ApplicationRecord
@@ -89,7 +90,7 @@ class Notification < ApplicationRecord
   end
 
   class << self
-    def browserable(types: [], exclude_types: [], from_account_id: nil)
+    def browserable(types: [], exclude_types: [], from_account_id: nil, include_filtered: false)
       requested_types = if types.empty?
                           TYPES
                         else
@@ -99,6 +100,7 @@ class Notification < ApplicationRecord
       requested_types -= exclude_types.map(&:to_sym)
 
       all.tap do |scope|
+        scope.merge!(where(filtered: false)) unless include_filtered || from_account_id.present?
         scope.merge!(where(from_account_id: from_account_id)) if from_account_id.present?
         scope.merge!(where(type: requested_types)) unless requested_types.size == TYPES.size
       end
@@ -144,6 +146,8 @@ class Notification < ApplicationRecord
   after_initialize :set_from_account
   before_validation :set_from_account
 
+  after_destroy :remove_from_notification_request
+
   private
 
   def set_from_account
@@ -158,4 +162,9 @@ class Notification < ApplicationRecord
       self.from_account_id = activity&.id
     end
   end
+
+  def remove_from_notification_request
+    notification_request = NotificationRequest.find_by(account_id: account_id, from_account_id: from_account_id)
+    notification_request&.reconsider_existence!
+  end
 end

app/models/notification_permission.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: notification_permissions
+#
+#  id              :bigint(8)        not null, primary key
+#  account_id      :bigint(8)        not null
+#  from_account_id :bigint(8)        not null
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#
+class NotificationPermission < ApplicationRecord
+  belongs_to :account
+  belongs_to :from_account, class_name: 'Account'
+end

app/models/notification_policy.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: notification_policies
+#
+#  id                      :bigint(8)        not null, primary key
+#  account_id              :bigint(8)        not null
+#  filter_not_following    :boolean          default(FALSE), not null
+#  filter_not_followers    :boolean          default(FALSE), not null
+#  filter_new_accounts     :boolean          default(FALSE), not null
+#  filter_private_mentions :boolean          default(TRUE), not null
+#  created_at              :datetime         not null
+#  updated_at              :datetime         not null
+#
+
+class NotificationPolicy < ApplicationRecord
+  belongs_to :account
+
+  has_many :notification_requests, primary_key: :account_id, foreign_key: :account_id, dependent: nil, inverse_of: false
+
+  attr_reader :pending_requests_count, :pending_notifications_count
+
+  MAX_MEANINGFUL_COUNT = 100
+
+  def summarize!
+    @pending_requests_count = pending_notification_requests.first
+    @pending_notifications_count = pending_notification_requests.last
+  end
+
+  private
+
+  def pending_notification_requests
+    @pending_notification_requests ||= notification_requests.where(dismissed: false).limit(MAX_MEANINGFUL_COUNT).pick(Arel.sql('count(*), coalesce(sum(notifications_count), 0)::bigint'))
+  end
+end

app/models/notification_request.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: notification_requests
+#
+#  id                  :bigint(8)        not null, primary key
+#  account_id          :bigint(8)        not null
+#  from_account_id     :bigint(8)        not null
+#  last_status_id      :bigint(8)        not null
+#  notifications_count :bigint(8)        default(0), not null
+#  dismissed           :boolean          default(FALSE), not null
+#  created_at          :datetime         not null
+#  updated_at          :datetime         not null
+#
+
+class NotificationRequest < ApplicationRecord
+  include Paginable
+
+  MAX_MEANINGFUL_COUNT = 100
+
+  belongs_to :account
+  belongs_to :from_account, class_name: 'Account'
+  belongs_to :last_status, class_name: 'Status'
+
+  before_save :prepare_notifications_count
+
+  def self.preload_cache_collection(requests)
+    cached_statuses_by_id = yield(requests.filter_map(&:last_status)).index_by(&:id) # Call cache_collection in block
+
+    requests.each do |request|
+      request.last_status = cached_statuses_by_id[request.last_status_id] unless request.last_status_id.nil?
+    end
+  end
+
+  def reconsider_existence!
+    return if dismissed?
+
+    prepare_notifications_count
+
+    if notifications_count.positive?
+      save
+    else
+      destroy
+    end
+  end
+
+  private
+
+  def prepare_notifications_count
+    self.notifications_count = Notification.where(account: account, from_account: from_account).limit(MAX_MEANINGFUL_COUNT).count
+  end
+end