bobot 1.0.52

data/lib/bobot/commander.rb

@@ -0,0 +1,68 @@
+module Bobot
+  module Commander
+    class Error < Bobot::FacebookError; end
+
+    EVENTS = %i[
+      message
+      delivery
+      postback
+      optin
+      read
+      account_linking
+      referral
+      message_echo
+    ].freeze
+
+    include Bobot::GraphFacebook
+
+    class << self
+      def deliver(body:, query:)
+        graph_post '/me/messages', body: body, query: {
+          access_token: query.fetch(:access_token),
+        }
+      end
+
+      def on(event, &block)
+        unless EVENTS.include? event
+          raise Error.new("#{event} is not a valid event; available events are #{EVENTS.join(',')}")
+        end
+        hooks[event] = block
+      end
+
+      def receive(payload)
+        event = Bobot::Event.parse(payload)
+        hooks.fetch(Bobot::Event::EVENTS.invert[event.class].to_sym)
+        puts "[ActiveJob] << Bobot::HookJob with event #{event.class}" if Bobot.debug_log
+        #event.mark_as_seen
+        job = Bobot::CommanderJob
+        if Bobot.async
+          job.perform_later(payload: payload)
+        else
+          job.perform_now(payload: payload)
+        end
+      rescue KeyError
+        $stderr.puts "Ignoring #{event.class} (no hook registered)"
+      end
+
+      def trigger(payload)
+        event = Bobot::Event.parse(payload)
+        hook = hooks.fetch(Bobot::Event::EVENTS.invert[event.class].to_sym)
+        puts "[ActiveJob] >> Bobot::HookJob related to event #{name.class}" if Bobot.debug_log
+        #event.show_typing(state: true)
+        hook.call(event)
+        #event.show_typing(state: false)
+        [event, event.payloads_sent[1..-2]]
+      rescue KeyError
+        $stderr.puts "Ignoring #{event.class} (no hook registered)"
+      end
+
+      def hooks
+        @hooks ||= {}
+      end
+
+      def unhook
+        @hooks = {}
+      end
+    end
+  end
+end

data/lib/bobot/configuration.rb

