rails_den 2.0.0

data/app/controllers/rails_den/moderation/report_notes_controller.rb

@@ -0,0 +1,27 @@
+module RailsDen
+  module Moderation
+    class ReportNotesController < RailsDen::ApplicationController
+      def create
+        report = RailsDen::Report.find(params[:report_id])
+        policy = RailsDen::ReportReviewPolicy.new(viewer: current_rails_den_user)
+        raise ActiveRecord::RecordNotFound unless policy.reviewable?(report)
+
+        note = nil
+        RailsDen::ModerationNote.transaction do
+          note = report.moderation_notes.create!(author: current_rails_den_user, body: params[:body])
+          RailsDen::ModerationAudit.record!(action: "moderation_note.created", subject: report,
+                                            actor: current_rails_den_user, report: report,
+                                            scope_board: report_board(report))
+        end
+        redirect_to moderation_report_path(report), status: :see_other, notice: "Private note added."
+      end
+
+      private
+
+      def report_board(report)
+        target = report.reportable
+        target.is_a?(RailsDen::Topic) ? target.board : target&.topic&.board
+      end
+    end
+  end
+end

data/app/controllers/rails_den/moderation/reports_controller.rb

@@ -0,0 +1,97 @@
+module RailsDen
+  module Moderation
+    class ReportsController < RailsDen::ApplicationController
+      before_action :require_moderation_access!
+
+      def index
+        @reports = RailsDen::ReportReviewScope.call(
+          viewer: current_rails_den_user,
+          relation: RailsDen::Report.open
+        )
+      end
+
+      def history
+        relation = RailsDen::Report.history
+        relation = relation.where(status: params[:status]) if params[:status].in?(%w[resolved dismissed])
+        relation = relation.where(report_reason_id: params[:report_reason_id]) if params[:report_reason_id].present?
+        relation = relation.where(reportable_type: params[:reportable_type]) if params[:reportable_type].present?
+        @reports = RailsDen::ReportReviewScope.call(viewer: current_rails_den_user, relation: relation)
+        @reasons = RailsDen::ReportReason.ordered
+        render :index
+      end
+
+      def show
+        @report = RailsDen::Report.includes(
+          :report_reason,
+          :reporter,
+          :reportable
+        ).find(params[:id])
+
+        policy = RailsDen::ReportReviewPolicy.new(
+          viewer: current_rails_den_user
+        )
+
+        raise ActiveRecord::RecordNotFound unless policy.reviewable?(@report)
+
+        @live_target_available = policy.live_target_readable?(@report)
+        @notes = @report.moderation_notes.includes(:author).order(:created_at, :id)
+        @related_reports = RailsDen::ReportReviewScope.call(
+          viewer: current_rails_den_user,
+          relation: RailsDen::Report.open.where(subject_user: @report.subject_user).where.not(id: @report.id)
+        )
+        @subject_reports = RailsDen::ReportReviewScope.call(
+          viewer: current_rails_den_user,
+          relation: RailsDen::Report.where(subject_user: @report.subject_user)
+        )
+        @global_moderator = policy.global_moderator?
+      end
+
+
+      def claim
+        load_reviewable_report
+        RailsDen::ReportAssignment.call(report: @report, actor: current_rails_den_user,
+                                        assignee: current_rails_den_user)
+        redirect_to moderation_report_path(@report), status: :see_other, notice: "Report claimed."
+      end
+
+      def release
+        load_reviewable_report
+        RailsDen::ReportAssignment.call(report: @report, actor: current_rails_den_user, assignee: nil)
+        redirect_to moderation_report_path(@report), status: :see_other, notice: "Report released."
+      end
+
+      %i[resolve dismiss reopen].each do |transition|
+        define_method(transition) do
+          load_reviewable_report
+          status = { resolve: "resolved", dismiss: "dismissed", reopen: "open" }.fetch(transition)
+          RailsDen::ReportDisposition.call(report: @report, actor: current_rails_den_user,
+                                          status: status, note: params[:note])
+          if @report.errors.any?
+            show
+            render :show, status: :unprocessable_entity
+          else
+            redirect_to moderation_report_path(@report), status: :see_other,
+                        notice: "Report #{status}."
+          end
+        end
+      end
+
+      private
+
+      def require_moderation_access!
+        return if RailsDen::ModerationAccess.allowed?(
+          user: current_rails_den_user
+        )
+
+        raise ActiveRecord::RecordNotFound
+      end
+
+      def load_reviewable_report
+        @report = RailsDen::Report.find(params[:id])
+        raise ActiveRecord::RecordNotFound unless RailsDen::ReportReviewPolicy.new(
+          viewer: current_rails_den_user
+        ).reviewable?(@report)
+      end
+    end
+  end
+end

