@ -0,0 +1,53 @@ | |||
# frozen_string_literal: true | |||
module Admin | |||
class FollowRecommendationsController < BaseController | |||
before_action :set_language | |||
def show | |||
authorize :follow_recommendation, :show? | |||
@form = Form::AccountBatch.new | |||
@accounts = filtered_follow_recommendations | |||
end | |||
def update | |||
@form = Form::AccountBatch.new(form_account_batch_params.merge(current_account: current_account, action: action_from_button)) | |||
@form.save | |||
rescue ActionController::ParameterMissing | |||
# Do nothing | |||
ensure | |||
redirect_to admin_follow_recommendations_path(filter_params) | |||
end | |||
private | |||
def set_language | |||
@language = follow_recommendation_filter.language | |||
end | |||
def filtered_follow_recommendations | |||
follow_recommendation_filter.results | |||
end | |||
def follow_recommendation_filter | |||
@follow_recommendation_filter ||= FollowRecommendationFilter.new(filter_params) | |||
end | |||
def form_account_batch_params | |||
params.require(:form_account_batch).permit(:action, account_ids: []) | |||
end | |||
def filter_params | |||
params.slice(*FollowRecommendationFilter::KEYS).permit(*FollowRecommendationFilter::KEYS) | |||
end | |||
def action_from_button | |||
if params[:suppress] | |||
'suppress_follow_recommendation' | |||
elsif params[:unsuppress] | |||
'unsuppress_follow_recommendation' | |||
end | |||
end | |||
end | |||
end |
@ -0,0 +1,19 @@ | |||
# frozen_string_literal: true | |||
class Api::V2::SuggestionsController < Api::BaseController | |||
include Authorization | |||
before_action -> { doorkeeper_authorize! :read } | |||
before_action :require_user! | |||
before_action :set_suggestions | |||
def index | |||
render json: @suggestions, each_serializer: REST::SuggestionSerializer | |||
end | |||
private | |||
def set_suggestions | |||
@suggestions = AccountSuggestions.get(current_account, limit_param(DEFAULT_ACCOUNTS_LIMIT)) | |||
end | |||
end |
@ -0,0 +1,17 @@ | |||
# frozen_string_literal: true | |||
class AccountSuggestions | |||
class Suggestion < ActiveModelSerializers::Model | |||
attributes :account, :source | |||
end | |||
def self.get(account, limit) | |||
suggestions = PotentialFriendshipTracker.get(account, limit).map { |target_account| Suggestion.new(account: target_account, source: :past_interaction) } | |||
suggestions.concat(FollowRecommendation.get(account, limit - suggestions.size, suggestions.map { |suggestion| suggestion.account.id }).map { |target_account| Suggestion.new(account: target_account, source: :global) }) if suggestions.size < limit | |||
suggestions | |||
end | |||
def self.remove(account, target_account_id) | |||
PotentialFriendshipTracker.remove(account.id, target_account_id) | |||
end | |||
end |
@ -0,0 +1,25 @@ | |||
# frozen_string_literal: true | |||
# == Schema Information | |||
# | |||
# Table name: account_summaries | |||
# | |||
# account_id :bigint(8) primary key | |||
# language :string | |||
# sensitive :boolean | |||
# | |||
class AccountSummary < ApplicationRecord | |||
self.primary_key = :account_id | |||
scope :safe, -> { where(sensitive: false) } | |||
scope :localized, ->(locale) { where(language: locale) } | |||
scope :filtered, -> { joins(arel_table.join(FollowRecommendationSuppression.arel_table, Arel::Nodes::OuterJoin).on(arel_table[:account_id].eq(FollowRecommendationSuppression.arel_table[:account_id])).join_sources).where(FollowRecommendationSuppression.arel_table[:id].eq(nil)) } | |||
def self.refresh | |||
Scenic.database.refresh_materialized_view(table_name, concurrently: true, cascade: false) | |||
end | |||
def readonly? | |||
true | |||
end | |||
end |
@ -0,0 +1,39 @@ | |||
# frozen_string_literal: true | |||
# == Schema Information | |||
# | |||
# Table name: follow_recommendations | |||
# | |||
# account_id :bigint(8) primary key | |||
# rank :decimal(, ) | |||
# reason :text is an Array | |||
# | |||
class FollowRecommendation < ApplicationRecord | |||
self.primary_key = :account_id | |||
belongs_to :account_summary, foreign_key: :account_id | |||
belongs_to :account, foreign_key: :account_id | |||
scope :safe, -> { joins(:account_summary).merge(AccountSummary.safe) } | |||
scope :localized, ->(locale) { joins(:account_summary).merge(AccountSummary.localized(locale)) } | |||
scope :filtered, -> { joins(:account_summary).merge(AccountSummary.filtered) } | |||
def readonly? | |||
true | |||
end | |||
def self.get(account, limit, exclude_account_ids = []) | |||
account_ids = Redis.current.zrevrange("follow_recommendations:#{account.user_locale}", 0, -1).map(&:to_i) - exclude_account_ids - [account.id] | |||
return [] if account_ids.empty? || limit < 1 | |||
accounts = Account.followable_by(account) | |||
.not_excluded_by_account(account) | |||
.not_domain_blocked_by_account(account) | |||
.where(id: account_ids) | |||
.limit(limit) | |||
.index_by(&:id) | |||
account_ids.map { |id| accounts[id] }.compact | |||
end | |||
end |
@ -0,0 +1,26 @@ | |||
# frozen_string_literal: true | |||
class FollowRecommendationFilter | |||
KEYS = %i( | |||
language | |||
status | |||
).freeze | |||
attr_reader :params, :language | |||
def initialize(params) | |||
@language = params.delete('language') || I18n.locale | |||
@params = params | |||
end | |||
def results | |||
if params['status'] == 'suppressed' | |||
Account.joins(:follow_recommendation_suppression).order(FollowRecommendationSuppression.arel_table[:id].desc).to_a | |||
else | |||
account_ids = Redis.current.zrevrange("follow_recommendations:#{@language}", 0, -1).map(&:to_i) | |||
accounts = Account.where(id: account_ids).index_by(&:id) | |||
account_ids.map { |id| accounts[id] }.compact | |||
end | |||
end | |||
end |
@ -0,0 +1,28 @@ | |||
# frozen_string_literal: true | |||
# == Schema Information | |||
# | |||
# Table name: follow_recommendation_suppressions | |||
# | |||
# id :bigint(8) not null, primary key | |||
# account_id :bigint(8) not null | |||
# created_at :datetime not null | |||
# updated_at :datetime not null | |||
# | |||
class FollowRecommendationSuppression < ApplicationRecord | |||
include Redisable | |||
belongs_to :account | |||
after_commit :remove_follow_recommendations, on: :create | |||
private | |||
def remove_follow_recommendations | |||
redis.pipelined do | |||
I18n.available_locales.each do |locale| | |||
redis.zrem("follow_recommendations:#{locale}", account_id) | |||
end | |||
end | |||
end | |||
end |
@ -0,0 +1,15 @@ | |||
# frozen_string_literal: true | |||
class FollowRecommendationPolicy < ApplicationPolicy | |||
def show? | |||
staff? | |||
end | |||
def suppress? | |||
staff? | |||
end | |||
def unsuppress? | |||
staff? | |||
end | |||
end |
@ -0,0 +1,7 @@ | |||
# frozen_string_literal: true | |||
class REST::SuggestionSerializer < ActiveModel::Serializer | |||
attributes :source | |||
has_one :account, serializer: REST::AccountSerializer | |||
end |
@ -0,0 +1,20 @@ | |||
.batch-table__row | |||
%label.batch-table__row__select.batch-table__row__select--aligned.batch-checkbox | |||
= f.check_box :account_ids, { multiple: true, include_hidden: false }, account.id | |||
.batch-table__row__content.batch-table__row__content--unpadded | |||
%table.accounts-table | |||
%tbody | |||
%tr | |||
%td= account_link_to account | |||
%td.accounts-table__count.optional | |||
= number_to_human account.statuses_count, strip_insignificant_zeros: true | |||
%small= t('accounts.posts', count: account.statuses_count).downcase | |||
%td.accounts-table__count.optional | |||
= number_to_human account.followers_count, strip_insignificant_zeros: true | |||
%small= t('accounts.followers', count: account.followers_count).downcase | |||
%td.accounts-table__count | |||
- if account.last_status_at.present? | |||
%time.time-ago{ datetime: account.last_status_at.to_date.iso8601, title: l(account.last_status_at.to_date) }= l account.last_status_at | |||
- else | |||
\- | |||
%small= t('accounts.last_active') |
@ -0,0 +1,42 @@ | |||
- content_for :page_title do | |||
= t('admin.follow_recommendations.title') | |||
- content_for :header_tags do | |||
= javascript_pack_tag 'admin', async: true, crossorigin: 'anonymous' | |||
.simple_form | |||
%p.hint= t('admin.follow_recommendations.description_html') | |||
%hr.spacer/ | |||
= form_tag admin_follow_recommendations_path, method: 'GET', class: 'simple_form' do | |||
.filters | |||
.filter-subset.filter-subset--with-select | |||
%strong= t('admin.follow_recommendations.language') | |||
.input.select.optional | |||
= select_tag :language, options_for_select(I18n.available_locales.map { |key| [human_locale(key), key]}, @language) | |||
.filter-subset | |||
%strong= t('admin.follow_recommendations.status') | |||
%ul | |||
%li= filter_link_to t('admin.accounts.moderation.active'), status: nil | |||
%li= filter_link_to t('admin.follow_recommendations.suppressed'), status: 'suppressed' | |||
= form_for(@form, url: admin_follow_recommendations_path, method: :patch) do |f| | |||
- RelationshipFilter::KEYS.each do |key| | |||
= hidden_field_tag key, params[key] if params[key].present? | |||
.batch-table | |||
.batch-table__toolbar | |||
%label.batch-table__toolbar__select.batch-checkbox-all | |||
= check_box_tag :batch_checkbox_all, nil, false | |||
.batch-table__toolbar__actions | |||
- if params[:status].blank? && can?(:suppress, :follow_recommendation) | |||
= f.button safe_join([fa_icon('times'), t('admin.follow_recommendations.suppress')]), name: :suppress, class: 'table-action-link', type: :submit, data: { confirm: t('admin.reports.are_you_sure') } | |||
- if params[:status] == 'suppressed' && can?(:unsuppress, :follow_recommendation) | |||
= f.button safe_join([fa_icon('plus'), t('admin.follow_recommendations.unsuppress')]), name: :unsuppress, class: 'table-action-link', type: :submit | |||
.batch-table__body | |||
- if @accounts.empty? | |||
= nothing_here 'nothing-here--under-tabs' | |||
- else | |||
= render partial: 'account', collection: @accounts, locals: { f: f } |
@ -0,0 +1,61 @@ | |||
# frozen_string_literal: true | |||
class Scheduler::FollowRecommendationsScheduler | |||
include Sidekiq::Worker | |||
include Redisable | |||
sidekiq_options retry: 0 | |||
# The maximum number of accounts that can be requested in one page from the | |||
# API is 80, and the suggestions API does not allow pagination. This number | |||
# leaves some room for accounts being filtered during live access | |||
SET_SIZE = 100 | |||
def perform | |||
# Maintaining a materialized view speeds-up subsequent queries significantly | |||
AccountSummary.refresh | |||
fallback_recommendations = FollowRecommendation.safe.filtered.limit(SET_SIZE).index_by(&:account_id) | |||
I18n.available_locales.each do |locale| | |||
recommendations = begin | |||
if AccountSummary.safe.filtered.localized(locale).exists? # We can skip the work if no accounts with that language exist | |||
FollowRecommendation.safe.filtered.localized(locale).limit(SET_SIZE).index_by(&:account_id) | |||
else | |||
{} | |||
end | |||
end | |||
# Use language-agnostic results if there are not enough language-specific ones | |||
missing = SET_SIZE - recommendations.keys.size | |||
if missing.positive? | |||
added = 0 | |||
# Avoid duplicate results | |||
fallback_recommendations.each_value do |recommendation| | |||
next if recommendations.key?(recommendation.account_id) | |||
recommendations[recommendation.account_id] = recommendation | |||
added += 1 | |||
break if added >= missing | |||
end | |||
end | |||
redis.pipelined do | |||
redis.del(key(locale)) | |||
recommendations.each_value do |recommendation| | |||
redis.zadd(key(locale), recommendation.rank, recommendation.account_id) | |||
end | |||
end | |||
end | |||
end | |||
private | |||
def key(locale) | |||
"follow_recommendations:#{locale}" | |||
end | |||
end |
@ -0,0 +1,9 @@ | |||
class CreateAccountSummaries < ActiveRecord::Migration[5.2] | |||
def change | |||
create_view :account_summaries, materialized: true | |||
# To be able to refresh the view concurrently, | |||
# at least one unique index is required | |||
safety_assured { add_index :account_summaries, :account_id, unique: true } | |||
end | |||
end |
@ -0,0 +1,5 @@ | |||
class CreateFollowRecommendations < ActiveRecord::Migration[5.2] | |||
def change | |||
create_view :follow_recommendations | |||
end | |||
end |
@ -0,0 +1,9 @@ | |||
class CreateFollowRecommendationSuppressions < ActiveRecord::Migration[6.1] | |||
def change | |||
create_table :follow_recommendation_suppressions do |t| | |||
t.references :account, null: false, foreign_key: { on_delete: :cascade }, index: { unique: true } | |||
t.timestamps | |||
end | |||
end | |||
end |
@ -0,0 +1,22 @@ | |||
SELECT | |||
accounts.id AS account_id, | |||
mode() WITHIN GROUP (ORDER BY language ASC) AS language, | |||
mode() WITHIN GROUP (ORDER BY sensitive ASC) AS sensitive | |||
FROM accounts | |||
CROSS JOIN LATERAL ( | |||
SELECT | |||
statuses.account_id, | |||
statuses.language, | |||
statuses.sensitive | |||
FROM statuses | |||
WHERE statuses.account_id = accounts.id | |||
AND statuses.deleted_at IS NULL | |||
ORDER BY statuses.id DESC | |||
LIMIT 20 | |||
) t0 | |||
WHERE accounts.suspended_at IS NULL | |||
AND accounts.silenced_at IS NULL | |||
AND accounts.moved_to_account_id IS NULL | |||
AND accounts.discoverable = 't' | |||
AND accounts.locked = 'f' | |||
GROUP BY accounts.id |
@ -0,0 +1,38 @@ | |||
SELECT | |||
account_id, | |||
sum(rank) AS rank, | |||
array_agg(reason) AS reason | |||
FROM ( | |||
SELECT | |||
accounts.id AS account_id, | |||
count(follows.id) / (1.0 + count(follows.id)) AS rank, | |||
'most_followed' AS reason | |||
FROM follows | |||
INNER JOIN accounts ON accounts.id = follows.target_account_id | |||
INNER JOIN users ON users.account_id = follows.account_id | |||
WHERE users.current_sign_in_at >= (now() - interval '30 days') | |||
AND accounts.suspended_at IS NULL | |||
AND accounts.moved_to_account_id IS NULL | |||
AND accounts.silenced_at IS NULL | |||
AND accounts.locked = 'f' | |||
AND accounts.discoverable = 't' | |||
GROUP BY accounts.id | |||
HAVING count(follows.id) >= 5 | |||
UNION ALL | |||
SELECT accounts.id AS account_id, | |||
sum(reblogs_count + favourites_count) / (1.0 + sum(reblogs_count + favourites_count)) AS rank, | |||
'most_interactions' AS reason | |||
FROM status_stats | |||
INNER JOIN statuses ON statuses.id = status_stats.status_id | |||
INNER JOIN accounts ON accounts.id = statuses.account_id | |||
WHERE statuses.id >= ((date_part('epoch', now() - interval '30 days') * 1000)::bigint << 16) | |||
AND accounts.suspended_at IS NULL | |||
AND accounts.moved_to_account_id IS NULL | |||
AND accounts.silenced_at IS NULL | |||
AND accounts.locked = 'f' | |||
AND accounts.discoverable = 't' | |||
GROUP BY accounts.id | |||
HAVING sum(reblogs_count + favourites_count) >= 5 | |||
) t0 | |||
GROUP BY account_id | |||
ORDER BY rank DESC |
@ -0,0 +1,3 @@ | |||
Fabricator(:follow_recommendation_suppression) do | |||
account | |||
end |
@ -0,0 +1,4 @@ | |||
require 'rails_helper' | |||
RSpec.describe FollowRecommendationSuppression, type: :model do | |||
end |