kogno 1.0.1

data/lib/core/lib/messenger/message.rb

@@ -0,0 +1,202 @@
+module Kogno
+module Messenger
+class Message < Kogno::Message
+
+  def initialize(data)
+    @data = data
+  end  
+
+  def platform
+    :messenger
+  end
+
+  def sender_id
+    return @data[:sender][:id]
+  end
+
+  def page_id
+    return @data[:recipient][:id]
+  end
+
+  def raw_payload
+    payload = @data[:postback][:payload] rescue nil
+    payload = (@data[:message][:quick_reply][:payload] rescue nil) if payload.nil?
+    payload = @overwritten_payload if payload.nil?
+    return(payload)
+  end
+
+  def stickers
+    @data[:message][:attachments].map{|a| a[:payload][:sticker_id]}.compact rescue []
+  end
+
+  def attachments
+    attachments = nil
+    attachments = @data[:message][:attachments] rescue nil
+    attachments
+  end
+
+  def referral(field=nil) # Field could be :context or :params)
+    referral = (@data[:postback][:referral] rescue nil)
+    referral = @data[:referral] if referral.nil?
+
+    if referral.nil? || referral == ""      
+      return nil
+    # elsif referral[:ref].nil? || referral[:ref] == ""  
+    #   return nil
+    elsif field.nil?
+      return referral
+    elsif field == :source
+      return referral[:source]
+    elsif field == :type
+      return referral[:type]
+    elsif field == :ref
+      return(referral[:ref] == "" ? nil : referral[:ref])
+    else
+      ref = (referral[:ref].split(Regexp.union(["/","-"]),2) rescue [])
+      if field == :context
+        return (ref[0] rescue nil)
+      elsif field == :params     
+        return digest_referral_params(ref[1])
+      else
+        return nil
+      end 
+    end
+
+  end
+
+  def digest_referral_params(params)    
+    dparams = {}
+    return dparams if params.nil?
+    dparams = (JSON.parse(params,{:symbolize_names => true}) rescue {})
+    if dparams.empty?
+      params.to_s.split(";").each do |param|
+        item = param.split(":")
+        if item.length > 1
+          dparams[item[0].to_sym] = item[1]
+        else
+          break
+        end  
+      end  
+    end
+    dparams = params if dparams.empty?
+    return dparams
+  end
+
+  def raw_message
+    m = @data[:message]
+    return nil if m.nil?
+    if !m[:text].nil?
+      return({
+        :type => :text,
+        :value => m[:text]
+      })
+    elsif !m[:attachments].nil?
+      m[:attachments].each do |attachment|
+        case attachment[:type]
+          when "location"
+            return({
+              :type => :location,
+              :value => {
+                :lat => attachment[:payload][:coordinates][:lat],
+                :lon => attachment[:payload][:coordinates][:long]
+              }
+            })
+        end
+      end
+    end
+  end
+
+  def text
+    if (self.raw_message[:type] == :text rescue false)
+      return self.raw_message[:value].to_s
+    else
+      return ""
+    end
+  end 
+
+  def get_context(user,msg,notification)
+
+    if !(context_from_postback = Context.get_from_payload(msg.payload)).nil?
+      context_route = context_from_postback
+    elsif !(context_in_link = Context.get(self.referral(:ref))).nil?
+      context_route = context_in_link[:context]
+      @data[:deep_link_param] = context_in_link[:param]
+    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)
+
+    begin
+
+      user = User.find_or_create_by_psid(self.sender_id, :messenger, self.page_id)
+      user.get_session_vars
+      self.set_nlp(user.locale)
+      I18n.locale = user.locale unless user.locale.nil?
+
+      unless user.vars[:nlp_context_ref].nil?
+        self.nlp.set_context_reference(user.vars[:nlp_context_ref])
+        user.vars.delete(:nlp_context_ref) # context references will only be used once
+      end
+
+      notification = Notification.new(user,self)
+
+      self.log_message_info(user)
+
+      context = get_context(user,self,notification)
+
+      return({msg: self, user: user, notification: notification, context: context}) if debug
+
+      unless empty_thread_from_ad?
+
+        called_action = context.run      
+        if Kogno::Application.config.store_log_in_database   
+          message_log_id = user.log_message(self).id
+        else
+          message_chat_log_id = 0
+        end     
+             
+        notification.send
+
+        response_log_id = 0
+        if Kogno::Application.config.store_log_in_database
+          response_log = user.log_response(notification)          
+          response_log_id = response_log.id unless response_log.nil?        
+        end  
+
+        # user.set_last_usage
+        user.save_session_vars
+        context.handle_message_from_memory
+
+      else
+        context.run_class_callbacks_only
+        user.save_session_vars
+        user.log_message(self) if Kogno::Application.config.store_log_in_database         
+      end
+      logger.write "- Current user context: #{user.context}", :blue unless user.context.nil?
+     
+    rescue StandardError => e
+      error_token = Digest::MD5.hexdigest("#{Time.now}#{rand(1000)}") # This helps to identify the error that arrives to Slack in order to search it in logs/http.log      
+      logger.write e.message, :red
+      logger.write "Error Token: #{error_token}", :red
+      logger.write "Backtrace:\n\t#{e.backtrace.join("\n\t")}", :red
+      ErrorHandler.notify_by_slack(Kogno::Application.config.app_name,e, error_token) if Kogno::Application.config.error_notifier.slack[:enable] rescue false
+    end
+
+  end
+
+end
+end
+end

