rails_den 2.0.0

data/app/services/rails_den/readable_community_content.rb

@@ -0,0 +1,156 @@
+module RailsDen
+  class ReadableCommunityContent
+    def initialize(viewer:)
+      @viewer = viewer
+    end
+
+    def boards
+      base_boards.where(
+        id: readable_board_ids
+      )
+    end
+
+    def categories
+      eligible_categories.where(
+        id: readable_board_category_ids
+      )
+    end
+
+    def topics
+      base_topics.where(
+        id: readable_topic_ids
+      )
+    end
+
+    def posts
+      Post
+        .where(deleted_at: nil)
+        .joins(:topic)
+        .merge(topics)
+    end
+
+    def board_readable?(board)
+      boards.where(
+        id: board.id
+      ).exists?
+    end
+
+    def category_readable?(category)
+      categories.where(
+        id: category.id
+      ).exists?
+    end
+
+    def topic_readable?(topic)
+      topics.where(
+        id: topic.id
+      ).exists?
+    end
+
+    def post_readable?(post)
+      posts.where(
+        id: post.id
+      ).exists?
+    end
+
+    def notification_readable?(notification)
+      subject = notification.notification_event.subject
+
+      case subject
+      when RailsDen::Topic
+        topic_readable?(subject)
+      when RailsDen::Post
+        post_readable?(subject)
+      when RailsDen::PrivateMessage
+        subject.private_message_recipients.exists?(recipient: viewer)
+      when RailsDen::Report
+        report_review_policy.reviewable?(subject)
+      when RailsDen::UserWarning, RailsDen::UserRestriction
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    attr_reader :viewer
+
+    def report_review_policy
+      @report_review_policy ||=
+        RailsDen::ReportReviewPolicy.new(viewer: viewer)
+    end
+
+    def base_categories
+      Category.where(
+        enabled: true,
+        visibility: "public"
+      )
+    end
+
+    def eligible_categories
+      base_categories.where(
+        id: eligible_category_ids
+      )
+    end
+
+    def eligible_category_ids
+      @eligible_category_ids ||= base_categories.filter_map do |category|
+        if RailsDen::PermissionResolver.eligible?(
+          user: viewer,
+          category: category
+        )
+          category.id
+        end
+      end
+    end
+
+    def readable_board_category_ids
+      @readable_board_category_ids ||=
+        boards.distinct.pluck(:category_id)
+    end
+
+    def base_boards
+      Board
+        .joins(:category)
+        .merge(eligible_categories)
+        .where(
+          rails_den_boards: {
+            enabled: true,
+            visibility: "public"
+          }
+        )
+    end
+
+    def readable_board_ids
+      @readable_board_ids ||= base_boards.filter_map do |board|
+        if RailsDen::PermissionResolver.allowed?(
+          user: viewer,
+          capability: :view,
+          board: board
+        )
+          board.id
+        end
+      end
+    end
+
+    def base_topics
+      Topic
+        .joins(:board)
+        .merge(boards)
+        .where(deleted_at: nil, merged_into_id: nil)
+    end
+
+    def readable_topic_ids
+      @readable_topic_ids ||= base_topics.filter_map do |topic|
+        if RailsDen::PermissionResolver.allowed?(
+          user: viewer,
+          capability: :view,
+          topic: topic
+        )
+          topic.id
+        end
+      end
+    end
+  end
+end

data/app/services/rails_den/report_assignment.rb

@@ -0,0 +1,31 @@
+module RailsDen
+  class ReportAssignment
+    def self.call(report:, actor:, assignee:)
+      raise ActiveRecord::RecordNotFound unless ReportReviewPolicy.new(viewer: actor).reviewable?(report)
+
+      action = if assignee.nil?
+        "report.released"
+      elsif report.assigned_to.nil?
+        "report.claimed"
+      else
+        "report.reassigned"
+      end
+
+      Report.transaction do
+        report.update!(assigned_to: assignee, assigned_at: assignee ? Time.current : nil)
+        ModerationAudit.record!(action: action, subject: report, actor: actor, report: report,
+                                scope_board: report_board(report),
+                                metadata: { "assignee_label" => assignee && RailsDen.user_display_name(assignee) })
+      end
+      report
+    end
+
+    def self.report_board(report)
+      case report.reportable
+      when Topic then report.reportable.board
+      when Post then report.reportable.topic.board
+      end
+    end
+    private_class_method :report_board
+  end
+end

