kogno 1.0.1

data/lib/core/bin_helpers/telegram_ctl.rb

@@ -0,0 +1,48 @@
+module Kogno
+class TelegramCtl
+  class << self
+
+    def options(a)
+      error = false
+      case (a[1].to_sym rescue nil)
+        when :webhook
+          if a[2] == 'start'
+            Kogno::Telegram::Api.set_webhook("#{Kogno::Application.config.telegram.webhook_https_server}#{Kogno::Application.config.telegram.webhook_route}", Kogno::Application.config.telegram.webhook_drop_pending_updates)
+          elsif a[2] == 'stop'
+            Kogno::Telegram::Api.delete_webhook(Kogno::Application.config.telegram.webhook_drop_pending_updates)
+          else
+            error = true  
+          end
+        when :set_commands
+          puts a[2]
+          scope = a[2]
+          if scope == "all"
+            puts "Aca222"
+            Kogno::Telegram::Api.set_all_commands
+          elsif Kogno::Telegram::Api.command_valid_scopes.include?(scope.to_sym)
+            Kogno::Telegram::Api.set_scope_commands(scope.to_sym)
+          else
+            error = true
+          end
+        when :delete_commands
+          scope = a[2]
+          if Kogno::Telegram::Api.command_valid_scopes.include?(scope.to_sym)
+            Kogno::Telegram::Api.delete_commands(scope)
+          else
+            error = true
+          end
+        else
+          error = true    
+      end
+
+      puts %{Usage: 
+        kogno telegram 
+            webhook start|stop
+            set_commands #{Kogno::Telegram::Api.command_valid_scopes.join("|")}|all
+            delete_commands #{Kogno::Telegram::Api.command_valid_scopes.join("|")}
+      } if error       
+    end
+
+  end
+end
+end

data/lib/core/bin_helpers/webhook_ctl.rb

