xasin-telegram 0.2.3 → 0.3.0

data/lib/xasin/telegram/MQTT_Adapter.rb

@@ -1,162 +1,26 @@
 
-require_relative 'HTTPCore.rb'
+require_relative 'GroupingAdapter.rb'
 require 'mqtt/sub_handler'
 
 module Xasin
 module Telegram
 	module MQTT
-		class Server
+		class Server < GroupingAdapter
 			attr_accessor :usernameList
 
 			def initialize(httpCore, mqtt)
-				# Check if we already have a HTTPCore, else create one
-				if(httpCore.is_a? Telegram::HTTPCore)
-					@httpCore = httpCore;
-				else
-					@httpCore = Telegram::HTTPCore.new(httpCore);
-				end
-				@httpCore.attach_receptor(self);
+				super(httpCore);
 
 				@mqtt = mqtt;
-
-				# Hash {username => ChatID}
-				@usernameList 	= Hash.new();
-				# Hash {ChatID => {GroupID => MessageID}}
-				@groupIDList 	= Hash.new do |hash, key|
-					hash[key] = Hash.new;
-				end
-
 				setup_mqtt();
 			end
 
-			def _process_inline_keyboard(keyboardLayout, gID = nil)
-				# Return unless we have a structure we can form into a keyboard
-				return nil unless (keyboardLayout.is_a? Array or keyboardLayout.is_a? Hash)
-
-				# Make sure the structure of keyboardLayout is [{}] or [[]]
-				if(keyboardLayout.is_a? Hash)
-					keyboardLayout = [keyboardLayout]
-				elsif(not (keyboardLayout[0].is_a? Array or keyboardLayout[0].is_a? Hash))
-					keyboardLayout = [keyboardLayout]
-				end
-
-				outData = Array.new();
-
-				# Iterate through the rows of keyboards
-				keyboardLayout.each do |row|
-					newRow = Array.new();
-
-					# Create the INLINE KEY button elements
-					row.each do |key, val|
-						cbd = {i: gID, k: (val or key)};
-						newRow << {text: key, callback_data: cbd.to_json}
-					end
-
-					# Add the new row to the array of rows
-					outData << newRow;
-				end
-
-				# Return the ready reply_markup element
-				return {inline_keyboard: outData};
-			end
-
-			# Processes messages received through MQTT
-			# It takes care of setting a few good defaults (like parse_mode),
-			# deletes any old messages of the same GroupID (if requested),
-			# and stores the new Message ID for later processing
-			# @param data [Hash] The raw "message" object received from the Telegram API
-			# @param uID [Integer,String] The user-id as received from the MQTT Wildcard.
-			#   Can be a username defined in @usernameList
-			def _handle_send(data, uID)
-				# Resolve a saved Username to a User-ID
-				uID = @usernameList[uID] if(@usernameList.key? uID)
-				return if (uID = uID.to_i) == 0; # Return if a unknown Username was used
-
-				gID = data[:gid];
-
-				# Check if a GroupID is present and a former message is known
-				if(gID and @groupIDList[uID][gID])
-					if(data[:replace])
-						_handle_delete(gID, uID)
-					elsif(data[:overwrite])
-						_handle_edit(data, uID);
-						return; # After editing, no new message should be sent!
-					end
-				end
-
-				# Lay out all mandatory parameters for sendMessage request
-				outData = {
-					chat_id: 	uID,
-					parse_mode: (data[:parse_mode] or "Markdown"), # Markdown parse mode is just nice
-					text:			data[:text]
-				}
-
-				# Check if the message is meant to be sent without notification
-				if(data[:silent])
-					outData[:disable_notification] = true;
-				end
-
-				# Check if an inline keyboard layout is given, and parse that.
-				if((ilk = data[:inline_keyboard]))
-					outData[:reply_markup] = _process_inline_keyboard(ilk, gID);
-				end
-
-				reply = @httpCore.perform_post("sendMessage", outData);
-				return unless reply[:ok]	# Something was wrong about our message layout
-				# TODO Add a proper error handler here.
-
-				# If a GroupID was given, save the sent message's ID
-				@groupIDList[uID][gID] = reply[:result][:message_id] if(gID);
-			end
-
-			def _handle_edit(data, uID)
-				# Resolve a saved Username to a User-ID
-				uID = @usernameList[uID] if(@usernameList.key? uID)
-				return if (uID = uID.to_i) == 0; # Return if a unknown Username was used
-
-				# Fetch the target MessageID - Return if none is present
-				return unless mID = @groupIDList[uID][data[:gid]]
-
-				# Lay out all mandatory arguments for the edit POST
-				outData = {
-					chat_id: uID,
-					message_id: mID,
-				};
-
-				# If a inline keyboard was given, parse that.
-				if(ilk = data[:inline_keyboard])
-					outData[:reply_markup] = _process_inline_keyboard(ilk, data[:gid]);
-				end
-
-				if(data[:text]) # Check if text was given
-					outData[:text] = data[:text];
-					# Send the POST request editing the message text
-					@httpCore.perform_post("editMessageText", outData);
-				else
-					# Otherwise, only edit the reply markup (keyboard etc.)
-					@httpCore.perform_post("editMessageReplyMarkup", outData);
-				end
-			end
-
-			def _handle_delete(data, uID)
-				# Resolve a saved Username to a User-ID
-				uID = @usernameList[uID] if(@usernameList.key? uID)
-				return if (uID = uID.to_i) == 0; # Return unless the username was known
-
-				# Fetch the real message ID held by a grouping ID
-				return unless mID = @groupIDList[uID][data]
-				@groupIDList[uID].delete(data); # Clear that ID from the list
-
-				# Perform the actual delete
-				@httpCore.perform_post("deleteMessage", {chat_id: uID, message_id: mID});
-			end
-
 			def setup_mqtt()
 				@mqtt.subscribe_to "Telegram/+/Send" do |data, tSplit|
 					begin
