chats 0.1.1 → 0.6.2

data/lib/chats/engine.rb

@@ -30,7 +30,7 @@ module Chats
     CHATS_LIB = File.expand_path("chats", LIB_ROOT)
 
     ZEITWERK_IGNORED = %w[
-      version.rb errors.rb configuration.rb engine.rb macros.rb
+      version.rb errors.rb configuration.rb engine.rb macros.rb subscribers.rb send_rate_limited.rb
     ].freeze
 
     initializer "chats.autoload", before: :set_autoload_paths do
@@ -64,6 +64,13 @@ module Chats
       end
     end
 
+    # Hand the gem's deprecator to the app, so `config.active_support.
+    # deprecation` (and `deprecators.silence`) govern chats' own deprecation
+    # warnings like any other framework's.
+    initializer "chats.deprecator" do |app|
+      app.deprecators[:chats] = Chats.deprecator if app.respond_to?(:deprecators)
+    end
+
     # Expose `acts_as_messager` / `acts_as_chat_subject` on every AR model.
     initializer "chats.active_record" do
       ActiveSupport.on_load(:active_record) do
@@ -71,11 +78,20 @@ module Chats
       end
     end
 
-    # Ship the gem's locale files (en, es). Host locale files with the same
-    # keys override these automatically (I18n's load order puts the app last).
-    initializer "chats.locales" do |app|
-      app.config.i18n.load_path += Dir[root.join("config", "locales", "**", "*.{rb,yml}").to_s]
-    end
+    # The gem's locale files (en, es) ship through Rails::Engine's own
+    # :add_locales initializer, which picks up every engine's config/locales
+    # automatically — and deliberately NOT through a manual
+    # `app.config.i18n.load_path +=` on top of it.
+    #
+    # That append is not merely redundant, it inverts the contract: railtie
+    # paths are unshifted ahead of everything in load_path, so an appended
+    # copy lands AFTER the host's own locales and silently overrides them. A
+    # host rewording `chats.flashes.blocked` in its own es.yml would keep
+    # reading ours, with no error and nothing to see.
+    #
+    # Gem first, host last. `clickwrap` carries the same note; `support_desk`
+    # shipped the bug and measured it (its file sat in load_path 14 times and
+    # the host's override lost).
 
     # NOTE: the host-facing helpers (`chat_button_to`, `chats_unread_badge`, …)
     # are exposed to ActionView from the BOTTOM of engine_helper.rb itself
@@ -90,7 +106,8 @@ module Chats
 
     # -------------------------------------------------------------------------
     # JavaScript: the engine ships tiny Stimulus controllers (thread, composer,
-    # debounced-submit) with NO build step, pinned for importmap-rails hosts.
+    # debounced-submit, refresh-inbox) with NO build step, pinned for
+    # importmap-rails hosts.
     #
     # The pin keys live under "controllers/chats/..." ON PURPOSE: the stock
     # Rails `app/javascript/controllers/index.js` calls
@@ -125,6 +142,11 @@ module Chats
       if app.config.respond_to?(:assets)
         app.config.assets.paths << root.join("app/javascript")
         app.config.assets.paths << root.join("app/assets/stylesheets")
+
+        # Propshaft serves anything on the load path; Sprockets serves only
+        # what is on the precompile list, so a Sprockets host 404s the
+        # stylesheet without this line.
+        app.config.assets.precompile << "chats.css" if app.config.assets.respond_to?(:precompile)
       end
     end
 

data/lib/chats/errors.rb

@@ -17,4 +17,20 @@ module Chats
   # Raised when the host `can_message` policy (or a feature flag like
   # `config.groups = false`) forbids the attempted action.
   class NotAllowedError < Error; end
+
+  # Raised when a conversation's SUBJECT has locked it (see
+  # Chats::ChatSubject#chat_locked?) and something tries to write to it
+  # anyway — send, edit, delete, react. A subclass of NotAllowedError on
+  # purpose: a host that already rescues NotAllowedError keeps working, and
+  # one that wants to show the lock notice specifically can rescue this.
+  # System messages are never refused: the app must always be able to say
+  # "this was closed" in the thread it just closed.
+  class LockedError < NotAllowedError
+    attr_reader :conversation
+
+    def initialize(message = nil, conversation: nil)
+      @conversation = conversation
+      super(message || conversation&.locked_notice || "this conversation is closed")
+    end
+  end
 end

