rails_den 2.0.0

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

@@ -0,0 +1,28 @@
+module RailsDen
+  module Presence
+    class SubscriptionToken
+      PURPOSE = "rails_den_presence"
+      EXPIRES_IN = 1.hour
+
+      class << self
+        def generate(identity)
+          identity
+            .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/presence/visibility.rb

@@ -0,0 +1,95 @@
+module RailsDen
+  module Presence
+    class Visibility
+      class << self
+        def presence_surface_visible_to?(viewer)
+          case RailsDen.config.presence_visibility.to_sym
+          when :everyone
+            true
+          when :members_only
+            viewer.present?
+          when :disabled
+            false
+          else
+            false
+          end
+        end
+
+        def profile_allows_presence?(profile)
+          return true unless profile
+
+          profile.show_presence?
+        end
+
+        def profile_allows_current_board?(profile)
+          profile_allows_presence?(profile) &&
+            (
+              profile.nil? ||
+              profile.show_current_board?
+            )
+        end
+      end
+
+      def initialize(
+        subject:,
+        viewer:,
+        profile: nil
+      )
+        @subject = subject
+        @viewer = viewer
+        @profile =
+          profile ||
+          RailsDen::MemberProfile.find_by(
+            profile_owner: subject
+          )
+      end
+
+      def presence_surface_visible?
+        self.class.presence_surface_visible_to?(
+          viewer
+        )
+      end
+
+      def presence_visible?
+        return false unless presence_surface_visible?
+
+        self.class.profile_allows_presence?(
+          profile
+        )
+      end
+
+      def last_seen_visible?
+        presence_visible?
+      end
+
+      def current_board_visible?(board)
+        return false unless presence_visible?
+
+        unless self.class.profile_allows_current_board?(
+          profile
+        )
+          return false
+        end
+
+        return false unless board
+
+        readable_content.board_readable?(
+          board
+        )
+      end
+
+      private
+
+      attr_reader :subject,
+                  :viewer,
+                  :profile
+
+      def readable_content
+        @readable_content ||=
+          RailsDen::ReadableCommunityContent.new(
+            viewer: viewer
+          )
+      end
+    end
+  end
+end

data/app/services/rails_den/private_messages/mailbox.rb

@@ -0,0 +1,108 @@
+module RailsDen
+  module PrivateMessages
+    class Mailbox
+      PER_PAGE = 25
+      Entry = Data.define(:conversation, :counterpart, :latest_message, :unread_count) do
+        def unread?
+          unread_count.positive?
+        end
+      end
+      Result = Data.define(:entries, :page, :total_pages, :total_count)
+
+      class << self
+        def inbox(owner:, page:)
+          new(owner: owner, page: page, box: :inbox).call
+        end
+
+        def sent(owner:, page:)
+          new(owner: owner, page: page, box: :sent).call
+        end
+      end
+
+      def initialize(owner:, page:, box:)
+        @owner = owner
+        @page = [page.to_i, 1].max
+        @box = box
+      end
+
+      def call
+        relation = participant_relation
+        total_count = relation.count
+        total_pages = [(total_count.to_f / PER_PAGE).ceil, 1].max
+        page = [@page, total_pages].min
+        rows = relation.offset((page - 1) * PER_PAGE).limit(PER_PAGE).to_a
+        conversations = RailsDen::PrivateConversation
+          .where(id: rows.map(&:private_conversation_id))
+          .includes(private_conversation_participants: :participant)
+          .index_by(&:id)
+        latest = latest_messages(conversations.keys)
+        unread = unread_counts(conversations.keys)
+
+        entries = rows.filter_map do |row|
+          conversation = conversations[row.private_conversation_id]
+          next unless conversation
+          counterpart = conversation.private_conversation_participants
+            .map(&:participant)
+            .find { |identity| identity_key(identity) != identity_key(owner) }
+          Entry.new(
+            conversation: conversation,
+            counterpart: counterpart,
+            latest_message: latest[conversation.id],
+            unread_count: unread.fetch(conversation.id, 0)
+          )
+        end
+
+        Result.new(entries: entries, page: page, total_pages: total_pages, total_count: total_count)
+      end
+
+      private
+
+      attr_reader :owner, :box
+
+      def participant_relation
+        relation = RailsDen::PrivateConversationParticipant
+          .where(participant: owner, box == :inbox ? :inbox_hidden_at : :sent_hidden_at => nil)
+          .joins(:private_conversation)
+
+        conversation_ids = if box == :inbox
+          RailsDen::PrivateMessageRecipient.joins(:private_message).where(
+            rails_den_private_message_recipients: {
+              recipient_type: owner.class.polymorphic_name,
+              recipient_id: owner.id
+            }
+          ).select("rails_den_private_messages.private_conversation_id")
+        else
+          RailsDen::PrivateMessage.where(sender: owner).select(:private_conversation_id)
+        end
+
+        relation
+          .where(private_conversation_id: conversation_ids)
+          .order(Arel.sql("rails_den_private_conversations.last_message_at DESC, rails_den_private_conversations.id DESC"))
+      end
+
+      def latest_messages(conversation_ids)
+        latest_ids = RailsDen::PrivateMessage
+          .where(private_conversation_id: conversation_ids)
+          .group(:private_conversation_id)
+          .select("MAX(id)")
+
+        RailsDen::PrivateMessage
+          .where(id: latest_ids)
+          .includes(:sender)
+          .index_by(&:private_conversation_id)
+      end
+
+      def unread_counts(conversation_ids)
+        RailsDen::PrivateMessageRecipient
+          .joins(:private_message)
+          .where(recipient: owner, read_at: nil, rails_den_private_messages: { private_conversation_id: conversation_ids })
+          .group("rails_den_private_messages.private_conversation_id")
+          .count
+      end
+
+      def identity_key(identity)
+        [identity.class.polymorphic_name, identity.id]
+      end
+    end
+  end
+end

