kogno 1.0.1

data/lib/core/lib/telegram/api.rb

@@ -0,0 +1,197 @@
+module Kogno
+module Telegram
+
+class Api
+
+  require 'uri'
+  require 'net/http'
+  require 'openssl'
+
+  class << self
+
+    def request(body,type,method=:post) # :messages, :messenger_profile
+
+      url = URI("#{Kogno::Application.config.telegram.api_url}/#{Kogno::Application.config.telegram.token}/#{type}")
+      
+      logger.write "REQUEST TO: #{url}", :pink
+      logger.write "SENT: #{JSON.parse(body)}", :blue      
+
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      case method
+        when :delete
+          request = Net::HTTP::Delete.new(url)
+        else 
+          request = Net::HTTP::Post.new(url)
+      end    
+
+      request["content-type"] = 'application/json'
+
+      request.body = body
+
+      response = http.request(request)
+      # logger.debug_json JSON.parse(body), :green
+      response_hash = JSON.parse(response.read_body, {:symbolize_names => true})
+      logger.write "RESPONSE: #{response_hash}\n", :light_blue
+      return(response_hash)
+
+    end
+
+    def set_webhook(webhook, drop_pending_updates=true)
+      body = {
+        url: webhook,
+        drop_pending_updates: drop_pending_updates
+      }
+      logger.write_json body, :blue
+      request(body.to_json, "setWebhook")
+    end
+
+    def delete_webhook(drop_pending_updates=true)
+      request(
+        {
+          drop_pending_updates: drop_pending_updates
+        }.to_json,
+        "deleteWebhook"
+      )
+    end
+
+    def send(recipient_id,message, type="sendMessage")
+      body = {
+        chat_id: recipient_id
+      }.merge(message).to_json
+
+      return(self.request(body,type))
+
+    end
+
+    def answer_inline_query(inline_query_id, results, extra_params={})
+      body = {
+        inline_query_id: inline_query_id,
+        results: results
+      }.merge(extra_params)
+      logger.write_json body, :blue
+      return(self.request(body.to_json,"answerInlineQuery"))
+
+    end
+
+    def set_commands(commands,scope, lang=nil)
+      valid_scopes = self.command_valid_scopes
+      raise "Error, invalid scope. Must be one of these:  #{valid_scopes.join(",")}" unless valid_scopes.include?(scope)
+      body = {
+        commands: commands.map{|command, description| {command: command, description: description}},
+        scope: {
+          type: scope
+        }
+      }          
+      body[:language_code] = lang unless lang.nil?
+      logger.write "SET COMMAND"  
+      logger.write_json body, :blue
+      return(self.request(body.to_json, "setMyCommands"))
+    end
+
+    def set_all_commands
+      Kogno::Application.config.telegram.commands.each do |conf|
+        set_commands(conf[:commands], conf[:scope], conf[:lang])
+      end
+    end
+
+    def set_scope_commands(scope)
+      Kogno::Application.config.telegram.commands.each do |conf|        
+        set_commands(conf[:commands], conf[:scope], conf[:lang]) if scope == conf[:scope]
+      end
+    end
+
+    def delete_commands(scope, lang=nil)
+      body = {
+        scope: {
+          type: scope
+        }
+      }
+      body[:language_code] = lang unless lang.nil?
+      logger.write "DELETE COMMAND"  
+      logger.write_json body, :blue
+      return(self.request(body.to_json, "deleteMyCommands"))
+    end
+
+
+    def command_valid_scopes
+      [:default, :all_private_chats, :all_group_chats, :all_chat_administrators]
+    end 
+
+    def answer_callback_query(callback_query_id, params={})
+      body = {
+        callback_query_id: callback_query_id
+      }.merge(params).to_json
+      return(self.request(body,"answerCallbackQuery"))
+    end
+
+    def text(text, settings={})
+
+      result = {
+        :text => text
+      }
+
+      result = result.merge(self.add_remove_keyboard_reply_markup) if settings[:remove_keyboard]
+
+      result
+
+    end
+
+    def inline_keyboard_markup(text,replies, update={})
+
+      result = {
+        text: text,
+        disable_web_page_preview: true,
+        reply_markup: { 
+          inline_keyboard: replies.first.class == Array ? replies : [replies] # needs to be an array of arrays
+        }        
+      }
+
+      result = result.merge(update) unless update.nil?
+
+      result
+
+    end
+
+    def add_inline_keyboard_markup(replies)
+        {
+          reply_markup: { 
+            inline_keyboard: replies # needs to be an array of arrays
+          } 
+        }  
+    end
+
+    def keyboard(text, buttons, one_time_keyboard=true) #type can be: :contact or :location 
+      {
+        text: text,
+        disable_web_page_preview: true,
+        reply_markup: { 
+          keyboard: buttons.first.class == Array ? buttons : [buttons], # needs to be an array of arrays
+          one_time_keyboard: one_time_keyboard
+        }
+      }
+    end
+
+    protected
+
+    def add_remove_keyboard_reply_markup
+      {
+        reply_markup: { 
+          remove_keyboard: true
+        }        
+      }
+    end
+
+    def add_reply_markup(settings)
+      reply_markup = {}
+      reply_markup[:inline_keyboard] = settings[:inline_keyboard]
+    end
+
+  end  
+
+end
+
+end
+end

