Clever Geek Handbook

Un tutoriel pas à pas sur l'écriture d'un bot Telegram en Ruby (natif)

Bonjour omelettics , j'ai eu récemment l'idée d'écrire un robot Telegram en  Ruby  sur un sujet spécifique, en un mot, ce bot était censé susciter des discussions en ligne à travers des événements de divertissement qui étaient lancés dans le chat par le même bot à un moment aléatoire avec un contexte aléatoire.





Et pendant que j'écrivais ce bot, je me suis familiarisé avec la bibliothèque telegram-bot-ruby (gem), j'ai appris à l'utiliser avec le joyau `` sqlite3-ruby '' et en plus, j'ai été imprégné de nombreuses capacités des bots Telegram, que je souhaite partager avec les chers lecteurs de ce forum, contribuer pour ainsi dire.





Beaucoup de gens veulent écrire des robots Telegram, car c'est amusant et facile.





Au moment d'écrire mon bot, j'ai été confronté au fait qu'il était difficile de trouver du bon matériel sur le sujet du bot Ruby pour Telegram. Par bon, j'entends celui qui parle de fonctionnalités élégantes et belles, telles que celles de l'API Telegram.





Immédiatement je jette un lien vers mon référentiel pour ce post:  ici ,

car lors des tests il y avait des bugs que je ne pouvais pas transférer ici, du coup pourquoi regarder directement dans le référentiel.





À la suite de la lecture de ce sujet, j'espère que le lecteur pourra améliorer son bot déjà écrit, ou télécharger dès maintenant Ruby, Telegram et créer quelque chose de nouveau et de beau. Après tout, comme déjà indiqué dans la "Déclaration du cyberespace":





Dans notre monde, tout ce que l'esprit humain est capable de créer peut être reproduit et diffusé indéfiniment sans aucun coût. Vos usines ne sont plus nécessaires à la transmission globale de la pensée.





  • Je suggère de commencer:





    Ma version Ruby est 2.7.2, mais il est possible que tout fonctionne avec les versions antérieures / ultérieures.





  • La structure approximative de l'application ressemblera à ceci





  • La première étape consiste à créer un Gemfile - le principal détenteur de dépendance pour les gemmes tierces dans Ruby.





  • Déposez  le Gemfile :





    source 'https://rubygems.org'
gem 'json'
gem 'net-http-persistent', '~> 2.9'
gem 'sqlite3'#gem  
gem 'telegram-bot-ruby'#      Telegram

    Nous sauvegardons le fichier et effectuons l'opération dans le terminal





    bundle install

    ( Ruby)  Gemfile  .





  • ( ) GitHub’a, .gitignore  , JetBrains :





  • .gitignore:





    /.idea/

  • , ,  FishSocket:





  •  FishSocket.rb :





    require 'telegram/bot'
require './library/mac-shake'
require './library/database'
require './modules/listener'
require './modules/security'
require './modules/standart_messages'
require './modules/response'
Entry point class
class FishSocket
  include Database
  def initialize
    super
    # Initialize BD
    Database.setup
    # Establishing webhook via @gem telegram/bot, using API-KEY
    Telegram::Bot::Client.run(TelegramOrientedInfo::APIKEY) do |bot|
      # Start time variable, for exclude message what was sends before bot starts
      startbottime = Time.now.toi
      # Active socket listener
      bot.listen do |message|
        # Processing the new income message    #if that message sent after bot run.
        Listener.catchnewmessage(message,bot) if Listener::Security.messageisnew(startbottime,message)
      end
    end
  end
end
Bot start
FishSocket.new

    5 :Gem telegram/bot, mac-shake, listener, security, database.





  • :





  •  mac-shake.rb:





    # frozenstringliteral: true
module TelegramOrientedInfo
APIKEY = ''
end

  • API-KEY , , Telegram API : @BotFather





      API-Key , API-Key, .





  •  security.rb: 





    class FishSocket
  module Listener
    # Module for checks
    module Security
      def messageisnew(starttime, message)
        messagetime = (defined? message.date) ? message.date : message.message.date
        messagetime.toi > starttime
      end
  def message_too_far
    message_date = (defined? Listener.message.date) ? Listener.message.date : Listener.message.message.date
    message_delay = Time.now.to_i - message_date.to_i
    # if message delay less then 5 min then processing message, else ignore
    message_delay > (5 * 60)
  end
  module_function :message_is_new, :message_too_far
end

end
end

    : , ( ). , 5 ( , )





  •  listener.rb:





    class FishSocket
  # Sorting new message module
  module Listener
    attr_accessor :message, :bot
def catch_new_message(message,bot)
  self.message = message
  self.bot = bot

  return false if Security.message_too_far

  case self.message
  when Telegram::Bot::Types::CallbackQuery
    CallbackMessages.process
  when Telegram::Bot::Types::Message
    StandartMessages.process
  end
end

module_function(
  :catch_new_message,
  :message,
  :message=,
  :bot,
  :bot=
)

