threddedDANIEL 0.14.5

data/app/models/thredded/post_moderation_record.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PostModerationRecord < ActiveRecord::Base
+    include Thredded::ModerationState
+    # Rails 4 doesn't support enum _prefix
+    if Rails::VERSION::MAJOR >= 5
+      enum previous_moderation_state: moderation_states, _prefix: :previous
+    end
+    validates :previous_moderation_state, presence: true
+
+    scope :order_newest_first, -> { order(created_at: :desc, id: :desc) }
+
+    belongs_to :messageboard, inverse_of: :post_moderation_records
+    validates :messageboard_id, presence: true unless Thredded.rails_gte_51?
+    belongs_to :post,
+               inverse_of: :moderation_records,
+               **(Thredded.rails_gte_51? ? { optional: true } : {})
+    belongs_to :post_user,
+               class_name: Thredded.user_class_name,
+               inverse_of: :thredded_post_moderation_records,
+               **(Thredded.rails_gte_51? ? { optional: true } : {})
+    belongs_to :moderator,
+               class_name: Thredded.user_class_name,
+               inverse_of: :thredded_post_moderation_records,
+               **(Thredded.rails_gte_51? ? { optional: true } : {})
+
+    validates_each :moderation_state do |record, attr, value|
+      if record.previous_moderation_state == value
+        record.errors.add attr, "Post moderation_state is already #{value}"
+      end
+    end
+
+    # @param [Thredded.user_class] moderator
+    # @param [Thredded::Post] post
+    # @param [Symbol, String] previous_moderation_state
+    # @param [Symbol, String] moderation_state
+    # @return [Thredded::PostModerationRecord] the newly created persisted record
+    def self.record!(moderator:, post:, previous_moderation_state:, moderation_state:)
+      # Rails 4 doesn't support enum _prefix
+      if Rails::VERSION::MAJOR < 5
+        previous_moderation_state = moderation_states[previous_moderation_state.to_s]
+      end
+      create!(
+        previous_moderation_state: previous_moderation_state,
+        moderation_state:          moderation_state,
+        moderator:                 moderator,
+        post:                      post,
+        post_content:              post.content,
+        post_user:                 post.user,
+        post_user_name:            post.user.try(:thredded_display_name),
+        messageboard_id:           post.messageboard_id,
+      )
+    end
+  end
+end

data/app/models/thredded/private_post.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PrivatePost < ActiveRecord::Base
+    include Thredded::PostCommon
+
+    belongs_to :user,
+               class_name: Thredded.user_class_name,
+               inverse_of: :thredded_private_posts,
+               **(Thredded.rails_gte_51? ? { optional: true } : {})
+    belongs_to :postable,
+               class_name:    'Thredded::PrivateTopic',
+               inverse_of:    :posts,
+               counter_cache: :posts_count
+    belongs_to :user_detail,
+               inverse_of:  :private_posts,
+               primary_key: :user_id,
+               foreign_key: :user_id,
+               **(Thredded.rails_gte_51? ? { optional: true } : {})
+
+    after_commit :update_parent_last_user_and_timestamp, on: %i[create destroy]
+    after_commit :notify_users, on: [:create]
+
+    # @param [Integer] per_page
+    def page(per_page: self.class.default_per_page)
+      calculate_page(postable.posts, per_page)
+    end
+
+    def private_topic_post?
+      true
+    end
+
+    # @return [ActiveRecord::Relation<Thredded.user_class>] users that can read this post.
+    def readers
+      collection_proxy = postable.users
+      if persisted?
+        collection_proxy.scope
+      else
+        Thredded.user_class.where(id: collection_proxy.to_a.map(&:id))
+      end
+    end
+
+    private
+
+    def notify_users
+      Thredded::NotifyPrivateTopicUsersJob.perform_later(id)
+    end
+
+    def update_parent_last_user_and_timestamp
+      return if postable.destroyed?
+      last_post = if destroyed?
+                    postable.posts.order_oldest_first.select(:user_id, :created_at).last
+                  else
+                    self
+                  end
+      postable.update_columns(
+        last_user_id: last_post.user_id,
+        last_post_at: last_post.created_at,
+        updated_at: Time.zone.now
+      )
+    end
+  end
+end

