kogno 1.0.1

data/lib/core/lib/whatsapp/message.rb

@@ -0,0 +1,132 @@
+module Kogno
+module WhatsApp
+class Message  < Kogno::Message
+
+  @overwritten_payload = nil
+
+  def initialize(data, type=nil)
+    @data = data
+    @type = type
+  end
+
+  def type
+    @type
+  end
+
+  def platform
+    :whatsapp
+  end
+
+  def metadata
+    @data[:metadata]
+  end
+
+  def sender_id
+    return @data[:contacts][0][:wa_id]
+  end
+
+  def sender_name
+    return @data[:contacts][0][:profile][:name] rescue ""
+  end
+
+  def attachments
+    message = @data[:messages][0]
+    a = nil
+    a = message[:audio]
+    a = message[:document] if a.nil?
+    a = message[:image] if a.nil?
+    a = message[:video] if a.nil?
+    return a
+  end
+
+
+  def raw_message
+    t = @data[:messages][0][:text][:body] rescue nil
+    unless t.nil?
+      return({
+        :type => :text,
+        :value => t
+      })
+    end
+  end
+
+  def raw_payload
+    payload = @data[:messages][0][:button][:payload] rescue nil
+    payload = (@data[:messages][0][:interactive][:button_reply][:id] rescue nil) if payload.nil?
+    payload = (@data[:messages][0][:interactive][:list_reply][:id] rescue nil) if payload.nil?
+    payload = @overwritten_payload if payload.nil?
+    return(payload)
+  end
+
+  def text
+    return self.raw_message[:value].to_s rescue ""
+  end
+
+
+  def handle_event(debug=false)
+
+    begin
+
+      user = User.find_or_create_by_psid(self.sender_id, :whatsapp)
+      user.get_session_vars
+
+      self.set_nlp(user.locale)
+
+      I18n.locale = user.locale unless user.locale.nil?
+
+      self.set_nlp(I18n.locale)
+
+      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/whatsapp/notification.rb

