bot_platform 0.1.0 → 0.2.0

data/lib/bot_platform/channels/web.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module BotPlatform::Channels
+  class Web
+    include Base
+
+    def channel_id
+      "web"
+    end
+
+    def match_request(headers,body)
+      false
+    end
+  end
+end

data/lib/bot_platform/channels/wechat.rb

@@ -0,0 +1 @@
+# frozen_string_literal: true

data/lib/bot_platform/channels.rb

@@ -0,0 +1,9 @@
+require_relative 'channels/base'
+require_relative 'channels/console'
+require_relative 'channels/lineworks'
+
+module BotPlatform
+  module Channels
+
+  end
+end

data/lib/bot_platform/cli.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'readline'
+require 'getoptlong'
+require 'singleton'
+
+module BotPlatform
+  class Cli
+    attr_accessor :bot_name, :user_name, :bot_id, :room_id, :bot_instance
+
+    def initialize(instance)
+      @bot_name = "bot"
+      @user_name = "user"
+      @bot_instance = instance
+      ENV['BOT_CHANNELS'] = 'console'
+      
+      Signal.trap(:INT) do
+        puts "\nbye."
+        exit 0
+      end
+    end
+
+    def run
+      puts welcome_message
+
+      opts = GetoptLong.new(
+        ['--name', GetoptLong::OPTIONAL_ARGUMENT]
+      )
+      opts.each do |opt, arg|
+        case opt
+        when '--name' then @bot_name = arg
+        end
+      end
+
+      while cmd = Readline.readline(prompt, true)
+        case cmd
+        when "exit", "quit", '\q' then
+          exit
+        when "help", '\h', '\?' then
+          puts help
+        when 'clear', '\c' then
+          system 'clear'
+        else # bot incoming activity
+          unless cmd.empty?
+            process cmd
+          end
+        end
+      end
+    end
+
+    def process(cmd)
+      headers = {"X-Bot-Platform-Bot":@bot_name}
+      body = {bot_id:@bot_id, room_id:@room_id}
+      if cmd.start_with? '/'
+        body[:type] = "cmd_back"
+        cmd.slice!(0)
+        body[:cmd] = cmd
+      else
+        body[:type] = "message"
+        body[:text] = cmd
+      end
+
+      instance = @bot_instance
+
+      BotPlatform::Adapter.instance.process_activity headers,body do |context|
+        instance.on_turn context
+      end
+
+    end
+
+    def prompt
+      return "#{@user_name}> "
+    end
+
+    def help
+      <<-USAGE
+usage:
+history
+exit, quit, \\q - close shell and exit
+help, \\h, \\? - print this usage
+clear, \\c - clear the terminal screen
+      USAGE
+    end
+
+    def welcome_message
+      <<-WELCOME
+Welcome to Bot Platform Command Line Interface (v0.1)
+       \\------/
+    _ [| o ω o|] _
+   / |==\\__-__/=| \\
+
+   powered by Ningfeng Yang
+         WELCOME
+    end
+  end
+end

data/lib/bot_platform/conversation_state.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  class ConversationState
+    include Singleton
+    attr_accessor :conversation
+
+
+    def initialize
+      user_id = turn_context.from.user_id
+      room_id = turn_context.from.room_id
+      key = "#{user_id}@#{room_id}"
+      user_state = MemoryStorage.instance.get(key) || {}
+      conversation_state = user_state[:conversation] || {}
+      user_state[:conversation] = conversation_state
+
+      MemoryStorage.instance.set(key, user_state)
+    end
+
+    def get(turn_context)
+      user_id = turn_context.from.user_id
+      room_id = turn_context.from.room_id
+      key = "#{user_id}@#{room_id}"
+
+      MemoryStorage.instance.get(key)[:conversation]
+    end
+
+    def set(context, key, value)
+      MemoryStorage.instance.get(context).set(key, value)
+    end
+  end
+end

