rails_den 2.0.0

data/app/channels/rails_den/chat_spatial_channel.rb

@@ -0,0 +1,203 @@
+module RailsDen
+  class ChatSpatialChannel < ActionCable::Channel::Base
+    INITIAL_STATE = {
+      x: 0.0,
+      y: 1.0,
+      z: 0.0,
+      yaw: 0.0,
+      pitch: 0.0,
+      grounded: true,
+      moving: false,
+      sequence: 0
+    }.freeze
+
+    def subscribed
+      @spatial_identity =
+        RailsDen::Chat::SubscriptionToken.resolve(
+          params[:token]
+        )
+
+      unless @spatial_identity
+        reject
+        return
+      end
+
+      @spatial_room =
+        RailsDen::Chat::SpatialRoom.resolve(
+          slug: params[:slug],
+          viewer: @spatial_identity
+        )
+
+      unless @spatial_room
+        reject
+        return
+      end
+
+      @spatial_session_id =
+        params[:session_id]
+          .to_s
+          .strip
+
+      stream_from(
+        RailsDen::Chat::SpatialBroadcaster.room_stream(
+          @spatial_room
+        )
+      )
+
+      entered =
+        spatial_registry.enter(
+          room: @spatial_room,
+          identity: @spatial_identity,
+          session_id: @spatial_session_id,
+          state: INITIAL_STATE
+        )
+
+      stream_from(
+        RailsDen::Chat::SpatialBroadcaster.session_stream(
+          @spatial_room,
+          session_id: @spatial_session_id
+        )
+      )
+
+      transmit(
+        {
+          type: "spatial_snapshot",
+          members:
+            RailsDen::Chat::SpatialSnapshot.call(
+              room: @spatial_room,
+              viewer: @spatial_identity
+            )
+        }
+      )
+
+      member =
+        RailsDen::Chat::SpatialSnapshot.member_payload(
+          room: @spatial_room,
+          snapshot: entered
+        )
+
+      if member
+        RailsDen::Chat::SpatialBroadcaster.member_entered(
+          room: @spatial_room,
+          member: member
+        )
+      end
+
+      broadcast_occupancy_change
+    rescue ActiveRecord::RecordNotFound,
+           ArgumentError,
+           Redis::BaseError,
+           RailsDen::Presence::ConfigurationError
+      reject
+    end
+
+    def unsubscribed
+      return unless spatial_ready?
+
+      changed =
+        spatial_registry.leave(
+          room: @spatial_room,
+          identity: @spatial_identity,
+          session_id: @spatial_session_id
+        )
+
+      return unless changed
+
+      RailsDen::Chat::SpatialBroadcaster.member_left(
+        room: @spatial_room,
+        session_id: @spatial_session_id
+      )
+
+      broadcast_occupancy_change
+    rescue ArgumentError,
+           Redis::BaseError,
+           RailsDen::Presence::ConfigurationError
+      nil
+    end
+
+    def move(data)
+      return unless spatial_ready?
+
+      result =
+        RailsDen::Chat::SpatialUpdate.call(
+          room: @spatial_room,
+          identity: @spatial_identity,
+          session_id: @spatial_session_id,
+          payload: data
+        )
+
+      unless result.accepted?
+        transmit(
+          {
+            type: "spatial_move_rejected",
+            reason: result.reason.to_s
+          }
+        )
+
+        return
+      end
+
+      member =
+        RailsDen::Chat::SpatialSnapshot.member_payload(
+          room: @spatial_room,
+          snapshot: result.snapshot
+        )
+
+      return unless member
+
+      RailsDen::Chat::SpatialBroadcaster.member_moved(
+        room: @spatial_room,
+        member: member
+      )
+    rescue ArgumentError,
+           Redis::BaseError,
+           RailsDen::Presence::ConfigurationError
+      transmit(
+        {
+          type: "spatial_move_rejected",
+          reason: "unavailable"
+        }
+      )
+    end
+
+    def heartbeat(_data = nil)
+      return unless spatial_ready?
+
+      spatial_registry.refresh(
+        room: @spatial_room,
+        identity: @spatial_identity,
+        session_id: @spatial_session_id
+      )
+    rescue ArgumentError,
+           Redis::BaseError,
+           RailsDen::Presence::ConfigurationError
+      nil
+    end
+
+    private
+
+    def spatial_registry
+      @spatial_registry ||= RailsDen::Chat::SpatialRegistry.new
+    end
+
+    def spatial_ready?
+      @spatial_identity.present? &&
+        @spatial_room.present? &&
+        @spatial_session_id.present?
+    end
+
+    def broadcast_occupancy_change
+      return unless @spatial_room&.channel?
+
+      count =
+        spatial_registry
+          .room_snapshots(room: @spatial_room)
+          .length
+
+      RailsDen::Chat::SpatialBroadcaster.occupancy_changed(
+        channel: @spatial_room.channel,
+        count: count
+      )
+    end
+  end
+end

