kogno 1.0.1

data/lib/core/lib/messenger/recurring_notification.rb

@@ -0,0 +1,81 @@
+module Kogno
+module Messenger
+class RecurringNotification < Kogno::Message
+
+  attr_accessor :event
+  attr_accessor :nlp
+
+  @overwritten_payload = nil
+
+  def initialize(data)
+    @data = data
+    @page_id = page_id
+  end
+
+  def type
+    :recurring_notification
+  end
+
+  def sender_id
+    return @data[:sender][:id]
+  end
+
+  def page_id
+    return @data[:recipient][:id]
+  end
+
+  def raw_payload
+    payload = @data[:optin][:payload] rescue nil
+    return(payload)
+  end
+
+  def notification_messages_status
+    if @data[:optin][:notification_messages_status] == "STOP_NOTIFICATIONS"
+      :stopped
+    else
+      :active
+    end
+  end
+
+  def get_context(user,notification)
+    # Here you can use different contexts by self.post_id
+    context_class = Context::router(Kogno::Application.config.routes.recurring_notification)[:class]
+    context = context_class.new(user,self,notification,nil)
+    return(context)
+  end
+
+  def handle_event(debug=false)
+  
+    begin
+
+      user = User.find_or_create_by_psid(self.sender_id, :messenger, self.page_id)
+      user.update_messenger_recurring_notification(@data[:optin])
+      user.get_session_vars
+      self.set_nlp(user.locale)
+      I18n.locale = user.locale unless user.locale.nil?
+
+      notification = Notification.new(user,self)
+
+      context = get_context(user,notification)
+      context.run_for_recurring_notification_only
+
+      notification.send
+
+      if Kogno::Application.config.store_log_in_database
+        user.log_message(self, :recurring_notifications) 
+        user.log_response(notification)
+      end
+     
+    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/nlp.rb