data/lib/bot_platform/dialogs/dialog.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  module Dialogs
+    class Dialog
+      include BotPlatform::Asserts
+      END_OF_TURN = "end_of_turn".freeze
+
+      attr_reader :id
+
+      def initialize(dialog_id)
+        assert_dialog_id_is_valid dialog_id
+
+        @id = dialog_id
+      end
+
+      # abstract
+      # start the instance when ready
+      def start(dc)
+        raise "unimplemented"
+      end
+
+      # called after user has new activity
+      # params:
+      #   dc: DialogContext
+      def continue(dc)
+        # by default just stop the dialog
+        return dc.stop
+      end
+
+      # called after pre-dialog was poped
+      # params:
+      #   dc: DialogContext
+      def resume(dc, result)
+        # by default just stop the dialog
+        stop result
+      end
+
+      # not-implemented
+      def reprompt(turn_context, instance)
+      end
+
+      # called by #DialogContext#stop_active_dialog if need to stop dialog
+      def stop(result)
+      end
+    end
+  end
+end

data/lib/bot_platform/dialogs/dialog_context.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  module Dialogs
+    class DialogContext
+      include BotPlatform::Asserts
+
+      attr_accessor :dialogs, :turn_context, :dialog_stack
+
+      def initialize(dialogs, turn_context, dialog_state)
+        assert_dialog_set_is_valid dialogs
+        assert_turn_context_is_valid turn_context
+        assert_dialog_state_is_valid dialog_state
+
+        @dialogs = dialogs
+        @turn_context = turn_context
+        @dialog_stack = dialog_state.dialog_stack
+      end
+
+      def active_dialog
+        return nil if @dialog_stack.nil? || @dialog_stack.length==0
+        @dialog_stack.last
+      end
+
+      def start_dialog(dialog_id, options)
+        assert_dialog_id_is_valid dialog_id
+
+        dialog = @dialogs.find(dialog_id)
+        raise "dialog(id=#{dialog_id}) cannot be found." if dialog.nil?
+        dialog_instance = DialogInstance.new dialog_id
+        @dialog_stack.push dialog_instance
+
+        dialog.start self, options
+      end
+
+      def prompt(dialog_id, options)
+        assert_dialog_id_is_valid dialog_id
+        assert_is_not_empty options
+
+        start_dialog dialog_id, options
+      end
+
+      def continue_dialog
+        instance = active_dialog 
+        if instance != nil
+          dialog = @dialogs.find instance.dialog_id
+          if dialog
+            return dialog.continue self
+          end
+        end
+
+        return DialogResult.new :empty
+      end
+
+      def stop_dialog(result)
+        if @dialog_stack.any?
+          @dialog_stack.pop
+        end
+        dialog = active_dialog
+
+        #previous dialog
+        if dialog
+          dialog.resume self
+        else
+          return DialogResult.new :complete, result
+        end
+      end
+
+      # stop all dialogs in the stack
+      def stop_all
+        if @dialog_stack.any?
+          @dialog_stack.each do |dialog|
+            dialog.stop
+          end
+          @dialog_stack = []
+        end
+      end
+
+      # stop active dialog and start a new dialog by given
+      def replace_dialog(dialog_id, options)
+        unless active_dialog.nil?
+          @dialog_stack.pop
+        end
+
+        return start_dialog(dialog_id, options)
+      end
+
+      def reprompt
+        dialog = active_dialog
+        if dialog != nil
+          dialog.reprompt(turn_context)
+        end
+      end
+
+      def stop_active_dialog
+        dialog = active_dialog
+        if dialog != nil
+          dialog.stop
+          @dialog_stack.pop
+        end
+      end
+    end
+  end
+end

data/lib/bot_platform/dialogs/dialog_instance.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  module Dialogs
+    class DialogInstance
+      attr_reader :dialog_id
+      attr_accessor :state
+
+      def initialize(dialog_id)
+        @dialog_id = dialog_id
+        @state = {}
+      end
+    end
+  end
+end

