threddedDANIEL 0.14.5

data/app/controllers/thredded/autocomplete_users_controller.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Thredded
+  class AutocompleteUsersController < Thredded::ApplicationController
+    MAX_RESULTS = 20
+
+    def index
+      authorize_creating Thredded::PrivateTopicForm.new(user: thredded_current_user).private_topic
+      users = params.key?(:q) ? users_by_prefix : users_by_ids
+      render json: {
+        results: users.map { |user| user_to_autocomplete_result(user) }
+      }
+    end
+
+    protected
+
+    def user_to_autocomplete_result(user)
+      {
+        id: user.id,
+        name: user.send(Thredded.user_name_column),
+        display_name: user.send(Thredded.user_display_name_method),
+        avatar_url: Thredded.avatar_url.call(user)
+      }
+    end
+
+    private
+
+    def users_by_prefix
+      query = params[:q].to_s.strip
+      if query.length >= Thredded.autocomplete_min_length
+        DbTextSearch::CaseInsensitive.new(users_scope, Thredded.user_name_column).prefix(query)
+          .where.not(id: thredded_current_user.id)
+          .limit(MAX_RESULTS)
+      else
+        []
+      end
+    end
+
+    def users_by_ids
+      ids = params[:ids].to_s.split(',')
+      if ids.present?
+        users_scope.where(id: ids)
+      else
+        []
+      end
+    end
+
+    def users_scope
+      thredded_current_user.thredded_can_message_users
+    end
+  end
+end

data/app/controllers/thredded/messageboard_groups_controller.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Thredded
+  class MessageboardGroupsController < Thredded::ApplicationController
+    def new
+      @messageboard_group = Thredded::MessageboardGroup.new
+      authorize @messageboard_group, :create?
+    end
+
+    def create
+      @messageboard_group = Thredded::MessageboardGroup.new(messageboard_group_params)
+      authorize @messageboard_group, :create?
+
+      if @messageboard_group.save
+        redirect_to root_path, notice: I18n.t('thredded.messageboard_group.saved', name: @messageboard_group.name)
+      else
+        flash.now[:notice] = @messageboard_group.errors.full_messages.to_sentence
+
+        render action: :new
+      end
+    end
+
+    private
+
+    def messageboard_group_params
+      params
+        .require(:messageboard_group)
+        .permit(:name)
+    end
+  end
+end

data/app/controllers/thredded/messageboards_controller.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Thredded
+  class MessageboardsController < Thredded::ApplicationController
+    before_action :thredded_require_login!, only: %i[new create edit update]
+
+    after_action :verify_authorized, except: %i[index]
+    after_action :verify_policy_scoped, except: %i[new create edit update]
+
+    def index
+      @groups = Thredded::MessageboardGroupView.grouped(policy_scope(Thredded::Messageboard.all))
+    end
+
+    def new
+      @messageboard = Thredded::Messageboard.new
+      @messageboard_group = Thredded::MessageboardGroup.all
+      authorize_creating @messageboard
+    end
+
+    def create
+      @messageboard = Thredded::Messageboard.new(messageboard_params)
+      authorize_creating @messageboard
+      if Thredded::CreateMessageboard.new(@messageboard, thredded_current_user).run
+        redirect_to root_path
+      else
+        render :new
+      end
+    end
+
+    def edit
+      @messageboard = Thredded::Messageboard.friendly_find!(params[:id])
+      authorize @messageboard, :update?
+    end
+
+    def update
+      @messageboard = Thredded::Messageboard.friendly_find!(params[:id])
+      authorize @messageboard, :update?
+      if @messageboard.update(messageboard_params)
+        redirect_to messageboard_topics_path(@messageboard), notice: I18n.t('thredded.messageboard.updated_notice')
+      else
+        render :edit
+      end
+    end
+
+    private
+
+    def messageboard_params
+      params
+        .require(:messageboard)
+        .permit(:name, :description, :messageboard_group_id, :locked)
+    end
+  end
+end