data/app/services/rails_den/report_creator.rb

@@ -0,0 +1,96 @@
+module RailsDen
+  class ReportCreator
+    EXCERPT_LENGTH = 500
+    DUPLICATE_MESSAGE = "You have already reported this."
+
+    class << self
+      def call(reporter:, reportable:, report_reason:, details: nil)
+        new(
+          reporter: reporter,
+          reportable: reportable,
+          report_reason: report_reason,
+          details: details
+        ).call
+      end
+    end
+
+    def initialize(reporter:, reportable:, report_reason:, details: nil)
+      @reporter = reporter
+      @reportable = reportable
+      @report_reason = report_reason
+      @details = details.to_s.strip.presence
+    end
+
+    def call
+      report = Report.new(
+        reporter: reporter,
+        reportable: reportable,
+        report_reason: report_reason,
+        details: details,
+        status: "open",
+        subject_user: subject_user,
+        **snapshot_attributes
+      )
+
+      Report.transaction do
+        if duplicate_open_report?
+          report.errors.add(:base, DUPLICATE_MESSAGE)
+        else
+          report.save
+        end
+      end
+
+      ReportDelivery.call(report: report) if report.persisted?
+
+      report
+    end
+
+    private
+
+    attr_reader :reporter, :reportable, :report_reason, :details
+
+    def duplicate_open_report?
+      Report.open.where(
+        reporter: reporter,
+        reportable: reportable
+      ).lock.exists?
+    end
+
+    def snapshot_attributes
+      case reportable
+      when Topic
+        {
+          subject_label: label(reportable.title),
+          subject_excerpt: excerpt(reportable.posts.order(:created_at, :id).pick(:body))
+        }
+      when Post
+        {
+          subject_label: label("Post by #{RailsDen.user_display_name(reportable.author)}"),
+          subject_excerpt: excerpt(reportable.body)
+        }
+      else
+        {
+          subject_label: label(RailsDen.user_display_name(reportable)),
+          subject_excerpt: nil
+        }
+      end
+    end
+
+    def subject_user
+      case reportable
+      when Topic, Post
+        reportable.author
+      else
+        reportable
+      end
+    end
+
+    def excerpt(value)
+      value.to_s.each_grapheme_cluster.take(EXCERPT_LENGTH).join.presence
+    end
+
+    def label(value)
+      value.to_s.each_grapheme_cluster.take(255).join
+    end
+  end
+end

data/app/services/rails_den/report_delivery.rb

@@ -0,0 +1,39 @@
+module RailsDen
+  class ReportDelivery
+    class << self
+      def call(report:)
+        new(report: report).call
+      end
+    end
+
+    def initialize(report:)
+      @report = report
+    end
+
+    def call
+      event = RailsDen::NotificationEvent.create_or_find_by!(
+        dedupe_key: "report_created:#{report.id}"
+      ) do |new_event|
+        new_event.assign_attributes(
+          event_type: "report_created",
+          actor: report.reporter,
+          subject: report,
+          target: report.reportable
+        )
+      end
+
+      RailsDen::Notifications::Materializer.call(events: [event])
+      event
+    rescue StandardError => error
+      Rails.logger.error(
+        "RailsDen report #{report.id} notification delivery failed: " \
+          "#{error.class}: #{error.message}"
+      )
+      nil
+    end
+
+    private
+
+    attr_reader :report
+  end
+end

data/app/services/rails_den/report_disposition.rb

@@ -0,0 +1,25 @@
+module RailsDen
+  class ReportDisposition
+    def self.call(report:, actor:, status:, note:)
+      raise ActiveRecord::RecordNotFound unless ReportReviewPolicy.new(viewer: actor).reviewable?(report)
+      raise ArgumentError, "unknown report status" unless status.to_s.in?(Report::STATUSES)
+
+      note = note.to_s.strip
+      report.errors.add(:resolution_note, "is required") if note.blank?
+      return report if report.errors.any?
+
+      Report.transaction do
+        if status.to_s == "open"
+          report.update!(status: "open", closed_by: nil, closed_at: nil, resolution_note: nil)
+          action = "report.reopened"
+        else
+          report.update!(status: status, closed_by: actor, closed_at: Time.current, resolution_note: note)
+          action = "report.#{status}"
+        end
+        ModerationAudit.record!(action: action, subject: report, actor: actor, report: report,
+                                note: note, scope_board: ReportAssignment.send(:report_board, report))
+      end
+      report
+    end
+  end
+end