data/lib/core/lib/messenger/notification.rb

@@ -0,0 +1,351 @@
+module Kogno
+module Messenger
+class Notification < Kogno::Notification
+
+  def set_context(context)
+    @context = context
+  end
+
+  def send(messaging_type="RESPONSE",recipient_id=nil,page_id=nil,delete=true)
+    recipient_id = @recipient.psid if recipient_id.nil?
+    page_id = @recipient.page_id if page_id.nil?
+    messages = @before_messages+@messages+@after_messages
+    @message_log = messages
+    messages.each do |message|
+      if message[:type].to_sym == :action
+        @response_log << Api::send_action(recipient_id,message[:value][:action],messaging_type,page_id)
+        sleep(message[:value][:duration]) if message[:value][:action].to_sym == :typing_on
+      else
+        message = self.replace_place_holders(message[:value])
+        @response_log << Api::send_message(recipient_id,message,messaging_type,page_id)
+      end
+    end    
+    self.delete_messages() if delete
+  end
+
+  def send_using_token()
+    notification_token = @recipient.messenger_recurring_notification.token rescue nil
+    if notification_token.nil?
+      logger.write "Error. The user doesn't have a messenger recurring notification token", :red
+      return false
+    end
+    page_id = @recipient.page_id if page_id.nil?
+    messages = @before_messages+@messages+@after_messages
+    @message_log = messages
+    messages.each do |message|
+      if message[:type].to_sym == :action
+        # @response_log << Api::send_action(recipient_id,message[:value][:action],messaging_type,page_id)
+        sleep(message[:value][:duration]) if message[:value][:action].to_sym == :typing_on
+      else
+        message = self.replace_place_holders(message[:value])
+        @response_log << Api::send_message_with_rn_token(notification_token,message,page_id)
+      end
+    end    
+    self.delete_messages()
+  end
+
+
+  # def schedule(send_at, tag=nil)
+  #   unless @recipient.nil?
+  #     @recipient.scheduled_messages.create({
+  #       messages: @messages.to_json,
+  #       tag: tag,
+  #       send_at: send_at
+  #     })
+  #     self.delete_messages()
+  #   end
+  # end
+
+  def send_private_reply(recipient_id=nil,page_id=nil,delete=true)
+    response = []
+    recipient_id = @recipient.psid if recipient_id.nil?
+    @message_log = @messages
+    @messages.each do |message|
+      message = self.replace_place_holders(message[:value])
+      @response_log << Api::send_private_reply(recipient_id,message,page_id)
+    end
+    self.delete_messages() if delete
+  end
+
+  def response_log
+    @response_log
+  end
+
+  def message_log
+    @message_log
+  end
+
+  def destroy_message_log
+    @message_log = []
+  end
+
+  def get_psid_from_response_log
+    return(@response_log.first[:recipient_id] rescue nil)
+  end
+  
+  def send_multiple(users,messaging_type)
+    logger.write "Sending..", :green
+    logger.write_json @messages, :bright
+    logger.write "To:", :green
+    users.each do |user|
+      logger.write "PSID: #{user[:psid]}", :bright
+      send(messaging_type,user[:psid],user[:page_id],false)
+    end
+    self.delete_messages()
+  end
+
+  def import_messages(messages,position="")
+    messages = messages.class == Array ? messages : JSON.parse(messages,{:symbolize_names => true})
+    case position.to_sym
+      when :before
+        @before_messages = messages
+      when :after
+        @after_messages = messages
+      else
+        @messages = messages
+    end
+  end
+
+  def export_messages
+
+    messages = @messages.to_json
+    self.delete_messages()
+    return messages
+
+  end
+
+  def delete_messages()
+    @before_messages = []
+    @messages = []
+    @after_messages = []
+  end
+
+  def text(text, extra_params={})
+    text = t(text) if text.class == Symbol
+    text = Notification::rand_text(text)
+    self.push_message(Api::text_message(text))
+  end
+
+  def loading_typing_on(recipient_id)
+    Api::send_action(recipient_id,:typing_on)
+  end
+
+  def loading_typing_off(recipient_id)
+    Api::send_action(recipient_id,:typing_off)
+  end
+
+  def typing_on(duration)
+    self.push_message({:action => :typing_on, :duration => duration}, :action)
+  end
+
+  def typing_off
+    self.push_message({:action => :typing_off}, :action)
+  end
+
+  def quick_reply(text,replies,extra_settings={})
+    settings = {typed_postbacks: Kogno::Application.config.typed_postbacks}.merge(extra_settings) # defaults
+    replies = [replies] if replies.class == Hash
+    replies = replies.map{|h| {content_type: :text}.merge(h)}
+    text = t(text) if text.class == Symbol
+    text = Notification::rand_text(text)
+    replies = replies.map{|r| {title: r[:title], payload: r[:payload], content_type: r[:content_type] || :text}} # :text as default
+    set_typed_postbacks(replies.map{|reply|
+      [reply[:title].to_payload, reply[:payload]] unless reply[:title].nil?
+    }.compact.to_h) if settings[:typed_postbacks]
+    self.push_message(Api::quick_replies(text, replies))
+  end
+
+  def button(text,buttons,extra_settings={})
+    settings = {typed_postbacks: Kogno::Application.config.typed_postbacks}.merge(extra_settings) # defaults
+    buttons = buttons.map{|h| {type: :postback}.merge(h)}
+    text = t(text) if text.class == Symbol
+    text = Notification::rand_text(text)
+    set_typed_postbacks(buttons.map{|button|
+      [button[:title].to_payload, button[:payload]] if button[:type] == :postback
+    }.compact.to_h) if settings[:typed_postbacks]
+    self.push_message(Api::button_template(text,buttons))
+  end
+
+  def messenger_generic_template(elements,image_aspect_ratio=:horizontal, quick_replies=[])
+    if quick_replies.empty?
+      message = Api::generic_template(elements,image_aspect_ratio)
+    else
+      quick_replies = [quick_replies] if quick_replies.class == Hash
+      quick_replies = quick_replies.map{|h| {content_type: :text}.merge(h)}
+      message = Api::generic_template_with_replies(elements,image_aspect_ratio, quick_replies)
+    end
+    self.push_message(message)  
+  end
+
+  def url(params)
+    params[:messenger_extensions] = false if params[:messenger_extensions].nil?
+    params[:image_aspect_ratio] = :horizontal if params[:image_aspect_ratio].nil?
+
+    ge_params = {
+      title: params[:title],
+      image_url: params[:image],
+      default_action: {
+        type: :web_url,
+        url: params[:url],
+        messenger_extensions: params[:messenger_extensions]
+      }
+    }
+
+    ge_params[:buttons] =  [
+      {
+        type: :web_url,
+        url: params[:url],
+        title: params[:button],
+        messenger_extensions: params[:messenger_extensions]
+      }
+    ] unless params[:button].nil?
+
+    self.messenger_generic_template(ge_params,params[:image_aspect_ratio])
+  end
+  
+
+  def carousel(elements, quick_replies=[], image_aspect_ratio=:horizontal)
+    elements = elements[0..9]
+    elements.map do |element| # sharing element: se va a enviar el mismo elemento con los modificadores agregados en :share_contents
+      unless element[:buttons].nil?
+        element[:buttons].map do |button|
+          if button[:type] == :element_share
+            share_element = Marshal.load(Marshal.dump(element))
+            share_element[:buttons].delete_if{|button| button[:type] == :element_share }
+            button[:share_contents] = Api::generic_template(share_element.merge(button[:share_contents]))
+          end
+        end
+      end
+    end
+
+    if quick_replies.empty?
+      message = Api::generic_template(elements,image_aspect_ratio)
+    else
+      message = Api::generic_template_with_replies(elements,image_aspect_ratio, quick_replies)
+    end
+    self.push_message(message)  
+  end
+
+  def recurring_notification_request(request)
+
+    attachment = {
+      type: :template,
+      payload: {
+        template_type: :notification_messages, 
+        title: request[:title],
+        notification_messages_frequency: request[:frequency].to_s.upcase,
+        notification_messages_reoptin: request[:reoptin] ? "ENABLED" : "DISABLED",
+      }
+    }
+
+    attachment[:payload][:image_url] = request[:image_url] unless request[:image_url].nil?
+    attachment[:payload][:payload] = request[:payload] unless request[:payload].nil?
+    attachment[:payload][:notification_messages_timezone] = request[:timezone] unless request[:timezone].nil?
+
+    self.push_message(Api.attachment_message(attachment))
+
+  end
+
+  def image(params)
+    params[:image_aspect_ratio] = :horizontal if params[:image_aspect_ratio].nil?
+
+    message = {
+      title: params[:caption],
+      image_url: params[:url]
+    }
+
+    quick_replies = []
+    quick_replies = params[:buttons] unless params[:buttons].nil?
+
+    self.messenger_generic_template(message,params[:image_aspect_ratio], quick_replies)
+
+  end
+
+  def video(params)
+
+    message = {
+      type: :template,
+      payload: {
+          template_type: :media,
+          elements: [
+            {
+                media_type: :video,
+                url: params[:url]
+            }
+         ]
+      }
+    } 
+
+    unless params[:buttons].nil?
+      buttons = params[:buttons].class == Hash ? [params[:buttons]] : params[:buttons]
+      buttons.map{|button| {type: :postback}.merge(button)}
+      message[:payload][:elements][0][:buttons] = buttons
+    end
+
+    Api::attachment_message(message)
+  end  
+
+  def set_vars(vars)
+    @vars = @vars.merge(vars)
+  end
+
+  def self.rand_text(text)    
+    if text.class == Array
+      return(text[rand(text.count)])
+    else
+      return(text)
+    end
+  end
+
+
+  def replace_place_holders(message)
+    message_in_json = message.to_json
+    @vars.each do |place_holder,replacement_value|
+     message_in_json = message_in_json.gsub(":::#{place_holder}:::",replacement_value.to_s)
+    end
+    JSON.parse(message_in_json)
+  end
+
+
+  def push_message(message,type=:message) # :message o :action
+    new_message = {:type => type, :value => message}
+    logger.debug_json new_message, :blue
+    @messages << new_message
+  end
+
+
+  def set_typed_postbacks(typed_postbacks)
+    @recipient.vars[:typed_postbacks] = {} if @recipient.vars[:typed_postbacks].nil?
+    @recipient.vars[:typed_postbacks] = @recipient.vars[:typed_postbacks].merge(typed_postbacks)
+  end
+
+  # Advanced responses.
+
+  # def opt_out(text, button_label)
+  #   self.quick_reply(
+  #     text,
+  #     [
+  #       {
+  #         :content_type => :text,
+  #         :title => button_label,
+  #         :payload => PAYLOADS[:opt_out]
+  #       }
+  #     ]
+  #   )
+  # end
+
+  def location_request(text) # Deprecated by Facebook
+    self.quick_reply(
+      text,
+      [
+        {
+          :content_type => :location
+        }
+      ],
+      {typed_postbacks: false}
+    )
+  end
+
+end
+end
+end

