threddedDANIEL 0.14.5

data/app/models/thredded/user_extender.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Thredded
+  module UserExtender
+    extend ActiveSupport::Concern
+
+    include ::Thredded::UserPermissions::Read::All
+    include ::Thredded::UserPermissions::Write::All
+    include ::Thredded::UserPermissions::Message::ReadersOfWriteableBoards
+    include ::Thredded::UserPermissions::Moderate::IfModeratorColumnTrue
+    include ::Thredded::UserPermissions::Admin::IfAdminColumnTrue
+
+    included do # rubocop:disable Metrics/BlockLength
+      with_options dependent: :nullify, foreign_key: 'user_id', inverse_of: :user do |opt|
+        opt.has_many :thredded_posts, class_name: 'Thredded::Post'
+        opt.has_many :thredded_topics, class_name: 'Thredded::Topic'
+        opt.has_many :thredded_private_posts, class_name: 'Thredded::PrivatePost'
+        opt.has_many :thredded_started_private_topics, class_name: 'Thredded::PrivateTopic'
+      end
+
+      with_options dependent: :nullify, foreign_key: 'last_user_id', inverse_of: :last_user do |opt|
+        opt.has_many :thredded_last_user_topics, class_name: 'Thredded::Topic'
+        opt.has_many :thredded_last_user_private_topics, class_name: 'Thredded::PrivateTopic'
+      end
+
+      with_options dependent: :destroy, foreign_key: 'user_id', inverse_of: :user do |opt|
+        opt.has_many :thredded_user_messageboard_preferences, class_name: 'Thredded::UserMessageboardPreference'
+        opt.has_many :thredded_notifications_for_followed_topics, class_name: 'Thredded::NotificationsForFollowedTopics'
+        opt.has_many :thredded_notifications_for_private_topics, class_name: 'Thredded::NotificationsForPrivateTopics'
+        opt.has_many :thredded_post_notifications, class_name: 'Thredded::UserPostNotification'
+        opt.has_many :thredded_private_users, class_name: 'Thredded::PrivateUser'
+        opt.has_many :thredded_topic_read_states, class_name: 'Thredded::UserTopicReadState'
+        opt.has_many :thredded_private_topic_read_states, class_name: 'Thredded::UserPrivateTopicReadState'
+        opt.has_many :thredded_topic_follows, class_name: 'Thredded::UserTopicFollow'
+        opt.has_one :thredded_user_detail, class_name: 'Thredded::UserDetail'
+        opt.has_one :thredded_user_preference, class_name: 'Thredded::UserPreference'
+      end
+
+      has_many :thredded_private_topics,
+               through:    :thredded_private_users,
+               class_name: 'Thredded::PrivateTopic',
+               source:     :private_topic
+
+      with_options dependent: :nullify, class_name: 'Thredded::PostModerationRecord' do |opt|
+        opt.has_many :thredded_post_moderation_records, foreign_key: 'post_user_id', inverse_of: :post_user
+        opt.has_many :thredded_post_moderated_records, foreign_key: 'moderator_id', inverse_of: :moderator
+      end
+
+      scope :left_join_thredded_user_details, (lambda do
+        users = arel_table
+        user_details = Thredded::UserDetail.arel_table
+        joins(users.join(user_details, Arel::Nodes::OuterJoin)
+                .on(users[:id].eq(user_details[:user_id])).join_sources)
+      end)
+    end
+
+    def thredded_user_preference
+      super || build_thredded_user_preference
+    end
+
+    def thredded_user_detail
+      super || build_thredded_user_detail
+    end
+
+    def thredded_anonymous?
+      false
+    end
+
+    def thredded_display_name
+      send(Thredded.user_display_name_method).presence || fail(<<-ERROR)
+        User.#{Thredded.user_display_name_method} must not be empty: please set make sure non nil or configure Thredded.user_display_name_method")
+      ERROR
+    end
+  end
+end

