kogno 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1cc825f1588ff8f42e48f3c66179b48f19cd8a4870b83873ffabd4113b397eb1
+  data.tar.gz: 840b0e50ecfe3a4a29d3ba1a14a091088eb8c9e5702c55f06fbb3cb6966bb03f
+SHA512:
+  metadata.gz: cfe719306daaa60adeae5f3371fe6152acfba284121bce9ddc61bb69cfc44833388aa642d6fb9cb50f7af50b0e3a92587fe17b9e286f30179aafbf5ada38530e
+  data.tar.gz: fdd5ba07dc827464e9a564fdf4ff5d5a389dd4c3acd365880eeb0449bdad285a5f0118458c68c8774d32bea3cf29d68c3fda462329460f7fe58297e05e64659f

data/bin/kogno

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby -W0
+require 'kogno'
+require 'core/loaders/config_files'
+
+require 'core/bin_helpers/webhook_ctl'
+require 'core/bin_helpers/sequences_ctl'
+require 'core/bin_helpers/scheduled_messages_ctl'
+require 'core/bin_helpers/messenger_ctl'
+require 'core/bin_helpers/telegram_ctl'
+require 'core/bin_helpers/server_ctl'
+require 'core/bin_helpers/scaffolding'
+
+require 'core/lib/messenger/api'
+require 'core/lib/telegram/api'
+
+command = (ARGV[0].to_sym rescue nil)
+
+# Kogno::Application.create_project_folders
+
+help_message = %{Usage:
+  kogno 
+      start|stop|restart
+
+      ## Control daemons separatelly
+      http start|stop|restart|status|fg
+      sequences start|stop|restart|fg
+      scheduled_messages start|stop|restart|fg
+      
+      runner \[ruby code\]
+      new \[proyect name\] <- Create a new chatbot
+      install <- Create sql tables needed
+      messenger
+          menu on|off
+          get_started on|off \[page_id\]
+          greeting on|off
+          update_whitelisted_domains
+          ice_breakers on|off
+      telegram
+          webhook start|stop
+          set_commands #{Kogno::Telegram::Api.command_valid_scopes.join("|")}|all
+          delete_commands #{Kogno::Telegram::Api.command_valid_scopes.join("|")}
+}
+
+case command
+  when :http
+    Kogno::WebhookCtl.options(ARGV[1])
+
+  when :start, :stop, :restart, :status
+    Kogno::ServerCtl.options(ARGV[0])  
+    
+  when :console, :c  
+    require 'irb'
+    require 'irb/completion'    
+    require File.join(Kogno::Application.project_path,'application.rb')
+    logger.write "Loading #{Kogno::Application.config.environment} environment (Kogno #{Gem.loaded_specs["kogno"].version.version})", :bright
+    ARGV.clear
+    IRB.start 
+    IRB.conf[:DEBUG_LEVEL]=0
+    IRB.conf[:PROMPT_MODE] = :MY_PROMPT
+
+  when :sequences, :seq
+    Kogno::SequencesCtl.options(ARGV[1])
+
+  when :scheduled_messages, :sm
+    Kogno::ScheduledMessagesCtl.options(ARGV[1])
+
+  when :runner
+    require File.join(Kogno::Application.project_path,'application.rb')
+    eval(ARGV[1])
+
+  when :new
+    Kogno::Scaffolding.new_project
+
+  when :install
+    Kogno::Scaffolding.install
+
+  when :messenger
+    Kogno::MessengerCtl.options(ARGV)
+
+  when :telegram
+    Kogno::TelegramCtl.options(ARGV)
+
+  when :help
+    puts help_message
+
+  when :version
+    puts Gem.loaded_specs["kogno"].version.version
+
+  else
+    puts help_message
+    
+end

data/lib/boot.rb

@@ -0,0 +1,9 @@
+ActiveSupport::Deprecation.silenced = true
+require 'action_view'
+require 'tilt'
+
+$LOAD_PATH.push("#{Kogno::Application.project_path}/lib")
+
+Kogno::Application.load_core
+Kogno::Application.load_locales
+Kogno::Application.load_app

data/lib/core/bin_helpers/messenger_ctl.rb

