stealth 0.9.1

data/lib/stealth/services/facebook/reply_handler.rb

@@ -0,0 +1,471 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  module Services
+    module Facebook
+
+      class ReplyHandler < Stealth::Services::BaseReplyHandler
+
+        attr_reader :recipient_id, :reply
+
+        def initialize(recipient_id: nil, reply: nil)
+          @recipient_id = recipient_id
+          @reply = reply
+        end
+
+        def text
+          check_if_arguments_are_valid!(
+            suggestions: reply['suggestions'],
+            buttons: reply['buttons']
+          )
+
+          template = unstructured_template
+          template['message']['text'] = reply['text']
+
+          if reply['suggestions'].present?
+            fb_suggestions = generate_suggestions(suggestions: reply['suggestions'])
+            template["message"]["quick_replies"] = fb_suggestions
+          end
+
+          # If buttons are present, we need to convert this to a button template
+          if reply['buttons'].present?
+            template['message'].delete('text')
+
+            fb_buttons = generate_buttons(buttons: reply['buttons'])
+            attachment = button_attachment_template(text: reply['text'], buttons: fb_buttons)
+            template['message']['attachment'] = attachment
+          end
+
+          template
+        end
+
+        def image
+          check_if_arguments_are_valid!(
+            suggestions: reply['suggestions'],
+            buttons: reply['buttons']
+          )
+
+          template = unstructured_template
+          attachment = attachment_template(
+            attachment_type: 'image',
+            attachment_url: reply['image_url']
+          )
+          template['message']['attachment'] = attachment
+
+          if reply['suggestions'].present?
+            fb_suggestions = generate_suggestions(suggestions: reply['suggestions'])
+            template["message"]["quick_replies"] = fb_suggestions
+          end
+
+          template
+        end
+
+        def audio
+          check_if_arguments_are_valid!(
+            suggestions: reply['suggestions'],
+            buttons: reply['buttons']
+          )
+
+          template = unstructured_template
+          attachment = attachment_template(
+            attachment_type: 'audio',
+            attachment_url: reply['audio_url']
+          )
+          template['message']['attachment'] = attachment
+
+          if reply['suggestions'].present?
+            fb_suggestions = generate_suggestions(suggestions: reply['suggestions'])
+            template["message"]["quick_replies"] = fb_suggestions
+          end
+
+          template
+        end
+
+        def video
+          check_if_arguments_are_valid!(
+            suggestions: reply['suggestions'],
+            buttons: reply['buttons']
+          )
+
+          template = unstructured_template
+          attachment = attachment_template(
+            attachment_type: 'video',
+            attachment_url: reply['video_url']
+          )
+          template['message']['attachment'] = attachment
+
+          if reply['suggestions'].present?
+            fb_suggestions = generate_suggestions(suggestions: reply['suggestions'])
+            template["message"]["quick_replies"] = fb_suggestions
+          end
+
+          template
+        end
+
+        def file
+          check_if_arguments_are_valid!(
+            suggestions: reply['suggestions'],
+            buttons: reply['buttons']
+          )
+
+          template = unstructured_template
+          attachment = attachment_template(
+            attachment_type: 'file',
+            attachment_url: reply['file_url']
+          )
+          template['message']['attachment'] = attachment
+
+          if reply['suggestions'].present?
+            fb_suggestions = generate_suggestions(suggestions: reply['suggestions'])
+            template["message"]["quick_replies"] = fb_suggestions
+          end
+
+          template
+        end
+
+        def cards
+          template = card_template(
+            sharable: reply["details"]["sharable"],
+            aspect_ratio: reply["details"]["aspect_ratio"]
+          )
+
+          fb_elements = generate_card_elements(elements: reply["details"]["elements"])
+          template["message"]["attachments"]["payload"]["elements"] = fb_elements
+
+          template
+        end
+
+        def list
+          template = list_template(
+            top_element_style: reply["details"]["top_element_style"]
+          )
+
+          fb_elements = generate_list_elements(elements: reply["details"]["elements"])
+          template["message"]["attachments"]["payload"]["elements"] = fb_elements
+
+          if reply["details"]["buttons"].present?
+            if reply["details"]["buttons"].size > 1
+              raise(ArgumentError, "Facebook lists support a single button attached to the list itsef.")
+            end
+
+            template["message"]["attachments"]["payload"]["buttons"] = generate_buttons(buttons: reply["details"]["buttons"])
+          end
+
+          template
+        end
+
+        def mark_seen
+          sender_action_template(action: 'mark_seen')
+        end
+
+        def enable_typing_indicator
+          sender_action_template(action: 'typing_on')
+        end
+
+        def disable_typing_indicator
+          sender_action_template(action: 'typing_off')
+        end
+
+        def delay
+          enable_typing_indicator
+        end
+
+        # generates property/value pairs required to set the profile
+        def messenger_profile
+          unless Stealth.config.facebook.setup.present?
+            raise Stealth::Errors::ConfigurationError, "Setup for Facebook is not specified in services.yml."
+          end
+
+          profile = {}
+          Stealth.config.facebook.setup.each do |profile_option, _|
+            profile[profile_option] = self.send(profile_option)
+          end
+
+          profile
+        end
+
+        private
+
+          def unstructured_template
+            {
+              "recipient" => {
+                "id" => recipient_id
+              },
+              "message" => { }
+            }
+          end
+
+          def card_template(sharable: nil, aspect_ratio: nil)
+            template = {
+              "recipient" => {
+                "id" => recipient_id
+              },
+              "message" => {
+                "type" => "template",
+                "payload" => {
+                  "template_type" => "generic",
+                  "elements" => []
+                }
+              }
+            }
+
+            if sharable.present?
+              template["message"]["payload"]["sharable"] = sharable
+            end
+
+            if aspect_ratio.present?
+              template["message"]["payload"]["image_aspect_ratio"] = aspect_ratio
+            end
+
+            template
+          end
+
+          def list_template(top_element_style: nil, buttons: [])
+            template = {
+              "recipient" => {
+                "id" => recipient_id
+              },
+              "message" => {
+                "type" => "template",
+                "payload" => {
+                  "template_type" => "list",
+                  "elements" => []
+                }
+              }
+            }
+
+            if top_element_style.present?
+              unless ['large', 'compact'].include?(top_element_style)
+                raise(ArgumentError, "Facebook list replies only support 'large' or 'compact' as the top_element_style.")
+              end
+
+              template["message"]["payload"]["top_element_style"] = top_element_style
+            end
+
+            if buttons.present?
+              unless buttons.size > 1
+                raise(ArgumentError, "Facebook lists only support a single button in the top element.")
+              end
+
+              template["message"]["payload"]["buttons"] = aspect_ratio
+            end
+
+            template
+          end
+
+          def element_template(element_type:, element:)
+            unless element["text"].present?
+              raise(ArgumentError, "Facebook card and list elements must have a 'text' attribute.")
+            end
+
+            template = {
+              "title" => element["title"]
+            }
+
+            if element["subtitle"].present?
+              template["subtitle"] = element["subtitle"]
+            end
+
+            if element["image_url"].present?
+              template["image_url"] = element["image_url"]
+            end
+
+            if element["default_action"].present?
+              default_action = generate_default_action(action_params: element["default_action"])
+              template["default_action"] = default_action
+            end
+
+            if element["buttons"].present?
+              if element_type == 'card' && element["buttons"].size > 3
+                raise(ArgumentError, "Facebook card elements only support 3 buttons.")
+              end
+
+              if element_type == 'list' && element["buttons"].size > 1
+                raise(ArgumentError, "Facebook list elements only support 1 button.")
+              end
+
+              fb_buttons = generate_buttons(buttons: element["buttons"])
+              template["buttons"] = fb_buttons
+            end
+
+            template
+          end
+
+          def attachment_template(attachment_type:, attachment_url:)
+            {
+              "type" => attachment_type,
+              "payload" => {
+                "url" => attachment_url
+              }
+            }
+          end
+
+          def button_attachment_template(text:, buttons:)
+            {
+              "type" => "template",
+              "payload" => {
+                "template_type" => "button",
+                "text"          => text,
+                "buttons"       => buttons
+              }
+            }
+          end
+
+          def sender_action_template(action:)
+            {
+              "recipient" => {
+                "id" => recipient_id
+              },
+              "sender_action" => action
+            }
+          end
+
+          def generate_card_elements(elements:)
+            if elements.size > 10
+              raise(ArgumentError, "Facebook cards can have at most 10 cards.")
+            end
+
+            fb_elements = elements.collect do |element|
+              element_template(element_type: 'card', element: element)
+            end
+
+            fb_elements
+          end
+
+          def generate_list_elements(elements:)
+            if elements.size < 2 || elements.size > 4
+              raise(ArgumentError, "Facebook lists must have 2-4 elements.")
+            end
+
+            fb_elements = elements.collect do |element|
+              element_template(element_type: 'list', element: element)
+            end
+
+            fb_elements
+          end
+
+          def generate_suggestions(suggestions:)
+            quick_replies = suggestions.collect do |suggestion|
+              # If the user selected a location-type button, no other info needed
+              if suggestion["type"] == 'location'
+                quick_reply = { "content_type" => "location" }
+
+              # Facebook only supports these two types for now
+              else
+                quick_reply = {
+                  "content_type" => "text",
+                  "title" => suggestion["text"]
+                }
+
+                if suggestion["payload"].present?
+                  quick_reply["payload"] = suggestion["payload"]
+                else
+                  quick_reply["payload"] = suggestion["text"]
+                end
+
+                if suggestion["image_url"].present?
+                  quick_reply["image_url"] = suggestion["image_url"]
+                end
+              end
+
+              quick_reply
+            end
+
+            quick_replies
+          end
+
+          # Requires adding support for Buy, Log In, Log Out, and Share button types
+          def generate_buttons(buttons:)
+            fb_buttons = buttons.collect do |button|
+              case button['type']
+              when 'url'
+                button = {
+                  "type" => "web_url",
+                  "url" => button["url"],
+                  "title" => button["text"]
+                }
+
+                if button["webview_height"].present?
+                  button["webview_height_ratio"] = button["webview_height"]
+                end
+
+                button
+
+              when 'payload'
+                button = {
+                  "type" => "postback",
+                  "payload" => button["payload"],
+                  "title" => button["text"]
+                }
+
+              when 'call'
+                button = {
+                  "type" => "phone_number",
+                  "payload" => button["phone_number"],
+                  "title" => button["text"]
+                }
+
+              when 'nested'
+                button = {
+                  "type" => "nested",
+                  "title" => button["text"],
+                  "call_to_actions" => generate_buttons(buttons: button["buttons"])
+                }
+
+              else
+                raise(Stealth::Errors::ServiceImpaired, "Sorry, we don't yet support #{button["type"]} buttons yet!")
+              end
+
+              button
+            end
+
+            fb_buttons
+          end
+
+          def generate_default_action(action_params:)
+            default_action = {
+              "type" => "web_url",
+              "url" => action_params["url"]
+            }
+
+            if action_params["webview_height"].present?
+              action_params["webview_height_ratio"] = action_params["webview_height"]
+            end
+
+            default_action
+          end
+
+          def check_if_arguments_are_valid!(suggestions:, buttons:)
+            if suggestions.present? && buttons.present?
+              raise(ArgumentError, "A reply cannot have buttons and suggestions!")
+            end
+          end
+
+          def greeting
+            Stealth.config.facebook.setup.greeting.map do |greeting|
+              {
+                "locale" => greeting["locale"],
+                "text" => greeting["text"]
+              }
+            end
+          end
+
+          def persistent_menu
+            Stealth.config.facebook.setup.persistent_menu.map do |persistent_menu|
+              {
+                "locale" => persistent_menu['locale'],
+                "composer_input_disabled" => (persistent_menu['composer_input_disabled'] || false),
+                "call_to_actions" => generate_buttons(buttons: persistent_menu['call_to_actions'])
+              }
+            end
+          end
+
+          def get_started
+            Stealth.config.facebook.setup.get_started
+          end
+      end
+
+    end
+  end
+end

