Restructure omni services and add Chatwoot research snapshot

research/chatwoot/app/controllers/api/v1/widget/base_controller.rb

@@ -0,0 +1,89 @@
+class Api::V1::Widget::BaseController < ApplicationController
+  include SwitchLocale
+  include WebsiteTokenHelper
+
+  before_action :set_web_widget
+  before_action :set_contact
+
+  private
+
+  def conversations
+    if @contact_inbox.hmac_verified?
+      verified_contact_inbox_ids = @contact.contact_inboxes.where(inbox_id: auth_token_params[:inbox_id], hmac_verified: true).map(&:id)
+      @conversations = @contact.conversations.where(contact_inbox_id: verified_contact_inbox_ids)
+    else
+      @conversations = @contact_inbox.conversations.where(inbox_id: auth_token_params[:inbox_id])
+    end
+  end
+
+  def conversation
+    @conversation ||= conversations.last
+  end
+
+  def create_conversation
+    ::Conversation.create!(conversation_params)
+  end
+
+  def inbox
+    @inbox ||= ::Inbox.find_by(id: auth_token_params[:inbox_id])
+  end
+
+  def conversation_params
+    # FIXME: typo referrer in additional attributes, will probably require a migration.
+    {
+      account_id: inbox.account_id,
+      inbox_id: inbox.id,
+      contact_id: @contact.id,
+      contact_inbox_id: @contact_inbox.id,
+      additional_attributes: {
+        browser_language: browser.accept_language&.first&.code,
+        browser: browser_params,
+        initiated_at: timestamp_params,
+        referer: permitted_params[:message][:referer_url]
+      },
+      custom_attributes: permitted_params[:custom_attributes].presence || {}
+    }
+  end
+
+  def contact_email
+    permitted_params.dig(:contact, :email)&.downcase
+  end
+
+  def contact_name
+    return if @contact.email.present? || @contact.phone_number.present? || @contact.identifier.present?
+
+    permitted_params.dig(:contact, :name) || (contact_email.split('@')[0] if contact_email.present?)
+  end
+
+  def contact_phone_number
+    permitted_params.dig(:contact, :phone_number)
+  end
+
+  def browser_params
+    {
+      browser_name: browser.name,
+      browser_version: browser.full_version,
+      device_name: browser.device.name,
+      platform_name: browser.platform.name,
+      platform_version: browser.platform.version
+    }
+  end
+
+  def timestamp_params
+    { timestamp: permitted_params[:message][:timestamp] }
+  end
+
+  def message_params
+    {
+      account_id: conversation.account_id,
+      sender: @contact,
+      content: permitted_params[:message][:content],
+      inbox_id: conversation.inbox_id,
+      content_attributes: {
+        in_reply_to: permitted_params[:message][:reply_to]
+      },
+      echo_id: permitted_params[:message][:echo_id],
+      message_type: :incoming
+    }
+  end
+end

research/chatwoot/app/controllers/api/v1/widget/campaigns_controller.rb

@@ -0,0 +1,16 @@
+class Api::V1::Widget::CampaignsController < Api::V1::Widget::BaseController
+  skip_before_action :set_contact
+
+  def index
+    account = @web_widget.inbox.account
+    @campaigns = if account.feature_enabled?('campaigns')
+                   @web_widget
+                     .inbox
+                     .campaigns
+                     .where(enabled: true, account_id: account.id)
+                     .includes(:sender)
+                 else
+                   []
+                 end
+  end
+end

research/chatwoot/app/controllers/api/v1/widget/configs_controller.rb