data/app/channels/rails_den/chat_spatial_occupancy_channel.rb

@@ -0,0 +1,69 @@
+module RailsDen
+  class ChatSpatialOccupancyChannel <
+    ActionCable::Channel::Base
+
+    def subscribed
+      @spatial_identity =
+        RailsDen::Chat::SubscriptionToken.resolve(
+          params[:token]
+        )
+
+      unless @spatial_identity
+        reject
+        return
+      end
+
+      @spatial_channels =
+        RailsDen::ChatChannelAccess
+          .readable_scope(
+            viewer:
+              @spatial_identity
+          )
+          .order(
+            :title,
+            :id
+          )
+          .to_a
+
+      @spatial_channels.each do |channel|
+        stream_from(
+          RailsDen::Chat::SpatialBroadcaster
+            .occupancy_stream(
+              channel
+            )
+        )
+      end
+
+      transmit_snapshot
+    rescue Redis::BaseError,
+           RailsDen::Presence::ConfigurationError
+      reject
+    end
+
+    def refresh(_data = nil)
+      return unless @spatial_identity
+
+      transmit_snapshot
+    rescue Redis::BaseError,
+           RailsDen::Presence::ConfigurationError
+      nil
+    end
+
+    private
+
+    def transmit_snapshot
+      transmit(
+        {
+          type:
+            "spatial_occupancy_snapshot",
+
+          channels:
+            RailsDen::Chat::SpatialOccupancySnapshot.call(
+              viewer:
+                @spatial_identity
+            )
+        }
+      )
+    end
+  end
+end

data/app/channels/rails_den/chat_stream_channel.rb

@@ -0,0 +1,108 @@
+module RailsDen
+  class ChatStreamChannel < ActionCable::Channel::Base
+    def subscribed
+      @chat_identity =
+        RailsDen::Chat::SubscriptionToken.resolve(
+          params[:token]
+        )
+
+      unless @chat_identity
+        reject
+        return
+      end
+
+      @chat_channel =
+        RailsDen::ChatChannel.find_by!(
+          slug: params[:slug]
+        )
+
+      access =
+        RailsDen::ChatChannelAccess.new(
+          viewer: @chat_identity,
+          channel: @chat_channel
+        )
+
+      unless access.readable?
+        reject
+        return
+      end
+
+      @presence_session_id =
+        params[:session_id]
+          .to_s
+          .strip
+
+      stream_from(
+        RailsDen::Chat::Broadcaster.stream_for(
+          @chat_channel
+        )
+      )
+
+      stream_from(
+        RailsDen::Presence::Broadcaster
+          .community_stream
+      )
+
+      enter_chat_room
+    rescue ActiveRecord::RecordNotFound
+      reject
+    end
+
+    def unsubscribed
+      leave_chat_room
+    end
+
+    private
+
+    def enter_chat_room
+      return unless RailsDen::Presence.enabled?
+      return if @presence_session_id.blank?
+
+      RailsDen::Presence::ChatRoomRegistry
+        .new
+        .enter(
+          identity: @chat_identity,
+          session_id: @presence_session_id,
+          chat_channel: @chat_channel
+        )
+
+      broadcast_presence_change
+    rescue ArgumentError,
+           Redis::BaseError,
+           RailsDen::Presence::ConfigurationError
+      nil
+    end
+
+    def leave_chat_room
+      return unless @chat_identity
+      return unless @chat_channel
+      return if @presence_session_id.blank?
+      return unless RailsDen::Presence.enabled?
+
+      changed =
+        RailsDen::Presence::ChatRoomRegistry
+          .new
+          .leave(
+            identity: @chat_identity,
+            session_id: @presence_session_id,
+            chat_channel: @chat_channel
+          )
+
+      broadcast_presence_change if changed
+    rescue ArgumentError,
+           Redis::BaseError,
+           RailsDen::Presence::ConfigurationError
+      nil
+    end
+
+    def broadcast_presence_change
+      ActionCable.server.broadcast(
+        RailsDen::Presence::Broadcaster
+          .community_stream,
+        {
+          type: "presence_changed"
+        }
+      )
+    end
+  end
+end

data/app/channels/rails_den/notifications_channel.rb

@@ -0,0 +1,30 @@
+module RailsDen
+  class NotificationsChannel < ActionCable::Channel::Base
+    def subscribed
+      recipient =
+        RailsDen::Notifications::SubscriptionToken.resolve(
+          params[:token]
+        )
+
+      unless recipient
+        reject
+        return
+      end
+
+      stream_from(
+        RailsDen::Notifications::Broadcaster.stream_name(
+          recipient
+        )
+      )
+
+      transmit(
+        {
+          unread_count:
+            RailsDen::Notifications::Broadcaster.unread_count(
+              recipient
+            )
+        }
+      )
+    end
+  end
+end