data/lib/stealth/services/facebook/setup.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require 'stealth/services/facebook/client'
+
+module Stealth
+  module Services
+    module Facebook
+
+      class Setup
+
+        class << self
+          def trigger
+            reply_handler = Stealth::Services::Facebook::ReplyHandler.new
+            reply = reply_handler.messenger_profile
+            client = Stealth::Services::Facebook::Client.new(reply: reply, endpoint: 'messenger_profile')
+            client.transmit
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/stealth/services/jobs/handle_message_job.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  module Services
+
+    class HandleMessageJob < Stealth::Jobs
+      sidekiq_options queue: :webhooks, retry: false
+
+      def perform(service, params, headers)
+        dispatcher = Stealth::Dispatcher.new(
+          service: service,
+          params: params,
+          headers: headers
+        )
+
+        dispatcher.process
+      end
+    end
+
+  end
+end

data/lib/stealth/session.rb

@@ -0,0 +1,74 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  class Session
+
+    SLUG_SEPARATOR = '->'
+
+    attr_reader :session, :flow, :state, :user_id
+
+    def initialize(user_id:)
+      @user_id = user_id
+
+      unless defined?($redis)
+        raise(Stealth::Errors::RedisNotConfigured, "Please make sure REDIS_URL is configured before using sessions.")
+      end
+
+      get
+      self
+    end
+
+    def self.flow_and_state_from_session_slug(slug:)
+      {
+        flow: slug&.split(SLUG_SEPARATOR)&.first,
+        state: slug&.split(SLUG_SEPARATOR)&.last
+      }
+    end
+
+    def flow
+      @flow = begin
+        flow_klass = [flow_string, 'flow'].join('_').classify.constantize
+        flow = flow_klass.new.init_state(state_string)
+        flow
+      end
+    end
+
+    def state
+      flow.current_state
+    end
+
+    def flow_string
+      session&.split(SLUG_SEPARATOR)&.first
+    end
+
+    def state_string
+      session&.split(SLUG_SEPARATOR)&.last
+    end
+
+    def get
+      @session ||= $redis.get(user_id)
+    end
+
+    def set(flow:, state:)
+      @session = canonical_session_slug(flow: flow, state: state)
+      flow
+      $redis.set(user_id, canonical_session_slug(flow: flow, state: state))
+    end
+
+    def present?
+      session.present?
+    end
+
+    def blank?
+      !present?
+    end
+
+    private
+
+      def canonical_session_slug(flow:, state:)
+        [flow, state].join(SLUG_SEPARATOR)
+      end
+
+  end
+end

