narayana/zhabogram
Archived
2
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Release 1.1

Browse source 
Now reading messages instant (if we're online), otherwise we will got duplicate updates.
Code optimizations and simplifications.
Added missing dependency (fileutils)
This commit is contained in:
annelin 2019-05-31 14:30:25 +03:00
parent 711534b909
commit b160e6f2ff
3 changed files with 100 additions and 131 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

226
inc/telegramclient.rb
View file

@ -17,7 +17,7 @@ class TelegramClient
config.client.application_version = params['version'] || '1.0' # hmm... config.client.application_version = params['version'] || '1.0' # hmm...
config.client.use_test_dc = params['use_test_dc'] || false config.client.use_test_dc = params['use_test_dc'] || false
config.client.system_version = '42' # I think I have permission to hardcode The Ultimate Question of Life, the Universe, and Everything?.. config.client.system_version = '42' # I think I have permission to hardcode The Ultimate Question of Life, the Universe, and Everything?..
config.client.use_file_database = false # wow config.client.use_file_database = true # wow
config.client.use_message_database = false # such library config.client.use_message_database = false # such library
config.client.use_chat_info_database = false # much options config.client.use_chat_info_database = false # much options
config.client.enable_storage_optimizer = false # ... config.client.enable_storage_optimizer = false # ...
@ -37,8 +37,7 @@ class TelegramClient
@me = nil # self telegram profile @me = nil # self telegram profile
@online = nil # we do not know @online = nil # we do not know
@auth_state = 'nil' # too. @auth_state = 'nil' # too.
@cache = {chats: {}, users: {}, users_fullinfo: {}, userpics: {}, unread_msg: {}, incoming_msg: [] } # cache storage @cache = {chats: {}, users: {}, photos: {}} # cache
@files_dir = File.dirname(__FILE__) + '/../sessions/' + @jid + '/files/'
end end
# initialize and connect telegram client # # initialize and connect telegram client #
@ -46,14 +45,14 @@ class TelegramClient
return if @client and @client.ready? return if @client and @client.ready?
@logger.info 'Connecting to Telegram network..' @logger.info 'Connecting to Telegram network..'
@client = TD::Client.new(database_directory: 'sessions/' + @jid, files_directory: 'sessions/' + @jid + '/files/') # create telegram client instance @client = TD::Client.new(database_directory: 'sessions/' + @jid, files_directory: 'sessions/' + @jid + '/files/') # create telegram client instance
@client.on(TD::Types::Update::AuthorizationState) do |update| self.auth_handler(update) end # register auth update handler @client.on(TD::Types::Update::AuthorizationState) do |update| self.auth_handler(update) end # register auth update handler
@client.on(TD::Types::Update::NewMessage) do |update| self.message_handler(update) end # register new message update handler
@client.on(TD::Types::Update::MessageContent) do |update| self.message_edited_handler(update) end # register msg edited handler
@client.on(TD::Types::Update::DeleteMessages) do |update| self.message_deleted_handler(update) end # register msg del handler
@client.on(TD::Types::Update::File) do |update| self.file_handler(update) end # register file handler @client.on(TD::Types::Update::File) do |update| self.file_handler(update) end # register file handler
@client.on(TD::Types::Update::NewChat) do |update| self.new_chat_handler(update) end # register new chat handler @client.on(TD::Types::Update::NewMessage) do |update| self.message_handler(update) end # register new message update handler
@client.on(TD::Types::Update::User) do |update| self.user_handler(update) end # new user update? @client.on(TD::Types::Update::MessageContent) do |update| self.message_edited_handler(update) end # register msg edited handler
@client.on(TD::Types::Update::UserStatus) do |update| self.status_update_handler(update) end # register status handler @client.on(TD::Types::Update::DeleteMessages) do |update| self.message_deleted_handler(update) end # register msg del handler
@client.on(TD::Types::Update::NewChat) do |update| self.new_chat_handler(update) end # register new chat handler
@client.on(TD::Types::Update::User) do |update| self.user_handler(update) end # new user update?
@client.on(TD::Types::Update::UserStatus) do |update| self.status_update_handler(update) end # register status handler
@client.connect() @client.connect()
end end
@ -63,8 +62,8 @@ class TelegramClient
@logger.info 'Disconnecting..' @logger.info 'Disconnecting..'
@cache[:chats].each_key do |chat_id| @xmpp.presence(@jid, chat_id.to_s, :unavailable) end # send offline presences @cache[:chats].each_key do |chat_id| @xmpp.presence(@jid, chat_id.to_s, :unavailable) end # send offline presences
(logout) ? @client.log_out : @client.dispose # logout if needed (logout) ? @client.log_out : @client.dispose # logout if needed
@client = nil
@online = false @online = false
@xmpp.presence(@jid, nil, :unavailable)
end end
@ -112,78 +111,57 @@ class TelegramClient
# message from telegram network handler # # message from telegram network handler #
def message_handler(update, show_date = false) def message_handler(update, show_date = false)
@logger.debug 'Got NewMessage update'
@logger.debug update.message.to_json
@logger.info 'New message from Telegram chat %s' % update.message.chat_id
# we need to ignore incoming messages sometime
@cache[:incoming_msg].shift(900) if @cache[:incoming_msg].size > 1000 # clean cache if it exceeds 1000 messages (but remain last 100 entires)
return if @cache[:incoming_msg].include? update.message.id # ignore message if it's already seen
return if update.message.is_outgoing and update.message.sending_state.instance_of? TD::Types::MessageSendingState::Pending # ignore self outgoing messages return if update.message.is_outgoing and update.message.sending_state.instance_of? TD::Types::MessageSendingState::Pending # ignore self outgoing messages
# media? # @logger.debug 'Got NewMessage update'
file = nil @logger.debug update.message.to_json
prefix = '' @logger.info 'New message from Telegram chat %s' % update.message.chat_id
text = ''
case update.message.content # message content
when TD::Types::MessageContent::Photo # photos prefix = []
file = update.message.content.photo.sizes[-1].photo content = update.message.content
text = "%s.jpg (image/jpeg), %d bytes | %s | %s" % [update.message.content.photo.id.to_s, file.size.to_i, self.format_content_link(file.remote.id, 'image.jpg'), update.message.content.caption.text.to_s]
when TD::Types::MessageContent::Animation # "gif" (mp4) animations # file handling
file = update.message.content.animation.animation file = case content
text = "gif: %s | %s" % [update.message.content.animation.file_name, self.format_content_link(file.remote.id, 'video.mp4')] when TD::Types::MessageContent::Sticker then [content.sticker.sticker, content.sticker.emoji + '.webp']
when TD::Types::MessageContent::Sticker # stickers when TD::Types::MessageContent::VoiceNote then [content.voice_note.voice, 'voice message %i s.' % content.voice_note.duration + '.oga']
file = update.message.content.sticker.sticker when TD::Types::MessageContent::Animation then [content.animation.animation, content.animation.file_name + '.mp4' ]
text = "sticker: %s | %s" % [update.message.content.sticker.emoji.to_s, self.format_content_link(file.remote.id, 'sticker.webp')] when TD::Types::MessageContent::Photo then [content.photo.sizes[-1].photo, content.photo.id + '.jpg']
when TD::Types::MessageContent::Audio # music files when TD::Types::MessageContent::Audio then [content.audio.audio, content.audio.file_name]
file = update.message.content.audio.audio when TD::Types::MessageContent::Video then [content.video.video, content.video.file_name]
text = "%s (%s), %d bytes | %s | %s" % [update.message.content.audio.file_name.to_s, update.message.content.audio.mime_type.to_s, file.size.to_i, self.format_content_link(file.remote.id, update.message.content.audio.file_name.to_s), update.message.content.caption.text.to_s] when TD::Types::MessageContent::Document then [content.document.document, content.document.file_name]
when TD::Types::MessageContent::Video # video files end
file = update.message.content.video.video
text = "%s (%s), %d bytes | %s | %s" % [update.message.content.video.file_name.to_s, update.message.content.video.mime_type.to_s, file.size.to_i, self.format_content_link(file.remote.id, update.message.content.video.file_name.to_s), update.message.content.caption.text.to_s] # text handling
when TD::Types::MessageContent::VoiceNote # voice messages text = case content
file = update.message.content.voice_note.voice when TD::Types::MessageContent::BasicGroupChatCreate, TD::Types::MessageContent::SupergroupChatCreate then "has created chat"
text = "voice message (%i s.) | %s" % [update.message.content.voice_note.duration, self.format_content_link(file.remote.id, 'voice.oga')] when TD::Types::MessageContent::ChatJoinByLink then "joined chat via invite link"
when TD::Types::MessageContent::Document # documents when TD::Types::MessageContent::ChatAddMembers then "invited %s" % self.format_username(message.content.member_user_ids.first)
file = update.message.content.document.document when TD::Types::MessageContent::ChatDeleteMember then "kicked %s" % self.format_username(update.message.content.user_id)
text = "%s (%s), %d bytes | %s | %s" % [update.message.content.document.file_name.to_s, update.message.content.document.mime_type.to_s, file.size.to_i, self.format_content_link(file.remote.id, update.message.content.document.file_name.to_s), update.message.content.caption.text.to_s] when TD::Types::MessageContent::PinMessage then "pinned message: %s" % self.format_message(update.message.chat_id, content.message_id)
when TD::Types::MessageContent::BasicGroupChatCreate, TD::Types::MessageContent::SupergroupChatCreate # group created when TD::Types::MessageContent::ChatChangeTitle then "chat title set to: %s" % update.message.content.title.to_s
text = "created" when TD::Types::MessageContent::Location then "coordinates: %s | https://www.google.com/maps/search/%s,%s/" % [content.location.latitude, content.location.longitude]
when TD::Types::MessageContent::ChatJoinByLink # joined member when TD::Types::MessageContent::Photo, TD::Types::MessageContent::Audio, TD::Types::MessageContent::Video, TD::Types::MessageContent::Document then content.caption.text
text = "joined" when TD::Types::MessageContent::Text then content.text.text
when TD::Types::MessageContent::ChatAddMembers # add members else "unknown message type %s" % update.message.content.class
text = "added " end
update.message.content.member_user_ids.each do |member| text = text + self.format_username(member) + ' ' end
when TD::Types::MessageContent::ChatDeleteMember # kicked member # download file if needed
text = "removed %s" % self.format_username(update.message.content.user_id) @client.download_file(file[0].id) if file and not file[0].local.is_downloading_completed
when TD::Types::MessageContent::PinMessage # pinned message
@client.get_message(update.message.chat_id, update.message.content.message_id).then { |message| text = "pinned message: %s" % message.content.text.text.to_s }.wait
when TD::Types::MessageContent::ChatChangeTitle # changed chat title
text = "chat title set to: %s" % update.message.content.title.to_s
when TD::Types::MessageContent::Location # location
location = "%s,%s" % [update.message.content.location.latitude.to_s, update.message.content.location.longitude.to_s]
text = "coordinates: %s | https://www.google.com/maps/search/%s/" % [location, location]
when TD::Types::MessageContent::Text # plain text
text = update.message.content.text.text.to_s
else
text = "unknown message type %s" % update.message.content.class
end
@client.download_file(file.id) if file # download it if already not
# forwards, replies and message id.. # forwards, replies and message id..
prefix += "[%s]" % DateTime.strptime((update.message.date+Time.now.getlocal(@timezone).utc_offset).to_s,'%s').strftime("[%d %b %Y %H:%M:%S]") if show_date prefix << DateTime.strptime((update.message.date+Time.now.getlocal(@timezone).utc_offset).to_s,'%s').strftime("%d %b %Y %H:%M:%S") if show_date # show date if its
prefix += "fwd from %s | " % self.format_username(update.message.forward_info.sender_user_id) if update.message.forward_info.instance_of? TD::Types::MessageForwardInfo::MessageForwardedFromUser # fwd from user prefix << (update.message.is_outgoing ? '➡ ' : '⬅ ') + update.message.id.to_s # message direction
prefix += "fwd from %s | " % self.format_chatname(update.message.forward_info.chat_id) if update.message.forward_info.instance_of? TD::Types::MessageForwardInfo::MessageForwardedPost # fwd from chat prefix << "fwd: %s" % self.format_username(update.message.forward_info.sender_user_id) if update.message.forward_info.instance_of? TD::Types::MessageForwardInfo::MessageForwardedFromUser # fwd from user
prefix += "reply to %s | " % self.format_reply(update.message.chat_id, update.message.reply_to_message_id) if update.message.reply_to_message_id.to_i != 0 # reply to prefix << "fwd: %s" % self.format_chatname(update.message.forward_info.chat_id) if update.message.forward_info.instance_of? TD::Types::MessageForwardInfo::MessageForwardedPost # fwd from chat
prefix << "reply: %s" % self.format_message(update.message.chat_id, update.message.reply_to_message_id, false) if update.message.reply_to_message_id.to_i != 0 # reply to
prefix << "file: %s" % self.format_file(file[0], file[1]) if file
prefix << "user: %s" % self.format_username(update.message.sender_user_id) if update.message.chat_id < 0 # show sender in group chats
# text formatting text = (prefix << text).join(' | ')
text = "%s | %s | %s\n%s" % [update.message.id, self.format_username(update.message.sender_user_id), prefix, text] if update.message.chat_id < 0 # groupchats
text = "%s %s | %s%s" % [(update.message.is_outgoing ? '🠚' : '🠘'), update.message.id.to_s, prefix, text] if update.message.chat_id > 0 # private chats
# send and add message id to unreads # read message & send it to xmpp
@cache[:unread_msg][update.message.chat_id] = update.message.id @client.view_messages(update.message.chat_id, [update.message.id], force_read: true)
@cache[:incoming_msg] << update.message.id
@xmpp.message(@jid, update.message.chat_id.to_s, text) @xmpp.message(@jid, update.message.chat_id.to_s, text)
end end
@ -219,18 +197,6 @@ class TelegramClient
text = "✗ %s |" % update.message_ids.join(',') text = "✗ %s |" % update.message_ids.join(',')
@xmpp.message(@jid, update.chat_id.to_s, text) @xmpp.message(@jid, update.chat_id.to_s, text)
end end
# file msg -- symlink to download path #
def file_handler(update)
@logger.debug 'Got File update'
@logger.debug update.to_json
if update.file.local.is_downloading_completed then
fname = update.file.local.path.to_s
target = "%s/%s%s" % [@@content_path, Digest::SHA256.hexdigest(update.file.remote.id), File.extname(fname)]
@logger.debug 'Downloading of <%s> completed! Link to <%s>' % [fname, target]
File.symlink(fname, target)
end
end
# status update handler # # status update handler #
def status_update_handler(update) def status_update_handler(update)
@ -240,6 +206,18 @@ class TelegramClient
self.process_status_update(update.user_id, update.status, false) self.process_status_update(update.user_id, update.status, false)
end end
# file msg -- symlink to download path #
def file_handler(update)
@logger.debug 'Got File update'
@logger.debug update.to_json
if update.file.local.is_downloading_completed then
source = update.file.local.path.to_s
target = self.format_file(update.file, update.file.local.path, true)
@logger.debug 'Downloading of <%s> completed! Created link to <%s>' % [source, target]
File.symlink(source, target)
end
end
########################################### ###########################################
## LooP handlers ######################### ## LooP handlers #########################
@ -419,40 +397,33 @@ class TelegramClient
# send message and mark chat as read # # send message and mark chat as read #
@client.send_message(chat_id, message, reply_to_message_id: reply_to) @client.send_message(chat_id, message, reply_to_message_id: reply_to)
@client.view_messages(chat_id, [@cache[:unread_msg].delete(chat_id)], force_read: true) if @cache[:unread_msg][chat_id]
end end
# update users information and save it to cache # # update users information and save it to cache #
def process_chat_info(chat_id, subscription = true) def process_chat_info(chat_id, subscription = true)
@logger.debug 'Updating chat id %s..' % chat_id.to_s @logger.debug 'Updating chat id %s..' % chat_id.to_s
@client.get_chat(chat_id).then { |chat|
# fullfil cache.. pasha durov, privet. #
@client.get_chat(chat_id).then { |chat|
@cache[:chats][chat_id] = chat # cache chat @cache[:chats][chat_id] = chat # cache chat
@client.download_file(chat.photo.small.id).wait if chat.photo # download userpic @client.download_file(chat.photo.small.id).then{|f| @cache[:photos][chat_id] = f}.wait if chat.photo # download userpic
@cache[:userpics][chat_id] = Digest::SHA1.hexdigest(IO.binread(self.format_content_link(chat.photo.small.remote.id, 'image.jpg', true))) if chat.photo and File.exist? self.format_content_link(chat.photo.small.remote.id, 'image.jpg', true) # cache userpic @xmpp.presence(@jid, chat_id.to_s, :subscribe, nil, nil, chat.title.to_s) if subscription # send subscription request
@xmpp.presence(@jid, chat_id.to_s, :subscribe, nil, nil, @cache[:chats][chat_id].title.to_s) if subscription # send subscription request self.process_status_update(chat_id, chat.title.to_s, true) if chat.id < 0 # groups presence
@xmpp.presence(@jid, chat_id.to_s, nil, :chat, @cache[:chats][chat_id].title.to_s, nil, @cache[:userpics][chat_id]) if chat.type.instance_of? TD::Types::ChatType::BasicGroup or chat.type.instance_of? TD::Types::ChatType::Supergroup # send :chat status if its group/supergroup
# self.process_user_info(chat.type.user_id) if chat.type.instance_of? TD::Types::ChatType::Private # process user if its a private chat
}.wait }.wait
end end
# update user info in cache and sync status to roster if needed # # update user info in cache and sync status to roster if needed #
def process_user_info(user_id) def process_user_info(user_id)
@logger.debug 'Updating user id %s..' % user_id.to_s @logger.debug 'Updating user id %s..' % user_id
@client.get_user(user_id).then { |user| @client.get_user(user_id).then { |user|
@cache[:users][user_id] = user # add to cache @cache[:users][user_id] = user # add to cache
self.process_status_update(user_id, user.status) # status update @client.get_user_full_info(user_id).then{ |bio| @cache[:chats][user_id].attributes[:client_data] = bio.bio }.wait
}.wait self.process_status_update(user_id, user.status, true) # status update
@client.get_user_full_info(user_id).then{ |user_info|
@cache[:users_fullinfo][user_id] = user_info # here is user "bio"
}.wait }.wait
end end
# convert telegram status to XMPP one # convert telegram status to XMPP one
def process_status_update(user_id, status, immed = true) def process_status_update(user_id, status, immed = true)
@logger.debug "Processing status update for user id %s.." % user_id.to_s @logger.debug "Processing status update for user id %s.." % user_id.to_s
xmpp_show, xmpp_status, xmpp_photo = nil xmpp_show, xmpp_status, xmpp_photo = nil
case status case status
when TD::Types::UserStatus::Online when TD::Types::UserStatus::Online
xmpp_show = nil xmpp_show = nil
@ -469,8 +440,13 @@ class TelegramClient
when TD::Types::UserStatus::LastMonth when TD::Types::UserStatus::LastMonth
xmpp_show = :unavailable xmpp_show = :unavailable
xmpp_status = "Last seen last month" xmpp_status = "Last seen last month"
else
xmpp_show = :chat
xmpp_status = status
end end
xmpp_photo = @cache[:userpics][user_id] if @cache[:userpics].key? user_id
xmpp_photo = self.format_file(@cache[:photos][user_id], 'image.jpg', true) if @cache[:photos].include? user_id
xmpp_photo = (File.exist? xmpp_photo.to_s) ? Base64.encode64(IO.binread(xmpp_photo)) : nil
@xmpp.presence(@jid, user_id.to_s, nil, xmpp_show, xmpp_status, nil, xmpp_photo, immed) @xmpp.presence(@jid, user_id.to_s, nil, xmpp_show, xmpp_status, nil, xmpp_photo, immed)
end end
@ -487,13 +463,9 @@ class TelegramClient
lastname = @cache[:users][chat_id].last_name # <N/FAMILY> lastname = @cache[:users][chat_id].last_name # <N/FAMILY>
username = @cache[:users][chat_id].username # <NICKNAME> username = @cache[:users][chat_id].username # <NICKNAME>
phone = @cache[:users][chat_id].phone_number # <TEL> phone = @cache[:users][chat_id].phone_number # <TEL>
bio = @cache[:users_fullinfo][chat_id].bio if @cache[:users_fullinfo].key? chat_id # <DESC> bio = @cache[:chats][chat_id].client_data # <DESC>
end userpic = self.format_file(@cache[:photos][chat_id], 'image.jpg', true) if @cache[:photos].include? chat_id
userpic = (File.exist? userpic.to_s) ? Base64.encode64(IO.binread(userpic)) : nil
# userpic #
if @cache[:chats][chat_id].photo then # we have userpic
userpic = self.format_content_link(@cache[:chats][chat_id].photo.small.remote.id, 'image.jpg', true)
userpic = (File.exist? userpic) ? Base64.encode64(IO.binread(userpic)) : nil
end end
# .. # ..
@ -504,21 +476,19 @@ class TelegramClient
def resolve_username(username) def resolve_username(username)
resolved = nil resolved = nil
if username[0] == '@' then # @username if username[0] == '@' then # @username
@client.search_public_chat(username[1..-1]).then {|chat| resolved = chat.id}.wait @client.search_public_chat(username[1..-1]).then {|chat| resolved = '@' + chat.id.to_s}.wait
elsif username[0..3] == 'http' or username[0..3] == 't.me' then # chat link elsif username[0..3] == 'http' or username[0..3] == 't.me' then # chat link
@client.join_chat_by_invite_link(username) @client.join_chat_by_invite_link(username)
elsif username.to_i != 0 then # user id elsif username.to_i != 0 then # user id
resolved = username resolved = username
end end
return '' if not resolved return resolved || ''
return '@' + resolved.to_s
end end
########################################### ###########################################
## Format functions ####################### ## Format functions #######################
########################################### ###########################################
# format tg user name # # format tg user name #
def format_username(user_id, show_id = false) def format_username(user_id, show_id = false)
return if user_id == 0 # @me return if user_id == 0 # @me
@ -538,22 +508,20 @@ class TelegramClient
name = '%s (%s)' % [@cache[:chats][chat_id].title, chat_id] name = '%s (%s)' % [@cache[:chats][chat_id].title, chat_id]
return name return name
end end
# format reply# # format reply#
def format_reply(chat_id, message_id) def format_message(chat_id, message_id, full = true)
text = '' text = ''
@client.get_message(chat_id, message_id).then { |message| text = "%s" % message.content.text.text.to_s }.wait @client.get_message(chat_id, message_id).then { |message| text = message.content.text.text }.wait
text = (text.lines.count > 1) ? "%s..." % text.split("\n")[0] : text text = (text.lines.count > 1 and not full) ? "%s.." % text.split("\n")[0] : text
return "%s (%s..)" % [message_id.to_s, text] return "msg %s [%s]" % [message_id.to_s, text]
end end
# format content link # def format_file(file, filename, local = false)
def format_content_link(file_id, fname, local = false) if local then return "%s/%s%s" % [@@content_path, Digest::SHA256.hexdigest(file.remote.id), File.extname(filename)] end
prefix = (local) ? @@content_path : @@content_link return "%s (%d kbytes) | %s/%s%s" % [filename, file.size/1024, @@content_link, Digest::SHA256.hexdigest(file.remote.id), File.extname(filename).to_s]
path = "%s/%s%s" % [prefix, Digest::SHA256.hexdigest(file_id), File.extname(fname)]
return path
end end
# state functions # # state functions #
def online?() @online end def online?() @online end
def tz_set?() return @timezone != '-00:00' end def tz_set?() return @timezone != '-00:00' end

4
inc/xmppcomponent.rb
View file

@ -104,7 +104,7 @@ class XMPPComponent
# transport shutdown # # transport shutdown #
def disconnect() def disconnect()
@logger.info "Closing connections..." @logger.info "Closing connections..."
@sessions.each do |jid, session| @sessions[jid].disconnect() end @sessions.each do |jid, session| @sessions[jid].disconnect(); self.presence(jid, nil, :unavailable) end
@component.close() @component.close()
end end
@ -139,7 +139,7 @@ class XMPPComponent
req.add_element('nick', {'xmlns' => 'http://jabber.org/protocol/nick'} ).add_text(nickname) unless nickname.nil? # nickname req.add_element('nick', {'xmlns' => 'http://jabber.org/protocol/nick'} ).add_text(nickname) unless nickname.nil? # nickname
req.add_element('x', {'xmlns' => 'vcard-temp:x:update'} ).add_element("photo").add_text(photo) unless photo.nil? # nickname req.add_element('x', {'xmlns' => 'vcard-temp:x:update'} ).add_element("photo").add_text(photo) unless photo.nil? # nickname
@logger.debug req.to_s @logger.debug req.to_s
(immediately) ? @component.send(req) : @presence_que.store(from+to, req) (immediately) ? @component.send(req) : @presence_que.store(req.from.to_s+req.to.to_s, req)
end end
# request timezone information # # request timezone information #

1
zhabogram.rb
View file

@ -6,6 +6,7 @@ require 'xmpp4r/discovery'
require 'digest' require 'digest'
require 'base64' require 'base64'
require 'sqlite3' require 'sqlite3'
require 'fileutils'
require 'tdlib-ruby' require 'tdlib-ruby'
require_relative 'inc/telegramclient' require_relative 'inc/telegramclient'
require_relative 'inc/xmppregister' require_relative 'inc/xmppregister'