kogno 1.0.1

data/lib/core/models/user.rb

@@ -0,0 +1,285 @@
+class User < ActiveRecord::Base
+
+  has_many :sequences
+  has_many :chat_logs
+  has_many :scheduled_messages
+  has_many :matched_messages
+  has_many :actions, foreign_key: :user_id, :class_name => "UserAction"
+  has_many :telegram_groups, foreign_key: :inviter_user_id, :class_name => "TelegramChatGroup"
+  has_one :messenger_recurring_notification
+
+
+  attr_accessor :just_created, :vars
+  before_create :set_default_for_session_vars
+
+  def set_default_for_session_vars
+    self.session_vars = {}
+  end
+
+  def type
+    :user
+  end
+
+  def chat_id
+    self.psid
+  end
+
+  def fetch_profile_information
+    Kogno::FacebookGraph.fetch_user_data(self.psid, self.page_id)
+  end
+
+
+  def reset
+    self.exit_context
+    self.save
+  end
+
+  def mark_last_message_as_read
+    self.last_message_read = true
+    self.save
+  end
+
+  def mark_last_message_as_unread
+    self.last_message_read = false
+    self.save
+  end
+
+  def set_context(context, params={})
+
+    self.context = context
+    self.context_params = params.to_json.encode('utf-8')
+    self.save
+
+  end
+
+  def set_locale(locale)
+    self.locale = locale
+    I18n.locale = locale
+    self.save
+  end
+
+  def get_context_params
+    (JSON.parse(self.context_params,{:symbolize_names => true}) rescue {})
+  end
+
+  def add_context(context)
+    context_a = self.context.to_s.split(Regexp.union(["/","."]))
+    context_a.push(context)
+    self.context = context_a.join(".")
+    self.save
+  end
+
+
+  def exit_context
+    self.set_context(nil) if !self.context.nil?
+  end
+
+
+  def self.find_or_create_by_psid(psid,platform,page_id=nil,psid_from_post_comment=nil)
+    user = User.find_by_psid(psid)    
+    if user.nil?
+      begin
+        new_user = User.create(psid: psid, platform: platform, page_id: page_id, last_usage_at: Time.now.utc, psid_from_post_comment: psid_from_post_comment)
+        user = User.find(new_user.id)
+        user.just_created = true
+      rescue ActiveRecord::RecordNotUnique => e
+        user = User.find_by_psid(psid)
+        user.just_created = false 
+      end              
+    else
+      user.just_created = false
+      if user.psid_from_post_comment.nil? and !psid_from_post_comment.nil?
+        user.psid_from_post_comment = psid_from_post_comment
+        user.save
+      end
+    end
+    return user
+  end
+
+  def set_last_usage
+    self.last_usage_at = Time.now.utc
+  end
+
+  def last_usage
+    Time.now.utc - self.last_usage_at
+  end
+
+  def dummy?
+    self.id.nil?
+  end
+
+  def first_time?
+    self.just_created.nil? ? false : self.just_created
+  end
+
+  #Sequences
+
+  def set_sequence(stage, context)
+    sequence = sequences.find_by_context(context)
+    if sequence.nil?
+      sequence = sequences.create(stage:stage, context: context)
+    else
+      if stage != sequence.stage
+        sequence.stage = stage
+        sequence.last_hit_at = Time.now.utc
+        sequence.last_executed = 0
+        sequence.execution_time = nil
+      else
+        sequence.updated_at = Time.now.utc
+      end
+      sequence.save
+    end
+  end
+
+  def exit_sequence(stage, context)
+    sequence = self.sequences.where("stage = '#{stage}' and  context = '#{context}'").first
+    unless sequence.nil?
+      sequence.destroy
+      true
+    else
+      false
+    end
+  end
+
+  # Session Vars
+
+  def save_session_vars
+    self.last_usage_at = Time.now.utc
+    new_session_vars = self.vars.to_json.encode('utf-8')
+    if self.session_vars != new_session_vars
+      self.session_vars = new_session_vars      
+    end
+    self.save
+  end
+
+  def get_session_vars
+
+    self.vars = (JSON.parse(self.session_vars,{:symbolize_names => true}) rescue {})
+
+  end
+
+  def save_current_context
+    self.get_session_vars if self.vars.nil?
+    unless self.context.to_s.empty?
+      self.vars[:saved_context] = {
+        context: self.context.to_s,      
+        params: self.context_params
+      }
+    end
+  end
+
+  def previous_context
+    self.get_session_vars if self.vars.nil?
+    self.vars[:previous_context]
+  end
+
+  def delete_previous_context
+    self.get_session_vars if self.vars.nil?
+    self.vars.delete :previous_context
+  end
+
+  def log_message(message, message_type = :received)
+    if message_type == :post_comment_received
+     self.chat_logs.create({
+        message_type: message_type,
+        body: message.webhook_data.to_json,
+        context: self.context,
+        message: message.text.to_s[0..1000],
+        nlp_entities: (message.nlp.entities.to_json rescue {}),
+        new_user: self.first_time?
+      })
+    else  
+      self.chat_logs.create({
+        message_type: message_type,
+        body: message.webhook_data.to_json,
+        context: self.context,
+        payload: message.payload,
+        payload_params: message.params,
+        message: message.text.to_s[0..1000],
+        nlp_entities: (message.nlp.entities.to_json rescue {}),
+        user_vars: self.session_vars,
+        new_user: self.first_time?
+      })
+    end
+
+  end
+
+  def log_response(response,scheduled=false)
+    unless response.message_log.empty?
+      response_log = self.chat_logs.create({
+        message_type: :sent,
+        body: response.message_log.to_json,
+        response: response.response_log.to_json,
+        context: self.context,
+        user_vars: self.vars.to_json,
+        scheduled: scheduled
+      })
+      response.destroy_message_log
+      return(response_log)
+    end  
+  end
+
+  def destroy_scheduled_messages(tag=nil)
+    if tag.nil?
+      self.scheduled_messages.destroy_all
+    else
+      self.scheduled_messages.where(tag: tag).destroy_all
+    end
+  end
+
+  def scheduled_message?(tag)
+    if self.scheduled_messages.where(tag: tag).empty?
+      return false
+    else
+      return true
+    end
+  end
+
+  def reschedule_message(tag, send_at)
+    self.scheduled_messages.where(tag: tag).update_all(send_at: send_at)
+  end
+
+  def notification
+    if @notification.nil?
+      self.vars = {}
+      case self.platform.to_sym
+        when :messenger
+          @notification =  Kogno::Messenger::Notification.new(self)
+        when :telegram
+          @notification =  Kogno::Telegram::Notification.new(self)
+        when :whatsapp
+          @notification =  Kogno::WhatsApp::Notification.new(self)
+      end
+    end
+    @reply = @notification
+    @user = self
+    return @notification
+  end
+
+  def update_messenger_recurring_notification(data)
+    return false unless self.platform == "messenger"
+    params = {
+      token: data[:notification_messages_token],
+      frecuency: data[:notification_messages_frequency],
+      expires_at: Time.at(data[:token_expiry_timestamp]/1000),
+      token_status: data[:user_token_status],
+      timezone: data[:notification_messages_timezone],
+      active: data[:notification_messages_status] == "STOP_NOTIFICATIONS" ? false : true    
+    }
+    if self.messenger_recurring_notification.nil?
+      self.messenger_recurring_notification = MessengerRecurringNotification.create(params)
+    else
+      self.messenger_recurring_notification.update(params)
+    end
+    self.messenger_recurring_notification
+  end
+
+  def messenger_recurring_notification_data
+    self.messenger_recurring_notification.data rescue {}
+  end
+
+  def subscribed_to_messenger_recurring_notification?
+    messenger_recurring_notification_data[:status] == :active ? true : false
+  end
+  
+end