data/lib/stealth/version.rb

@@ -0,0 +1,12 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  module Version
+    def self.version
+      File.read(File.join(File.dirname(__FILE__), '../..', 'VERSION')).strip
+    end
+  end
+
+  VERSION = Version.version
+end

data/lib/stealth.rb

@@ -0,0 +1 @@
+require 'stealth/base'

data/spec/configuration_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Stealth::Configuration" do
+
+  describe "accessing via method calling" do
+    let(:services_yml) { File.read(File.join(File.dirname(__FILE__), 'sample_services_yml', 'services.yml')) }
+    let(:parsed_config) { YAML.load(ERB.new(services_yml).result)[Stealth.env] }
+    let(:config) { Stealth.load_services_config!(services_yml) }
+
+    it "should return the root node" do
+      expect(config.facebook).to eq parsed_config['facebook']
+    end
+
+    it "should access deeply nested nodes" do
+      expect(config.facebook.setup.greeting).to eq parsed_config['facebook']['setup']['greeting']
+    end
+
+    it "should handle values that are arrays correctly" do
+      expect(config.facebook.setup.persistent_menu).to be_a(Array)
+    end
+
+    it "should retain the configuration at the class level" do
+      expect(Stealth.config.facebook.setup.greeting).to eq parsed_config['facebook']['setup']['greeting']
+    end
+
+    it "should handle multiple keys at the root level" do
+      expect(config.twilio_sms.account_sid).to eq parsed_config['twilio_sms']['account_sid']
+    end
+  end
+
+  describe "config files with ERB" do
+    let(:services_yml) { File.read(File.join(File.dirname(__FILE__), 'sample_services_yml', 'services_with_erb.yml')) }
+    let(:config) { Stealth.load_services_config!(services_yml) }
+
+    it "should replace available embedded env vars" do
+      ENV['FACEBOOK_VERIFY_TOKEN'] = 'it works'
+      expect(config.facebook.verify_token).to eq 'it works'
+    end
+
+    it "should replace unavailable embedded env vars with nil" do
+      expect(config.facebook.challenge).to be_nil
+    end
+
+    it "should not reload the configuration file if one already exists" do
+      Stealth.load_services_config(services_yml)
+      expect(config.facebook.challenge).to be_nil
+    end
+  end
+
+end