end
end

    , callback , .  callback . Telegram API 2.0 InlineMessages. , UI ,  InlineKeyboardMarkup  , ,  CallbackMessage, , , Telegram API. .





  •  Database.rb 





    # This module assigned to all database operations
module Database
  attr_accessor :db
require 'sqlite3'
  # This module assigned to create table action
  module Create
    def steamaccountlist
      Database.db.execute <<-SQL
    CREATE TABLE steamaccountlist (
    accesses VARCHAR (128),
    used INTEGER (1))
      SQL
      true
    rescue SQLite3::SQLException
      false
    end
    modulefunction(
        :steamaccount_list
    )
  end
def setup
    # Initializing database file
    self.db = SQLite3::Database.open 'autosteam.db'
    # Try to get custom table, if table not exists - create this one
    unless gettable('steamaccountlist')
      Create.steamaccount_list
    end
  end
# Get all from the selected table
  # @var tablename
  def gettable(tablename)
    db.execute <<-SQL
    Select * from #{tablename}
    SQL
  rescue SQLite3::SQLException
    false
  end
modulefunction(
    :gettable,
    :setup,
    :db,
    :db=
  )
end

    / .





  • ,  fishsocket.rb , , Active Socket Telegram API. - Webhook Telegram API, .





  • -  





     standartmessages.rb, () . : Standart Callback. 





     standartmessages.rb :





    class FishSocket
  module Listener
    # This module assigned to processing all standart messages
    module StandartMessages
      def process
        case Listener.message.text
        when '/getaccount'
          Response.stdmessage 'Very sorry,     '
        else
          Response.stdmessage '   ,   '
        end
      end
  module_function(
      :process
  )
end

end
end

    /getaccount, , . 





  • ,  Response,





     response.rb 





    class FishSocket
  module Listener
    # This module assigned to responses from bot
    module Response
      def stdmessage(message, chatid = false )
        chat = (defined?Listener.message.chat.id) ? Listener.message.chat.id : Listener.message.message.chat.id
        chat = chatid if chatid
        Listener.bot.api.sendmessage(
          parsemode: 'html',
          chatid: chat,
          text: message
        )
      end
  module_function(
    :std_message
  )
end