data/lib/bot_platform/dialogs/dialog_result.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  module Dialogs
+    class DialogResult
+      STATUS_TYPES = {
+        :empty => 0,
+        :complete => 1,
+        :canceled => 2,
+      }
+
+      attr_reader :status, :result
+
+      def initialize(status, result=nil)
+        raise "invalid dialog result status" if !STATUS_TYPES.key?(status)
+
+        @status = status
+        @result = result
+      end
+    end
+  end
+end

data/lib/bot_platform/dialogs/dialog_set.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  module Dialogs
+    class DialogSet
+      include BotPlatform::Asserts
+
+      attr_accessor :dialogs, :dialog_state
+
+      def initialize()
+#        assert_dialog_state_is_not_null dialog_state
+#        @dialog_state = dialog_state
+        @dialog_state = BotPlatform::Dialogs::DialogState.new
+        @dialogs = {}
+      end
+
+      def add(dialog)
+        assert_dialog_is_valid dialog
+        assert_dialog_is_uniq @dialogs, dialog.id
+
+        @dialogs[dialog.id.to_sym] = dialog
+        return self
+      end
+
+      def create_dialog_context(turn_context)
+        assert_turn_context_is_valid turn_context
+
+        state = @dialog_state
+
+        return DialogContext.new self, turn_context, state
+      end
+
+      def find(dialog_id)
+        return @dialogs[dialog_id.to_sym]
+      end
+    end
+  end
+end

data/lib/bot_platform/dialogs/dialog_state.rb

@@ -0,0 +1,11 @@
+module BotPlatform
+  module Dialogs
+    class DialogState
+      attr_accessor :dialog_stack
+
+      def initialize
+        @dialog_stack = []
+      end
+    end
+  end
+end

data/lib/bot_platform/dialogs/prompts/prompt.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  module Dialogs
+    module Prompts
+      class Prompt < Dialog
+        attr_reader :validator
+
+        def initialize(dialog_id, validtor=nil)
+          super(dialog_id)
+          @validator = validator
+        end
+
+        def start(dc, options)
+          assert_dialog_context_is_valid dc
+          assert_prompt_options_is_valid options
+
+          state = dc.active_dialog.state
+          state[:options] = options
+          state[:state] = {}
+
+          on_prompt(dc.turn_context, state[:state], state[:options], false)
+          return BotPlatform::Dialogs::DialogResult.new :complete
+        end
+
+        def continue(dc)
+          assert_dialog_context_is_valid dc
+
+          if dc.turn_context.activity.type != BotPlatform::Activity::TYPES[:message]
+            # do nothing
+            return BotPlatform::Dialogs::DialogResult.new :complete
+          end
+
+          instance = dc.active_dialog
+          state = instance.state[:state]
+          options = instance.state[:options]
+
+          recognized = on_recognize(dc.turn_context, state, options)
+
+          is_valid = false
+
+          if !@validator.nil?
+            prompt_validator_ctx = PromptValidatorContext.new dc.turn_context, recognized, state, options
+            is_valid = @validator.send(prompt_validator_ctx)
+          elsif recognized.succeeded
+            is_valid = true
+          end
+
+          if is_valid
+            return dc.stop_dialog(recognized.value)
+          else
+            return on_prompt(dc.turn_context, state, options, true)
+          end
+        end
+
+        def resume(dc, result=null)
+          assert_dialog_context_is_valid dc
+
+          reprompt(dc.turn_context, dc.active_dialog)
+          return BotPlatform::Dialogs::DialogResult.new :complete
+        end
+
+        def repromp(ttx, instance)
+          assert_turn_context_is_valid ttx
+          assert_dialog_instance_is_valid instance
+
+          state = instace.state[:state]
+          options = instance.state[:options]
+
+          on_prompt(ttx, state, options, false)
+        end
+
+        def on_prompt(turn_context, state, options, is_retry)
+          raise "not implemented(abstrct in super)"
+        end
+
+        def on_recognize(turn_context, state, options, is_retry)
+          raise "not implemented(abstrct in super)"
+        end
+
+      end
+    end
+  end
+end