rails_den 2.0.0

data/app/services/rails_den/bookmark_list.rb

@@ -0,0 +1,109 @@
+module RailsDen
+  class BookmarkList
+    PER_PAGE = 25
+    Result = Data.define(:bookmarks, :page, :total_pages, :post_pages)
+
+    def self.call(bookmarker:, page:)
+      new(bookmarker: bookmarker, page: page).call
+    end
+
+    def self.page_for(bookmarker:, bookmark:)
+      new(bookmarker: bookmarker, page: 1).page_for(bookmark)
+    end
+
+    def initialize(bookmarker:, page:)
+      @bookmarker = bookmarker
+      @requested_page = page.to_i
+    end
+
+    def call
+      total_pages = [(readable_scope.count.to_f / PER_PAGE).ceil, 1].max
+      page = [[requested_page, 1].max, total_pages].min
+      bookmarks = readable_scope
+        .order(created_at: :desc, id: :desc)
+        .offset((page - 1) * PER_PAGE)
+        .limit(PER_PAGE)
+        .preload(:bookmarkable)
+        .to_a
+
+      preload_context(bookmarks)
+      Result.new(bookmarks:, page:, total_pages:, post_pages: post_pages_for(bookmarks))
+    end
+
+    def page_for(bookmark)
+      newer_count = readable_scope.where(
+        "rails_den_bookmarks.created_at > :created_at OR " \
+          "(rails_den_bookmarks.created_at = :created_at AND rails_den_bookmarks.id > :id)",
+        created_at: bookmark.created_at,
+        id: bookmark.id
+      ).count
+
+      newer_count / PER_PAGE + 1
+    end
+
+    private
+
+    attr_reader :bookmarker, :requested_page
+
+    def readable_scope
+      @readable_scope ||= begin
+        owner_scope = Bookmark.where(bookmarker: bookmarker)
+        readable = ReadableCommunityContent.new(viewer: bookmarker)
+        topics = owner_scope.where(bookmarkable_type: "RailsDen::Topic", bookmarkable_id: readable.topics.select(:id))
+        posts = owner_scope.where(bookmarkable_type: "RailsDen::Post", bookmarkable_id: readable.posts.select(:id))
+        topics.or(posts)
+      end
+    end
+
+    def preload_context(bookmarks)
+      targets = bookmarks.map(&:bookmarkable)
+      topics = targets.grep(Topic)
+      posts = targets.grep(Post)
+
+      ActiveRecord::Associations::Preloader.new(records: topics, associations: :board).call if topics.any?
+      ActiveRecord::Associations::Preloader.new(records: posts, associations: { topic: :board }).call if posts.any?
+      ActiveRecord::Associations::Preloader.new(records: posts, associations: :author).call if posts.any?
+    end
+
+    def post_pages_for(bookmarks)
+      post_ids = bookmarks.filter_map do |bookmark|
+        bookmark.bookmarkable_id if bookmark.bookmarkable_type == "RailsDen::Post"
+      end
+      return {} if post_ids.empty?
+
+      topic_ids = bookmarks.filter_map do |bookmark|
+        bookmark.bookmarkable.topic_id if bookmark.bookmarkable_type == "RailsDen::Post"
+      end.uniq
+
+      quoted_ids = post_ids.map { |id| Bookmark.connection.quote(id) }.join(", ")
+      quoted_topic_ids = topic_ids.map { |id| Bookmark.connection.quote(id) }.join(", ")
+      posts_per_page = Topic::POSTS_PER_PAGE
+      sql = <<~SQL.squish
+        SELECT ranked_posts.id,
+               ((ranked_posts.position - 1) / #{posts_per_page}) + 1 AS page
+        FROM (
+          SELECT rails_den_posts.id,
+                 ROW_NUMBER() OVER (
+                   PARTITION BY rails_den_posts.topic_id
+                   ORDER BY
+                     CASE
+                       WHEN rails_den_posts.id = rails_den_topics.opening_post_id THEN 0
+                       ELSE 1
+                     END,
+                     rails_den_posts.created_at,
+                     rails_den_posts.id
+                 ) AS position
+          FROM rails_den_posts
+          INNER JOIN rails_den_topics
+            ON rails_den_topics.id = rails_den_posts.topic_id
+          WHERE rails_den_posts.topic_id IN (#{quoted_topic_ids})
+        ) ranked_posts
+        WHERE ranked_posts.id IN (#{quoted_ids})
+      SQL
+
+      Bookmark.connection.select_rows(sql).to_h do |id, page|
+        [id.to_i, page.to_i]
+      end
+    end
+  end
+end

data/app/services/rails_den/bookmark_state.rb

@@ -0,0 +1,17 @@
+module RailsDen
+  class BookmarkState
+    Result = Data.define(:topic_bookmark, :post_bookmarks)
+
+    def self.call(bookmarker:, topic:, posts:)
+      return Result.new(topic_bookmark: nil, post_bookmarks: {}) unless bookmarker
+
+      topic_bookmark = Bookmark.find_by(bookmarker: bookmarker, bookmarkable: topic)
+      post_ids = Array(posts).map(&:id)
+      post_bookmarks = Bookmark
+        .where(bookmarker: bookmarker, bookmarkable_type: "RailsDen::Post", bookmarkable_id: post_ids)
+        .index_by(&:bookmarkable_id)
+
+      Result.new(topic_bookmark:, post_bookmarks:)
+    end
+  end
+end

data/app/services/rails_den/built_in_role_provisioner.rb

@@ -0,0 +1,98 @@
+module RailsDen
+  class BuiltInRoleProvisioner
+    ROLE_DEFINITIONS = [
+      {
+        name: "Guest",
+        key: "guest",
+        position: 0,
+        allowed_capabilities: %w[
+          view
+        ]
+      },
+      {
+        name: "Member",
+        key: "member",
+        position: 10,
+        allowed_capabilities: %w[
+          view
+          post
+          reply
+          upload
+          message
+        ]
+      },
+      {
+        name: "Moderator",
+        key: "moderator",
+        position: 20,
+        allowed_capabilities: %w[
+          view
+          post
+          reply
+          upload
+          message
+          moderate
+        ]
+      },
+      {
+        name: "Administrator",
+        key: "administrator",
+        position: 40,
+        allowed_capabilities: %w[
+          view
+          post
+          reply
+          upload
+          message
+          moderate
+        ]
+      }
+    ].freeze
+
+    class << self
+      def call
+        new.call
+      end
+    end
+
+    def call
+      ROLE_DEFINITIONS.each do |definition|
+        provision_role(definition)
+      end
+    end
+
+    private
+
+    def provision_role(definition)
+      role =
+        RailsDen::Role.find_or_initialize_by(
+          key: definition.fetch(:key)
+        )
+
+      role.assign_attributes(
+        name: definition.fetch(:name),
+        built_in: true,
+        position: definition.fetch(:position)
+      )
+
+      role.save!
+
+      RailsDen::RolePermission::CAPABILITIES.each do |capability|
+        permission =
+          RailsDen::RolePermission.find_or_initialize_by(
+            role: role,
+            capability: capability
+          )
+
+        permission.allowed =
+          capability.in?(
+            definition.fetch(
+              :allowed_capabilities
+            )
+          )
+
+        permission.save!
+      end
+    end
+  end
+end

data/app/services/rails_den/chat/broadcaster.rb

@@ -0,0 +1,81 @@
+module RailsDen
+  module Chat
+    class Broadcaster
+      class << self
+        def stream_for(channel)
+          "rails_den:chat:channel:#{channel.id}:v1"
+        end
+
+        def message_created!(message)
+          ActionCable.server.broadcast(
+            stream_for(
+              message.chat_channel
+            ),
+            {
+              type:
+                "chat_message_created",
+              message:
+                RailsDen::Chat::MessagePayload.call(
+                  message
+                )
+            }
+          )
+        end
+
+        def message_pinned!(message)
+          broadcast_message_event(
+            "chat_message_pinned",
+            message
+          )
+        end
+
+        def message_unpinned!(message)
+          broadcast_message_event(
+            "chat_message_unpinned",
+            message
+          )
+        end
+
+        def membership_removed!(
+          channel:
+        )
+          ActionCable.server.broadcast(
+            stream_for(channel),
+            {
+              type:
+                "chat_membership_removed"
+            }
+          )
+        end
+
+        def presence_changed!
+          ActionCable.server.broadcast(
+            RailsDen::Presence::Broadcaster
+              .community_stream,
+            {
+              type:
+                "presence_changed"
+            }
+          )
+        end
+
+        private
+
+        def broadcast_message_event(type, message)
+          ActionCable.server.broadcast(
+            stream_for(
+              message.chat_channel
+            ),
+            {
+              type: type,
+              message:
+                RailsDen::Chat::MessagePayload.call(
+                  message
+                )
+            }
+          )
+        end
+      end
+    end
+  end
+end

data/app/services/rails_den/chat/message_payload.rb

@@ -0,0 +1,26 @@
+module RailsDen
+  module Chat
+    class MessagePayload
+      class << self
+        def call(message)
+          {
+            id: message.id,
+            body: message.body,
+            author_name:
+              RailsDen.user_display_name(
+                message.author
+              ),
+            author_member_key:
+              RailsDen::Chat::SpatialSnapshot.member_key_for(
+                message.author
+              ),
+            created_at:
+              message.created_at.iso8601,
+            pinned:
+              message.pinned?
+          }
+        end
+      end
+    end
+  end
+end

data/app/services/rails_den/chat/presence_snapshot.rb

@@ -0,0 +1,269 @@
+module RailsDen
+  module Chat
+    class PresenceSnapshot
+      class << self
+        def call(
+          viewer:,
+          channels:,
+          now: Time.current
+        )
+          new(
+            viewer: viewer,
+            channels: channels,
+            now: now
+          ).call
+        end
+      end
+
+      def initialize(
+        viewer:,
+        channels:,
+        now:
+      )
+        @viewer = viewer
+        @channels =
+          Array(channels)
+        @now = now
+      end
+
+      def call
+        unless RailsDen::Presence.enabled?
+          return hidden_result
+        end
+
+        unless RailsDen::Presence::Visibility
+          .presence_surface_visible_to?(
+            viewer
+          )
+          return hidden_result
+        end
+
+        channel_ids =
+          channels
+            .map(&:id)
+            .to_set
+
+        snapshots =
+          RailsDen::Presence::ChatRoomRegistry
+            .new
+            .community_room_snapshots(
+              now: now
+            )
+            .select do |snapshot|
+              channel_ids.include?(
+                snapshot.chat_channel_id
+              )
+            end
+
+        keys =
+          snapshots
+            .map do |snapshot|
+              identity_key(
+                snapshot.identity_type,
+                snapshot.identity_id
+              )
+            end
+            .uniq
+
+        profiles =
+          profiles_by_identity_key(
+            keys
+          )
+
+        identities =
+          identities_by_key(
+            keys
+          )
+
+        snapshots_by_channel =
+          snapshots.group_by(
+            &:chat_channel_id
+          )
+
+        result = {}
+
+        channels.each do |channel|
+          channel_snapshots =
+            snapshots_by_channel.fetch(
+              channel.id,
+              []
+            )
+
+          member_keys =
+            channel_snapshots
+              .map do |snapshot|
+                identity_key(
+                  snapshot.identity_type,
+                  snapshot.identity_id
+                )
+              end
+              .uniq
+
+          members =
+            member_keys
+              .filter_map do |key|
+                identity =
+                  identities[key]
+
+                next unless identity
+
+                access =
+                  RailsDen::ChatChannelAccess.new(
+                    viewer: identity,
+                    channel: channel
+                  )
+
+                next unless access.readable?
+
+                profile =
+                  profiles[key]
+
+                unless RailsDen::Presence::Visibility
+                  .profile_allows_current_board?(
+                    profile
+                  )
+                  next
+                end
+
+                {
+                  display_name:
+                    RailsDen.user_display_name(
+                      identity
+                    ),
+                  mention_name:
+                    RailsDen
+                      .user_mention_name(
+                        identity
+                      )
+                      .to_s
+                }
+              end
+              .sort_by do |member|
+                member
+                  .fetch(
+                    :display_name
+                  )
+                  .downcase
+              end
+
+          result[
+            channel.slug
+          ] = {
+            count: members.length,
+            members: members
+          }
+        end
+
+        {
+          visible: true,
+          available: true,
+          channels: result
+        }
+      rescue Redis::BaseError,
+             RailsDen::Presence::ConfigurationError
+        unavailable_result
+      end
+
+      private
+
+      attr_reader :viewer,
+                  :channels,
+                  :now
+
+      def profiles_by_identity_key(keys)
+        return {} if keys.empty?
+
+        result = {}
+
+        keys
+          .group_by(&:first)
+          .each do |type, typed_keys|
+            ids =
+              typed_keys.map(&:last)
+
+            RailsDen::MemberProfile
+              .where(
+                profile_owner_type: type,
+                profile_owner_id: ids
+              )
+              .each do |profile|
+                result[
+                  identity_key(
+                    profile.profile_owner_type,
+                    profile.profile_owner_id
+                  )
+                ] = profile
+              end
+          end
+
+        result
+      end
+
+      def identities_by_key(keys)
+        result = {}
+
+        keys
+          .group_by(&:first)
+          .each do |type, typed_keys|
+            klass =
+              identity_class(
+                type
+              )
+
+            next unless klass
+
+            ids =
+              typed_keys.map(&:last)
+
+            klass
+              .where(
+                id: ids
+              )
+              .each do |identity|
+                result[
+                  identity_key(
+                    identity
+                      .class
+                      .polymorphic_name,
+                    identity.id
+                  )
+                ] = identity
+              end
+          end
+
+        result
+      end
+
+      def identity_class(type)
+        type
+          .to_s
+          .constantize
+      rescue NameError
+        nil
+      end
+
+      def identity_key(type, id)
+        [
+          type.to_s,
+          id.to_s
+        ]
+      end
+
+      def hidden_result
+        {
+          visible: false,
+          available: true,
+          channels: {}
+        }
+      end
+
+      def unavailable_result
+        {
+          visible: true,
+          available: false,
+          channels: {}
+        }
+      end
+    end
+  end
+end