rails_den 2.0.0

data/app/presenters/rails_den/member_profile_presenter.rb

@@ -0,0 +1,285 @@
+require "digest"
+
+module RailsDen
+  class MemberProfilePresenter
+    SIZES = %i[small medium large].freeze
+
+    attr_reader :profile,
+                :viewer,
+                :host_profile_path,
+                :recent_limit
+
+    def initialize(
+      profile:,
+      viewer:,
+      host_profile_path: nil,
+      recent_limit: 10
+    )
+      unless profile.is_a?(RailsDen::MemberProfile)
+        raise ArgumentError,
+              "profile must be a RailsDen::MemberProfile"
+      end
+
+      @profile = profile
+      @viewer = viewer
+      @host_profile_path = host_profile_path
+      @recent_limit = recent_limit.to_i.clamp(1, 25)
+    end
+
+    def owner
+      profile.profile_owner
+    end
+
+    def owner?
+      viewer == owner
+    end
+
+    def display_name
+      RailsDen.user_display_name(owner).to_s
+    end
+
+    def mention_name
+      RailsDen.user_mention_name(owner).to_s
+    end
+
+    def avatar_variant(size:)
+      return unless SIZES.include?(size.to_sym)
+      return unless avatar_attached?
+
+      profile.avatar.variant(size).processed
+    end
+
+    def avatar_attached?
+      MemberProfile.avatar_storage_available? &&
+        profile.avatar.attached?
+    end
+
+    def avatar_alt_text
+      "Avatar for #{display_name}"
+    end
+
+    def fallback_initial
+      display_name.scan(/\X/).first.presence
+    end
+
+    def bio_html
+      MemberProfileBioRenderer.call(
+        source: profile.bio
+      )
+    end
+
+    def topics_count
+      return profile.topics_count if profile.persisted?
+
+      public_readable_content
+        .topics
+        .where(author: owner)
+        .count
+    end
+
+    def posts_count
+      return profile.posts_count if profile.persisted?
+
+      public_readable_content
+        .posts
+        .where(author: owner)
+        .count
+    end
+
+    def custom_profile_field_values
+      return [] unless profile.persisted?
+
+      @custom_profile_field_values ||=
+        profile
+          .profile_field_values
+          .includes(:profile_field)
+          .select do |value_record|
+            profile_field =
+              value_record.profile_field
+
+            profile_field.enabled? &&
+              (
+                profile_field.field_type == "checkbox" ||
+                value_record.value.present?
+              )
+          end
+          .sort_by do |value_record|
+            [
+              value_record.profile_field.position,
+              value_record.profile_field.id
+            ]
+          end
+    end
+
+    def recent_topics
+      readable_content
+        .topics
+        .where(author: owner)
+        .includes(board: :category)
+        .order(created_at: :desc, id: :desc)
+        .limit(recent_limit)
+    end
+
+    def recent_posts
+      readable_content
+        .posts
+        .where(author: owner)
+        .includes(topic: { board: :category })
+        .order(created_at: :desc, id: :desc)
+        .limit(recent_limit)
+    end
+
+    def followed_content_visible?
+      viewer.present? &&
+        (owner? || !profile.hide_followed_content?)
+    end
+
+    def followed_boards
+      return Board.none unless followed_content_visible?
+
+      readable_content
+        .boards
+        .joins(:board_follows)
+        .where(
+          rails_den_board_follows: owner_query
+        )
+        .includes(:category)
+        .order(
+          "rails_den_board_follows.created_at DESC",
+          "rails_den_board_follows.id DESC"
+        )
+        .limit(recent_limit)
+    end
+
+    def followed_topics
+      return Topic.none unless followed_content_visible?
+
+      readable_content
+        .topics
+        .joins(:topic_follows)
+        .where(
+          rails_den_topic_follows: owner_query
+        )
+        .includes(board: :category)
+        .order(
+          "rails_den_topic_follows.created_at DESC",
+          "rails_den_topic_follows.id DESC"
+        )
+        .limit(recent_limit)
+    end
+
+    def followed_boards_count
+      return unless followed_content_visible?
+
+      followed_boards
+        .unscope(:limit, :order)
+        .count
+    end
+
+    def followed_topics_count
+      return unless followed_content_visible?
+
+      followed_topics
+        .unscope(:limit, :order)
+        .count
+    end
+
+    def presence_status
+      return @presence_status if defined?(@presence_status)
+
+      @presence_status =
+        calculate_presence_status
+    end
+
+    def presence_status_visible?
+      presence_status.present?
+    end
+
+    def presence_label
+      case presence_status
+      when :online
+        "Online"
+      when :away
+        "Away"
+      when :offline
+        "Offline"
+      end
+    end
+
+    def presence_last_seen_at
+      return unless presence_visibility.last_seen_visible?
+      return unless presence_status == :offline
+
+      profile.last_seen_at
+    end
+
+    def owner_identity_version_digest
+      Digest::SHA256.hexdigest(
+        [
+          owner.class.polymorphic_name,
+          owner.id,
+          display_name,
+          mention_name
+        ].join("\0")
+      )
+    end
+
+    private
+
+    def calculate_presence_status
+      return unless RailsDen::Presence.enabled?
+
+      unless presence_visibility.presence_surface_visible?
+        return
+      end
+
+      unless presence_visibility.presence_visible?
+        return :offline
+      end
+
+      presence_state&.status
+    end
+
+    def presence_state
+      return @presence_state if defined?(@presence_state)
+
+      @presence_state =
+        RailsDen::Presence::Registry.new.state(
+          identity: owner
+        )
+    rescue Redis::BaseError,
+           RailsDen::Presence::ConfigurationError
+      @presence_state = nil
+    end
+
+    def presence_visibility
+      @presence_visibility ||=
+        RailsDen::Presence::Visibility.new(
+          subject: owner,
+          viewer: viewer,
+          profile: profile
+        )
+    end
+
+    def readable_content
+      @readable_content ||=
+        ReadableCommunityContent.new(
+          viewer: viewer
+        )
+    end
+
+    def public_readable_content
+      @public_readable_content ||=
+        ReadableCommunityContent.new(
+          viewer: nil
+        )
+    end
+
+    def owner_query
+      {
+        follower_type: owner.class.polymorphic_name,
+        follower_id: owner.id
+      }
+    end
+  end
+end

