rails_den 2.0.0

data/app/controllers/rails_den/chat_messages_controller.rb

@@ -0,0 +1,166 @@
+module RailsDen
+  class ChatMessagesController < ApplicationController
+    before_action :require_rails_den_participation!
+
+    def create
+      @channel =
+        ChatChannel.find_by!(
+          slug: params[:chat_channel_slug]
+        )
+
+      access =
+        ChatChannelAccess.new(
+          viewer: current_rails_den_user,
+          channel: @channel
+        )
+
+      raise ActiveRecord::RecordNotFound unless access.readable?
+
+      return head :forbidden unless access.postable?
+
+      attributes =
+        message_params
+
+      if RailsDen::Chat::WhisperDelivery
+           .whisper_candidate?(
+             attributes[:body]
+           )
+        deliver_whisper(
+          attributes[:body]
+        )
+
+        return
+      end
+
+      @message =
+        @channel.chat_messages.build(
+          attributes
+        )
+
+      @message.author =
+        current_rails_den_user
+
+      if @message.save
+        respond_to do |format|
+          format.html do
+            redirect_to chat_channel_path(
+              @channel.slug,
+              anchor:
+                "chat-message-#{@message.id}"
+            )
+          end
+
+          format.json do
+            render json: {
+              message:
+                RailsDen::Chat::MessagePayload.call(
+                  @message
+                )
+            },
+                   status: :created
+          end
+        end
+      else
+        respond_to do |format|
+          format.html do
+            load_messages
+            @can_post = true
+
+            render "rails_den/chat_channels/show",
+                   status: :unprocessable_entity
+          end
+
+          format.json do
+            render json: {
+              errors:
+                @message.errors.full_messages
+            },
+                   status: :unprocessable_entity
+          end
+        end
+      end
+    end
+
+    private
+
+    def deliver_whisper(body)
+      result =
+        RailsDen::Chat::WhisperDelivery.call(
+          channel: @channel,
+          sender:
+            current_rails_den_user,
+          body: body
+        )
+
+      if result.fetch(:ok)
+        respond_to do |format|
+          format.html do
+            redirect_to chat_channel_path(
+              @channel.slug
+            ),
+                        status: :see_other,
+                        notice:
+                          "Whisper sent to @#{result.fetch(:target_mention_name)}."
+          end
+
+          format.json do
+            render json: {
+              message: nil,
+              whisper: {
+                target:
+                  result.fetch(
+                    :target_mention_name
+                  ),
+                body:
+                  result.fetch(:body)
+              }
+            },
+                   status: :created
+          end
+        end
+
+        return
+      end
+
+      respond_to do |format|
+        format.html do
+          redirect_to chat_channel_path(
+            @channel.slug
+          ),
+                      status: :see_other,
+                      alert:
+                        result.fetch(:error)
+        end
+
+        format.json do
+          render json: {
+            errors: [
+              result.fetch(:error)
+            ]
+          },
+                 status: :unprocessable_entity
+        end
+      end
+    end
+
+    def load_messages
+      @messages =
+        @channel
+          .chat_messages
+          .includes(:author)
+          .order(
+            created_at: :desc,
+            id: :desc
+          )
+          .limit(50)
+          .to_a
+          .reverse
+    end
+
+    def message_params
+      params
+        .require(:chat_message)
+        .permit(:body)
+    end
+  end
+end

data/app/controllers/rails_den/chat_reaction_types_controller.rb

@@ -0,0 +1,24 @@
+module RailsDen
+  class ChatReactionTypesController < ApplicationController
+    PICKER_LIMIT = 48
+
+    def index
+      reaction_types =
+        ReactionTypeSearch.call(
+          query: params[:q],
+          limit: PICKER_LIMIT
+        )
+
+      render json: {
+        reaction_types: reaction_types.map do |reaction_type|
+          {
+            id: reaction_type.id,
+            name: reaction_type.name,
+            key: reaction_type.key,
+            emoji: reaction_type.emoji
+          }
+        end
+      }
+    end
+  end
+end

data/app/controllers/rails_den/community_read_states_controller.rb

@@ -0,0 +1,12 @@
+module RailsDen
+  class CommunityReadStatesController < ApplicationController
+    def update
+      CommunityReadState.mark_all_read!(
+        reader: current_rails_den_user
+      )
+
+      redirect_to root_path,
+                  notice: "Everything marked read."
+    end
+  end
+end

