Class: Telegram::Bot::UpdatesController

Inherits:
AbstractController::Base
  • Object
show all
Extended by:
Session::ConfigMethods
Includes:
AbstractController::Callbacks, Commands, Instrumentation, ReplyHelpers, Rescue, Translation
Defined in:
lib/telegram/bot/updates_controller.rb,
lib/telegram/bot/updates_controller/rescue.rb,
lib/telegram/bot/updates_controller/session.rb,
lib/telegram/bot/updates_controller/testing.rb,
lib/telegram/bot/updates_controller/commands.rb,
lib/telegram/bot/updates_controller/translation.rb,
lib/telegram/bot/updates_controller/typed_update.rb,
lib/telegram/bot/updates_controller/reply_helpers.rb,
lib/telegram/bot/updates_controller/log_subscriber.rb,
lib/telegram/bot/updates_controller/instrumentation.rb,
lib/telegram/bot/updates_controller/message_context.rb,
lib/telegram/bot/updates_controller/callback_query_context.rb

Overview

Base class to create update processors. With callbacks, session and helpers.

Public methods ending with ‘!` handle messages with commands. Message text is automatically parsed into method arguments. Be sure to use default values and splat arguments in every action method to not get errors, when user sends command without necessary args / with extra args.

def start!(token = nil, *)
  if token
    # ...
  else
    # ...
  end
end

def help!(*)
  respond_with :message, text:
end

To process plain text messages (without commands) or other updates just define public method with name of payload type. By default they receive payload as an argument, but some of them are called with more usefuk args:

def message(message)
  respond_with :message, text: "Echo: #{message['text']}"
end

def inline_query(query, offset)
  answer_inline_query results_for_query(query, offset), is_personal: true
end

To process update run:

ControllerClass.dispatch(bot, update)

There is also ability to run action without update:

ControllerClass.new(bot, from: telegram_user, chat: telegram_chat).
  process(:help, *args)

Defined Under Namespace

Modules: CallbackQueryContext, Commands, Instrumentation, MessageContext, ReplyHelpers, Rescue, Session, Testing, Translation, TypedUpdate Classes: LogSubscriber

Constant Summary collapse

PAYLOAD_TYPES = 
%w[
  message
  edited_message
  channel_post
  edited_channel_post
  inline_query
  chosen_inline_result
  callback_query
  shipping_query
  pre_checkout_query
  poll
  poll_answer
].freeze

Constants included from Commands

Commands::CMD_REGEX

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Session::ConfigMethods

session_store=, use_session!

Methods included from Instrumentation

instrument, #process_action, #respond_with

Methods included from Translation

#action_name_i18n_key, #localize, #translate

Methods included from ReplyHelpers

#answer_callback_query, #answer_inline_query, #answer_pre_checkout_query, #answer_shipping_query, #edit_message, #reply_with, #respond_with

Methods included from Commands

#action_for_command, #action_for_message, command_from_text

Constructor Details

#initialize(bot = nil, update = nil) ⇒ UpdatesController

Second argument can be either update object with hash access & string keys or Hash with ‘:from` or `:chat` to override this values and assume that update is nil.



124
125
126
127
128
129
130
131
132
133
 
# File 'lib/telegram/bot/updates_controller.rb', line 124

def initialize(bot = nil, update = nil)
  if update.is_a?(Hash) && (update.key?(:from) || update.key?(:chat))
    options = update
    update = nil
  end
  @_update = update
  @_bot = bot
  @_chat, @_from = options && options.values_at(:chat, :from)
  @_payload, @_payload_type = self.class.payload_from_update(update)
end

Class Method Details

.dispatch(*args) ⇒ Object

Initialize controller and process update.



106
107
108
 
# File 'lib/telegram/bot/updates_controller.rb', line 106

def dispatch(*args)
  new(*args).dispatch
end

.payload_from_update(update) ⇒ Object 



110
111
112
113
114
115
 
# File 'lib/telegram/bot/updates_controller.rb', line 110