data/app/queries/rails_den/topic_new_post_counts.rb

@@ -0,0 +1,153 @@
+module RailsDen
+  class TopicNewPostCounts
+    def self.call(topics:, reader:, since:)
+      new(
+        topics: topics,
+        reader: reader,
+        since: since
+      ).call
+    end
+
+    def initialize(topics:, reader:, since:)
+      @topics = topics
+      @reader = reader
+      @since = since
+    end
+
+    def call
+      topic_ids = Array(topics).map(&:id)
+
+      return {} if topic_ids.empty?
+
+      zero_counts = topic_ids.index_with(0)
+
+      return zero_counts if reader.nil? || since.nil?
+
+      counts =
+        Topic
+          .where(id: topic_ids)
+          .joins(read_states_join)
+          .joins(markers_join)
+          .joins(board_read_states_join)
+          .joins(board_markers_join)
+          .joins(community_read_states_join)
+          .joins(community_markers_join)
+          .joins(new_posts_join)
+          .group("rails_den_topics.id")
+          .count("new_posts.id")
+
+      zero_counts.merge(
+        counts.transform_values(&:to_i)
+      )
+    end
+
+    private
+
+    attr_reader :topics,
+                :reader,
+                :since
+
+    def read_states_join
+      Topic.sanitize_sql_array(
+        [
+          <<~SQL.squish,
+            LEFT JOIN rails_den_topic_read_states new_read_states
+              ON new_read_states.topic_id = rails_den_topics.id
+             AND new_read_states.reader_type = ?
+             AND new_read_states.reader_id = ?
+          SQL
+          reader.class.polymorphic_name,
+          reader.id
+        ]
+      )
+    end
+
+    def markers_join
+      <<~SQL.squish
+        LEFT JOIN rails_den_posts new_markers
+          ON new_markers.id = new_read_states.last_read_post_id
+      SQL
+    end
+
+    def new_posts_join
+      Topic.sanitize_sql_array(
+        [
+          <<~SQL.squish,
+            LEFT JOIN rails_den_posts new_posts
+              ON new_posts.topic_id = rails_den_topics.id
+             AND new_posts.deleted_at IS NULL
+             AND new_posts.created_at > ?
+             AND (
+                  new_read_states.id IS NULL
+                  OR new_posts.created_at > new_markers.created_at
+                  OR (
+                    new_posts.created_at = new_markers.created_at
+                    AND new_posts.id > new_markers.id
+                  )
+             )
+             AND (
+                  new_board_read_states.last_read_post_id IS NULL
+                  OR new_posts.created_at > new_board_markers.created_at
+                  OR (
+                    new_posts.created_at = new_board_markers.created_at
+                    AND new_posts.id > new_board_markers.id
+                  )
+             )
+             AND (
+                  new_community_read_states.last_read_post_id IS NULL
+                  OR new_posts.created_at > new_community_markers.created_at
+                  OR (
+                    new_posts.created_at = new_community_markers.created_at
+                    AND new_posts.id > new_community_markers.id
+                  )
+             )
+          SQL
+          since
+        ]
+      )
+    end
+
+    def board_read_states_join
+      Topic.sanitize_sql_array(
+        [
+          <<~SQL.squish,
+            LEFT JOIN rails_den_board_read_states new_board_read_states
+              ON new_board_read_states.board_id = rails_den_topics.board_id
+             AND new_board_read_states.reader_type = ?
+             AND new_board_read_states.reader_id = ?
+          SQL
+          reader.class.polymorphic_name,
+          reader.id
+        ]
+      )
+    end
+
+    def board_markers_join
+      <<~SQL.squish
+        LEFT JOIN rails_den_posts new_board_markers
+          ON new_board_markers.id = new_board_read_states.last_read_post_id
+      SQL
+    end
+
+    def community_read_states_join
+      Topic.sanitize_sql_array(
+        [
+          <<~SQL.squish,
+            LEFT JOIN rails_den_community_read_states new_community_read_states
+              ON new_community_read_states.reader_type = ?
+             AND new_community_read_states.reader_id = ?
+          SQL
+          reader.class.polymorphic_name,
+          reader.id
+        ]
+      )
+    end
+
+    def community_markers_join
+      <<~SQL.squish
+        LEFT JOIN rails_den_posts new_community_markers
+          ON new_community_markers.id = new_community_read_states.last_read_post_id
+      SQL
+    end
+  end
+end

