rails_den 2.0.0

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

@@ -0,0 +1,499 @@
+module RailsDen
+  module Presence
+    class Directory
+      Entry = Struct.new(
+        :identity,
+        :profile,
+        :presenter,
+        :status,
+        :board,
+        :last_seen_at,
+        :last_activity_at,
+        keyword_init: true
+      )
+
+      Result = Struct.new(
+        :visible,
+        :available,
+        :live_entries,
+        :recent_entries,
+        keyword_init: true
+      ) do
+        def visible?
+          !!visible
+        end
+
+        def available?
+          !!available
+        end
+
+        def online_count
+          live_entries.count {
+            |entry|
+            entry.status == :online
+          }
+        end
+
+        def away_count
+          live_entries.count {
+            |entry|
+            entry.status == :away
+          }
+        end
+      end
+
+      class << self
+        def call(
+          viewer:,
+          now: Time.current
+        )
+          new(
+            viewer: viewer,
+            now: now
+          ).call
+        end
+      end
+
+      def initialize(
+        viewer:,
+        now:
+      )
+        @viewer = viewer
+        @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
+
+        snapshots =
+          registry.community_snapshots(
+            now: now
+          )
+
+        snapshots_by_identity =
+          snapshots.group_by do |snapshot|
+            identity_key(
+              snapshot.identity_type,
+              snapshot.identity_id
+            )
+          end
+
+        profiles =
+          profiles_by_identity_key(
+            snapshots_by_identity.keys
+          )
+
+        identities =
+          identities_by_key(
+            snapshots_by_identity.keys,
+            profiles
+          )
+
+        readable_boards =
+          readable_boards_for(
+            snapshots
+          )
+
+        live_entries =
+          build_live_entries(
+            snapshots_by_identity,
+            profiles,
+            identities,
+            readable_boards
+          )
+
+        live_keys =
+          live_entries
+            .map {
+              |entry|
+              identity_key_for(
+                entry.identity
+              )
+            }
+            .to_set
+
+        recent_entries =
+          build_recent_entries(
+            live_keys
+          )
+
+        Result.new(
+          visible: true,
+          available: true,
+          live_entries: live_entries,
+          recent_entries: recent_entries
+        )
+      rescue Redis::BaseError,
+             RailsDen::Presence::ConfigurationError
+        unavailable_result
+      end
+
+      private
+
+      attr_reader :viewer,
+                  :now
+
+      def registry
+        @registry ||=
+          RailsDen::Presence::Registry.new
+      end
+
+      def readable_content
+        @readable_content ||=
+          RailsDen::ReadableCommunityContent.new(
+            viewer: viewer
+          )
+      end
+
+      def build_live_entries(
+        snapshots_by_identity,
+        profiles,
+        identities,
+        readable_boards
+      )
+        entries =
+          snapshots_by_identity.filter_map do |key, snapshots|
+            identity =
+              identities[key]
+
+            next unless identity
+
+            profile =
+              profiles[key]
+
+            unless RailsDen::Presence::Visibility
+                     .profile_allows_presence?(
+                       profile
+                     )
+              next
+            end
+
+            latest_activity =
+              snapshots
+                .filter_map(
+                  &:last_activity_at
+                )
+                .max
+
+            status =
+              if latest_activity &&
+                 latest_activity >=
+                   now -
+                   RailsDen::Presence.away_after
+                :online
+              else
+                :away
+              end
+
+            board =
+              current_board_for(
+                snapshots,
+                profile,
+                readable_boards
+              )
+
+            Entry.new(
+              identity: identity,
+              profile: profile,
+              presenter:
+                presenter_for(
+                  identity,
+                  profile
+                ),
+              status: status,
+              board: board,
+              last_seen_at: nil,
+              last_activity_at:
+                latest_activity
+            )
+          end
+
+        entries.sort_by do |entry|
+          [
+            entry.status == :online ? 0 : 1,
+            -(
+              entry.last_activity_at&.to_f ||
+              0
+            ),
+            entry.presenter
+              .display_name
+              .downcase
+          ]
+        end
+      end
+
+      def build_recent_entries(
+        live_keys
+      )
+        cutoff =
+          now -
+          RailsDen::Presence.recently_active_window
+
+        RailsDen::MemberProfile
+          .where(
+            show_presence: true,
+            last_seen_at: cutoff..now
+          )
+          .includes(
+            :profile_owner
+          )
+          .order(
+            last_seen_at: :desc,
+            id: :desc
+          )
+          .filter_map do |profile|
+            identity =
+              profile.profile_owner
+
+            next unless identity
+
+            key =
+              identity_key_for(
+                identity
+              )
+
+            next if live_keys.include?(
+              key
+            )
+
+            unless RailsDen::Presence::Visibility
+                     .profile_allows_presence?(
+                       profile
+                     )
+              next
+            end
+
+            Entry.new(
+              identity: identity,
+              profile: profile,
+              presenter:
+                presenter_for(
+                  identity,
+                  profile
+                ),
+              status: :offline,
+              board: nil,
+              last_seen_at:
+                profile.last_seen_at,
+              last_activity_at: nil
+            )
+          rescue ActiveRecord::RecordNotFound
+            nil
+          end
+      end
+
+      def current_board_for(
+        snapshots,
+        profile,
+        readable_boards
+      )
+        unless RailsDen::Presence::Visibility
+                 .profile_allows_current_board?(
+                   profile
+                 )
+          return
+        end
+
+        snapshots
+          .select {
+            |snapshot|
+            snapshot.board_id.present?
+          }
+          .sort_by {
+            |snapshot|
+            -(
+              snapshot.last_activity_at&.to_f ||
+              0
+            )
+          }
+          .each do |snapshot|
+            board =
+              readable_boards[
+                snapshot.board_id.to_s
+              ]
+
+            return board if board
+          end
+
+        nil
+      end
+
+      def readable_boards_for(
+        snapshots
+      )
+        ids =
+          snapshots
+            .filter_map(
+              &:board_id
+            )
+            .map(&:to_s)
+            .uniq
+
+        return {} if ids.empty?
+
+        readable_content
+          .boards
+          .where(
+            id: ids
+          )
+          .index_by {
+            |board|
+            board.id.to_s
+          }
+      end
+
+      def profiles_by_identity_key(
+        keys
+      )
+        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
+              )
+              .includes(
+                :profile_owner
+              )
+              .each do |profile|
+                result[
+                  identity_key(
+                    profile.profile_owner_type,
+                    profile.profile_owner_id
+                  )
+                ] = profile
+              end
+          end
+
+        result
+      end
+
+      def identities_by_key(
+        keys,
+        profiles
+      )
+        result = {}
+
+        profiles.each do |key, profile|
+          identity =
+            profile.profile_owner
+
+          result[key] =
+            identity if identity
+        rescue ActiveRecord::RecordNotFound
+          nil
+        end
+
+        missing_keys =
+          keys.reject {
+            |key|
+            result.key?(
+              key
+            )
+          }
+
+        missing_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_for(
+                    identity
+                  )
+                ] = identity
+              end
+          end
+
+        result
+      end
+
+      def identity_class(type)
+        type.to_s.constantize
+      rescue NameError
+        nil
+      end
+
+      def presenter_for(
+        identity,
+        profile
+      )
+        RailsDen::MemberProfilePresenter.new(
+          profile:
+            profile ||
+            RailsDen::MemberProfile.new(
+              profile_owner: identity
+            ),
+          viewer: viewer,
+          host_profile_path:
+            RailsDen.user_mention_path(
+              identity
+            )
+        )
+      end
+
+      def identity_key_for(identity)
+        identity_key(
+          identity.class.polymorphic_name,
+          identity.id
+        )
+      end
+
+      def identity_key(
+        type,
+        id
+      )
+        [
+          type.to_s,
+          id.to_s
+        ]
+      end
+
+      def hidden_result
+        Result.new(
+          visible: false,
+          available: true,
+          live_entries: [],
+          recent_entries: []
+        )
+      end
+
+      def unavailable_result
+        Result.new(
+          visible: true,
+          available: false,
+          live_entries: [],
+          recent_entries: []
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module RailsDen
+  module Presence
+    class LastSeen
+      class << self
+        def record!(identity:, at: Time.current)
+          profile =
+            RailsDen::MemberProfile.for_presence!(
+              identity
+            )
+
+          return profile if profile.last_seen_at &&
+                            profile.last_seen_at >= at
+
+          profile.update!(
+            last_seen_at: at
+          )
+
+          profile
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,202 @@
+module RailsDen
+  module Presence
+    class PageMap
+      class << self
+        def call(
+          posts:,
+          viewer:,
+          now: Time.current
+        )
+          new(
+            posts: posts,
+            viewer: viewer,
+            now: now
+          ).tap(&:build!)
+        end
+      end
+
+      def initialize(
+        posts:,
+        viewer:,
+        now: Time.current
+      )
+        @posts =
+          Array(posts)
+
+        @viewer =
+          viewer
+
+        @now =
+          now
+
+        @statuses = {}
+      end
+
+      def build!
+        return self unless RailsDen::Presence.enabled?
+
+        identities =
+          unique_identities
+
+        return self if identities.empty?
+
+        profiles =
+          profiles_by_identity(
+            identities
+          )
+
+        snapshots =
+          RailsDen::Presence::Registry
+            .new
+            .community_snapshots(
+              now: now
+            )
+
+        snapshots_by_identity =
+          snapshots.group_by do |snapshot|
+            [
+              snapshot.identity_type.to_s,
+              snapshot.identity_id.to_s
+            ]
+          end
+
+        identities.each do |identity|
+          key =
+            identity_key(
+              identity
+            )
+
+          profile =
+            profiles[key] ||
+            RailsDen::MemberProfile.new(
+              profile_owner: identity,
+              show_presence: true,
+              show_current_board: true
+            )
+
+          visibility =
+            RailsDen::Presence::Visibility.new(
+              subject: identity,
+              viewer: viewer,
+              profile: profile
+            )
+
+          unless visibility.presence_surface_visible?
+            next
+          end
+
+          unless visibility.presence_visible?
+            statuses[key] =
+              :offline
+
+            next
+          end
+
+          statuses[key] =
+            status_from_snapshots(
+              snapshots_by_identity.fetch(
+                key,
+                []
+              )
+            )
+        end
+
+        self
+      rescue Redis::BaseError,
+             RailsDen::Presence::ConfigurationError
+        statuses.clear
+
+        self
+      end
+
+      def status_for(identity)
+        return unless identity
+
+        statuses[
+          identity_key(
+            identity
+          )
+        ]
+      end
+
+      private
+
+      attr_reader :posts,
+                  :viewer,
+                  :now,
+                  :statuses
+
+      def unique_identities
+        posts
+          .filter_map(&:author)
+          .index_by do |identity|
+            identity_key(
+              identity
+            )
+          end
+          .values
+      end
+
+      def profiles_by_identity(identities)
+        types =
+          identities.map do |identity|
+            identity
+              .class
+              .polymorphic_name
+              .to_s
+          end.uniq
+
+        ids =
+          identities.map do |identity|
+            identity.id
+          end.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 status_from_snapshots(snapshots)
+        return :offline if snapshots.empty?
+
+        last_activity_at =
+          snapshots
+            .filter_map(
+              &:last_activity_at
+            )
+            .max
+
+        return :away unless last_activity_at
+
+        cutoff =
+          now -
+            RailsDen::Presence.away_after
+
+        if last_activity_at >= cutoff
+          :online
+        else
+          :away
+        end
+      end
+
+      def identity_key(identity)
+        [
+          identity
+            .class
+            .polymorphic_name
+            .to_s,
+          identity.id.to_s
+        ]
+      end
+    end
+  end
+end