rails_den 2.0.0

data/app/services/rails_den/notifications/materializer.rb

@@ -0,0 +1,284 @@
+module RailsDen
+  module Notifications
+    class Materializer
+      EVENT_PRIORITIES = {
+        "topic_created" => 10,
+        "badge_awarded" => 15,
+        "post_created" => 20,
+        "trust_level_reached" => 20,
+        "post_reacted" => 25,
+        "post_replied" => 30,
+        "post_quoted" => 40,
+        "post_mentioned" => 50,
+        "private_message_received" => 55,
+        "report_created" => 60,
+        "warning_issued" => 70,
+        "restriction_created" => 70,
+        "restriction_expired" => 70,
+        "restriction_lifted" => 70
+      }.freeze
+
+      GAMIFICATION_EVENT_TYPES = %w[
+        badge_awarded
+        trust_level_reached
+      ].freeze
+
+      class << self
+        def call(events:)
+          new(events: events).call
+        end
+      end
+
+      def initialize(events:)
+        @events =
+          Array(events)
+            .compact
+            .uniq(&:id)
+
+        @mute_cache = {}
+      end
+
+      def call
+        candidates_by_recipient.map do |_key, candidates|
+          materialize_for(candidates)
+        end.compact
+      end
+
+      private
+
+      attr_reader :events,
+                  :mute_cache
+
+      def candidates_by_recipient
+        candidates =
+          Hash.new do |hash, key|
+            hash[key] = []
+          end
+
+        events.each do |event|
+          recipients_for(event).each do |recipient|
+            next unless recipient
+
+            if same_identity?(
+              recipient,
+              event.actor
+            ) && !self_notification_allowed?(event)
+              next
+            end
+
+            next if muted_for_event?(
+              recipient,
+              event
+            )
+
+            candidates[identity_key(recipient)] << [
+              recipient,
+              event
+            ]
+          end
+        end
+
+        candidates
+      end
+
+      def recipients_for(event)
+        case event.event_type
+        when "topic_created"
+          board_followers(event)
+        when "post_created"
+          topic_followers(event)
+        when "post_replied"
+          [event.target&.author]
+        when "post_quoted"
+          [event.target&.author]
+        when "post_mentioned"
+          [event.target]
+        when "post_reacted"
+          [event.subject&.author]
+        when "private_message_received"
+          event
+            .subject
+            .private_message_recipients
+            .includes(
+              :recipient
+            )
+            .map(
+              &:recipient
+            )
+        when "badge_awarded",
+             "trust_level_reached"
+          [event.target]
+        when "report_created"
+          RailsDen::ReportRecipients.call(
+            report: event.subject
+          )
+        when "warning_issued",
+             "restriction_created",
+             "restriction_expired",
+             "restriction_lifted"
+          [event.target]
+        else
+          []
+        end
+      end
+
+      def board_followers(event)
+        topic = event.subject
+
+        return [] unless topic.is_a?(
+          RailsDen::Topic
+        )
+
+        topic
+          .board
+          .board_follows
+          .includes(
+            :follower
+          )
+          .map(
+            &:follower
+          )
+      end
+
+      def topic_followers(event)
+        post = event.subject
+
+        return [] unless post.is_a?(
+          RailsDen::Post
+        )
+
+        post
+          .topic
+          .topic_follows
+          .includes(
+            :follower
+          )
+          .map(
+            &:follower
+          )
+      end
+
+      def self_notification_allowed?(event)
+        GAMIFICATION_EVENT_TYPES.include?(
+          event.event_type
+        )
+      end
+
+      def muted_for_event?(recipient, event)
+        return false if %w[
+          report_created
+          private_message_received
+          badge_awarded
+          trust_level_reached
+        ].include?(
+          event.event_type
+        )
+
+        topic, board =
+          notification_context(event)
+
+        muted?(
+          recipient,
+          board
+        ) ||
+          muted?(
+            recipient,
+            topic
+          )
+      end
+
+      def notification_context(event)
+        subject = event.subject
+
+        case subject
+        when RailsDen::Topic
+          [
+            subject,
+            subject.board
+          ]
+        when RailsDen::Post
+          [
+            subject.topic,
+            subject.topic.board
+          ]
+        else
+          [
+            nil,
+            nil
+          ]
+        end
+      end
+
+      def muted?(recipient, notifiable)
+        return false unless notifiable
+
+        key = [
+          *identity_key(recipient),
+          notifiable.class.polymorphic_name,
+          notifiable.id
+        ]
+
+        mute_cache.fetch(key) do
+          mute_cache[key] =
+            RailsDen::NotificationMute.exists?(
+              recipient: recipient,
+              notifiable: notifiable
+            )
+        end
+      end
+
+      def materialize_for(candidates)
+        recipient, winning_event =
+          candidates.max_by do |_candidate_recipient, event|
+            EVENT_PRIORITIES.fetch(
+              event.event_type,
+              0
+            )
+          end
+
+        sibling_event_ids =
+          events.map(
+            &:id
+          )
+
+        existing =
+          Notification.where(
+            notification_event_id: sibling_event_ids,
+            recipient: recipient
+          )
+
+        notification =
+          existing.find_by(
+            notification_event: winning_event
+          ) ||
+          Notification.create_or_find_by!(
+            notification_event: winning_event,
+            recipient: recipient
+          )
+
+        existing
+          .where
+          .not(
+            id: notification.id
+          )
+          .destroy_all
+
+        notification
+      end
+
+      def same_identity?(first, second)
+        return false unless first && second
+
+        identity_key(first) ==
+          identity_key(second)
+      end
+
+      def identity_key(identity)
+        [
+          identity.class.polymorphic_name,
+          identity.id
+        ]
+      end
+    end
+  end
+end