data/app/channels/rails_den/presence_channel.rb

@@ -0,0 +1,205 @@
+module RailsDen
+  class PresenceChannel < ActionCable::Channel::Base
+    def subscribed
+      @presence_identity =
+        RailsDen::Presence::SubscriptionToken.resolve(
+          params[:token]
+        )
+
+      unless @presence_identity
+        reject
+        return
+      end
+
+      @presence_session_id =
+        params[:session_id]
+          .to_s
+          .strip
+
+      if @presence_session_id.blank?
+        reject
+        return
+      end
+
+      stream_from(
+        RailsDen::Presence::Broadcaster.community_stream
+      )
+
+      registry.register(
+        identity: @presence_identity,
+        session_id: @presence_session_id,
+        board: initial_board
+      )
+
+      transmit_current_state
+
+      broadcast_presence_change(
+        force: true
+      )
+    rescue ArgumentError,
+           Redis::BaseError,
+           RailsDen::Presence::ConfigurationError
+      reject
+    end
+
+    def unsubscribed
+      return unless @presence_identity
+      return if @presence_session_id.blank?
+
+      registry.disconnect(
+        identity: @presence_identity,
+        session_id: @presence_session_id
+      )
+
+      broadcast_presence_change(
+        force: true
+      )
+    rescue Redis::BaseError,
+           RailsDen::Presence::ConfigurationError
+      nil
+    end
+
+    def heartbeat(_data = nil)
+      return unless presence_ready?
+
+      registry.heartbeat(
+        identity: @presence_identity,
+        session_id: @presence_session_id
+      )
+
+      transmit_current_state
+
+      broadcast_presence_change
+    rescue Redis::BaseError
+      transmit_presence_unavailable
+    end
+
+    def active(data)
+      return unless presence_ready?
+
+      board =
+        if data.key?("board_id")
+          resolve_optional_board(
+            data["board_id"]
+          )
+        else
+          :unchanged
+        end
+
+      registry.mark_active(
+        identity: @presence_identity,
+        session_id: @presence_session_id,
+        board: board
+      )
+
+      transmit_current_state
+
+      broadcast_presence_change(
+        force: true
+      )
+    rescue ActiveRecord::RecordNotFound,
+           Redis::BaseError
+      transmit_presence_unavailable
+    end
+
+    def location(data)
+      return unless presence_ready?
+
+      registry.mark_active(
+        identity: @presence_identity,
+        session_id: @presence_session_id,
+        board:
+          resolve_optional_board(
+            data["board_id"]
+          )
+      )
+
+      transmit_current_state
+
+      broadcast_presence_change(
+        force: true
+      )
+    rescue ActiveRecord::RecordNotFound,
+           Redis::BaseError
+      transmit_presence_unavailable
+    end
+
+    private
+
+    def registry
+      @registry ||=
+        RailsDen::Presence::Registry.new
+    end
+
+    def presence_ready?
+      @presence_identity.present? &&
+        @presence_session_id.present?
+    end
+
+    def initial_board
+      return if params[:board_id].blank?
+
+      resolve_board(
+        params[:board_id]
+      )
+    end
+
+    def resolve_optional_board(board_id)
+      return if board_id.blank?
+
+      resolve_board(
+        board_id
+      )
+    end
+
+    def resolve_board(board_id)
+      board =
+        RailsDen::Board.find(
+          board_id
+        )
+
+      readable =
+        RailsDen::ReadableCommunityContent.new(
+          viewer: @presence_identity
+        )
+
+      unless readable.board_readable?(
+        board
+      )
+        raise ActiveRecord::RecordNotFound
+      end
+
+      board
+    end
+
+    def transmit_current_state
+      state =
+        registry.state(
+          identity: @presence_identity
+        )
+
+      transmit(
+        {
+          available: true,
+          status: state.status,
+          session_count: state.session_count,
+          board_ids: state.board_ids
+        }
+      )
+    end
+
+    def transmit_presence_unavailable
+      transmit(
+        {
+          available: false
+        }
+      )
+    end
+
+    def broadcast_presence_change(force: false)
+      RailsDen::Presence::Broadcaster.broadcast_change!(
+        force: force
+      )
+    end
+  end
+end

data/app/controllers/admin/rails_den/administrators_controller.rb

@@ -0,0 +1,26 @@
+module Admin
+  module RailsDen
+    class AdministratorsController < ApplicationController
+      def destroy
+        administrator =
+          ::RailsDen::Administrator.find(
+            params[:id]
+          )
+
+        if ::RailsDen::Administrator.count <= 1
+          redirect_to admin_root_path,
+                      status: :see_other,
+                      alert: "RailsDen must have at least one administrator."
+
+          return
+        end
+
+        administrator.destroy!
+
+        redirect_to admin_root_path,
+                    status: :see_other,
+                    notice: "Administrator removed."
+      end
+    end
+  end
+end