data/lib/core/web/webhook.rb

@@ -0,0 +1,198 @@
+
+require 'kogno'
+require 'core/loaders/config_files'
+
+require 'sinatra'
+require 'sinatra/namespace'
+require 'sinatra/cross_origin'
+require 'json'
+
+Logger.set(:webhook) if ARGV[0] == "daemon"
+
+require File.join(Kogno::Application.project_path,'application.rb')
+
+set :port, Kogno::Application.config.http_port || 1337
+set :bind, '0.0.0.0'
+set :root, File.join(Kogno::Application.project_path,'web')
+set :public_folder, File.join(Kogno::Application.project_path,'web','public')
+set :environment, Kogno::Application.config.environment
+set :logging, false
+
+configure do
+  enable :cross_origin
+end
+
+before do 
+  reload!(false) if Kogno::Application.config.environment == :development
+end
+
+# before '/*' do
+#   allowed_paths = [
+#     Kogno::Application.config.messenger.webhook_route, 
+#     Kogno::Application.config.telegram.webhook_route, 
+#     Kogno::Application.config.whatsapp.webhook_route , 
+#     "/"
+#   ]
+#   unless allowed_paths.include?(request.path_info)
+#   $logger.debug_json request.path_info, :red
+# end
+
+get "/" do
+  Kogno::Application.config.app_name
+end
+
+post Kogno::Application.config.messenger.webhook_route do
+
+  request.body.rewind
+  params = JSON.parse(request.body.read, {:symbolize_names => true})
+  $logger.write "MESSENGER INCOMING WEBHOOK: #{request.fullpath}", :bright
+  $logger.debug "PARAMS: #{params}"
+  if params[:object] == "page"
+    params[:entry].each do |entry|
+      events = []
+      event_type = nil
+      if !entry[:messaging].nil?
+        events = entry[:messaging]
+        event_type = :message
+      elsif !entry[:changes].nil?
+        events = entry[:changes]
+        event_type = :post_comment
+      end    
+
+      unless event_type.nil?
+        events.each do |event|
+          msg = nil
+          if event_type == :message
+            unless event[:optin].nil?
+              msg = Kogno::Messenger::RecurringNotification.new(event)
+            else
+              msg = Kogno::Messenger::Message.new(event)
+            end
+          elsif event_type == :post_comment
+            msg = Kogno::Messenger::PostComment.new(event,entry[:id])
+          end 
+          unless msg.nil?
+            Thread.new {
+              begin
+                msg.handle_event()
+              rescue StandardError => e
+                $logger.write e.message, :red
+                $logger.write "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
+              end
+            }
+          end
+        end
+      end
+    end
+    status 200
+    "EVENT_RECEIVED"
+  else
+    status 404
+  end
+
+end
+
+get Kogno::Application.config.messenger.webhook_route do
+
+  mode = params["hub.mode"]
+  token = params["hub.verify_token"]
+  challenge = params["hub.challenge"]
+  if !mode.nil? and !token.nil?
+    if mode == 'subscribe' and token == Kogno::Application.messenger.webhook_verify_token
+      status 200
+      challenge
+    else
+      status 403
+    end
+  end
+
+end
+
+post Kogno::Application.config.telegram.webhook_route do
+  request.body.rewind
+  params = JSON.parse(request.body.read, {:symbolize_names => true})
+  $logger.write "TELEGRAM INCOMING WEBHOOK: #{request.fullpath}", :bright
+  $logger.debug "PARAMS: #{params}"
+
+  message = {data: params[:message], type: :message} if !params[:message].nil?
+  message = {data: params[:callback_query], type: :callback_query} if !params[:callback_query].nil? and message.nil?
+  message = {data: params[:inline_query], type: :inline_query} if !params[:inline_query].nil? and message.nil?
+  message = {data: params[:my_chat_member], type: :chat_activity} if !params[:my_chat_member].nil? and message.nil?
+
+  if !message.nil?
+    msg = nil
+    if [:message, :callback_query].include?(message[:type])
+      msg = Kogno::Telegram::Message.new(message[:data], message[:type])
+    elsif message[:type] == :inline_query
+      msg = Kogno::Telegram::InlineQuery.new(message[:data])
+    elsif message[:type] == :chat_activity
+      msg = Kogno::Telegram::ChatActivity.new(message[:data])
+    end
+    if !msg.nil?
+      Thread.new {
+        begin
+          msg.handle_event()
+        rescue StandardError => e
+          $logger.write e.message, :red
+          $logger.write "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
+        end
+      }    
+      status 200
+      "True"
+    else
+      status 404
+    end
+  else
+    status 404
+  end
+end
+
+post Kogno::Application.config.whatsapp.webhook_route do
+  request.body.rewind
+  params = JSON.parse(request.body.read, {:symbolize_names => true})
+  $logger.write "WHATSAPP INCOMING WEBHOOK: #{request.fullpath}", :bright
+  $logger.debug "PARAMS: #{params}"
+  entries = params[:entry]  
+  entries.each do |entry|
+    entry[:changes].each do |change|    
+      msg = nil
+      if !change[:value][:messages].nil?
+        msg = Kogno::WhatsApp::Message.new(change[:value], :message)
+      elsif !change[:value][:statuses].nil?
+        msg = Kogno::WhatsApp::StatusMessage.new(change[:value], :message)
+      end
+      unless msg.nil?
+        Thread.new {
+          begin
+            msg.handle_event()
+          rescue StandardError => e
+            $logger.write e.message, :red
+            $logger.write "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
+          end
+          $logger.write "\n"
+        }        
+      end
+    end
+  end
+
+  status 200
+  "EVENT_RECEIVED"
+end
+
+get Kogno::Application.config.whatsapp.webhook_route do
+
+  mode = params["hub.mode"]
+  token = params["hub.verify_token"]
+  challenge = params["hub.challenge"]
+  if !mode.nil? and !token.nil?
+    if mode == 'subscribe' and token == Kogno::Application.whatsapp.webhook_verify_token
+      status 200
+      challenge
+    else
+      status 403
+    end
+  end
+
+end
+
+require File.join(Kogno::Application.project_path,'web','routes.rb')