data/app/services/rails_den/notifications/subscription_token.rb

@@ -0,0 +1,28 @@
+module RailsDen
+  module Notifications
+    class SubscriptionToken
+      PURPOSE = "rails_den_notifications"
+      EXPIRES_IN = 1.hour
+
+      class << self
+        def generate(recipient)
+          recipient
+            .to_sgid(
+              expires_in: EXPIRES_IN,
+              for: PURPOSE
+            )
+            .to_s
+        end
+
+        def resolve(token)
+          return if token.blank?
+
+          GlobalID::Locator.locate_signed(
+            token,
+            for: PURPOSE
+          )
+        end
+      end
+    end
+  end
+end

data/app/services/rails_den/permission_resolver.rb

@@ -0,0 +1,252 @@
+module RailsDen
+  class PermissionResolver
+    class << self
+      def allowed?(
+        user:,
+        capability:,
+        category: nil,
+        board: nil,
+        topic: nil
+      )
+        new(
+          user: user,
+          capability: capability,
+          category: category,
+          board: board,
+          topic: topic
+        ).allowed?
+      end
+
+      def eligible?(
+        user:,
+        category: nil,
+        board: nil,
+        topic: nil
+      )
+        new(
+          user: user,
+          capability: :view,
+          category: category,
+          board: board,
+          topic: topic
+        ).eligible?
+      end
+    end
+
+    def initialize(
+      user:,
+      capability:,
+      category: nil,
+      board: nil,
+      topic: nil
+    )
+      @user = user
+      @capability = capability.to_s
+      @topic = topic
+      @board = board || topic&.board
+      @category = category || @board&.category
+
+      if board && topic && topic.board_id != board.id
+        raise ArgumentError,
+              "topic must belong to the supplied board"
+      end
+
+      if category && @board && @board.category_id != category.id
+        raise ArgumentError,
+              "board must belong to the supplied category"
+      end
+
+      validate_capability!
+    end
+
+    def allowed?
+      return false unless eligible?
+
+      return true if effective_role_keys.include?(
+        "administrator"
+      )
+
+      effective_roles.any? do |role|
+        effective_permission_for(role) == true
+      end
+    end
+
+    def eligible?
+      return false if host_board_access_decision == false
+      return false unless category_role_requirements_satisfied?
+      return false unless board_role_requirements_satisfied?
+      return false unless topic_role_requirements_satisfied?
+
+      true
+    end
+
+    private
+
+    attr_reader :user,
+                :capability,
+                :category,
+                :board,
+                :topic
+
+    def effective_role_keys
+      @effective_role_keys ||=
+        [
+          *global_role_keys,
+          *board_role_keys
+        ].uniq
+    end
+
+    def global_role_keys
+      RailsDen::RoleResolver.call(
+        user: user
+      )
+    end
+
+    def board_role_keys
+      return [] unless board
+      return [] unless user
+
+      RailsDen::BoardRoleAssignment
+        .where(
+          board: board,
+          user: user
+        )
+        .joins(
+          :role
+        )
+        .order(
+          "rails_den_roles.position ASC",
+          "rails_den_roles.id ASC"
+        )
+        .pluck(
+          "rails_den_roles.key"
+        )
+    end
+
+    def effective_roles
+      @effective_roles ||=
+        RailsDen::Role
+          .where(
+            key: effective_role_keys
+          )
+          .order(
+            :position,
+            :id
+          )
+    end
+
+    def board_role_requirements_satisfied?
+      return true unless board
+
+      required_role_keys =
+        RailsDen::BoardRoleRequirement
+          .where(
+            board: board
+          )
+          .joins(
+            :role
+          )
+          .pluck(
+            "rails_den_roles.key"
+          )
+
+      return true if required_role_keys.empty?
+
+      required_role_keys.any? do |required_role_key|
+        effective_role_keys.include?(
+          required_role_key
+        )
+      end
+    end
+
+    def category_role_requirements_satisfied?
+      return true unless category
+
+      requirements_satisfied?(
+        RailsDen::CategoryRoleRequirement.where(
+          category: category
+        ),
+        role_keys: global_role_keys
+      )
+    end
+
+    def topic_role_requirements_satisfied?
+      return true unless topic
+
+      requirements_satisfied?(
+        RailsDen::TopicRoleRequirement.where(
+          topic: topic
+        )
+      )
+    end
+
+    def requirements_satisfied?(
+      requirements,
+      role_keys: effective_role_keys
+    )
+      required_role_keys =
+        requirements
+          .joins(:role)
+          .pluck("rails_den_roles.key")
+
+      required_role_keys.empty? ||
+        required_role_keys.any? do |required_role_key|
+          role_keys.include?(required_role_key)
+        end
+    end
+
+    def effective_permission_for(role)
+      if board
+        board_permission =
+          RailsDen::BoardRolePermission.find_by(
+            board: board,
+            role: role,
+            capability: capability
+          )
+
+        return board_permission.allowed unless board_permission.nil?
+      end
+
+      role_permission =
+        RailsDen::RolePermission.find_by(
+          role: role,
+          capability: capability
+        )
+
+      role_permission&.allowed
+    end
+
+    def host_board_access_decision
+      return nil unless board
+
+      callback =
+        RailsDen.configuration.can_access_board
+
+      return nil unless callback
+
+      decision =
+        callback.call(
+          user,
+          board
+        )
+
+      return decision if [
+        true,
+        false,
+        nil
+      ].include?(decision)
+
+      raise ArgumentError,
+            "RailsDen can_access_board callback must return true, false, or nil"
+    end
+
+    def validate_capability!
+      return if capability.in?(
+        RailsDen::RolePermission::CAPABILITIES
+      )
+
+      raise ArgumentError,
+            "Unknown RailsDen capability: #{capability.inspect}"
+    end
+  end
+end

