Merge pull request #169 from dapi/feature/157-ui-manager-chat

feat(chat): UI для отправки сообщений менеджером

Author: dapi

app/controllers/tenants/chats_controller.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 module Tenants
-  # Контроллер для просмотра чатов tenant'а
+  # Контроллер для просмотра и управления чатами tenant'а
   #
   # Показывает список чатов с пагинацией и сортировкой,
-  # а также историю переписки выбранного чата.
+  # историю переписки выбранного чата, а также позволяет
+  # менеджерам перехватывать диалоги и отправлять сообщения.
   class ChatsController < ApplicationController
+    include ErrorLogger
+
     PER_PAGE = 20
 
     # GET /chats
@@ -22,6 +25,59 @@ def show
       @chat = load_chat_with_messages(params[:id])
     end
 
+    # POST /chats/:id/takeover
+    # Перехват диалога менеджером
+    def takeover
+      @chat = find_chat
+      ChatTakeoverService.new(@chat).takeover!(current_user)
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html { redirect_to tenant_chat_path(@chat), notice: t('.success') }
+      end
+    rescue ChatTakeoverService::AlreadyTakenError => e
+      respond_with_error(t('.already_taken'))
+    rescue ChatTakeoverService::UnauthorizedError => e
+      respond_with_error(t('.unauthorized'))
+    end
+
+    # POST /chats/:id/release
+    # Возврат диалога боту
+    def release
+      @chat = find_chat
+      ChatTakeoverService.new(@chat).release!(user: current_user)
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html { redirect_to tenant_chat_path(@chat), notice: t('.success') }
+      end
+    rescue ChatTakeoverService::NotTakenError => e
+      respond_with_error(t('.not_taken'))
+    rescue ChatTakeoverService::UnauthorizedError => e
+      respond_with_error(t('.unauthorized'))
+    end
+
+    # POST /chats/:id/send_message
+    # Отправка сообщения менеджером
+    def send_message
+      @chat = find_chat
+
+      return respond_with_error(t('.empty_message')) if params[:text].blank?
+
+      @message = ManagerMessageService.new(@chat).send!(current_user, params[:text])
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html { redirect_to tenant_chat_path(@chat) }
+      end
+    rescue ManagerMessageService::NotInManagerModeError => e
+      respond_with_error(t('.not_in_manager_mode'))
+    rescue ManagerMessageService::NotTakenByUserError => e
+      respond_with_error(t('.not_taken_by_user'))
+    rescue ManagerMessageService::RateLimitExceededError => e
+      respond_with_error(t('.rate_limit_exceeded'))
+    end
+
     private
 
     # Загружает чат со всеми сообщениями (с лимитом для производительности)
@@ -35,9 +91,10 @@ def load_chat_with_messages(chat_id)
 
       # Загружаем сообщения с лимитом для производительности
       # (200 сообщений ≈ 120KB HTML, 2000 DOM nodes)
+      # Используем id как tiebreaker при одинаковом created_at
       messages = chat.messages
                      .includes(:tool_calls)
-                     .order(created_at: :desc)
+                     .order(created_at: :desc, id: :desc)
                      .limit(ApplicationConfig.max_chat_messages_display)
                      .reverse
 
@@ -63,11 +120,12 @@ def fetch_chats
     def preload_last_messages(chats)
       return if chats.empty?
 
-      # Get last message for each chat in single query using window function
+      # Get last message for each chat in single query using DISTINCT ON
+      # Order by id DESC as tiebreaker when created_at is the same
       last_messages = Message
         .where(chat_id: chats.map(&:id))
         .select('DISTINCT ON (chat_id) *')
-        .order('chat_id, created_at DESC')
+        .order('chat_id, created_at DESC, id DESC')
         .index_by(&:chat_id)
 
       # Assign to association cache
@@ -79,5 +137,27 @@ def preload_last_messages(chats)
     def sort_column
       %w[last_message_at created_at].include?(params[:sort]) ? params[:sort] : 'last_message_at'
     end
+
+    # Находит чат для takeover/release/send_message actions
+    def find_chat
+      current_tenant.chats
+                    .with_client_details
+                    .includes(messages: :tool_calls)
+                    .find(params[:id])
+    end
+
+    # Отвечает с ошибкой
+    def respond_with_error(message)
+      respond_to do |format|
+        format.turbo_stream do
+          render turbo_stream: turbo_stream.replace(
+            'flash',
+            partial: 'tenants/shared/flash',
+            locals: { message: message, type: :error }
+          )
+        end
+        format.html { redirect_to tenant_chat_path(@chat), alert: message }
+      end
+    end
   end
 end

