polylingo_chat 0.1.1 → 0.4.0

data/lib/generators/polylingo_chat/install/templates/controllers/polylingo_chat/conversations_controller.rb

@@ -0,0 +1,127 @@
+module PolylingoChat
+  class ConversationsController < ApplicationController
+    before_action :set_conversation, only: [:show, :update, :destroy]
+
+    # GET /polylingo_chat/conversations
+    def index
+      @conversations = Conversation.all.includes(:participants, :messages)
+
+      respond_to do |format|
+        format.html # renders app/views/polylingo_chat/conversations/index.html.erb
+        format.json { render json: @conversations.map { |c| conversation_json(c) } }
+      end
+    end
+
+    # GET /polylingo_chat/conversations/:id
+    def show
+      respond_to do |format|
+        format.html # renders app/views/polylingo_chat/conversations/show.html.erb
+        format.json { render json: conversation_json(@conversation, include_messages: true) }
+      end
+    end
+
+    # POST /polylingo_chat/conversations
+    def create
+      @conversation = Conversation.new(conversation_params)
+
+      if @conversation.save
+        # Add participants if provided
+        if params[:participant_ids].present?
+          add_participants_from_params(@conversation)
+        end
+
+        respond_to do |format|
+          format.html { redirect_to polylingo_chat_conversation_path(@conversation), notice: 'Conversation created successfully.' }
+          format.json { render json: conversation_json(@conversation), status: :created }
+        end
+      else
+        respond_to do |format|
+          format.html { render :new, status: :unprocessable_entity }
+          format.json { render json: { errors: @conversation.errors.full_messages }, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # PATCH/PUT /polylingo_chat/conversations/:id
+    def update
+      if @conversation.update(conversation_params)
+        respond_to do |format|
+          format.html { redirect_to polylingo_chat_conversation_path(@conversation), notice: 'Conversation updated successfully.' }
+          format.json { render json: conversation_json(@conversation) }
+        end
+      else
+        respond_to do |format|
+          format.html { render :edit, status: :unprocessable_entity }
+          format.json { render json: { errors: @conversation.errors.full_messages }, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE /polylingo_chat/conversations/:id
+    def destroy
+      @conversation.destroy
+
+      respond_to do |format|
+        format.html { redirect_to polylingo_chat_conversations_path, notice: 'Conversation deleted successfully.' }
+        format.json { head :no_content }
+      end
+    end
+
+    private
+
+    def set_conversation
+      @conversation = Conversation.find(params[:id])
+    end
+
+    def conversation_params
+      params.require(:conversation).permit(:title)
+    end
+
+    def add_participants_from_params(conversation)
+      Array(params[:participant_ids]).each do |participant_data|
+        type = participant_data[:type] || 'User'
+        id = participant_data[:id]
+        role = participant_data[:role]
+
+        klass = type.constantize
+        record = klass.find(id)
+        conversation.add_participant(record, role: role)
+      end
+    end
+
+    def conversation_json(conversation, include_messages: false)
+      {
+        id: conversation.id,
+        title: conversation.title,
+        created_at: conversation.created_at,
+        updated_at: conversation.updated_at,
+        participants: conversation.participants.map { |p| participant_json(p) },
+        messages: include_messages ? conversation.messages.map { |m| message_json(m) } : []
+      }
+    end
+
+    def participant_json(participant)
+      {
+        id: participant.id,
+        type: participant.participantable_type,
+        participant_id: participant.participantable_id,
+        role: participant.role,
+        name: participant.participantable.try(:name) || participant.participantable.try(:email)
+      }
+    end
+
+    def message_json(message)
+      {
+        id: message.id,
+        body: message.body,
+        language: message.language,
+        translated_body: message.translated_body,
+        translated: message.translated,
+        sender_type: message.sender_type,
+        sender_id: message.sender_id,
+        sender_name: message.sender_name,
+        created_at: message.created_at
+      }
+    end
+  end
+end

data/lib/generators/polylingo_chat/install/templates/controllers/polylingo_chat/messages_controller.rb

@@ -0,0 +1,113 @@
+module PolylingoChat
+  class MessagesController < ApplicationController
+    before_action :set_conversation
+
+    # GET /polylingo_chat/conversations/:conversation_id/messages
+    # Optional query params:
+    #   - target_language: ISO 639-1 code (e.g., 'es', 'fr', 'de')
+    #   - translate: 'true' to enable on-the-fly translation
+    def index
+      @messages = @conversation.messages.order(created_at: :asc)
+
+      respond_to do |format|
+        format.html # renders app/views/polylingo_chat/messages/index.html.erb
+        format.json do
+          # Check if on-the-fly translation is requested
+          if params[:translate] == 'true' && params[:target_language].present?
+            render json: @messages.map { |m| translate_message_json(m, params[:target_language]) }
+          else
+            render json: @messages.map { |m| message_json(m) }
+          end
+        end
+      end
+    end
+
+    # POST /polylingo_chat/conversations/:conversation_id/messages
+    def create
+      @message = @conversation.messages.new(message_params)
+
+      # Set sender from params (polymorphic)
+      if params[:sender_type] && params[:sender_id]
+        sender_klass = params[:sender_type].constantize
+        @message.sender = sender_klass.find(params[:sender_id])
+      end
+
+      if @message.save
+        respond_to do |format|
+          format.html { redirect_to polylingo_chat_conversation_path(@conversation), notice: 'Message sent successfully.' }
+          format.json { render json: message_json(@message), status: :created }
+        end
+      else
+        respond_to do |format|
+          format.html { redirect_to polylingo_chat_conversation_path(@conversation), alert: 'Failed to send message.' }
+          format.json { render json: { errors: @message.errors.full_messages }, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    private
+
+    def set_conversation
+      @conversation = Conversation.find(params[:conversation_id])
+    end
+
+    def message_params
+      params.require(:message).permit(:body, :language)
+    end
+
+    def message_json(message)
+      {
+        id: message.id,
+        body: message.body,
+        language: message.language,
+        translated_body: message.translated_body,
+        translated: message.translated,
+        sender_type: message.sender_type,
+        sender_id: message.sender_id,
+        sender_name: message.sender_name,
+        conversation_id: message.conversation_id,
+        created_at: message.created_at,
+        updated_at: message.updated_at
+      }
+    end
+
+    def translate_message_json(message, target_language)
+      # Check if translation is enabled
+      unless PolylingoChat.config.api_key.present?
+        return message_json(message)
+      end
+
+      # If message is already in target language, return as is
+      if message.language == target_language
+        return message_json(message).merge(
+          translated_body: message.body,
+          target_language: target_language
+        )
+      end
+
+      # If we have a stored translation in the target language (for default language)
+      if target_language == PolylingoChat.config.default_language && message.translated_body.present?
+        return message_json(message).merge(target_language: target_language)
+      end
+
+      # Translate on-the-fly
+      begin
+        translated = PolylingoChat::Translator.translate(
+          text: message.body,
+          from: message.language || 'auto',
+          to: target_language,
+          context: nil
+        )
+        translated = translated.value if translated.respond_to?(:value)
+
+        message_json(message).merge(
+          translated_body: translated,
+          target_language: target_language
+        )
+      rescue StandardError => e
+        Rails.logger.error("PolylingoChat: Translation failed - #{e.message}")
+        message_json(message).merge(target_language: target_language)
+      end
+    end
+  end
+end

data/lib/generators/polylingo_chat/install/templates/create_conversations.rb

@@ -1,6 +1,6 @@
-class CreateConversations < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+class CreatePolylingoChatConversations < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
   def change
-    create_table :conversations do |t|
+    create_table :polylingo_chat_conversations do |t|
       t.string :title
       t.boolean :private, default: true
       t.timestamps

data/lib/generators/polylingo_chat/install/templates/create_message_translations.rb

@@ -0,0 +1,13 @@
+class CreatePolylingoChatMessageTranslations < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :polylingo_chat_message_translations do |t|
+      t.references :message, null: false, foreign_key: { to_table: :polylingo_chat_messages }
+      t.string :language, null: false
+      t.text :translated_text, null: false
+
+      t.timestamps
+    end
+
+    add_index :polylingo_chat_message_translations, [:message_id, :language], unique: true, name: 'idx_message_translations_on_message_and_language'
+  end
+end

data/lib/generators/polylingo_chat/install/templates/create_messages.rb

@@ -1,13 +1,17 @@
-class CreateMessages < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+class CreatePolylingoChatMessages < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
   def change
-    create_table :messages do |t|
-      t.references :sender, null: false, foreign_key: { to_table: :users }
-      t.references :conversation, null: false, foreign_key: true
+    create_table :polylingo_chat_messages do |t|
+      # Polymorphic sender - supports User, Vendor, Customer, etc.
+      t.references :sender, polymorphic: true, null: false
+      t.references :conversation, null: false, foreign_key: { to_table: :polylingo_chat_conversations }
       t.text :body
       t.string :language
       t.text :translated_body
       t.boolean :translated, default: false
       t.timestamps
     end
+
+    add_index :polylingo_chat_messages, [:sender_type, :sender_id]
+    add_index :polylingo_chat_messages, [:conversation_id, :created_at]
   end
 end

data/lib/generators/polylingo_chat/install/templates/create_participants.rb

@@ -1,12 +1,15 @@
-class CreateParticipants < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+class CreatePolylingoChatParticipants < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
   def change
-    create_table :participants do |t|
-      t.references :user, null: false, foreign_key: true
-      t.references :conversation, null: false, foreign_key: true
+    create_table :polylingo_chat_participants do |t|
+      # Polymorphic association - supports User, Vendor, Customer, etc.
+      t.references :participantable, polymorphic: true, null: false
+      t.references :conversation, null: false, foreign_key: { to_table: :polylingo_chat_conversations }
       t.string :role
       t.timestamps
     end
 
-    add_index :participants, [:user_id, :conversation_id], unique: true
+    add_index :polylingo_chat_participants, [:participantable_type, :participantable_id, :conversation_id],
+              unique: true,
+              name: 'index_polylingo_participants_on_participantable_conversation'
   end
 end

data/lib/generators/polylingo_chat/install/templates/javascript/chat.js

@@ -16,17 +16,17 @@ document.addEventListener('turbo:load', () => {
     return
   }
 
-  // Subscribe to the PolylinguoChatChannel
-  console.log("Subscribing to PolylinguoChatChannel...")
+  // Subscribe to the PolylingoChatChannel
+  console.log("Subscribing to PolylingoChatChannel...")
   const subscription = consumer.subscriptions.create(
-    { channel: "PolylinguoChatChannel", conversation_id: conversationId },
+    { channel: "PolylingoChatChannel", conversation_id: conversationId },
     {
       connected() {
-        console.log("✓ Connected to PolylinguoChatChannel!")
+        console.log("✓ Connected to PolylingoChatChannel!")
       },
 
       disconnected() {
-        console.log("✗ Disconnected from PolylinguoChatChannel")
+        console.log("✗ Disconnected from PolylingoChatChannel")
       },
 
       received(data) {

data/lib/generators/polylingo_chat/install/templates/jobs/translate_job.rb

@@ -0,0 +1,93 @@
+module PolylingoChat
+  class TranslateJob < ::ApplicationJob
+    queue_as :polylingo_chat_translations
+
+    def perform(message_id)
+      # Find message using namespaced model
+      message = PolylingoChat::Message.find_by(id: message_id)
+      return unless message
+
+      conversation = message.conversation
+      return unless conversation
+
+      # Get all participants except the sender (works with polymorphic associations)
+      recipient_participants = conversation.participants.where.not(
+        participantable_type: message.sender_type,
+        participantable_id: message.sender_id
+      )
+      recipients = recipient_participants.map(&:participantable)
+
+      # Check if translation is enabled (API key present)
+      translation_enabled = PolylingoChat.config.api_key.present?
+
+      # Detect and store the source language
+      if translation_enabled
+        source_lang = PolylingoChat::Translator.detect_language(message.body)
+        message.update_column(:language, source_lang)
+      end
+
+      # Store default translation (to default_language) for API consumers
+      if translation_enabled
+        default_lang = PolylingoChat.config.default_language
+        unless source_lang == default_lang
+          context = conversation.messages.order(created_at: :asc).last(20).pluck(:body).join("") rescue nil
+          default_translation = PolylingoChat::Translator.translate(
+            text: message.body,
+            from: source_lang,
+            to: default_lang,
+            context: context
+          )
+          default_translation = default_translation.value if default_translation.respond_to?(:value)
+          message.update_column(:translated_body, default_translation)
+        end
+      end
+
+      recipients.each do |recipient|
+        if translation_enabled
+          # Translation enabled - translate message for this specific recipient
+          target_lang = recipient.preferred_language || PolylingoChat.config.default_language
+          context = conversation.messages.order(created_at: :asc).last(20).pluck(:body).join("") rescue nil
+
+          translated = PolylingoChat::Translator.translate(text: message.body, from: source_lang, to: target_lang, context: context)
+          # If translator returns a Future-like, wait
+          translated = translated.value if translated.respond_to?(:value)
+        else
+          # No API key - just use original message (chat-only mode)
+          translated = message.body
+        end
+
+        # Broadcast to recipient using ActionCable (skip if API-only)
+        begin
+          if defined?(ActionCable)
+            # Broadcast to user-specific channel
+            ActionCable.server.broadcast("polylingo_chat_recipient_#{recipient.id}", {
+              message: translated,
+              original: message.body,
+              message_id: message.id,
+              sender_id: message.sender_id,
+              sender_name: message.sender_name,
+              translated: translation_enabled
+            })
+
+            # Also broadcast to conversation channel for demo/group chat
+            ActionCable.server.broadcast("conversation_#{conversation.id}", {
+              message: translated,
+              original: message.body,
+              message_id: message.id,
+              sender_id: message.sender_id,
+              sender_name: message.sender_name,
+              translated: translation_enabled,
+              recipient_id: recipient.id
+            })
+          end
+        rescue StandardError => e
+          Rails.logger.error("PolylingoChat: Broadcast failed - #{e.message}")
+        end
+      end
+
+      message.update_column(:translated, translation_enabled)
+    rescue StandardError => e
+      Rails.logger.error("PolylingoChat: Failed to process translation - #{e.message}")
+    end
+  end
+end

data/lib/generators/polylingo_chat/install/templates/models/conversation.rb

@@ -1,7 +1,36 @@
-class Conversation < ApplicationRecord
-  has_many :participants, dependent: :destroy
-  has_many :users, through: :participants
-  has_many :messages, dependent: :destroy
+module PolylingoChat
+  class Conversation < ApplicationRecord
+    has_many :participants, class_name: "PolylingoChat::Participant", dependent: :destroy
+    has_many :messages, class_name: "PolylingoChat::Message", dependent: :destroy
 
-  validates :title, length: { maximum: 255 }, allow_blank: true
+    validates :title, length: { maximum: 255 }, allow_blank: true
+
+    # Get all participantable objects (User, Vendor, Customer, etc.)
+    def participantables
+      participants.map(&:participantable)
+    end
+
+    # Get participants of a specific type
+    # Example: conversation.participantables_of_type(User)
+    def participantables_of_type(klass)
+      participants.where(participantable_type: klass.name).map(&:participantable)
+    end
+
+    # Backward compatibility - returns all User participants
+    def users
+      participantables_of_type(User) if defined?(User)
+    end
+
+    # Check if a record is a participant in this conversation
+    def includes_participant?(record)
+      participants.exists?(participantable: record)
+    end
+
+    # Add a participant to the conversation
+    def add_participant(record, role: nil)
+      participants.find_or_create_by(participantable: record) do |p|
+        p.role = role if role
+      end
+    end
+  end
 end

data/lib/generators/polylingo_chat/install/templates/models/message.rb

@@ -1,14 +1,22 @@
-class Message < ApplicationRecord
-  belongs_to :conversation
-  belongs_to :sender, class_name: 'User', foreign_key: 'sender_id'
+module PolylingoChat
+  class Message < ApplicationRecord
+    belongs_to :conversation, class_name: "PolylingoChat::Conversation"
+    # Polymorphic sender - supports User, Vendor, Customer, etc.
+    belongs_to :sender, polymorphic: true
 
-  validates :body, presence: true
+    validates :body, presence: true
 
-  after_create_commit :enqueue_translation_job
+    after_create_commit :enqueue_translation_job
 
-  private
+    # Helper method to get sender's name (works with any model that has a name method)
+    def sender_name
+      sender.try(:name) || sender.try(:full_name) || sender.try(:email) || "Unknown"
+    end
 
-  def enqueue_translation_job
-    PolylingoChat::TranslateJob.perform_later(id) if PolylingoChat.config.async
+    private
+
+    def enqueue_translation_job
+      PolylingoChat::TranslateJob.perform_later(id) if PolylingoChat.config.async
+    end
   end
 end

data/lib/generators/polylingo_chat/install/templates/models/participant.rb

@@ -1,6 +1,21 @@
-class Participant < ApplicationRecord
-  belongs_to :user
-  belongs_to :conversation
+module PolylingoChat
+  class Participant < ApplicationRecord
+    # Polymorphic association - can belong to User, Vendor, Customer, etc.
+    belongs_to :participantable, polymorphic: true
+    belongs_to :conversation, class_name: "PolylingoChat::Conversation"
 
-  validates :user_id, uniqueness: { scope: :conversation_id }
+    validates :participantable_id, uniqueness: {
+      scope: [:participantable_type, :conversation_id],
+      message: "is already a participant in this conversation"
+    }
+
+    # Alias for backward compatibility and convenience
+    def user
+      participantable
+    end
+
+    def user=(value)
+      self.participantable = value
+    end
+  end
 end

data/lib/generators/polylingo_chat/install/templates/views/polylingo_chat/conversations/index.html.erb

@@ -0,0 +1,56 @@
+<div class="polylingo-conversations">
+  <h1>Conversations</h1>
+
+  <div class="conversations-list">
+    <%% if @conversations.any? %>
+      <%% @conversations.each do |conversation| %>
+        <div class="conversation-item">
+          <h3><%%= link_to conversation.title || "Conversation ##{conversation.id}", polylingo_chat_conversation_path(conversation) %></h3>
+          <p>
+            <strong>Participants:</strong>
+            <%%= conversation.participantables.map { |p| p.try(:name) || p.try(:email) }.join(', ') %>
+          </p>
+          <p>
+            <strong>Messages:</strong> <%%= conversation.messages.count %>
+          </p>
+          <small>Created <%%= time_ago_in_words(conversation.created_at) %> ago</small>
+        </div>
+      <%% end %>
+    <%% else %>
+      <p>No conversations yet.</p>
+    <%% end %>
+  </div>
+</div>
+
+<style>
+  .polylingo-conversations {
+    max-width: 800px;
+    margin: 0 auto;
+    padding: 20px;
+  }
+
+  .conversations-list {
+    display: flex;
+    flex-direction: column;
+    gap: 15px;
+  }
+
+  .conversation-item {
+    padding: 15px;
+    border: 1px solid #ddd;
+    border-radius: 8px;
+    background: #f9f9f9;
+  }
+
+  .conversation-item h3 {
+    margin: 0 0 10px 0;
+  }
+
+  .conversation-item p {
+    margin: 5px 0;
+  }
+
+  .conversation-item small {
+    color: #666;
+  }
+</style>