data/app/models/thredded/private_topic.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PrivateTopic < ActiveRecord::Base
+    include Thredded::TopicCommon
+
+    scope :for_user, ->(user) { joins(:private_users).merge(PrivateUser.where(user_id: user.id)) }
+
+    extend FriendlyId
+    friendly_id :slug_candidates,
+                use:            %i[history reserved],
+                # Avoid route conflicts
+                reserved_words: ::Thredded::FriendlyIdReservedWordsAndPagination.new(%w[new])
+
+    belongs_to :user,
+               class_name: Thredded.user_class_name,
+               inverse_of: :thredded_private_topics,
+               **(Thredded.rails_gte_51? ? { optional: true } : {})
+    belongs_to :user_detail,
+               primary_key:   :user_id,
+               foreign_key:   :user_id,
+               inverse_of:    :private_topics,
+               **(Thredded.rails_gte_51? ? { optional: true } : {})
+
+    has_many :posts,
+             class_name:  'Thredded::PrivatePost',
+             foreign_key: :postable_id,
+             inverse_of:  :postable,
+             dependent:   :destroy
+    has_one :first_post, -> { order_oldest_first },
+            class_name:  'Thredded::PrivatePost',
+            foreign_key: :postable_id
+    has_many :private_users, inverse_of: :private_topic
+    has_many :users, through: :private_users
+    has_many :user_read_states,
+             class_name: 'Thredded::UserPrivateTopicReadState',
+             foreign_key: :postable_id,
+             inverse_of: :postable,
+             dependent: :destroy
+
+    validates_each :users do |model, _attr, users|
+      # Must include the creator + at least one other user
+      if users.length < 2
+        model.errors.add(:user_ids, I18n.t('thredded.private_topics.errors.user_ids_length'))
+      end
+      unless users.include?(model.user)
+        # This never happens in the UI, so we don't need to i18n the message.
+        model.errors.add(:user_ids, 'must include in user_ids')
+      end
+    end
+
+    before_validation :ensure_user_in_private_users
+
+    # Finds the topic by its slug or ID, or raises Thredded::Errors::PrivateTopicNotFound.
+    # @param slug_or_id [String]
+    # @return [Thredded::PrivateTopic]
+    # @raise [Thredded::Errors::PrivateTopicNotFound] if the topic with the given slug does not exist.
+    def self.friendly_find!(slug_or_id)
+      friendly.find(slug_or_id)
+    rescue ActiveRecord::RecordNotFound
+      raise Thredded::Errors::PrivateTopicNotFound
+    end
+
+    def public?
+      false
+    end
+
+    def should_generate_new_friendly_id?
+      title_changed?
+    end
+
+    def normalize_friendly_id(input)
+      Thredded.slugifier.call(input.to_s)
+    end
+
+    private
+
+    def slug_candidates
+      [
+        :title,
+        [:title, '-topic']
+      ]
+    end
+
+    def ensure_user_in_private_users
+      users << user if user.present? && !users.include?(user)
+    end
+  end
+end

data/app/models/thredded/private_user.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PrivateUser < ActiveRecord::Base
+    belongs_to :private_topic, inverse_of: :private_users
+    belongs_to :user, class_name: Thredded.user_class_name, inverse_of: :thredded_private_users
+  end
+end

data/app/models/thredded/stats.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Thredded
+  class Stats
+    include ActionView::Helpers::NumberHelper
+
+    def messageboards_count
+      number_to_human(messageboards.count, precision: 4)
+    end
+
+    def topics_count
+      number_to_human(messageboards.map(&:topics_count).sum, precision: 4)
+    end
+
+    def posts_count
+      number_to_human(messageboards.map(&:posts_count).sum, precision: 5)
+    end
+
+    private
+
+    def messageboards
+      @messageboards ||= Thredded::Messageboard.ordered
+    end
+  end
+end

