rails_den 2.0.0

data/app/controllers/rails_den/posts_controller.rb

@@ -0,0 +1,318 @@
+module RailsDen
+  class PostsController < ApplicationController
+    before_action :require_rails_den_participation!, only: %i[create edit update]
+    before_action :find_post,
+                  only: %i[
+                    edit
+                    update
+                    destroy
+                    restore
+                    history
+                  ]
+
+    before_action :require_post_edit_permission!,
+                  only: %i[edit update]
+
+    before_action :require_post_delete_permission!,
+                  only: :destroy
+
+    before_action :require_post_restore_permission!,
+                  only: :restore
+
+    before_action :require_post_history_permission!,
+                  only: :history
+
+    def create
+      @topic = find_public_topic
+
+      unless PermissionResolver.allowed?(
+        user: current_rails_den_user,
+        capability: :reply,
+        board: @topic.board
+      )
+        return head :forbidden
+      end
+
+      return head :forbidden if @topic.locked?
+
+      attachments =
+        submitted_attachments
+
+      if attachments.any? &&
+         !can_upload_to_board?(@topic.board)
+        return head :forbidden
+      end
+
+      quoted_post = find_quoted_post
+
+      @post = @topic.posts.build(post_params)
+      @post.author = current_rails_den_user
+      @post.quoted_post = quoted_post
+      @post.reply_to =
+        quoted_post || find_reply_to_post
+      @post.pending_attachments =
+        attachments
+
+      @quote_post = quoted_post
+
+      if @post.save
+        attach_pending_files(@post)
+        destroy_current_draft
+
+        redirect_to topic_path(
+          @topic,
+          page: @topic.posts_page_count,
+          anchor: "post-#{@post.id}"
+        )
+      else
+        load_posts_page
+
+        render "rails_den/topics/show",
+               status: :unprocessable_entity
+      end
+    end
+
+    def edit
+      @page = @topic.normalized_posts_page(
+        params[:page]
+      )
+
+      @edit_reason = nil
+    end
+
+    def update
+      attachments =
+        submitted_attachments
+
+      if attachments.any? &&
+         !can_upload_to_board?(@topic.board)
+        return head :forbidden
+      end
+
+      @edit_reason = edit_reason_param
+      @post.pending_attachments =
+        attachments
+
+      if @post.revise(
+        post_params,
+        editor: current_rails_den_user,
+        edit_reason: @edit_reason
+      )
+        attach_pending_files(@post)
+
+        redirect_to topic_path(
+          @topic,
+          page: return_page,
+          anchor: "post-#{@post.id}"
+        )
+      else
+        @page = return_page
+
+        render :edit,
+               status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @post.soft_delete!(
+        by: current_rails_den_user
+      )
+
+      if rails_den_can_moderate_post?(@post)
+        RailsDen::ModerationAudit.record!(action: "post.deleted", subject: @post,
+                                          actor: current_rails_den_user,
+                                          scope_board: @topic.board)
+      end
+
+      redirect_to topic_path(
+        @topic,
+        page: return_page,
+        anchor: "post-#{@post.id}"
+      )
+    end
+
+    def restore
+      @post.restore!
+
+      if rails_den_can_moderate_post?(@post)
+        RailsDen::ModerationAudit.record!(action: "post.restored", subject: @post,
+                                          actor: current_rails_den_user,
+                                          scope_board: @topic.board)
+      end
+
+      redirect_to topic_path(
+        @topic,
+        page: return_page,
+        anchor: "post-#{@post.id}"
+      )
+    end
+
+    def history
+      @page = @topic.normalized_posts_page(
+        params[:page]
+      )
+
+      @revisions =
+        @post
+          .post_revisions
+          .includes(:editor)
+          .order(
+            created_at: :desc,
+            id: :desc
+          )
+    end
+
+    private
+
+    def find_public_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
+
+      topic
+    end
+
+    def find_post
+      @topic = find_public_topic
+      @post = @topic.posts.find(params[:id])
+    end
+
+    def find_reply_to_post
+      reply_to_id =
+        params.dig(
+          :rails_den_post,
+          :reply_to_id
+        )
+
+      return if reply_to_id.blank?
+
+      @topic.posts.find(reply_to_id)
+    end
+
+    def find_quoted_post
+      quoted_post_id =
+        params.dig(
+          :rails_den_post,
+          :quoted_post_id
+        )
+
+      return if quoted_post_id.blank?
+
+      @topic
+        .posts
+        .where(deleted_at: nil)
+        .find(quoted_post_id)
+    end
+
+    def load_posts_page
+      @page = @topic.normalized_posts_page(
+        params[:page]
+      )
+
+      @total_pages = @topic.posts_page_count
+
+      @posts =
+        @topic
+          .posts_for_page(@page)
+          .with_attached_attachments
+          .includes(
+            :mentions,
+            :onebox_entries
+          )
+
+      @bookmark_state =
+        BookmarkState.call(
+          bookmarker: current_rails_den_user,
+          topic: @topic,
+          posts: @posts
+        )
+    end
+
+    def return_page
+      @topic.normalized_posts_page(
+        params[:page]
+      )
+    end
+
+    def can_upload_to_board?(board)
+      PermissionResolver.allowed?(
+        user: current_rails_den_user,
+        capability: :upload,
+        board: board
+      )
+    end
+
+    def require_post_edit_permission!
+      return if rails_den_can_edit_post?(@post)
+
+      head :forbidden
+    end
+
+    def require_post_delete_permission!
+      return if rails_den_can_delete_post?(@post)
+
+      head :forbidden
+    end
+
+    def require_post_restore_permission!
+      return if rails_den_can_restore_post?(@post)
+
+      head :forbidden
+    end
+
+    def require_post_history_permission!
+      return if rails_den_can_view_post_history?(@post)
+
+      head :forbidden
+    end
+
+    def destroy_current_draft
+      PostDraft.find_by(
+        topic: @topic,
+        author: current_rails_den_user
+      )&.destroy!
+    end
+
+    def edit_reason_param
+      params.dig(
+        :rails_den_post,
+        :edit_reason
+      )
+    end
+
+    def submitted_attachments
+      Array(
+        params.dig(
+          :rails_den_post,
+          :attachments
+        )
+      ).reject(&:blank?)
+    end
+
+    def attach_pending_files(post)
+      return if post.pending_attachments.empty?
+
+      post.attachments.attach(
+        post.pending_attachments
+      )
+    end
+
+    def post_params
+      params.require(:rails_den_post).permit(
+        :body
+      )
+    end
+  end
+end

