bot_platform 0.1.0 → 0.2.3

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

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  module Dialogs
+    module Prompts
+      class PromptOptions
+        attr_accessor :prompt, :retry_prompt, :choices, :validations
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  module Dialogs
+    module Prompts
+      class PromptRecognizerResult
+        attr_accessor :succeeded, :value
+
+        def initialize
+          @succeeded = false
+          @value = nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  module Dialogs
+    module Prompts
+      class TextPrompt < Prompt
+        def on_prompt(ctx, state, options, is_retry)
+          assert_turn_context_is_valid ctx
+          #assert_dialog_instance_state_is_valid state
+          assert_prompt_options_is_valid options
+
+          if is_retry && !options.retry_prompt.nil?
+            ctx.send_activity options.retry_prompt
+          else
+            ctx.send_activity options.prompt
+          end
+        end
+
+        def on_recognize(ctx, state, options)
+          assert_turn_context_is_valid ctx
+
+          result = PromptRecognizerResult.new
+          if ctx.activity.type == BotPlatform::Activity::TYPES[:message]
+            message = ctx.activity.text
+            unless message.nil? || message.empty?
+              result.succeeded = true
+              result.value = message
+            end
+          end
+
+          return result
+        end
+      end
+    end
+  end
+end

data/lib/bot_platform/dialogs.rb

@@ -0,0 +1,17 @@
+require_relative 'dialogs/dialog'
+require_relative 'dialogs/dialog_context'
+require_relative 'dialogs/dialog_instance'
+require_relative 'dialogs/dialog_result'
+require_relative 'dialogs/dialog_set'
+require_relative 'dialogs/dialog_state'
+
+require_relative 'dialogs/prompts/prompt'
+require_relative 'dialogs/prompts/prompt_options'
+require_relative 'dialogs/prompts/text_prompt'
+require_relative 'dialogs/prompts/prompt_recognizer_result'
+
+module BotPlatform
+  module Dialogs
+
+  end
+end

data/lib/bot_platform/message_factory.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  class MessageFactory
+    def self.Text(text)
+      return Activity.new Activity::TYPES[:message], {text: text}
+    end
+  end
+end

data/lib/bot_platform/state/bot_state.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  module State
+    class BotState
+      include BotPlatform::Asserts
+
+      attr_accessor :storage, :service_key
+      def initialize(storage, service_key)
+        @storage = storage
+        @service_key = service_key
+      end
+
+      def save_changes(turn_context, force=false)
+        assert_turn_context_is_valid turn_context
+
+        #TODO:
+      end
+    end
+  end
+end

data/lib/bot_platform/state/conversation_state.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  module State
+    class ConversationState < BotState
+      def initialize(storage)
+        super(storage, "conversation_state")
+      end
+
+      def get_storage_key(turn_context)
+        channel_id = turn_context.activity.channel_id
+        conversation_id = turn_context.conversation.id
+        "#{channel_id}/conversations/#{conversation_id}"
+      end
+    end
+  end
+end

data/lib/bot_platform/state/user_state.rb

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

data/lib/bot_platform/storage/memory_storage.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module BotPlatform
+  module Storage
+    class MemoryStorage
+      include Singleton
+      include Storageable
+
+      attr_accessor :data, :locker
+
+      def initialize
+        @locker = Mutex::new
+        @data = {}
+      end
+
+      def read(keys)
+        new_hash = {}
+        @locker.synchronize do
+          keys.each do |key|
+            if @data.key?(key)
+              k = key.to_sym
+              new_hash[k] = @data[k]
+            end
+          end
+        end
+        return new_hash
+      end
+
+      def write(changes)
+        @locker.synchronize do
+          changes.each do |change|
+            @data[change.key.to_sym] = change.value
+          end
+        end
+      end
+
+      def getState(context)
+        user_id = context.from[:user_id]
+        room_id = context.from[:room_id] || ""
+        # FIXME: room_id appear and disappear
+        #key = "#{user_id}@#{room_id}"
+        key = "#{user_id}".intern
+        @data[key] = ConversationState.new(key) if @data[key].nil?
+        return @data[key]
+      end
+    end
+
+  end
+end

data/lib/bot_platform/storage/mysql_storage.rb

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

data/lib/bot_platform/storage/redis_storage.rb

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