@@ -0,0 +1,48 @@
+module Kogno
+class MessengerCtl
+  class << self
+
+    def options(a)
+      page_id = a[3] rescue nil
+      case (a[1].to_sym rescue nil)
+        when :menu
+          if a[2] == 'on'
+            Kogno::Messenger::Api.persistent_menu(page_id)
+          elsif a[2] == 'off'
+            Kogno::Messenger::Api.setting_delete([:persistent_menu])
+          end
+        when :get_started
+          if a[2] == 'on'
+            Kogno::Messenger::Api.get_started_button(page_id)
+          elsif a[2] == 'off'
+            Kogno::Messenger::Api.setting_delete([:get_started], page_id)
+          end
+        when :update_whitelisted_domains
+          Kogno::Messenger::Api.update_whitelisted_domains
+        when :ice_breakers
+          if a[2] == 'on'
+            Kogno::Messenger::Api.ice_breakers()
+          elsif a[2] == 'off'
+            Kogno::Messenger::Api.setting_delete([:ice_breakers])
+          end          
+        when :greeting
+          if a[2] == 'on'
+            Kogno::Messenger::Api.greeting()
+          elsif a[2] == 'off'
+            Kogno::Messenger::Api.setting_delete([:greting])
+          end         
+        else
+          puts %{Usage: 
+            kogno messenger 
+                menu on|off
+                get_started on|off
+                greeting on|off
+                ice_breakers on|off                
+                update_whitelisted_domains
+          }      
+      end
+    end
+
+  end
+end
+end

data/lib/core/bin_helpers/scaffolding.rb

