sinbotra 0.1.6 → 0.2.0

data/lib/sinbotra/bot/user_store.rb

@@ -0,0 +1,7 @@
+class Sinbotra::Bot
+  class UserStore < RedisStore
+    def make_key(id)
+      ["sinbotra", "users", id].join(":")
+    end
+  end
+end

data/lib/sinbotra/message_handler.rb

@@ -0,0 +1,26 @@
+class Sinbotra::MessageHandler
+  class << self
+    attr_reader :handlers
+
+    def add_handler(provider, handler)
+      @handlers ||= {}
+      @handlers[provider] = handler
+    end
+  end
+
+  attr_reader :provider
+
+  def initialize(provider, async=true)
+    @provider = provider
+    @is_async = async
+  end
+
+  def receive_messages(messages)
+    messages.each do |msg|
+      bot = handler_class.new(msg)
+      bot.respond
+    end
+  end
+
+  def handler_class; self.class.handlers[@provider]; end
+end

data/lib/sinbotra/message_store.rb

@@ -0,0 +1,21 @@
+require "json"
+
+module Sinbotra
+  class MessageStore
+    def self.log_in_message!(provider, message, sender)
+      timestamp = Time.now
+      m = { sender: :user, timestamp: timestamp.to_i, message: message.to_json}.to_json
+      $redis.lpush(key(provider, sender.id), m)
+    end
+
+    def self.log_out_message!(provider, message, receiver)
+      timestamp = Time.now
+      m = { sender: :bot, timestamp: timestamp.to_i, message: message.to_json}.to_json
+      $redis.lpush(key(provider, receiver.id), m)
+    end
+
+    def self.key(provider, user_id)
+      ["sinbotra", "messages", user_id.to_s, provider].join(":")
+    end
+  end
+end

data/lib/sinbotra/messenger.rb

@@ -1,4 +1,5 @@
+require "sinbotra/messenger/platform"
 require "sinbotra/messenger/bot"
-require "sinbotra/messenger/handler"
 require "sinbotra/messenger/message"
-require "sinbotra/messenger/user"
+require "sinbotra/messenger/message_presenter"
+require "sinbotra/messenger/user_presenter"

data/lib/sinbotra/messenger/bot.rb

@@ -1,91 +1,142 @@
 module Sinbotra::Messenger
   class Bot
-    attr_reader :current_user
+    GET_STARTED_ID = "GET_STARTED"
 
-    def initialize(user)
-      @current_user = user
-    end
+    class << self
+      attr_reader :_listeners, :_default_listener, :_conversations, :_dont_understand_phrases, :get_started_method
 
-    def say(text)
-      client.text(
-        recipient_id: recipient_id,
-        text: text
-      )
-    end
-    alias_method :text, :say
+      Listener     = Struct.new(:matcher, :method_name)
+      Conversation = Struct.new(:id, :klass)
+
+      def get_started(method_name)
+        @get_started_method = method_name
+        Sinbotra::Messenger::Platform.get_started(GET_STARTED_ID)
+      end
 
-    def quick_replies(text, replies)
-      client.qr(
-        recipient_id: recipient_id,
-        text:         text,
-        replies:      replies
-      )
+      def listeners(methods)
+        @_listeners = methods.map { |name, matcher| Listener.new(matcher, name) }
+      end
+
+      def default_listener(listener)
+        @_default_listener = listener
+      end
+
+      def conversations(conversation_map)
+        c = conversation_map.each_with_object({}) { |(id, klass), h|
+          h[id] = Conversation.new(id, klass)
+        }
+        @_conversations = c
+      end
+
+      def dont_understand_phrases(phrases)
+        @_dont_understand_phrases = phrases
+      end
     end
 
-    def typing(seconds=0, &blk)
-      client.typing(recipient_id: recipient_id, seconds: seconds, &blk)
+    attr_reader :current_user
+    attr_reader :message
+    attr_reader :platform
+    attr_reader :get_started_method
+
+    def listeners;          self.class._listeners;         end
+    def default_listener;   self.class._default_listener;  end
+    def conversations;      self.class._conversations;     end
+    def get_started_method; self.class.get_started_method; end
+
+    include Sinbotra::Messenger
+
+    def initialize(message)
+      @current_user = UserPresenter.new(message.sender)
+      @message      = MessagePresenter.new(message)
+      @platform     = Platform.new(@current_user.id)
+      @phrases      = setup_phrases
+      log_message!
     end
 
-    def qr(text, postback=nil)
-      MessengerClient::QuickReply.new(text, postback)
+    def respond
+      $logger.debug("Responding...")
+      in_conversation? ? send_to_conversation! : send_to_listeners!
     end
 
-    def payload_button(text, payload)
-      MessengerClient::PayloadButton.new(text, payload)
+    def in_conversation?; current_user.in_conversation?; end
+
+    def start_conversation(convo_id)
+      current_user.start_conversation(convo_id)
+      convo = make_conversation(convo_id)
+      $logger.debug("Start Conversation: #{convo}")
+      convo.start
     end
