Commiting

app/models/concerns/account_associations.rb

@@ -7,16 +7,11 @@ module AccountAssociations
     # Local users
     has_one :user, inverse_of: :account, dependent: :destroy
 
-    # Identity proofs
-    has_many :identity_proofs, class_name: 'AccountIdentityProof', dependent: :destroy, inverse_of: :account
-
     # Timelines
-    has_many :stream_entries, inverse_of: :account, dependent: :destroy
     has_many :statuses, inverse_of: :account, dependent: :destroy
     has_many :favourites, inverse_of: :account, dependent: :destroy
     has_many :mentions, inverse_of: :account, dependent: :destroy
     has_many :notifications, inverse_of: :account, dependent: :destroy
-    has_many :conversations, class_name: 'AccountConversation', dependent: :destroy, inverse_of: :account
     has_many :scheduled_statuses, inverse_of: :account, dependent: :destroy
 
     # Pinned statuses
@@ -27,10 +22,6 @@ module AccountAssociations
     has_many :status_pins, inverse_of: :account, dependent: :destroy
     has_many :pinned_statuses, -> { reorder('status_pins.created_at DESC') }, through: :status_pins, class_name: 'Status', source: :status
 
-    # Endorsements
-    has_many :account_pins, inverse_of: :account, dependent: :destroy
-    has_many :endorsed_accounts, through: :account_pins, class_name: 'Account', source: :target_account
-
     # Media
     has_many :media_attachments, dependent: :destroy
     has_many :polls, dependent: :destroy
@@ -63,7 +54,6 @@ module AccountAssociations
 
     # Hashtags
     has_and_belongs_to_many :tags
-    has_many :featured_tags, -> { includes(:tag) }, dependent: :destroy, inverse_of: :account
 
     # Billing
     has_many :transactions, class_name: 'Transaction', dependent: :destroy, inverse_of: :account

app/models/concerns/account_finder_concern.rb

@@ -8,10 +8,6 @@ module AccountFinderConcern
       find_local(username) || raise(ActiveRecord::RecordNotFound)
     end
 
-    def find_remote!(username, domain)
-      find_remote(username, domain) || raise(ActiveRecord::RecordNotFound)
-    end
-
     def find_acct!(acct)
       find_acct(acct) || raise(ActiveRecord::RecordNotFound)
     end
@@ -21,25 +17,24 @@ module AccountFinderConcern
     end
 
     def find_local(username)
-      find_remote(username, nil)
-    end
-
-    def find_remote(username, domain)
-      AccountFinder.new(username, domain).account
+      find_now(username)
     end
 
     def find_acct(acct)
       username, domain = acct.split("@")
-      find_remote(username, domain)
+      find_now(username)
+    end
+
+    def find_now(username)
+      AccountFinder.new(username).account
     end
   end
 
   class AccountFinder
-    attr_reader :username, :domain
+    attr_reader :username
 
-    def initialize(username, domain)
+    def initialize(username)
       @username = username
-      @domain = domain
     end
 
     def account
@@ -65,11 +60,7 @@ module AccountFinderConcern
     end
 
     def matching_domain
-      if domain.nil?
-        Account.where(domain: nil)
-      else
-        Account.where(Account.arel_table[:domain].lower.eq domain.to_s.downcase)
-      end
+      Account.where(domain: nil)
     end
   end
 end

app/models/concerns/account_interactions.rb

@@ -40,20 +40,6 @@ module AccountInteractions
       end
     end
 
-    def endorsed_map(target_account_ids, account_id)
-      follow_mapping(AccountPin.where(account_id: account_id, target_account_id: target_account_ids), :target_account_id)
-    end
-
-    def domain_blocking_map(target_account_ids, account_id)
-      accounts_map    = Account.where(id: target_account_ids).select('id, domain').each_with_object({}) { |a, h| h[a.id] = a.domain }
-      blocked_domains = domain_blocking_map_by_domain(accounts_map.values.compact, account_id)
-      accounts_map.reduce({}) { |h, (id, domain)| h.merge(id => blocked_domains[domain]) }
-    end
-
-    def domain_blocking_map_by_domain(target_domains, account_id)
-      follow_mapping(AccountDomainBlock.where(account_id: account_id, domain: target_domains), :domain)
-    end
-
     private
 
     def follow_mapping(query, field)