data/app/services/rails_den/report_recipients.rb

@@ -0,0 +1,89 @@
+module RailsDen
+  class ReportRecipients
+    class << self
+      def call(report:)
+        new(report: report).call
+      end
+    end
+
+    def initialize(report:)
+      @report = report
+    end
+
+    def call
+      policy_candidates
+        .uniq { |candidate| identity_key(candidate) }
+        .select do |candidate|
+          RailsDen::ReportReviewPolicy.new(viewer: candidate)
+            .reviewable?(report)
+        end
+    end
+
+    private
+
+    attr_reader :report
+
+    def policy_candidates
+      candidates = [
+        *global_role_holders,
+        *administrator_identities
+      ]
+
+      board = report_board
+      candidates.concat(board_role_holders(board)) if board
+      candidates.compact
+    end
+
+    def global_role_holders
+      RailsDen::RoleAssignment
+        .where(role_id: candidate_role_ids)
+        .includes(:user)
+        .map(&:user)
+    end
+
+    def administrator_identities
+      RailsDen::Administrator.includes(:user).map(&:user)
+    end
+
+    def board_role_holders(board)
+      RailsDen::BoardRoleAssignment
+        .where(board: board, role_id: candidate_role_ids(board: board))
+        .includes(:user)
+        .map(&:user)
+    end
+
+    def candidate_role_ids(board: report_board)
+      role_ids = RailsDen::RolePermission.where(
+        capability: "moderate",
+        allowed: true
+      ).select(:role_id)
+
+      ids = RailsDen::Role.where(id: role_ids).pluck(:id)
+
+      if board
+        ids.concat(
+          RailsDen::BoardRolePermission.where(
+            board: board,
+            capability: "moderate",
+            allowed: true
+          ).pluck(:role_id)
+        )
+      end
+
+      ids.uniq
+    end
+
+    def report_board
+      case report.reportable
+      when RailsDen::Topic
+        report.reportable.board
+      when RailsDen::Post
+        report.reportable.topic.board
+      end
+    end
+
+    def identity_key(identity)
+      [identity.class.polymorphic_name, identity.id]
+    end
+  end
+end

data/app/services/rails_den/report_review_policy.rb

@@ -0,0 +1,66 @@
+module RailsDen
+  class ReportReviewPolicy
+    def initialize(viewer:)
+      @viewer = viewer
+    end
+
+    def reviewable?(report)
+      return false unless viewer
+
+      case report.reportable_type
+      when RailsDen::Topic.polymorphic_name
+        topic = report.reportable
+        topic && moderate_topic_cached?(topic)
+      when RailsDen::Post.polymorphic_name
+        post = report.reportable
+        post && moderate_topic_cached?(post.topic)
+      else
+        global_moderator?
+      end
+    end
+
+    def live_target_readable?(report)
+      return false unless reviewable?(report)
+
+      target = report.reportable
+      content = RailsDen::ReadableCommunityContent.new(viewer: viewer)
+
+      case target
+      when RailsDen::Topic
+        content.topic_readable?(target)
+      when RailsDen::Post
+        content.post_readable?(target)
+      else
+        target.present?
+      end
+    end
+
+    def global_moderator?
+      return @global_moderator if defined?(@global_moderator)
+
+      @global_moderator = RailsDen::PermissionResolver.allowed?(
+          user: viewer,
+          capability: :moderate
+        )
+    end
+
+    private
+
+    attr_reader :viewer
+
+    def moderate_topic?(topic)
+      RailsDen::PermissionResolver.allowed?(
+        user: viewer,
+        capability: :moderate,
+        topic: topic
+      )
+    end
+
+    def moderate_topic_cached?(topic)
+      @topic_decisions ||= {}
+      @topic_decisions.fetch(topic.id) do
+        @topic_decisions[topic.id] = moderate_topic?(topic)
+      end
+    end
+  end
+end

data/app/services/rails_den/report_review_scope.rb