app/javascript/controllers/chat_message_form_controller.js

@@ -0,0 +1,36 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Handles chat message form submission and input clearing
+// Submits form on Enter key and clears input after successful submission
+export default class extends Controller {
+  static targets = ["input"]
+
+  connect() {
+    // Listen for turbo:submit-end to clear input after successful submission
+    this.element.addEventListener("turbo:submit-end", this.handleSubmitEnd.bind(this))
+  }
+
+  disconnect() {
+    this.element.removeEventListener("turbo:submit-end", this.handleSubmitEnd.bind(this))
+  }
+
+  // Submit form (called on Enter keypress via data-action)
+  submit(event) {
+    // Only submit on Enter without Shift (allow Shift+Enter for newlines in future textarea)
+    if (event.shiftKey) return
+
+    event.preventDefault()
+    this.element.requestSubmit()
+  }
+
+  // Clear input after successful form submission
+  handleSubmitEnd(event) {
+    if (event.detail.success) {
+      const input = this.element.querySelector("input[name='text']")
+      if (input) {
+        input.value = ""
+        input.focus()
+      }
+    }
+  }
+}

app/javascript/controllers/countdown_controller.js

@@ -0,0 +1,57 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Displays a countdown timer that updates every second
+// Used for showing remaining takeover timeout in chat status
+//
+// Usage:
+//   <span data-controller="countdown" data-countdown-seconds-value="1800">
+//     (30м)
+//   </span>
+export default class extends Controller {
+  static values = {
+    seconds: Number
+  }
+
+  connect() {
+    this.remainingSeconds = this.secondsValue
+    this.updateDisplay()
+    this.startTimer()
+  }
+
+  disconnect() {
+    this.stopTimer()
+  }
+
+  startTimer() {
+    this.intervalId = setInterval(() => {
+      this.remainingSeconds -= 1
+
+      if (this.remainingSeconds <= 0) {
+        this.stopTimer()
+        // Timer expired - page will be updated via Turbo Stream from server
+        this.element.textContent = "(0м)"
+        return
+      }
+
+      this.updateDisplay()
+    }, 1000)
+  }
+
+  stopTimer() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId)
+      this.intervalId = null
+    }
+  }
+
+  updateDisplay() {
+    const minutes = Math.floor(this.remainingSeconds / 60)
+    const seconds = this.remainingSeconds % 60
+
+    if (minutes > 0) {
+      this.element.textContent = `(${minutes}м ${seconds}с)`
+    } else {
+      this.element.textContent = `(${seconds}с)`
+    }
+  }
+}

app/jobs/chat_takeover_timeout_job.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Автоматически возвращает диалог боту после таймаута
+#
+# Выполняется через заданное время после takeover.
+# Проверяет что это та же сессия takeover (через taken_at timestamp).
+#
+# @example Использование
+#   ChatTakeoverTimeoutJob.set(wait: 30.minutes).perform_later(chat.id, chat.taken_at.to_i)
+#
+# @see ChatTakeoverService для логики takeover/release
+# @author Danil Pismenny
+# @since 0.1.0
+class ChatTakeoverTimeoutJob < ApplicationJob
+  include ErrorLogger
+
+  queue_as :default
+
+  # Retry с экспоненциальной задержкой для временных ошибок
+  # SolidQueue не поддерживает символы, используем lambda
+  retry_on StandardError,
+           wait: ->(executions) { (executions**2) + 2 },
+           attempts: 3
+
+  # Не ретраить при отсутствии записи
+  discard_on ActiveRecord::RecordNotFound
+
+  # @param chat_id [Integer] ID чата
+  # @param taken_at_timestamp [Integer] Unix timestamp времени takeover
+  def perform(chat_id, taken_at_timestamp)
+    chat = Chat.find_by(id: chat_id)
+
+    unless chat
+      Rails.logger.info "[ChatTakeoverTimeoutJob] Chat #{chat_id} not found, skipping"
+      return
+    end
+
+    unless chat.manager_mode?
+      Rails.logger.info "[ChatTakeoverTimeoutJob] Chat #{chat_id} not in manager_mode, skipping"
+      return
+    end
+
+    # Проверяем что это та же сессия takeover
+    # (не новая, начавшаяся после планирования этого job)
+    unless chat.taken_at&.to_i == taken_at_timestamp
+      Rails.logger.info "[ChatTakeoverTimeoutJob] Chat #{chat_id} has newer takeover session, skipping"
+      return
+    end
+
+    ChatTakeoverService.new(chat).release!(timeout: true)
+    Rails.logger.info "[ChatTakeoverTimeoutJob] Chat #{chat_id} released due to timeout"
+  rescue StandardError => e
+    log_error(e, context: { chat_id: chat_id, taken_at_timestamp: taken_at_timestamp })
+    raise # Re-raise для retry механизма
+  end
+end