data/app/controllers/rails_den/presence_controller.rb

@@ -0,0 +1,12 @@
+module RailsDen
+  class PresenceController < ApplicationController
+    skip_before_action :authenticate_rails_den_user!
+
+    def index
+      @presence_directory =
+        RailsDen::Presence::Directory.call(
+          viewer: current_rails_den_user
+        )
+    end
+  end
+end

data/app/controllers/rails_den/presence_snapshots_controller.rb

@@ -0,0 +1,83 @@
+module RailsDen
+  class PresenceSnapshotsController < ApplicationController
+    skip_before_action :authenticate_rails_den_user!
+
+    def show
+      if params[:board_id].present?
+        render_board_snapshot
+        return
+      end
+
+      render_directory_snapshot
+    end
+
+    private
+
+    def render_board_snapshot
+      board =
+        RailsDen::Board.find(
+          params[:board_id]
+        )
+
+      readable_content =
+        RailsDen::ReadableCommunityContent.new(
+          viewer: current_rails_den_user
+        )
+
+      unless readable_content.board_readable?(
+        board
+      )
+        raise ActiveRecord::RecordNotFound
+      end
+
+      board_presence =
+        RailsDen::Presence::BoardSummary.call(
+          board: board,
+          viewer: current_rails_den_user
+        )
+
+      render json: {
+        board_presence_visible:
+          board_presence.visible?,
+        board_presence_count:
+          board_presence.count
+      }
+    end
+
+    def render_directory_snapshot
+      directory =
+        RailsDen::Presence::Directory.call(
+          viewer: current_rails_den_user
+        )
+
+      render json: {
+        visible: directory.visible?,
+        available: directory.available?,
+        online_count: directory.online_count,
+        away_count: directory.away_count,
+        directory_summary_html:
+          render_to_string(
+            partial:
+              "rails_den/presence/summary",
+            formats: [
+              :html
+            ],
+            locals: {
+              directory: directory
+            }
+          ),
+        directory_body_html:
+          render_to_string(
+            partial:
+              "rails_den/presence/directory_body",
+            formats: [
+              :html
+            ],
+            locals: {
+              directory: directory
+            }
+          )
+      }
+    end
+  end
+end

data/app/controllers/rails_den/previews_controller.rb

@@ -0,0 +1,10 @@
+module RailsDen
+  class PreviewsController < ApplicationController
+    def create
+      render html: RailsDen.format(
+        params.fetch(:body, "")
+      ),
+             layout: false
+    end
+  end
+end