data/app/queries/rails_den/topic_unread_counts.rb

@@ -0,0 +1,137 @@
+module RailsDen
+  class TopicUnreadCounts
+    def self.call(topics:, reader:)
+      new(topics: topics, reader: reader).call
+    end
+
+    def initialize(topics:, reader:)
+      @topics = topics
+      @reader = reader
+    end
+
+    def call
+      topic_ids = Array(topics).map(&:id)
+
+      return {} if reader.nil? || topic_ids.empty?
+
+      counts =
+        Topic
+          .where(id: topic_ids)
+          .joins(read_states_join)
+          .joins(markers_join)
+          .joins(board_read_states_join)
+          .joins(board_markers_join)
+          .joins(community_read_states_join)
+          .joins(community_markers_join)
+          .joins(unread_posts_join)
+          .group("rails_den_topics.id")
+          .count("unread_posts.id")
+
+      topic_ids.index_with(0).merge(
+        counts.transform_values(&:to_i)
+      )
+    end
+
+    private
+
+    attr_reader :topics,
+                :reader
+
+    def read_states_join
+      Topic.sanitize_sql_array(
+        [
+          <<~SQL.squish,
+            LEFT JOIN rails_den_topic_read_states read_states
+              ON read_states.topic_id = rails_den_topics.id
+             AND read_states.reader_type = ?
+             AND read_states.reader_id = ?
+          SQL
+          reader.class.polymorphic_name,
+          reader.id
+        ]
+      )
+    end
+
+    def markers_join
+      <<~SQL.squish
+        LEFT JOIN rails_den_posts markers
+          ON markers.id = read_states.last_read_post_id
+      SQL
+    end
+
+    def unread_posts_join
+      <<~SQL.squish
+        LEFT JOIN rails_den_posts unread_posts
+          ON unread_posts.topic_id = rails_den_topics.id
+         AND unread_posts.deleted_at IS NULL
+         AND (
+              read_states.id IS NULL
+              OR unread_posts.created_at > markers.created_at
+              OR (
+                unread_posts.created_at = markers.created_at
+                AND unread_posts.id > markers.id
+              )
+         )
+         AND (
+              board_read_states.last_read_post_id IS NULL
+              OR unread_posts.created_at > board_markers.created_at
+              OR (
+                unread_posts.created_at = board_markers.created_at
+                AND unread_posts.id > board_markers.id
+              )
+         )
+         AND (
+              community_read_states.last_read_post_id IS NULL
+              OR unread_posts.created_at > community_markers.created_at
+              OR (
+                unread_posts.created_at = community_markers.created_at
+                AND unread_posts.id > community_markers.id
+              )
+         )
+      SQL
+    end
+
+    def board_read_states_join
+      Topic.sanitize_sql_array(
+        [
+          <<~SQL.squish,
+            LEFT JOIN rails_den_board_read_states board_read_states
+              ON board_read_states.board_id = rails_den_topics.board_id
+             AND board_read_states.reader_type = ?
+             AND board_read_states.reader_id = ?
+          SQL
+          reader.class.polymorphic_name,
+          reader.id
+        ]
+      )
+    end
+
+    def board_markers_join
+      <<~SQL.squish
+        LEFT JOIN rails_den_posts board_markers
+          ON board_markers.id = board_read_states.last_read_post_id
+      SQL
+    end
+
+    def community_read_states_join
+      Topic.sanitize_sql_array(
+        [
+          <<~SQL.squish,
+            LEFT JOIN rails_den_community_read_states community_read_states
+              ON community_read_states.reader_type = ?
+             AND community_read_states.reader_id = ?
+          SQL
+          reader.class.polymorphic_name,
+          reader.id
+        ]
+      )
+    end
+
+    def community_markers_join
+      <<~SQL.squish
+        LEFT JOIN rails_den_posts community_markers
+          ON community_markers.id = community_read_states.last_read_post_id
+      SQL
+    end
+  end
+end

