2016-11-15 10:56:29 -05:00
|
|
|
# frozen_string_literal: true
|
2017-05-01 20:14:47 -04:00
|
|
|
# == Schema Information
|
|
|
|
#
|
|
|
|
# Table name: accounts
|
|
|
|
#
|
2018-04-23 05:29:17 -04:00
|
|
|
# id :bigint(8) not null, primary key
|
2017-05-01 20:14:47 -04:00
|
|
|
# username :string default(""), not null
|
|
|
|
# domain :string
|
|
|
|
# secret :string default(""), not null
|
|
|
|
# private_key :text
|
|
|
|
# public_key :text default(""), not null
|
|
|
|
# remote_url :string default(""), not null
|
|
|
|
# salmon_url :string default(""), not null
|
|
|
|
# hub_url :string default(""), not null
|
|
|
|
# created_at :datetime not null
|
|
|
|
# updated_at :datetime not null
|
|
|
|
# note :text default(""), not null
|
|
|
|
# display_name :string default(""), not null
|
|
|
|
# uri :string default(""), not null
|
|
|
|
# url :string
|
|
|
|
# avatar_file_name :string
|
|
|
|
# avatar_content_type :string
|
|
|
|
# avatar_file_size :integer
|
|
|
|
# avatar_updated_at :datetime
|
|
|
|
# header_file_name :string
|
|
|
|
# header_content_type :string
|
|
|
|
# header_file_size :integer
|
|
|
|
# header_updated_at :datetime
|
|
|
|
# avatar_remote_url :string
|
|
|
|
# subscription_expires_at :datetime
|
|
|
|
# silenced :boolean default(FALSE), not null
|
|
|
|
# suspended :boolean default(FALSE), not null
|
|
|
|
# locked :boolean default(FALSE), not null
|
|
|
|
# header_remote_url :string default(""), not null
|
|
|
|
# last_webfingered_at :datetime
|
2017-07-19 11:06:46 -04:00
|
|
|
# inbox_url :string default(""), not null
|
|
|
|
# outbox_url :string default(""), not null
|
|
|
|
# shared_inbox_url :string default(""), not null
|
|
|
|
# followers_url :string default(""), not null
|
|
|
|
# protocol :integer default("ostatus"), not null
|
2017-11-07 13:06:44 -05:00
|
|
|
# memorial :boolean default(FALSE), not null
|
2018-04-23 05:29:17 -04:00
|
|
|
# moved_to_account_id :bigint(8)
|
2018-03-04 03:19:11 -05:00
|
|
|
# featured_collection_url :string
|
2018-04-14 06:41:08 -04:00
|
|
|
# fields :jsonb
|
2018-05-07 03:31:07 -04:00
|
|
|
# actor_type :string
|
2018-12-06 11:36:11 -05:00
|
|
|
# discoverable :boolean
|
2017-05-01 20:14:47 -04:00
|
|
|
#
|
2016-11-15 10:56:29 -05:00
|
|
|
|
2016-08-17 11:56:23 -04:00
|
|
|
class Account < ApplicationRecord
|
2018-11-27 06:28:01 -05:00
|
|
|
USERNAME_RE = /[a-z0-9_]+([a-z0-9_\.-]+[a-z0-9_]+)?/i
|
2018-03-22 05:45:48 -04:00
|
|
|
MENTION_RE = /(?<=^|[^\/[:word:]])@((#{USERNAME_RE})(?:@[a-z0-9\.\-]+[a-z0-9]+)?)/i
|
2018-12-06 11:36:11 -05:00
|
|
|
MIN_FOLLOWERS_DISCOVERY = 10
|
2017-05-05 15:37:02 -04:00
|
|
|
|
2018-12-02 19:32:08 -05:00
|
|
|
include AccountAssociations
|
2017-05-05 15:37:02 -04:00
|
|
|
include AccountAvatar
|
2017-05-31 14:28:45 -04:00
|
|
|
include AccountFinderConcern
|
2017-05-05 15:37:02 -04:00
|
|
|
include AccountHeader
|
Account domain blocks (#2381)
* Add <ostatus:conversation /> tag to Atom input/output
Only uses ref attribute (not href) because href would be
the alternate link that's always included also.
Creates new conversation for every non-reply status. Carries
over conversation for every reply. Keeps remote URIs verbatim,
generates local URIs on the fly like the rest of them.
* Conversation muting - prevents notifications that reference a conversation
(including replies, favourites, reblogs) from being created. API endpoints
/api/v1/statuses/:id/mute and /api/v1/statuses/:id/unmute
Currently no way to tell when a status/conversation is muted, so the web UI
only has a "disable notifications" button, doesn't work as a toggle
* Display "Dismiss notifications" on all statuses in notifications column, not just own
* Add "muted" as a boolean attribute on statuses JSON
For now always false on contained reblogs, since it's only relevant for
statuses returned from the notifications endpoint, which are not nested
Remove "Disable notifications" from detailed status view, since it's
only relevant in the notifications column
* Up max class length
* Remove pending test for conversation mute
* Add tests, clean up
* Rename to "mute conversation" and "unmute conversation"
* Raise validation error when trying to mute/unmute status without conversation
* Adding account domain blocks that filter notifications and public timelines
* Add tests for domain blocks in notifications, public timelines
Filter reblogs of blocked domains from home
* Add API for listing and creating account domain blocks
* API for creating/deleting domain blocks, tests for Status#ancestors
and Status#descendants, filter domain blocks from them
* Filter domains in streaming API
* Update account_domain_block_spec.rb
2017-05-18 19:14:30 -04:00
|
|
|
include AccountInteractions
|
2017-05-05 15:37:02 -04:00
|
|
|
include Attachmentable
|
2017-11-17 18:16:48 -05:00
|
|
|
include Paginable
|
2018-11-18 18:43:52 -05:00
|
|
|
include AccountCounters
|
2016-09-12 12:22:43 -04:00
|
|
|
|
2017-07-19 11:06:46 -04:00
|
|
|
enum protocol: [:ostatus, :activitypub]
|
|
|
|
|
2017-05-07 10:40:57 -04:00
|
|
|
validates :username, presence: true
|
2017-06-08 09:22:01 -04:00
|
|
|
|
|
|
|
# Remote user validations
|
2017-06-11 11:01:32 -04:00
|
|
|
validates :username, uniqueness: { scope: :domain, case_sensitive: true }, if: -> { !local? && will_save_change_to_username? }
|
2018-07-30 16:29:52 -04:00
|
|
|
validates :username, format: { with: /\A#{USERNAME_RE}\z/i }, if: -> { !local? && will_save_change_to_username? }
|
2017-05-07 10:40:57 -04:00
|
|
|
|
|
|
|
# Local user validations
|
2018-03-22 06:30:22 -04:00
|
|
|
validates :username, format: { with: /\A[a-z0-9_]+\z/i }, length: { maximum: 30 }, if: -> { local? && will_save_change_to_username? }
|
2018-03-21 05:26:53 -04:00
|
|
|
validates_with UniqueUsernameValidator, if: -> { local? && will_save_change_to_username? }
|
2017-06-11 11:01:32 -04:00
|
|
|
validates_with UnreservedUsernameValidator, if: -> { local? && will_save_change_to_username? }
|
|
|
|
validates :display_name, length: { maximum: 30 }, if: -> { local? && will_save_change_to_display_name? }
|
|
|
|
validates :note, length: { maximum: 160 }, if: -> { local? && will_save_change_to_note? }
|
2018-05-05 15:11:19 -04:00
|
|
|
validates :fields, length: { maximum: 4 }, if: -> { local? && will_save_change_to_fields? }
|
2016-03-16 06:18:09 -04:00
|
|
|
|
2016-09-19 18:39:03 -04:00
|
|
|
scope :remote, -> { where.not(domain: nil) }
|
|
|
|
scope :local, -> { where(domain: nil) }
|
2017-08-21 11:32:41 -04:00
|
|
|
scope :expiring, ->(time) { remote.where.not(subscription_expires_at: nil).where('subscription_expires_at < ?', time) }
|
2018-04-17 07:50:48 -04:00
|
|
|
scope :partitioned, -> { order(Arel.sql('row_number() over (partition by domain)')) }
|
2016-12-06 12:22:59 -05:00
|
|
|
scope :silenced, -> { where(silenced: true) }
|
|
|
|
scope :suspended, -> { where(suspended: true) }
|
2018-04-23 15:27:18 -04:00
|
|
|
scope :without_suspended, -> { where(suspended: false) }
|
2017-01-07 20:55:40 -05:00
|
|
|
scope :recent, -> { reorder(id: :desc) }
|
2018-11-26 09:53:27 -05:00
|
|
|
scope :bots, -> { where(actor_type: %w(Application Service)) }
|
2017-01-07 20:55:40 -05:00
|
|
|
scope :alphabetic, -> { order(domain: :asc, username: :asc) }
|
2017-04-18 15:09:07 -04:00
|
|
|
scope :by_domain_accounts, -> { group(:domain).select(:domain, 'COUNT(*) AS accounts_count').order('accounts_count desc') }
|
2017-05-22 15:50:58 -04:00
|
|
|
scope :matches_username, ->(value) { where(arel_table[:username].matches("#{value}%")) }
|
|
|
|
scope :matches_display_name, ->(value) { where(arel_table[:display_name].matches("#{value}%")) }
|
2017-09-13 06:30:07 -04:00
|
|
|
scope :matches_domain, ->(value) { where(arel_table[:domain].matches("%#{value}%")) }
|
Re-add follow recommendations API (#7918)
* Re-add follow recommendations API
GET /api/v1/suggestions
Removed in 8efa081f210d72ed450c39ac4cde0fd84fb3d3fb due to Neo4J
dependency. The algorithm uses triadic closures, takes into account
suspensions, blocks, mutes, domain blocks, excludes locked and moved
accounts, and prefers more recently updated accounts.
* Track interactions with people you don't follow
Replying to, favouriting and reblogging someone you're not following
will make them show up in follow recommendations. The interactions
have different weights:
- Replying is 1
- Favouriting is 10 (decidedly positive interaction, but private)
- Reblogging is 20
Following them, muting or blocking will remove them from the list,
obviously.
* Remove triadic closures, ensure potential friendships are trimmed
2018-07-02 19:47:56 -04:00
|
|
|
scope :searchable, -> { where(suspended: false).where(moved_to_account_id: nil) }
|
2018-12-06 11:36:11 -05:00
|
|
|
scope :discoverable, -> { where(silenced: false).where(discoverable: true).joins(:account_stat).where(AccountStat.arel_table[:followers_count].gteq(MIN_FOLLOWERS_DISCOVERY)) }
|
|
|
|
scope :tagged_with, ->(tag) { joins(:accounts_tags).where(accounts_tags: { tag_id: tag }) }
|
|
|
|
scope :popular, -> { order('account_stats.followers_count desc') }
|
|
|
|
scope :by_recent_status, -> { order('(case when account_stats.last_status_at is null then 1 else 0 end) asc, account_stats.last_status_at desc') }
|
2016-10-16 12:57:54 -04:00
|
|
|
|
2017-04-28 09:12:37 -04:00
|
|
|
delegate :email,
|
2018-04-10 03:16:06 -04:00
|
|
|
:unconfirmed_email,
|
2017-05-01 10:31:02 -04:00
|
|
|
:current_sign_in_ip,
|
|
|
|
:current_sign_in_at,
|
|
|
|
:confirmed?,
|
2017-08-16 11:12:58 -04:00
|
|
|
:admin?,
|
2017-11-16 19:22:38 -05:00
|
|
|
:moderator?,
|
|
|
|
:staff?,
|
2017-05-08 17:10:50 -04:00
|
|
|
:locale,
|
2018-05-17 20:26:51 -04:00
|
|
|
:hides_network?,
|
2017-05-01 10:31:02 -04:00
|
|
|
to: :user,
|
|
|
|
prefix: true,
|
|
|
|
allow_nil: true
|
2017-04-28 09:12:37 -04:00
|
|
|
|
2018-06-17 07:54:02 -04:00
|
|
|
delegate :chosen_languages, to: :user, prefix: false, allow_nil: true
|
2017-05-01 11:42:13 -04:00
|
|
|
|
2016-02-22 10:00:20 -05:00
|
|
|
def local?
|
2016-09-29 15:28:21 -04:00
|
|
|
domain.nil?
|
2016-02-22 10:00:20 -05:00
|
|
|
end
|
|
|
|
|
2017-11-18 13:39:02 -05:00
|
|
|
def moved?
|
|
|
|
moved_to_account_id.present?
|
|
|
|
end
|
|
|
|
|
2018-05-07 03:31:07 -04:00
|
|
|
def bot?
|
|
|
|
%w(Application Service).include? actor_type
|
|
|
|
end
|
|
|
|
|
|
|
|
alias bot bot?
|
|
|
|
|
|
|
|
def bot=(val)
|
|
|
|
self.actor_type = ActiveModel::Type::Boolean.new.cast(val) ? 'Service' : 'Person'
|
|
|
|
end
|
|
|
|
|
2016-02-22 12:10:30 -05:00
|
|
|
def acct
|
2016-09-29 15:28:21 -04:00
|
|
|
local? ? username : "#{username}@#{domain}"
|
2016-02-22 12:10:30 -05:00
|
|
|
end
|
|
|
|
|
2017-04-10 16:58:06 -04:00
|
|
|
def local_username_and_domain
|
|
|
|
"#{username}@#{Rails.configuration.x.local_domain}"
|
|
|
|
end
|
|
|
|
|
|
|
|
def to_webfinger_s
|
|
|
|
"acct:#{local_username_and_domain}"
|
|
|
|
end
|
|
|
|
|
2016-02-22 12:10:30 -05:00
|
|
|
def subscribed?
|
2017-05-03 13:13:04 -04:00
|
|
|
subscription_expires_at.present?
|
2016-02-22 12:10:30 -05:00
|
|
|
end
|
|
|
|
|
2017-09-28 11:50:14 -04:00
|
|
|
def possibly_stale?
|
|
|
|
last_webfingered_at.nil? || last_webfingered_at <= 1.day.ago
|
|
|
|
end
|
|
|
|
|
|
|
|
def refresh!
|
|
|
|
return if local?
|
2018-01-22 08:25:09 -05:00
|
|
|
ResolveAccountService.new.call(acct)
|
2017-09-28 11:50:14 -04:00
|
|
|
end
|
|
|
|
|
2018-08-22 05:53:41 -04:00
|
|
|
def suspend!
|
|
|
|
transaction do
|
|
|
|
user&.disable! if local?
|
|
|
|
update!(suspended: true)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-11-07 13:06:44 -05:00
|
|
|
def unsuspend!
|
|
|
|
transaction do
|
|
|
|
user&.enable! if local?
|
|
|
|
update!(suspended: false)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def memorialize!
|
|
|
|
transaction do
|
|
|
|
user&.disable! if local?
|
|
|
|
update!(memorial: true)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-02-22 10:00:20 -05:00
|
|
|
def keypair
|
2017-08-21 11:32:41 -04:00
|
|
|
@keypair ||= OpenSSL::PKey::RSA.new(private_key || public_key)
|
2016-02-22 10:00:20 -05:00
|
|
|
end
|
|
|
|
|
2018-12-06 11:36:11 -05:00
|
|
|
def tags_as_strings=(tag_names)
|
2018-12-06 22:18:37 -05:00
|
|
|
tag_names.map! { |name| name.mb_chars.downcase.to_s }
|
|
|
|
tag_names.uniq!
|
2018-12-06 11:36:11 -05:00
|
|
|
|
|
|
|
# Existing hashtags
|
|
|
|
hashtags_map = Tag.where(name: tag_names).each_with_object({}) { |tag, h| h[tag.name] = tag }
|
|
|
|
|
|
|
|
# Initialize not yet existing hashtags
|
|
|
|
tag_names.each do |name|
|
|
|
|
next if hashtags_map.key?(name)
|
2018-12-06 22:18:37 -05:00
|
|
|
hashtags_map[name] = Tag.new(name: name)
|
2018-12-06 11:36:11 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
# Remove hashtags that are to be deleted
|
|
|
|
tags.each do |tag|
|
|
|
|
if hashtags_map.key?(tag.name)
|
|
|
|
hashtags_map.delete(tag.name)
|
|
|
|
else
|
|
|
|
transaction do
|
|
|
|
tags.delete(tag)
|
|
|
|
tag.decrement_count!(:accounts_count)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# Add hashtags that were so far missing
|
|
|
|
hashtags_map.each_value do |tag|
|
|
|
|
transaction do
|
|
|
|
tags << tag
|
|
|
|
tag.increment_count!(:accounts_count)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-04-14 06:41:08 -04:00
|
|
|
def fields
|
|
|
|
(self[:fields] || []).map { |f| Field.new(self, f) }
|
|
|
|
end
|
|
|
|
|
|
|
|
def fields_attributes=(attributes)
|
2018-09-18 10:45:58 -04:00
|
|
|
fields = []
|
|
|
|
old_fields = self[:fields] || []
|
2018-04-14 06:41:08 -04:00
|
|
|
|
2018-05-05 15:11:19 -04:00
|
|
|
if attributes.is_a?(Hash)
|
|
|
|
attributes.each_value do |attr|
|
|
|
|
next if attr[:name].blank?
|
2018-09-18 10:45:58 -04:00
|
|
|
|
|
|
|
previous = old_fields.find { |item| item['value'] == attr[:value] }
|
|
|
|
|
|
|
|
if previous && previous['verified_at'].present?
|
|
|
|
attr[:verified_at] = previous['verified_at']
|
|
|
|
end
|
|
|
|
|
2018-05-05 15:11:19 -04:00
|
|
|
fields << attr
|
|
|
|
end
|
2018-04-14 06:41:08 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
self[:fields] = fields
|
|
|
|
end
|
|
|
|
|
2018-09-18 10:45:58 -04:00
|
|
|
DEFAULT_FIELDS_SIZE = 4
|
|
|
|
|
2018-04-14 06:41:08 -04:00
|
|
|
def build_fields
|
2018-09-18 10:45:58 -04:00
|
|
|
return if fields.size >= DEFAULT_FIELDS_SIZE
|
|
|
|
|
|
|
|
tmp = self[:fields] || []
|
|
|
|
|
|
|
|
(DEFAULT_FIELDS_SIZE - tmp.size).times do
|
|
|
|
tmp << { name: '', value: '' }
|
|
|
|
end
|
2018-04-14 06:41:08 -04:00
|
|
|
|
2018-09-18 10:45:58 -04:00
|
|
|
self.fields = tmp
|
2018-04-14 06:41:08 -04:00
|
|
|
end
|
|
|
|
|
2017-12-06 01:04:49 -05:00
|
|
|
def magic_key
|
|
|
|
modulus, exponent = [keypair.public_key.n, keypair.public_key.e].map do |component|
|
|
|
|
result = []
|
|
|
|
|
|
|
|
until component.zero?
|
|
|
|
result << [component % 256].pack('C')
|
|
|
|
component >>= 8
|
|
|
|
end
|
|
|
|
|
|
|
|
result.reverse.join
|
|
|
|
end
|
|
|
|
|
|
|
|
(['RSA'] + [modulus, exponent].map { |n| Base64.urlsafe_encode64(n) }).join('.')
|
|
|
|
end
|
|
|
|
|
2016-02-20 16:53:20 -05:00
|
|
|
def subscription(webhook_url)
|
2017-08-21 11:32:41 -04:00
|
|
|
@subscription ||= OStatus2::Subscription.new(remote_url, secret: secret, webhook: webhook_url, hub: hub_url)
|
2016-02-20 16:53:20 -05:00
|
|
|
end
|
2016-02-26 09:28:08 -05:00
|
|
|
|
2017-05-05 15:37:02 -04:00
|
|
|
def save_with_optional_media!
|
2016-12-02 08:14:49 -05:00
|
|
|
save!
|
2017-01-18 20:14:57 -05:00
|
|
|
rescue ActiveRecord::RecordInvalid
|
2017-01-19 03:37:07 -05:00
|
|
|
self.avatar = nil
|
2017-03-18 17:51:20 -04:00
|
|
|
self.header = nil
|
2017-01-19 03:37:07 -05:00
|
|
|
self[:avatar_remote_url] = ''
|
2017-03-18 17:51:20 -04:00
|
|
|
self[:header_remote_url] = ''
|
2017-01-18 20:14:57 -05:00
|
|
|
save!
|
2016-02-28 08:33:13 -05:00
|
|
|
end
|
|
|
|
|
2016-03-24 21:13:30 -04:00
|
|
|
def object_type
|
|
|
|
:person
|
|
|
|
end
|
|
|
|
|
2016-02-29 13:42:08 -05:00
|
|
|
def to_param
|
2016-09-29 15:28:21 -04:00
|
|
|
username
|
2016-02-29 13:42:08 -05:00
|
|
|
end
|
|
|
|
|
2017-04-28 09:10:41 -04:00
|
|
|
def excluded_from_timeline_account_ids
|
|
|
|
Rails.cache.fetch("exclude_account_ids_for:#{id}") { blocking.pluck(:target_account_id) + blocked_by.pluck(:account_id) + muting.pluck(:target_account_id) }
|
|
|
|
end
|
|
|
|
|
Account domain blocks (#2381)
* Add <ostatus:conversation /> tag to Atom input/output
Only uses ref attribute (not href) because href would be
the alternate link that's always included also.
Creates new conversation for every non-reply status. Carries
over conversation for every reply. Keeps remote URIs verbatim,
generates local URIs on the fly like the rest of them.
* Conversation muting - prevents notifications that reference a conversation
(including replies, favourites, reblogs) from being created. API endpoints
/api/v1/statuses/:id/mute and /api/v1/statuses/:id/unmute
Currently no way to tell when a status/conversation is muted, so the web UI
only has a "disable notifications" button, doesn't work as a toggle
* Display "Dismiss notifications" on all statuses in notifications column, not just own
* Add "muted" as a boolean attribute on statuses JSON
For now always false on contained reblogs, since it's only relevant for
statuses returned from the notifications endpoint, which are not nested
Remove "Disable notifications" from detailed status view, since it's
only relevant in the notifications column
* Up max class length
* Remove pending test for conversation mute
* Add tests, clean up
* Rename to "mute conversation" and "unmute conversation"
* Raise validation error when trying to mute/unmute status without conversation
* Adding account domain blocks that filter notifications and public timelines
* Add tests for domain blocks in notifications, public timelines
Filter reblogs of blocked domains from home
* Add API for listing and creating account domain blocks
* API for creating/deleting domain blocks, tests for Status#ancestors
and Status#descendants, filter domain blocks from them
* Filter domains in streaming API
* Update account_domain_block_spec.rb
2017-05-18 19:14:30 -04:00
|
|
|
def excluded_from_timeline_domains
|
|
|
|
Rails.cache.fetch("exclude_domains_for:#{id}") { domain_blocks.pluck(:domain) }
|
|
|
|
end
|
|
|
|
|
2017-11-29 21:50:05 -05:00
|
|
|
def preferred_inbox_url
|
|
|
|
shared_inbox_url.presence || inbox_url
|
|
|
|
end
|
|
|
|
|
2018-04-14 06:41:08 -04:00
|
|
|
class Field < ActiveModelSerializers::Model
|
2018-09-18 10:45:58 -04:00
|
|
|
attributes :name, :value, :verified_at, :account, :errors
|
|
|
|
|
|
|
|
def initialize(account, attributes)
|
|
|
|
@account = account
|
|
|
|
@attributes = attributes
|
2018-10-04 09:47:03 -04:00
|
|
|
@name = attributes['name'].strip[0, string_limit]
|
|
|
|
@value = attributes['value'].strip[0, string_limit]
|
2018-09-18 10:45:58 -04:00
|
|
|
@verified_at = attributes['verified_at']&.to_datetime
|
|
|
|
@errors = {}
|
|
|
|
end
|
|
|
|
|
|
|
|
def verified?
|
|
|
|
verified_at.present?
|
|
|
|
end
|
|
|
|
|
2018-10-04 09:47:03 -04:00
|
|
|
def value_for_verification
|
|
|
|
@value_for_verification ||= begin
|
|
|
|
if account.local?
|
|
|
|
value
|
|
|
|
else
|
|
|
|
ActionController::Base.helpers.strip_tags(value)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-09-18 10:45:58 -04:00
|
|
|
def verifiable?
|
2018-10-04 09:47:03 -04:00
|
|
|
value_for_verification.present? && value_for_verification.start_with?('http://', 'https://')
|
2018-09-18 10:45:58 -04:00
|
|
|
end
|
2018-04-14 06:41:08 -04:00
|
|
|
|
2018-09-18 10:45:58 -04:00
|
|
|
def mark_verified!
|
|
|
|
@verified_at = Time.now.utc
|
|
|
|
@attributes['verified_at'] = @verified_at
|
2018-04-14 06:41:08 -04:00
|
|
|
end
|
2018-05-02 09:57:37 -04:00
|
|
|
|
|
|
|
def to_h
|
2018-09-18 10:45:58 -04:00
|
|
|
{ name: @name, value: @value, verified_at: @verified_at }
|
2018-05-02 09:57:37 -04:00
|
|
|
end
|
2018-10-04 09:47:03 -04:00
|
|
|
|
|
|
|
private
|
|
|
|
|
|
|
|
def string_limit
|
|
|
|
if account.local?
|
|
|
|
255
|
|
|
|
else
|
|
|
|
2047
|
|
|
|
end
|
|
|
|
end
|
2018-04-14 06:41:08 -04:00
|
|
|
end
|
|
|
|
|
2016-11-09 11:48:44 -05:00
|
|
|
class << self
|
2017-09-11 18:16:03 -04:00
|
|
|
def readonly_attributes
|
|
|
|
super - %w(statuses_count following_count followers_count)
|
|
|
|
end
|
|
|
|
|
2017-06-22 12:34:27 -04:00
|
|
|
def domains
|
2018-04-12 08:45:17 -04:00
|
|
|
reorder(nil).pluck(Arel.sql('distinct accounts.domain'))
|
2017-06-22 12:34:27 -04:00
|
|
|
end
|
|
|
|
|
2017-08-12 18:44:41 -04:00
|
|
|
def inboxes
|
2018-04-12 08:45:17 -04:00
|
|
|
urls = reorder(nil).where(protocol: :activitypub).pluck(Arel.sql("distinct coalesce(nullif(accounts.shared_inbox_url, ''), accounts.inbox_url)"))
|
2017-09-28 21:16:20 -04:00
|
|
|
DeliveryFailureTracker.filter(urls)
|
2017-08-12 18:44:41 -04:00
|
|
|
end
|
|
|
|
|
2017-03-17 15:47:38 -04:00
|
|
|
def search_for(terms, limit = 10)
|
2017-05-07 10:40:57 -04:00
|
|
|
textsearch, query = generate_query_for_search(terms)
|
2017-03-17 15:47:38 -04:00
|
|
|
|
2017-04-09 08:45:01 -04:00
|
|
|
sql = <<-SQL.squish
|
2017-03-17 15:47:38 -04:00
|
|
|
SELECT
|
|
|
|
accounts.*,
|
|
|
|
ts_rank_cd(#{textsearch}, #{query}, 32) AS rank
|
|
|
|
FROM accounts
|
|
|
|
WHERE #{query} @@ #{textsearch}
|
2017-06-14 12:01:27 -04:00
|
|
|
AND accounts.suspended = false
|
2017-12-11 20:14:33 -05:00
|
|
|
AND accounts.moved_to_account_id IS NULL
|
2017-03-17 15:47:38 -04:00
|
|
|
ORDER BY rank DESC
|
|
|
|
LIMIT ?
|
2017-04-09 08:45:01 -04:00
|
|
|
SQL
|
2017-03-17 15:47:38 -04:00
|
|
|
|
2018-11-18 18:43:52 -05:00
|
|
|
records = find_by_sql([sql, limit])
|
|
|
|
ActiveRecord::Associations::Preloader.new.preload(records, :account_stat)
|
|
|
|
records
|
2017-03-17 15:47:38 -04:00
|
|
|
end
|
|
|
|
|
2017-12-05 17:02:27 -05:00
|
|
|
def advanced_search_for(terms, account, limit = 10, following = false)
|
2017-05-07 10:40:57 -04:00
|
|
|
textsearch, query = generate_query_for_search(terms)
|
2017-03-17 15:47:38 -04:00
|
|
|
|
2017-12-05 17:02:27 -05:00
|
|
|
if following
|
|
|
|
sql = <<-SQL.squish
|
|
|
|
WITH first_degree AS (
|
|
|
|
SELECT target_account_id
|
|
|
|
FROM follows
|
|
|
|
WHERE account_id = ?
|
|
|
|
)
|
|
|
|
SELECT
|
|
|
|
accounts.*,
|
|
|
|
(count(f.id) + 1) * ts_rank_cd(#{textsearch}, #{query}, 32) AS rank
|
|
|
|
FROM accounts
|
|
|
|
LEFT OUTER JOIN follows AS f ON (accounts.id = f.account_id AND f.target_account_id = ?) OR (accounts.id = f.target_account_id AND f.account_id = ?)
|
|
|
|
WHERE accounts.id IN (SELECT * FROM first_degree)
|
|
|
|
AND #{query} @@ #{textsearch}
|
|
|
|
AND accounts.suspended = false
|
2017-12-11 20:14:33 -05:00
|
|
|
AND accounts.moved_to_account_id IS NULL
|
2017-12-05 17:02:27 -05:00
|
|
|
GROUP BY accounts.id
|
|
|
|
ORDER BY rank DESC
|
|
|
|
LIMIT ?
|
|
|
|
SQL
|
|
|
|
|
2018-11-18 18:43:52 -05:00
|
|
|
records = find_by_sql([sql, account.id, account.id, account.id, limit])
|
2017-12-05 17:02:27 -05:00
|
|
|
else
|
|
|
|
sql = <<-SQL.squish
|
|
|
|
SELECT
|
|
|
|
accounts.*,
|
|
|
|
(count(f.id) + 1) * ts_rank_cd(#{textsearch}, #{query}, 32) AS rank
|
|
|
|
FROM accounts
|
|
|
|
LEFT OUTER JOIN follows AS f ON (accounts.id = f.account_id AND f.target_account_id = ?) OR (accounts.id = f.target_account_id AND f.account_id = ?)
|
|
|
|
WHERE #{query} @@ #{textsearch}
|
|
|
|
AND accounts.suspended = false
|
2017-12-11 20:14:33 -05:00
|
|
|
AND accounts.moved_to_account_id IS NULL
|
2017-12-05 17:02:27 -05:00
|
|
|
GROUP BY accounts.id
|
|
|
|
ORDER BY rank DESC
|
|
|
|
LIMIT ?
|
|
|
|
SQL
|
|
|
|
|
2018-11-18 18:43:52 -05:00
|
|
|
records = find_by_sql([sql, account.id, account.id, limit])
|
2017-12-05 17:02:27 -05:00
|
|
|
end
|
2018-11-18 18:43:52 -05:00
|
|
|
|
|
|
|
ActiveRecord::Associations::Preloader.new.preload(records, :account_stat)
|
|
|
|
records
|
2017-03-17 15:47:38 -04:00
|
|
|
end
|
|
|
|
|
2017-01-08 13:12:54 -05:00
|
|
|
private
|
|
|
|
|
2017-05-07 10:40:57 -04:00
|
|
|
def generate_query_for_search(terms)
|
|
|
|
terms = Arel.sql(connection.quote(terms.gsub(/['?\\:]/, ' ')))
|
|
|
|
textsearch = "(setweight(to_tsvector('simple', accounts.display_name), 'A') || setweight(to_tsvector('simple', accounts.username), 'B') || setweight(to_tsvector('simple', coalesce(accounts.domain, '')), 'C'))"
|
|
|
|
query = "to_tsquery('simple', ''' ' || #{terms} || ' ''' || ':*')"
|
|
|
|
|
|
|
|
[textsearch, query]
|
|
|
|
end
|
2016-10-03 11:16:58 -04:00
|
|
|
end
|
|
|
|
|
2018-04-01 17:55:42 -04:00
|
|
|
def emojis
|
2018-05-06 05:48:51 -04:00
|
|
|
@emojis ||= CustomEmoji.from_text(emojifiable_text, domain)
|
2018-04-01 17:55:42 -04:00
|
|
|
end
|
|
|
|
|
2017-04-24 20:47:31 -04:00
|
|
|
before_create :generate_keys
|
|
|
|
before_validation :normalize_domain
|
2017-07-14 13:47:53 -04:00
|
|
|
before_validation :prepare_contents, if: :local?
|
2018-12-02 19:32:08 -05:00
|
|
|
before_destroy :clean_feed_manager
|
2017-04-18 17:15:44 -04:00
|
|
|
|
|
|
|
private
|
|
|
|
|
2017-07-14 13:47:53 -04:00
|
|
|
def prepare_contents
|
|
|
|
display_name&.strip!
|
|
|
|
note&.strip!
|
|
|
|
end
|
|
|
|
|
2017-04-24 20:47:31 -04:00
|
|
|
def generate_keys
|
2018-05-02 09:45:24 -04:00
|
|
|
return unless local? && !Rails.env.test?
|
2017-04-24 20:47:31 -04:00
|
|
|
|
2018-05-02 09:45:24 -04:00
|
|
|
keypair = OpenSSL::PKey::RSA.new(2048)
|
2017-04-24 20:47:31 -04:00
|
|
|
self.private_key = keypair.to_pem
|
|
|
|
self.public_key = keypair.public_key.to_pem
|
|
|
|
end
|
|
|
|
|
|
|
|
def normalize_domain
|
|
|
|
return if local?
|
|
|
|
|
|
|
|
self.domain = TagManager.instance.normalize_domain(domain)
|
|
|
|
end
|
2018-05-06 05:48:51 -04:00
|
|
|
|
|
|
|
def emojifiable_text
|
|
|
|
[note, display_name, fields.map(&:value)].join(' ')
|
|
|
|
end
|
2018-12-02 19:32:08 -05:00
|
|
|
|
|
|
|
def clean_feed_manager
|
|
|
|
reblog_key = FeedManager.instance.key(:home, id, 'reblogs')
|
|
|
|
reblogged_id_set = Redis.current.zrange(reblog_key, 0, -1)
|
|
|
|
|
|
|
|
Redis.current.pipelined do
|
|
|
|
Redis.current.del(FeedManager.instance.key(:home, id))
|
|
|
|
Redis.current.del(reblog_key)
|
|
|
|
|
|
|
|
reblogged_id_set.each do |reblogged_id|
|
|
|
|
reblog_set_key = FeedManager.instance.key(:home, id, "reblogs:#{reblogged_id}")
|
|
|
|
Redis.current.del(reblog_set_key)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2016-02-20 16:53:20 -05:00
|
|
|
end
|