data/app/controllers/rails_den/home_controller.rb

@@ -0,0 +1,35 @@
+module RailsDen
+  class HomeController < ApplicationController
+    skip_before_action :authenticate_rails_den_user!
+
+    def index
+      readable_content =
+        ReadableCommunityContent.new(
+          viewer: current_rails_den_user
+        )
+
+      @community_presence =
+        RailsDen::Presence::CommunitySummary.call(
+          viewer: current_rails_den_user
+        )
+
+      @readable_boards_by_category_id =
+        readable_content
+          .boards
+          .ordered
+          .group_by(&:category_id)
+
+      @categories =
+        readable_content
+          .categories
+          .ordered
+
+      @category_sponsorships_by_category_id =
+        CategorySponsorship
+          .includes(:sponsor)
+          .active_on(Date.current)
+          .where(category_id: @categories.map(&:id))
+          .index_by(&:category_id)
+    end
+  end
+end

data/app/controllers/rails_den/member_profiles_controller.rb

@@ -0,0 +1,286 @@
+module RailsDen
+  class MemberProfilesController < ApplicationController
+    before_action :require_rails_den_participation!,
+                  only: %i[
+                    edit
+                    edit_own
+                    update
+                    update_own
+                    destroy_avatar
+                  ]
+
+    skip_before_action :authenticate_rails_den_user!,
+                       only: :show
+
+    before_action :set_member_profile,
+                  except: %i[edit_own update_own]
+
+    before_action :require_profile_owner!,
+                  only: %i[edit update destroy_avatar]
+
+    def show
+      build_presenter
+
+      render "rails_den/member_profiles/show"
+    rescue ActiveRecord::RecordNotFound
+      head :not_found
+    end
+
+    def edit
+      prepare_profile_fields
+    end
+
+    def edit_own
+      @member_profile =
+        MemberProfile.find_or_initialize_by(
+          profile_owner: current_rails_den_user
+        )
+
+      prepare_profile_fields
+
+      render :edit
+    end
+
+    def update
+      persist_profile
+    end
+
+    def update_own
+      @member_profile =
+        MemberProfile.find_or_initialize_by(
+          profile_owner: current_rails_den_user
+        )
+
+      persist_profile
+    end
+
+    def destroy_avatar
+      @member_profile.avatar.purge if @member_profile.avatar.attached?
+
+      redirect_to member_profile_path(
+        mention_name: RailsDen.user_mention_name(
+          @member_profile.profile_owner
+        )
+      ),
+                  status: :see_other,
+                  notice: I18n.t(
+                    "rails_den.member_profiles.avatar_removed"
+                  )
+    end
+
+    private
+
+    def set_member_profile
+      @member_profile = MemberProfile.find(params[:id])
+      @member_profile.profile_owner
+    rescue ActiveRecord::RecordNotFound
+      head :not_found
+    end
+
+    def require_profile_owner!
+      return if performed?
+      return if @member_profile.profile_owner == current_rails_den_user
+
+      head :forbidden
+    end
+
+    def build_presenter
+      @presenter = MemberProfilePresenter.new(
+        profile: @member_profile,
+        viewer: current_rails_den_user,
+        host_profile_path: RailsDen.user_mention_path(
+          @member_profile.profile_owner
+        )
+      )
+    end
+
+    def persist_profile
+      @member_profile.assign_attributes(
+        member_profile_params
+      )
+
+      prepare_profile_fields(
+        submitted_values: submitted_profile_field_values
+      )
+
+      profile_valid =
+        @member_profile.valid?
+
+      profile_fields_valid =
+        validate_profile_field_values
+
+      unless profile_valid && profile_fields_valid
+        return render :edit,
+                      status: :unprocessable_entity
+      end
+
+      MemberProfile.transaction do
+        @member_profile.save!
+        persist_profile_field_values!
+      end
+
+      MemberProfileStatsRefreshJob.perform_now(
+        @member_profile.id
+      )
+
+      redirect_to member_profile_path(
+        mention_name: RailsDen.user_mention_name(
+          @member_profile.profile_owner
+        )
+      ),
+                  status: :see_other,
+                  notice: I18n.t(
+                    "rails_den.member_profiles.updated"
+                  )
+    rescue ActiveRecord::RecordInvalid => error
+      add_record_errors(error.record)
+
+      render :edit,
+             status: :unprocessable_entity
+    rescue ActiveRecord::StatementInvalid
+      @member_profile.errors.add(
+        :avatar,
+        "storage is not installed; run the Active Storage migrations"
+      )
+
+      render :edit,
+             status: :unprocessable_entity
+    end
+
+    def prepare_profile_fields(submitted_values: nil)
+      @profile_fields ||=
+        ProfileField
+          .enabled
+          .ordered
+          .to_a
+
+      existing_values =
+        @member_profile
+          .profile_field_values
+          .to_a
+          .index_by(&:profile_field_id)
+
+      @profile_field_values_by_id = {}
+
+      @profile_fields.each do |profile_field|
+        value_record =
+          existing_values[profile_field.id] ||
+          @member_profile.profile_field_values.build(
+            profile_field: profile_field
+          )
+
+        if submitted_values&.key?(
+          profile_field.id.to_s
+        )
+          value_record.value =
+            submitted_values[
+              profile_field.id.to_s
+            ]
+        end
+
+        @profile_field_values_by_id[
+          profile_field.id
+        ] = value_record
+      end
+    end
+
+    def validate_profile_field_values
+      valid = true
+
+      @profile_fields.each do |profile_field|
+        value_record =
+          @profile_field_values_by_id.fetch(
+            profile_field.id
+          )
+
+        next if value_record.valid?
+
+        valid = false
+
+        value_record.errors[:value].each do |message|
+          @member_profile.errors.add(
+            :base,
+            "#{profile_field.label}: #{message}"
+          )
+        end
+      end
+
+      valid
+    end
+
+    def persist_profile_field_values!
+      @profile_fields.each do |profile_field|
+        value_record =
+          @profile_field_values_by_id.fetch(
+            profile_field.id
+          )
+
+        if profile_field.field_type != "checkbox" &&
+           value_record.value.blank?
+          value_record.destroy! if value_record.persisted?
+
+          next
+        end
+
+        value_record.save!
+      end
+    end
+
+    def add_record_errors(record)
+      return if record.equal?(@member_profile)
+
+      if record.is_a?(ProfileFieldValue)
+        profile_field = record.profile_field
+
+        record.errors[:value].each do |message|
+          @member_profile.errors.add(
+            :base,
+            "#{profile_field.label}: #{message}"
+          )
+        end
+      else
+        record.errors.full_messages.each do |message|
+          @member_profile.errors.add(
+            :base,
+            message
+          )
+        end
+      end
+    end
+
+    def submitted_profile_field_values
+      @profile_fields ||=
+        ProfileField
+          .enabled
+          .ordered
+          .to_a
+
+      permitted_keys =
+        @profile_fields.map do |profile_field|
+          profile_field.id.to_s
+        end
+
+      params
+        .fetch(
+          :profile_field_values,
+          ActionController::Parameters.new
+        )
+        .permit(*permitted_keys)
+        .to_h
+    end
+
+    def member_profile_params
+      submitted =
+        params[:rails_den_member_profile] ||
+        params.require(:member_profile)
+
+      submitted.permit(
+        :avatar,
+        :bio,
+        :hide_followed_content,
+        :show_presence,
+        :show_current_board
+      )
+    end
+  end
+end