data/lib/core/lib/messenger/post_comment.rb

@@ -0,0 +1,104 @@
+module Kogno
+module Messenger
+class PostComment
+
+  attr_accessor :event
+
+  @overwritten_payload = nil
+
+  def initialize(data, page_id)
+    @data = data
+    @page_id = page_id
+  end
+
+  def type
+    :post_comment
+  end
+
+  def payload_action
+    nil
+  end
+
+  def sender_id
+    return(@data[:value][:from][:id] rescue nil)
+  end
+
+  def sender_name
+    return(@data[:value][:from][:name] rescue nil)
+  end
+
+  def post_id
+    return(@data[:value][:post_id] rescue nil)
+  end
+
+  def page_id
+    @page_id
+  end
+
+  def item_type
+    return(@data[:value][:item].to_sym rescue nil)
+  end
+
+  def text
+    return(@data[:value][:message] rescue "")
+  end
+ 
+  def comment_id
+    return(@data[:value][:comment_id] rescue nil)
+  end
+
+  def get_context(user,notification)
+    # Here you can use different contexts by self.post_id
+    context_class = Context::router(Kogno::Application.config.routes.post_comment)[:class]
+    context_route = nil
+    context = context_class.new(user,self,notification,context_route)
+    return(context)
+  end
+
+  def empty?
+    self.text.to_s.empty?
+  end
+
+  def handle_event(debug=false)
+
+    begin
+
+      user = User.new(last_usage_at: Time.now, vars:{})
+      self.set_nlp(user.locale)
+
+      notification = Notification.new(user,self)
+
+      logger.write "--------------------MESSAGE: #{self.text}--------------------------", :green
+
+      context = get_context(user,notification)
+
+      return({post_comment: self, user: user, notification: notification, context: context}) if debug
+
+      context.run_for_text_only
+
+      notification.send_private_reply(self.comment_id)
+
+      recipient_psid = notification.get_psid_from_response_log
+
+      user = User.find_or_create_by_psid(recipient_psid, :messenger, self.page_id, self.sender_id, false)
+
+      if Kogno::Application.config.store_log_in_database
+        user.log_message(self, :post_comment_received) 
+        user.log_response(notification)
+      end
+
+      logger.write "**********************#{user.context}***********************", :green
+     
+    rescue StandardError => e
+      error_token = Digest::MD5.hexdigest("#{Time.now}#{rand(1000)}") # This helps to identify the error that arrives to Slack in order to search it in logs/http.log      
+      logger.write e.message, :red
+      logger.write "Error Token: #{error_token}", :red
+      logger.write "Backtrace:\n\t#{e.backtrace.join("\n\t")}", :red
+      ErrorHandler.notify_by_slack(Kogno::Application.config.app_name,e, error_token) if Kogno::Application.config.error_notifier.slack[:enable] rescue false
+    end
+
+  end
+
+end
+end
+end