data/lib/chats/inbox.rb

@@ -0,0 +1,363 @@
+# frozen_string_literal: true
+
+module Chats
+  # THE inbox query, in one object: load a viewer's recent conversations,
+  # optionally filter them, and fold the ones that belong to a stacked
+  # counterpart into Chats::InboxGroup rows.
+  #
+  #   Chats::Inbox.for(alice)                       # rows, newest activity first
+  #   Chats::Inbox.for(alice, query: "madrid")      # the search box
+  #   Chats::Inbox.for(alice, with: support_desk)   # one stack's contents
+  #   Chats::Inbox.for(alice, limit: 10)            # the messaging dock's recent list
+  #
+  # Rows are `Chats::Conversation | Chats::InboxGroup`, sorted by last
+  # activity descending. Grouping happens HERE and nowhere else, and so does
+  # the rule that a conversation with no messages is never listed.
+  #
+  # == Why `inbox_limit` bounds ROWS, not conversations
+  #
+  # A stacked counterpart can hold hundreds of threads. Limiting the raw
+  # conversation query first would let a busy support desk EVICT everything
+  # else from the inbox — 200 desk threads and not one message from a friend.
+  # So the two populations are queried separately: ordinary conversations get
+  # the limit, stacked ones get their own bounded window, and the limit is
+  # applied again to the ROWS that come out. A stack's numbers
+  # (`open_count`, `unread_count`) are then GLOBAL, read with two indexed
+  # aggregates per stack — never per conversation, and never by loading the
+  # stack to count it.
+  class Inbox
+    include Enumerable
+
+    attr_reader :viewer, :query, :with, :limit
+
+    class << self
+      # The inbox for +viewer+. Returns a Chats::Inbox, which enumerates its
+      # rows (`to_a` for a plain Array).
+      def for(viewer, query: nil, with: nil, limit: nil)
+        new(viewer, query: query, with: with, limit: limit)
+      end
+    end
+
+    # +limit+ is how many ROWS come back (`config.inbox_limit` by default).
+    # A smaller one is a smaller query, not a slice of the big one — except
+    # while searching, which still looks through the whole `inbox_limit`
+    # window (a match is no less a match for being the eleventh most
+    # recent conversation) and then returns at most +limit+ hits.
+    def initialize(viewer, query: nil, with: nil, limit: nil)
+      @viewer = viewer
+      @query = query.to_s.strip.presence
+      @with = with
+      @limit = Integer(limit || Chats.config.inbox_limit).clamp(1, Chats.config.inbox_limit)
+    end
+
+    # Conversation | InboxGroup rows, newest activity first, at most
+    # +limit+ of them.
+    def rows
+      @rows ||= build_rows
+    end
+
+    # Yield each row (Enumerable gives `map`, `select`, `find`, … from here).
+    def each(&)
+      rows.each(&)
+    end
+
+    # The rows as a plain Array.
+    def to_a
+      rows
+    end
+
+    # How many rows the inbox has.
+    def size
+      rows.size
+    end
+
+    # Whether the inbox has any rows at all.
+    def any?
+      rows.any?
+    end
+
+    # Whether the inbox has no rows.
+    def empty?
+      rows.empty?
+    end
+
+    # The conversations behind the rows, stacked threads included. Stays an
+    # ActiveRecord::Relation (already loaded) in the simple case — no search,
+    # nothing stacked — so an inbox ejected under 0.1.x can still chain
+    # `.where` or hand it to a paginator. Becomes an Array once rows had to
+    # be assembled in Ruby.
+    def conversations
+      rows
+      @flat
+    end
+
+    # { conversation_id => unread message count } — one grouped query for
+    # every loaded conversation, which is what the row badges read.
+    def unread_counts
+      @unread_counts ||= Chats::Conversation.unread_counts_for(viewer, conversations)
+    end
+
+    # Unread messages in one conversation, from the grouped query above.
+    def unread_count_for(conversation)
+      unread_counts.fetch(conversation.id, 0)
+    end
+
+    # The stack-aware badge number: how many inbox ROWS carry unread content
+    # (a stack of five unread threads is still one thing to deal with).
+    # `Messager#unread_chats_count` is the unstacked count and is unchanged.
+    def unread_count
+      rows.count do |row|
+        row.is_a?(Chats::InboxGroup) ? row.unread? : unread_count_for(row).positive?
+      end
+    end
+
+    # True when scoped to one counterpart (`?with=`): a stack's contents,
+    # which are listed individually rather than re-stacked.
+    def filtered?
+      with.present?
+    end
+
+    private
+
+    # How many conversations each leg of the query loads: the row limit, or
+    # the whole inbox window while a search filters it in Ruby.
+    def window
+      query ? Chats.config.inbox_limit : limit
+    end
+
+    # The viewer's own inbox relation (`Messager#chats`: `inbox_for` with
+    # `config.inbox_scope` applied, and whatever the host's model adds on
+    # top), memoized so it is built ONCE per inbox however many legs the
+    # row query is split into (the stack aggregates build their own).
+    #
+    # Only conversations with at least one message (Conversation.
+    # with_messages, system messages and tombstones included): one that was
+    # opened and never used is not listed — not as a row, not in a
+    # stack, not in search, not in the `?with=` view. It still OPENS, because
+    # authorization reads `viewer.chats`, not this.
+    def base_relation
+      @base_relation ||= listed(viewer.chats).includes(:last_message, :subject, participants: :messager)
+    end
+
+    # What a list may show of +relation+. The one place the rule lives, so
+    # the rows and the stack totals can never disagree about it.
+    def listed(relation)
+      relation.with_messages
+    end
+
+    # The polymorphic types worth splitting out. Empty when nothing stacks
+    # (an ordinary app pays nothing) and when the inbox is already filtered
+    # to one counterpart.
+    def grouped_types
+      @grouped_types ||= filtered? ? [] : Chats.grouped_messager_types
+    end
+
+    # Seats held by a stacked messager — never the viewer's own seat, so a
+    # stacked messager's OWN inbox stays flat.
+    def stacked_seats
+      Chats::Participant.select(:conversation_id)
+                        .where(messager_type: grouped_types)
+                        .where.not(messager_type: viewer.class.polymorphic_name, messager_id: viewer.id)
+    end
+
+    def load_conversations
+      if filtered?
+        @ungrouped_relation = filter_to_counterpart(base_relation).limit(window)
+        @stacked = []
+      elsif grouped_types.empty?
+        @ungrouped_relation = base_relation.limit(window)
+        @stacked = []
+      else
+        stacked = Chats::Conversation.direct.where(id: stacked_seats)
+        @ungrouped_relation = base_relation.where.not(id: stacked).limit(window)
+        recent = base_relation.direct.where(id: stacked_seats).except(:includes).select(:id).limit(window)
+        # Preserve the recent search window, plus the freshest conversation
+        # of each counterpart. A busy stack cannot consume another stack's
+        # row; at most twice the row limit is materialized.
+        candidates = base_relation.where(id: limited_ids(recent))
+                                  .or(base_relation.where(id: limited_ids(stack_representatives)))
+        @stacked = apply_search(candidates)
+      end
+
+      @ungrouped = apply_search(@ungrouped_relation)
+      # The relation itself when nothing had to be assembled in Ruby (it is
+      # loaded, so iterating it costs nothing extra); the flat Array otherwise.
+      @flat = @stacked.empty? && query.nil? ? @ungrouped_relation : @ungrouped + @stacked
+    end
+
+    # MySQL rejects LIMIT directly in an IN subquery. A derived table keeps
+    # the bounded selection in SQL and works on all three supported adapters.
+    def limited_ids(relation)
+      Chats::Conversation.from(relation, :limited_conversations).select(:id)
+    end
+
+    # ROW_NUMBER works on every supported adapter (PostgreSQL, SQLite and
+    # MySQL 8). Ranking in SQL avoids loading an entire busy desk's history.
+    def stack_representatives
+      activity = "COALESCE(chats_conversations.last_message_at, chats_conversations.created_at)"
+      ranking = "ROW_NUMBER() OVER (PARTITION BY stack_seats.messager_type, stack_seats.messager_id " \
+                "ORDER BY #{activity} DESC, chats_conversations.id DESC) AS stack_rank"
+      ranked = base_relation.direct.except(:includes, :order)
+                            .joins("INNER JOIN chats_participants stack_seats " \
+                                   "ON stack_seats.conversation_id = chats_conversations.id")
+                            .where(stack_seats: { messager_type: grouped_types })
+                            .where.not(stack_seats: { messager_type: viewer.class.polymorphic_name,
+                                                      messager_id: viewer.id })
+                            .select("chats_conversations.id, #{activity} AS activity_at", ranking)
+      Chats::Conversation.from(ranked, :ranked_stacks).where("stack_rank = 1")
+                         .order(Arel.sql("activity_at DESC, id DESC")).limit(window).select(:id)
+    end
+
+    # Only the direct threads shared with one counterpart. Direct only, by
+    # design: a group that happens to include the desk is not part of the
+    # desk's stack.
+    def filter_to_counterpart(relation)
+      seats = Chats::Participant.select(:conversation_id).where(
+        messager_type: with.class.polymorphic_name, messager_id: with.id
+      )
+      relation.direct.where(id: seats)
+    end
+
+    def build_rows
+      load_conversations
+      rows = @ungrouped.dup
+      stacks = {}
+
+      @stacked.each do |conversation|
+        counterpart = stacked_counterpart(conversation)
+        # The SQL prefilter matches by polymorphic type; an STI sibling that
+        # isn't actually grouped lands here and goes back to being a row.
+        next rows << conversation if counterpart.nil?
+
+        (stacks[Chats.messager_key(counterpart)] ||= [counterpart, []]).last << conversation
+      end
+
+      totals = stack_totals(stacks.each_value.map(&:first))
+      rows.concat(stacks.each_value.map { |messager, members| build_group(messager, members, totals) })
+      sort_rows(rows).first(limit)
+    end
+
+    # Newest activity first, exactly like the SQL the relation would have
+    # used (COALESCE(last_message_at, created_at) DESC), at full timestamp
+    # precision — `to_r`, not `to_f`, because two messages a microsecond
+    # apart must not collapse into a tie. Ties break on id, so the order is
+    # total and a row never shuffles between renders.
+    def sort_rows(rows)
+      rows.sort do |a, b|
+        by_activity = sort_key(b).to_r <=> sort_key(a).to_r
+        by_activity.zero? ? compare_ids(b, a) : by_activity
+      end
+    end
+
+    def build_group(messager, members, totals)
+      key = stack_key(messager.class.polymorphic_name, messager.id)
+
+      Chats::InboxGroup.new(
+        messager: messager,
+        conversations: sort_rows(members),
+        unread_count: totals[:unread].fetch(key, 0),
+        open_count: totals[:open].fetch(key, 0)
+      )
+    end
+
+    # What each stacked row says about its WHOLE stack, for every stack at
+    # once: two grouped aggregates, however many stacks the inbox shows and
+    # however deep each one runs — never per stack, never by loading one.
+    # Grouped by the counterpart's seat; the type and id lists may pair up
+    # a few seats that aren't stacks here, and those rows are simply never
+    # read back.
+    def stack_totals(messagers)
+      return { open: {}, unread: {} } if messagers.empty?
+
+      types = messagers.map { |messager| messager.class.polymorphic_name }.uniq
+      seats = listed(viewer.chats).reorder(nil).direct
+                                  .joins("INNER JOIN chats_participants stack_seats " \
+                                         "ON stack_seats.conversation_id = chats_conversations.id")
+                                  .where(stack_seats: { messager_type: types, messager_id: messagers.map(&:id) })
+                                  .group("stack_seats.messager_type", "stack_seats.messager_id")
+
+      {
+        open: keyed(seats.distinct.count("chats_conversations.id")),
+        unread: keyed(seats.unread_by(viewer).count("chats_messages.id"))
+      }
+    end
+
+    def keyed(counts)
+      counts.transform_keys { |(type, id)| stack_key(type, id) }
+    end
+
+    # uuid and bigint keys alike: the database may hand ids back as strings.
+    def stack_key(type, id)
+      [type, id.to_s]
+    end
+
+    # The other party of a DIRECT conversation, when their class asked to be
+    # stacked (`acts_as_messager inbox: :grouped`). Read from the preloaded
+    # participants — no extra query per row.
+    def stacked_counterpart(conversation)
+      return nil unless conversation.direct?
+
+      other = conversation.participants.find do |participant|
+        participant.messager.present? && participant.messager != viewer
+      end&.messager
+
+      other if Chats.grouped_inbox?(other)
+    end
+
+    def sort_key(row)
+      row.last_message_at || (row.respond_to?(:created_at) ? row.created_at : nil) || Chats::Conversation::EPOCH
+    end
+
+    # The total-order tiebreak: a conversation's own id, a stack's freshest
+    # conversation's id. Works for bigint and uuid keys alike, and never
+    # raises on a pair it can't compare — it just calls them equal.
+    def compare_ids(a, b)
+      left = tiebreak(a)
+      right = tiebreak(b)
+      return 0 if left.nil? || right.nil? || left.class != right.class
+
+      left <=> right
+    end
+
+    def tiebreak(row)
+      row.is_a?(Chats::InboxGroup) ? row.conversation&.id : row.id
+    end
+
+    # Partial, case-insensitive matching across the inbox metadata users can
+    # actually see: participant names, conversation titles, subject labels,
+    # and message bodies. Each leg is capped (config.inbox_limit), so
+    # metadata is filtered portably in Ruby from the already-preloaded
+    # objects while the potentially larger message-body set stays in SQL. No
+    # PostgreSQL-only full-text dependency is needed at this scale.
+    def apply_search(relation)
+      return relation.to_a unless Chats.config.search && query
+
+      loaded = relation.to_a
+      normalized_query = query.downcase
+      message_match_ids = conversations_matching_body(loaded)
+
+      loaded.select do |conversation|
+        message_match_ids.include?(conversation.id) ||
+          searchable_metadata(conversation).downcase.include?(normalized_query)
+      end
+    end
+
+    def conversations_matching_body(conversations)
+      return [] if Chats.config.encrypt_messages || conversations.empty?
+
+      pattern = "%#{Chats::Conversation.sanitize_sql_like(query.downcase)}%"
+      Chats::Message.where(conversation_id: conversations.map(&:id), deleted_at: nil)
+                    .where("LOWER(chats_messages.body) LIKE ?", pattern)
+                    .distinct
+                    .pluck(:conversation_id)
+    end
+
+    def searchable_metadata(conversation)
+      participant_names = conversation.participants.filter_map do |participant|
+        Chats.display_name_for(participant.messager) if participant.active?
+      end
+
+      [conversation.title, conversation.subject_label, *participant_names].compact.join(" ")
+    end
+  end
+end