@@ -0,0 +1,49 @@
+module RailsDen
+  class ReportReviewScope
+    class << self
+      def call(viewer:, relation: RailsDen::Report.all)
+        new(viewer: viewer, relation: relation).call
+      end
+    end
+
+    def initialize(viewer:, relation:)
+      @viewer = viewer
+      @relation = relation
+    end
+
+    def call
+      policy = RailsDen::ReportReviewPolicy.new(viewer: viewer)
+
+      reports = relation
+        .includes(:report_reason, :reporter, :reportable)
+        .order(created_at: :desc, id: :desc)
+        .to_a
+
+      preload_content_context(reports)
+      reports.select { |report| policy.reviewable?(report) }
+    end
+
+    private
+
+    attr_reader :viewer, :relation
+
+    def preload_content_context(reports)
+      topics = reports.filter_map do |report|
+        report.reportable if report.reportable.is_a?(RailsDen::Topic)
+      end
+      posts = reports.filter_map do |report|
+        report.reportable if report.reportable.is_a?(RailsDen::Post)
+      end
+
+      ActiveRecord::Associations::Preloader.new(
+        records: topics,
+        associations: { board: :category }
+      ).call if topics.any?
+
+      ActiveRecord::Associations::Preloader.new(
+        records: posts,
+        associations: { topic: { board: :category } }
+      ).call if posts.any?
+    end
+  end
+end

data/app/services/rails_den/restriction_resolver.rb

@@ -0,0 +1,28 @@
+module RailsDen
+  class RestrictionResolver
+    class << self
+      def account_state(user:, at: Time.current)
+        active = active_restrictions(user: user, at: at)
+        return "banned" if active.any? { |restriction| restriction.kind == "ban" }
+        return "suspended" if active.any? { |restriction| restriction.kind == "suspension" }
+
+        "active"
+      end
+
+      def silenced?(user:, at: Time.current)
+        active_restrictions(user: user, at: at).any? { |restriction| restriction.kind == "silence" }
+      end
+
+      def suspended?(user:, at: Time.current) = account_state(user: user, at: at) == "suspended"
+      def banned?(user:, at: Time.current) = account_state(user: user, at: at) == "banned"
+      def can_access?(user:, at: Time.current) = account_state(user: user, at: at) == "active"
+      def can_participate?(user:, at: Time.current) = can_access?(user: user, at: at) && !silenced?(user: user, at: at)
+
+      def active_restrictions(user:, at: Time.current)
+        RailsDen::UserRestriction.for_user(user).unlifted.where("starts_at <= ?", at).to_a.select do |restriction|
+          restriction.active?(at: at)
+        end
+      end
+    end
+  end
+end

data/app/services/rails_den/role_resolver.rb

@@ -0,0 +1,66 @@
+module RailsDen
+  class RoleResolver
+    class << self
+      def call(user:)
+        new(
+          user: user
+        ).call
+      end
+
+      def has_role?(user:, role:)
+        call(
+          user: user
+        ).include?(
+          role.to_s
+        )
+      end
+    end
+
+    def initialize(user:)
+      @user = user
+    end
+
+    def call
+      return ["guest"] unless user
+
+      role_keys =
+        [
+          "member",
+          *assigned_role_keys
+        ]
+
+      if legacy_administrator?
+        role_keys << "administrator"
+      end
+
+      role_keys.uniq
+    end
+
+    private
+
+    attr_reader :user
+
+    def assigned_role_keys
+      RailsDen::RoleAssignment
+        .where(
+          user: user
+        )
+        .joins(
+          :role
+        )
+        .order(
+          "rails_den_roles.position ASC",
+          "rails_den_roles.id ASC"
+        )
+        .pluck(
+          "rails_den_roles.key"
+        )
+    end
+
+    def legacy_administrator?
+      RailsDen::Administrator.exists?(
+        user: user
+      )
+    end
+  end
+end

data/app/services/rails_den/search/adapters/basic.rb

@@ -0,0 +1,35 @@
+module RailsDen
+  module Search
+    module Adapters
+      class Basic
+        def search(relation:, columns:, query:)
+          normalized_query =
+            query
+              .to_s
+              .strip
+              .downcase
+
+          return relation.none if normalized_query.blank?
+
+          pattern =
+            "%#{ActiveRecord::Base.sanitize_sql_like(normalized_query)}%"
+
+          conditions =
+            Array(columns)
+              .map do |column|
+                "LOWER(#{column}) LIKE ?"
+              end
+              .join(" OR ")
+
+          relation.where(
+            conditions,
+            *Array.new(
+              Array(columns).length,
+              pattern
+            )
+          )
+        end
+      end
+    end
+  end
+end