-						data = JSON.parse(data);
+						data = JSON.parse(data, symbolize_names: true);
 					rescue
-						data = {text: data}
+						data = { text: data }
 					end
 
 					_handle_send(data, tSplit[0]);
@@ -164,7 +28,7 @@ module Telegram
 
 				@mqtt.subscribe_to "Telegram/+/Edit" do |data, tSplit|
 					begin
-						data = JSON.parse(data);
+						data = JSON.parse(data, symbolize_names: true);
 					rescue
 						next;
 					end
@@ -187,52 +51,21 @@ module Telegram
 				end
 			end
 
-			def handle_packet(packet)
-				if(msg = packet[:message])
-					uID = msg[:chat][:id];
-					if(newUID = @usernameList.key(uID))
-						uID = newUID
-					end
-
-					data = Hash.new();
-					return unless(data[:text] = msg[:text])
-
-					if(replyMSG = msg[:reply_to_message])
-						data[:reply_gid] = @groupIDList[uID].key(replyMSG[:message_id]);
-					end
-
-					if(data[:text] =~ /^\//)
-						@mqtt.publish_to "Telegram/#{uID}/Command", data.to_json;
-					elsif(data[:reply_gid])
-						@mqtt.publish_to "Telegram/#{uID}/Reply", data.to_json;
-					else
-						@mqtt.publish_to "Telegram/#{uID}/Received", data.to_json;
-					end
-				end
-
-				if(msg = packet[:callback_query])
-					@httpCore.perform_post("answerCallbackQuery", {callback_query_id: msg[:id]});
-
-					uID = msg[:message][:chat][:id];
-					if(newUID = @usernameList.key(uID))
-						uID = newUID
-					end
-
-					begin
-						data = JSON.parse(msg[:data], symbolize_names: true);
-
-						data = {
-							gid:  data[:i],
-							key: data[:k],
-						}
-
-						if(data[:key] =~ /^\//)
-							@mqtt.publish_to "Telegram/#{uID}/Command", {text: data[:key]}.to_json
-						end
-						@mqtt.publish_to "Telegram/#{uID}/KeyboardPress", data.to_json
-					rescue
-					end
-				end
+			def on_message(data, uID)
+				super(data, uID);
+				@mqtt.publish_to "Telegram/#{uID}/Received", data.to_json;
+			end
+			def on_command(data, uID)
+				super(data, uID);
+				@mqtt.publish_to "Telegram/#{uID}/Command", data.to_json;
+			end
+			def on_reply(data, uID)
+				super(data, uID);
+				@mqtt.publish_to "Telegram/#{uID}/Reply", data.to_json;
+			end
+			def on_callback_pressed(data, uID)
+				super(data, uID);
+				@mqtt.publish_to "Telegram/#{uID}/KeyboardPress", data.to_json
 			end
 		end
 	end

data/lib/xasin/telegram/Message.rb

@@ -0,0 +1,126 @@
+
+module Xasin
+	module Telegram
+		class Message
+			# Return whether or not parsing of the message was successful.
+			# TODO Actually perfom validity checks.
+			attr_reader :valid
+
+			# Returns the message ID of this message.
+			attr_reader :message_id
+			# Returns the {Chat} object this message was sent in.
+			attr_reader :chat
+			# Returns the {User} Object that sent this message.
+			attr_reader :user
+
+			# Optional argument, ID of the message that was replied to.
+			attr_reader :reply_to_id
+
+			# String, text of the message.
+			# Even if the message is not a String (i.e. a Sticker etc.),
+			# this will be at least an empty string.
+			attr_reader :text
+
+			# Timestamp, from Telegram, that the message was sent on.
+			attr_reader :timestamp
+
+			# Optional, command included in this message.
+			# Can be nil.
+			attr_reader :command
+
+			# Whether a command already handled this message.
+			# Usually means that it should not be processed any further,
+			# in order to prevent multiple commands from acting on the same
+			# message and causing weird behaviors.
+			attr_accessor :handled
+
+			# Initialize a message object.
+			# This will create a new message object with the given
+			# Telegram "Message" Hash. It can be taken directly from
+			# the Telegram API.
+			#
+			# The Message will automatically try to fetch the matching
+			# {Chat} and {User} that sent the message, and will also
+			# parse any additional metadata such as commands, stickers,
+			# etc.
+			def initialize(handler, message_object)
+				@handler = handler
+
+				return if message_object.nil?
+
+				@valid = true;
+
+				@message_id = message_object[:message_id]
+
+				@chat = handler[message_object[:chat]]
+				@user = handler[message_object[:from]]
+
+				@reply_to_id = message_object.dig(:reply_to_message, :id)
+
+				@text = message_object[:text] || "";
+
+				@timestamp = Time.at(message_object[:date] || 0)
+
+				m = /\/([\S]*)/.match(@text)
+				@command = m[1] if m
+
+				@handled = false
+			end
+
+			# Edit the text of the message.
+			# Simple wrapper for the 'editMessageText' Telegram
+			# API function, and will directly set the messge's text.
+			#
+			# parse_mode is set to HTML.
+			def edit_text(text)
+				out_data = {
+					chat_id: @chat.chat_id,
+					message_id: @message_id,
+					parse_mode: 'HTML',
+					text: text
+				}
+
+				@handler.core.perform_post('editMessageText', out_data);
+			end
+			alias text= edit_text
+
+			# Try to delete this message.
+			# Wrapper for Telegram's deleteMessage function
+			def delete!
+				@handler.core.perform_post('deleteMessage',
+					{
+						chat_id: @chat.chat_id,
+						message_id: @message_id
+					}
+				);
+			end
+
+			# Send a text message with it's reply set to this.
+			#
+			# This will send a new message with given text, whose reply
+			# message ID is set to this message. Makes it easy to respond to
+			# certain events quite cleanly.
+			def reply(text)
+				@chat.send_message(text, reply_to: self)
+			end
+
+			# Send a message to the chat this message originated from.
+			#
+			# This is a wrapper for message.chat.send_message, as it allows
+			# the Bot to easily respond to a {User}'s action in the same chat
+			# the user wrote it in. It will simply forward all arguments to
+			# {Chat#send_message}
+			def send_message(text, **opts)
+				@chat.send_message(text, **opts)
+			end
+
+			def to_s
+				@text
+			end
+
+			def to_i
+				@message_id
+			end
+		end
+	end
+end

data/lib/xasin/telegram/OnCommand.rb

@@ -0,0 +1,34 @@
+
+
+module Xasin
+	module Telegram
+		class OnCommand < OnTelegramEvent
+			attr_accessor :deny_message
+			attr_accessor :required_perms
+
+			def initialize(options)
+				super()
+
+				@block = options[:block]
+				@command = options[:command]
+
+				@required_perms = [options[:permissions]].flatten.uniq
+
+				@deny_message = options[:deny_msg] || 'You are not authorized, %s.'
+
+				@priority += 5
+			end
+
+			def nomp_message(message)
+				return if message.handled
+				return unless message.command == @command
+
+				if message.user.has_permissions? @required_perms
+					@block.call message
+				else
+					message.reply @deny_message % [message.user.casual_name]
+				end
+			end
+		end
+	end
+end

data/lib/xasin/telegram/OnMessage.rb

@@ -0,0 +1,29 @@
+
+
+module Xasin
+	module Telegram
+		class OnMessage < OnTelegramEvent
+			def initialize(options)
+				super()
+
+				@block = options[:block]
+				@regexp = options[:regexp]
+
+				@priority += 1 if @regexp
+			end
+
+			def nomp_message(message)
+				if @regexp
+					match = @regexp.match message.to_s
+
+					if match
+						@block.call message, match
+						message.handled = true
+					end
+				else
+					@block.call message
+				end
+			end
+		end
+	end
+end

data/lib/xasin/telegram/SingleUser.rb

@@ -7,7 +7,13 @@ module Telegram
 		attr_reader :httpCore
 
 		def initialize(userChat, httpCore)
-			@httpCore = httpCore.is_a?(Telegram::HTTPCore) ? httpCore : HTTPCore.new(httpCore);
+			# Check if we already have a HTTPCore, else create one
+			@httpCore = if(httpCore.is_a? Telegram::HTTPCore)
+					httpCore;
+				else
+					Telegram::HTTPCore.new(httpCore);
+				end
+			@httpCore.attach_receptor(self);
 			@httpCore.attach_receptor(self);
 
 			@userID = userChat;
@@ -17,19 +23,18 @@ module Telegram
 		end
 
 		def handle_packet(packet)
-			if(packet[:message]) then
+			if(packet[:message])
 				return unless packet[:message][:chat][:id] == @userID;
 
 				@message_procs.each do |cb| cb.call(packet[:message]); end
 				packet[:has_been_handled] = true;
 			end
 
-			if(packet[:callback_query]) then
-				return unless packet[:callback_query][:message][:chat][:id] == @userID;
+			return unless packet[:callback_query]
+			return unless packet[:callback_query][:message][:chat][:id] == @userID;
 
-				@inlinebutton_procs.each do |cb| cb.call(packet[:callback_query]); end
-				packet[:has_been_handled] = true;
-			end
+			@inlinebutton_procs.each { |cb| cb.call(packet[:callback_query]); }
+			packet[:has_been_handled] = true;
 		end
 
 		def send_message(text, **args)