bot_framework 0.1.0beta → 0.1.0beta2

data/examples/simple_regex/config.ru

@@ -0,0 +1,6 @@
+require 'pry'
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'bot_framework'
+require_relative 'bot'
+# include BotFramework
+run BotFramework::Server

data/lib/bot_framework.rb

@@ -2,6 +2,8 @@ require 'oauth2'
 require 'jwt'
 require 'httparty'
 require 'json'
+require 'logger'
+
 require 'bot_framework/version'
 require 'bot_framework/errors'
 require 'bot_framework/util'
@@ -12,6 +14,7 @@ require 'bot_framework/bot_state'
 require 'bot_framework/token_validator'
 require 'bot_framework/bot'
 require 'bot_framework/server'
+# Models
 require 'bot_framework/models/base'
 require 'bot_framework/models/activity'
 require 'bot_framework/models/api_response'
@@ -37,6 +40,11 @@ require 'bot_framework/models/resource_response'
 require 'bot_framework/models/signin_card'
 require 'bot_framework/models/thumbnail_card'
 
+# Dialog
+require 'bot_framework/dialogs/entity_recognizer'
+require 'bot_framework/dialogs/luis_recognizer'
+require 'bot_framework/dialogs/reg_exp_recognizer'
+
 module BotFramework
   class << self
     attr_accessor :connector
@@ -44,5 +52,9 @@ module BotFramework
     def configure(*args, &block)
       @connector = Connector.new(*args, &block)
     end
+
+    def logger
+      @logger ||= defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+    end
   end
 end

data/lib/bot_framework/api_base.rb

@@ -1,3 +1,5 @@
+require 'uri'
+
 module BotFramework
   class ApiBase
     include HTTParty
@@ -8,23 +10,23 @@ module BotFramework
     end
 
     def api_get(local_uri, _opts = {})
-      uri = service_url + local_uri
+      uri = URI.join(service_url, URI.escape(local_uri))
       JSON.parse(BotFramework.connector.token.get(uri).body)
     end
 
     def api_post(local_uri, opts = {})
-      uri = service_url + local_uri
+      uri = URI.join(service_url, URI.escape(local_uri))
       JSON.parse(BotFramework.connector.token.post(uri, body: opts.to_json,
                                                         headers: { 'Content-Type' => 'application/json' }).body)
     end
 
     def api_delete(local_uri)
-      uri = service_url + local_uri
+      uri = URI.join(service_url, URI.escape(local_uri))
       BotFramework.connector.token.delete(uri)
     end
 
     def api_request(method, local_uri, opts)
-      uri = service_url + local_uri
+      uri = URI.join(service_url, URI.escape(local_uri))
       BotFramework.connector.token.request(method, uri, opts)
     end
   end

data/lib/bot_framework/bot.rb

@@ -1,17 +1,58 @@
 module BotFramework
   class Bot
     class << self
+      extend Gem::Deprecate
+      attr_accessor :recognizers
+
       def on(event, &block)
         hooks[event] = block
       end
 
+      def on_intent(intent, &block)
+        intent_callbacks[intent] = block
+      end
+
+      def recognizer=(recognizer)
+        warn "DEPRECATED: Use add_recognizer method instead"
+        add_recognizer(recognizer)
+      end
+      deprecate :recognizer=, :add_recognizer, 2016, 5
+
+      def add_recognizer(recognizer)
+        recognizers << recognizer
+      end
+
+      def recognizers
+        @recognizers ||= []
+      end
+
       def trigger(event, *args)
         # hooks.fetch(event).call(*args)
-        instance_exec *args, &hooks.fetch(event)
+        if hooks[event].nil?
+          BotFramework.logger.info "No call back registered for #{event}"
+          return false
+        end
+        instance_exec(*args, &hooks.fetch(event))
+      end
+
+      def trigger_intent_call_back(intent, *args)
+        if intent_callbacks[intent].nil?
+          BotFramework.logger.info "No call back registered for #{intent}"
+          trigger_intent_call_back(:default, *args) if intent_callbacks[:default]
+          return false
+        end
+        instance_exec(*args, &intent_callbacks.fetch(intent))
       end
 
       def receive(payload)