data/app/models/thredded/user_messageboard_preference.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Thredded
+  class UserMessageboardPreference < ActiveRecord::Base
+    belongs_to :user_preference,
+               primary_key: :user_id,
+               foreign_key: :user_id,
+               inverse_of: :messageboard_preferences
+    belongs_to :user,
+               class_name: Thredded.user_class_name,
+               inverse_of: :thredded_user_messageboard_preferences
+    belongs_to :messageboard
+
+    validates :user_id, presence: true
+    validates :messageboard_id, presence: true
+
+    after_initialize :set_auto_follow_from_user_preference, unless: :persisted?
+
+    scope :auto_followers, -> { where(auto_follow_topics: true) }
+
+    def self.in(messageboard)
+      find_or_initialize_by(messageboard_id: messageboard.id)
+    end
+
+    def user_preference
+      super || build_user_preference
+    end
+
+    def user_id=(value)
+      super
+      set_auto_follow_from_user_preference
+    end
+
+    def user=(value)
+      super
+      set_auto_follow_from_user_preference
+    end
+
+    private
+
+    def set_auto_follow_from_user_preference
+      self.auto_follow_topics = user_preference.auto_follow_topics if user_id && !id
+    end
+  end
+end

data/app/models/thredded/user_permissions/admin/if_admin_column_true.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Thredded
+  module UserPermissions
+    module Admin
+      module IfAdminColumnTrue
+        # @return [boolean] Whether this user has full admin rights on Thredded.
+        def thredded_admin?
+          send(Thredded.admin_column)
+        end
+      end
+    end
+  end
+end

data/app/models/thredded/user_permissions/admin/none.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Thredded
+  module UserPermissions
+    module Admin
+      module None
+        # @return [boolean] Whether this user has full admin rights on Thredded.
+        def thredded_admin?
+          false
+        end
+      end
+    end
+  end
+end

data/app/models/thredded/user_permissions/message/readers_of_writeable_boards.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Thredded
+  module UserPermissions
+    module Message
+      module ReadersOfWriteableBoards
+        # @return [ActiveRecord::Relation<Thredded.user_class>] the users this user can include in a private topic
+        def thredded_can_message_users
+          # By default, return everyone who can read the messageboards this user can post in
+          Thredded.user_class.thredded_messageboards_readers(thredded_can_write_messageboards)
+        end
+      end
+    end
+  end
+end

data/app/models/thredded/user_permissions/moderate/if_moderator_column_true.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Thredded
+  module UserPermissions
+    module Moderate
+      module IfModeratorColumnTrue
+        extend ActiveSupport::Concern
+
+        # @return [ActiveRecord::Relation<Thredded::Messageboard>] messageboards that the user can moderate
+        def thredded_can_moderate_messageboards
+          send(Thredded.moderator_column) ? Thredded::Messageboard.all : Thredded::Messageboard.none
+        end
+      end
+    end
+  end
+end

data/app/models/thredded/user_permissions/moderate/none.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Thredded
+  module UserPermissions
+    module Moderate
+      module None
+        extend ActiveSupport::Concern
+
+        # @return [ActiveRecord::Relation<Thredded::Messageboard>] messageboards that the user can moderate
+        def thredded_can_moderate_messageboards
+          Thredded::Messageboard.none
+        end
+      end
+    end
+  end
+end

data/app/models/thredded/user_permissions/read/all.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Thredded
+  module UserPermissions
+    module Read
+      module All
+        extend ActiveSupport::Concern
+        included { extend ClassMethods }
+
+        # @return [ActiveRecord::Relation<Thredded::Messageboard>] messageboards that the user can read
+        def thredded_can_read_messageboards
+          Thredded::Messageboard.all
+        end
+
+        module ClassMethods
+          # Users that can read some of the given messageboards.
+          #
+          # @param _messageboards [Array<Thredded::Messageboard>]
+          # @return [ActiveRecord::Relation<Thredded.user_class>] users that can read the given messageboards
+          def thredded_messageboards_readers(_messageboards)
+            all
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/thredded/user_permissions/write/all.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Thredded
+  module UserPermissions
+    module Write
+      module All
+        extend ActiveSupport::Concern
+
+        # @return [ActiveRecord::Relation<Thredded::Messageboard>] messageboards that the user can post in
+        def thredded_can_write_messageboards
+          Thredded::Messageboard.all
+        end
+      end
+    end
+  end
+end