data/app/controllers/rails_den/private_conversations_controller.rb

@@ -0,0 +1,120 @@
+module RailsDen
+  class PrivateConversationsController < ApplicationController
+    rescue_from ActiveRecord::RecordNotFound,
+                with: :render_not_found
+    before_action :set_conversation, only: %i[show hide_inbox hide_sent]
+
+    def index
+      load_mailbox(:inbox)
+    end
+
+    def sent
+      load_mailbox(:sent)
+    end
+
+    def new
+      @recipient_mention_name = params[:to].to_s.delete_prefix("@")
+      @subject = ""
+      @body = ""
+      @errors = []
+      ensure_can_send!
+    end
+
+    def create
+      attributes = private_message_params
+      @recipient_mention_name = attributes[:to].to_s
+      @subject = attributes[:subject].to_s
+      @body = attributes[:body].to_s
+      result = RailsDen::PrivateMessages::Sender.start(
+        sender: current_rails_den_user,
+        recipient_mention_name: @recipient_mention_name,
+        subject: @subject,
+        body: @body
+      )
+
+      if result.success?
+        redirect_to private_conversation_path(result.conversation)
+      else
+        @errors = result.errors
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def show
+      RailsDen::PrivateMessages::ReadMarker.call(
+        conversation: @conversation,
+        reader: current_rails_den_user
+      )
+      load_thread
+    end
+
+    def hide_inbox
+      @participant.update!(inbox_hidden_at: Time.current)
+      redirect_to private_messages_path, status: :see_other, notice: "Removed from Inbox."
+    end
+
+    def hide_sent
+      @participant.update!(sent_hidden_at: Time.current)
+      redirect_to sent_private_messages_path, status: :see_other, notice: "Removed from Sent."
+    end
+
+    private
+
+    def load_mailbox(box)
+      result = RailsDen::PrivateMessages::Mailbox.public_send(
+        box,
+        owner: current_rails_den_user,
+        page: params[:page]
+      )
+      @mailbox = box
+      @entries = result.entries
+      @page = result.page
+      @total_pages = result.total_pages
+      @total_count = result.total_count
+    end
+
+    def set_conversation
+      @participant = RailsDen::PrivateConversationParticipant
+        .where(participant: current_rails_den_user)
+        .find_by!(private_conversation_id: params[:id])
+      @conversation = @participant.private_conversation
+    end
+
+    def load_thread(reply_body: "", errors: [])
+      total_count = @conversation.private_messages.count
+      @total_pages = [(total_count.to_f / 50).ceil, 1].max
+      requested_page = params[:page].present? ? params[:page].to_i : @total_pages
+      @page = [[requested_page, 1].max, @total_pages].min
+      @messages = @conversation.private_messages
+        .includes(:sender)
+        .order(:created_at, :id)
+        .offset((@page - 1) * 50)
+        .limit(50)
+      @counterpart = @conversation.private_conversation_participants
+        .includes(:participant)
+        .map(&:participant)
+        .find { |identity| identity != current_rails_den_user }
+      @reply_body = reply_body
+      @errors = errors
+      @can_send = RailsDen::PermissionResolver.allowed?(
+        user: current_rails_den_user,
+        capability: :message
+      ) && RailsDen::RestrictionResolver.can_participate?(user: current_rails_den_user)
+    end
+
+    def private_message_params
+      params.require(:private_message).permit(:to, :subject, :body)
+    end
+
+    def ensure_can_send!
+      return if RailsDen::PermissionResolver.allowed?(user: current_rails_den_user, capability: :message) &&
+        RailsDen::RestrictionResolver.can_participate?(user: current_rails_den_user)
+
+      redirect_to private_messages_path, alert: "You cannot send private messages right now."
+    end
+
+    def render_not_found
+      head :not_found
+    end
+  end
+end

data/app/controllers/rails_den/private_messages_controller.rb