@@ -0,0 +1,191 @@
+require 'wit'
+module Kogno
+class Nlp
+
+  attr_accessor :wit, :intents, :entities, :traits, :processed, :phrase, :context_reference
+
+  def initialize(phrase=nil,locale=:en, context_reference=nil)
+    self.wit = Wit.new(access_token: Nlp.get_wit_token(locale), api_version: Kogno::Application.config.nlp.wit[:api_version])
+    self.processed = false
+    self.phrase = phrase
+    self.context_reference = context_reference
+    self.entities = {}
+  end
+
+  def self.get_wit_token(locale)
+    tokens = Kogno::Application.config.nlp.wit[:apps]
+    if !locale.nil? and !tokens[locale.to_sym].nil?
+      return tokens[locale.to_sym]
+    else # Hash      
+      return tokens[:default]
+    end
+  end
+
+  def set_context_reference(context_reference)
+    self.context_reference = context_reference
+  end
+
+  def process_phrase(phrase=nil, context_reference=nil)
+    if !Kogno::Application.config.nlp.wit[:enable]
+      logger.write "NLP Service is not enabled in config/initializers/nlp.rb", :red
+      return false
+    end
+
+    wit_tries = 0
+
+    phrase = phrase.nil? ? self.phrase : phrase
+    context_reference = context_reference.nil? ? self.context_reference : context_reference
+
+    self.processed = true
+    if phrase.nil? or phrase.empty?
+      {}
+    elsif phrase.length > 256
+      {}  
+    else
+
+      phrase = Spelling::correction(phrase)
+      # logger.write "-----", :red
+      # logger.write phrase, :red
+
+      wit_output = nil
+      loop do
+        wit_output = self.wit.message_with_context(phrase, context_reference) rescue :error
+        break if wit_output != :error || wit_tries == 3
+        logger.debug "Wit error!!!", :red
+        wit_tries+=1
+        sleep(1)
+      end
+
+      self.intents = wit_output["intents"].deep_symbolize_keys! rescue {}
+      self.entities = wit_output["entities"].deep_symbolize_keys! rescue {}
+      self.traits = wit_output["traits"].deep_symbolize_keys! rescue {}
+
+      logger.debug "  NLP RESOLVED VALUES => #{wit_output}", :light_blue
+
+      self.add_pre_processed_entities()
+    end
+
+  end
+
+  def process_phrase_once
+    unless self.processed
+      self.process_phrase
+    end
+  end
+
+  def empty_entities?
+    self.processed and self.entities.empty?
+  end
+
+  def intent(name_only=true)
+    final_intent = nil
+    intents = (self.intents rescue nil)
+    unless intents.nil?
+      intents.each do |intent|
+        if final_intent.nil?
+          final_intent = intent
+        elsif intent[:confidence] > final_intent[:confidence]
+          final_intent = intent
+        end
+      end
+    end
+    if final_intent.nil?
+      return nil
+    else
+      return name_only ? final_intent[:name] : final_intent
+    end
+  end
+
+  def expression
+    self.entities[:expression].first[:value] rescue nil
+  end
+
+  def location
+    self.entities[:location] rescue []
+  end
+
+  def search_query
+    self.entities[:search_query] rescue nil
+  end
+
+  def local_search_query
+    self.entities[:local_search_query] rescue nil
+  end
+
+
+  def dates
+    self.entities[:datetime].map{|d| d[:values][0][:value].to_date} rescue []
+  end
+
+  def datetime_range
+
+    params = self.entities[:"wit$datetime:datetime"] rescue []
+
+    dates = {
+      :from => nil,
+      :to => nil
+    }
+
+    # case (params.count rescue 0)
+    count = params.count rescue 0
+
+    # when 1
+    if count == 1
+      if params[0][:value].nil?
+        dates[:from] = (params[0][:values][0][:from][:value].to_date rescue nil)
+        dates[:to] = (params[0][:values][0][:to][:value].to_date rescue nil)
+        dates[:to] = dates[:to] - 1.day unless dates[:to].nil? #esto es por que el git al traer rango trae un dia mas
+      else
+        dates[:from] = (params[0][:value].to_date rescue nil)
+        unless self.entities[:duration].nil?
+          dates[:to] = get_return_date_from_duration(dates[:from]) unless dates[:from].nil?
+        end
+      end
+      # when 2
+    elsif count > 1
+      dates[:from] = (params[0][:value].to_date rescue nil)
+      dates[:to] = (params[1][:value].to_date rescue nil)
+    end
+
+    if ((dates[:from] > dates[:to]) rescue false) #solo para asegurar que la fecha de salida sea anterior a la de llegada
+      from_tmp = dates[:from]
+      dates[:from] = dates[:to]
+      dates[:to] = from_tmp
+    end
+
+    return (dates)
+  end
+
+  def datetime_range?
+    datetime_range = self.datetime_range
+    !datetime_range[:from].nil? && !datetime_range[:to].nil?
+  end
+
+
+  def duration_in_days
+
+    multiplier = {"day"=>1,"week"=>7,"month"=>31}
+    duration = (self.entities[:duration][0] rescue nil)
+    unless duration.nil?
+      return(duration[:value]*multiplier[duration[:unit]] rescue 0)
+    else
+      return nil
+    end
+
+  end
+
+  def self.most_confidence(elements)
+    if elements.class == Array
+      return elements.sort_by{|element| element["confidence"]}.first
+    else
+      return false
+    end
+  end
+
+  def add_pre_processed_entities    
+    self.entities[:datetime_range] = self.datetime_range if self.datetime_range?
+    self.entities[:datetime] = self.entities[:"wit$datetime:datetime"].map{|v| v[:value] || v[:from][:value] rescue nil} unless self.entities[:"wit$datetime:datetime"].nil?
+  end
+
+end
+end

data/lib/core/lib/notification.rb