data/app/models/thredded/user_permissions/write/none.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Thredded
+  module UserPermissions
+    module Write
+      module None
+        extend ActiveSupport::Concern
+
+        # @return [ActiveRecord::Relation<Thredded::Messageboard>] messageboards that the user can post in
+        def thredded_can_write_messageboards
+          Thredded::Messageboard.none
+        end
+      end
+    end
+  end
+end

data/app/models/thredded/user_post_notification.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Thredded
+  # Delivery records for Thredded::Post notifications.
+  class UserPostNotification < ActiveRecord::Base
+    belongs_to :user, class_name: Thredded.user_class_name, inverse_of: :thredded_post_notifications
+    belongs_to :post, class_name: 'Thredded::Post', inverse_of: :user_notifications
+
+    # @param post [Thredded::Post]
+    # @return [Array<Integer>] The IDs of users who were already notified about the given post.
+    def self.notified_user_ids(post)
+      where(post_id: post.id).pluck(:user_id)
+    end
+
+    # Create a user-post notification record for a given post and a user.
+    # @param post [Thredded::Post]
+    # @param user [Thredded.user_class]
+    # @return [Boolean] true if a new record was created, false otherwise (e.g. if a record had already existed).
+    def self.create_from_post_and_user(post, user)
+      create(
+        post_id: post.id,
+        user_id: user.id,
+        notified_at: Time.zone.now
+      )
+    rescue ActiveRecord::RecordNotUnique
+      false
+    end
+  end
+end

data/app/models/thredded/user_preference.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Thredded
+  class UserPreference < ActiveRecord::Base
+    belongs_to :user, class_name: Thredded.user_class_name, inverse_of: :thredded_user_preference
+
+    with_options(inverse_of: :user_preference, primary_key: :user_id, foreign_key: :user_id,
+                 dependent: :destroy) do |opt|
+      opt.has_many :messageboard_preferences,
+                   class_name: 'Thredded::UserMessageboardPreference'
+      opt.has_many :messageboard_notifications_for_followed_topics,
+                   class_name: 'Thredded::MessageboardNotificationsForFollowedTopics'
+      opt.has_many :notifications_for_followed_topics,
+                   class_name: 'Thredded::NotificationsForFollowedTopics'
+      opt.has_many :notifications_for_private_topics,
+                   class_name: 'Thredded::NotificationsForPrivateTopics'
+    end
+    validates :user_id, presence: true
+
+    scope :auto_followers, -> { where(auto_follow_topics: true) }
+
+    accepts_nested_attributes_for :notifications_for_followed_topics,
+                                  :notifications_for_private_topics,
+                                  :messageboard_notifications_for_followed_topics
+  end
+end

data/app/models/thredded/user_private_topic_read_state.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Thredded
+  class UserPrivateTopicReadState < ActiveRecord::Base
+    include Thredded::UserTopicReadStateCommon
+    belongs_to :user,
+               class_name: Thredded.user_class_name,
+               inverse_of: :thredded_private_topic_read_states
+    belongs_to :postable,
+               class_name: 'Thredded::PrivateTopic',
+               inverse_of: :user_read_states
+  end
+end