data/app/services/rails_den/private_messages/read_marker.rb

@@ -0,0 +1,25 @@
+module RailsDen
+  module PrivateMessages
+    class ReadMarker
+      def self.call(conversation:, reader:, at: Time.current)
+        participant = conversation.private_conversation_participants.find_by!(participant: reader)
+        message_ids = conversation.private_messages.select(:id)
+        updated = RailsDen::PrivateMessageRecipient
+          .where(private_message_id: message_ids, recipient: reader, read_at: nil)
+          .update_all(read_at: at, updated_at: at)
+
+        event_ids = RailsDen::NotificationEvent.where(
+          event_type: "private_message_received",
+          subject_type: RailsDen::PrivateMessage.polymorphic_name,
+          subject_id: message_ids
+        ).select(:id)
+        notifications_updated = RailsDen::Notification
+          .where(notification_event_id: event_ids, recipient: reader, read_at: nil)
+          .update_all(read_at: at, updated_at: at)
+        RailsDen::Notifications::Broadcaster.call(recipient: reader) if notifications_updated.positive?
+        participant
+        updated
+      end
+    end
+  end
+end

data/app/services/rails_den/private_messages/sender.rb

@@ -0,0 +1,113 @@
+module RailsDen
+  module PrivateMessages
+    class Sender
+      Result = Data.define(:conversation, :message, :errors) do
+        def success?
+          errors.empty?
+        end
+      end
+
+      class << self
+        def start(sender:, recipient_mention_name:, subject:, body:)
+          new(sender: sender).start(
+            recipient_mention_name: recipient_mention_name,
+            subject: subject,
+            body: body
+          )
+        end
+
+        def reply(sender:, conversation:, body:)
+          new(sender: sender).reply(conversation: conversation, body: body)
+        end
+      end
+
+      def initialize(sender:)
+        @sender = sender
+      end
+
+      def start(recipient_mention_name:, subject:, body:)
+        authorization_error = sending_error
+        return failure(authorization_error) if authorization_error
+
+        normalized_name = recipient_mention_name.to_s.strip.delete_prefix("@").downcase
+        recipient = RailsDen.resolve_user_mention(normalized_name)
+        return failure("That member could not be found.") unless recipient
+        return failure("That member could not be found.") unless RailsDen.user_mention_name(recipient) == normalized_name
+        return failure("You cannot message yourself.") if same_identity?(sender, recipient)
+        return failure("That member cannot receive private messages.") unless RailsDen::RestrictionResolver.can_access?(user: recipient)
+
+        conversation = nil
+        message = nil
+
+        RailsDen::PrivateConversation.transaction do
+          conversation = RailsDen::PrivateConversation.create!(
+            subject: subject,
+            created_by: sender,
+            last_message_at: Time.current
+          )
+          conversation.private_conversation_participants.create!(participant: sender)
+          conversation.private_conversation_participants.create!(participant: recipient)
+          message = conversation.private_messages.create!(sender: sender, body: body)
+          message.private_message_recipients.create!(recipient: recipient)
+          conversation.update!(last_message_at: message.created_at)
+        end
+
+        emit(message)
+        Result.new(conversation: conversation, message: message, errors: [])
+      rescue ActiveRecord::RecordInvalid => error
+        failure(*error.record.errors.full_messages)
+      end
+
+      def reply(conversation:, body:)
+        authorization_error = sending_error
+        return failure(authorization_error, conversation: conversation) if authorization_error
+
+        participants = conversation.private_conversation_participants.includes(:participant).to_a
+        sender_participant = participants.find { |row| same_identity?(row.participant, sender) }
+        return failure("Conversation not found.", conversation: conversation) unless sender_participant
+
+        others = participants.reject { |row| same_identity?(row.participant, sender) }
+        return failure("This conversation cannot be replied to.", conversation: conversation) unless others.one?
+
+        recipient_participant = others.sole
+        message = nil
+
+        RailsDen::PrivateConversation.transaction do
+          message = conversation.private_messages.create!(sender: sender, body: body)
+          message.private_message_recipients.create!(recipient: recipient_participant.participant)
+          sender_participant.update!(sent_hidden_at: nil)
+          recipient_participant.update!(inbox_hidden_at: nil)
+          conversation.update!(last_message_at: message.created_at)
+        end
+
+        emit(message)
+        Result.new(conversation: conversation, message: message, errors: [])
+      rescue ActiveRecord::RecordInvalid => error
+        failure(*error.record.errors.full_messages, conversation: conversation)
+      end
+
+      private
+
+      attr_reader :sender
+
+      def sending_error
+        return "Sender must be persisted." unless sender&.persisted?
+        return "You do not have permission to send private messages." unless RailsDen::PermissionResolver.allowed?(user: sender, capability: :message)
+        return "You cannot send private messages right now." unless RailsDen::RestrictionResolver.can_participate?(user: sender)
+      end
+
+      def emit(message)
+        RailsDen::NotificationEvents::Emitter.call(private_message: message)
+      end
+
+      def failure(*errors, conversation: nil)
+        Result.new(conversation: conversation, message: nil, errors: errors.flatten.compact)
+      end
+
+      def same_identity?(first, second)
+        first && second &&
+          [first.class.polymorphic_name, first.id] == [second.class.polymorphic_name, second.id]
+      end
+    end
+  end
+end

