A platform for community discussion. Free, open, simple.
# frozen_string_literal: true
##
# Allows us to query Bookmark records for lists. Used mainly
# in the user/activity/bookmarks page.
class BookmarkQuery
def self.on_preload(&blk)
(@preload ||= Set.new) << blk
end
def self.preload(bookmarks, object)
preload_polymorphic_associations(bookmarks, object.guardian)
@preload.each { |preload| preload.call(bookmarks, object) } if @preload
end
# These polymorphic associations are loaded to make the UserBookmarkListSerializer's
# life easier, which conditionally chooses the bookmark serializer to use based
# on the type, and we want the associations all loaded ahead of time to make
# sure we are not doing N+1s.
def self.preload_polymorphic_associations(bookmarks, guardian)
Bookmark.registered_bookmarkables.each do |registered_bookmarkable|
registered_bookmarkable.perform_preload(bookmarks, guardian)
end
end
attr_reader :guardian
def initialize(user:, guardian: nil, search_term: nil, page: nil, per_page: nil)
@user = user
@search_term = search_term
@guardian = guardian || Guardian.new(@user)
@page = page ? page.to_i : 0
@per_page = per_page ? per_page.to_i : 20
end
def count_all
queries = list_queries
return 0 if queries.empty?
Bookmark.from("(#{queries.join(" UNION ")}) AS bookmarks").count
end
def list_all(&blk)
queries = list_queries
return [] if queries.empty?
results =
Bookmark.from("(#{queries.join(" UNION ")}) AS bookmarks").order(
Arel.sql(
"(CASE WHEN bookmarks.pinned THEN 0 ELSE 1 END), bookmarks.reminder_at ASC, bookmarks.updated_at DESC",
),
)
results = results.offset(@page * @per_page) if @page.positive?
results = blk&.call(results) || results
results = results.limit(@per_page).to_a
BookmarkQuery.preload(results, self)
results
end
def unread_notifications(limit: 20)
notifications = fetch_reminder_notifications(limit)
bookmark_ids = notifications.filter_map { |n| n.data_hash[:bookmark_id] }
bookmarks = Bookmark.where(user: @user, id: bookmark_ids)
BookmarkQuery.preload(bookmarks, self)
bookmarks_by_id = bookmarks.index_by(&:id)
deleted_bookmarkables = load_deleted_bookmarkables(notifications, bookmarks_by_id)
notifications.select do |n|
can_see_notification_bookmark?(n, bookmarks_by_id, deleted_bookmarkables)
end
end
private
def list_queries
@list_queries ||= build_list_queries
end
def build_list_queries
Bookmark.registered_bookmarkables.filter_map do |bookmarkable|
query = bookmarkable.perform_list_query(@user, @guardian)
next if query.nil?
query = apply_search_filter(bookmarkable, query) if @search_term.present?
query.to_sql
end
end
def apply_search_filter(bookmarkable, query)
ts_query = Search.ts_query(term: @search_term)
bookmarkable.perform_search_query(query, "%#{@search_term}%", ts_query)
end
def fetch_reminder_notifications(limit)
Notification
.for_user_menu(@user.id, limit: [limit, 100].min)
.unread
.where(notification_type: Notification.types[:bookmark_reminder])
end
def load_deleted_bookmarkables(notifications, bookmarks_by_id)
notifications
.select do |n|
data = n.data_hash
data[:bookmark_id].present? && data[:bookmarkable_type].present? &&
!bookmarks_by_id[data[:bookmark_id]]
end
.group_by { |n| n.data_hash[:bookmarkable_type] }
.transform_values do |notifs|
ids = notifs.map { |n| n.data_hash[:bookmarkable_id] }
type = notifs.first.data_hash[:bookmarkable_type]
Bookmark.registered_bookmarkable_from_type(type).model.where(id: ids).index_by(&:id)
end
end
def can_see_notification_bookmark?(notification, bookmarks_by_id, deleted_bookmarkables)
data = notification.data_hash
return false if data[:bookmark_id].nil?
if bookmark = bookmarks_by_id[data[:bookmark_id]]
Bookmark.registered_bookmarkable_from_type(bookmark.bookmarkable_type).can_see?(
@guardian,
bookmark,
)
else
bookmarkable = deleted_bookmarkables.dig(data[:bookmarkable_type], data[:bookmarkable_id])
bookmarkable &&
Bookmark.registered_bookmarkable_from_type(data[:bookmarkable_type]).can_see_bookmarkable?(
@guardian,
bookmarkable,
)
end
end
end