data/app/models/thredded/user_topic_follow.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Thredded
+  class UserTopicFollow < ActiveRecord::Base
+    enum reason: %i[manual posted mentioned auto]
+
+    belongs_to :user, inverse_of: :thredded_topic_follows, class_name: Thredded.user_class_name
+    belongs_to :topic, inverse_of: :user_follows
+
+    validates :user_id, presence: true
+    validates :topic_id, presence: true
+
+    # shim to behave like postable-related (though actually only ever related to topic)
+    alias_attribute :postable_id, :topic_id
+    alias_attribute :postable, :topic
+
+    # Creates a follow or finds the existing one.
+    #
+    # This method is safe to call concurrently from different processes. Lookup and creation happen in a transaction.
+    # If an ActiveRecord::RecordNotUnique error is raised, the find is retried.
+    #
+    # @return [Thredded::UserTopicFollow]
+    def self.create_unless_exists(user_id, topic_id, reason = :manual)
+      uncached do
+        transaction(requires_new: true) do
+          create_with(reason: reason).find_or_create_by(user_id: user_id, topic_id: topic_id)
+        end
+      end
+    rescue ActiveRecord::RecordNotUnique
+      # The record has been created from another connection, retry to find it.
+      retry
+    end
+  end
+end

data/app/models/thredded/user_topic_read_state.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Thredded
+  class UserTopicReadState < ActiveRecord::Base
+    include Thredded::UserTopicReadStateCommon
+    belongs_to :user,
+               class_name: Thredded.user_class_name,
+               inverse_of: :thredded_topic_read_states
+    belongs_to :postable,
+               class_name: 'Thredded::Topic',
+               inverse_of: :user_read_states
+  end
+end

data/app/notifiers/thredded/email_notifier.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Thredded
+  class EmailNotifier
+    def initialize
+      fail 'Please set Thredded.email_from in config/initializers/thredded.rb' if Thredded.email_from.blank?
+    end
+
+    def human_name
+      I18n.t('thredded.email_notifier.by_email')
+    end
+
+    def key
+      'email'
+    end
+
+    def new_post(post, users)
+      Thredded::PostMailer.post_notification(post.id, users.map(&:email)).deliver_now
+    end
+
+    def new_private_post(post, users)
+      Thredded::PrivateTopicMailer.message_notification(post.id, users.map(&:email)).deliver_now
+    end
+  end
+end

data/app/policies/thredded/messageboard_group_policy.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Thredded
+  class MessageboardGroupPolicy
+    # @param user [Thredded.user_class]
+    # @param group [Thredded::MessageboardGroup]
+    def initialize(user, group)
+      @user = user
+      @group = group
+    end
+
+    def create?
+      @user.thredded_admin?
+    end
+  end
+end

data/app/policies/thredded/messageboard_policy.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Thredded
+  class MessageboardPolicy
+    # The scope of readable messageboards
+    class Scope
+      # @param user [Thredded.user_class]
+      # @param scope [ActiveRecord::Relation<Thredded::Messageboard>]
+      def initialize(user, scope)
+        @user = user
+        @scope = scope
+      end
+
+      # @return [ActiveRecord::Relation<Thredded::Messageboards>]
+      def resolve
+        @scope.merge(@user.thredded_can_read_messageboards)
+      end
+    end
+
+    # @param user [Thredded.user_class]
+    # @param messageboard [Thredded::Messageboard]
+    def initialize(user, messageboard)
+      @user = user
+      @messageboard = messageboard
+    end
+
+    def create?
+      @user.thredded_admin?
+    end
+
+    def read?
+      @user.thredded_admin? || @user.thredded_can_read_messageboards.include?(@messageboard)
+    end
+
+    def update?
+      @user.thredded_admin?
+    end
+
+    def post?
+      @user.thredded_admin? ||
+        (!@messageboard.locked? || moderate?) &&
+          @user.thredded_can_write_messageboards.include?(@messageboard)
+    end
+
+    def moderate?
+      @user.thredded_admin? || @user.thredded_can_moderate_messageboards.include?(@messageboard)
+    end
+  end
+end