data/app/models/thredded/topic.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Thredded
+  class Topic < ActiveRecord::Base # rubocop:disable Metrics/ClassLength
+    include Thredded::TopicCommon
+    include Thredded::ContentModerationState
+
+    scope :for_messageboard, ->(messageboard) { where(messageboard_id: messageboard.id) }
+
+    scope :stuck, -> { where(sticky: true) }
+    scope :unstuck, -> { where(sticky: false) }
+
+    # Using `search_query` instead of `search` to avoid conflict with Ransack.
+    scope :search_query, ->(query) { ::Thredded::TopicsSearch.new(query, self).search }
+
+    scope :order_sticky_first, -> { order(sticky: :desc) }
+
+    scope :followed_by, lambda { |user|
+      joins(:user_follows)
+        .where(thredded_user_topic_follows: { user_id: user.id })
+    }
+    scope :unread_followed_by, ->(user) { followed_by(user).unread(user) }
+
+    extend FriendlyId
+    friendly_id :slug_candidates,
+                use: %i[history reserved],
+                # Avoid route conflicts
+                reserved_words: ::Thredded::FriendlyIdReservedWordsAndPagination.new(%w[topics])
+
+    belongs_to :user,
+               class_name: Thredded.user_class_name,
+               inverse_of: :thredded_topics,
+               **(Thredded.rails_gte_51? ? { optional: true } : {})
+
+    belongs_to :messageboard,
+               counter_cache: true,
+               touch: true,
+               inverse_of: :topics
+    validates :messageboard_id, presence: true
+
+    belongs_to :user_detail,
+               primary_key:   :user_id,
+               foreign_key:   :user_id,
+               inverse_of:    :topics,
+               counter_cache: :topics_count,
+               **(Thredded.rails_gte_51? ? { optional: true } : {})
+
+    has_many :posts,
+             autosave: true,
+             class_name:  'Thredded::Post',
+             foreign_key: :postable_id,
+             inverse_of:  :postable,
+             dependent:   :destroy
+    has_one :first_post, -> { order_oldest_first },
+            class_name:  'Thredded::Post',
+            foreign_key: :postable_id
+    has_one :last_post, -> { order_newest_first },
+            class_name:  'Thredded::Post',
+            foreign_key: :postable_id
+
+    has_many :topic_categories, dependent: :destroy
+    has_many :categories, through: :topic_categories
+    has_many :user_read_states,
+             class_name: 'Thredded::UserTopicReadState',
+             foreign_key: :postable_id,
+             inverse_of: :postable,
+             dependent: :destroy
+    has_many :user_follows,
+             class_name: 'Thredded::UserTopicFollow',
+             inverse_of: :topic,
+             dependent: :destroy
+    has_many :followers,
+             class_name: Thredded.user_class_name,
+             source: :user,
+             through: :user_follows
+
+    delegate :name, to: :messageboard, prefix: true
+
+    after_commit :update_messageboard_last_topic, on: :update, if: -> { previous_changes.include?('moderation_state') }
+    after_commit :update_last_user_and_time_from_last_post!, if: -> { previous_changes.include?('moderation_state') }
+
+    after_commit :handle_messageboard_change_after_commit,
+                 on: :update,
+                 if: -> { previous_changes.include?('messageboard_id') }
+
+    # Finds the topic by its slug or ID, or raises Thredded::Errors::TopicNotFound.
+    # @param slug_or_id [String]
+    # @return [Thredded::Topic]
+    # @raise [Thredded::Errors::TopicNotFound] if the topic with the given slug does not exist.
+    def self.friendly_find!(slug_or_id)
+      friendly.find(slug_or_id)
+    rescue ActiveRecord::RecordNotFound
+      raise Thredded::Errors::TopicNotFound
+    end
+
+    class << self
+      private
+
+      # @param user [Thredded.user_class]
+      # @return [ByPostableLookup]
+      def follows_by_topic_hash(user)
+        Thredded::TopicCommon::CachingHash.from_relation(
+          Thredded::UserTopicFollow.where(user_id: user.id, topic_id: current_scope.map(&:id))
+        )
+      end
+
+      public
+
+      # @param user [Thredded.user_class]
+      # @return [Array<[TopicCommon, UserTopicReadStateCommon, UserTopicFollow]>]
+      def with_read_and_follow_states(user)
+        null_read_state = Thredded::NullUserTopicReadState.new
+        return current_scope.zip([null_read_state, nil]) if user.thredded_anonymous?
+        read_states_by_topic = read_states_by_postable_hash(user)
+        follows_by_topic = follows_by_topic_hash(user)
+        current_scope.map do |topic|
+          [topic, read_states_by_topic[topic] || null_read_state, follows_by_topic[topic]]
+        end
+      end
+    end
+
+    def public?
+      true
+    end
+
+    # @return [Thredded::PostModerationRecord, nil]
+    def last_moderation_record
+      first_post.try(:last_moderation_record)
+    end
+
+    def update_last_user_and_time_from_last_post!
+      return if destroyed?
+      scope = posts.order_newest_first
+      scope = scope.moderation_state_visible_to_all if moderation_state_visible_to_all?
+      last_post = scope.select(:user_id, :created_at).first
+      if last_post
+        update_columns(last_user_id: last_post.user_id, last_post_at: last_post.created_at, updated_at: Time.zone.now)
+      else
+        # Either a visible topic is left with no visible posts, or an invisible topic is left with no posts at all.
+        # This shouldn't happen in stock Thredded.
+        update_columns(last_user_id: nil, last_post_at: created_at, updated_at: Time.zone.now)
+      end
+    end
+
+    def should_generate_new_friendly_id?
+      title_changed?
+    end
+
+    def normalize_friendly_id(input)
+      Thredded.slugifier.call(input.to_s)
+    end
+
+    private
+
+    def slug_candidates
+      [
+        :title,
+        [:title, '-', messageboard.try(:name)],
+        [:title, '-', messageboard.try(:name), '-topic']
+      ]
+    end
+
+    def update_messageboard_last_topic
+      messageboard.update_last_topic!
+    end
+
+    def handle_messageboard_change_after_commit
+      # Update the `posts.messageboard_id` column. The column is just a performance optimization,
+      # so use update_all to avoid validitaing, triggering callbacks, and updating the timestamps:
+      posts.update_all(messageboard_id: messageboard_id)
+
+      # Update the associated messageboard metadata that Rails does not update them automatically.
+      previous_changes['messageboard_id'].each do |messageboard_id|
+        Thredded::Messageboard.reset_counters(messageboard_id, :topics, :posts)
+        Thredded::Messageboard.find(messageboard_id).update_last_topic!
+      end
+    end
+  end
+end

