360Dialog WhatsApp

.env.template

@@ -24,3 +24,9 @@ THREEMARB_PRIVATE=
 # POSTMARK_TRANSACTIONAL_STREAM=outbound
 # DOCKER_IMAGE_TAG=
 # SENTRY_DSN=
+#
+# THREE_SIXTY_DIALOG_PARTNER_ID=
+# THREE_SIXTY_DIALOG_PARTNER_USERNAME=
+# THREE_SIXTY_DIALOG_PARTNER_PASSWORD=
+# THREE_SIXTY_DIALOG_WHATS_APP_REST_API_ENDPOINT=
+# THREE_SIXTY_DIALOG_PARTNER_REST_API_ENDPOINT=

ansible/roles/installation/tasks/main.yml

@@ -53,6 +53,10 @@
     TWILIO_AUTH_TOKEN: "{{ rails.twilio.auth_token }}"
     TWILIO_API_KEY_SID: "{{ rails.twilio.api_key.sid }}"
     TWILIO_API_KEY_SECRET: "{{ rails.twilio.api_key.secret }}"
+    THREE_SIXTY_DIALOG_PARTNER_ID: "{{ rails.three_sixty_dialog.partner.id }}"
+    THREE_SIXTY_DIALOG_PARTNER_USERNAME: "{{ rails.three_sixty_dialog.partner.username }}"
+    THREE_SIXTY_DIALOG_PARTNER_PASSWORD: "{{ rails.three_sixty_dialog.partner.password }}"
+
   community.general.docker_compose:
     project_src: /home/ansible
     build: no

app/adapters/whats_app_adapter/outbound.rb

@@ -4,94 +4,25 @@ module WhatsAppAdapter
   class Outbound
     class << self
       def send!(message)
-        recipient = message&.recipient
-        return unless contributor_can_receive_messages?(recipient)
-
-        if freeform_message_permitted?(recipient)
-          send_message(recipient, message)
-        else
-          send_message_template(recipient, message)
-        end
+        "WhatsAppAdapter::#{business_solution_provider}Outbound".constantize.send!(message)
       end
 
       def send_welcome_message!(contributor)
-        return unless contributor_can_receive_messages?(contributor)
-
-        welcome_message = I18n.t('adapter.whats_app.welcome_message', project_name: Setting.project_name)
-        WhatsAppAdapter::Outbound::Text.perform_later(recipient: contributor, text: welcome_message)
-      end
-
-      def send_unsupported_content_message!(contributor)
-        return unless contributor_can_receive_messages?(contributor)
-
-        WhatsAppAdapter::Outbound::Text.perform_later(recipient: contributor,
-                                                      text: I18n.t('adapter.whats_app.unsupported_content_template',
-                                                                   first_name: contributor.first_name,
-                                                                   contact_person: contributor.organization.contact_person.name))
+        "WhatsAppAdapter::#{business_solution_provider}Outbound".constantize.send_welcome_message!(contributor)
       end
 
       def send_more_info_message!(contributor)
-        return unless contributor_can_receive_messages?(contributor)
-
-        text = [Setting.about, "_#{I18n.t('adapter.whats_app.unsubscribe.instructions')}_"].join("\n\n")
-        WhatsAppAdapter::Outbound::Text.perform_later(recipient: contributor, text: text)
+        "WhatsAppAdapter::#{business_solution_provider}Outbound".constantize.send_more_info_message!(contributor)
       end
 
       def send_unsubsribed_successfully_message!(contributor)
-        return unless contributor_can_receive_messages?(contributor)
-
-        text = [I18n.t('adapter.whats_app.unsubscribe.successful'), "_#{I18n.t('adapter.whats_app.subscribe.instructions')}_"].join("\n\n")
-        WhatsAppAdapter::Outbound::Text.perform_later(recipient: contributor, text: text)
-      end
-
-      def contributor_can_receive_messages?(recipient)
-        recipient&.whats_app_phone_number.present?
-      end
-
-      def time_of_day
-        current_time = Time.current
-        morning = current_time.change(hour: 6)
-        day = current_time.change(hour: 11)
-        evening = current_time.change(hour: 17)
-        night = current_time.change(hour: 23)
-
-        case current_time
-        when morning..day
-          'morning'
-        when day..evening
-          'day'
-        when evening..night
-          'evening'
-        else
-          'night'
-        end
-      end
-
-      def freeform_message_permitted?(recipient)
-        responding_to_template_message = recipient.whats_app_message_template_responded_at.present? &&
-                                         recipient.whats_app_message_template_responded_at > 24.hours.ago
-        latest_message_received_within_last_24_hours = recipient.replies.first&.created_at.present? &&
-                                                       recipient.replies.first.created_at > 24.hours.ago
-        responding_to_template_message || latest_message_received_within_last_24_hours
-      end
-
-      def send_message_template(recipient, message)
-        recipient.update!(whats_app_message_template_sent_at: Time.current)
-        text = I18n.t("adapter.whats_app.request_template.new_request_#{time_of_day}_#{rand(1..3)}", first_name: recipient.first_name,
-                                                                                                     request_title: message.request.title)
-        WhatsAppAdapter::Outbound::Text.perform_later(recipient: recipient, text: text)
+        "WhatsAppAdapter::#{business_solution_provider}Outbound".constantize.send_unsubsribed_successfully_message!(contributor)
       end
 