data/lib/chats/inbox_group.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Chats
+  # A stack of direct conversations that share one counterpart, shown as a
+  # SINGLE inbox row. Built by Chats::Inbox for messagers declared with
+  # `acts_as_messager inbox: :grouped` — a support desk, a marketplace
+  # storefront, any seat a person ends up with many separate threads with.
+  #
+  # It quacks like the parts of Chats::Conversation the inbox row needs
+  # (+last_message+, +last_message_at+, +unread_count+) so the two row
+  # partials stay symmetrical.
+  #
+  # +unread_count+ and +open_count+ are GLOBAL: they describe the whole
+  # stack, however deep it runs, not the bounded window in +conversations+.
+  # Chats::Inbox reads them with two indexed aggregates per stack.
+  class InboxGroup
+    # +conversations+ is the loaded WINDOW of the stack (freshest first,
+    # bounded by config.inbox_limit); +open_count+ and +unread_count+ describe
+    # the whole stack, however deep it runs.
+    attr_reader :messager, :conversations, :unread_count, :open_count
+
+    def initialize(messager:, conversations:, unread_count: 0, open_count: nil)
+      @messager = messager
+      @conversations = conversations
+      @unread_count = unread_count
+      @open_count = open_count || conversations.size
+    end
+
+    # A stack of one is really just a conversation: the row links straight to
+    # it, and the thread carries a "see all" link back to the stack.
+    def single?
+      open_count == 1
+    end
+
+    # The freshest conversation in the stack — what the row previews, and
+    # what it links to when the stack holds exactly one.
+    def conversation
+      conversations.first
+    end
+
+    # The stack's most recent message (the row's preview line).
+    def last_message
+      conversation&.last_message
+    end
+
+    # The sort key the inbox orders rows by: the freshest activity in the
+    # stack (mirrors Conversation.recent_first's COALESCE).
+    def last_message_at
+      conversations.filter_map { |c| c.last_message_at || c.created_at }.max
+    end
+
+    # Whether the stack has anything unread in it, anywhere.
+    def unread?
+      unread_count.positive?
+    end
+
+    # What the row is called. A stack is named after its counterpart from
+    # every seat, so the viewer is accepted and ignored — the signature
+    # matches Chats::Conversation#title_for so both row partials can call it.
+    def title_for(_viewer)
+      Chats.display_name_for(messager)
+    end
+
+    # Stable DOM id for the row (no AR record to derive one from).
+    def dom_id
+      "chats_inbox_group_#{messager.class.polymorphic_name.underscore.tr("/", "_")}_#{messager.id}"
+    end
+
+    # The signed, purpose-scoped GlobalID that filters the inbox to this
+    # stack (`GET /conversations?with=…`).
+    def with_sgid
+      Chats.inbox_with_sgid(messager)
+    end
+  end
+end