+        trigger(payload.type.to_sym)
+        # Run on default
         trigger(:activity, payload)
+        recognizers.each do |recognizer|
+          recognizer.recognize(message: payload.as_json) do |_error, intents|
+            trigger_intent_call_back(intents[:intent], payload, intents) if intents[:intent]
+          end
+        end
       end
 
       def reply(activity, message = '')
@@ -19,7 +60,7 @@ module BotFramework
       end
 
       def user_data=(data)
-        p "Data set as #{data}"
+        BotFramework.logger.info "Data set as #{data}"
       end
 
       def set_conversation_data(activity, data)
@@ -43,6 +84,10 @@ module BotFramework
       def reset_hooks
         @hooks = {}
       end
+
+      def intent_callbacks
+        @intent_callbacks ||= {}
+      end
     end
   end
 end

data/lib/bot_framework/connector.rb

@@ -4,6 +4,16 @@ module BotFramework
     # include HTTParty
     attr_accessor :app_id, :app_secret, :token
     CONFIG_URI = 'https://api.aps.skype.com/v1/.well-known/openidconfiguration'.freeze
+    REFRESH_ENDPOINT = 'https://login.microsoftonline.com/botframework.com/oauth2/v2.0/token'.freeze
+    REFRESH_SCOPE = 'https://api.botframework.com/.default'.freeze
+    OPEN_ID_METADATA = 'https://login.botframework.com/v1/.well-known/openidconfiguration'.freeze
+    BOT_CONNECTOR_ISSUER = 'https://api.botframework.com'.freeze
+    MSA_OPEN_ID_METADATA = 'https://login.microsoftonline.com/common/v2.0/.well-known/openid-configuration'.freeze
+    MSA_ISSUER = 'https://sts.windows.net/72f988bf-86f1-41af-91ab-2d7cd011db47/'.freeze
+    MSA_AUDIENCE = 'https://graph.microsoft.com'.freeze
+    EMULATOR_AUDIENCE_METADATA = 'https://login.microsoftonline.com/botframework.com/v2.0/.well-known/openid-configuration'.freeze
+    EMULATOR_AUDIENCE = 'https://sts.windows.net/d6d49420-f39b-4df7-a1dc-d59a935871db/'.freeze
+    STATE_END_POINT = 'https://state'.freeze
 
     def initialize(options = {})
       @app_id = options[:app_id]
@@ -13,8 +23,8 @@ module BotFramework
 
     def client
       OAuth2::Client.new(app_id, app_secret,
-                         authorize_url: '/common/oauth2/v2.0/authorize',
-                         token_url: '/common/oauth2/v2.0/token',
+                         authorize_url: 'botframework.com/oauth2/v2.0/authorize',
+                         token_url: 'botframework.com/oauth2/v2.0/token',
                          raise_errors: true,
                          site: 'https://login.microsoftonline.com')
     end
@@ -26,9 +36,7 @@ module BotFramework
     end
 
     def get_token
-      client.client_credentials.get_token(scope: 'https://graph.microsoft.com/.default',
-                                          client_id: app_id,
-                                          client_secret: app_secret)
+      client.client_credentials.get_token(scope: 'https://api.botframework.com/.default', token_method: :post)
     end
   end
 end

data/lib/bot_framework/console_connector.rb

@@ -0,0 +1,17 @@
+require 'observer'
+require 'nio'
+module BotFramework
+  class ConsoleConnector
+    include Observable
+    def listen
+      BotFramework.logger.info 'Listening'
+      loop do
+        line = Readline.readline('> ')
+        break if line.nil? || line == 'quit'
+        Readline::HISTORY.push(line)
+        BotFramework.logger.info "You typed: #{line}"
+      end
+      self
+    end
+  end
+end

data/lib/bot_framework/dialogs/action_set.rb