end
end

    API Telegrama , gem telegram-ruby,  api.sendmessage. Telegram API , .





  • : ( BotFather, API .





    
      
      
    
        
        
        
      
    
    
        
        
        
      
      
    
        
        
        
      
    
    
    
    /getaccount

    .





  • Inline , , Inline .





  • assets/ inlinebutton. inlinebutton.rb : 





    class FishSocket
  # This module assigned to creating InlineKeyboardButton
  module InlineButton
    GETACCOUNT = Telegram::Bot::Types::InlineKeyboardButton.new(text: ' account', callbackdata: 'getaccount')
  end
end

     telegram-ruby-gem  InlineKeyboardButton.





  •  Reponse  : 





    def inlinemessage(message, inlinemarkup,editless = false, chatid = false)
  chat = (defined?Listener.message.chat.id) ? Listener.message.chat.id : Listener.message.message.chat.id
  chat = chatid if chatid
  Listener.bot.api.sendmessage(
    chatid: chat,
    parsemode: 'html',
    text: message,
    replymarkup: inlinemarkup)
end
def generateinlinemarkup(kb, force = false)
  Telegram::Bot::Types::InlineKeyboardMarkup.new(
    inlinekeyboard: kb
  )
end

    modulefunction() :





    modulefunction(
  :stdmessage,
  :generateinlinemarkup,
  :inlinemessage
)

  •  





    /start

    , ,  StandartMessages





    def process
  case Listener.message.text
  when '/getaccount'
    Response.stdmessage 'Very sorry,     '
  when '/start'
    Response.inlinemessage ',    ', Response::generateinlinemarkup(
        InlineButton::GETACCOUNT
    )
  else
    Response.stdmessage '   ,   '
  end
end

  •  callbackmessages.rb  Callback : callbackmessages.rb





    class FishSocket
  module Listener
    # This module assigned to processing all callback messages
    module CallbackMessages
      attraccessor :callback_message
  def process
    self.callback_message = Listener.message.message
    case Listener.message.data
    when 'get_account'
      Listener::Response.std_message('    ')
    end
  end

  module_function(
      :process,
      :callback_message,
      :callback_message=
  )
end

end
end

    StandartMessages , Telegram ,  -  .





  • , . fishsocket.rb





    require 'telegram/bot'
require './library/mac-shake'
require './library/database'
require './modules/listener'
require './modules/security'
require './modules/standartmessages'
require './modules/response'
require './modules/callbackmessages'
require './modules/assets/inlinebutton'
Entry point class
class FishSocket
  include Database
  def initialize
    super

  •  





    /start

    - .





  • , - 2 ForceReply , EditInlineMessage











  • ForceReply,  Response 





    def forcereplymessage(text, chatid = false)
  chat = (defined?Listener.message.chat.id) ? Listener.message.chat.id : Listener.message.message.chat.id
  chat = chatid if chatid
  Listener.bot.api.sendmessage(
    parsemode: 'html',
    chatid: chat,
    text: text,
    replymarkup: Telegram::Bot::Types::ForceReply.new(
      forcereply: true,
      selective: true
    )
  )
end

    modulefunction - .





    ( , )





  • : 





    module InlineButton
  GETACCOUNT = Telegram::Bot::Types::InlineKeyboardButton.new(text: ' account', callbackdata: 'getaccount')
  HAVEPROMO = Telegram::Bot::Types::InlineKeyboardButton.new(text: ' ?', callbackdata: 'forcepromo')
end

  •  





    /start

     StandartMessages





    when '/start'
  Response.inlinemessage ',    ', Response::generateinlinemarkup(
    [
        InlineButton::GETACCOUNT,
        InlineButton::HAVEPROMO
    ]
  )

    , .





  • ,  ForceReply: CallbackMessages





    def process
  self.callbackmessage = Listener.message.message
  case Listener.message.data
  when 'getaccount'
    Listener::Response.stdmessage('    ')
  when 'forcepromo'
    Listener::Response.forcereplymessage(' ')
  end
end

  • , 





    ForceReply, : (Reply) , .     .





  • " ." , StandartMessages :  StandartMessages





    def process
  case Listener.message.text
  when '/getaccount'
    Response.stdmessage 'Very sorry,     '
  when '/start'
    Response.inlinemessage ',    ', Response::generateinlinemarkup(
      [
          InlineButton::GETACCOUNT,
          InlineButton::HAVEPROMO
      ]
    )
  else
    unless Listener.message.replytomessage.nil?
      case Listener.message.replytomessage.text
      when / /
        return Listener::Response.std_message ' ,    :' if Promos::validate Listener.message.text
    return Listener::Response.std_message '  '
  end
end
Response.std_message '   ,   '

end
end

  •  promos.rb   promos.rb





    class FishSocket
  module Listener
    # This module assigned to processing all promo-codes
    module Promos
      def validate(code)
        return true if code =~ /^1[a-zA-Z]*0$/
        false
      end
  module_function(
      :validate
  )
end

end
end

    . FishSocket :  FishSocket





    require 'telegram/bot'
require './library/mac-shake'
require './library/database'
require './modules/listener'
require './modules/security'
require './modules/standartmessages'
require './modules/response'
require './modules/callbackmessages'
require './modules/assets/inline_button'
require './modules/promos'
Entry point class
class FishSocket
  include Database
  def initialize

  • , :





    , : InlineMessages: 





  • "",  





    /start

    " ?" InlineButton





    module InlineButton
  GETACCOUNT = Telegram::Bot::Types::InlineKeyboardButton.new(text: ' account', callbackdata: 'getaccount')
  HAVEPROMO = Telegram::Bot::Types::InlineKeyboardButton.new(text: ' ?', callbackdata: 'forcepromo')
  ADDITIONMENU = Telegram::Bot::Types::InlineKeyboardButton.new(text: '', callbackdata: 'advancedmenu')
end

    StandartMessages





    when '/start'
  Response.inlinemessage ',    ', Response::generateinlinemarkup(
    [
        InlineButton::GETACCOUNT,
        InlineButton::ADDITIONMENU
    ]
  )





  • allbackMessages:  CallbackMessages





    def process
  self.callbackmessage = Listener.message.message
  case Listener.message.data
  when 'getaccount'
    Listener::Response.stdmessage('    ')
  when 'forcepromo'
    Listener::Response.forcereply¨C222Cmenu'
    Listener::Response.inline¨C223Cinline¨C224CButton::HAVE¨C225Cmessage

  •  Response,  inlinemessage Response





    def inlinemessage(message, inlinemarkup, editless = false, chatid = false)
  chat = (defined?Listener.message.chat.id) ? Listener.message.chat.id : Listener.message.message.chat.id
  chat = chatid if chatid
  if editless
    return Listener.bot.api.editmessagetext(
      chatid: chat,
      parsemode: 'html',
      messageid: Listener.message.message.messageid,
      text: message,
      replymarkup: inlinemarkup
    )
  end
  Listener.bot.api.sendmessage(
    chatid: chat,
    parsemode: 'html',
    text: message,
    replymarkup: inline_markup
  )
end

    ? - , , , - , , , .





  • , :





      





    , , ReplyKeyboard. 

    : 





    . 





Postface:  Beaucoup de choses n'ont pas été abordées ici, mais après tout, il y a des mains et de la documentation pour tout, pour moi personnellement, il n'y avait pas assez de description de la lib sur GitHub. Je crois qu'à notre époque, n'importe qui peut devenir un botman, et maintenant cette personne sait quoi faire. Paix pour tous.







More articles:


All Articles