kogno 1.0.1

data/lib/core/lib/error_handler.rb

@@ -0,0 +1,36 @@
+require 'uri'
+require 'net/http'
+require 'openssl'
+
+module Kogno
+  class ErrorHandler
+    class << self
+
+      def notify_by_slack(username, error, token)
+        
+        error_message = %{```
+Error Message: #{error.message[0..256]}
+Error Token: #{token}
+Backtrace:#{error.backtrace.join("\n\t")[0..1024]}
+```}
+        
+        url = URI(Kogno::Application.config.error_notifier.slack[:webhook])
+        
+        http = Net::HTTP.new(url.host, url.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        
+        request = Net::HTTP::Post.new(url)
+        request["content-type"] = 'application/json'
+        request.body = {
+          username: username,
+          text: error_message
+        }.to_json
+        
+        response = http.request(request)
+        logger.write "-- This error was notified in Slack ---", :red
+      end
+
+    end
+  end
+end

data/lib/core/lib/message.rb

@@ -0,0 +1,182 @@
+module Kogno
+class Message
+
+  attr_accessor :event
+
+  @overwritten_payload = nil
+
+  def type
+    :message
+  end
+
+  def sender_id
+    0
+  end
+
+  def page_id
+    nil
+  end
+
+  def stickers
+    []
+  end
+
+  def attachments
+    []
+  end
+
+  def referral(field=nil)
+    nil
+  end
+
+  def deep_link_data
+    nil
+  end
+
+  def set_nlp(lang)
+    @nlp = Nlp.new(self.text,lang)
+  end 
+
+  def nlp
+    @nlp
+  end
+
+  def deep_link_param
+    @data[:deep_link_param] rescue nil
+  end
+
+  def webhook_data
+    @data
+  end
+
+  def overwrite_postback(payload)
+    @overwritten_payload = payload
+  end
+
+  def payload(action_only=false)
+    if action_only
+      pl = self.raw_payload.split(":",2)[0] rescue nil
+      if pl.nil?
+        return pl
+      else
+        return pl.split(Regexp.union(["/","-"])).last
+      end
+    else
+      self.raw_payload.split(":",2)[0] rescue nil
+    end
+  end
+
+  def payload_action
+    self.payload(true)
+  end
+
+  def postback_payload
+    self.payload(true)
+  end
+
+  def postback_params
+    self.params
+  end
+
+  # def event
+  #   JSON.parse(self.body,{:symbolize_names => true})
+  # end
+
+  def empty?
+    self.raw_payload.nil? && self.raw_message.nil? && self.attachments.nil?
+  end
+
+  def empty_thread_from_ad?
+    if self.empty?
+      unless self.referral.nil?
+        if self.referral(:source) == "ADS" and self.referral(:type) == "OPEN_THREAD"
+          return true
+        end
+      end
+    end    
+
+    return false  
+  end
+
+  def params
+    raw_params = self.raw_payload.to_s.split(":",2)[1].to_s
+    if raw_params.empty?
+      return({})
+    else  
+      p = (JSON.parse(raw_params, {:symbolize_names => true}) rescue nil)
+      p = raw_params if p.nil?
+      return(p)
+    end      
+  end
+
+   def raw_payload
+    # In order to implement in another platform, this function must exist
+    nil
+  end
+
+  def raw_message
+    # In order to implement in another platform, this function must exist
+    {}
+  end
+
+  def text
+    # In order to implement in another platform, this function must exist
+    ""
+  end
+
+  def numbers_in_text
+    # self.text.scan(/\d+/).map{|n| n.to_i}
+    self.text.scan(/(\d+(?:\.\d+)?)/).map{|n| n.first}
+  end
+
+  def location
+    if (self.raw_message[:type] == :location rescue false)
+      return self.raw_message[:value]
+    else
+      return nil
+    end
+  end
+
+  def get_context(user,msg,notification)
+
+    # Context::call_typed_postbacks(msg,user) if msg.payload.nil? && !user.vars[:typed_postbacks].nil?
+    # user.vars.delete(:typed_postbacks)
+    
+    if !(context_from_postback = Context.get_from_payload(msg.payload)).nil?
+      context_route = context_from_postback
+    elsif !(context_from_typed_postback = Context.get_from_typed_postback(msg,user)).nil?    
+      context_route = context_from_typed_postback
+    else
+      context_route = user.context      
+    end
+
+    context_class = Context.router(context_route, msg.type)[:class]
+    if context_class.nil?
+      user.exit_context
+      context_class = Context.router(Kogno::Application.config.routes.default)[:class]
+    end
+    context = context_class.new(user,msg,notification,context_route)
+    context
+  end
+
+
+  def handle_event(debug=false)
+    # In order to implement in another platform, this function must exist  
+  end
+
+  def log_message_info(user)
+    context = user.context
+    logger.write "\n-------- INCOMING MESSAGE -------", :yellow
+    logger.write "Text    : \"#{self.text}\"", :yellow
+    unless self.params.empty?
+      logger.write "Payload : #{self.payload} => params: #{self.params}", :yellow
+    else
+      logger.write "Payload : #{self.payload}", :yellow
+    end
+    logger.write "User ID : #{user.psid}", :yellow
+    logger.write "Context : #{(context.nil? || context.empty?) ? Kogno::Application.config.routes.default : context}", :yellow    
+    logger.write "---------------------------------\n", :yellow
+  end
+
+end
+end

data/lib/core/lib/messenger/api.rb

@@ -0,0 +1,281 @@
+module Kogno
+module Messenger
+class Api
+
+  require 'uri'
+  require 'net/http'
+  require 'json'
+  require 'openssl'
+
+  class << self
+
+    def request(body,access_token,type=:messages,method=:post) # :messages, :messenger_profile
+      url = URI("#{Kogno::Application.messenger.graph_url}/#{type}?access_token=#{access_token}")
+
+      logger.write "REQUEST TO: #{url}", :pink
+      logger.write "SENT: #{JSON.parse(body)}", :blue      
+
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      case method
+        when :delete
+          request = Net::HTTP::Delete.new(url)
+        else 
+          request = Net::HTTP::Post.new(url)
+      end    
+
+      request["content-type"] = 'application/json'
+
+      request.body = body
+
+      response = http.request(request)
+      # logger.debug_json JSON.parse(body), :green
+      response_hash = JSON.parse(response.read_body, {:symbolize_names => true})
+      logger.write "RESPONSE: #{response_hash}\n", :light_blue
+      return(response_hash)
+    end
+
+    def setting(body,page_id=nil)
+      access_token = self.get_access_token(page_id)
+      self.request(body,access_token,:messenger_profile)
+    end
+
+    def setting_delete(fields,page_id=nil)
+      access_token = self.get_access_token(page_id)
+      self.request({
+        fields: fields
+      }.to_json,access_token,:messenger_profile, :delete)
+    end
+
+    def send_message(recipient_psid,message,messaging_type="RESPONSE",page_id=nil)
+
+      body = {
+        messaging_type: messaging_type,
+        recipient: {
+          id: recipient_psid
+        },
+        message: message
+      }.to_json
+
+      access_token = self.get_access_token(page_id)
+      return(self.request(body,access_token))
+
+    end
+
+    def send_message_with_rn_token(notification_token,message,page_id=nil)
+
+      body = {
+        recipient: {
+          notification_messages_token: notification_token
+        },
+        message: message
+      }.to_json
+
+      access_token = self.get_access_token(page_id)
+      return(self.request(body,access_token))
+
+    end
+
+
+    def send_private_reply(recipient_id,message,page_id=nil)
+
+      body = {
+        :recipient => {
+          :comment_id => recipient_id
+        },
+        :message => message
+      }.to_json
+
+      access_token = self.get_access_token(page_id)
+      return(self.request(body,access_token))
+    end
+
+
+
+    def send_action(recipient_psid,action,messaging_type="RESPONSE",page_id=nil) # action => mark_seen, typing_on, typing_off
+      # body = %{{"recipient":{"id":"#{recipient_psid}"},"sender_action":"#{action}"}}
+      body = {
+        messaging_type: messaging_type,
+        recipient: {
+          id: recipient_psid
+        },
+        sender_action: action
+      }.to_json
+
+      access_token = self.get_access_token(page_id)
+      return(self.request(body,access_token))
+    end
+
+    def text_message(text)
+
+      {
+        :text => text
+      }
+      # return %{{"text":"#{text}"}}
+
+    end
+
+
+    def attachment_message(attachment)
+
+      {
+        attachment: attachment
+      }
+
+    end
+
+    def button_template(text,buttons)
+
+      attachment = {
+        type: :template,
+        payload: {
+          template_type: :button,
+          text: text,
+          buttons: buttons
+        }
+      }
+      return self.attachment_message(attachment)
+
+    end
+
+    def quick_replies(title,replies)
+
+      response = {
+        text: title,
+        quick_replies: replies
+      }
+
+      return response
+
+    end
+
+    def list_template(elements, buttons = [])
+      attachment = {
+        type: :template,
+        payload: {
+          template_type: :list,
+          top_element_style: :compact,
+          elements: elements,
+          buttons: buttons
+        }
+      }
+
+      return self.attachment_message(attachment)
+
+    end
+
+    def generic_template(elements,image_aspect_ratio=:horizontal)
+
+      elements = [elements] unless elements.class == Array
+
+      attachment = {
+        type: :template,
+        payload: {
+          template_type: :generic,
+          image_aspect_ratio: image_aspect_ratio,
+          elements: elements
+        }
+      }
+
+      return self.attachment_message(attachment)
+
+    end
+
+    def generic_template_with_replies(elements,image_aspect_ratio=:horizontal, quick_replies)
+      message = generic_template(elements,image_aspect_ratio=:horizontal)
+      message[:quick_replies] = quick_replies
+      return message
+    end
+
+    def show_ad_message(message)
+
+      JSON.pretty_generate(
+        {
+          message: message,
+          user_edit: true
+        }
+      )
+
+    end
+
+    def get_access_token(page_id=nil)
+
+      if page_id.nil?
+        Kogno::Application.messenger.pages.first[1][:token]
+      else
+        Kogno::Application.messenger.pages[page_id][:token] rescue nil
+      end
+
+    end
+
+    def persistent_menu(page_id=nil)
+      persistent_menu = Kogno::Application.messenger.persistent_menu
+      if persistent_menu.nil?
+        body = {
+          persistent_menu:[
+            {
+              locale: "default",
+              composer_input_disabled: false,
+            }
+          ]
+        }
+      else
+        body = {
+          persistent_menu: persistent_menu
+        }
+      end
+      logger.write_json body, :bright
+      self.setting(body.to_json, page_id)
+    end
+
+    def get_started_button(page_id=nil)
+      body = {
+        get_started: {
+          payload: Kogno::Application.messenger.welcome_screen_payload
+        }
+      }
+      logger.write_json body, :bright
+      self.setting(body.to_json, page_id)
+    end
+
+    def ice_breakers(page_id=nil)
+      body = {
+        ice_breakers: Kogno::Application.messenger.ice_breakers
+      }
+      logger.write_json body, :bright
+      self.setting(body.to_json, page_id)
+    end
+
+    def add_domain(domain)
+      body = {
+        whitelisted_domains: [
+          domain
+        ]
+      }
+      logger.write_json body, :bright
+      self.setting(body.to_json)
+    end
+
+    def update_whitelisted_domains
+      body = {
+        whitelisted_domains: Kogno::Application.messenger.whitelisted_domains
+      }
+      logger.write_json body, :bright
+      self.setting(body.to_json)
+    end
+    
+    def greeting(page_id=nil)
+      body = {
+        greeting: Kogno::Application.messenger.greeting
+      }
+      logger.write_json body, :bright
+      self.setting(body.to_json, page_id)
+    end
+
+  end
+
+end
+end
+end

data/lib/core/lib/messenger/facebook_graph.rb

@@ -0,0 +1,32 @@
+require 'uri'
+require 'net/http'
+require 'openssl'
+
+module Kogno
+class FacebookGraph
+  class << self
+
+    def fetch_user_data(psid,page_id=nil)
+      url = URI("https://graph.facebook.com/v3.3/#{psid}/?access_token=#{self.get_access_token(page_id)}&fields=name,first_name,last_name,timezone,locale,profile_pic")
+      puts url
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      request = Net::HTTP::Get.new(url)
+      response = http.request(request)
+      return(JSON.parse(response.read_body, {:symbolize_names => true}))
+    end
+
+    def get_access_token(page_id=nil)
+      if page_id.nil?
+        Kogno::Application.messenger.pages.first[1][:token]
+      else
+        Kogno::Application.messenger.pages[page_id][:token] rescue nil
+      end
+    end    
+
+  end  
+
+
+end
+end