data/lib/bot_platform/storage/storageable.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  module Storage
+    module Storageable
+      attr_accessor :data, :_user_state, :coversation_state, :dialog_state
+
+      def set(key, value, exipred=false)
+      end
+
+      def get(key)
+      end
+
+      def del(key)
+      end
+
+      def read(keys)
+      end
+
+      def write(changes)
+      end
+
+      def user_state
+        get(:_user_state)
+      end
+
+      def user_state=(state)
+        set(:_user_state, state)
+      end
+
+    end
+  end
+end

data/lib/bot_platform/turn_context.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module BotPlatform
+  class TurnContext
+    include Asserts
+
+    attr_reader :adpter, #元のアダプター情報
+      :activity, # ユーザーからの要求(incoming)
+      :channel_id,
+      :from
+
+    attr_accessor :state, #コンテキストに登録されたサービスを保持
+      :responded, # 応答済フラグ
+      :locale,
+      :buffered_reply_activities,
+      :turn_state, # コンテキストに登録されたサービスを保持
+      :_on_send_activities,
+      :_on_update_activities,
+      :_on_delete_activities
+
+    def initialize(adapter, activity)
+      @adapter = adapter
+      @activity = activity # incoming activity
+      @from = activity.from
+      @channel_id = activity.channel_id
+      @responded = false
+      @locale = "ja"
+      @_on_send_activities = []
+      @_on_update_activities = []
+      @_on_delete_activities = []
+
+    end
+
+    def add_on_send_activities(activity_handler)
+      @_on_send_activities << activity_handler
+      self
+    end
+
+    def add_on_update_activities(activity_handler)
+      @_on_update_activities << activity_handler
+      self
+    end
+
+    def add_on_delete_activits(activity_handler)
+      @_on_delete_activities << activity_handler
+      self
+    end
+
+    def self.dup_context(context, activity)
+      ctx = TurnContext.new context.adapter, activity
+      ctx.state = context.state
+      ctx.responded = context.responded
+      if context.is_a?(TurnContext)
+        ctx.buffered_reply_activities = context.buffered_reply_activities
+        # keep private middleware pipeline hooks.
+        ctx._on_send_activities = context._on_send_activities
+        ctx._on_update_activity = context._on_update_activity
+        ctx._on_delete_activity = context._on_delete_activity
+      end
+      return ctx
+    end
+
+    def send_message(text)
+      activity_to_send = Activity.new(Activity::TYPES[:message], {text: text})
+      send_activity(activity_to_send)
+    end
+
+    def send_confirm(text,prefix="")
+      activity_to_send = Activity.new(Activity::TYPES[:confirm], {text: text, prefix: prefix})
+      send_activity(activity_to_send)
+    end
+
+    def send_options(caption, prefix, options)
+      activity_to_send = Activity.new(Activity::TYPES[:options], {text: caption, options: options, prefix: prefix})
+      send_activity(activity_to_send)
+    end
+
+    def send_image(preview_url, resource_url)
+      activity_to_send = Activity.new(Activity::TYPES[:image], {resource_url: resource_url, preview_url: preview_url})
+      send_activity(activity_to_send)
+    end
+
+    def send_content(content)
+      activity_to_send = Activity.new(Activity::TYPES[:carousel], {
+        content: content, to: @activity.from
+      })
+      send_activity(activity_to_send)
+    end
+
+    def send_activity(activity)
+      activity.to = @activity.from
+      send_activities([activity])
+    end
+
+    # Sends a set of activities to the sender of the incoming activity.
+    def send_activities(activities)
+      assert_activity_is_not_null activities
+      assert_activity_is_not_null activities[0]
+
+      @adapter.send_activities(self, activities)
+    end
+
+
+  end
+end

data/lib/bot_platform/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BotPlatform
-  VERSION = "0.1.0"
+  VERSION = "0.2.3"
 end

data/lib/bot_platform.rb

@@ -1,6 +1,17 @@
 # frozen_string_literal: true
 
 require_relative "bot_platform/version"
+require_relative "bot_platform/activity"
+require_relative "bot_platform/adapter"
+require_relative "bot_platform/asserts"
+require_relative "bot_platform/message_factory"
+require_relative "bot_platform/turn_context"
+require_relative "bot_platform/channels"
+require_relative "bot_platform/dialogs"
+require_relative "bot_platform/storage/storageable"
+require_relative "bot_platform/storage/memory_storage"
+require_relative "bot_platform/state/bot_state"
+require_relative "bot_platform/state/conversation_state"
 
 module BotPlatform
   class Error < StandardError; end