@@ -0,0 +1,206 @@
+module Bobot
+  # Defines constants and methods related to configuration
+  module Configuration
+    # An array of valid keys in the options hash when configuring
+    VALID_CONFIGURATION_KEYS = %i[
+      page_id
+      app_id
+      app_secret
+      page_access_token
+      verify_token
+      domains
+      debug_log
+      async
+    ].freeze
+
+    # By default, don't set a facebook page id
+    DEFAULT_PAGE_ID = nil
+
+    # By default, don't set a facebook developper app id
+    DEFAULT_APP_ID = nil
+
+    # By default, don't set a facebook developper app secret
+    DEFAULT_APP_SECRET = nil
+
+    # By default, don't set a facebook developper page access token
+    DEFAULT_PAGE_ACCESS_TOKEN = nil
+
+    # By default, don't set a facebook webhook_verify_token
+    DEFAULT_VERIFY_TOKEN = nil
+
+    # By default, don't set a facebook whitelisting domains
+    DEFAULT_DOMAINS = nil
+
+    # By default, debug log is to false
+    DEFAULT_DEBUG_LOG = false
+
+    # By default, async is to false
+    DEFAULT_ASYNC = false
+
+    # @private
+    attr_accessor(*VALID_CONFIGURATION_KEYS)
+
+    # Our host application root path
+    # We set this when the engine is initialized
+    mattr_accessor :app_root
+
+    # When this module is extended, set all configuration options to their default values
+    def self.extended(base)
+      base.reset!
+    end
+
+    # Convenience method to allow configuration options to be set in a block
+    def configure
+      yield self
+    end
+
+    # Custom self assignments
+    def domains=(rhs)
+      return unless rhs.present?
+      if rhs.respond_to?(:to_str)
+        @domains = rhs.split(",").map(&:strip)
+      elsif rhs.is_a?(Array)
+        @domains = rhs
+      else
+        raise Bobot::InvalidParameter.new(:domains, "should be a string or an array")
+      end
+    end
+
+    # Create a hash of options and their values
+    def configurations
+      VALID_CONFIGURATION_KEYS.inject({}) do |option, key|
+        option.merge!(key => send(key))
+      end
+    end
+
+    # Reset all configuration options to defaults
+    def reset!
+      self.page_id = DEFAULT_PAGE_ID
+      self.app_id = DEFAULT_APP_ID
+      self.app_secret = DEFAULT_APP_SECRET
+      self.page_access_token = DEFAULT_PAGE_ACCESS_TOKEN
+      self.verify_token = DEFAULT_VERIFY_TOKEN
+      self.domains = DEFAULT_DOMAINS
+      self.debug_log = DEFAULT_DEBUG_LOG
+      self.async = DEFAULT_ASYNC
+    end
+
+    def update_facebook_setup!
+      subscribe_to_facebook_page!
+      set_greeting_text!
+      set_whitelist_domains!
+      set_get_started_button!
+      set_persistent_menu!
+    end
+
+    ## == Subcribe your bot to your page ==
+    def subscribe_to_facebook_page!
+      raise Bobot::InvalidParameter.new(:page_id)      unless Bobot.page_id.present?
+      raise Bobot::InvalidParameter.new(:access_token) unless Bobot.page_access_token.present?
+      Bobot::Subscription.set(
+        query: {
+          page_id: Bobot.page_id,
+          access_token: Bobot.page_access_token,
+        },
+      )
+    end
+
+    ## == Unsubcribe your bot from your page ==
+    def unsubscribe_to_facebook_page!
+      raise Bobot::InvalidParameter.new(:page_id)      unless Bobot.page_id.present?
+      raise Bobot::InvalidParameter.new(:access_token) unless Bobot.page_access_token.present?
+      Bobot::Subscription.unset(
+        query: {
+          page_id: Bobot.page_id,
+          access_token: Bobot.page_access_token,
+        },
+      )
+    end
+
+    ## == Set bot description (only displayed on first time). ==
+    def set_greeting_text!
+      raise Bobot::InvalidParameter.new(:access_token) unless Bobot.page_access_token.present?
+      greeting_texts = []
+      # Default text
+      greeting_text = I18n.t('bobot.config.greeting_text', locale: I18n.default_locale, default: nil)
+      if greeting_text.present?
+        greeting_texts << {
+          locale: 'default',
+          text: greeting_text,
+        }
+      end
+      # Each languages
+      I18n.available_locales.each do |locale|
+        greeting_text = I18n.t('bobot.config.greeting_text', locale: locale, default: nil)
+        next unless greeting_text.present?
+        facebook_locales = I18n.t('bobot.config.facebook_locales', locale: locale, default: nil)
+        facebook_locales.to_a.each do |locale_long|
+          greeting_texts << { locale: locale_long, text: greeting_text }
+        end
+      end
+      raise Bobot::InvalidParameter.new(:greeting_texts) unless greeting_texts.present?
+      Bobot::Profile.set(
+        body: { greeting: greeting_texts },
+        query: { access_token: Bobot.page_access_token },
+      )
+    end
+
+    ## == Set bot whitelist domains (only displayed on first time) ==
+    ## == Some features like Messenger Extensions and Checkbox Plugin require ==
+    ## == a page to specify a domain whitelist. ==
+    def set_whitelist_domains!
+      raise Bobot::InvalidParameter.new(:access_token) unless Bobot.page_access_token.present?
+      raise Bobot::InvalidParameter.new(:domains) unless Bobot.domains.present?
+      Bobot::Profile.set(
+        body: { whitelisted_domains: Bobot.domains },
+        query: { access_token: Bobot.page_access_token },
+      )
+    end
+
+    ## == You can define the action to trigger when new humans click on ==
+    ## == the Get Started button. Before doing it you should check to select the ==
+    ## == messaging_postbacks field when setting up your webhook. ==
+    def set_get_started_button!
+      raise Bobot::InvalidParameter.new(:access_token) unless Bobot.page_access_token.present?
+      Bobot::Profile.set(
+        body: { get_started: { payload: I18n.t('bobot.config.get_started.payload') } },
+        query: { access_token: Bobot.page_access_token },
+      )
+    end
+
+    ## == You can show a persistent menu to humans. ==
+    ## == If you want to have a persistent menu, you have to set get_started ==
+    ## == button before. ==
+    def set_persistent_menu!
+      raise Bobot::InvalidParameter.new(:access_token) unless Bobot.page_access_token.present?
+      persistent_menus = []
+      # Default text
+      persistent_menu = I18n.t('bobot.config.persistent_menu', locale: I18n.default_locale, default: nil)
+      if persistent_menu.present?
+        persistent_menus << {
+          locale: 'default',
+          composer_input_disabled: persistent_menu[:composer_input_disabled],
+          call_to_actions: persistent_menu[:call_to_actions],
+        }
+      end
+      # Each languages
+      I18n.available_locales.each do |locale|
+        persistent_menu = I18n.t('bobot.config.persistent_menu', locale: locale, default: nil)
+        facebook_locales = I18n.t('bobot.config.facebook_locales', locale: locale, default: nil)
+        next unless persistent_menu.present?
+        facebook_locales.to_a.each do |locale_long|
+          persistent_menus << {
+            locale: locale_long,
+            composer_input_disabled: persistent_menu[:composer_input_disabled],
+            call_to_actions: persistent_menu[:call_to_actions],
+          }
+        end
+      end
+      raise Bobot::InvalidParameter.new(:persistent_menus) unless persistent_menus.present?
+      Bobot::Profile.set(
+        body: { persistent_menu: persistent_menus },
+        query: { access_token: Bobot.page_access_token },
+      )
+    end
+  end
+end

data/lib/bobot/engine.rb