-    def url_button(text, url)
-      MessengerClient::URLButton.new(text, url)
+
+    def make_conversation(convo_id)
+      convo = conversations[convo_id]
+      convo.klass.new(self, platform)
     end
 
-    def generic_template(title, subtitle, image, link, buttons)
+    def send_to_conversation!
+      $logger.debug("Send message to conversation")
+      id    = current_user.conversation.id
+      convo = make_conversation(id)
+      convo.continue_dialogue
     end
 
-    def text_with_buttons(text, buttons)
-      client.button_template(
-        recipient_id: recipient_id,
-        text:         text,
-        buttons:      buttons
-      )
+    def send_to_listeners!
+      $logger.debug("Send message through handler stack")
+      listener = listeners.find { |l| matches_message?(l) }
+      if listener.nil?
+        get_started_message? ? handle_get_started! : handle_default!
+      else
+        send(listener.method_name, message)
+      end
     end
 
-    def video(url)
-      client.video(recipient_id: recipient_id, url: url)
+    def get_started_message?
+      pb = message.postback
+      pb.to_s == self.class::GET_STARTED_ID
     end
 
-    def image(url)
-      client.image(recipient_id: recipient_id, url: url)
+    def handle_get_started!
+      send(get_started_method, message)
     end
 
-    def location
-      client.location(recipient_id: recipient_id)
+    def handle_default!
+      send(default_listener, message)
     end
 
-    def current_message
-      current_user.current_message
+    def has_conversation?(intent)
+      # TODO: Figure this out ;)
+      false
     end
 
-    def start_conversation(convo_id)
-      convo = find_convo(convo_id)
-      current_user.start_conversation(convo)
-      convo.perform_current_step(self)
+    def get_intent(msg)
+      # TODO: Send msg to NLP API
     end
 
-    def has_conversation?(convo_id)
-      !!find_convo(convo_id)
+    def next_dont_understand_phrase
+      return "I don't understand" unless @phrases.any?
+      @phrase_index ||= 0
+      phrase = @phrases[@phrase_index % @phrases.size]
+      @phrase_index += 1
+      phrase
     end
 
     private
 
-    def client
-      @client ||= MessengerClient::Client.new(ENV.fetch("FACEBOOK_PAGE_TOKEN"))
+    def matches_message?(listener)
+      if txt = message.text
+        return true if txt.match(listener.matcher)
+      elsif pb = message.postback
+        return true if pb.to_s.match(listener.matcher)
+      end
+      return false
     end
 
-    def recipient_id
-      current_user.id
+    def setup_phrases
+      phrases = self.class._dont_understand_phrases || []
+      phrases.shuffle
     end
 
-    def find_convo(convo_id)
-      Sinbotra::Bot::ConversationRepo.find(convo_id)
+    def log_message!
+      Sinbotra::MessageStore.log_in_message!(:facebook, message, message.sender)
     end
   end
 end

data/lib/sinbotra/messenger/message.rb

@@ -1,57 +1,18 @@
 module Sinbotra::Messenger
   class Message
-    Sender   = Struct.new(:id)
-    Location = Struct.new(:title, :url, :lat, :lng)
-
-    def self.load(msg)
-      new(msg).parse
-    end
-
-    attr_reader :id
-    attr_reader :timestamp
-    attr_reader :sender
-    attr_reader :postback
-    attr_reader :text
-    attr_reader :location
-
-    def initialize(msg)
-      @raw_message = msg
-    end
-
-    def parse
-      parse_message
-      self
-    end
-
-    def postback?
-      !!postback
+    class Base < Struct
+      def postback; respond_to?(:_postback) ? _postback : nil; end
+      def text;     respond_to?(:_text)     ? _text     : nil; end
     end
 
-    private
-
-    def parse_message
-      @timestamp = @raw_message["timestamp"]
-      @sender    = Sender.new(@raw_message["sender"]["id"])
-      if pb = @raw_message["postback"]
-        # From button postback
-        @postback = pb["payload"].to_sym if pb["payload"]
-      elsif msg = @raw_message["message"]
-        # Message or quick reply (or location)
-        @text = msg["text"]
-        @id   = msg["id"]
-        if qr = msg["quick_reply"]
-          # Is quick reply
-          @postback = qr["payload"].to_sym if qr["payload"]
-        end
-        attch = msg["attachments"]
-        if !attch.nil? && attch["type"] == "location"
-          # Is location
-          coords = attch["payload"]["coordinates"]
-          @location = Location.new(attch["title"], attch["url"], coords.first, coords.last)
-        end
-      else
-        raise ArgumentError, "Dunno what this message is about: #{message.to_s}"
-      end
-    end
+    Sender     = Base.new(:id)
+    Text       = Base.new(:id, :timestamp, :sender, :_text)
+    Image      = Base.new(:id, :timestamp, :sender, :url, :sticker_id)
+    Video      = Base.new(:id, :timestamp, :sender, :url)
+    Audio      = Base.new(:id, :timestamp, :sender, :url)
+    File       = Base.new(:id, :timestamp, :sender, :url)
+    Location   = Base.new(:id, :timestamp, :sender, :url, :lat, :lng)
+    QuickReply = Base.new(:id, :timestamp, :sender, :_postback, :_text)
+    Postback   = Base.new(:timestamp, :sender, :_postback)
   end
 end