-      def send_message(recipient, message)
-        files = message.files
+      private
 
-        if files.blank?
-          WhatsAppAdapter::Outbound::Text.perform_later(recipient: recipient, text: message.text)
-        else
-          files.each_with_index do |file, index|
-            WhatsAppAdapter::Outbound::File.perform_later(recipient: recipient, text: index.zero? ? message.text : '', file: file)
-          end
-        end
+      def business_solution_provider
+        Setting.three_sixty_dialog_client_api_key.present? ? 'ThreeSixtyDialog' : 'Twilio'
       end
     end
   end

app/adapters/whats_app_adapter/outbound/three_sixty_dialog_file.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module WhatsAppAdapter
+  class Outbound
+    class ThreeSixtyDialogFile < ApplicationJob
+      queue_as :default
+
+      def perform(message_id:, file_id:)
+        message = Message.find(message_id)
+        @recipient = message.recipient
+        @file_id = file_id
+
+        url = URI.parse("#{Setting.three_sixty_dialog_whats_app_rest_api_endpoint}/messages")
+        headers = { 'D360-API-KEY' => Setting.three_sixty_dialog_client_api_key, 'Content-Type' => 'application/json' }
+        request = Net::HTTP::Post.new(url.to_s, headers)
+        request.body = payload.to_json
+        response = Net::HTTP.start(url.host, url.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+        handle_response(response)
+      end
+
+      private
+
+      attr_reader :recipient, :file_id
+
+      def payload
+        {
+          recipient_type: 'individual',
+          to: recipient.whats_app_phone_number.split('+').last,
+          type: 'image',
+          image: {
+            id: file_id
+          }
+        }
+      end
+
+      def handle_response(response)
+        case response.code.to_i
+        when 200
+          Rails.logger.debug 'Great!'
+        when 400..599
+          exception = WhatsAppAdapter::ThreeSixtyDialogError.new(error_code: response.code, message: response.body)
+          ErrorNotifier.report(exception)
+        end
+      end
+    end
+  end
+end

app/adapters/whats_app_adapter/outbound/three_sixty_dialog_text.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module WhatsAppAdapter
+  class Outbound
+    class ThreeSixtyDialogText < ApplicationJob
+      queue_as :default
+
+      def perform(payload:)
+        url = URI.parse("#{Setting.three_sixty_dialog_whats_app_rest_api_endpoint}/messages")
+        headers = { 'D360-API-KEY' => Setting.three_sixty_dialog_client_api_key, 'Content-Type' => 'application/json' }
+        request = Net::HTTP::Post.new(url.to_s, headers)
+
+        request.body = payload.to_json
+        response = Net::HTTP.start(url.host, url.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+        handle_response(response)
+      end
+
+      private
+
+      def handle_response(response)
+        case response.code.to_i
+        when 201
+          Rails.logger.debug 'Great!'
+        when 400..599
+          exception = WhatsAppAdapter::ThreeSixtyDialogError.new(error_code: response.code, message: response.body)
+          ErrorNotifier.report(exception)
+        end
+      end
+    end
+  end
+end

app/adapters/whats_app_adapter/three_sixty_dialog_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module WhatsAppAdapter
+  class ThreeSixtyDialogError < StandardError
+    def initialize(error_code:, message:)
+      super("Error occurred for WhatsApp with error code: #{error_code} with message: #{message}")
+    end
+  end
+end

app/adapters/whats_app_adapter/three_sixty_dialog_inbound.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module WhatsAppAdapter
+  class ThreeSixtyDialogInbound
+    UNKNOWN_CONTRIBUTOR = :unknown_contributor
+    UNSUPPORTED_CONTENT = :unsupported_content
+    REQUEST_FOR_MORE_INFO = :request_for_more_info
+    REQUEST_TO_RECEIVE_MESSAGE = :request_to_receive_message
+    UNSUBSCRIBE_CONTRIBUTOR = :unsubscribe_contributor
+    SUBSCRIBE_CONTRIBUTOR = :subscribe_contributor
+    UNSUPPORTED_CONTENT_TYPES = %w[location contacts document].freeze
+
+    attr_reader :sender, :text, :message
+
+    def initialize
+      @callbacks = {}
+    end
+
+    def on(callback, &block)
+      @callbacks[callback] = block
+    end
+
+    def consume(whats_app_message)
+      whats_app_message = whats_app_message.with_indifferent_access
+
+      @sender = initialize_sender(whats_app_message)
+      return unless @sender
+
+      @message = initialize_message(whats_app_message)
+      return unless @message
+
+      @unsupported_content = initialize_unsupported_content(whats_app_message)
+
+      files = initialize_file(whats_app_message)
+      @message.files = files
+
+      return unless create_message?
+
+      yield(@message) if block_given?
+    end
+
+    private
+
+    def trigger(event, *args)
+      return unless @callbacks.key?(event)
+
+      @callbacks[event].call(*args)
+    end
+
+    def initialize_sender(whats_app_message)
+      whats_app_phone_number = whats_app_message[:contacts].first[:wa_id].phony_normalized
+      sender = Contributor.find_by(whats_app_phone_number: whats_app_phone_number)
+
+      unless sender
+        trigger(UNKNOWN_CONTRIBUTOR, whats_app_phone_number)
+        return nil
+      end
+
+      sender
+    end
+
+    def initialize_message(whats_app_message)
+      message = whats_app_message[:messages].first
+      text = message[:text]&.dig(:body) || message[:button]&.dig(:text)
+
+      trigger(REQUEST_FOR_MORE_INFO, sender) if request_for_more_info?(text)
+      trigger(UNSUBSCRIBE_CONTRIBUTOR, sender) if unsubscribe_text?(text)
+      trigger(SUBSCRIBE_CONTRIBUTOR, sender) if subscribe_text?(text)
+      trigger(REQUEST_TO_RECEIVE_MESSAGE, sender) if request_to_receive_message?(sender, text)
+
+      message = Message.new(text: text, sender: sender)
+      message.raw_data.attach(
+        io: StringIO.new(JSON.generate(whats_app_message)),
+        filename: 'whats_app_message.json',
+        content_type: 'application/json'
+      )
+      message
+    end
+
+    def initialize_unsupported_content(whats_app_message)
+      return unless unsupported_content?(whats_app_message)
+
+      message.unknown_content = true
+      trigger(UNSUPPORTED_CONTENT, sender)
+    end
+
+    def initialize_file(whats_app_message)
+      message = whats_app_message[:messages].first
+      return [] unless file_type_supported?(message)
+
+      file = Message::File.new
+
+      message_file = supported_file(message)
+      content_type = message_file[:mime_type]
+      file_id = message_file[:id]
+
+      file.attachment.attach(
+        io: StringIO.new(fetch_file(file_id)),
+        filename: file_id,
+        content_type: content_type,
+        identify: false
+      )
+
+      [file]
+    end
+
+    def file_type_supported?(message)
+      supported_file(message).present?
+    end
+
+    def supported_file(message)
+      message[:image] || message[:voice] || message[:video] || message[:audio]
+    end
+
+    def unsupported_content?(whats_app_message)
+      message = whats_app_message[:messages].first
+      return unless message
+
+      unsupported_content = message.keys.any? do |key|
+        UNSUPPORTED_CONTENT_TYPES.include?(key)
+      end
+      errors = message[:errors]
+      return unsupported_content unless errors
+
+      error_indicating_unsupported_content(errors)
+    end
+
+    def error_indicating_unsupported_content(errors)
+      errors.first[:title].match?(/Unsupported message type/) || errors.first[:title].match?(/Received Wrong Message Type/)
+    end
+
+    def request_for_more_info?(text)
+      return false if text.blank?
+
+      text.strip.eql?(I18n.t('adapter.whats_app.quick_reply_button_text.more_info'))
+    end
+
+    def request_to_receive_message?(contributor, text)
+      return false if request_for_more_info?(text) || unsubscribe_text?(text) || subscribe_text?(text)
+
+      contributor.whats_app_message_template_sent_at.present?
+    end
+
+    def quick_reply_response?(text)
+      quick_reply_keys = %w[answer more_info]
+      quick_reply_texts = []
+      quick_reply_keys.each do |key|
+        quick_reply_texts << I18n.t("adapter.whats_app.quick_reply_button_text.#{key}")
+      end
+      text.strip.in?(quick_reply_texts)
+    end
+
+    def unsubscribe_text?(text)
+      return false if text.blank?
+
+      text.downcase.strip.eql?(I18n.t('adapter.whats_app.unsubscribe.text'))
+    end
+
+    def subscribe_text?(text)
+      return false if text.blank?
+
+      text.downcase.strip.eql?(I18n.t('adapter.whats_app.subscribe.text'))
+    end
+
+    def create_message?
+      has_non_text_content = message.files.any? || message.unknown_content
+      text = message.text
+      has_non_text_content || (message.text.present? && !quick_reply_response?(text) && !unsubscribe_text?(text) && !subscribe_text?(text))
+    end
+
+    def fetch_file(file_id)
+      url = URI.parse("#{Setting.three_sixty_dialog_whats_app_rest_api_endpoint}/media/#{file_id}")
+      headers = { 'D360-API-KEY' => Setting.three_sixty_dialog_client_api_key, 'Content-Type' => 'application/json' }
+      request = Net::HTTP::Get.new(url.to_s, headers)
+      response = Net::HTTP.start(url.host, url.port, use_ssl: true) do |http|
+        http.request(request)
+      end
+      response.body
+    end
+  end
+end