data/app/services/rails_den/private_messages/unread_count.rb

@@ -0,0 +1,22 @@
+module RailsDen
+  module PrivateMessages
+    class UnreadCount
+      def self.call(owner:)
+        visible_conversations = RailsDen::PrivateConversationParticipant
+          .where(participant: owner, inbox_hidden_at: nil)
+          .select(:private_conversation_id)
+
+        RailsDen::PrivateMessageRecipient
+          .joins(:private_message)
+          .where(
+            recipient: owner,
+            read_at: nil,
+            rails_den_private_messages: {
+              private_conversation_id: visible_conversations
+            }
+          )
+          .count
+      end
+    end
+  end
+end

data/app/services/rails_den/reaction_summary.rb

@@ -0,0 +1,54 @@
+module RailsDen
+  class ReactionSummary
+    Entry = Data.define(:reaction_type, :count, :viewer_reaction_id)
+
+    def self.call(posts:, viewer:)
+      new(posts: posts, viewer: viewer).call
+    end
+
+    def initialize(posts:, viewer:)
+      @posts = Array(posts)
+      @viewer = viewer
+    end
+
+    def call
+      result = post_ids.index_with { [] }
+      return result if post_ids.empty?
+
+      counts = Reaction.where(post_id: post_ids).group(:post_id, :reaction_type_id).count
+      viewer_reactions = reactions_for_viewer.index_by { |reaction| [reaction.post_id, reaction.reaction_type_id] }
+      types = ReactionType.where(id: counts.keys.map(&:last).uniq).index_by(&:id)
+
+      counts.each do |(post_id, reaction_type_id), count|
+        reaction_type = types[reaction_type_id]
+        next unless reaction_type
+
+        result[post_id] << Entry.new(
+          reaction_type: reaction_type,
+          count: count,
+          viewer_reaction_id: viewer_reactions[[post_id, reaction_type_id]]&.id
+        )
+      end
+
+      result.each_value do |entries|
+        entries.sort_by! { |entry| [entry.reaction_type.position, entry.reaction_type.id] }
+      end
+
+      result
+    end
+
+    private
+
+    attr_reader :posts, :viewer
+
+    def post_ids
+      @post_ids ||= posts.map(&:id).compact.uniq
+    end
+
+    def reactions_for_viewer
+      return Reaction.none unless viewer
+
+      Reaction.where(post_id: post_ids, reactor: viewer).select(:id, :post_id, :reaction_type_id)
+    end
+  end
+end