@@ -0,0 +1,203 @@
+require 'fileutils'
+module Kogno
+class Scaffolding
+  class << self
+
+    def new_project
+      project_name = ARGV[1]
+      FileUtils.mkdir(project_name)
+      FileUtils.cp_r("#{Application.core_path}/scaffolding/new_project/.","./#{project_name}/")
+      FileUtils.mkdir("./#{project_name}/config/initializers")
+      FileUtils.mkdir("./#{project_name}/bot/templates")
+      FileUtils.mkdir("./#{project_name}/bot/templates/main")
+      # FileUtils.mkdir("./#{project_name}/bot/extensions")
+      # FileUtils.mkdir("./#{project_name}/bot/models")
+      FileUtils.mkdir("./#{project_name}/bot/helpers")
+      FileUtils.mkdir("./#{project_name}/lib")
+      FileUtils.mkdir("./#{project_name}/logs")
+      FileUtils.mkdir("./#{project_name}/tmp")
+      FileUtils.mkdir("./#{project_name}/web/public")
+      FileUtils.mkdir("./#{project_name}/web/views")
+
+      logger.write "\nA new project has been created at ./#{project_name}", :green
+      logger.write "Next steps:", :bright
+      logger.write "  - cd ./#{project_name}/", :pink
+      logger.write "  - bundle install", :pink
+      logger.write "  - Configure the database in config/database.yml", :pink
+      logger.write "  - kogno install", :pink
+    end
+
+    def install
+      if !self.test_database
+        logger.write "ERROR: check your database configuration in config/database.yml", :red
+      else
+        self.create_tables
+        logger.write "\nNow, you can configure:\n   config/application.rb\n\nAlso some or all these platforms:\n  config/platforms/messenger.rb \n  config/platforms/telegram.rb \n  config/platforms/whatsapp.rb \n  config/nlp.rb\n", :bright        
+      end
+    end
+
+    def test_database
+      require 'core/db'
+      ActiveRecord::Base.connection rescue nil
+      return ActiveRecord::Base.connected?
+    end
+
+    def create_tables
+      logger.write "Creating tables..", :bright
+      logger.write "   users", :green
+      ActiveRecord::Base.connection.execute(%{
+        CREATE TABLE IF NOT EXISTS users (
+          id int(10) unsigned NOT NULL AUTO_INCREMENT,
+          psid varchar(50),
+          platform varchar(50),
+          psid_from_post_comment varchar(50),
+          page_id varchar(50),          
+          name varchar(55), 
+          first_name varchar(55), 
+          last_name varchar(55), 
+          timezone varchar(10), 
+          locale varchar(5),
+          last_usage_at datetime,
+          created_at datetime,
+          updated_at datetime,
+          context varchar(120) DEFAULT NULL,
+          context_params text,
+          session_vars text,
+          last_message_read boolean default false,
+          PRIMARY KEY (id),
+          UNIQUE KEY psid (psid),
+          UNIQUE KEY token (psid_from_post_comment),
+          KEY(page_id),
+          KEY(platform)
+        ) ENGINE=MyISAM
+      })
+
+      logger.write "   kogno_sequences", :green
+      ActiveRecord::Base.connection.execute(%{
+        CREATE TABLE IF NOT EXISTS kogno_sequences(
+        	id int(10) unsigned NOT NULL AUTO_INCREMENT,
+        	user_id int unsigned,
+        	stage varchar(60),
+        	context varchar(60),
+        	last_executed int default 0,
+        	last_hit_at datetime,
+        	execution_time datetime default NULL,
+        	created_at datetime,
+        	updated_at datetime,
+        	primary key(id),
+        	unique key user_context(user_id, context)
+        ) ENGINE=MyISAM
+      })
+
+      logger.write "   kogno_chat_logs", :green
+      ActiveRecord::Base.connection.execute(%{
+        CREATE TABLE IF NOT EXISTS kogno_chat_logs (
+          id int(10) unsigned NOT NULL AUTO_INCREMENT,
+          user_id int(10) unsigned DEFAULT NULL,
+          message_type varchar(32) COLLATE utf8mb4_general_ci DEFAULT NULL,
+          body text COLLATE utf8mb4_general_ci,
+          context varchar(120) COLLATE utf8mb4_general_ci DEFAULT NULL,
+          message varchar(1024) COLLATE utf8mb4_general_ci DEFAULT NULL,
+          payload varchar(120) COLLATE utf8mb4_general_ci DEFAULT NULL,
+          payload_params varchar(1024) COLLATE utf8mb4_general_ci DEFAULT NULL,
+          nlp_entities text COLLATE utf8mb4_general_ci,
+          user_vars text COLLATE utf8mb4_general_ci,
+          response text,
+          new_user boolean default false,
+          processed int(1) unsigned DEFAULT 0,
+          scheduled boolean default false,
+          created_at datetime DEFAULT NULL,
+          updated_at datetime DEFAULT NULL,
+          PRIMARY KEY (id),
+          KEY user_id (user_id)
+        ) ENGINE=MyISAM
+      })
+
+      logger.write "   kogno_scheduled_messages", :green
+      ActiveRecord::Base.connection.execute(%{
+        CREATE TABLE IF NOT EXISTS kogno_scheduled_messages(
+          id int(10) unsigned NOT NULL AUTO_INCREMENT,
+          user_id int(10) unsigned DEFAULT NULL,
+          tag varchar(24) default null,
+          messages text,
+          send_at datetime,
+          created_at datetime,
+          updated_at datetime,
+          PRIMARY KEY (id),
+          KEY user_id (user_id),
+          KEY tag (tag)
+        ) ENGINE=MyISAM
+      })
+
+      logger.write "   kogno_matched_messages", :green
+      ActiveRecord::Base.connection.execute(%{
+        CREATE TABLE IF NOT EXISTS kogno_matched_messages (
+          id int(11) unsigned primary key auto_increment,
+          user_id int(11) unsigned not null,
+          platform_message_id int(11) unsigned default 0,
+          created_at datetime,
+          updated_at datetime,
+          key(user_id),
+          key(platform_message_id)
+        ) ENGINE=MyISAM 
+      })      
+
+      logger.write "   kogno_telegram_chat_groups", :green
+      ActiveRecord::Base.connection.execute(%{
+        CREATE TABLE IF NOT EXISTS kogno_telegram_chat_groups (
+          id int(11) unsigned primary key auto_increment,
+          chat_id bigint not null,
+          title varchar(256),
+          kind enum('group','supergroup','channel'),
+          membership boolean,
+          perms varchar(1024),
+          inviter_user_id int unsigned not null,
+          created_at datetime,
+          updated_at datetime,
+          unique key(chat_id)
+        ) ENGINE=MyISAM 
+      })
+
+      logger.write "   kogno_long_payloads", :green
+      ActiveRecord::Base.connection.execute(%{
+        CREATE TABLE IF NOT EXISTS kogno_long_payloads(
+          id int(11) unsigned primary key auto_increment,
+          token varchar(32),
+          payload varchar(64),
+          params text,
+          unique key token(token),
+          created_at datetime,
+          updated_at datetime
+        ) ENGINE=MyISAM
+      })
+
+      logger.write "   kogno_messenger_recurring_notifications", :green
+      ActiveRecord::Base.connection.execute(%{
+        CREATE TABLE IF NOT EXISTS kogno_messenger_recurring_notifications(
+          id int unsigned auto_increment primary key,
+          user_id int unsigned,
+          token varchar(64),
+          frecuency varchar(32),
+          expires_at datetime,
+          token_status varchar(32),
+          timezone varchar(16),
+          active boolean,
+          key(user_id),
+          key(expires_at),
+          created_at datetime,
+          updated_at datetime
+        ) ENGINE=MyISAM 
+      })
+   
+
+      # logger.write "   Changin database encoding..", :green
+      ActiveRecord::Base.connection.execute("ALTER DATABASE #{ActiveRecord::Base.connection.current_database} CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci")
+      ActiveRecord::Base.connection.execute("ALTER TABLE users CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci")
+      ActiveRecord::Base.connection.execute("ALTER TABLE users MODIFY session_vars text CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci")
+      ActiveRecord::Base.connection.execute("ALTER TABLE kogno_scheduled_messages MODIFY messages text CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci")
+  
+    end
+
+  end
+end
+end