data/app/controllers/thredded/moderation_controller.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Thredded
+  class ModerationController < Thredded::ApplicationController
+    before_action :thredded_require_login!
+    before_action :load_moderatable_messageboards
+
+    def pending
+      @posts = Thredded::PostsPageView.new(
+        thredded_current_user,
+        moderatable_posts
+          .pending_moderation
+          .order_oldest_first
+          .preload(:user, :postable)
+          .page(current_page)
+      )
+      maybe_set_last_moderated_record_flash
+    end
+
+    def history
+      @post_moderation_records = accessible_post_moderation_records
+        .order(created_at: :desc)
+        .page(current_page)
+    end
+
+    def activity
+      @posts = Thredded::PostsPageView.new(
+        thredded_current_user,
+        moderatable_posts
+          .order_newest_first
+          .preload(:user, :postable, :messageboard)
+          .page(current_page)
+      )
+      maybe_set_last_moderated_record_flash
+    end
+
+    def moderate_post
+      return head(:bad_request) unless Thredded::Post.moderation_states.include?(params[:moderation_state])
+      flash[:last_moderated_record_id] = Thredded::ModeratePost.run!(
+        post: moderatable_posts.find(params[:id]),
+        moderation_state: params[:moderation_state],
+        moderator: thredded_current_user,
+      ).id
+      redirect_back fallback_location: pending_moderation_path
+    end
+
+    def users
+      @users = Thredded.user_class
+        .left_join_thredded_user_details
+        .merge(Thredded::UserDetail.order(moderation_state_changed_at: :desc))
+      @query = params[:q].to_s
+      if @query.present?
+        @users = DbTextSearch::CaseInsensitive.new(@users, Thredded.user_name_column).prefix(@query)
+      end
+      @users = @users.page(current_page)
+    end
+
+    def user
+      @user = Thredded.user_class.find(params[:id])
+      # Do not apply policy_scope here, as we want to show blocked posts as well.
+      posts_scope = @user.thredded_posts
+        .where(messageboard_id: policy_scope(Messageboard.all).pluck(:id))
+        .order_newest_first
+        .includes(:postable)
+        .page(current_page)
+      @posts = Thredded::PostsPageView.new(thredded_current_user, posts_scope)
+    end
+
+    def moderate_user
+      return head(:bad_request) unless Thredded::UserDetail.moderation_states.include?(params[:moderation_state])
+      user = Thredded.user_class.find(params[:id])
+      user.thredded_user_detail.update!(moderation_state: params[:moderation_state])
+      redirect_back fallback_location: user_moderation_path(user.id)
+    end
+
+    private
+
+    def maybe_set_last_moderated_record_flash
+      return unless flash[:last_moderated_record_id]
+      @last_moderated_record = accessible_post_moderation_records.find(flash[:last_moderated_record_id].to_s)
+    end
+
+    def moderatable_posts
+      Thredded::Post.where(messageboard_id: @moderatable_messageboards)
+    end
+
+    def accessible_post_moderation_records
+      Thredded::PostModerationRecord
+        .where(messageboard_id: @moderatable_messageboards)
+    end
+
+    def load_moderatable_messageboards
+      @moderatable_messageboards = thredded_current_user.thredded_can_moderate_messageboards.to_a
+      if @moderatable_messageboards.empty? # rubocop:disable Style/GuardClause
+        fail Pundit::NotAuthorizedError, 'You are not authorized to perform this action.'
+      end
+    end
+
+    def current_page
+      (params[:page] || 1).to_i
+    end
+  end
+end

data/app/controllers/thredded/post_permalinks_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PostPermalinksController < Thredded::ApplicationController
+    def show
+      post = Thredded::Post.find(params[:id])
+      authorize post, :read?
+      redirect_to post_url(post, user: thredded_current_user), status: :found
+    end
+  end
+end

data/app/controllers/thredded/post_previews_controller.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PostPreviewsController < Thredded::ApplicationController
+    include Thredded::RenderPreview
+
+    # Preview a new post
+    def preview
+      @post = Thredded::Post.new(post_params)
+      @post.postable = Thredded::Topic.friendly_find!(params[:topic_id])
+      render_preview
+    end
+
+    # Preview an update to an existing post
+    def update
+      @post = Thredded::Post.find(params[:post_id])
+      @post.assign_attributes(post_params)
+      render_preview
+    end
+
+    private
+
+    def post_params
+      params.require(:post)
+        .permit(:content)
+        .merge(user: thredded_current_user, messageboard: messageboard)
+    end
+  end
+end