@@ -0,0 +1,47 @@
+class Api::V1::Widget::ConfigsController < Api::V1::Widget::BaseController
+  before_action :set_global_config
+
+  def create
+    build_contact
+    set_token
+  end
+
+  private
+
+  def set_global_config
+    @global_config = GlobalConfig.get(
+      'LOGO_THUMBNAIL',
+      'BRAND_NAME',
+      'WIDGET_BRAND_URL',
+      'MAXIMUM_FILE_UPLOAD_SIZE',
+      'INSTALLATION_NAME'
+    )
+  end
+
+  def set_contact
+    @contact_inbox = @web_widget.inbox.contact_inboxes.find_by(
+      source_id: auth_token_params[:source_id]
+    )
+    @contact = @contact_inbox&.contact
+  end
+
+  def build_contact
+    return if @contact.present?
+
+    @contact_inbox = @web_widget.create_contact_inbox(additional_attributes)
+    @contact = @contact_inbox.contact
+  end
+
+  def set_token
+    payload = { source_id: @contact_inbox.source_id, inbox_id: @web_widget.inbox.id }
+    @token = ::Widget::TokenService.new(payload: payload).generate_token
+  end
+
+  def additional_attributes
+    if @web_widget.inbox.account.feature_enabled?('ip_lookup')
+      { created_at_ip: request.remote_ip }
+    else
+      {}
+    end
+  end
+end

research/chatwoot/app/controllers/api/v1/widget/contacts_controller.rb

@@ -0,0 +1,76 @@
+class Api::V1::Widget::ContactsController < Api::V1::Widget::BaseController
+  include WidgetHelper
+
+  before_action :validate_hmac, only: [:set_user]
+
+  def show; end
+
+  def update
+    identify_contact(@contact)
+  end
+
+  def set_user
+    contact = nil
+
+    if a_different_contact?
+      @contact_inbox, @widget_auth_token = build_contact_inbox_with_token(@web_widget)
+      contact = @contact_inbox.contact
+    else
+      contact = @contact
+    end
+
+    @contact_inbox.update(hmac_verified: true) if should_verify_hmac? && valid_hmac?
+
+    identify_contact(contact)
+  end
+
+  # TODO : clean up this with proper routes delete contacts/custom_attributes
+  def destroy_custom_attributes
+    @contact.custom_attributes = @contact.custom_attributes.excluding(params[:custom_attributes])
+    @contact.save!
+    render json: @contact
+  end
+
+  private
+
+  def identify_contact(contact)
+    contact_identify_action = ContactIdentifyAction.new(
+      contact: contact,
+      params: permitted_params.to_h.deep_symbolize_keys,
+      discard_invalid_attrs: true
+    )
+    @contact = contact_identify_action.perform
+  end
+
+  def a_different_contact?
+    @contact.identifier.present? && @contact.identifier != permitted_params[:identifier]
+  end
+
+  def validate_hmac
+    return unless should_verify_hmac?
+
+    render json: { error: 'HMAC failed: Invalid Identifier Hash Provided' }, status: :unauthorized unless valid_hmac?
+  end
+
+  def should_verify_hmac?
+    return false if params[:identifier_hash].blank? && !@web_widget.hmac_mandatory
+
+    # Taking an extra caution that the hmac is triggered whenever identifier is present
+    return false if params[:custom_attributes].present? && params[:identifier].blank?
+
+    true
+  end
+
+  def valid_hmac?
+    params[:identifier_hash] == OpenSSL::HMAC.hexdigest(
+      'sha256',
+      @web_widget.hmac_token,
+      params[:identifier].to_s
+    )
+  end
+
+  def permitted_params
+    params.permit(:website_token, :identifier, :identifier_hash, :email, :name, :avatar_url, :phone_number, custom_attributes: {},
+                                                                                                            additional_attributes: {})
+  end
+end

research/chatwoot/app/controllers/api/v1/widget/conversations_controller.rb