data/app/controllers/rails_den/moderation/restrictions_controller.rb

@@ -0,0 +1,71 @@
+module RailsDen
+  module Moderation
+    class RestrictionsController < RailsDen::ApplicationController
+      before_action :load_member, only: %i[new create]
+      before_action :authorize_member!, only: %i[new create]
+
+      def new
+        @restriction = RailsDen::UserRestriction.new(kind: params[:kind], source_report_id: params[:report_id])
+        @active_restrictions = RailsDen::RestrictionResolver.active_restrictions(user: @member)
+      end
+
+      def create
+        attributes = restriction_params
+        @restriction = RailsDen::UserRestrictionManager.create!(
+          user: @member, actor: current_rails_den_user, kind: attributes[:kind],
+          reason: attributes[:reason], internal_note: attributes[:internal_note],
+          ends_at: parsed_ends_at(attributes), indefinite: attributes[:indefinite] == "1",
+          source_report: report_from(attributes[:source_report_id])
+        )
+        redirect_to moderation_member_history_path(mention_name: RailsDen.user_mention_name(@member)),
+                    status: :see_other, notice: "#{@restriction.kind.humanize} imposed."
+      rescue ActiveRecord::RecordInvalid => error
+        @restriction = error.record
+        @active_restrictions = RailsDen::RestrictionResolver.active_restrictions(user: @member)
+        render :new, status: :unprocessable_entity
+      end
+
+      def lift
+        @restriction = RailsDen::UserRestriction.find(params[:id])
+        RailsDen::UserRestrictionManager.lift!(restriction: @restriction,
+                                               actor: current_rails_den_user,
+                                               reason: params[:lift_reason])
+        redirect_to moderation_member_history_path(
+          mention_name: RailsDen.user_mention_name(@restriction.user)
+        ), status: :see_other, notice: "Restriction lifted."
+      end
+
+      private
+
+      def load_member
+        @member = RailsDen.resolve_user_mention(params[:mention_name].to_s.downcase) || raise(ActiveRecord::RecordNotFound)
+      end
+
+      def authorize_member!
+        raise ActiveRecord::RecordNotFound unless RailsDen::GlobalModerationPolicy.new(
+          actor: current_rails_den_user
+        ).may_sanction?(@member)
+      end
+
+      def restriction_params
+        params.fetch(:restriction, {}).permit(:kind, :reason, :internal_note, :duration_minutes,
+                                               :indefinite, :source_report_id)
+      end
+
+      def parsed_ends_at(attributes)
+        return if attributes[:indefinite] == "1"
+        minutes = Integer(attributes[:duration_minutes], exception: false)
+        minutes&.positive? ? Time.current + minutes.minutes : nil
+      end
+
+      def report_from(id)
+        return if id.blank?
+        report = RailsDen::Report.find(id)
+        raise ActiveRecord::RecordNotFound unless RailsDen::ReportReviewPolicy.new(
+          viewer: current_rails_den_user
+        ).reviewable?(report)
+        report
+      end
+    end
+  end
+end

data/app/controllers/rails_den/moderation/topics_controller.rb