@@ -0,0 +1,45 @@
+module RailsDen
+  class PrivateMessagesController < ApplicationController
+    rescue_from ActiveRecord::RecordNotFound,
+                with: -> { head :not_found }
+    def create
+      participant = RailsDen::PrivateConversationParticipant
+        .where(participant: current_rails_den_user)
+        .find_by!(private_conversation_id: params[:id])
+      conversation = participant.private_conversation
+      body = params.require(:private_message).permit(:body)[:body].to_s
+      result = RailsDen::PrivateMessages::Sender.reply(
+        sender: current_rails_den_user,
+        conversation: conversation,
+        body: body
+      )
+
+      if result.success?
+        page = [(conversation.private_messages.count.to_f / 50).ceil, 1].max
+        redirect_to private_conversation_path(
+          conversation,
+          page: page,
+          anchor: "private-message-#{result.message.id}"
+        )
+      else
+        @participant = participant
+        @conversation = conversation
+        load_thread(body, result.errors)
+        render "rails_den/private_conversations/show", status: :unprocessable_entity
+      end
+    end
+
+    private
+
+    def load_thread(reply_body, errors)
+      total_count = @conversation.private_messages.count
+      @total_pages = [(total_count.to_f / 50).ceil, 1].max
+      @page = @total_pages
+      @messages = @conversation.private_messages.includes(:sender).order(:created_at, :id).offset((@page - 1) * 50).limit(50)
+      @counterpart = @conversation.private_conversation_participants.includes(:participant).map(&:participant).find { |identity| identity != current_rails_den_user }
+      @reply_body = reply_body
+      @errors = errors
+      @can_send = false
+    end
+  end
+end

data/app/controllers/rails_den/reactions_controller.rb

@@ -0,0 +1,124 @@
+module RailsDen
+  class ReactionsController < ApplicationController
+    before_action :load_post
+    before_action :require_rails_den_participation!, only: %i[create destroy]
+
+    REACTORS_PER_PAGE = 50
+
+    def index
+      @reaction_type = ReactionType.find(params[:reaction_type_id])
+      scope = @post.reactions.where(reaction_type: @reaction_type).includes(:reactor).order(:id)
+      @page = [params[:page].to_i, 1].max
+      @total_pages = [(scope.count.to_f / REACTORS_PER_PAGE).ceil, 1].max
+      @page = @total_pages if @page > @total_pages
+      @reactions = scope.offset((@page - 1) * REACTORS_PER_PAGE).limit(REACTORS_PER_PAGE)
+
+      respond_to do |format|
+        format.html
+        format.json do
+          render json: {
+            html: render_to_string(
+              partial: "rails_den/reactions/reactor_list",
+              formats: [:html],
+              locals: { reactions: @reactions }
+            )
+          }
+        end
+      end
+    end
+
+    def picker
+      selected_ids = @post.reactions.where(reactor: current_rails_den_user).pluck(:reaction_type_id)
+      @picker_reaction_types = ReactionTypeSearch.call(
+        query: params[:q],
+        limit: 48,
+        exclude_ids: selected_ids
+      )
+
+      respond_to do |format|
+        format.html
+        format.json do
+          render json: {
+            html: render_to_string(
+              partial: "rails_den/reactions/picker_options",
+              formats: [:html],
+              locals: {
+                post: @post,
+                reaction_types: @picker_reaction_types
+              }
+            )
+          }
+        end
+      end
+    end
+
+    def create
+      return head :forbidden if @post.author == current_rails_den_user
+
+      reaction_type = ReactionType.enabled.find(params[:reaction_type_id])
+      reaction = @post.reactions.find_or_initialize_by(
+        reaction_type: reaction_type,
+        reactor: current_rails_den_user
+      )
+      created = reaction.new_record?
+      reaction.save!
+
+      respond_with_component(created: created)
+    rescue ActiveRecord::RecordNotUnique
+      respond_with_component(created: false)
+    end
+
+    def destroy
+      reaction = @post.reactions.find_by!(id: params[:id], reactor: current_rails_den_user)
+      reaction.destroy!
+      respond_with_component(created: false)
+    end
+
+    private
+
+    def load_post
+      @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])
+    end
+
+    def respond_with_component(created:)
+      respond_to do |format|
+        format.html { redirect_to_post }
+        format.json do
+          render json: {
+            html: render_component,
+            created: created
+          }
+        end
+      end
+    end
+
+    def render_component
+      render_to_string(
+        partial: "rails_den/reactions/post_reactions",
+        formats: [:html],
+        locals: {
+          post: @post,
+          summaries: ReactionSummary.call(posts: [@post], viewer: current_rails_den_user).fetch(@post.id),
+          enabled_reactions_exist: ReactionType.enabled.exists?,
+          picker_reaction_types: ReactionTypeSearch.call(
+            query: nil,
+            limit: 12,
+            exclude_ids: @post.reactions.where(reactor: current_rails_den_user).pluck(:reaction_type_id)
+          )
+        }
+      )
+    end
+
+    def redirect_to_post
+      redirect_to topic_path(
+        @topic,
+        page: @topic.posts_page_for(@post),
+        anchor: "post-#{@post.id}"
+      )
+    end
+  end
+end