data/app/services/rails_den/presence/board_summary.rb

@@ -0,0 +1,131 @@
+module RailsDen
+  module Presence
+    class BoardSummary
+      Summary =
+        Struct.new(
+          :visible,
+          :count,
+          keyword_init: true
+        ) do
+          def visible?
+            !!visible
+          end
+        end
+
+      class << self
+        def call(
+          board:,
+          viewer:,
+          now: Time.current
+        )
+          new(
+            board: board,
+            viewer: viewer,
+            now: now
+          ).call
+        end
+      end
+
+      def initialize(
+        board:,
+        viewer:,
+        now:
+      )
+        @board = board
+        @viewer = viewer
+        @now = now
+      end
+
+      def call
+        return hidden_summary unless RailsDen::Presence.enabled?
+
+        unless RailsDen::Presence::Visibility
+          .presence_surface_visible_to?(
+            viewer
+          )
+          return hidden_summary
+        end
+
+        identity_keys =
+          registry
+            .board_snapshots(
+              board: board,
+              now: now
+            )
+            .map do |snapshot|
+              [
+                snapshot.identity_type.to_s,
+                snapshot.identity_id.to_s
+              ]
+            end
+            .uniq
+
+        profiles =
+          profiles_by_identity_key(
+            identity_keys
+          )
+
+        visible_count =
+          identity_keys.count do |identity_key|
+            RailsDen::Presence::Visibility
+              .profile_allows_current_board?(
+                profiles[identity_key]
+              )
+          end
+
+        Summary.new(
+          visible: true,
+          count: visible_count
+        )
+      rescue Redis::BaseError,
+             RailsDen::Presence::ConfigurationError
+        hidden_summary
+      end
+
+      private
+
+      attr_reader :board,
+                  :viewer,
+                  :now
+
+      def registry
+        @registry ||=
+          RailsDen::Presence::Registry.new
+      end
+
+      def profiles_by_identity_key(identity_keys)
+        return {} if identity_keys.empty?
+
+        types =
+          identity_keys
+            .map(&:first)
+            .uniq
+
+        ids =
+          identity_keys
+            .map(&:last)
+            .uniq
+
+        RailsDen::MemberProfile
+          .where(
+            profile_owner_type: types,
+            profile_owner_id: ids
+          )
+          .to_a
+          .index_by do |profile|
+            [
+              profile.profile_owner_type.to_s,
+              profile.profile_owner_id.to_s
+            ]
+          end
+      end
+
+      def hidden_summary
+        Summary.new(
+          visible: false,
+          count: 0
+        )
+      end
+    end
+  end
+end