@@ -0,0 +1,66 @@
+module BotFramework
+  module Dialogs
+    class ActionSet
+      attr_accessor :actions
+
+      def initialize
+        @actions = {}
+      end
+
+      def clone(copy_to = nil)
+        obj = copy_to || ActionSet.new
+        obj.trigger = trigger
+        actions.each do |name|
+          object.actions[name] = actions[name]
+        end
+        obj
+      end
+
+      def add_dialog_trigger(actions, dialog_id)
+        if trigger
+          trigger.localization_namespace = dialog_id.split(':').first
+          actions.begin_dialog_action(dialog_id, dialog_id, trigger)
+        end
+      end
+
+      def find_action_routes(context, callback); end
+
+      def select_action_route(session, route); end
+
+      def dialog_interrupted(session, dialog_id, dialog_ags); end
+
+      def begin_dialog_action(name, id, options = {}); end
+
+      def end_conversation_action(name, message, options); end
+
+      def reload_action(name, message, options); end
+
+      def cancel_action(name, message, options)
+        action(name, options) do |args, session|
+          if options[:confirm_prompt]
+            session.begin_dialog('BotBuilder:ConfirmCancel', localization_namespace: nil,
+                                                             confirm_prompt: nil,
+                                                             dialog_index: nil,
+                                                             msg: message)
+          elsif message.present?
+            session.send_localized(args.library_name, message)
+          else
+            session.cancel_dialog(args.dialog_index)
+          end
+        end
+      end
+
+      def select_action_routes; end
+
+      def trigger_action; end
+
+      private
+
+      def action(_name, _options = {})
+        yield
+      end
+
+      def recognize_action(message); end
+    end
+  end
+end

data/lib/bot_framework/dialogs/dialog.rb

@@ -0,0 +1,25 @@
+require_relative '../session'
+require_relative 'action_set'
+module BotFramework
+  # Abstract class for dialog
+  module Dialogs
+    class Dialog < ActionSet
+      RESUME_REASONS = [:completed, :not_completed, :canceled, :back, :forward, :reprompt].freeze
+      def begin(session, _opts = {})
+        reply_recieved(session)
+      end
+
+      def reply_recieved(_session, _recognize_result = {})
+        raise NotImplementedError
+      end
+
+      def dialog_resumed(session, result)
+        session.error(result[:error]) if result[:error]
+      end
+
+      def recognize(_context)
+        yield nil, { score: 0.1 }
+      end
+    end
+  end
+end

data/lib/bot_framework/dialogs/entity_recognizer.rb