@@ -0,0 +1,61 @@
+module RailsDen
+  module Moderation
+    class TopicsController < RailsDen::ApplicationController
+      before_action :load_topic
+
+      def show
+        RailsDen::TopicModeration.authorize!(current_rails_den_user, @topic)
+      end
+
+      def pin = toggle(:pinned, true, "Topic pinned.")
+      def unpin = toggle(:pinned, false, "Topic unpinned.")
+      def lock = toggle(:locked, true, "Topic locked.")
+      def unlock = toggle(:locked, false, "Topic unlocked.")
+
+      def move
+        destination = RailsDen::Board.find(params[:board_id])
+        RailsDen::TopicModeration.move!(topic: @topic, destination: destination,
+                                        actor: current_rails_den_user)
+        redirect_to topic_path(@topic), status: :see_other, notice: "Topic moved."
+      end
+
+      def merge
+        destination = RailsDen::Topic.find(params[:destination_topic_id])
+        RailsDen::TopicMerger.call(source: @topic, destination: destination,
+                                   actor: current_rails_den_user)
+        redirect_to topic_path(destination), status: :see_other, notice: "Topics merged."
+      end
+
+      def split
+        starting_post = @topic.posts.find(params[:post_id])
+        destination = RailsDen::Board.find(params[:board_id])
+        new_topic = RailsDen::TopicSplitter.call(source: @topic, starting_post: starting_post,
+                                                 destination_board: destination,
+                                                 title: params[:title], actor: current_rails_den_user)
+        redirect_to topic_path(new_topic), status: :see_other, notice: "Topic split."
+      end
+
+      def destroy
+        RailsDen::TopicModeration.soft_delete!(topic: @topic, actor: current_rails_den_user)
+        redirect_to board_path(@topic.board), status: :see_other, notice: "Topic deleted."
+      end
+
+      def restore
+        RailsDen::TopicModeration.restore!(topic: @topic, actor: current_rails_den_user)
+        redirect_to topic_path(@topic), status: :see_other, notice: "Topic restored."
+      end
+
+      private
+
+      def load_topic
+        @topic = RailsDen::Topic.find(params[:id])
+      end
+
+      def toggle(attribute, value, notice)
+        RailsDen::TopicModeration.toggle!(topic: @topic, actor: current_rails_den_user,
+                                          attribute: attribute, value: value)
+        redirect_to topic_path(@topic), status: :see_other, notice: notice
+      end
+    end
+  end
+end

data/app/controllers/rails_den/moderation/warnings_controller.rb

@@ -0,0 +1,50 @@
+module RailsDen
+  module Moderation
+    class WarningsController < RailsDen::ApplicationController
+      before_action :load_member
+      before_action :authorize!
+
+      def new
+        @warning = RailsDen::UserWarning.new(report_id: params[:report_id])
+      end
+
+      def create
+        @warning = RailsDen::UserWarningIssuer.call(
+          user: @member, actor: current_rails_den_user,
+          message: warning_params[:message], internal_note: warning_params[:internal_note],
+          report: report_from_params
+        )
+        redirect_to moderation_member_history_path(mention_name: RailsDen.user_mention_name(@member)),
+                    status: :see_other, notice: "Warning issued."
+      rescue ActiveRecord::RecordInvalid => error
+        @warning = error.record
+        render :new, status: :unprocessable_entity
+      end
+
+      private
+
+      def load_member
+        @member = RailsDen.resolve_user_mention(params[:mention_name].to_s.downcase) || raise(ActiveRecord::RecordNotFound)
+      end
+
+      def authorize!
+        raise ActiveRecord::RecordNotFound unless RailsDen::GlobalModerationPolicy.new(
+          actor: current_rails_den_user
+        ).may_sanction?(@member)
+      end
+
+      def warning_params
+        params.fetch(:warning, {}).permit(:message, :internal_note, :report_id)
+      end
+
+      def report_from_params
+        return if warning_params[:report_id].blank?
+        report = RailsDen::Report.find(warning_params[:report_id])
+        raise ActiveRecord::RecordNotFound unless RailsDen::ReportReviewPolicy.new(
+          viewer: current_rails_den_user
+        ).reviewable?(report)
+        report
+      end
+    end
+  end
+end

data/app/controllers/rails_den/notification_preferences_controller.rb