app/models/chat.rb

@@ -27,13 +27,40 @@ class Chat < ApplicationRecord
   belongs_to :tenant, counter_cache: true
   belongs_to :client
   belongs_to :chat_topic, optional: true
+  belongs_to :taken_by, class_name: 'User', optional: true
 
   has_one :telegram_user, through: :client
 
   has_many :bookings, dependent: :destroy
 
   acts_as_chat
 
+  # Takeover support
+  # mode: ai_mode (по умолчанию) - бот отвечает автоматически
+  # mode: manager_mode - менеджер перехватил диалог, бот не отвечает
+  enum :mode, { ai_mode: 0, manager_mode: 1 }, default: :ai_mode
+
+  validates :taken_by, presence: true, if: :manager_mode?
+  validates :taken_at, presence: true, if: :manager_mode?
+
+  scope :in_manager_mode, -> { where(mode: :manager_mode) }
+  scope :taken_by_user, ->(user) { where(taken_by: user) }
+
+  # Возвращает оставшееся время до автоматического возврата боту
+  # @return [Float, nil] секунды до таймаута или nil если не в manager_mode
+  def takeover_time_remaining
+    return nil unless manager_mode? && taken_at
+
+    timeout_at = taken_at + ChatTakeoverService::TIMEOUT_DURATION
+    [ timeout_at - Time.current, 0 ].max
+  end
+
+  # Проверяет, истёк ли таймаут takeover
+  # @return [Boolean]
+  def takeover_expired?
+    manager_mode? && taken_at && taken_at < ChatTakeoverService::TIMEOUT_DURATION.ago
+  end
+
   # Scope для предзагрузки данных клиента и Telegram пользователя
   # Используется в dashboard для отображения информации о клиенте
   scope :with_client_details, -> { includes(client: :telegram_user) }

app/models/message.rb

@@ -1,7 +1,33 @@
 # frozen_string_literal: true
 
 # Represents a single message within a chat conversation
+#
+# @attr [String] role роль отправителя (user, assistant, tool, system)
+# @attr [String] content содержимое сообщения
+# @attr [Integer] sender_type тип отправителя для assistant сообщений
+# @attr [Integer] sender_id ID пользователя, если отправлено менеджером
 class Message < ApplicationRecord
   acts_as_message touch_chat: :last_message_at
   has_many_attached :attachments
+
+  belongs_to :sender, class_name: 'User', optional: true
+
+  # Тип отправителя для различения AI и менеджера в истории чата
+  # ai: сообщение от AI-бота (по умолчанию)
+  # manager: сообщение от менеджера в режиме takeover
+  # client: сообщение от клиента (для аналитики)
+  # system: системное уведомление (переключение на менеджера и т.д.)
+  enum :sender_type, { ai: 0, manager: 1, client: 2, system: 3 }, default: :ai
+
+  validates :sender, presence: true, if: :manager?
+
+  # Возвращает true, если сообщение отправлено менеджером
+  def from_manager?
+    manager?
+  end
+
+  # Возвращает true, если сообщение является системным уведомлением
+  def system_notification?
+    system?
+  end
 end

app/models/telegram_user.rb

@@ -65,6 +65,12 @@ def chat_id
     id
   end
 
+  # Alias для chat_id - используется в Telegram Bot API для отправки сообщений
+  #
+  # @return [Integer] ID пользователя Telegram
+  # @note В Telegram Bot API, chat_id для личных сообщений равен user_id
+  alias telegram_id id
+
   # Находит или создает пользователя по данным от Telegram
   #
   # @param data [Hash] данные пользователя от Telegram API