data/lib/chats/inbox_refresh_job.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Chats
+  # One messager's inbox refresh (Chats::Broadcasts.refresh_inbox_of): at
+  # most one queued per messager, standing for every write that commits
+  # before it starts. A messager deleted before it ran has no inbox.
+  class InboxRefreshJob < ActiveJob::Base
+    discard_on ActiveJob::DeserializationError
+
+    def perform(messager)
+      Chats::Broadcasts.refresh_inbox_now(messager)
+    end
+  end
+end

data/lib/chats/macros.rb

@@ -17,8 +17,40 @@ module Chats
   # lives in Chats::Messager / Chats::ChatSubject so it's discoverable,
   # testable, and `include`-able directly when a host prefers that style.
   module Macros
-    def acts_as_messager
+    # Options (all optional; the defaults are 0.1.x behaviour):
+    #
+    #   notifications: false   this messager is never notifiable — a support
+    #                          desk, a bot, an org mailbox. `Participant#
+    #                          notifiable_for?` says no, so hosts stop
+    #                          branching on class in every notifier.
+    #   blockable: false       block/report affordances don't apply to it, so
+    #                          the bundled views hide them.
+    #   inbox: :grouped        every direct conversation with this messager
+    #                          stacks into ONE inbox row (see Chats::Inbox).
+    #   group_path: ->(viewer) { }  where that stacked row links to; defaults
+    #                          to the filtered inbox (`?with=<sgid>`).
+    #   verified: true         this messager is an OFFICIAL account — a support
+    #                          desk, an organization, a brand. The bundled views
+    #                          mark its name with the rosette everyone already
+    #                          reads as "verified". Strictly true/false: a badge
+    #                          is a trust claim, so a stray "false" string must
+    #                          raise rather than quietly verify.
+    #
+    #   class Desk < ApplicationRecord
+    #     acts_as_messager notifications: false, blockable: false, inbox: :grouped,
+    #                      verified: true
+    #   end
+    def acts_as_messager(notifications: true, blockable: true, inbox: :default, group_path: nil,
+                         verified: false)
       include Chats::Messager
+
+      self.chat_options = Chats::Messager.normalize_options(
+        notifications: notifications,
+        blockable: blockable,
+        inbox: inbox,
+        group_path: group_path,
+        verified: verified
+      )
     end
 
     def acts_as_chat_subject

data/lib/chats/models/concerns/chat_subject.rb

@@ -31,5 +31,28 @@ module Chats
     def chat_subject_label
       "#{self.class.model_name.human} #{id}"
     end
+
+    # Whether conversations ABOUT this record still accept messages. The
+    # subject already owns the conversation's meaning, so it owns its
+    # openness too — a closed ticket, a delivered order, an archived listing:
+    #
+    #   class Ticket < ApplicationRecord
+    #     acts_as_chat_subject
+    #     def chat_locked?       = closed?
+    #     def chat_locked_notice = "This ticket is closed. Reply to reopen it."
+    #   end
+    #
+    # System messages are exempt (the host can always post "Ticket closed"),
+    # and locking is a WRITE rule only: the thread stays readable. See
+    # Chats::Conversation#locked?.
+    def chat_locked?
+      false
+    end
+
+    # The sentence shown where the composer would be. Nil falls back to the
+    # gem's localized "This conversation is closed."
+    def chat_locked_notice
+      nil
+    end
   end
 end