data/app/controllers/rails_den/member_reports_controller.rb

@@ -0,0 +1,22 @@
+module RailsDen
+  class MemberReportsController < ReportsController
+    private
+
+    def load_reportable!
+      normalized_name = params[:mention_name].to_s.strip.downcase
+      identity = RailsDen.resolve_user_mention(normalized_name)
+
+      unless identity && RailsDen.user_mention_name(identity) == normalized_name
+        raise ActiveRecord::RecordNotFound
+      end
+
+      @reportable = identity
+      @mention_name = normalized_name
+    end
+
+    def report_heading = "Report member"
+    def report_subject = RailsDen.user_display_name(@reportable)
+    def report_submit_path = member_report_path(mention_name: @mention_name)
+    def report_return_path = member_profile_path(mention_name: @mention_name)
+  end
+end

data/app/controllers/rails_den/members_controller.rb

@@ -0,0 +1,42 @@
+module RailsDen
+  class MembersController < ApplicationController
+    skip_before_action :authenticate_rails_den_user!,
+                       only: :show
+
+    def show
+      normalized_name =
+        params[:mention_name]
+          .to_s
+          .strip
+          .downcase
+
+      identity = RailsDen.resolve_user_mention(normalized_name)
+
+      unless identity &&
+             RailsDen.user_mention_name(identity) == normalized_name
+        return head :not_found
+      end
+
+      profile =
+        MemberProfile.find_by(profile_owner: identity) ||
+        MemberProfile.new(profile_owner: identity)
+
+      build_presenter(profile)
+
+      render "rails_den/member_profiles/show"
+    end
+
+    private
+
+    def build_presenter(profile)
+      @member_profile = profile
+      @presenter = MemberProfilePresenter.new(
+        profile: profile,
+        viewer: current_rails_den_user,
+        host_profile_path: RailsDen.user_mention_path(
+          profile.profile_owner
+        )
+      )
+    end
+  end
+end