@@ -0,0 +1,116 @@
+module RailsDen
+  class NotificationPreferencesController < ApplicationController
+    def update
+      notifiable = find_notifiable
+
+      result =
+        RailsDen::NotificationPreferences.set(
+          recipient: current_rails_den_user,
+          notifiable: notifiable,
+          level: preference_level
+        )
+
+      respond_to do |format|
+        format.html do
+          redirect_to destination_path(notifiable),
+                      status: :see_other,
+                      notice: "Notification preference updated."
+        end
+
+        format.json do
+          render json: {
+            level: result.level.to_s,
+            changed: result.changed,
+            notifiable_type:
+              notifiable.class.polymorphic_name,
+            notifiable_id: notifiable.id
+          }
+        end
+      end
+    rescue ArgumentError => error
+      respond_to do |format|
+        format.html do
+          head :unprocessable_entity
+        end
+
+        format.json do
+          render json: {
+            errors: [
+              error.message
+            ]
+          },
+                 status: :unprocessable_entity
+        end
+      end
+    end
+
+    private
+
+    def preference_level
+      params
+        .require(:notification_preference)
+        .fetch(:level)
+    end
+
+    def find_notifiable
+      if params[:topic_id]
+        find_readable_topic
+      elsif params[:board_id]
+        find_readable_board
+      else
+        raise ActiveRecord::RecordNotFound
+      end
+    end
+
+    def find_readable_topic
+      topic =
+        RailsDen::Topic.find(
+          params[:topic_id]
+        )
+
+      readable_content =
+        ReadableCommunityContent.new(
+          viewer: current_rails_den_user
+        )
+
+      unless readable_content.topic_readable?(
+        topic
+      )
+        raise ActiveRecord::RecordNotFound
+      end
+
+      topic
+    end
+
+    def find_readable_board
+      board =
+        RailsDen::Board.find(
+          params[:board_id]
+        )
+
+      readable_content =
+        ReadableCommunityContent.new(
+          viewer: current_rails_den_user
+        )
+
+      unless readable_content.board_readable?(
+        board
+      )
+        raise ActiveRecord::RecordNotFound
+      end
+
+      board
+    end
+
+    def destination_path(notifiable)
+      case notifiable
+      when RailsDen::Topic
+        topic_path(notifiable)
+      when RailsDen::Board
+        board_path(notifiable)
+      else
+        raise ActiveRecord::RecordNotFound
+      end
+    end
+  end
+end

data/app/controllers/rails_den/notifications_controller.rb

@@ -0,0 +1,67 @@
+module RailsDen
+  class NotificationsController < ApplicationController
+    def index
+      @notifications =
+        RailsDen::Notification
+          .includes(
+            notification_event: [
+              :actor,
+              :subject,
+              :target
+            ]
+          )
+          .where(
+            recipient: current_rails_den_user
+          )
+          .order(created_at: :desc)
+          .select do |notification|
+            readable_content.notification_readable?(
+              notification
+            )
+          end
+
+      mark_notifications_read
+    end
+
+    def destroy
+      notification =
+        RailsDen::Notification.find_by(
+          id: params[:id],
+          recipient: current_rails_den_user
+        )
+
+      notification&.destroy!
+
+      redirect_to notifications_path,
+                  status: :see_other
+    end
+
+    private
+
+    def readable_content
+      @readable_content ||=
+        RailsDen::ReadableCommunityContent.new(
+          viewer: current_rails_den_user
+        )
+    end
+
+    def mark_notifications_read
+      updated =
+        RailsDen::Notification
+          .where(
+            recipient: current_rails_den_user,
+            read_at: nil
+          )
+          .update_all(
+            read_at: Time.current,
+            updated_at: Time.current
+          )
+
+      return unless updated.positive?
+
+      RailsDen::Notifications::Broadcaster.call(
+        recipient: current_rails_den_user
+      )
+    end
+  end
+end

data/app/controllers/rails_den/post_bookmarks_controller.rb

@@ -0,0 +1,29 @@
+module RailsDen
+  class PostBookmarksController < ApplicationController
+    def create
+      @topic = Topic.find(params[:topic_id])
+      readable = ReadableCommunityContent.new(viewer: current_rails_den_user)
+      raise ActiveRecord::RecordNotFound unless readable.topic_readable?(@topic)
+      @post = @topic.posts.where(deleted_at: nil).find(params[:post_id])
+      raise ActiveRecord::RecordNotFound unless readable.post_readable?(@post)
+
+      bookmark = Bookmark.create_or_find_by!(bookmarker: current_rails_den_user, bookmarkable: @post)
+      respond_to do |format|
+        format.html { redirect_to_post }
+        format.json { render json: { html: render_control(bookmark) } }
+      end
+    rescue ActiveRecord::RecordNotUnique
+      retry
+    end
+
+    private
+
+    def render_control(bookmark)
+      render_to_string(partial: "rails_den/bookmarks/post_control", formats: [:html], locals: { post: @post, bookmark: bookmark })
+    end
+
+    def redirect_to_post
+      redirect_to topic_path(@topic, page: @topic.posts_page_for(@post), anchor: "post-#{@post.id}")
+    end
+  end
+end