data/app/services/rails_den/reaction_type_importer.rb

@@ -0,0 +1,91 @@
+module RailsDen
+  class ReactionTypeImporter
+    Result = Data.define(:imported, :skipped, :failed, :errors)
+
+    COMMON = [
+      { name: "Like", key: "like", emoji: "👍" },
+      { name: "Love", key: "love", emoji: "❤️" },
+      { name: "Laugh", key: "laugh", emoji: "😂" },
+      { name: "Celebrate", key: "celebrate", emoji: "🎉" },
+      { name: "Wow", key: "wow", emoji: "😮" },
+      { name: "Sad", key: "sad", emoji: "😢" },
+      { name: "Thinking", key: "thinking", emoji: "🤔" },
+      { name: "Fire", key: "fire", emoji: "🔥" }
+    ].freeze
+
+    class << self
+      def common
+        import(COMMON)
+      end
+
+      def selected(ids)
+        import(
+          EmojiCatalog.resolve(ids).map do |entry|
+            {
+              name: entry.name,
+              key: entry.key,
+              emoji: entry.emoji
+            }
+          end
+        )
+      end
+
+      def all
+        import(
+          EmojiCatalog.entries.map do |entry|
+            {
+              name: entry.name,
+              key: entry.key,
+              emoji: entry.emoji
+            }
+          end
+        )
+      end
+
+      private
+
+      def import(candidates)
+        imported = 0
+        skipped = 0
+        errors = []
+
+        ReactionType.transaction do
+          existing = ReactionType.lock.to_a
+          existing_keys = existing.map(&:key).to_set
+          existing_emojis = existing.map(&:emoji).to_set
+          next_position = existing.map(&:position).compact.max.to_i + 1
+          rows = []
+
+          candidates.each do |candidate|
+            if existing_keys.include?(candidate.fetch(:key)) ||
+               existing_emojis.include?(candidate.fetch(:emoji))
+              skipped += 1
+              next
+            end
+
+            rows << candidate.merge(
+              position: next_position + rows.length,
+              enabled: true
+            )
+            existing_keys << candidate.fetch(:key)
+            existing_emojis << candidate.fetch(:emoji)
+          end
+
+          if rows.any?
+            ReactionType.insert_all!(rows, record_timestamps: true)
+            imported = rows.length
+          end
+        rescue ActiveRecord::ActiveRecordError => error
+          errors << error.message
+        end
+
+        Result.new(
+          imported: imported,
+          skipped: skipped,
+          failed: errors.any? ? candidates.length - skipped : 0,
+          errors: errors.freeze
+        )
+      end
+    end
+  end
+end

data/app/services/rails_den/reaction_type_search.rb

@@ -0,0 +1,34 @@
+module RailsDen
+  class ReactionTypeSearch
+    def self.call(query:, limit: 40, exclude_ids: [])
+      new(query: query, limit: limit, exclude_ids: exclude_ids).call
+    end
+
+    def initialize(query:, limit:, exclude_ids:)
+      @query = query.to_s.strip
+      @limit = limit
+      @exclude_ids = Array(exclude_ids)
+    end
+
+    def call
+      scope = ReactionType.enabled.where.not(id: exclude_ids).ordered
+      return scope.limit(limit).to_a if query.blank?
+
+      catalog_emojis = EmojiCatalog.search(query, limit: limit * 4).map(&:emoji)
+      pattern = "%#{ActiveRecord::Base.sanitize_sql_like(query.downcase)}%"
+
+      scope
+        .where(
+          "LOWER(name) LIKE :pattern OR LOWER(key) LIKE :pattern OR emoji IN (:emojis)",
+          pattern: pattern,
+          emojis: catalog_emojis.presence || [""]
+        )
+        .limit(limit)
+        .to_a
+    end
+
+    private
+
+    attr_reader :query, :limit, :exclude_ids
+  end
+end