data/app/models/thredded/topic_category.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Thredded
+  class TopicCategory < ActiveRecord::Base
+    belongs_to :category
+    belongs_to :topic
+  end
+end

data/app/models/thredded/user_detail.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Thredded
+  class UserDetail < ActiveRecord::Base
+    include Thredded::ModerationState
+
+    belongs_to :user, class_name: Thredded.user_class_name, inverse_of: :thredded_user_detail
+    validates :user_id, uniqueness: true, **(Thredded.rails_gte_51? ? {} : { presence: true })
+
+    has_many :topics, class_name: 'Thredded::Topic', foreign_key: :user_id, primary_key: :user_id
+    has_many :private_topics, class_name: 'Thredded::PrivateTopic', foreign_key: :user_id, primary_key: :user_id
+    has_many :posts, class_name: 'Thredded::Post', foreign_key: :user_id, primary_key: :user_id
+    has_many :private_posts, class_name: 'Thredded::PrivatePost', foreign_key: :user_id, primary_key: :user_id
+    has_many :messageboard_users, class_name: 'Thredded::MessageboardUser', foreign_key: :thredded_user_detail_id,
+                                  inverse_of: :user_detail, dependent: :destroy
+
+    scope :recently_active, -> { where(arel_table[:last_seen_at].gt(Thredded.active_user_threshold.ago)) }
+
+    before_save :set_moderation_state_changed_at
+
+    private
+
+    def set_moderation_state_changed_at
+      self.moderation_state_changed_at = Time.current if moderation_state_changed?
+    end
+  end
+end