threddedDANIEL 0.14.5

data/app/models/concerns/thredded/user_topic_read_state_common.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Thredded
+  module UserTopicReadStateCommon
+    extend ActiveSupport::Concern
+    included do
+      extend ClassMethods
+      validates :user_id, uniqueness: { scope: :postable_id }
+    end
+
+    # @return [Boolean]
+    def read?
+      postable.last_post_at <= read_at
+    end
+
+    # @param post [Post or PrivatePost]
+    # @return [Boolean]
+    def post_read?(post)
+      post.created_at <= read_at
+    end
+
+    module ClassMethods
+      # @param user_id [Integer]
+      # @param topic_id [Integer]
+      # @param post [Thredded::PostCommon]
+      # @param post_page [Integer]
+      def touch!(user_id, topic_id, post, post_page)
+        # TODO: Switch to upsert once Travis supports PostgreSQL 9.5.
+        # Travis issue: https://github.com/travis-ci/travis-ci/issues/4264
+        # Upsert gem: https://github.com/seamusabshere/upsert
+        state = find_or_initialize_by(user_id: user_id, postable_id: topic_id)
+        fail ArgumentError, "expected post_page >= 1, given #{post_page.inspect}" if post_page < 1
+        return unless !state.read_at? || state.read_at < post.created_at
+        state.update!(read_at: post.created_at, page: post_page)
+      end
+
+      def read_on_first_post!(user, topic)
+        create!(user: user, postable: topic, read_at: Time.zone.now, page: 1)
+      end
+    end
+  end
+end

data/app/models/thredded/category.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Thredded
+  class Category < ActiveRecord::Base
+    extend FriendlyId
+    belongs_to :messageboard
+    has_many :topic_categories
+    has_many :topics, through: :topic_categories
+    friendly_id :name, use: %i[history scoped], scope: :messageboard
+
+    validates :name, presence: true
+    validates :messageboard_id, presence: true
+
+    def normalize_friendly_id(input)
+      Thredded.slugifier.call(input.to_s)
+    end
+  end
+end

data/app/models/thredded/messageboard.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Thredded
+  class Messageboard < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :slug_candidates,
+                use:            %i[slugged reserved],
+                # Avoid route conflicts
+                reserved_words: ::Thredded::FriendlyIdReservedWordsAndPagination.new(
+                  %w[
+                    admin
+                    autocomplete-users
+                    messageboards
+                    posts
+                    preferences
+                    private-posts
+                    private-topics
+                    theme-preview
+                  ]
+                )
+
+    validates :name, uniqueness: true, length: { maximum: 60 }, presence: true
+    validates :topics_count, numericality: true
+    validates :position, presence: true, on: :update
+    before_save :ensure_position, on: :create
+
+    def ensure_position
+      self.position ||= (created_at || Time.zone.now).to_i
+    end
+
+    has_many :categories, dependent: :destroy
+    has_many :user_messageboard_preferences, dependent: :destroy
+    has_many :posts, dependent: :destroy
+    has_many :topics, dependent: :destroy, inverse_of: :messageboard
+
+    belongs_to :last_topic, class_name: 'Thredded::Topic',  optional: true
+
+    has_many :user_details, through: :posts
+    has_many :messageboard_users,
+             inverse_of:  :messageboard,
+             foreign_key: :thredded_messageboard_id,
+             dependent: :destroy
+    has_many :recently_active_user_details,
+             -> { merge(Thredded::MessageboardUser.recently_active) },
+             class_name: 'Thredded::UserDetail',
+             through:    :messageboard_users,
+             source:     :user_detail
+    has_many :recently_active_users,
+             class_name: Thredded.user_class_name,
+             through:    :recently_active_user_details,
+             source:     :user
+
+    belongs_to :group,
+               inverse_of: :messageboards,
+               foreign_key: :messageboard_group_id,
+               class_name: 'Thredded::MessageboardGroup',
+               **(Thredded.rails_gte_51? ? { optional: true } : {})
+
+    has_many :post_moderation_records, inverse_of: :messageboard, dependent: :delete_all
+
+    # rubocop:disable Style/Lambda
+    scope :top_level_messageboards, -> { where(group: nil) }
+    scope :by_messageboard_group, ->(group) { where(group: group.id) }
+    scope :ordered, ->(order = Thredded.messageboards_order) {
+      case order
+      when :position
+        self
+      when :created_at_asc
+        ordered_by_created_at_asc
+      when :last_post_at_desc
+        ordered_by_last_post_at_desc
+      when :topics_count_desc
+        ordered_by_topics_count_desc
+      end.ordered_by_position.order(id: :asc)
+    }
+    scope :ordered_by_position, ->() { order(position: :asc) }
+    scope :ordered_by_created_at_asc, ->() { order(created_at: :asc) }
+    scope :ordered_by_last_post_at_desc, ->() {
+      joins('LEFT JOIN thredded_topics AS last_topics ON thredded_messageboards.last_topic_id = last_topics.id')
+        .order(Arel.sql('COALESCE(last_topics.last_post_at, thredded_messageboards.created_at) DESC'))
+    }
+    scope :ordered_by_topics_count_desc, ->() {
+      order(topics_count: :desc)
+    }
+    # rubocop:enable Style/Lambda
+
+    # Finds the messageboard by its slug or ID, or raises Thredded::Errors::MessageboardNotFound.
+    # @param slug_or_id [String]
+    # @return [Thredded::Messageboard]
+    # @raise [Thredded::Errors::MessageboardNotFound] if the messageboard 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::MessageboardNotFound
+    end
+
+    def last_user
+      last_topic.try(:last_user)
+    end
+
+    def update_last_topic!
+      return if destroyed?
+      self.last_topic = topics.order_recently_posted_first.moderation_state_visible_to_all.first
+      save! if last_topic_id_changed?
+    end
+
+    def normalize_friendly_id(input)
+      Thredded.slugifier.call(input.to_s)
+    end
+
+    private
+
+    def slug_candidates
+      [
+        :name,
+        [:name, '-board']
+      ]
+    end
+  end
+end