data/lib/sinbotra/messenger/message_presenter.rb

@@ -0,0 +1,6 @@
+require "delegate"
+
+module Sinbotra::Messenger
+  class MessagePresenter < SimpleDelegator
+  end
+end

data/lib/sinbotra/messenger/middleware/facebook_signature.rb

@@ -0,0 +1,32 @@
+require "openssl"
+
+module Sinbotra::Messenger::Middleware
+  class FacebookSignature
+    def initialize(app)
+      raise ArgumentError, "You need to set a FACEBOOK_PAGE_TOKEN environmental variable to run the server!" unless ENV["FACEBOOK_PAGE_TOKEN"]
+      raise ArgumentError, "You need to set a FACEBOOK_APP_SECRET environmental variable to run the server!" unless ENV["FACEBOOK_APP_SECRET"]
+      @app = app
+    end
+
+    def call(env)
+      req = Rack::Request.new(env)
+      return @app.call(env) unless req.post?
+
+      payload = req.body.read
+      unless signature_valid?(payload, env)
+        return Rack::Response.new([], 401, {}).finish
+      end
+      @app.call(env)
+    end
+
+    def signature_valid?(payload_body, env)
+      digest = OpenSSL::HMAC.hexdigest(
+        OpenSSL::Digest.new("sha1"),
+        ENV["FACEBOOK_APP_SECRET"],
+        payload_body
+      )
+      signature = "sha1=" + digest
+      Rack::Utils.secure_compare(signature, env["HTTP_X_HUB_SIGNATURE"])
+    end
+  end
+end

data/lib/sinbotra/messenger/middleware/parse_message.rb

@@ -0,0 +1,81 @@
+module Sinbotra::Messenger::Middleware
+  class ParseMessage
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      req = Rack::Request.new(env)
+      return @app.call(env) unless req.post?
+      data = json(req)
+      env["facebook.messages"] = parse_messages(data)
+      @app.call(env)
+    end
+
+    private
+
+    def parse_messages(data)
+      $logger.debug("Data: #{data}")
+      e = data["entry"].first
+      e["messaging"].map { |message|
+        parse_message(message)
+      }.compact
+    end
+
+    def parse_message(message)
+      sender = Sinbotra::Messenger::Message::Sender.new(message["sender"]["id"])
+      timestamp = message["timestamp"]
+      m = message["message"]
+      if m.nil?
+        return parse_postback(message, timestamp, sender)
+      end
+      if attchs = m["attachments"]
+        attch = attchs.first
+        pl    = attch["payload"]
+        url   = pl["url"]
+        case attch["type"]
+        when "image"
+          Sinbotra::Messenger::Message::Image.new(m["mid"], timestamp, sender, url, pl["sticker_id"])
+        when "video"
+          Sinbotra::Messenger::Message::Video.new(m["mid"], timestamp, sender, url)
+        when "audio"
+          Sinbotra::Messenger::Message::Audio.new(m["mid"], timestamp, sender, url)
+        when "file"
+          Sinbotra::Messenger::Message::File.new(m["mid"], timestamp, sender, url)
+        when "location"
+          url = attch["url"]
+          lat, lng = pl["coordinates"]["lat"], pl["coordinates"]["long"]
+          Sinbotra::Messenger::Message::Location.new(m["mid"], timestamp, sender, url, lat, lng)
+        else
+        end
+      else
+        parse_non_media(m, timestamp, sender)
+      end
+    end
+
+    def parse_non_media(message, timestamp, sender)
+      if qr = message["quick_reply"]
+        payload = qr["payload"].to_sym
+        return Sinbotra::Messenger::Message::QuickReply.new(message["mid"], timestamp, sender, payload, message["text"])
+      end
+      if txt = message["text"]
+        return Sinbotra::Messenger::Message::Text.new(message["mid"], timestamp, sender, txt)
+      end
+      return nil
+    end
+
+    def parse_postback(message, timestamp, sender)
+      if pb = message["postback"]
+        payload = pb["payload"].to_sym
+        return Sinbotra::Messenger::Message::Postback.new(timestamp, sender, payload)
+      end
+      return nil
+    end
+
+    def json(req)
+      req.body.rewind
+      body = req.body.read
+      JSON.load(body)
+    end
+  end
+end