data/app/controllers/rails_den/post_drafts_controller.rb

@@ -0,0 +1,125 @@
+module RailsDen
+  class PostDraftsController < ApplicationController
+    before_action :require_rails_den_participation!, only: :update
+    before_action :find_readable_topic
+    before_action :require_reply_permission!,
+                  only: :update
+    before_action :require_unlocked_topic!,
+                  only: :update
+
+    def update
+      body =
+        draft_params[:body]
+          .to_s
+
+      if body.blank?
+        destroy_current_draft
+
+        return head :no_content
+      end
+
+      quoted_post =
+        find_quoted_post
+
+      draft =
+        PostDraft.find_or_initialize_by(
+          topic: @topic,
+          author: current_rails_den_user
+        )
+
+      draft.body = body
+      draft.quoted_post = quoted_post
+      draft.reply_to =
+        quoted_post || find_reply_to_post
+
+      if draft.save
+        head :no_content
+      else
+        render json: {
+          errors: draft.errors.full_messages
+        },
+               status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      destroy_current_draft
+
+      head :no_content
+    end
+
+    private
+
+    def find_readable_topic
+      @topic =
+        Topic.find(
+          params[:topic_id]
+        )
+
+      readable_content =
+        ReadableCommunityContent.new(
+          viewer: current_rails_den_user
+        )
+
+      unless readable_content.topic_readable?(
+        @topic
+      )
+        raise ActiveRecord::RecordNotFound
+      end
+    end
+
+    def require_reply_permission!
+      return if PermissionResolver.allowed?(
+        user: current_rails_den_user,
+        capability: :reply,
+        board: @topic.board
+      )
+
+      head :forbidden
+    end
+
+    def require_unlocked_topic!
+      return unless @topic.locked?
+
+      head :forbidden
+    end
+
+    def find_reply_to_post
+      reply_to_id =
+        draft_params[:reply_to_id]
+
+      return if reply_to_id.blank?
+
+      @topic.posts.find(reply_to_id)
+    end
+
+    def find_quoted_post
+      quoted_post_id =
+        draft_params[:quoted_post_id]
+
+      return if quoted_post_id.blank?
+
+      @topic
+        .posts
+        .where(deleted_at: nil)
+        .find(quoted_post_id)
+    end
+
+    def destroy_current_draft
+      PostDraft.find_by(
+        topic: @topic,
+        author: current_rails_den_user
+      )&.destroy!
+    end
+
+    def draft_params
+      params
+        .require(:rails_den_post_draft)
+        .permit(
+          :body,
+          :reply_to_id,
+          :quoted_post_id
+        )
+    end
+  end
+end

data/app/controllers/rails_den/post_reports_controller.rb

@@ -0,0 +1,31 @@
+module RailsDen
+  class PostReportsController < ReportsController
+    private
+
+    def load_reportable!
+      topic = Topic.find(params[:topic_id])
+      readable = ReadableCommunityContent.new(viewer: current_rails_den_user)
+      raise ActiveRecord::RecordNotFound unless readable.topic_readable?(topic)
+
+      @reportable = readable.posts.where(topic: topic).find(params[:post_id])
+    end
+
+    def report_heading
+      "Report post by #{RailsDen.user_display_name(@reportable.author)}"
+    end
+
+    def report_subject = @reportable.body.to_s.truncate(120)
+
+    def report_submit_path
+      topic_post_report_path(@reportable.topic, @reportable)
+    end
+
+    def report_return_path
+      topic_path(
+        @reportable.topic,
+        page: @reportable.topic.posts_page_for(@reportable),
+        anchor: "post-#{@reportable.id}"
+      )
+    end
+  end
+end