@@ -0,0 +1,102 @@
+class Api::V1::Widget::ConversationsController < Api::V1::Widget::BaseController
+  include Events::Types
+  before_action :render_not_found_if_empty, only: [:toggle_typing, :toggle_status, :set_custom_attributes, :destroy_custom_attributes]
+
+  def index
+    @conversation = conversation
+  end
+
+  def create
+    ActiveRecord::Base.transaction do
+      process_update_contact
+      @conversation = create_conversation
+      conversation.messages.create!(message_params)
+      # TODO: Temporary fix for message type cast issue, since message_type is returning as string instead of integer
+      conversation.reload
+    end
+  end
+
+  def process_update_contact
+    @contact = ContactIdentifyAction.new(
+      contact: @contact,
+      params: { email: contact_email, phone_number: contact_phone_number, name: contact_name },
+      retain_original_contact_name: true,
+      discard_invalid_attrs: true
+    ).perform
+  end
+
+  def update_last_seen
+    head :ok && return if conversation.nil?
+
+    conversation.contact_last_seen_at = DateTime.now.utc
+    conversation.save!
+    ::Conversations::UpdateMessageStatusJob.perform_later(conversation.id, conversation.contact_last_seen_at)
+    head :ok
+  end
+
+  def transcript
+    return head :too_many_requests if conversation.blank?
+    return head :payment_required unless conversation.account.email_transcript_enabled?
+    return head :too_many_requests unless conversation.account.within_email_rate_limit?
+
+    send_transcript_email
+    head :ok
+  end
+
+  def toggle_typing
+    case permitted_params[:typing_status]
+    when 'on'
+      trigger_typing_event(CONVERSATION_TYPING_ON)
+    when 'off'
+      trigger_typing_event(CONVERSATION_TYPING_OFF)
+    end
+
+    head :ok
+  end
+
+  def toggle_status
+    return head :forbidden unless @web_widget.end_conversation?
+
+    unless conversation.resolved?
+      conversation.status = :resolved
+      conversation.save!
+    end
+    head :ok
+  end
+
+  def set_custom_attributes
+    conversation.update!(custom_attributes: permitted_params[:custom_attributes])
+  end
+
+  def destroy_custom_attributes
+    conversation.custom_attributes = conversation.custom_attributes.excluding(params[:custom_attribute])
+    conversation.save!
+    render json: conversation
+  end
+
+  private
+
+  def send_transcript_email
+    return if conversation.contact&.email.blank?
+
+    ConversationReplyMailer.with(account: conversation.account).conversation_transcript(
+      conversation,
+      conversation.contact.email
+    )&.deliver_later
+    conversation.account.increment_email_sent_count
+  end
+
+  def trigger_typing_event(event)
+    Rails.configuration.dispatcher.dispatch(event, Time.zone.now, conversation: conversation, user: @contact)
+  end
+
+  def render_not_found_if_empty
+    return head :not_found if conversation.nil?
+  end
+
+  def permitted_params
+    params.permit(:id, :typing_status, :website_token, :email, contact: [:name, :email, :phone_number],
+                                                               message: [:content, :referer_url, :timestamp, :echo_id],
+                                                               custom_attributes: {})
+  end
+end

research/chatwoot/app/controllers/api/v1/widget/direct_uploads_controller.rb

@@ -0,0 +1,11 @@
+class Api::V1::Widget::DirectUploadsController < ActiveStorage::DirectUploadsController
+  include WebsiteTokenHelper
+  before_action :set_web_widget
+  before_action :set_contact
+
+  def create
+    return if @contact.nil? || @current_account.nil?
+
+    super
+  end
+end

research/chatwoot/app/controllers/api/v1/widget/events_controller.rb

@@ -0,0 +1,23 @@
+class Api::V1::Widget::EventsController < Api::V1::Widget::BaseController
+  include Events::Types
+
+  def create
+    Rails.configuration.dispatcher.dispatch(permitted_params[:name], Time.zone.now, contact_inbox: @contact_inbox,
+                                                                                    event_info: permitted_params[:event_info].to_h.merge(event_info))
+    head :no_content
+  end
+
+  private
+
+  def event_info
+    {
+      widget_language: params[:locale],
+      browser_language: browser.accept_language.first&.code,
+      browser: browser_params
+    }
+  end
+
+  def permitted_params
+    params.permit(:name, :website_token, event_info: {})
+  end
+end

research/chatwoot/app/controllers/api/v1/widget/inbox_members_controller.rb

@@ -0,0 +1,7 @@
+class Api::V1::Widget::InboxMembersController < Api::V1::Widget::BaseController
+  skip_before_action :set_contact
+
+  def index
+    @inbox_members = @web_widget.inbox.inbox_members.includes(user: { avatar_attachment: :blob })
+  end
+end

research/chatwoot/app/controllers/api/v1/widget/integrations/dyte_controller.rb

