2016-11-15 10:56:29 -05:00
# frozen_string_literal: true
2023-02-20 00:58:28 -05:00
2017-05-01 20:14:47 -04:00
# == Schema Information
#
# Table name: accounts
#
2020-04-26 17:29:08 -04:00
# id :bigint(8) not null, primary key
# username :string default(""), not null
# domain :string
# private_key :text
# public_key :text 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
# locked :boolean default(FALSE), not null
# header_remote_url :string default(""), not null
# last_webfingered_at :datetime
# 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
# memorial :boolean default(FALSE), not null
# moved_to_account_id :bigint(8)
# featured_collection_url :string
# fields :jsonb
# actor_type :string
# discoverable :boolean
# also_known_as :string is an Array
# silenced_at :datetime
# suspended_at :datetime
# hide_collections :boolean
# avatar_storage_schema_version :integer
# header_storage_schema_version :integer
2020-06-02 13:24:53 -04:00
# devices_url :string
2020-11-07 18:28:39 -05:00
# suspension_origin :integer
2021-05-07 13:32:58 -04:00
# sensitized_at :datetime
2022-02-24 18:34:14 -05:00
# trendable :boolean
# reviewed_at :datetime
# requested_review_at :datetime
2023-08-14 12:54:51 -04:00
# indexable :boolean default(FALSE), not null
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
2023-03-31 09:07:22 -04:00
self . ignored_columns += %w(
2021-05-07 13:32:58 -04:00
subscription_expires_at
secret
remote_url
salmon_url
hub_url
2022-02-24 18:34:14 -05:00
trust_level
2021-05-07 13:32:58 -04:00
)
2021-03-11 23:25:24 -05:00
2023-08-21 10:09:26 -04:00
BACKGROUND_REFRESH_INTERVAL = 1 . week . freeze
2023-06-06 08:50:51 -04:00
USERNAME_RE = / [a-z0-9_]+([a-z0-9_.-]+[a-z0-9_]+)? /i
2023-10-03 11:01:45 -04:00
MENTION_RE = %r{ (?<![=/[:word:]])@(( #{ USERNAME_RE } )(?:@[[:word:].-]+[[:word:]]+)?) }i
2023-06-06 08:50:51 -04:00
URL_PREFIX_RE = %r{ \ Ahttp(s?)://[^/]+ }
2022-11-09 23:49:30 -05:00
USERNAME_ONLY_RE = / \ A #{ USERNAME_RE } \ z /i
2017-05-05 15:37:02 -04:00
2023-12-01 06:00:41 -05:00
include Attachmentable # Load prior to Avatar & Header concerns
include Account :: Associations
include Account :: Avatar
include Account :: Counters
include Account :: FinderConcern
include Account :: Header
include Account :: Interactions
include Account :: Merging
include Account :: Search
include Account :: StatusesSearch
2020-12-14 03:06:34 -05:00
include DomainMaterializable
2023-12-01 06:00:41 -05:00
include DomainNormalizable
include Paginable
2016-09-12 12:22:43 -04:00
2018-10-21 20:57:25 -04:00
MAX_DISPLAY_NAME_LENGTH = ( ENV [ 'MAX_DISPLAY_NAME_CHARS' ] || 30 ) . to_i
MAX_NOTE_LENGTH = ( ENV [ 'MAX_BIO_CHARS' ] || 500 ) . to_i
2022-05-25 06:27:11 -04:00
DEFAULT_FIELDS_SIZE = ( ENV [ 'MAX_PROFILE_FIELDS' ] || 4 ) . to_i
2017-09-10 20:43:52 -04:00
2023-02-19 23:00:36 -05:00
enum protocol : { ostatus : 0 , activitypub : 1 }
enum suspension_origin : { local : 0 , remote : 1 } , _prefix : true
2017-07-19 11:06:46 -04:00
2017-05-07 10:40:57 -04:00
validates :username , presence : true
2020-02-01 09:42:24 -05:00
validates_with UniqueUsernameValidator , if : - > { will_save_change_to_username? }
2017-06-08 09:22:01 -04:00
2023-01-18 10:33:03 -05:00
# Remote user validations, also applies to internal actors
validates :username , format : { with : USERNAME_ONLY_RE } , if : - > { ( ! local? || actor_type == 'Application' ) && will_save_change_to_username? }
2017-05-07 10:40:57 -04:00
2023-07-20 12:23:48 -04:00
# Remote user validations
validates :uri , presence : true , unless : :local? , on : :create
2017-05-07 10:40:57 -04:00
# Local user validations
2019-07-18 19:44:42 -04:00
validates :username , format : { with : / \ A[a-z0-9_]+ \ z /i } , length : { maximum : 30 } , if : - > { local? && will_save_change_to_username? && actor_type != 'Application' }
2022-06-01 13:23:31 -04:00
validates_with UnreservedUsernameValidator , if : - > { local? && will_save_change_to_username? && actor_type != 'Application' }
2018-10-21 20:57:25 -04:00
validates :display_name , length : { maximum : MAX_DISPLAY_NAME_LENGTH } , if : - > { local? && will_save_change_to_display_name? }
2019-01-10 13:12:10 -05:00
validates :note , note_length : { maximum : MAX_NOTE_LENGTH } , if : - > { local? && will_save_change_to_note? }
2022-05-25 06:27:11 -04:00
validates :fields , length : { maximum : DEFAULT_FIELDS_SIZE } , if : - > { local? && will_save_change_to_fields? }
2023-07-20 12:23:48 -04:00
validates :uri , absence : true , if : :local? , on : :create
validates :inbox_url , absence : true , if : :local? , on : :create
validates :shared_inbox_url , absence : true , if : :local? , on : :create
validates :followers_url , absence : true , if : :local? , on : :create
2016-03-16 06:18:09 -04:00
2024-01-08 08:48:31 -05:00
normalizes :username , with : - > ( username ) { username . squish }
2016-09-19 18:39:03 -04:00
scope :remote , - > { where . not ( domain : nil ) }
scope :local , - > { where ( domain : nil ) }
2018-04-17 07:50:48 -04:00
scope :partitioned , - > { order ( Arel . sql ( 'row_number() over (partition by domain)' ) ) }
2019-05-14 13:05:02 -04:00
scope :silenced , - > { where . not ( silenced_at : nil ) }
scope :suspended , - > { where . not ( suspended_at : nil ) }
2020-11-04 14:45:01 -05:00
scope :sensitized , - > { where . not ( sensitized_at : nil ) }
2019-05-14 13:05:02 -04:00
scope :without_suspended , - > { where ( suspended_at : nil ) }
scope :without_silenced , - > { where ( silenced_at : nil ) }
2020-12-15 11:23:58 -05:00
scope :without_instance_actor , - > { where . not ( id : - 99 ) }
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 ) ) }
2019-12-04 14:36:33 -05:00
scope :groups , - > { where ( actor_type : 'Group' ) }
2017-01-07 20:55:40 -05:00
scope :alphabetic , - > { order ( domain : :asc , username : :asc ) }
2024-01-22 08:55:37 -05:00
scope :matches_uri_prefix , - > ( value ) { where ( arel_table [ :uri ] . matches ( " #{ sanitize_sql_like ( value ) } /% " , false , true ) ) . or ( where ( uri : value ) ) }
2023-02-22 05:53:13 -05:00
scope :matches_username , - > ( value ) { where ( 'lower((username)::text) LIKE lower(?)' , " #{ value } % " ) }
2017-05-22 15:50:58 -04:00
scope :matches_display_name , - > ( value ) { where ( arel_table [ :display_name ] . matches ( " #{ value } % " ) ) }
2023-07-01 15:48:16 -04:00
scope :without_unapproved , - > { left_outer_joins ( :user ) . merge ( User . approved . confirmed ) . or ( remote ) }
2024-01-18 20:39:30 -05:00
scope :auditable , - > { where ( id : Admin :: ActionLog . select ( :account_id ) . distinct ) }
2022-05-26 09:50:33 -04:00
scope :searchable , - > { without_unapproved . without_suspended . where ( moved_to_account_id : nil ) }
2023-09-07 12:55:25 -04:00
scope :discoverable , - > { searchable . without_silenced . where ( discoverable : true ) . joins ( :account_stat ) }
2023-10-06 06:58:16 -04:00
scope :by_recent_status , - > { includes ( :account_stat ) . merge ( AccountStat . order ( 'last_status_at DESC NULLS LAST' ) ) . references ( :account_stat ) }
2024-01-08 10:31:13 -05:00
scope :by_recent_activity , - > { left_joins ( :user , :account_stat ) . order ( coalesced_activity_timestamps . desc ) . order ( id : :desc ) }
2018-12-16 22:32:36 -05:00
scope :popular , - > { order ( 'account_stats.followers_count desc' ) }
2023-05-31 03:57:24 -04:00
scope :by_domain_and_subdomains , - > ( domain ) { where ( domain : Instance . by_domain_and_subdomains ( domain ) . select ( :domain ) ) }
2019-08-29 18:14:36 -04:00
scope :not_excluded_by_account , - > ( account ) { where . not ( id : account . excluded_from_timeline_account_ids ) }
scope :not_domain_blocked_by_account , - > ( account ) { where ( arel_table [ :domain ] . eq ( nil ) . or ( arel_table [ :domain ] . not_in ( account . excluded_from_timeline_domains ) ) ) }
2016-10-16 12:57:54 -04:00
2023-03-19 02:47:54 -04:00
after_update_commit :trigger_update_webhooks
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_at ,
2021-12-05 15:48:39 -05:00
:created_at ,
:sign_up_ip ,
2017-05-01 10:31:02 -04:00
:confirmed? ,
2019-03-14 00:28:30 -04:00
:approved? ,
:pending? ,
2019-06-19 20:52:34 -04:00
:disabled? ,
2022-03-25 21:53:13 -04:00
:unconfirmed? ,
2019-09-11 10:32:44 -04:00
:unconfirmed_or_pending? ,
2019-06-19 20:52:34 -04:00
:role ,
2017-05-08 17:10:50 -04:00
:locale ,
2019-01-21 13:36:33 -05:00
:shows_application? ,
2022-10-20 08:35:29 -04:00
:prefers_noindex? ,
2023-06-09 21:29:37 -04:00
:time_zone ,
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
2021-11-18 16:02:08 -05:00
update_index ( 'accounts' , :self )
2019-08-15 19:24:03 -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
2019-07-18 19:44:42 -04:00
def instance_actor?
id == - 99
end
2018-05-07 03:31:07 -04:00
alias bot bot?
def bot = ( val )
self . actor_type = ActiveModel :: Type :: Boolean . new . cast ( val ) ? 'Service' : 'Person'
end
2019-12-04 14:36:33 -05:00
def group?
actor_type == 'Group'
end
alias group group?
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
2019-12-30 13:20:43 -05:00
def pretty_acct
local? ? username : " #{ username } @ #{ Addressable :: IDNA . to_unicode ( domain ) } "
end
2017-04-10 16:58:06 -04:00
def local_username_and_domain
" #{ username } @ #{ Rails . configuration . x . local_domain } "
end
Add local followers page to admin account UI (#9610)
* Add local followers page to admin account UI
For moderation, I often find myself wondering who, locally, is following
a remote user. Currently, to see this, I have to go back to the web UI,
paste in their full handle, click their profile, and go to the
"Followers" tab (plus, this information is incidental, and if mastodon
ever decides to resolve all of the follower information, there will be
no place local followers are shown). This PR adds a new page which is
accessible via the "following" count on the admin's account view
page, which shows the local followers. (It has filter parameters for
account location to indicate that only local followers are shown, and
leave room for expansion if mastodon ever decides to store the entire
remote follow list).
* Normalize en.yml
2018-12-27 07:15:39 -05:00
def local_followers_count
Follow . where ( target_account_id : id ) . count
end
2017-04-10 16:58:06 -04:00
def to_webfinger_s
" acct: #{ local_username_and_domain } "
end
2017-09-28 11:50:14 -04:00
def possibly_stale?
last_webfingered_at . nil? || last_webfingered_at < = 1 . day . ago
end
2023-08-21 10:09:26 -04:00
def schedule_refresh_if_stale!
return unless last_webfingered_at . present? && last_webfingered_at < = BACKGROUND_REFRESH_INTERVAL . ago
AccountRefreshWorker . perform_in ( rand ( 6 . hours . to_i ) , id )
end
2017-09-28 11:50:14 -04:00
def refresh!
2019-07-06 17:26:16 -04:00
ResolveAccountService . new . call ( acct ) unless local?
2017-09-28 11:50:14 -04:00
end
2019-05-14 13:05:02 -04:00
def silenced?
silenced_at . present?
end
2019-07-13 10:45:50 -04:00
def silence! ( date = Time . now . utc )
2019-05-14 13:05:02 -04:00
update! ( silenced_at : date )
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
end
def unsilence!
2019-10-09 01:11:23 -04:00
update! ( silenced_at : nil )
2019-05-14 13:05:02 -04:00
end
def suspended?
2020-12-15 11:23:58 -05:00
suspended_at . present? && ! instance_actor?
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
end
2020-11-07 18:28:39 -05:00
def suspended_permanently?
suspended? && deletion_request . nil?
end
def suspended_temporarily?
suspended? && deletion_request . present?
end
2023-11-30 10:43:26 -05:00
alias unavailable? suspended?
alias permanently_unavailable? suspended_permanently?
2021-07-13 23:35:49 -04:00
def suspend! ( date : Time . now . utc , origin : :local , block_email : true )
2018-08-22 05:53:41 -04:00
transaction do
2020-09-15 08:37:58 -04:00
create_deletion_request!
2020-11-07 18:28:39 -05:00
update! ( suspended_at : date , suspension_origin : origin )
2021-07-13 23:35:49 -04:00
create_canonical_email_block! if block_email
2018-08-22 05:53:41 -04:00
end
end
2017-11-07 13:06:44 -05:00
def unsuspend!
transaction do
2020-09-15 08:37:58 -04:00
deletion_request & . destroy!
2020-11-07 18:28:39 -05:00
update! ( suspended_at : nil , suspension_origin : nil )
2021-04-16 21:14:25 -04:00
destroy_canonical_email_block!
2017-11-07 13:06:44 -05:00
end
end
2020-11-04 14:45:01 -05:00
def sensitized?
sensitized_at . present?
end
def sensitize! ( date = Time . now . utc )
update! ( sensitized_at : date )
end
def unsensitize!
update! ( sensitized_at : nil )
end
2017-11-07 13:06:44 -05:00
def memorialize!
2020-09-15 08:37:58 -04:00
update! ( memorial : true )
2017-11-07 13:06:44 -05:00
end
2019-06-04 17:11:18 -04:00
def sign?
true
end
2022-02-14 15:27:53 -05:00
def previous_strikes_count
strikes . where ( overruled_at : nil ) . count
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 )
2021-01-12 03:27:38 -05:00
hashtags_map = Tag . find_or_create_by_names ( tag_names ) . index_by ( & :name )
2018-12-06 11:36:11 -05:00
# Remove hashtags that are to be deleted
tags . each do | tag |
if hashtags_map . key? ( tag . name )
hashtags_map . delete ( tag . name )
else
2021-05-07 08:33:43 -04:00
tags . delete ( tag )
2018-12-06 11:36:11 -05:00
end
end
# Add hashtags that were so far missing
hashtags_map . each_value do | tag |
2021-05-07 08:33:43 -04:00
tags << tag
2018-12-06 11:36:11 -05:00
end
end
2019-01-10 12:46:17 -05:00
def also_known_as
self [ :also_known_as ] || [ ]
end
2018-04-14 06:41:08 -04:00
def fields
2023-05-23 04:49:12 -04:00
( self [ :fields ] || [ ] ) . filter_map do | f |
2022-11-09 02:24:21 -05:00
Account :: Field . new ( self , f )
2021-08-11 10:40:55 -04:00
rescue
nil
2023-05-23 04:49:12 -04:00
end
2018-04-14 06:41:08 -04:00
end
def fields_attributes = ( attributes )
2018-09-18 10:45:58 -04:00
fields = [ ]
old_fields = self [ :fields ] || [ ]
2019-03-05 09:19:54 -05:00
old_fields = [ ] if old_fields . is_a? ( Hash )
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 ] }
2023-02-18 06:37:47 -05:00
attr [ :verified_at ] = previous [ 'verified_at' ] if previous && previous [ 'verified_at' ] . present?
2018-09-18 10:45:58 -04:00
2018-05-05 15:11:19 -04:00
fields << attr
end
2018-04-14 06:41:08 -04:00
end
self [ :fields ] = fields
end
def build_fields
2022-05-25 06:27:11 -04:00
return if fields . size > = DEFAULT_FIELDS_SIZE
2018-09-18 10:45:58 -04:00
tmp = self [ :fields ] || [ ]
2019-03-08 13:59:08 -05:00
tmp = [ ] if tmp . is_a? ( Hash )
2018-09-18 10:45:58 -04:00
2022-05-25 06:27:11 -04:00
( DEFAULT_FIELDS_SIZE - tmp . size ) . times do
2018-09-18 10:45:58 -04:00
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-05-05 15:37:02 -04:00
def save_with_optional_media!
2016-12-02 08:14:49 -05:00
save!
2022-12-15 11:11:14 -05:00
rescue ActiveRecord :: RecordInvalid = > e
errors = e . record . errors . errors
errors . each do | err |
if err . attribute == :avatar
self . avatar = nil
elsif err . attribute == :header
self . header = nil
end
end
2019-10-09 01:10:46 -04:00
2017-01-18 20:14:57 -05:00
save!
2016-02-28 08:33:13 -05:00
end
2020-03-08 19:10:29 -04:00
def hides_followers?
2022-03-07 03:36:47 -05:00
hide_collections?
2020-03-08 19:10:29 -04:00
end
def hides_following?
2022-03-07 03:36:47 -05:00
hide_collections?
2020-03-08 19:10:29 -04: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
2022-08-25 14:39:40 -04:00
def to_log_human_identifier
acct
end
2017-04-28 09:10:41 -04:00
def excluded_from_timeline_account_ids
2021-04-12 06:37:14 -04:00
Rails . cache . fetch ( " exclude_account_ids_for: #{ id } " ) { block_relationships . pluck ( :target_account_id ) + blocked_by_relationships . pluck ( :account_id ) + mute_relationships . pluck ( :target_account_id ) }
2017-04-28 09:10:41 -04:00
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
Add follower synchronization mechanism (#14510)
* Add support for followers synchronization on the receiving end
Check the `collectionSynchronization` attribute on `Create` and `Announce`
activities and synchronize followers from provided collection if possible.
* Add tests for followers synchronization on the receiving end
* Add support for follower synchronization on the sender's end
* Add tests for the sending end
* Switch from AS attributes to HTTP header
Replace the custom `collectionSynchronization` ActivityStreams attribute by
an HTTP header (`X-AS-Collection-Synchronization`) with the same syntax as
the `Signature` header and the following fields:
- `collectionId` to specify which collection to synchronize
- `digest` for the SHA256 hex-digest of the list of followers known on the
receiving instance (where “receiving instance” is determined by accounts
sharing the same host name for their ActivityPub actor `id`)
- `url` of a collection that should be fetched by the instance actor
Internally, move away from the webfinger-based `domain` attribute and use
account `uri` prefix to group accounts.
* Add environment variable to disable followers synchronization
Since the whole mechanism relies on some new preconditions that, in some
extremely rare cases, might not be met, add an environment variable
(DISABLE_FOLLOWERS_SYNCHRONIZATION) to disable the mechanism altogether and
avoid followers being incorrectly removed.
The current conditions are:
1. all managed accounts' actor `id` and inbox URL have the same URI scheme and
netloc.
2. all accounts whose actor `id` or inbox URL share the same URI scheme and
netloc as a managed account must be managed by the same Mastodon instance
as well.
As far as Mastodon is concerned, breaking those preconditions require extensive
configuration changes in the reverse proxy and might also cause other issues.
Therefore, this environment variable provides a way out for people with highly
unusual configurations, and can be safely ignored for the overwhelming majority
of Mastodon administrators.
* Only set follower synchronization header on non-public statuses
This is to avoid unnecessary computations and allow Follow-related
activities to be handled by the usual codepath instead of going through
the synchronization mechanism (otherwise, any Follow/Undo/Accept activity
would trigger the synchronization mechanism even if processing the activity
itself would be enough to re-introduce synchronization)
* Change how ActivityPub::SynchronizeFollowersService handles follow requests
If the remote lists a local follower which we only know has sent a follow
request, consider the follow request as accepted instead of sending an Undo.
* Integrate review feeback
- rename X-AS-Collection-Synchronization to Collection-Synchronization
- various minor refactoring and code style changes
* Only select required fields when computing followers_hash
* Use actor URI rather than webfinger domain in synchronization endpoint
* Change hash computation to be a XOR of individual hashes
Makes it much easier to be memory-efficient, and avoid sorting discrepancy issues.
* Marginally improve followers_hash computation speed
* Further improve hash computation performances by using pluck_each
2020-10-21 12:04:09 -04:00
def synchronization_uri_prefix
return 'local' if local?
2021-08-11 11:48:42 -04:00
@synchronization_uri_prefix || = " #{ uri [ URL_PREFIX_RE ] } / "
Add follower synchronization mechanism (#14510)
* Add support for followers synchronization on the receiving end
Check the `collectionSynchronization` attribute on `Create` and `Announce`
activities and synchronize followers from provided collection if possible.
* Add tests for followers synchronization on the receiving end
* Add support for follower synchronization on the sender's end
* Add tests for the sending end
* Switch from AS attributes to HTTP header
Replace the custom `collectionSynchronization` ActivityStreams attribute by
an HTTP header (`X-AS-Collection-Synchronization`) with the same syntax as
the `Signature` header and the following fields:
- `collectionId` to specify which collection to synchronize
- `digest` for the SHA256 hex-digest of the list of followers known on the
receiving instance (where “receiving instance” is determined by accounts
sharing the same host name for their ActivityPub actor `id`)
- `url` of a collection that should be fetched by the instance actor
Internally, move away from the webfinger-based `domain` attribute and use
account `uri` prefix to group accounts.
* Add environment variable to disable followers synchronization
Since the whole mechanism relies on some new preconditions that, in some
extremely rare cases, might not be met, add an environment variable
(DISABLE_FOLLOWERS_SYNCHRONIZATION) to disable the mechanism altogether and
avoid followers being incorrectly removed.
The current conditions are:
1. all managed accounts' actor `id` and inbox URL have the same URI scheme and
netloc.
2. all accounts whose actor `id` or inbox URL share the same URI scheme and
netloc as a managed account must be managed by the same Mastodon instance
as well.
As far as Mastodon is concerned, breaking those preconditions require extensive
configuration changes in the reverse proxy and might also cause other issues.
Therefore, this environment variable provides a way out for people with highly
unusual configurations, and can be safely ignored for the overwhelming majority
of Mastodon administrators.
* Only set follower synchronization header on non-public statuses
This is to avoid unnecessary computations and allow Follow-related
activities to be handled by the usual codepath instead of going through
the synchronization mechanism (otherwise, any Follow/Undo/Accept activity
would trigger the synchronization mechanism even if processing the activity
itself would be enough to re-introduce synchronization)
* Change how ActivityPub::SynchronizeFollowersService handles follow requests
If the remote lists a local follower which we only know has sent a follow
request, consider the follow request as accepted instead of sending an Undo.
* Integrate review feeback
- rename X-AS-Collection-Synchronization to Collection-Synchronization
- various minor refactoring and code style changes
* Only select required fields when computing followers_hash
* Use actor URI rather than webfinger domain in synchronization endpoint
* Change hash computation to be a XOR of individual hashes
Makes it much easier to be memory-efficient, and avoid sorting discrepancy issues.
* Marginally improve followers_hash computation speed
* Further improve hash computation performances by using pluck_each
2020-10-21 12:04:09 -04:00
end
2022-02-24 18:34:14 -05:00
def requires_review?
reviewed_at . nil?
end
def reviewed?
reviewed_at . present?
end
def requested_review?
requested_review_at . present?
end
def requires_review_notification?
requires_review? && ! requested_review?
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-08-12 18:44:41 -04:00
def inboxes
2020-12-07 06:08:30 -05:00
urls = reorder ( nil ) . where ( protocol : :activitypub ) . group ( :preferred_inbox_url ) . pluck ( Arel . sql ( " coalesce(nullif(accounts.shared_inbox_url, ''), accounts.inbox_url) AS preferred_inbox_url " ) )
2020-04-15 14:33:24 -04:00
DeliveryFailureTracker . without_unavailable ( urls )
2017-08-12 18:44:41 -04:00
end
2024-01-08 10:31:13 -05:00
def coalesced_activity_timestamps
Arel . sql (
<< ~ SQL . squish
COALESCE ( users . current_sign_in_at , account_stats . last_status_at , to_timestamp ( 0 ) )
SQL
)
end
2022-01-23 12:10:10 -05:00
def from_text ( text )
return [ ] if text . blank?
2017-03-17 15:47:38 -04:00
2022-01-23 12:10:10 -05:00
text . scan ( MENTION_RE ) . map { | match | match . first . split ( '@' , 2 ) } . uniq . filter_map do | ( username , domain ) |
2023-02-18 17:09:40 -05:00
domain = if TagManager . instance . local_domain? ( domain )
nil
else
TagManager . instance . normalize_domain ( domain )
end
2022-01-23 12:10:10 -05:00
EntityCache . instance . mention ( username , domain )
end
end
2023-08-17 03:13:26 -04:00
def inverse_alias ( key , original_key )
2023-12-18 05:26:09 -05:00
define_method ( :" #{ key } = " ) do | value |
public_send ( :" #{ original_key } = " , ! ActiveModel :: Type :: Boolean . new . cast ( value ) )
2023-08-17 03:13:26 -04:00
end
define_method ( key ) do
! public_send ( original_key )
end
end
2016-10-03 11:16:58 -04:00
end
2023-08-17 03:13:26 -04:00
inverse_alias :show_collections , :hide_collections
inverse_alias :unlocked , :locked
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-07-14 13:47:53 -04:00
before_validation :prepare_contents , if : :local?
2023-05-02 12:23:35 -04:00
before_create :generate_keys
2018-12-02 19:32:08 -05:00
before_destroy :clean_feed_manager
2017-04-18 17:15:44 -04:00
2022-04-26 15:22:09 -04:00
def ensure_keys!
return unless local? && private_key . blank? && public_key . blank?
2023-02-20 00:58:28 -05:00
2022-04-26 15:22:09 -04:00
generate_keys
save!
end
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
2019-07-18 19:44:42 -04:00
return unless local? && private_key . blank? && public_key . blank?
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?
2018-12-26 00:38:42 -05:00
super
2017-04-24 20:47:31 -04:00
end
2018-05-06 05:48:51 -04:00
def emojifiable_text
2019-08-11 07:15:18 -04:00
[ note , display_name , fields . map ( & :name ) , fields . map ( & :value ) ] . join ( ' ' )
2018-05-06 05:48:51 -04:00
end
2018-12-02 19:32:08 -05:00
def clean_feed_manager
2020-12-22 17:57:46 -05:00
FeedManager . instance . clean_feeds! ( :home , [ id ] )
2018-12-02 19:32:08 -05:00
end
2021-04-16 21:14:25 -04:00
def create_canonical_email_block!
return unless local? && user_email . present?
2021-07-02 06:03:15 -04:00
begin
CanonicalEmailBlock . create ( reference_account : self , email : user_email )
rescue ActiveRecord :: RecordNotUnique
# A canonical e-mail block may already exist for the same e-mail
end
2021-04-16 21:14:25 -04:00
end
def destroy_canonical_email_block!
return unless local?
CanonicalEmailBlock . where ( reference_account : self ) . delete_all
end
2023-03-19 02:47:54 -04:00
# NOTE: the `account.created` webhook is triggered by the `User` model, not `Account`.
def trigger_update_webhooks
TriggerWebhookWorker . perform_async ( 'account.updated' , 'Account' , id ) if local?
end
2016-02-20 16:53:20 -05:00
end