data/app/services/rails_den/board_following.rb

@@ -0,0 +1,91 @@
+module RailsDen
+  class BoardFollowing
+    Result = Data.define(
+      :board_follow,
+      :following,
+      :changed
+    )
+
+    def initialize(board:, follower:)
+      raise ArgumentError, "board is required" if board.nil?
+      raise ArgumentError, "follower is required" if follower.nil?
+
+      @board = board
+      @follower = follower
+    end
+
+    def follow
+      existing_follow = find_follow
+
+      if existing_follow
+        return result(
+          board_follow: existing_follow,
+          following: true,
+          changed: false
+        )
+      end
+
+      board_follow =
+        board
+          .board_follows
+          .create_or_find_by!(
+            follower: follower
+          )
+
+      result(
+        board_follow: board_follow,
+        following: true,
+        changed: board_follow.previously_new_record?
+      )
+    rescue ActiveRecord::RecordNotUnique
+      result(
+        board_follow: find_follow!,
+        following: true,
+        changed: false
+      )
+    end
+
+    def unfollow
+      board_follow = find_follow
+
+      unless board_follow
+        return result(
+          board_follow: nil,
+          following: false,
+          changed: false
+        )
+      end
+
+      BoardFollow.transaction do
+        board_follow.destroy!
+      end
+
+      result(
+        board_follow: nil,
+        following: false,
+        changed: true
+      )
+    end
+
+    private
+
+    attr_reader :board,
+                :follower
+
+    def find_follow
+      board.board_follows.find_by(
+        follower: follower
+      )
+    end
+
+    def find_follow!
+      board.board_follows.find_by!(
+        follower: follower
+      )
+    end
+
+    def result(**attributes)
+      Result.new(**attributes)
+    end
+  end
+end