data/app/models/thredded/messageboard_group.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Thredded
+  class MessageboardGroup < ActiveRecord::Base
+    has_many :messageboards,
+             inverse_of: :group,
+             foreign_key: :messageboard_group_id,
+             dependent: :nullify
+
+    scope :ordered, -> { order(position: :asc, id: :asc) }
+    validates :name, presence: true, uniqueness: true
+    validates :position, presence: true, on: :update
+    before_save :ensure_position, on: :create
+
+    def ensure_position
+      self.position ||= Time.zone.now.to_i
+    end
+  end
+end

data/app/models/thredded/messageboard_notifications_for_followed_topics.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Thredded
+  class MessageboardNotificationsForFollowedTopics < ActiveRecord::Base
+    belongs_to :user_preference,
+               primary_key: :user_id,
+               foreign_key: :user_id,
+               inverse_of: :messageboard_notifications_for_followed_topics
+    belongs_to :user,
+               class_name: Thredded.user_class_name,
+               inverse_of: :thredded_user_messageboard_preferences
+    belongs_to :messageboard
+    scope :for_messageboard, ->(messageboard) { where(messageboard_id: messageboard.id) }
+
+    validates :user_id, presence: true
+    validates :messageboard_id, presence: true
+
+    def self.in(messageboard)
+      where(messageboard_id: messageboard.id)
+    end
+
+    include Thredded::NotifierPreference
+
+    def self.default(_notifier)
+      # could be moved to `notifier.defaults(:notifications_for_followed_topics)` or
+      # `notifier.defaults(:messageboard_notifications_for_followed_topics)`
+      Thredded::BaseNotifier::NotificationsDefault.new(true)
+    end
+  end
+end

data/app/models/thredded/messageboard_user.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Thredded
+  # The state of a user with regards to a messageboard, such as the last time the user was active (visited)
+  # the messageboard.
+  class MessageboardUser < ActiveRecord::Base
+    belongs_to :messageboard,
+               class_name:  'Thredded::Messageboard',
+               foreign_key: :thredded_messageboard_id,
+               inverse_of:  :messageboard_users
+    belongs_to :user_detail, class_name: 'Thredded::UserDetail', foreign_key: :thredded_user_detail_id
+    scope :recently_active, -> { where(arel_table[:last_seen_at].gt(Thredded.active_user_threshold.ago)) }
+  end
+end

data/app/models/thredded/notifications_for_followed_topics.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Thredded
+  class NotificationsForFollowedTopics < ActiveRecord::Base
+    belongs_to :user,
+               class_name: Thredded.user_class_name,
+               inverse_of: :thredded_notifications_for_followed_topics
+    belongs_to :messageboard,
+               # If messageboard is `nil`, these are the global preferences.
+               **(Thredded.rails_gte_51? ? { optional: true } : {})
+    belongs_to :user_preference,
+               primary_key: :user_id,
+               foreign_key: :user_id,
+               inverse_of: :notifications_for_followed_topics
+
+    validates :user_id, presence: true
+
+    include Thredded::NotifierPreference
+
+    def self.default(_notifier)
+      # could be moved to  `notifier.defaults(:notifications_for_followed_topics)`
+      Thredded::BaseNotifier::NotificationsDefault.new(true)
+    end
+  end
+end