data/app/controllers/rails_den/mention_candidates_controller.rb

@@ -0,0 +1,14 @@
+module RailsDen
+  class MentionCandidatesController < ApplicationController
+    def index
+      suggestions = Mentions::Autocomplete.call(
+        prefix: params[:q].to_s.strip.downcase,
+        limit: params[:limit]
+      )
+
+      render json: {
+        suggestions: suggestions.map(&:as_json)
+      }
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module RailsDen
+  module Moderation
+    class AuditEventsController < RailsDen::ApplicationController
+      def index
+        raise ActiveRecord::RecordNotFound unless RailsDen::ModerationAccess.allowed?(
+          user: current_rails_den_user
+        )
+        relation = RailsDen::ModerationEvent.all
+        relation = relation.where(action: params[:event_action]) if params[:event_action].present?
+        @events = RailsDen::ModerationEventScope.call(viewer: current_rails_den_user, relation: relation)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module RailsDen
+  module Moderation
+    class MemberHistoriesController < RailsDen::ApplicationController
+      def show
+        @member = resolve_member!
+        raise ActiveRecord::RecordNotFound unless RailsDen::ModerationAccess.allowed?(user: current_rails_den_user)
+
+        @global = RailsDen::ReportReviewPolicy.new(viewer: current_rails_den_user).global_moderator?
+        @reports = RailsDen::ReportReviewScope.call(
+          viewer: current_rails_den_user,
+          relation: RailsDen::Report.where(subject_user: @member)
+        )
+        @events = scoped_events
+        @warnings = @global ? RailsDen::UserWarning.where(user: @member).includes(:issued_by) : RailsDen::UserWarning.none
+        @restrictions = @global ? RailsDen::UserRestriction.where(user: @member).includes(:created_by, :lifted_by) : RailsDen::UserRestriction.none
+        @notes = @global ? RailsDen::ModerationNote.where(subject: @member).includes(:author).order(:created_at) : RailsDen::ModerationNote.none
+        @timeline = (@reports.to_a + @events.to_a).sort_by(&:created_at).reverse
+      end
+
+      private
+
+      def resolve_member!
+        name = params[:mention_name].to_s.downcase
+        member = RailsDen.resolve_user_mention(name)
+        raise ActiveRecord::RecordNotFound unless member && RailsDen.user_mention_name(member) == name
+        member
+      end
+
+      def scoped_events
+        report_ids = @reports.map(&:id)
+        relation = RailsDen::ModerationEvent.where(subject: @member)
+          .or(RailsDen::ModerationEvent.where(report_id: report_ids))
+        RailsDen::ModerationEventScope.call(viewer: current_rails_den_user, relation: relation)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module RailsDen
+  module Moderation
+    class MemberNotesController < RailsDen::ApplicationController
+      def create
+        member = resolve_member!
+        raise ActiveRecord::RecordNotFound unless RailsDen::ReportReviewPolicy.new(
+          viewer: current_rails_den_user
+        ).global_moderator?
+
+        RailsDen::ModerationNote.transaction do
+          RailsDen::ModerationNote.create!(subject: member, author: current_rails_den_user, body: params[:body])
+          RailsDen::ModerationAudit.record!(action: "moderation_note.created", subject: member,
+                                            actor: current_rails_den_user)
+        end
+        redirect_to moderation_member_history_path(mention_name: RailsDen.user_mention_name(member)),
+                    status: :see_other, notice: "Private member note added."
+      end
+
+      private
+
+      def resolve_member!
+        RailsDen.resolve_user_mention(params[:mention_name].to_s.downcase) || raise(ActiveRecord::RecordNotFound)
+      end
+    end
+  end
+end