data/lib/core/lib/telegram/chat_activity.rb

@@ -0,0 +1,111 @@
+module Kogno
+module Telegram
+class ChatActivity
+
+  def initialize(data)
+    @data = data
+  end
+
+  def type
+    :chat_activity
+  end
+
+  def chat
+    @data[:chat]
+  end
+
+  def chat_id
+    @data[:chat][:id]
+  end
+
+  def chat_title
+    @data[:chat][:title]
+  end
+
+  def chat_type
+    @data[:chat][:type]
+  end
+
+  def inviter_user_id
+    @data[:from][:id]
+  end
+
+  def get_kgn_id
+    nil
+  end
+
+  def chat_perms
+    perms = @data[:new_chat_member]
+    {
+      can_be_edited: perms[:can_be_edited],
+      can_manage_chat: perms[:can_be_edited],
+      can_change_info: perms[:can_be_edited],
+      can_post_messages: perms[:can_be_edited],
+      can_edit_messages: perms[:can_be_edited],
+      can_delete_messages: perms[:can_be_edited],
+      can_invite_users: perms[:can_be_edited],
+      can_restrict_members: perms[:can_be_edited],
+      can_promote_members: perms[:can_be_edited],
+      can_manage_voice_chats: perms[:can_be_edited]
+    }
+  end
+
+  def chat_membership_status    
+    if ["member","administrator"].include?(@data[:new_chat_member][:status])
+      return true
+    elsif  ["left","kicked"].include?(@data[:new_chat_member][:status])
+      return false
+    end
+  end
+
+  def get_context(user,notification, notification_group,chat=nil)
+    # Here you can use different contexts by self.post_id
+    context_class = Context::router(Kogno::Application.config.routes.chat_activity)[:class]
+    context_route = :main
+    context = context_class.new(user,self,notification,context_route, notification_group, chat)
+    return(context)
+  end
+
+  def handle_event(debug=false)
+
+    begin
+
+      user = User.find_or_create_by_psid(self.inviter_user_id, :telegram)
+      self.set_nlp(user.locale)
+      I18n.locale = user.locale unless user.locale.nil?
+      notification = Notification.new(user,self)
+      chat = TelegramChatGroup.find_or_create({
+        chat_id: self.chat_id,
+        title: self.chat_title,
+        kind: self.chat_type,
+        inviter_user_id: user.id,
+        membership: self.chat_membership_status       
+      })
+
+      notification = Notification.new(user,self)
+      notification_group = Notification.new(chat,self)
+
+      context = get_context(user,notification, notification_group, chat)
+      context.run_for_chat_activity_only
+
+      notification.send
+      notification_group.send
+
+      if Kogno::Application.config.store_log_in_database
+        user.log_message(self, :chat_activity_received) 
+        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/telegram/inline_query.rb

@@ -0,0 +1,112 @@
+module Kogno
+module Telegram
+class InlineQuery  < Kogno::Message
+
+  attr_accessor :event
+
+  @overwritten_payload = nil
+
+  def initialize(data)
+    @data = data
+  end
+
+  def type
+    :inline_query
+  end
+
+  def platform
+    :telegram
+  end
+
+  def page_id
+    nil
+  end
+
+  def chat_type
+    @data[:chat_type]
+  end
+
+  def id
+    return @data[:id]
+  end
+
+  def sender_id
+    return @data[:from][:id]
+  end
+
+  def sender_first_name
+    return @data[:from][:first_name] rescue ""
+  end
+
+  def sender_last_name
+    return @data[:from][:last_name] rescue "" 
+  end
+
+  def payload_action
+    nil
+  end
+
+  def empty?
+    self.text.to_s.empty?
+  end
+
+
+  def text
+    return (@data[:query].to_s rescue "")
+  end
+
+  def get_context(user,notification)
+    # Here you can use different contexts by self.post_id
+    context_class = Context::router(Kogno::Application.config.routes.inline_query)[:class]
+    context = context_class.new(user,self,notification,nil, nil, user)
+    return(context)
+  end
+
+  def handle_event(debug=false)
+
+    begin
+
+      user = User.find_or_create_by_psid(self.sender_id, :telegram)
+      user.first_name = self.sender_first_name
+      user.last_name = self.sender_last_name
+      user.save
+
+      self.set_nlp(user.locale)
+      I18n.locale = user.locale unless user.locale.nil?
+
+      notification = Notification.new(user,self)
+
+      logger.write "--------------------MESSAGE: #{self.text}--------------------------", :green
+
+      context = get_context(user,notification)
+
+      return({post_comment: self, user: user, notification: notification, context: context}) if debug
+
+      context.run_for_text_only
+
+      notification.answer_inline_query(self.id, self.sender_id)
+
+      recipient_psid = notification.get_psid_from_response_log
+
+      user = User.find_or_create_by_psid(self.sender_id, :telegram)
+
+      if Kogno::Application.config.store_log_in_database
+        user.log_message(self, :inline_query_received) 
+        user.log_response(notification)
+      end
+
+      logger.write "**********************#{user.context}***********************", :green
+     
+    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