@@ -0,0 +1,36 @@
+class Api::V1::Widget::Integrations::DyteController < Api::V1::Widget::BaseController
+  before_action :set_message
+
+  def add_participant_to_meeting
+    if @message.content_type != 'integrations'
+      return render json: {
+        error: I18n.t('errors.dyte.invalid_message_type')
+      }, status: :unprocessable_entity
+    end
+
+    response = dyte_processor_service.add_participant_to_meeting(
+      @message.content_attributes['data']['meeting_id'],
+      @conversation.contact
+    )
+    render_response(response)
+  end
+
+  private
+
+  def render_response(response)
+    render json: response, status: response[:error].blank? ? :ok : :unprocessable_entity
+  end
+
+  def dyte_processor_service
+    Integrations::Dyte::ProcessorService.new(account: @web_widget.inbox.account, conversation: @conversation)
+  end
+
+  def set_message
+    @message = @web_widget.inbox.messages.find(permitted_params[:message_id])
+    @conversation = @message.conversation
+  end
+
+  def permitted_params
+    params.permit(:website_token, :message_id)
+  end
+end

research/chatwoot/app/controllers/api/v1/widget/labels_controller.rb

@@ -0,0 +1,30 @@
+class Api::V1::Widget::LabelsController < Api::V1::Widget::BaseController
+  def create
+    if conversation.present? && label_defined_in_account?
+      conversation.label_list.add(permitted_params[:label])
+      conversation.save!
+    end
+
+    head :no_content
+  end
+
+  def destroy
+    if conversation.present?
+      conversation.label_list.remove(permitted_params[:id])
+      conversation.save!
+    end
+
+    head :no_content
+  end
+
+  private
+
+  def label_defined_in_account?
+    label = @current_account.labels&.find_by(title: permitted_params[:label])
+    label.present?
+  end
+
+  def permitted_params
+    params.permit(:id, :label, :website_token)
+  end
+end

research/chatwoot/app/controllers/api/v1/widget/messages_controller.rb

@@ -0,0 +1,73 @@
+class Api::V1::Widget::MessagesController < Api::V1::Widget::BaseController
+  before_action :set_conversation, only: [:create]
+  before_action :set_message, only: [:update]
+
+  def index
+    @messages = conversation.nil? ? [] : message_finder.perform
+  end
+
+  def create
+    @message = conversation.messages.new(message_params)
+    build_attachment
+    @message.save!
+  end
+
+  def update
+    if @message.content_type == 'input_email'
+      @message.update!(submitted_email: contact_email)
+      ContactIdentifyAction.new(
+        contact: @contact,
+        params: { email: contact_email, name: contact_name },
+        retain_original_contact_name: true
+      ).perform
+    else
+      @message.update!(message_update_params[:message])
+    end
+  rescue StandardError => e
+    render json: { error: @contact.errors, message: e.message }.to_json, status: :internal_server_error
+  end
+
+  private
+
+  def build_attachment
+    return if params[:message][:attachments].blank?
+
+    params[:message][:attachments].each do |uploaded_attachment|
+      attachment = @message.attachments.new(
+        account_id: @message.account_id,
+        file: uploaded_attachment
+      )
+
+      attachment.file_type = helpers.file_type(uploaded_attachment&.content_type) if uploaded_attachment.is_a?(ActionDispatch::Http::UploadedFile)
+    end
+  end
+
+  def set_conversation
+    @conversation = create_conversation if conversation.nil?
+  end
+
+  def message_finder_params
+    {
+      filter_internal_messages: true,
+      before: permitted_params[:before],
+      after: permitted_params[:after]
+    }
+  end
+
+  def message_finder
+    @message_finder ||= MessageFinder.new(conversation, message_finder_params)
+  end
+
+  def message_update_params
+    params.permit(message: [{ submitted_values: [:name, :title, :value, { csat_survey_response: [:feedback_message, :rating] }] }])
+  end
+
+  def permitted_params
+    # timestamp parameter is used in create conversation method
+    params.permit(:id, :before, :after, :website_token, contact: [:name, :email], message: [:content, :referer_url, :timestamp, :echo_id, :reply_to])
+  end
+
+  def set_message
+    @message = @web_widget.inbox.messages.find(permitted_params[:id])
+  end
+end