@@ -0,0 +1,33 @@
+require 'rails'
+require 'bobot'
+
+module Bobot
+  class Engine < ::Rails::Engine
+    isolate_namespace Bobot
+    config.generators.api_only = true
+
+    config.action_dispatch.rescue_responses['Bobot::ActionNotAllowed'] = :forbidden
+
+    initializer 'bobot.load_app_root' do |app|
+      Bobot.app_root = app.root
+    end
+
+    initializer 'Bobot setup middlewares' do |app|
+      app.config.middleware.use ActionDispatch::Flash
+    end
+
+    config.generators do |g|
+      g.test_framework :rspec,
+                       fixtures: true,
+                       view_specs: false,
+                       helper_specs: false,
+                       routing_specs: false,
+                       controller_specs: true,
+                       request_specs: true
+    end
+
+    rake_tasks do
+      Dir[File.join(File.dirname(__FILE__), '../tasks/*.rake')].each { |f| load f }
+    end
+  end
+end

data/lib/bobot/error_parser.rb

@@ -0,0 +1,102 @@
+module Bobot
+  # Parses and raises Facebook response errors for the send API.
+  class ErrorParser
+    INTERNAL_ERROR_CODES = {
+      1200 => [],
+    }.freeze
+
+    ACCESS_TOKEN_ERROR_CODES = {
+      190 => [],
+    }.freeze
+
+    ACCOUNT_LINKING_ERROR_CODES = {
+      10_303 => [],
+    }.freeze
+
+    LIMIT_ERROR_CODES = {
+      4 => [2_018_022],
+      100 => [2_018_109],
+      613 => [nil],
+    }.freeze
+
+    BAD_PARAMETER_ERROR_CODES = {
+      100 => [nil, 2_018_001],
+    }.freeze
+
+    PERMISSION_ERROR_CODES = {
+      10 => [2_018_065, 2_018_108],
+      200 => [1_545_041, 2_018_028, 2_018_027, 2_018_021],
+      230 => [nil],
+    }.freeze
+
+    class << self
+      # Raise any errors in the given response.
+      #
+      # response - A HTTParty::Response object.
+      #
+      # Returns nil if no errors were found, otherwises raises appropriately
+      def raise_errors_from(response)
+        return false unless response.key?('error')
+
+        error = response['error']
+
+        error_code = error['code']
+        error_subcode = error['error_subcode']
+
+        raise_code_only_error(error_code, error) if error_subcode.nil?
+
+        raise_code_subcode_error(error_code, error_subcode, error)
+
+        # Default to unidentified error
+        raise FacebookError.new(error)
+      end
+
+    private
+
+      def raise_code_only_error(error_code, args)
+        raise InternalError.new(args)       if internal_error?(error_code)
+        raise AccessTokenError.new(args)    if access_token_error?(error_code)
+        raise AccountLinkingError.new(args) if account_linking_error?(error_code)
+      end
+
+      def raise_code_subcode_error(error_code, error_subcode, args)
+        raise LimitError.new(args)        if limit_error?(error_code, error_subcode)
+        raise BadParameterError.new(args) if bad_parameter_error?(error_code, error_subcode)
+        raise PermissionError.new(args)   if permission_error?(error_code, error_subcode)
+      end
+
+      def internal_error?(error_code)
+        INTERNAL_ERROR_CODES.keys.include? error_code
+      end
+
+      def access_token_error?(error_code)
+        ACCESS_TOKEN_ERROR_CODES.keys.include? error_code
+      end
+
+      def account_linking_error?(error_code)
+        ACCOUNT_LINKING_ERROR_CODES.keys.include? error_code
+      end
+
+      def limit_error?(error_code, error_subcode)
+        limit_errors = LIMIT_ERROR_CODES[error_code]
+        return unless limit_errors
+
+        limit_errors.include? error_subcode
+      end
+
+      def bad_parameter_error?(error_code, error_subcode)
+        bad_parameter_errors = BAD_PARAMETER_ERROR_CODES[error_code]
+        return unless bad_parameter_errors
+
+        bad_parameter_errors.include? error_subcode
+      end
+
+      def permission_error?(error_code, error_subcode)
+        permission_errors = PERMISSION_ERROR_CODES[error_code]
+        return unless permission_errors
+
+        permission_errors.include? error_subcode
+      end
+    end
+  end
+end

data/lib/bobot/event.rb

@@ -0,0 +1,40 @@
+require 'bobot/events/common'
+require 'bobot/events/message'
+require 'bobot/events/message_echo'
+require 'bobot/events/delivery'
+require 'bobot/events/postback'
+require 'bobot/events/optin'
+require 'bobot/events/read'
+require 'bobot/events/account_linking'
+require 'bobot/events/referral'
+
+module Bobot
+  module Event
+    EVENTS = {
+      'message' => Message,
+      'delivery' => Delivery,
+      'postback' => Postback,
+      'optin' => Optin,
+      'read' => Read,
+      'account_linking' => AccountLinking,
+      'referral' => Referral,
+      'message_echo' => MessageEcho,
+    }.freeze
+
+    def self.parse(payload)
+      return MessageEcho.new(payload) if payload_is_echo?(payload)
+
+      EVENTS.each do |event, klass|
+        return klass.new(payload) if payload.key?(event)
+      end
+
+      raise UnknownPayload.new(payload)
+    end
+
+    def self.payload_is_echo?(payload)
+      payload.key?('message') && payload['message']['is_echo'] == true
+    end
+
+    class UnknownPayload < Bobot::Error; end
+  end
+end