@@ -0,0 +1,96 @@
+module Kogno
+class WebhookCtl
+  class << self
+
+    def pid_file
+      Application.file_path(File.join(Application.project_path,"tmp","webhook.pid"))
+    end
+
+    def log_environment_info
+      logger.write "Kogno #{Gem.loaded_specs["kogno"].version.version} http server starting in #{Kogno::Application.config.environment}", :bright
+    end
+
+    def server_file
+      File.join(Application.core_path,"lib/core/web/webhook.rb")
+    end
+
+    def save_pid(pid)
+      File.write(self.pid_file, pid)
+    end
+
+    def delete_pid
+      save_pid("")
+    end
+
+    def get_pid
+      File.read(File.join(self.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        
+        system(%{
+          RACK_ENV=#{Kogno::Application.config.environment} ruby #{self.server_file} daemon > /dev/null&
+          echo $! > "#{self.pid_file}"
+        })
+        logger.write "START", :green
+      end
+    end
+
+    def fg
+      log_environment_info()
+      if get_pid > 0 && alive?
+        logger.write "Error: It has already started..", :red
+      else
+        system("RACK_ENV=#{Kogno::Application.config.environment} ruby #{self.server_file}")
+      end
+    end
+
+    def stop
+      pid = self.get_pid
+      self.kill_process(pid)
+      self.delete_pid
+      logger.write "STOP", :red
+    end
+
+    def status
+      if alive?
+        logger.write "Running | Pid: #{self.get_pid}..", :green
+      else
+        logger.write "Stopped", :red
+      end
+    end
+
+    def options(option)
+      case option.to_s.to_sym
+        when :start
+          self.start
+        when :stop
+          self.stop
+        when :restart
+          self.stop
+          self.start
+        when :status
+          self.status
+        when :fg
+          self.fg
+        else
+          puts "usage: http stop|start|restart|status|fg"
+      end
+    end
+  end
+end
+end

data/lib/core/db.rb

@@ -0,0 +1,8 @@
+  db_configuration_file = File.join(Kogno::Application.project_path,'config', 'database.yml')
+  db_configuration = YAML.load(File.read(db_configuration_file))
+
+  def db_connect(db_configuration)
+    ActiveRecord::Base.establish_connection(db_configuration)
+  end
+
+  db_connect(db_configuration)

data/lib/core/extensions/array.rb

@@ -0,0 +1,28 @@
+
+class Array
+
+  def replace_keys(defaults)
+    new_a = []
+    self.each do |v|
+      if v.class == Array
+        new_a << v.replace_keys(defaults)
+      elsif v.class == Hash
+        new_h = v
+        defaults.each do |find,replace|
+          # logger.debug "#{find} => #{replace}"
+          # logger.debug "v:#{v}"
+          new_h = new_h.transform_keys{|k| k == find ? replace : k}
+        end
+        new_a << new_h
+      else
+        new_a << v
+      end
+    end
+    return(new_a)
+  end
+
+  def deep_symbolize_keys!
+    self.map{|h| h.deep_symbolize_keys!}
+  end
+
+end

data/lib/core/extensions/hash.rb

@@ -0,0 +1,12 @@
+
+class Hash
+
+  def replace_keys(defaults)
+    new_hash = self
+    defaults.each do |find,replace|
+      new_hash = new_hash.transform_keys{|k| k == find ? replace : k}
+    end
+    return(new_hash)
+  end
+
+end

data/lib/core/extensions/logger.rb

@@ -0,0 +1,70 @@
+class Logger  
+
+  def write(str, color=nil)
+    if color.nil?
+      self.info(str)
+    else
+      self.info(Logger::colorize(str, color.to_sym))
+    end
+  end
+
+  def write_json(json,color=nil)
+    write(JSON.pretty_generate(json),color)
+  end
+
+  def debug(str,color=nil)
+    write(str,color) if Kogno::Application.config.environment == :development
+  end
+
+  def debug_json(json,color=nil)
+     write(JSON.pretty_generate(json),color) if Kogno::Application.config.environment == :development
+  end
+  
+
+  class << self
+
+    def set(daemon)
+      case daemon
+        when :webhook
+          $logger = Logger.new(File.join(Kogno::Application.project_path,'logs','http.log'))
+        when :sequences
+          $logger = Logger.new(File.join(Kogno::Application.project_path,'logs','sequences.log'))
+        when :scheduled_messages
+          $logger = Logger.new(File.join(Kogno::Application.project_path,'logs','scheduled_messages.log'))  
+        else
+          $logger = Logger.new(STDOUT)
+      end
+
+      # logger.datetime_format = ""
+      $logger.formatter = proc do |severity, datetime, progname, msg|
+        "#{msg}\n"
+      end
+
+      ActiveRecord::Base.logger = $logger
+    end
+
+
+    def colors
+      @colors ||= {
+        bright: 1,
+        blue: 34,
+        green: 32,
+        light_blue: 36,
+        pink: 35,
+        red: 31,
+        white: 256,
+        yellow: 33
+      }
+    end
+
+    def colorize(str, color_code)
+      "\e[#{colors[color_code]}m#{str}\e[0m"
+    end
+
+  end
+
+end
+
+def logger
+ $logger
+end

data/lib/core/extensions/string.rb

@@ -0,0 +1,6 @@
+class String
+
+  def to_payload
+    self.downcase.gsub(" ","_").to_sym
+  end
+end

data/lib/core/extensions/wit.rb

@@ -0,0 +1,60 @@
+require 'wit'
+class Wit
+
+
+  def initialize(opts = {})
+    @access_token = opts[:access_token]
+    @api_version = opts[:api_version] || "20210928"
+
+    if opts[:logger]
+      @logger = opts[:logger]
+    end
+  end
+
+  def message_with_context(msg, context=nil)
+    params = {}
+    params[:q] = msg unless msg.nil?
+    params[:context] = context.to_json unless context.nil?
+    res = req(logger, @access_token, Net::HTTP::Get, '/message', params)
+    return res
+  end
+
+  def entity_create(params) # extras = {roles: [], keywords: [], lookups: []}
+    res = req(logger, @access_token, Net::HTTP::Post, "/entities", {}, params)
+    return res
+  end
+
+  def entity_keyword_add(name, role, keyword, synonyms)
+    res = req(logger, @access_token, Net::HTTP::Post, "/entities/#{name}/keywords", {}, {keyword: keyword, synonyms: synonyms})
+    return res
+  end
+
+  def entity_keyword_remove(name, keyword)
+    res = req(logger, @access_token, Net::HTTP::Delete, "/entities/#{name}/keywords/#{keyword}")
+    return res    
+  end
+
+  def req(logger, access_token, meth_class, path, params={}, payload={})
+    uri = URI(WIT_API_HOST + path)
+    uri.query = URI.encode_www_form(params)
+    # logger.debug uri, :green
+    request = meth_class.new(uri)
+    request['authorization'] = 'Bearer ' + access_token
+    request['accept'] = 'application/vnd.wit.' + @api_version + '+json'
+    request.add_field 'Content-Type', 'application/json'
+    request.body = payload.to_json
+    # logger.debug request, :yellow
+    Net::HTTP.start(uri.host, uri.port, {:use_ssl => uri.scheme == 'https'}) do |http|
+      rsp = http.request(request)
+      json = JSON.parse(rsp.body)
+      if rsp.code.to_i != 200
+        error_msg = (json.is_a?(Hash) and json.has_key?('error')) ?  json['error'] : json
+        logger.write "Wit.ai responded with an error: #{error_msg}", :red
+        raise Error.new("Wit.ai responded with an error: #{error_msg}")
+      end
+      # logger.debug("#{meth_class} #{uri} #{json}")
+      json
+    end
+  end
+
+end

data/lib/core/global_methods.rb

@@ -0,0 +1,67 @@
+def t(key, **interpolation)
+  translation = I18n.t(key, **interpolation)
+  if translation.class == Array
+    return translation[rand(translation.count)]
+  else
+    return translation
+  end
+end
+
+def l(value, **format)
+  I18n.l(value, **format)
+end
+
+def set_payload(payload,params=nil)
+  unless params.nil?
+    output_payload = "#{payload}:#{params.to_json}" 
+  else
+    output_payload = payload
+  end
+  return output_payload
+end
+
+def reload!(print = true)
+  puts 'Reloading ...' if print
+  Kogno::Application.load_locales
+  Kogno::Application.load_app
+  return true
+end
+
+def sql_query(query)
+  # logger.debug "sql_query = > #{query}", :green
+  results = ActiveRecord::Base.connection.select_all(query)
+  {
+    columns: results.columns, 
+    rows: results.rows
+  }
+  results
+end
+
+def html_template(route, params={})
+  
+  route_array = route.to_s.split("/")
+  if route_array.count == 2
+    action_group = route_array[0]
+    action = route_array[1]
+  elsif route_array.count == 1
+    if self.type == :context
+      action_group = self.name
+      action = route_array[0]
+    else
+      raise "Can't determine the context for template #{route}"
+      return false
+    end
+  else
+      raise "Wrong format on route. Expected:'context_name/template_name'"
+      return false
+  end
+
+  template = $context_html_templates[action_group.to_sym][action.to_sym]
+  if template.nil?
+    logger.write "Template bot/templates/#{action_group}/#{action}.rhtml not found.", :red
+    return ""
+  else
+    return template.render(self, params)
+  end
+
+end

data/lib/core/helpers/string.rb

@@ -0,0 +1,105 @@
+def tabulate(text, divider, max_chars, orientation = "left")
+  amount = text.count(divider)
+  amount = amount + 1
+  spacing = max_chars / amount
+  text = text.split(divider)
+  text.each do |str|
+    str = str.strip
+    index = text.find_index(str)
+    if str[0] == " "
+      text[index] = str[1..-1]
+    elsif str[str.length - 1] == " "
+      text[index] = str.chop
+    end
+  end
+  new_text = []
+  #even_space = 0
+
+  case orientation
+  when "left"
+    new_text = tabulateLeft(text, spacing)
+  when "right"
+    new_text = tabulateRight(text, spacing)
+  when "middle"
+    new_text = tabulateMiddle(text, spacing)
+  end
+
+  return new_text.join(divider)
+end
+
+def tabulateLeft(text, spacing)
+  new_text = []
+  text.each do |str|
+    tab_str = str
+    spaces = spacing - str.length
+
+    if text.find_index(tab_str).even?
+      if spacing > tab_str.length && text.find_index(tab_str) != 0
+        tab_str.prepend(" ")
+        spaces -= 1
+      end
+      while spaces > 0 do
+        tab_str.concat(" ")
+        spaces -= 1
+      end
+    else
+      if spacing > tab_str.length
+        tab_str.prepend(" ")
+        spaces -= 1
+      end
+      while spaces > 0 do
+        tab_str.concat(" ")
+        spaces -= 1
+      end
+    end
+    new_text << tab_str
+  end
+  return new_text
+end
+
+def tabulateRight(text, spacing)
+  new_text = []
+  text.each do |str|
+    tab_str = str
+    spaces = spacing - str.length
+
+    if text.find_index(tab_str).even?
+      if spacing > tab_str.length
+        tab_str.concat(" ")
+        spaces -= 1
+      end
+      while spaces > 0 do
+        tab_str.prepend(" ")
+        spaces -= 1
+      end
+    else
+      while spaces > 0 do
+        tab_str.prepend(" ")
+        spaces -= 1
+      end
+    end
+    new_text << tab_str
+  end
+  return new_text
+end
+
+def tabulateMiddle(text, spacing)
+  new_text = []
+  text.each do |str|
+    tab_str = str
+    spaces = spacing - str.length
+    divided = spaces / 2
+    concat = false
+
+    while spaces > divided do
+      tab_str.prepend(" ")
+      spaces -= 1
+    end
+    while spaces > 0 do
+      tab_str.concat(" ")
+      spaces -= 1
+    end
+    new_text << tab_str
+  end
+  return new_text
+end

data/lib/core/lib/base_config.rb

@@ -0,0 +1,17 @@
+module Kogno
+
+  class BaseConfig 
+
+    def initialize(*attr_accessors)
+      attr_accessors.each do |attr_accessor_name|
+        self.class.send(:attr_accessor, attr_accessor_name)
+      end
+    end
+
+    def to_h
+      self.as_json
+    end
+
+  end
+  
+end

data/lib/core/lib/block_params.rb

@@ -0,0 +1,4 @@
+module Kogno
+  class BlockParams < Array
+  end
+end