@@ -0,0 +1,206 @@
+module Kogno
+module WhatsApp
+class Notification < Kogno::Notification
+
+  def send(recipient_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
+        sleep(message[:value][:duration]) if message[:value][:action].to_sym == :typing_on
+      else
+        message = self.replace_place_holders(message[:value])
+        @response_log << Api::send(recipient_id,message)
+      end
+    end    
+    self.delete_messages() if delete
+    @recipient.mark_last_message_as_unread unless @recipient.nil?
+  end
+
+  def text(text, extra_params={})
+    extra_params = {preview_url: false}.merge(extra_params)  
+    params = {
+      type: :text,
+      text: {
+        body: text
+      }.merge(extra_params)
+    }  
+    self.push_message(params, :message)
+  end
+
+
+  def typing_on(duration)
+    self.push_message({:action => :typing_on, :duration => duration}, :action)
+  end
+
+  def whatsapp_template(name, components=[], lang="en_US")
+    self.push_message(Api::template_message(name, components, lang), :message)
+  end
+
+  def button(text, replies, extra_settings={})
+    replies = [replies] if replies.class == Hash
+    settings = {typed_postbacks: Kogno::Application.config.typed_postbacks}.merge(extra_settings) # defaults
+    replies = replies.replace_keys({payload: :id})
+    buttons = replies.map do |reply|
+      {
+        type: :reply,
+        reply: reply
+      }
+    end
+
+    set_typed_postbacks(replies.map{|button|
+      [button[:title].to_payload, button[:id]] unless button[:title].nil?
+    }.compact.to_h) if settings[:typed_postbacks]
+
+    self.push_message(Api::interactive_buttons(text, buttons), :message)
+  end
+
+  def quick_reply(text, replies, extra_settings={})
+    self.button(text, replies, extra_settings)
+  end
+
+  def list(params,header={},footer={})
+    params[:sections] = params[:sections].map{|s| 
+      {
+        title: s[:title],
+        rows: s[:rows].replace_keys({payload: :id})
+      }
+    }
+
+    params[:header] = header unless header.empty?
+    params[:footer] = footer unless footer.empty?
+
+    self.push_message(Api::interactive_list(params), :message)
+  end
+
+  def url(params)
+    self.raw(
+        {  
+          type: :image,
+          image: {          
+            link: params[:image],
+            caption: "#{params[:title]}\n#{params[:sub_title]}\n#{params[:url]}"
+          }
+        }
+      )
+  end
+
+  def location(params)
+    self.push_message(Api::location(params), :message)
+  end
+  
+  def image(params)
+    # params = params.replace_keys({url: :link})
+    if params[:buttons].nil?
+
+      self.raw(
+        {  
+          type: :image,
+          image: {
+            link: params[:url],
+            caption: params[:caption]
+          }
+        }
+      )
+
+    else
+
+      buttons = params[:buttons]
+      buttons = [buttons] if buttons.class == Hash
+      buttons = buttons.replace_keys({payload: :id})
+      replies = buttons.map do |reply|
+        {
+          type: :reply,
+          reply: reply
+        }
+      end
+      self.raw(
+        {  
+          type: :interactive,
+          interactive: {
+            type: :button,
+            header: {
+              type: :image,
+              image: {
+                link: params[:url]
+              }
+            },
+            body:{
+              text: params[:caption]
+            },
+            action:{
+              buttons: replies
+            }
+          }
+        }
+      )
+
+    end
+
+  end
+
+  def video(params)
+
+    if params[:buttons].nil?
+
+      self.raw(
+        {  
+          type: :video,
+          video: {
+            link: params[:url],
+            caption: params[:caption]
+          }
+        }
+      )
+
+    else
+
+      buttons = params[:buttons]
+      buttons = [buttons] if buttons.class == Hash
+      buttons = buttons.replace_keys({payload: :id})
+      replies = buttons.map do |reply|
+        {
+          type: :reply,
+          reply: reply
+        }
+      end
+      self.raw(
+        {  
+          type: :interactive,
+          interactive: {
+            type: :button,
+            header: {
+              type: :video,
+              video: {
+                link: params[:url]
+              }
+            },
+            body:{
+              text: params[:caption]
+            },
+            action:{
+              buttons: replies
+            }
+          }
+        }
+      )
+
+    end
+
+  end  
+
+  def document(params)
+    self.push_message(Api::media(:document, params), :message)
+  end
+
+  def contact(params)
+    self.push_message(Api::contacts(params), :message)
+  end
+
+
+
+end
+end
+end

data/lib/core/lib/whatsapp/status_message.rb

@@ -0,0 +1,58 @@
+module Kogno
+module WhatsApp
+class StatusMessage  < Kogno::Message
+
+  @overwritten_payload = nil
+
+  def initialize(data, type=nil)
+    @data = data
+    @type = type
+  end
+
+  def type
+    @type
+  end
+
+  def platform
+    :whatsapp
+  end
+
+  def status_raw
+    @data[:statuses][0]
+  end
+
+  def status
+    self.status_raw[:status]
+  end
+
+  def metadata
+    @data[:metadata]
+  end
+
+  def sender_id
+    return self.status_raw[:recipient_id]
+  end
+
+
+  def handle_event(debug=false)
+
+    begin
+
+      user = User.find_or_create_by_psid(self.sender_id, :whatsapp)
+      if self.status == "read"
+        user.mark_last_message_as_read
+      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/loaders/config_files.rb

@@ -0,0 +1,15 @@
+module Kogno
+
+  Dir[File.join(Application.project_path,'config','*.rb')].each do |required_file|
+    require required_file
+  end
+
+  Dir[File.join(Application.project_path,'config','platforms','*.rb')].each do |required_file|
+    require required_file
+  end
+
+  Dir[File.join(Application.project_path,'config','initializers','*.rb')].each do |required_file|
+    require required_file
+  end
+
+end

data/lib/core/models/chat_log.rb

@@ -0,0 +1,4 @@
+class ChatLog < ActiveRecord::Base
+  self.table_name = "kogno_chat_logs"
+  belongs_to :user
+end

data/lib/core/models/long_payload.rb

@@ -0,0 +1,25 @@
+class LongPayload < ActiveRecord::Base
+    self.table_name = "kogno_long_payloads"
+    before_create :generate_token    
+
+    def generate_token
+      self.token = Digest::MD5.hexdigest "#{Time.now}#{rand(100000)}"
+    end
+
+    def self.set(data)
+      data = data.split(":",2)
+      payload = data[0]
+      params = data[1]
+      payload_param = create(payload: payload, params: params)
+      return payload_param.token
+    end
+
+    def self.get(token)
+      payload = find_by_token(token)
+      unless payload.nil?
+        return ("#{payload.payload}:#{payload.params}")
+      else
+        return {}
+      end
+    end
+end

data/lib/core/models/matched_message.rb

@@ -0,0 +1,5 @@
+class MatchedMessage < ActiveRecord::Base
+  self.table_name = "kogno_matched_messages"
+  belongs_to :user
+
+end

data/lib/core/models/messenger_recurring_notification.rb

@@ -0,0 +1,16 @@
+class MessengerRecurringNotification < ActiveRecord::Base
+  self.table_name = "kogno_messenger_recurring_notifications"
+  belongs_to :user
+
+  def data
+    {
+      token: self.token,
+      frecuency: self.frecuency,
+      expires_at: self.expires_at,
+      token_status: self.token_status,
+      timezone: self.timezone,
+      status: self.active ? :active : :stopped  
+    }
+  end
+
+end

data/lib/core/models/scheduled_message.rb

@@ -0,0 +1,40 @@
+class ScheduledMessage < ActiveRecord::Base
+  self.table_name = "kogno_scheduled_messages"
+  belongs_to :user
+
+  def self.process_all(sleep=60)
+    loop do
+      scheduled_messages = where("'#{Time.now.utc}' > send_at").includes(:user).order(:send_at)
+      scheduled_messages.each do |scheduled_message|
+        if scheduled_message.user.last_usage > Kogno::Application.config.sequences.time_elapsed_after_last_usage
+          scheduled_message.execute
+        else
+          logger.write "User ID #{scheduled_message.user.psid} wrote us recently, let's wait #{Kogno::Application.config.sequences.time_elapsed_after_last_usage - scheduled_message.user.last_usage} seconds before bother him.", :green
+        end
+      end
+      scheduled_messages.destroy_all
+      sleep(sleep)
+    end
+  end
+
+  def execute
+    if self.user.platform == "messenger"
+      notification = Kogno::Messenger::Notification.new(self.user)
+    elsif self.user.platform == "telegram"
+      notification = Kogno::Telegram::Notification.new(self.user)
+    elsif self.user.platform == "whatsapp"
+      notification = Kogno::WhatsApp::Notification.new(self.user)
+    else
+      logger.write "Platform '#{self.user.platform} not supported. User ID: #{self.user.id}"
+      notification = nil
+    end
+    unless notification.nil?
+      notification.import_messages(self.messages)
+      logger.write "Sending scheduled messages to #{self.user.psid}..", :green
+      logger.write_json JSON.parse(self.messages), :bright
+      notification.send
+      self.user.log_response(notification,true) if Kogno::Application.config.store_log_in_database
+    end
+  end
+
+end

data/lib/core/models/sequence.rb

@@ -0,0 +1,29 @@
+class Sequence < ActiveRecord::Base
+  self.table_name = "kogno_sequences"
+  belongs_to :user
+  before_create :set_last_hit_at
+
+  def set_last_hit_at
+    self.last_hit_at = Time.now.utc
+  end
+
+  def route
+    "#{context}.#{stage}"
+  end
+
+
+  def self.process_all(sleep=60)
+    loop do
+      actions = where("'#{Time.now.utc}' > execution_time or execution_time is null").includes(:user).order(:execution_time)
+      actions.each do |action|
+        if action.user.last_usage > Kogno::Application.config.sequences.time_elapsed_after_last_usage
+          Kogno::Context.run_sequence(action)
+        else
+          logger.write "User ID #{action.user.psid} wrote us recently, let's wait #{Kogno::Application.config.sequences.time_elapsed_after_last_usage - action.user.last_usage} seconds before bother him.", :green
+        end
+      end
+      sleep(sleep)
+    end
+  end
+
+end

data/lib/core/models/telegram_chat_group.rb

@@ -0,0 +1,26 @@
+class TelegramChatGroup < ActiveRecord::Base
+  self.table_name = "kogno_telegram_chat_groups"
+  belongs_to :user, foreign_key: :inviter_user_id
+
+  def type
+    self.kind.to_sym
+  end
+
+  def self.find_or_create(args)
+    chat = find_by_chat_id(args[:chat_id])
+    if chat.nil?
+      chat = create(args)
+    else
+      chat.update(args)
+    end
+    return chat
+  end
+
+  def notification
+    if @notification.nil?
+      @notification =  Kogno::Telegram::Notification.new(self)
+    end
+    @notification
+  end
+  
+end