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-16 21:14:28 -05:00
scope :discoverable , - > { searchable . where ( silenced : false ) . where ( discoverable : true ) . joins ( :account_stat ) . where ( AccountStat . arel_table [ :followers_count ] . gteq ( MIN_FOLLOWERS_DISCOVERY ) ) . by_recent_status }
2018-12-06 11:36:11 -05:00
scope :tagged_with , - > ( tag ) { joins ( :accounts_tags ) . where ( accounts_tags : { tag_id : tag } ) }
2018-12-07 19:32:26 -05:00
scope :by_recent_status , - > { order ( Arel . sql ( '(case when account_stats.last_status_at is null then 1 else 0 end) asc, account_stats.last_status_at desc' ) ) }
2018-12-16 22:32:36 -05:00
scope :popular , - > { order ( 'account_stats.followers_count 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
Add moderation warnings (#9519)
* Add moderation warnings
Replace individual routes for disabling, silencing, and suspending
a user, as well as the report update route, with a unified account
action controller that allows you to select an action (none,
disable, silence, suspend) as well as whether it should generate an
e-mail notification with optional custom text. That notification,
with the optional custom text, is saved as a warning.
Additionally, there are warning presets you can configure to save
time when performing the above.
* Use Account#local_username_and_domain
2018-12-22 14:02:09 -05:00
def silence!
update! ( silenced : true )
end
def unsilence!
update! ( silenced : false )
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