@@ -0,0 +1,371 @@
+module Kogno
+class Notification
+
+  # attr_accessor :template
+  # attr_accessor :user, :msg, :context
+  # attr_accessor :nlp
+
+  def initialize(recipient=nil,msg=nil)
+    @messages = []
+    @inline_query_results = []
+    @before_messages = []
+    @after_messages = []
+    @vars = {}
+    @recipient = recipient
+    @user = @recipient if @recipient.type == :user
+    @message = msg
+    @response_log = []
+    @message_log = []
+    @context_obj_for_tilt_template = nil
+  end
+
+  def set_context(context)
+    @context = context
+  end
+
+  def send(messaging_type="RESPONSE",recipient_id=nil,page_id=nil,delete=true)
+    logger.write "---- send() not implemented yet for this platform ----", :red  
+  end
+
+  def send_using_token()
+    logger.write "---- send_with_token() not implemented yet for this platform ----", :red  
+  end
+
+  def scheduled(send_at, tag=nil)
+    return false unless @recipient.type == :user
+    unless @recipient.nil?
+      unless @messages.empty?
+        @recipient.scheduled_messages.create({
+          messages: @messages.to_json,
+          tag: tag,
+          send_at: send_at
+        })
+        self.delete_messages()
+      else
+        logger.write "Error: No messages to send", :red
+      end
+    end
+  end
+
+  def send_private_reply(recipient_id=nil,page_id=nil,delete=true)
+    logger.write "---- send_private_reply not implemented yet for this platform ----", :red  
+  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 "---- send_multiple not implemented yet for this platform ----", :red  
+  end
+
+  def match_next_message(users,messaging_type)
+    logger.write "---- match_next_message isn't working for this platform ----", :red  
+  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 raw(params, type=:message)
+    self.push_message(params, type)
+  end
+
+  def text(text)
+    logger.write "---- text not implemented yet for this platform ----", :red  
+  end
+
+  def loading_typing_on(recipient_id)
+    logger.write "---- loading_typing_on not implemented yet for this platform ----", :red  
+  end
+
+  def loading_typing_off(recipient_id)
+    logger.write "---- loading_typing_off not implemented yet for this platform ----", :red  
+  end
+
+  def typing_on(duration)
+    self.push_message({:action => :typing_on, :duration => duration}, :action)
+  end
+
+  def typing(seconds)
+    typing_on(seconds)
+  end
+
+  def typing_off
+    self.push_message({:action => :typing_off}, :action)
+  end
+
+  def quick_reply(text,replies,typed_postbacks=true)
+    logger.write "---- quick_reply not implemented yet for this platform ----", :red  
+  end
+
+  def button(text,buttons,typed_postbacks=true)
+    logger.write "---- button not implemented yet for this platform ----", :red  
+  end
+
+  def list(elements,buttons=[])
+    logger.write "---- list not implemented yet for this platform ----", :red  
+  end
+
+  def messenger_generic_template(elements,image_aspect_ratio=:horizontal, quick_replies=[])
+    logger.write "---- messenger_generic_template not implemented yet for this platform ----", :red  
+  end
+
+  def whatsapp_template(name, components=[], lang="en_US")
+    logger.write "---- whatsapp_template not implemented yet for this platform ----", :red  
+  end
+
+  def carousel(elements,last_element={},image_aspect_ratio=:horizontal , quick_replies=[])
+    logger.write "---- carousel not implemented yet for this platform ----", :red  
+  end
+
+  def recurring_notification_request(args)
+    logger.write "---- recurring_notification_request not implemented yet for this platform ----", :red 
+  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 payload(payload,params={})
+    "#{payload}:#{params.to_json}"
+  end
+
+  def template(route,params={})
+    map = digest_template_route(route)
+    if map == false
+      return false
+    else
+      action_group = map[:action_group]
+      action = map[:action]
+    end
+
+    if @context.nil?
+      @reply = self
+      Context.base_template(action_group,action,params,false, self)
+    else
+      @context.template(action_group,action,params)
+    end
+  end
+
+  # def partial(action_group,action,params={})
+  #   template(action_group,"#{action}",params)
+  # end
+
+  # def template_block(action_group,action,params={},&block)
+  #   @reply = self
+  #   eval(template(action_group,action,params,true))
+  # end
+
+  # def partial_block(action_group,action,params={},&block)
+  #   @reply = self
+  #   eval(template(action_group,"_#{action}",params,true))
+  # end
+
+  def set_typed_postbacks(typed_postbacks)
+    return false unless @recipient.type == :user
+    @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
+    logger.write "---- location_request not implemented yet for this platform ----", :red  
+  end
+
+  def url(params)
+    logger.write "---- url not implemented yet for this platform ----", :red  
+  end
+
+  def location(params)
+    logger.write "---- location not implemented yet for this platform ----", :red  
+  end
+
+  def image(params)
+    logger.write "---- image not implemented yet for this platform ----", :red  
+  end
+
+  def video(params)
+    logger.write "---- video not implemented yet for this platform ----", :red  
+  end
+
+  def document(params)
+    logger.write "---- document not implemented yet for this platform ----", :red  
+  end
+
+  def contact(params)
+    logger.write "---- contact not implemented yet for this platform ----", :red  
+  end    
+
+  def answer_inline_query(inline_query_id, delete=true)
+    logger.write "---- answer_inline_query not implemented yet for this platform ----", :red  
+  end
+
+  def answer_callback_query(params={},callback_query_id=nil)
+    logger.write "---- answer_callback_query not implemented yet for this platform ----", :red  
+  end
+
+  def push_inline_query_result(result)
+    logger.write "---- push_inline_query_result not implemented yet for this platform ----", :red  
+  end
+
+  def html(code, reply_markup = {} ,extra_params={})
+    logger.write "---- html not implemented yet for this platform ----", :red  
+  end
+
+  def html_template(action_group, action, params, reply_markup = {} ,extra_params={})
+    logger.write "---- html_template not implemented yet for this platform ----", :red  
+  end
+
+  def render_html_template(action_group, action, params)
+    logger.write "---- render_html_template not implemented yet for this platform ----", :red  
+  end
+
+  def markdown(params)
+    logger.write "---- markdown not implemented yet for this platform ----", :red  
+  end
+
+  def confirm(question,params,type=:quick_reply)
+    # params example:
+    # {
+    #   yes: {title: "Yes", payload: true}},
+    #   no: {title: "No", :payload: false}
+    # }
+    if type == :quick_reply
+      self.quick_reply(
+        question,
+        [
+          {
+            :content_type => :text,
+            :title => params[:yes][:title],
+            :payload => params[:yes][:payload]
+          },
+          {
+            :content_type => :text,
+            :title => params[:no][:title],
+            :payload => params[:no][:payload],
+          }
+        ],
+        {typed_postbacks: true}
+      )
+    elsif type == :button
+      self.button(
+        question,
+        [
+          {
+            :type => :postback,
+            :title => params[:accept_title],
+            :payload => params[:accept_payload]
+          },
+          {
+            :type => :postback,
+            :title => params[:reject_title],
+            :payload => params[:reject_payload]
+          }
+        ]
+      )
+    end
+    self.set_typed_postbacks({"YES"=>params[:accept_payload], "NO"=> params[:reject_payload], "CANCEL" => params[:reject_payload]})
+  end
+
+  protected
+
+  def digest_template_route(route)
+
+    route_array = route.to_s.split("/")
+    if route_array.count > 1
+      action_group = route_array[0]
+      action = route_array[1]
+    else
+      if !@context.nil?
+        action_group = @context.name
+        action = route_array[0]
+      else
+        raise "Can't determine the context for template #{route}"
+        return false
+      end
+    end
+
+    return(
+      {
+        action_group: action_group,
+        action: action
+      }
+    )
+
+  end
+
+end
+end

data/lib/core/lib/spelling.rb

@@ -0,0 +1,13 @@
+module Kogno
+class Spelling
+
+  class << self
+
+    def correction(sentece) # Este metodo deberia ser sobrescrito en app/extensions si hay que agregar corrector ortografico antes del pasarle al wit
+      sentece
+    end
+
+  end
+
+end
+end