telepathy/src/telepathy/bot.cr

180 lines
7.2 KiB
Crystal

require "http"
module Telepathy
class Bot
enum Control
Done
end
enum ParseMode
Normal, Markdown, HTML
end
def initialize(@api_token : String)
@request_base = "https://api.telegram.org/bot#{@api_token}"
@this_user = uninitialized User?
@this_user = get_me
@last_update_id = uninitialized Int64?
@last_update_id = nil
@command_hooks = {} of String => Update, Array(String) -> Void
@message_hooks = [] of Update -> Void
@poll_start_hooks = [] of -> Void
@poll_end_hooks = [] of -> Void
@poll_channel = Channel(Int64?|Control).new
@update_channel = Channel(Array(Update)|Control).new
@poll_running = false
end
def get_me
response = HTTP::Client.get(@request_base + "/getMe",
headers: HTTP::Headers{"User-agent" => "Telepathy"})
return Response(User).from_json(response.body).result
end
def get_updates(timeout = 0)
update_data = {} of String => Int64 | Int32 | String
update_data["timeout"] = timeout
@last_update_id.try { |id| update_data["offset"] = id }
response = HTTP::Client.get(@request_base + "/getUpdates",
headers: HTTP::Headers{"User-agent" => "Telepathy", "Content-type" => "application/json" },
body: update_data.to_json)
return Response(Array(Update)).from_json(response.body).result
end
def send_message(chat_id : String | Int64, text : String,
parse_mode : ParseMode = ParseMode::Normal,
disable_web_preview : Bool = false,
disable_notification : Bool = false,
reply_to_message_id : Int64? = nil)
message_data = { "chat_id" => chat_id, "text" => text } of String => Int64 | String | Bool
message_data["disable_web_preview"] = true if disable_web_preview
message_data["disable_notification"] = true if disable_notification
if parse_mode == ParseMode::Markdown
message_data["parse_mode"] = "Markdown"
elsif parse_mode == ParseMode::HTML
message_data["parse_mode"] = "HTML"
end
reply_to_message_id.try { |id| message_data["reply_to_message_id"] = id }
HTTP::Client.get(@request_base + "/sendMessage",
headers: HTTP::Headers{"User-agent" => "Telepathy", "Content-type" => "application/json" },
body: message_data.to_json)
end
def send_photo(chat_id : String | Int64, photo : String | File, caption : String? = nil,
disable_notification : Bool = false,
reply_to_message_id : Int64? = nil)
IO.pipe do |reader, writer|
channel = Channel(String).new(1)
spawn do
HTTP::FormData.build(writer) do |formdata|
channel.send(formdata.content_type)
case chat_id
when String
formdata.field("chat_id", chat_id.as(String))
when Int64
formdata.field("chat_id", chat_id.as(Int64).to_s)
end
formdata.field("disable_notification", disable_notification.to_s)
caption.try { |caption| formdata.field("caption", caption) }
reply_to_message_id.try { |id| formdata.field("reply_to_message_id", id) }
case photo
when String
formdata.field("photo", photo.as(String))
when File
photo_file = photo.as(File)
formdata.file("photo", photo_file,
HTTP::FormData::FileMetadata.new(filename: File.basename(photo_file.path)))
end
end
writer.close
end
response = HTTP::Client.get(@request_base + "/sendPhoto",
headers: HTTP::Headers{"User-agent" => "Telepathy", "Content-type" => channel.receive },
body: reader)
end
end
def command(command_name, &block: Update, Array(String) -> Void)
@command_hooks[command_name] = block
end
def message(&block: Update -> Void)
@message_hooks.push(block)
end
def poll_start(&block: -> Void)
@poll_start_hooks.push(block);
end
def poll_end(&block: -> Void)
@poll_end_hooks.push(block);
end
private def process_updates(updates)
updates.each do |update|
if message = update.message
@message_hooks.each &.call(update)
if entity = message.entities.try { |it| it.first? }
text = message.text.as String
if entity.offset == 0 && entity.type == "bot_command"
divider_index = (text.index /\s|@/) || text.size
first_space_index = (text.index /\s/) || text.size
command = text[1...divider_index]
remaining = text[first_space_index..text.size]
params = remaining.empty? ? ([] of String) : (remaining[1...remaining.size].split ' ')
@command_hooks[command]?.try { |command| command.call(update, params) }
end
end
end
end
end
private def spawn_workers
spawn do
loop do
action = @poll_channel.receive
case action
when Int64?
@last_update_id = action.nil? ? @last_update_id : action + 1
@update_channel.send get_updates 10
when Control
break
end
end
end
spawn do
loop do
item = @update_channel.receive
case item
when Array(Update)
process_updates(item)
@poll_channel.send item.last?.try &.update_id
when Control
@poll_channel.send item
break
end
end
end
end
def poll
if !@poll_running
@poll_running = true
spawn_workers
@poll_channel.send nil
@poll_start_hooks.each &.call
end
end
def end_poll
if @poll_running
@poll_running = false
@poll_channel.send Control::Done
@poll_end_hooks.each &.call
end
end
end
end