@@ -0,0 +1,123 @@
+require 'chronic'
+module BotFramework
+  module Dialogs
+    class EntityRecognizer
+      DATE_REGEX = /^\d{4}-\d{2}-\d{2}/i
+      YES_REGEX = /^(1|y|yes|yep|sure|ok|true)(\W|$)/i
+      NO_REGX = /^(2|n|no|nope|not|false)(\W|$)/i
+      NUMBER_REGEX = /[+-]?(?:\d+\.?\d*|\d*\.?\d+)/
+      ORDINAL_WORDS_REGEX = /first|second|third|fourth|fifth|sixth|seventh|eigth|ninth|tenth/
+      def initialize(*args); end
+
+      def self.find_entity(entities, type)
+        # raise ArgumentError unless entities.is_a? Hash
+        entities.find { |entity| entity[:type] == type }
+      end
+
+      def self.find_all_entities(entities, type)
+        entities.find_all { |entity| entity[:type] == type }
+      end
+
+      def self.parse_time(entities)
+        entities = [EntityRecognizer.recognize_time(entities)] if entities.is_a? String
+        EntityRecognizer.resolve_time(entities)
+      end
+
+      def self.resolve_time(entities)
+        now = DateTime.now
+        resolved_date = nil
+        time = nil
+        entities.each do |entity|
+          next unless entity[:resolution]
+          case entity[:resolution][:resolution_type] || entity[:type]
+          when 'builtin.datetime'
+          when 'builtin.datetime.date'
+          when 'builtin.datetime.time'
+            time = entity[:resolution][:time]
+          when 'chronic.time'
+            duration = entity
+            time = entity[:resolution][:time]
+            resolved_date = duration[:resolution][:time]
+          end
+        end
+        date = now if !resolved_date && (date || time)
+        time
+      end
+
+      def self.recognize_time(utterance, reference_date = {})
+        time = Chronic.parse(utterance, reference_date)
+        return false unless time
+        {
+          type: 'chronic.time',
+          entity: time.to_s,
+          resolution: {
+            resolution_type: 'chronic.time',
+            time: time
+          }
+        }
+      end
+
+      def self.parse_number(entities)
+        entity = nil
+        entity = if entities.is_a? String
+                   { type: 'text', entity: entities.strip }
+                 else
+                   find_entity(entities, 'builtin.number')
+                 end
+
+        if entity
+          match = NUMBER_REGEX.match(entity[:entity])
+          return match[0] if match
+        end
+      end
+
+      def self.parse_boolean(utterance)
+        utterance.strip!
+        if YES_REGEX =~ utterance
+          true
+        elsif NO_REGX =~ utterance
+          false
+        end
+      end
+
+      def self.find_best_match(choices, utterance, threshhold = 0.6)
+        matches = find_all_matches(choices, utterance, threshhold)
+        matches.max { |entry| entry[:score] }
+      end
+
+      def self.find_all_matches(choices, utterance, threshold = 0.6)
+        matches = []
+        utterance = utterance.strip.downcase
+        tokens = utterance.split
+
+        expand_choices(choices).each_with_index do |choice, index|
+          score = 0.0
+          value = choice.strip.downcase
+          if value.include?(utterance)
+            score = utterance.size.to_f / value.size
+          elsif utterance.include? value
+            score = [0.5 + (value.size.to_f / utterance.size), 0.9].min
+          else
+            matched = ''
+            tokens.each { |token| matched += token if value.include? token }
+            score = matched.size / value.size
+          end
+          if score > threshold
+            matches.push(index: index, entity: choice, score: score)
+          end
+        end
+        matches
+      end
+
+      def self.expand_choices(choices)
+        case choices
+        when nil then []
+        when Array then choices.map(&:to_s)
+        when Hash then choices.keys.map(&:to_s)
+        when String then choices.split('|')
+        else [choices.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/bot_framework/dialogs/luis_recognizer.rb

@@ -0,0 +1,72 @@
+module BotFramework
+  module Dialogs
+    class LuisRecognizer
+      def initialize(models)
+        @models = { '*' => models }
+      end
+
+      def recognize(context)
+        result = { score: 0.0, intent: nil }
+        if context && context[:message] && context[:message][:text]
+          utterance = context[:message][:text]
+          locale = context[:locale] || '*'
+          model = @models[locale] || @models['*']
+          if model
+            LuisRecognizer.recognize(utterance, model) do |error, intents, entities|
+              if error
+                yield 'Error', nil
+              else
+                result[:intents] = intents
+                result[:entities] = entities
+
+                top = intents.max { |intent| intent[score] }
+                if top
+                  result[:score] = top[:score]
+                  result[:intent] = top[:intent]
+                  case top[:intent].downcase
+                  when 'builtin.intent.none'
+                  when 'none'
+                    result[:score] = 0.1
+                  end
+                end
+                yield nil, result
+              end
+              yield nil, result
+            end
+          else
+            yield StandardError.new("Luis model not found for locale #{locale}"), nil
+          end
+        else
+          yield nil, result
+        end
+      end
+
+      def self.recognize(utterance, model_uri)
+        uri = model_uri.strip
+        uri += '&q=' unless uri.end_with? '&q='
+        uri += URI.encode_www_form_component(utterance || '')
+        result = JSON.parse HTTParty.get(uri).body
+        # Symbolize keys
+        result = result.each_with_object({}) { |(k, v), temp| temp[k.to_sym] = v; temp }
+        result[:intents] ||= []
+        result[:entities] ||= []
+        if result[:topScoringIntent] && result[:intents].empty?
+          result[:intents] << result[:topScoringIntent]
+        end
+
+        if result[:intents].length == 1 && (result[:intents].first[:score].is_a? Numeric)
+          result[:intents].first[:score] = 1.0
+        end
+        # Symbolize keys
+        result[:intents].map! do |intent|
+          intent.each_with_object({}) { |(k, v), temp| temp[k.to_sym] = v; temp }
+        end
+
+        result[:entities].map! do |entity|
+          entity.each_with_object({}) { |(k, v), temp| temp[k.to_sym] = v; temp }
+        end
+        yield nil, result[:intents], result[:entities]
+      end
+    end
+  end
+end