data/lib/core/bin_helpers/scheduled_messages_ctl.rb

@@ -0,0 +1,95 @@
+module Kogno
+class ScheduledMessagesCtl
+  class << self
+
+    def log_environment_info
+      logger.write "Kogno #{Gem.loaded_specs["kogno"].version.version} scheduled_messages server starting in #{Kogno::Application.config.environment}", :bright
+    end
+
+    def pid_file
+      Application.file_path(File.join(Application.project_path,"tmp","scheduled_messages.pid"))
+    end
+
+    def save_pid(pid)
+      File.write(pid_file, pid)
+    end
+
+    def delete_pid
+      save_pid("")
+    end
+
+    def get_pid
+      File.read(File.join(pid_file)).to_i
+    end
+
+    def kill_process(pid)
+      return false if pid.to_i == 0
+      Process.kill("KILL",pid) rescue nil
+    end
+
+    def alive?
+      pid = get_pid
+      return false if pid == 0
+      Process.getpgid(pid) rescue false
+    end
+
+    def start
+      log_environment_info()
+      if get_pid > 0 && alive?
+        logger.write "Error: It has already started..", :red
+      else
+        logger.write "START", :green
+        pid = fork do           
+          Logger.set(:scheduled_messages)
+          require File.join(Kogno::Application.project_path,'application.rb')
+          ScheduledMessage.process_all
+        end
+        save_pid(pid)
+      end
+    end
+
+    def fg
+      log_environment_info()
+      if get_pid > 0 && alive?
+        logger.write "Error: It has already started..", :red
+      else
+        require File.join(Kogno::Application.project_path,'application.rb')
+        ScheduledMessage.process_all
+      end
+    end
+
+    def stop
+      pid = get_pid
+      kill_process(pid)
+      delete_pid
+      logger.write "STOP", :red
+    end
+
+    def status
+      if alive?
+        logger.write "Running | Pid: #{get_pid}..", :green
+      else
+        logger.write "Stopped", :red
+      end
+    end
+
+    def options(option)
+      case option.to_s.to_sym
+        when :start
+          start
+        when :stop
+          stop
+        when :fg
+          fg
+        when :status
+          status
+        when :restart
+          stop
+          start
+        else
+          puts "usage: scheduled_messages stop|start|restart|status|fg"
+      end
+    end
+  end
+end
+end

data/lib/core/bin_helpers/sequences_ctl.rb

@@ -0,0 +1,95 @@
+module Kogno
+class SequencesCtl
+  class << self
+
+    def pid_file
+      Application.file_path(File.join(Application.project_path,"tmp","sequence.pid"))
+    end
+
+    def log_environment_info
+      logger.write "Kogno #{Gem.loaded_specs["kogno"].version.version} sequences server starting in #{Kogno::Application.config.environment}", :bright
+    end
+
+    def save_pid(pid)
+      File.write(pid_file, pid)
+    end
+
+    def delete_pid
+      save_pid("")
+    end
+
+    def get_pid
+      File.read(File.join(pid_file)).to_i
+    end
+
+    def kill_process(pid)
+      return false if pid.to_i == 0
+      Process.kill("KILL",pid) rescue nil
+    end
+
+    def alive?
+      pid = get_pid
+      return false if pid == 0
+      Process.getpgid(pid) rescue false
+    end
+
+    def start
+      if get_pid > 0 && alive?
+        logger.write "Error: It has already started..", :red
+      else 
+        log_environment_info()     
+        logger.write "START", :green
+        pid = fork do
+          Logger.set(:sequences)
+          require File.join(Kogno::Application.project_path,'application.rb')
+          Sequence.process_all
+        end
+        save_pid(pid)
+      end
+    end
+
+    def fg
+      log_environment_info()
+      if get_pid > 0 && alive?
+        logger.write "Error: It has already started..", :red
+      else        
+        require File.join(Kogno::Application.project_path,'application.rb')
+        Sequence.process_all
+      end
+    end
+
+    def stop
+      pid = get_pid
+      kill_process(pid)
+      delete_pid
+      logger.write "STOP", :red
+    end
+
+    def status
+      if alive?
+        logger.write "Running | Pid: #{get_pid}..", :green
+      else
+        logger.write "Stopped", :red
+      end
+    end
+
+    def options(option)
+      case option.to_s.to_sym
+        when :start
+          start
+        when :stop
+          stop
+        when :fg
+          fg
+        when :status
+          status
+        when :restart
+          stop
+          start
+        else
+          puts "usage: sequences stop|start|restart|status|fg"
+      end
+    end
+  end
+end
+end