def payload_from_update(update)
  update && PAYLOAD_TYPES.find do |type|
    item = update[type]
    return [item, type] if item
  end
end

Instance Method Details

#action_for_callback_query ⇒ Object 



207
208
209
 
# File 'lib/telegram/bot/updates_controller.rb', line 207

def action_for_callback_query
  [payload_type, [payload['data']]]
end

#action_for_chosen_inline_result ⇒ Object 



203
204
205
 
# File 'lib/telegram/bot/updates_controller.rb', line 203

def action_for_chosen_inline_result
  [payload_type, [payload['result_id'], payload['query']]]
end

#action_for_default_payload ⇒ Object 



195
196
197
 
# File 'lib/telegram/bot/updates_controller.rb', line 195

def action_for_default_payload
  [payload_type, [payload]]
end

#action_for_inline_query ⇒ Object 



199
200
201
 
# File 'lib/telegram/bot/updates_controller.rb', line 199

def action_for_inline_query
  [payload_type, [payload['query'], payload['offset']]]
end

#action_for_payload ⇒ Object

Calculates action name and args for payload. Uses ‘action_for_#payload_type` methods. If this method doesn’t return anything it uses fallback with action same as payload type. Returns array ‘[action, args]`.



187
188
189
190
191
192
193
 
# File 'lib/telegram/bot/updates_controller.rb', line 187

def action_for_payload
  if payload_type
    send("action_for_#{payload_type}") || action_for_default_payload
  else
    [:unsupported_payload_type, []]
  end
end

#action_for_poll_answer ⇒ Object 



211
212
213
 
# File 'lib/telegram/bot/updates_controller.rb', line 211

def action_for_poll_answer
  [payload_type, [payload['poll_id'], payload['option_ids']]]
end

#action_missing(action, *_args) ⇒ Object

Silently ignore unsupported messages to not fail when user crafts an update with usupported command, callback query context, etc.



217
218
219
220
 
# File 'lib/telegram/bot/updates_controller.rb', line 217

def action_missing(action, *_args)
  logger.debug { "The action '#{action}' is not defined in #{self.class.name}" } if logger
  nil
end

#action_type ⇒ Object

There are multiple ways how action name is calculated for update (see Commands, MessageContext, etc.). This method represents the way how action was calculated for current udpate.

Some of possible values are ‘:payload, :command, :message_context`.



178
179
180
 
# File 'lib/telegram/bot/updates_controller.rb', line 178

def action_type
  action_options[:type] || :payload
end

#chat ⇒ Object

Accessor to ‘’chat’‘ field of payload. Also tries `’chat’‘ in `’message’‘ when there is no such field in payload.

Can be overriden with ‘chat` option for #initialize.



139
140
141
142
143
144
145
146
147
148
 
# File 'lib/telegram/bot/updates_controller.rb', line 139

def chat
  @_chat ||=
    if payload
      if payload.is_a?(Hash)
        payload['chat'] || payload['message'] && payload['message']['chat']
      else
        payload.try(:chat) || payload.try(:message).try!(:chat)
      end
    end
end

#dispatch ⇒ Object

Processes current update.



157
158
159
160
 
# File 'lib/telegram/bot/updates_controller.rb', line 157

def dispatch
  action, args = action_for_payload
  process(action, *args)
end

#from ⇒ Object

Accessor to ‘’from’‘ field of payload. Can be overriden with `from` option for #initialize.



152
153
154
 
# File 'lib/telegram/bot/updates_controller.rb', line 152

def from
  @_from ||= payload.is_a?(Hash) ? payload['from'] : payload.try(:from)
end

#process(action, *args) ⇒ Object

It provides support for passing array as action, where first vaule is action name and second is action metadata. This metadata is stored inside action_options



167
168
169
170
171
 
# File 'lib/telegram/bot/updates_controller.rb', line 167

def process(action, *args)
  action, options = action if action.is_a?(Array)
  @_action_options = options || {}
  super
end