data/lib/kogno.rb

@@ -0,0 +1,130 @@
+$VERBOSE = nil
+require 'active_record'
+require 'core/lib/base_config'
+require 'logger'
+require 'core/extensions/logger'
+
+Logger.set(:stdout)
+
+module Kogno
+
+  require "active_support/configurable"  
+  
+  class Application
+
+    include ActiveSupport::Configurable
+
+    config_accessor :sequences do
+      Kogno::BaseConfig.new(:time_elapsed_after_last_usage)
+    end
+
+    config_accessor :error_notifier do
+      Kogno::BaseConfig.new(:slack)
+    end
+
+    config_accessor :api do
+      Kogno::BaseConfig.new(:enable, :key)
+    end
+
+    config_accessor :messenger do
+      Kogno::BaseConfig.new(:graph_url, :pages, :webhook_verify_token, :persistent_menu, :welcome_screen_payload, :greeting, :ice_breakers, :stickers, :webhook_route, :whitelisted_domains)
+    end
+
+    config_accessor :whatsapp do
+      Kogno::BaseConfig.new(:graph_url, :phone_number_id, :access_token, :webhook_verify_token)
+    end
+
+    config_accessor :nlp do
+      Kogno::BaseConfig.new(:wit, :enable)
+    end
+
+    config_accessor :telegram do
+      Kogno::BaseConfig.new(:bot_name, :api_url, :token, :webhook_https_server, :webhook_drop_pending_updates, :webhook_route)
+    end
+
+    config_accessor :routes do
+      Kogno::BaseConfig.new(:default, :post_comment, :inline_query, :chat_activity, :commands, :recurring_notification)
+    end
+
+    class << self
+
+      def core_path
+        File.expand_path('../../',__FILE__)
+      end
+
+      def project_path
+        File.expand_path(Dir.pwd)
+      end
+
+      # def create_project_folders
+      #   tmp = File.join(project_path,"tmp")
+      #   logs = File.join(project_path,"logs")
+      #   web_public = File.join(project_path,"web","logs")
+      #   Dir.mkdir(tmp,0755) unless File.exist?(tmp)
+      #   Dir.mkdir(logs,0755) unless File.exist?(logs)
+      # end
+
+      def load_core
+        ignore_files = Dir[File.join(core_path,'lib','core','web','inc','*.rb')]
+        files_to_load_later = []
+        Dir[File.join(core_path,'lib','core','**','*.rb')].each do |required_file|
+          if !required_file.include?("lib/messenger/") and !required_file.include?("lib/telegram/") and !required_file.include?("lib/whatsapp/")
+            load required_file unless ignore_files.include?(required_file)
+          else
+            files_to_load_later << required_file
+          end
+        end
+
+        files_to_load_later.each do |required_file|
+            load required_file unless ignore_files.include?(required_file)
+        end
+      end
+
+      def load_locales
+        I18n.load_path = Dir[File.join(self.project_path,'config','locales','*.yml')]
+        I18n.config.available_locales = self.config.available_locales
+        I18n.default_locale = self.config.default_locale
+      end
+
+      def load_app # Load App's files: templates/*, controllers/*, helpers/* and models/*
+        $context_blocks = {}
+        $context_html_templates = {}
+        $contexts = Dir[File.join(self.project_path,'bot','contexts','*.rb')].map{|c| c.split("/").last.sub("_context.rb","")} rescue []
+        conversation_file = Dir[File.join(self.project_path,'bot','conversation.rb')]
+        app_files = Dir[File.join(self.project_path,'bot','**','*.rb')]
+        notification_template_files = Dir[File.join(self.project_path,'bot','**','*.erb')]
+        html_template_files = Dir[File.join(self.project_path,'bot','**','*.rhtml')]
+        lib_files = Dir[File.join(self.project_path,'lib','**','*.rb')]
+        (conversation_file+app_files+notification_template_files+html_template_files+lib_files).each do |required_file|
+          if required_file.include?("bot/templates/")
+            file_extension = required_file.split(".").last.to_sym
+            context = File.dirname(required_file).split("/").last.to_sym
+            case file_extension
+              when :erb
+                action = File.basename(required_file,".erb").to_sym
+                $context_blocks[context] = {} if $context_blocks[context].nil?
+                # $context_blocks[context][action] = File.read(required_file)
+                $context_blocks[context][action] = Tilt.new(required_file, nil, default_encoding: "utf-8")
+              when :rhtml
+                action = File.basename(required_file,".rhtml").to_sym
+                $context_html_templates[context] = {} if $context_html_templates[context].nil?
+                $context_html_templates[context][action] = Tilt.new(required_file, nil, default_encoding: "utf-8")
+              end
+          else
+            load required_file
+          end
+        end
+        return true
+      end
+
+      def file_path(file)
+        if File.exist?(file)        
+        else
+          File.open(file, "w") {|f| f.write("") }
+        end
+        return file
+      end
+
+    end
+  end
+end