data/app/controllers/thredded/posts_controller.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Thredded
+  # A controller for managing {Post}s.
+  class PostsController < Thredded::ApplicationController
+    include ActionView::RecordIdentifier
+    include Thredded::NewPostParams
+
+    helper_method :topic
+    after_action :update_user_activity
+
+    after_action :verify_authorized
+
+    def new
+      @post_form = Thredded::PostForm.new(
+        user: thredded_current_user, topic: parent_topic, post_params: new_post_params
+      )
+      authorize_creating @post_form.post
+    end
+
+    def create
+      @post_form = Thredded::PostForm.new(
+        user: thredded_current_user, topic: parent_topic, post_params: new_post_params
+      )
+      authorize_creating @post_form.post
+
+      if @post_form.save
+        redirect_to post_path(@post_form.post, user: thredded_current_user)
+      else
+        render :new
+      end
+    end
+
+    def edit
+      @post_form = Thredded::PostForm.for_persisted(post)
+      authorize @post_form.post, :update?
+      return redirect_to(canonical_topic_params) unless params_match?(canonical_topic_params)
+      render
+    end
+
+    def update
+      authorize post, :update?
+      post.update(new_post_params)
+
+      redirect_to post_path(post, user: thredded_current_user)
+    end
+
+    def destroy
+      authorize post, :destroy?
+      post.destroy!
+
+      redirect_back fallback_location: topic_url(topic),
+                    notice: I18n.t('thredded.posts.deleted_notice')
+    end
+
+    def mark_as_unread
+      authorize post, :read?
+      page = post.page(user: thredded_current_user)
+      post.mark_as_unread(thredded_current_user, page)
+      after_mark_as_unread # customization hook
+    end
+
+    def quote
+      authorize_reading post
+      render plain: Thredded::ContentFormatter.quote_content(post.content)
+    end
+
+    private
+
+    def canonical_topic_params
+      { messageboard_id: messageboard.slug, topic_id: topic.slug }
+    end
+
+    def after_mark_as_unread
+      redirect_to messageboard_topics_path(messageboard)
+    end
+
+    def topic
+      post.postable
+    end
+
+    def parent_topic
+      Thredded::Topic
+        .where(messageboard: messageboard)
+        .friendly
+        .find(params[:topic_id])
+    end
+
+    def post
+      @post ||= Thredded::Post.find(params[:id])
+    end
+
+    def current_page
+      params[:page].nil? ? 1 : params[:page].to_i
+    end
+  end
+end

data/app/controllers/thredded/preferences_controller.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PreferencesController < Thredded::ApplicationController
+    before_action :thredded_require_login!,
+                  :init_preferences
+
+    def edit; end
+
+    def update
+      if @preferences.save
+        flash[:notice] = t('thredded.preferences.updated_notice')
+        redirect_back fallback_location: edit_preferences_url(@preferences.messageboard)
+      else
+        render :edit
+      end
+    end
+
+    private
+
+    def init_preferences
+      @preferences = Thredded::UserPreferencesForm.new(
+        user:         thredded_current_user,
+        messageboard: messageboard_or_nil,
+        messageboards: policy_scope(Thredded::Messageboard.all),
+        params: preferences_params
+      )
+    end
+
+    def preferences_params
+      params.fetch(:user_preferences_form, {}).permit(
+        :auto_follow_topics,
+        :messageboard_auto_follow_topics,
+        :follow_topics_on_mention,
+        :messageboard_follow_topics_on_mention,
+        messageboard_notifications_for_followed_topics_attributes: %i[notifier_key id messageboard_id enabled],
+        notifications_for_followed_topics_attributes: %i[notifier_key id enabled],
+        notifications_for_private_topics_attributes: %i[notifier_key id enabled]
+      )
+    end
+  end
+end

data/app/controllers/thredded/private_post_permalinks_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PrivatePostPermalinksController < Thredded::ApplicationController
+    before_action :thredded_require_login!
+    def show
+      private_post = Thredded::PrivatePost.find(params[:id])
+      authorize private_post, :read?
+      redirect_to post_url(private_post, user: thredded_current_user), status: :found
+    end
+  end
+end

data/app/controllers/thredded/private_post_previews_controller.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Thredded
+  class PrivatePostPreviewsController < Thredded::ApplicationController
+    include Thredded::RenderPreview
+
+    # Preview a new post
+    def preview
+      @private_post = Thredded::PrivatePost.new(private_post_params)
+      @private_post.postable = Thredded::PrivateTopic.friendly_find!(params[:private_topic_id])
+      render_preview
+    end
+
+    # Preview an update to an existing post
+    def update
+      @private_post = Thredded::PrivatePost.find(params[:private_post_id])
+      @private_post.assign_attributes(private_post_params)
+      render_preview
+    end
+
+    private
+
+    def private_post_params
+      params.require(:post)
+        .permit(:content)
+        .merge(user: thredded_current_user)
+    end
+  end
+end