data/app/models/thredded/notifications_for_private_topics.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Thredded
+  class NotificationsForPrivateTopics < ActiveRecord::Base
+    belongs_to :user,
+               class_name: Thredded.user_class_name,
+               inverse_of: :thredded_notifications_for_private_topics
+    belongs_to :user_preference,
+               primary_key: :user_id,
+               foreign_key: :user_id,
+               inverse_of: :notifications_for_private_topics
+
+    validates :user_id, presence: true
+
+    include Thredded::NotifierPreference
+
+    def self.default(_notifier)
+      # could be moved to  `notifier.defaults(:notifications_for_private_topics)`
+      Thredded::BaseNotifier::NotificationsDefault.new(true)
+    end
+  end
+end

data/app/models/thredded/null_user.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Thredded
+  class NullUser
+    include ::Thredded::UserPermissions::Read::All
+    include ::Thredded::UserPermissions::Write::None
+    include ::Thredded::UserPermissions::Message::ReadersOfWriteableBoards
+    include ::Thredded::UserPermissions::Moderate::None
+    include ::Thredded::UserPermissions::Admin::None
+
+    def thredded_private_topics
+      Thredded::PrivateTopic.none
+    end
+
+    def id
+      nil
+    end
+
+    def name
+      I18n.t('thredded.null_user_name')
+    end
+
+    def to_s
+      name
+    end
+
+    def valid?
+      false
+    end
+
+    def thredded_anonymous?
+      true
+    end
+
+    def thredded_user_detail
+      Thredded::UserDetail.new
+    end
+
+    def thredded_user_preference
+      Thredded::UserPreference.new
+    end
+
+    def thredded_display_name
+      to_s
+    end
+
+    def marked_for_destruction?
+      return false
+    end
+  end
+end

data/app/models/thredded/null_user_topic_read_state.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Thredded
+  class NullUserTopicReadState
+    def page
+      1
+    end
+
+    def read?
+      false
+    end
+
+    def post_read?(_post)
+      false
+    end
+  end
+end

data/app/models/thredded/post.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Thredded
+  class Post < ActiveRecord::Base
+    include Thredded::PostCommon
+    include Thredded::ContentModerationState
+
+    belongs_to :user,
+               class_name: Thredded.user_class_name,
+               inverse_of: :thredded_posts,
+               **(Thredded.rails_gte_51? ? { optional: true } : {})
+    belongs_to :messageboard,
+               counter_cache: true
+    belongs_to :postable,
+               class_name:    'Thredded::Topic',
+               inverse_of:    :posts,
+               counter_cache: true
+    belongs_to :user_detail,
+               inverse_of:    :posts,
+               primary_key:   :user_id,
+               foreign_key:   :user_id,
+               counter_cache: true,
+               **(Thredded.rails_gte_51? ? { optional: true } : {})
+    has_many :moderation_records,
+             class_name: 'Thredded::PostModerationRecord',
+             dependent: :nullify
+    has_many :user_notifications,
+             class_name: 'Thredded::UserPostNotification',
+             dependent: :destroy
+    has_one :last_moderation_record, -> { order_newest_first },
+            class_name: 'Thredded::PostModerationRecord'
+
+    validates :messageboard_id, presence: true
+
+    after_commit :update_parent_last_user_and_time_from_last_post, on: %i[create destroy]
+    after_commit :update_parent_last_user_and_time_from_last_post_if_moderation_state_changed, on: :update
+
+    after_commit :auto_follow_and_notify, on: %i[create update]
+
+    # @param [Integer] per_page
+    # @param [Thredded.user_class] user
+    def page(per_page: self.class.default_per_page, user:)
+      readable_posts = PostPolicy::Scope.new(user, postable.posts).resolve
+      calculate_page(readable_posts, per_page)
+    end
+
+    def private_topic_post?
+      false
+    end
+
+    # @return [ActiveRecord::Relation<Thredded.user_class>] users that can read this post.
+    def readers
+      Thredded.user_class.thredded_messageboards_readers([messageboard])
+    end
+
+    private
+
+    def auto_follow_and_notify
+      return unless user
+      # need to do this in-process so that it appears to them immediately
+      if first_post_in_topic? ? Thredded.auto_follow_when_creating_topic : Thredded.auto_follow_when_posting_in_topic
+        UserTopicFollow.create_unless_exists(user.id, postable_id, :posted)
+      end
+      # everything else can happen later
+      AutoFollowAndNotifyJob.perform_later(id)
+    end
+
+    def update_parent_last_user_and_time_from_last_post
+      postable.update_last_user_and_time_from_last_post!
+      messageboard.update_last_topic!
+    end
+
+    def update_parent_last_user_and_time_from_last_post_if_moderation_state_changed
+      update_parent_last_user_and_time_from_last_post if previous_changes.include?('moderation_state')
+    end
+  end
+end