data/scaffolding/new_project/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+ruby ">= 2.7.0"
+gem 'mysql2', '>= 0.4.4', '< 0.6.0'

data/scaffolding/new_project/application.rb

@@ -0,0 +1,5 @@
+require 'boot'
+
+# Load your libs here
+# require 'somelib'
+#

data/scaffolding/new_project/bot/contexts/main_context.rb

@@ -0,0 +1,10 @@
+class MainContext < Conversation
+
+
+  def blocks
+
+    # here you should to write your context blocks
+
+  end
+
+end

data/scaffolding/new_project/bot/conversation.rb

@@ -0,0 +1,14 @@
+class Conversation < Kogno::Context
+
+  # before_blocks :do_something_before_blocks
+  # after_blocks :do_something_after_blocks
+
+  def do_something_before_blocks
+    # This will be called before the blocks method in the current context will be executed
+  end
+
+  def do_something_after_blocks
+    # This will be called after the blocks method in the current context will be executed
+  end
+
+end

data/scaffolding/new_project/bot/models/user.rb

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+
+end

data/scaffolding/new_project/config/application.rb

@@ -0,0 +1,28 @@
+Kogno::Application.configure do |config|
+
+  config.app_name = "Kogno"
+
+  config.environment = :development
+
+  config.http_port = 3000
+
+  # Internacionalization (I18n)
+  config.available_locales = [:en]
+  config.default_locale = :en
+
+  # Default context for any arrived message or event
+  config.routes.default = :main
+
+  config.sequences.time_elapsed_after_last_usage = 900 # 15 minutes
+
+  config.store_log_in_database = false
+
+  config.typed_postbacks = false
+
+  config.error_notifier.slack = {
+    enable: false,
+    webhook: "<YOUR SLACK WEBHOOOK HERE>"
+  }  
+
+end
+

data/scaffolding/new_project/config/database.yml

@@ -0,0 +1,8 @@
+adapter: mysql2
+pool: 5
+username: your_user_name
+password: your_password
+host:  localhost
+database: your_database_name
+encoding: utf8mb4
+collation: utf8mb4_unicode_ci

data/scaffolding/new_project/config/locales/en.yml

@@ -0,0 +1,4 @@
+en:
+  hello:
+    - "Hello"
+    - "Hi"

data/scaffolding/new_project/config/locales/es.yml

@@ -0,0 +1,3 @@
+es:
+  hello:
+    - "Hola"