rails_den 2.0.0

data/app/controllers/rails_den/chat_channels_controller.rb

@@ -0,0 +1,556 @@
+require "digest"
+require "openssl"
+
+module RailsDen
+  class ChatChannelsController < ApplicationController
+    SPATIAL_PALETTES = %w[
+      cyan-violet
+      emerald-cyan
+      amber-magenta
+      electric-blue
+      violet-emerald
+      magenta-cyan
+    ].freeze
+
+    before_action :find_channel,
+                  only: %i[
+                    show
+                    edit
+                    update
+                    destroy
+                  ]
+
+    before_action :require_channel_creation_permission!,
+                  only: %i[
+                    new
+                    create
+                  ]
+
+    before_action :require_channel_management_permission!,
+                  only: %i[
+                    edit
+                    update
+                    destroy
+                  ]
+
+    def index
+      @channels =
+        readable_channels
+
+      load_unread_counts
+
+      @can_create_channel =
+        can_create_channel?
+
+      @chat_presence =
+        RailsDen::Chat::PresenceSnapshot.call(
+          viewer:
+            current_rails_den_user,
+          channels:
+            @channels
+        )
+
+      @spatial_bootstrap =
+        build_spatial_bootstrap(
+          channel: nil
+        )
+    end
+
+    def show
+      access =
+        ChatChannelAccess.new(
+          viewer: current_rails_den_user,
+          channel: @channel
+        )
+
+      unless access.readable?
+        redirect_to chat_channels_path,
+                    alert:
+                      "That chat channel is unavailable."
+
+        return
+      end
+
+      @channels =
+        readable_channels
+
+      load_unread_counts
+
+      respond_to do |format|
+        format.html do
+          load_chat_page(
+            access
+          )
+        end
+
+        format.json do
+          render json:
+            RailsDen::Chat::PresenceSnapshot.call(
+              viewer:
+                current_rails_den_user,
+              channels:
+                @channels
+            )
+        end
+      end
+    end
+
+    def new
+      @channel =
+        ChatChannel.new(
+          visibility:
+            rails_den_administrator? ?
+              "public" :
+              "private"
+        )
+    end
+
+    def create
+      attributes =
+        channel_params.to_h
+
+      unless rails_den_administrator?
+        attributes["visibility"] =
+          "private"
+      end
+
+      @channel =
+        ChatChannel.new(
+          attributes
+        )
+
+      @channel.created_by =
+        current_rails_den_user
+
+      ChatChannel.transaction do
+        @channel.save!
+
+        @channel
+          .chat_channel_memberships
+          .create!(
+            member:
+              current_rails_den_user
+          )
+      end
+
+      redirect_to chat_channel_path(
+        @channel.slug
+      )
+    rescue ActiveRecord::RecordInvalid
+      render :new,
+             status: :unprocessable_entity
+    end
+
+    def edit
+    end
+
+    def update
+      attributes =
+        channel_params.to_h
+
+      unless rails_den_administrator?
+        attributes["visibility"] =
+          "private"
+      end
+
+      if @channel.update(
+        attributes
+      )
+        redirect_to chat_channel_path(
+          @channel.slug
+        )
+      else
+        render :edit,
+               status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @channel.destroy!
+
+      redirect_to chat_channels_path,
+                  status: :see_other,
+                  notice:
+                    "Chat channel deleted."
+    end
+
+    private
+
+    def find_channel
+      @channel =
+        ChatChannel.find_by(
+          slug: params[:slug]
+        )
+
+      return if @channel
+
+      redirect_to chat_channels_path,
+                  alert:
+                    "That chat channel is unavailable."
+    end
+
+    def readable_channels
+      ChatChannelAccess
+        .readable_scope(
+          viewer:
+            current_rails_den_user
+        )
+        .order(
+          :title,
+          :id
+        )
+        .to_a
+    end
+
+    def load_chat_page(access)
+      load_messages
+
+      @can_post =
+        access.postable?
+
+      @can_manage_channel =
+        access.manageable?
+
+      @can_create_channel =
+        can_create_channel?
+
+      @message =
+        @channel.chat_messages.build
+
+      @chat_channel_read_state =
+        ChatChannelReadState.find_by(
+          chat_channel:
+            @channel,
+          reader:
+            current_rails_den_user
+        )
+
+      @unread_count =
+        @unread_counts_by_channel_id.fetch(
+          @channel.id,
+          0
+        )
+
+      @first_unread_message_id =
+        @messages
+          .find do |message|
+            @chat_channel_read_state.nil? ||
+              !@chat_channel_read_state.read?(
+                message
+              )
+          end
+          &.id
+
+      @pinned_messages =
+        @channel
+          .chat_messages
+          .pinned
+          .includes(
+            :author
+          )
+          .order(
+            :created_at,
+            :id
+          )
+          .to_a
+
+      @membership =
+        @channel
+          .chat_channel_memberships
+          .find_by(
+            member:
+              current_rails_den_user
+          )
+
+      @memberships =
+        @channel
+          .chat_channel_memberships
+          .includes(:member)
+          .order(
+            :created_at,
+            :id
+          )
+
+      @chat_presence =
+        RailsDen::Chat::PresenceSnapshot.call(
+          viewer:
+            current_rails_den_user,
+          channels:
+            @channels
+        )
+
+      @spatial_bootstrap =
+        build_spatial_bootstrap(
+          channel: @channel
+        )
+    end
+
+    def load_messages
+      @messages =
+        @channel
+          .chat_messages
+          .includes(:author)
+          .order(
+            created_at: :desc,
+            id: :desc
+          )
+          .limit(50)
+          .to_a
+          .reverse
+    end
+
+    def load_unread_counts
+      @unread_counts_by_channel_id =
+        RailsDen::Chat::UnreadCounts.call(
+          channels:
+            @channels,
+          viewer:
+            current_rails_den_user
+        )
+    end
+
+    def build_spatial_bootstrap(channel:)
+      {
+        enabled:
+          RailsDen::Presence.enabled?,
+
+        community_name:
+          RailsDen.config.community_name,
+
+        subscription_token:
+          spatial_subscription_token,
+
+        session_id:
+          nil,
+
+        session_id_source:
+          "rails_den_presence",
+
+        self:
+          spatial_self_payload,
+
+        room:
+          spatial_room_payload(
+            channel
+          ),
+
+        channels:
+          @channels.map do |readable_channel|
+            spatial_channel_payload(
+              readable_channel
+            )
+          end
+      }
+    end
+
+    def spatial_subscription_token
+      identity =
+        current_rails_den_user
+
+      return unless identity
+
+      RailsDen::Chat::SubscriptionToken.generate(
+        identity
+      )
+    end
+
+    def spatial_room_payload(channel)
+      if channel
+        {
+          slug:
+            channel.slug,
+
+          snapshot:
+            spatial_room_snapshot(
+              channel
+            )
+        }
+      else
+        {
+          slug:
+            "atrium",
+
+          snapshot:
+            []
+        }
+      end
+    end
+
+    def spatial_self_payload
+      identity =
+        current_rails_den_user
+
+      return {} unless
+        identity&.respond_to?(:id) &&
+        identity.id.present?
+
+      seed =
+        spatial_identity_seed(
+          identity
+        )
+
+      {
+        display_name:
+          RailsDen.user_display_name(
+            identity
+          ),
+
+        member_key:
+          seed.first(24),
+
+        avatar_seed:
+          seed
+      }
+    end
+
+    def spatial_room_snapshot(channel)
+      return [] unless
+        RailsDen::Presence.enabled?
+
+      RailsDen::Chat::SpatialSnapshot.call(
+        channel:
+          channel,
+        viewer:
+          current_rails_den_user
+      )
+    end
+
+    def spatial_channel_payload(channel)
+      seed =
+        spatial_channel_seed(
+          channel
+        )
+
+      {
+        title:
+          channel.title,
+
+        slug:
+          channel.slug,
+
+        visibility:
+          channel.visibility,
+
+        url:
+          chat_channel_path(
+            channel.slug
+          ),
+
+        occupancy:
+          spatial_channel_occupancy(
+            channel
+          ),
+
+        visual_seed:
+          seed,
+
+        palette:
+          SPATIAL_PALETTES[
+            seed
+              .first(8)
+              .to_i(16) %
+              SPATIAL_PALETTES.length
+          ]
+      }
+    end
+
+    def spatial_channel_occupancy(channel)
+      spatial_occupancy
+        .fetch(
+          channel.slug,
+          0
+        )
+        .to_i
+    end
+
+    def spatial_occupancy
+      @spatial_occupancy ||=
+        RailsDen::Chat::SpatialOccupancySnapshot.call(
+          viewer:
+            current_rails_den_user
+        )
+    end
+
+    def spatial_identity_seed(identity)
+      OpenSSL::HMAC.hexdigest(
+        "SHA256",
+        spatial_identity_secret,
+        [
+          identity
+            .class
+            .polymorphic_name
+            .to_s,
+          identity.id.to_s
+        ].join("\0")
+      )
+    end
+
+    def spatial_identity_secret
+      @spatial_identity_secret ||=
+        Rails.application
+          .key_generator
+          .generate_key(
+            "rails_den_chat_spatial_identity_v1",
+            32
+          )
+    end
+
+    def spatial_channel_seed(channel)
+      Digest::SHA256.hexdigest(
+        [
+          "rails_den_chat_channel_v1",
+          channel.slug
+        ].join("\0")
+      )
+    end
+
+    def channel_params
+      params
+        .require(:chat_channel)
+        .permit(
+          :title,
+          :description,
+          :visibility
+        )
+    end
+
+    def can_create_channel?
+      PermissionResolver.allowed?(
+        user: current_rails_den_user,
+        capability: :message
+      ) &&
+        RestrictionResolver.can_participate?(
+          user: current_rails_den_user
+        )
+    end
+
+    def can_manage_channel?
+      return false unless @channel
+
+      ChatChannelAccess
+        .new(
+          viewer:
+            current_rails_den_user,
+          channel:
+            @channel
+        )
+        .manageable?
+    end
+
+    def require_channel_creation_permission!
+      return if can_create_channel?
+
+      redirect_to chat_channels_path,
+                  alert:
+                    "You cannot create chat channels."
+    end
+
+    def require_channel_management_permission!
+      return if can_manage_channel?
+
+      redirect_to chat_channels_path,
+                  alert:
+                    "That chat channel is unavailable."
+    end
+  end
+end

