You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

121 lines
4.8 KiB

  1. # frozen_string_literal: true
  2. require 'singleton'
  3. class FeedManager
  4. include Singleton
  5. MAX_ITEMS = 400
  6. def key(type, id)
  7. "feed:#{type}:#{id}"
  8. end
  9. def filter?(timeline_type, status, receiver_id)
  10. if timeline_type == :home
  11. filter_from_home?(status, receiver_id)
  12. elsif timeline_type == :mentions
  13. filter_from_mentions?(status, receiver_id)
  14. else
  15. false
  16. end
  17. end
  18. def push(timeline_type, account, status)
  19. timeline_key = key(timeline_type, account.id)
  20. if status.reblog?
  21. # If the original status is within 40 statuses from top, do not re-insert it into the feed
  22. rank = redis.zrevrank(timeline_key, status.reblog_of_id)
  23. return if !rank.nil? && rank < 40
  24. redis.zadd(timeline_key, status.id, status.reblog_of_id)
  25. else
  26. redis.zadd(timeline_key, status.id, status.id)
  27. trim(timeline_type, account.id)
  28. end
  29. PushUpdateWorker.perform_async(account.id, status.id)
  30. end
  31. def trim(type, account_id)
  32. return unless redis.zcard(key(type, account_id)) > FeedManager::MAX_ITEMS
  33. last = redis.zrevrange(key(type, account_id), FeedManager::MAX_ITEMS - 1, FeedManager::MAX_ITEMS - 1)
  34. redis.zremrangebyscore(key(type, account_id), '-inf', "(#{last.last}")
  35. end
  36. def merge_into_timeline(from_account, into_account)
  37. timeline_key = key(:home, into_account.id)
  38. query = from_account.statuses.limit(FeedManager::MAX_ITEMS / 4)
  39. if redis.zcard(timeline_key) >= FeedManager::MAX_ITEMS / 4
  40. oldest_home_score = redis.zrange(timeline_key, 0, 0, with_scores: true)&.first&.last&.to_i || 0
  41. query = query.where('id > ?', oldest_home_score)
  42. end
  43. redis.pipelined do
  44. query.each do |status|
  45. next if status.direct_visibility? || filter?(:home, status, into_account)
  46. redis.zadd(timeline_key, status.id, status.id)
  47. end
  48. end
  49. trim(:home, into_account.id)
  50. end
  51. def unmerge_from_timeline(from_account, into_account)
  52. timeline_key = key(:home, into_account.id)
  53. oldest_home_score = redis.zrange(timeline_key, 0, 0, with_scores: true)&.first&.last&.to_i || 0
  54. from_account.statuses.select('id').where('id > ?', oldest_home_score).find_in_batches do |statuses|
  55. redis.pipelined do
  56. statuses.each do |status|
  57. redis.zrem(timeline_key, status.id)
  58. redis.zremrangebyscore(timeline_key, status.id, status.id)
  59. end
  60. end
  61. end
  62. end
  63. private
  64. def redis
  65. Redis.current
  66. end
  67. def filter_from_home?(status, receiver_id)
  68. return true if status.reply? && status.in_reply_to_id.nil?
  69. check_for_mutes = [status.account_id]
  70. check_for_mutes.concat([status.reblog.account_id]) if status.reblog?
  71. return true if Mute.where(account_id: receiver_id, target_account_id: check_for_mutes).any?
  72. check_for_blocks = status.mentions.map(&:account_id)
  73. check_for_blocks.concat([status.reblog.account_id]) if status.reblog?
  74. return true if Block.where(account_id: receiver_id, target_account_id: check_for_blocks).any?
  75. if status.reply? && !status.in_reply_to_account_id.nil? # Filter out if it's a reply
  76. should_filter = !Follow.where(account_id: receiver_id, target_account_id: status.in_reply_to_account_id).exists? # and I'm not following the person it's a reply to
  77. should_filter &&= !(receiver_id == status.in_reply_to_account_id) # and it's not a reply to me
  78. should_filter &&= !(status.account_id == status.in_reply_to_account_id) # and it's not a self-reply
  79. return should_filter
  80. elsif status.reblog? # Filter out a reblog
  81. return Block.where(account_id: status.reblog.account_id, target_account_id: receiver_id).exists? # or if the author of the reblogged status is blocking me
  82. end
  83. false
  84. end
  85. def filter_from_mentions?(status, receiver_id)
  86. check_for_blocks = [status.account_id]
  87. check_for_blocks.concat(status.mentions.pluck(:account_id))
  88. check_for_blocks.concat([status.in_reply_to_account]) if status.reply? && !status.in_reply_to_account_id.nil?
  89. should_filter = receiver_id == status.account_id # Filter if I'm mentioning myself
  90. should_filter ||= Block.where(account_id: receiver_id, target_account_id: check_for_blocks).any? # or it's from someone I blocked, in reply to someone I blocked, or mentioning someone I blocked
  91. should_filter ||= (status.account.silenced? && !Follow.where(account_id: receiver_id, target_account_id: status.account_id).exists?) # of if the account is silenced and I'm not following them
  92. should_filter
  93. end
  94. end