818 lines
24 KiB
Ruby
818 lines
24 KiB
Ruby
# Copyright (C) 2012-2021 Zammad Foundation, http://zammad-foundation.org/
|
|
|
|
class Telegram
|
|
|
|
attr_accessor :client
|
|
|
|
=begin
|
|
|
|
check token and return bot attributes of token
|
|
|
|
bot = Telegram.check_token('token')
|
|
|
|
=end
|
|
|
|
def self.check_token(token)
|
|
api = TelegramAPI.new(token)
|
|
begin
|
|
bot = api.getMe
|
|
rescue
|
|
raise Exceptions::UnprocessableEntity, 'invalid api token'
|
|
end
|
|
bot
|
|
end
|
|
|
|
=begin
|
|
|
|
set webhook for bot
|
|
|
|
success = Telegram.set_webhook('token', callback_url)
|
|
|
|
returns
|
|
|
|
true|false
|
|
|
|
=end
|
|
|
|
def self.set_webhook(token, callback_url)
|
|
if callback_url.match?(%r{^http://}i)
|
|
raise Exceptions::UnprocessableEntity, 'webhook url need to start with https://, you use http://'
|
|
end
|
|
|
|
api = TelegramAPI.new(token)
|
|
begin
|
|
api.setWebhook(callback_url)
|
|
rescue
|
|
raise Exceptions::UnprocessableEntity, 'Unable to set webhook at Telegram, seems to be a invalid url.'
|
|
end
|
|
true
|
|
end
|
|
|
|
=begin
|
|
|
|
create or update channel, store bot attributes and verify token
|
|
|
|
channel = Telegram.create_or_update_channel('token', params)
|
|
|
|
returns
|
|
|
|
channel # instance of Channel
|
|
|
|
=end
|
|
|
|
def self.create_or_update_channel(token, params, channel = nil)
|
|
|
|
# verify token
|
|
bot = Telegram.check_token(token)
|
|
|
|
if !channel && Telegram.bot_duplicate?(bot['id'])
|
|
raise Exceptions::UnprocessableEntity, 'Bot already exists!'
|
|
end
|
|
|
|
if params[:group_id].blank?
|
|
raise Exceptions::UnprocessableEntity, 'Group needed!'
|
|
end
|
|
|
|
group = Group.find_by(id: params[:group_id])
|
|
if !group
|
|
raise Exceptions::UnprocessableEntity, 'Group invalid!'
|
|
end
|
|
|
|
# generate random callback token
|
|
callback_token = if Rails.env.test?
|
|
'callback_token'
|
|
else
|
|
SecureRandom.urlsafe_base64(10)
|
|
end
|
|
|
|
# set webhook / callback url for this bot @ telegram
|
|
callback_url = "#{Setting.get('http_type')}://#{Setting.get('fqdn')}/api/v1/channels_telegram_webhook/#{callback_token}?bid=#{bot['id']}"
|
|
Telegram.set_webhook(token, callback_url)
|
|
|
|
if !channel
|
|
channel = Telegram.bot_by_bot_id(bot['id'])
|
|
if !channel
|
|
channel = Channel.new
|
|
end
|
|
end
|
|
channel.area = 'Telegram::Bot'
|
|
channel.options = {
|
|
bot: {
|
|
id: bot['id'],
|
|
username: bot['username'],
|
|
first_name: bot['first_name'],
|
|
last_name: bot['last_name'],
|
|
},
|
|
callback_token: callback_token,
|
|
callback_url: callback_url,
|
|
api_token: token,
|
|
welcome: params[:welcome],
|
|
goodbye: params[:goodbye],
|
|
}
|
|
channel.group_id = group.id
|
|
channel.active = true
|
|
channel.save!
|
|
channel
|
|
end
|
|
|
|
=begin
|
|
|
|
check if bot already exists as channel
|
|
|
|
success = Telegram.bot_duplicate?(bot_id)
|
|
|
|
returns
|
|
|
|
channel # instance of Channel
|
|
|
|
=end
|
|
|
|
def self.bot_duplicate?(bot_id, channel_id = nil)
|
|
Channel.where(area: 'Telegram::Bot').each do |channel|
|
|
next if !channel.options
|
|
next if !channel.options[:bot]
|
|
next if !channel.options[:bot][:id]
|
|
next if channel.options[:bot][:id] != bot_id
|
|
next if channel.id.to_s == channel_id.to_s
|
|
|
|
return true
|
|
end
|
|
false
|
|
end
|
|
|
|
=begin
|
|
|
|
get channel by bot_id
|
|
|
|
channel = Telegram.bot_by_bot_id(bot_id)
|
|
|
|
returns
|
|
|
|
true|false
|
|
|
|
=end
|
|
|
|
def self.bot_by_bot_id(bot_id)
|
|
Channel.where(area: 'Telegram::Bot').each do |channel|
|
|
next if !channel.options
|
|
next if !channel.options[:bot]
|
|
next if !channel.options[:bot][:id]
|
|
return channel if channel.options[:bot][:id].to_s == bot_id.to_s
|
|
end
|
|
nil
|
|
end
|
|
|
|
=begin
|
|
|
|
generate message_id for message
|
|
|
|
message_id = Telegram.message_id(message)
|
|
|
|
returns
|
|
|
|
message_id # 123456@telegram
|
|
|
|
=end
|
|
|
|
def self.message_id(params)
|
|
message_id = nil
|
|
%i[message edited_message].each do |key|
|
|
next if !params[key]
|
|
next if !params[key][:message_id]
|
|
|
|
message_id = params[key][:message_id]
|
|
break
|
|
end
|
|
if message_id
|
|
%i[message edited_message].each do |key|
|
|
next if !params[key]
|
|
next if !params[key][:chat]
|
|
next if !params[key][:chat][:id]
|
|
|
|
message_id = "#{message_id}.#{params[key][:chat][:id]}"
|
|
end
|
|
end
|
|
if !message_id
|
|
message_id = params[:update_id]
|
|
end
|
|
"#{message_id}@telegram"
|
|
end
|
|
|
|
=begin
|
|
|
|
client = Telegram.new('token')
|
|
|
|
=end
|
|
|
|
def initialize(token)
|
|
@token = token
|
|
@api = TelegramAPI.new(token)
|
|
end
|
|
|
|
=begin
|
|
|
|
client.message(chat_id, 'some message', language_code)
|
|
|
|
=end
|
|
|
|
def message(chat_id, message, language_code = 'en')
|
|
return if Rails.env.test?
|
|
|
|
locale = Locale.find_by(alias: language_code)
|
|
if !locale
|
|
locale = Locale.where('locale LIKE :prefix', prefix: "#{language_code}%").first
|
|
end
|
|
|
|
if locale
|
|
message = Translation.translate(locale[:locale], message)
|
|
end
|
|
|
|
@api.sendMessage(chat_id, message)
|
|
end
|
|
|
|
def user(params)
|
|
{
|
|
id: params[:message][:from][:id],
|
|
username: params[:message][:from][:username],
|
|
first_name: params[:message][:from][:first_name],
|
|
last_name: params[:message][:from][:last_name]
|
|
}
|
|
end
|
|
|
|
def to_user(params)
|
|
Rails.logger.debug { 'Create user from message...' }
|
|
Rails.logger.debug { params.inspect }
|
|
|
|
# do message_user lookup
|
|
message_user = user(params)
|
|
|
|
auth = Authorization.find_by(uid: message_user[:id], provider: 'telegram')
|
|
|
|
# create or update user
|
|
login = message_user[:username] || message_user[:id]
|
|
user_data = {
|
|
login: login,
|
|
firstname: message_user[:first_name],
|
|
lastname: message_user[:last_name],
|
|
}
|
|
if auth
|
|
user = User.find(auth.user_id)
|
|
user.update!(user_data)
|
|
else
|
|
if message_user[:username]
|
|
user_data[:note] = "Telegram @#{message_user[:username]}"
|
|
end
|
|
user_data[:active] = true
|
|
user_data[:role_ids] = Role.signup_role_ids
|
|
user = User.create(user_data)
|
|
end
|
|
|
|
# create or update authorization
|
|
auth_data = {
|
|
uid: message_user[:id],
|
|
username: login,
|
|
user_id: user.id,
|
|
provider: 'telegram'
|
|
}
|
|
if auth
|
|
auth.update!(auth_data)
|
|
else
|
|
Authorization.create(auth_data)
|
|
end
|
|
|
|
user
|
|
end
|
|
|
|
def to_ticket(params, user, group_id, channel)
|
|
UserInfo.current_user_id = user.id
|
|
|
|
Rails.logger.debug { 'Create ticket from message...' }
|
|
Rails.logger.debug { params.inspect }
|
|
Rails.logger.debug { user.inspect }
|
|
Rails.logger.debug { group_id.inspect }
|
|
|
|
# prepare title
|
|
title = '-'
|
|
%i[text caption].each do |area|
|
|
next if !params[:message]
|
|
next if !params[:message][area]
|
|
|
|
title = params[:message][area]
|
|
break
|
|
end
|
|
if title == '-'
|
|
%i[sticker photo document voice].each do |area|
|
|
|
|
next if !params[:message]
|
|
next if !params[:message][area]
|
|
next if !params[:message][area][:emoji]
|
|
|
|
title = params[:message][area][:emoji]
|
|
break
|
|
rescue
|
|
# just go ahead
|
|
title
|
|
|
|
end
|
|
end
|
|
if title.length > 60
|
|
title = "#{title[0, 60]}..."
|
|
end
|
|
|
|
# find ticket or create one
|
|
state_ids = Ticket::State.where(name: %w[closed merged removed]).pluck(:id)
|
|
possible_tickets = Ticket.where(customer_id: user.id).where.not(state_id: state_ids).order(:updated_at)
|
|
ticket = possible_tickets.find_each.find { |possible_ticket| possible_ticket.preferences[:channel_id] == channel.id }
|
|
|
|
if ticket
|
|
# check if title need to be updated
|
|
if ticket.title == '-'
|
|
ticket.title = title
|
|
end
|
|
new_state = Ticket::State.find_by(default_create: true)
|
|
if ticket.state_id != new_state.id
|
|
ticket.state = Ticket::State.find_by(default_follow_up: true)
|
|
end
|
|
ticket.save!
|
|
return ticket
|
|
end
|
|
|
|
ticket = Ticket.new(
|
|
group_id: group_id,
|
|
title: title,
|
|
state_id: Ticket::State.find_by(default_create: true).id,
|
|
priority_id: Ticket::Priority.find_by(default_create: true).id,
|
|
customer_id: user.id,
|
|
preferences: {
|
|
channel_id: channel.id,
|
|
telegram: {
|
|
bid: params['bid'],
|
|
chat_id: params[:message][:chat][:id]
|
|
}
|
|
},
|
|
)
|
|
ticket.save!
|
|
ticket
|
|
end
|
|
|
|
def to_article(params, user, ticket, channel, article = nil)
|
|
|
|
if article
|
|
Rails.logger.debug { 'Update article from message...' }
|
|
else
|
|
Rails.logger.debug { 'Create article from message...' }
|
|
end
|
|
Rails.logger.debug { params.inspect }
|
|
Rails.logger.debug { user.inspect }
|
|
Rails.logger.debug { ticket.inspect }
|
|
|
|
UserInfo.current_user_id = user.id
|
|
|
|
if article
|
|
article.preferences[:edited_message] = {
|
|
message: {
|
|
created_at: params[:message][:date],
|
|
message_id: params[:message][:message_id],
|
|
from: params[:message][:from],
|
|
},
|
|
update_id: params[:update_id],
|
|
}
|
|
else
|
|
article = Ticket::Article.new(
|
|
ticket_id: ticket.id,
|
|
type_id: Ticket::Article::Type.find_by(name: 'telegram personal-message').id,
|
|
sender_id: Ticket::Article::Sender.find_by(name: 'Customer').id,
|
|
from: user(params)[:username],
|
|
to: "@#{channel[:options][:bot][:username]}",
|
|
message_id: Telegram.message_id(params),
|
|
internal: false,
|
|
preferences: {
|
|
message: {
|
|
created_at: params[:message][:date],
|
|
message_id: params[:message][:message_id],
|
|
from: params[:message][:from],
|
|
},
|
|
update_id: params[:update_id],
|
|
}
|
|
)
|
|
end
|
|
|
|
# add photo
|
|
if params[:message][:photo]
|
|
|
|
# find photo with best resolution for us
|
|
photo = nil
|
|
max_width = 650 * 2
|
|
last_width = 0
|
|
last_height = 0
|
|
|
|
params[:message][:photo].each do |file|
|
|
if !photo
|
|
photo = file
|
|
last_width = file['width'].to_i
|
|
last_height = file['height'].to_i
|
|
end
|
|
next if file['width'].to_i >= max_width || file['width'].to_i <= last_width
|
|
|
|
photo = file
|
|
last_width = file['width'].to_i
|
|
last_height = file['height'].to_i
|
|
end
|
|
if last_width > 650
|
|
last_width = (last_width / 2).to_i
|
|
last_height = (last_height / 2).to_i
|
|
end
|
|
|
|
# download photo
|
|
photo_result = get_file(params, photo)
|
|
body = "<img style=\"width:#{last_width}px;height:#{last_height}px;\" src=\"data:image/png;base64,#{Base64.strict_encode64(photo_result.body)}\">"
|
|
|
|
if params[:message][:caption]
|
|
body += "<br>#{params[:message][:caption].text2html}"
|
|
end
|
|
article.content_type = 'text/html'
|
|
article.body = body
|
|
article.save!
|
|
return article
|
|
end
|
|
|
|
# add document
|
|
if params[:message][:document]
|
|
|
|
document = params[:message][:document]
|
|
thumb = params[:message][:document][:thumb]
|
|
body = ' '
|
|
|
|
if thumb
|
|
width = thumb[:width]
|
|
height = thumb[:height]
|
|
thumb_result = get_file(params, thumb)
|
|
body = "<img style=\"width:#{width}px;height:#{height}px;\" src=\"data:image/png;base64,#{Base64.strict_encode64(thumb_result.body)}\">"
|
|
end
|
|
if params[:message][:caption]
|
|
body += "<br>#{params[:message][:caption].text2html}"
|
|
end
|
|
document_result = get_file(params, document)
|
|
article.content_type = 'text/html'
|
|
article.body = body
|
|
article.save!
|
|
|
|
Store.remove(
|
|
object: 'Ticket::Article',
|
|
o_id: article.id,
|
|
)
|
|
Store.add(
|
|
object: 'Ticket::Article',
|
|
o_id: article.id,
|
|
data: document_result.body,
|
|
filename: document[:file_name],
|
|
preferences: {
|
|
'Mime-Type' => document[:mime_type],
|
|
},
|
|
)
|
|
return article
|
|
end
|
|
|
|
# add video
|
|
if params[:message][:video]
|
|
|
|
video = params[:message][:video]
|
|
thumb = params[:message][:video][:thumb]
|
|
body = ' '
|
|
|
|
if thumb
|
|
width = thumb[:width]
|
|
height = thumb[:height]
|
|
thumb_result = get_file(params, thumb)
|
|
body = "<img style=\"width:#{width}px;height:#{height}px;\" src=\"data:image/png;base64,#{Base64.strict_encode64(thumb_result.body)}\">"
|
|
end
|
|
|
|
if params[:message][:caption]
|
|
body += "<br>#{params[:message][:caption].text2html}"
|
|
end
|
|
video_result = get_file(params, video)
|
|
article.content_type = 'text/html'
|
|
article.body = body
|
|
article.save!
|
|
|
|
Store.remove(
|
|
object: 'Ticket::Article',
|
|
o_id: article.id,
|
|
)
|
|
|
|
# get video type
|
|
type = video[:mime_type].gsub(%r{(.+/)}, '')
|
|
Store.add(
|
|
object: 'Ticket::Article',
|
|
o_id: article.id,
|
|
data: video_result.body,
|
|
filename: video[:file_name] || "video-#{video[:file_id]}.#{type}",
|
|
preferences: {
|
|
'Mime-Type' => video[:mime_type],
|
|
},
|
|
)
|
|
return article
|
|
end
|
|
|
|
# add voice
|
|
if params[:message][:voice]
|
|
|
|
voice = params[:message][:voice]
|
|
body = ' '
|
|
|
|
if params[:message][:caption]
|
|
body = "<br>#{params[:message][:caption].text2html}"
|
|
end
|
|
|
|
document_result = get_file(params, voice)
|
|
article.content_type = 'text/html'
|
|
article.body = body
|
|
article.save!
|
|
|
|
Store.remove(
|
|
object: 'Ticket::Article',
|
|
o_id: article.id,
|
|
)
|
|
Store.add(
|
|
object: 'Ticket::Article',
|
|
o_id: article.id,
|
|
data: document_result.body,
|
|
filename: voice[:file_path] || "audio-#{voice[:file_id]}.ogg",
|
|
preferences: {
|
|
'Mime-Type' => voice[:mime_type],
|
|
},
|
|
)
|
|
return article
|
|
end
|
|
|
|
# add sticker
|
|
if params[:message][:sticker]
|
|
|
|
sticker = params[:message][:sticker]
|
|
emoji = sticker[:emoji]
|
|
thumb = sticker[:thumb]
|
|
body = ' '
|
|
|
|
if thumb
|
|
width = thumb[:width]
|
|
height = thumb[:height]
|
|
thumb_result = get_file(params, thumb)
|
|
body = "<img style=\"width:#{width}px;height:#{height}px;\" src=\"data:image/webp;base64,#{Base64.strict_encode64(thumb_result.body)}\">"
|
|
article.content_type = 'text/html'
|
|
elsif emoji
|
|
article.content_type = 'text/plain'
|
|
body = emoji
|
|
end
|
|
|
|
article.body = body
|
|
article.save!
|
|
|
|
if sticker[:file_id]
|
|
|
|
document_result = get_file(params, sticker)
|
|
Store.remove(
|
|
object: 'Ticket::Article',
|
|
o_id: article.id,
|
|
)
|
|
Store.add(
|
|
object: 'Ticket::Article',
|
|
o_id: article.id,
|
|
data: document_result.body,
|
|
filename: sticker[:file_name] || "#{sticker[:set_name]}.webp",
|
|
preferences: {
|
|
'Mime-Type' => 'image/webp', # mime type is not given from Telegram API but this is actually WebP
|
|
},
|
|
)
|
|
end
|
|
return article
|
|
end
|
|
|
|
# add text
|
|
if params[:message][:text]
|
|
article.content_type = 'text/plain'
|
|
article.body = params[:message][:text]
|
|
article.save!
|
|
return article
|
|
end
|
|
raise Exceptions::UnprocessableEntity, 'invalid telegram message'
|
|
end
|
|
|
|
def to_group(params, group_id, channel)
|
|
# begin import
|
|
Rails.logger.debug { 'import message' }
|
|
|
|
# map channel_post params to message
|
|
if params[:channel_post]
|
|
return if params[:channel_post][:new_chat_title] # happens when channel title is renamed, we use [:chat][:title] already, safely ignore this.
|
|
|
|
# NOTE: used .blank? which is a rails method. empty? does not work on integers (values like date, width, height) to check.
|
|
# need delete_if to remove any empty hashes, .compact only removes keys with nil values.
|
|
params[:message] = {
|
|
document: {
|
|
file_name: params.dig(:channel_post, :document, :file_name),
|
|
mime_type: params.dig(:channel_post, :document, :mime_type),
|
|
file_id: params.dig(:channel_post, :document, :file_id),
|
|
file_size: params.dig(:channel_post, :document, :file_size),
|
|
thumb: {
|
|
file_id: params.dig(:channel_post, :document, :thumb, :file_id),
|
|
file_size: params.dig(:channel_post, :document, :thumb, :file_size),
|
|
width: params.dig(:channel_post, :document, :thumb, :width),
|
|
height: params.dig(:channel_post, :document, :thumb, :height)
|
|
}.compact
|
|
}.delete_if { |_, v| v.blank? },
|
|
video: {
|
|
duration: params.dig(:channel_post, :video, :duration),
|
|
width: params.dig(:channel_post, :video, :width),
|
|
height: params.dig(:channel_post, :video, :height),
|
|
mime_type: params.dig(:channel_post, :video, :mime_type),
|
|
file_id: params.dig(:channel_post, :video, :file_id),
|
|
file_size: params.dig(:channel_post, :video, :file_size),
|
|
thumb: {
|
|
file_id: params.dig(:channel_post, :video, :thumb, :file_id),
|
|
file_size: params.dig(:channel_post, :video, :thumb, :file_size),
|
|
width: params.dig(:channel_post, :video, :thumb, :width),
|
|
height: params.dig(:channel_post, :video, :thumb, :height)
|
|
}.compact
|
|
}.delete_if { |_, v| v.blank? },
|
|
voice: {
|
|
duration: params.dig(:channel_post, :voice, :duration),
|
|
mime_type: params.dig(:channel_post, :voice, :mime_type),
|
|
file_id: params.dig(:channel_post, :voice, :file_id),
|
|
file_size: params.dig(:channel_post, :voice, :file_size)
|
|
}.compact,
|
|
sticker: {
|
|
width: params.dig(:channel_post, :sticker, :width),
|
|
height: params.dig(:channel_post, :sticker, :height),
|
|
emoji: params.dig(:channel_post, :sticker, :emoji),
|
|
set_name: params.dig(:channel_post, :sticker, :set_name),
|
|
file_id: params.dig(:channel_post, :sticker, :file_id),
|
|
file_path: params.dig(:channel_post, :sticker, :file_path),
|
|
file_size: params.dig(:channel_post, :sticker, :file_size),
|
|
thumb: {
|
|
file_id: params.dig(:channel_post, :sticker, :thumb, :file_id),
|
|
file_size: params.dig(:channel_post, :sticker, :thumb, :file_size),
|
|
width: params.dig(:channel_post, :sticker, :thumb, :width),
|
|
height: params.dig(:channel_post, :sticker, :thumb, :height),
|
|
file_path: params.dig(:channel_post, :sticker, :thumb, :file_path)
|
|
}.compact
|
|
}.delete_if { |_, v| v.blank? },
|
|
chat: {
|
|
id: params.dig(:channel_post, :chat, :id),
|
|
first_name: params.dig(:channel_post, :chat, :title),
|
|
last_name: 'Channel',
|
|
username: "channel#{params.dig(:channel_post, :chat, :id)}"
|
|
},
|
|
from: {
|
|
id: params.dig(:channel_post, :chat, :id),
|
|
first_name: params.dig(:channel_post, :chat, :title),
|
|
last_name: 'Channel',
|
|
username: "channel#{params.dig(:channel_post, :chat, :id)}"
|
|
},
|
|
caption: (params.dig(:channel_post, :caption) || {}),
|
|
date: params.dig(:channel_post, :date),
|
|
message_id: params.dig(:channel_post, :message_id),
|
|
text: params.dig(:channel_post, :text),
|
|
photo: (params[:channel_post][:photo].map { |photo| { file_id: photo[:file_id], file_size: photo[:file_size], width: photo[:width], height: photo[:height] } } if params.dig(:channel_post, :photo))
|
|
}.delete_if { |_, v| v.blank? }
|
|
params.delete(:channel_post) # discard unused :channel_post hash
|
|
end
|
|
|
|
# checks if the channel post is being edited, and map it when it is
|
|
if params[:edited_channel_post]
|
|
# updates on telegram can only be on messages, no attachments
|
|
params[:edited_message] = {
|
|
chat: {
|
|
id: params.dig(:edited_channel_post, :chat, :id),
|
|
first_name: params.dig(:edited_channel_post, :chat, :title),
|
|
last_name: 'Channel',
|
|
username: "channel#{params.dig(:edited_channel_post, :chat, :id)}"
|
|
},
|
|
from: {
|
|
id: params.dig(:edited_channel_post, :chat, :id),
|
|
first_name: params.dig(:edited_channel_post, :chat, :title),
|
|
last_name: 'Channel',
|
|
username: "channel#{params.dig(:edited_channel_post, :chat, :id)}"
|
|
},
|
|
date: params.dig(:edited_channel_post, :date),
|
|
edit_date: params.dig(:edited_channel_post, :edit_date),
|
|
message_id: params.dig(:edited_channel_post, :message_id),
|
|
text: params.dig(:edited_channel_post, :text)
|
|
}
|
|
params.delete(:edited_channel_post) # discard unused :edited_channel_post hash
|
|
end
|
|
|
|
# prevent multiple update
|
|
return if !params[:edited_message] && Ticket::Article.exists?(message_id: Telegram.message_id(params))
|
|
|
|
# update article
|
|
if params[:edited_message]
|
|
article = Ticket::Article.find_by(message_id: Telegram.message_id(params))
|
|
return if !article
|
|
|
|
params[:message] = params[:edited_message]
|
|
user = to_user(params)
|
|
to_article(params, user, article.ticket, channel, article)
|
|
return article
|
|
end
|
|
|
|
# send welcome message and don't create ticket
|
|
text = params[:message][:text]
|
|
if text.present? && text.start_with?('/start')
|
|
message(params[:message][:chat][:id], channel.options[:welcome] || 'You are welcome! Just ask me something!', params[:message][:from][:language_code])
|
|
return
|
|
|
|
# find ticket and close it
|
|
elsif text.present? && text.start_with?('/end')
|
|
user = to_user(params)
|
|
|
|
# get the last ticket of customer which is not closed yet, and close it
|
|
state_ids = Ticket::State.where(name: %w[closed merged removed]).pluck(:id)
|
|
possible_tickets = Ticket.where(customer_id: user.id).where.not(state_id: state_ids).order(:updated_at)
|
|
ticket = possible_tickets.find_each.find { |possible_ticket| possible_ticket.preferences[:channel_id] == channel.id }
|
|
|
|
return if !ticket
|
|
|
|
ticket.state = Ticket::State.find_by(name: 'closed')
|
|
ticket.save!
|
|
|
|
return if !channel.options[:goodbye]
|
|
|
|
message(params[:message][:chat][:id], channel.options[:goodbye], params[:message][:from][:language_code])
|
|
return
|
|
end
|
|
|
|
ticket = nil
|
|
|
|
# use transaction
|
|
Transaction.execute(reset_user_id: true, context: 'telegram') do
|
|
user = to_user(params)
|
|
ticket = to_ticket(params, user, group_id, channel)
|
|
to_article(params, user, ticket, channel)
|
|
end
|
|
|
|
ticket
|
|
end
|
|
|
|
def from_article(article)
|
|
|
|
message = nil
|
|
Rails.logger.debug { "Create telegram personal message from article to '#{article[:to]}'..." }
|
|
|
|
message = {}
|
|
# TODO: create telegram message here
|
|
|
|
Rails.logger.debug { message.inspect }
|
|
message
|
|
end
|
|
|
|
def get_file(params, file)
|
|
|
|
# telegram bot files are limited up to 20MB
|
|
# https://core.telegram.org/bots/api#getfile
|
|
if !validate_file_size(file)
|
|
message_text = 'Telegram file is to big. (Maximum 20mb)'
|
|
message(params[:message][:chat][:id], "Sorry, we could not handle your message. #{message_text}", params[:message][:from][:language_code])
|
|
raise Exceptions::UnprocessableEntity, message_text
|
|
end
|
|
|
|
result = download_file(file[:file_id])
|
|
|
|
if !validate_download(result)
|
|
message_text = 'Unable to get you file from bot.'
|
|
message(params[:message][:chat][:id], "Sorry, we could not handle your message. #{message_text}", params[:message][:from][:language_code])
|
|
raise Exceptions::UnprocessableEntity, message_text
|
|
end
|
|
|
|
result
|
|
end
|
|
|
|
def download_file(file_id)
|
|
document = @api.getFile(file_id)
|
|
url = "https://api.telegram.org/file/bot#{@token}/#{document['file_path']}"
|
|
UserAgent.get(
|
|
url,
|
|
{},
|
|
{
|
|
open_timeout: 20,
|
|
read_timeout: 40,
|
|
verify_ssl: true,
|
|
},
|
|
)
|
|
end
|
|
|
|
def validate_file_size(file)
|
|
Rails.logger.error 'validate_file_size'
|
|
Rails.logger.error file[:file_size]
|
|
return false if file[:file_size] >= 20.megabytes
|
|
|
|
true
|
|
end
|
|
|
|
def validate_download(result)
|
|
return false if !result.success? || !result.body
|
|
|
|
true
|
|
end
|
|
|
|
end
|