data/app/controllers/rails_den/chat_message_pins_controller.rb

@@ -0,0 +1,78 @@
+module RailsDen
+  class ChatMessagePinsController < ApplicationController
+    before_action :load_channel_and_access
+    before_action :load_message
+
+    def create
+      if @message.with_lock do
+           next false if @message.pinned?
+
+           @message.update!(
+             pinned: true
+           )
+         end
+        RailsDen::Chat::Broadcaster.message_pinned!(
+          @message
+        )
+      end
+
+      render_message
+    end
+
+    def destroy
+      if @message.with_lock do
+           next false unless @message.pinned?
+
+           @message.update!(
+             pinned: false
+           )
+         end
+        RailsDen::Chat::Broadcaster.message_unpinned!(
+          @message
+        )
+      end
+
+      render_message
+    end
+
+    private
+
+    def load_channel_and_access
+      @channel =
+        ChatChannel.find_by!(
+          slug: params[:chat_channel_slug]
+        )
+
+      access =
+        ChatChannelAccess.new(
+          viewer:
+            current_rails_den_user,
+          channel:
+            @channel
+        )
+
+      raise ActiveRecord::RecordNotFound unless access.readable?
+      head :forbidden unless access.manageable?
+    end
+
+    def load_message
+      return if performed?
+
+      @message =
+        @channel
+          .chat_messages
+          .find(
+            params[:message_id]
+          )
+    end
+
+    def render_message
+      render json: {
+        message:
+          RailsDen::Chat::MessagePayload.call(
+            @message
+          )
+      }
+    end
+  end
+end