data/lib/core/bin_helpers/server_ctl.rb

@@ -0,0 +1,127 @@
+module Kogno
+class ServerCtl
+  class << self
+
+    def log_environment_info
+      logger.write "Kogno #{Gem.loaded_specs["kogno"].version.version} server starting in #{Kogno::Application.config.environment}", :bright
+    end
+
+    def pid_file(service)
+      case service
+        when 'webhook'
+          return Application.file_path(File.join(Application.project_path,"tmp","webhook.pid"))
+        when 'sequence'
+          return Application.file_path(File.join(Application.project_path,"tmp","sequence.pid"))
+        when 'scheduled_messages'  
+          return Application.file_path(File.join(Application.project_path,"tmp","scheduled_messages.pid"))
+        else
+          return 0
+      end
+      
+    end
+
+    def webhook_server_file
+      File.join(Application.core_path,"lib/core/web/webhook.rb")
+    end
+
+    def save_pid(pid, service)
+      File.write(pid_file(service), pid)      
+    end
+
+    def delete_pid(service)
+      save_pid("",service)
+    end
+
+    def get_pid(service)
+      File.read(File.join(pid_file(service))).to_i
+    end
+
+    def kill_process(pid)
+      return false if pid.to_i == 0
+      Process.kill("KILL",pid) rescue nil
+    end
+
+    def alive?(service)
+       pid = get_pid(service)
+       return false if pid == 0
+       Process.getpgid(pid) rescue false
+    end
+
+    def start
+      log_environment_info()
+      if get_pid('webhook') > 0
+        logger.write "Http: daemon already started..", :red
+      else
+        logger.write "Http: starting daemon..", :green
+        system(%{
+          RACK_ENV=#{Kogno::Application.config.environment} ruby #{self.webhook_server_file} daemon > /dev/null&
+          echo $! > "#{self.pid_file('webhook')}"
+        })
+      end
+
+      if get_pid('sequence') > 0
+        logger.write "Sequence: daemon already started..", :red
+      else
+        logger.write "Sequence: starting daemon..", :green
+        pid = fork do
+          Logger.set(:sequences)
+          require File.join(Kogno::Application.project_path,'application.rb')
+          Sequence.process_all
+        end
+        save_pid(pid, 'sequence')
+      end
+
+      if get_pid('scheduled_messages') > 0
+        logger.write "Scheduled Messages: daemon already started..", :red
+      else
+        logger.write "Scheduled Messages: starting daemon..", :green
+        pid = fork do
+          Logger.set(:scheduled_messages)
+          require File.join(Kogno::Application.project_path,'application.rb')
+          ScheduledMessage.process_all
+        end
+        save_pid(pid, 'scheduled_messages')
+      end
+
+    end
+
+    def stop
+      sequence_pid = get_pid('sequence')
+      kill_process(sequence_pid)
+      delete_pid('sequence')
+
+      webhook_pid = get_pid('webhook')
+      kill_process(webhook_pid)
+      delete_pid('webhook')
+
+      scheduled_messages_pid = get_pid('scheduled_messages')
+      kill_process(scheduled_messages_pid)
+      delete_pid('scheduled_messages')
+
+      logger.write "STOP", :red
+    end
+
+    def status
+      alive?('webhook') ? logger.write("Http running | Pid: #{get_pid('webhook')}..", :green) : logger.write("Http stopped", :red)
+      alive?('sequence') ? logger.write("Sequences running | Pid: #{get_pid('sequence')}..", :green) : logger.write("Sequence stopped", :red)
+      alive?('scheduled_messages') ? logger.write("Scheduled Messages running | Pid: #{get_pid('scheduled_messages')}..", :green) : logger.write("Scheduled Messages stopped", :red)      
+    end
+
+    def options(option)
+      case option.to_sym
+        when :start
+          start
+        when :stop
+          stop
+        when :status
+          status
+        when :restart
+          stop
+          start
+        else
+          puts "usage: server stop|start|restart|status"
+      end
+    end
+  end
+end
+end