@@ -85,8 +71,6 @@ module AccountInteractions
     has_many :muting, -> { order('mutes.id desc') }, through: :mute_relationships, source: :target_account
     has_many :muted_by_relationships, class_name: 'Mute', foreign_key: :target_account_id, dependent: :destroy
     has_many :muted_by, -> { order('mutes.id desc') }, through: :muted_by_relationships, source: :account
-    has_many :conversation_mutes, dependent: :destroy
-    has_many :domain_blocks, class_name: 'AccountDomainBlock', dependent: :destroy
   end
 
   def follow!(other_account, reblogs: nil, uri: nil)
@@ -120,14 +104,6 @@ module AccountInteractions
     mute
   end
 
-  def mute_conversation!(conversation)
-    conversation_mutes.find_or_create_by!(conversation: conversation)
-  end
-
-  def block_domain!(other_domain)
-    domain_blocks.find_or_create_by!(domain: other_domain)
-  end
-
   def unfollow!(other_account)
     follow = active_relationships.find_by(target_account: other_account)
     follow&.destroy
@@ -143,16 +119,6 @@ module AccountInteractions
     mute&.destroy
   end
 
-  def unmute_conversation!(conversation)
-    mute = conversation_mutes.find_by(conversation: conversation)
-    mute&.destroy!
-  end
-
-  def unblock_domain!(other_domain)
-    block = domain_blocks.find_by(domain: other_domain)
-    block&.destroy
-  end
-
   def following?(other_account)
     active_relationships.where(target_account: other_account).exists?
   end
@@ -161,18 +127,10 @@ module AccountInteractions
     block_relationships.where(target_account: other_account).exists?
   end
 
-  def domain_blocking?(other_domain)
-    domain_blocks.where(domain: other_domain).exists?
-  end
-
   def muting?(other_account)
     mute_relationships.where(target_account: other_account).exists?
   end
 
-  def muting_conversation?(conversation)
-    conversation_mutes.where(conversation: conversation).exists?
-  end
-
   def muting_notifications?(other_account)
     mute_relationships.where(target_account: other_account, hide_notifications: true).exists?
   end
@@ -201,10 +159,6 @@ module AccountInteractions
     status_pins.where(status: status).exists?
   end
 
-  def endorsed?(account)
-    account_pins.where(target_account: account).exists?
-  end
-
   def followers_for_local_distribution
     followers.local
              .joins(:user)

app/models/concerns/omniauthable.rb

@@ -44,9 +44,9 @@ module Omniauthable
       # verified email.  If no verified email was provided or the user already
       # exists, we assign a temporary email and ask the user to verify it on
       # the next step via Auth::ConfirmationsController.finish_signup
-
+      
+      # : TODO : remove, no sign up from app. only website
       user = User.new(user_params_from_auth(auth))
-      user.account.avatar_remote_url = auth.info.image if auth.info.image =~ /\A#{URI.regexp(%w(http https))}\z/
       user.skip_confirmation!
       user.save!
       user

app/models/concerns/status_threading_concern.rb

@@ -122,7 +122,6 @@ module StatusThreadingConcern
       blocked_by: Account.blocked_by_map(account_ids, account.id),
       muting: Account.muting_map(account_ids, account.id),
       following: Account.following_map(account_ids, account.id),
-      domain_blocking_by_domain: Account.domain_blocking_map_by_domain(domains, account.id),
     }
   end
 

app/models/concerns/streamable.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Streamable
-  extend ActiveSupport::Concern
-
-  included do
-    has_one :stream_entry, as: :activity
-
-    after_create do
-      account.stream_entries.create!(activity: self, hidden: hidden?) if needs_stream_entry?
-    end
-  end
-
-  def title
-    super
-  end
-
-  def content
-    title
-  end
-
-  def target
-    super
-  end
-
-  def object_type
-    :activity
-  end
-
-  def thread
-    super
-  end
-
-  def hidden?
-    false
-  end
-
-  private
-
-  def needs_stream_entry?
-    account.local?
-  end
-end