xasin-telegram 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b586489f2bb15aa638d85a6409bbfd937ee10d8
-  data.tar.gz: 3b184fa20bf6fa785ce51796b00af78ca75bc83f
+  metadata.gz: 25c7030241f3f7f6eb094897f5175c49a177e299
+  data.tar.gz: 9d335a41200777ead31dad505e059d3a9ae726c1
 SHA512:
-  metadata.gz: c8241173e2b8911d30dcbef771aa1c03848bc6d289160401a518d6b8248fa93281852ab34ccf192afc1a0e770a0dfa232900e528d5cf04fe7c5aa90e43b163b9
-  data.tar.gz: ee57382ce4b7649d32e7c01752ddf3d965241815b7e13413486014e5326644caa361b7567decd5f0467baef7d7ec5764fa2627db0c4ac01ad416b5795c4d87f9
+  metadata.gz: 6fe1d6ce851631e0460bba3b843eef7fbf3583bff045bd854870c9cf1cb8526c8b300e5a793d7e13e5c8ebbf22a1fc926bf0727a7f13b7d243faf35878c26685
+  data.tar.gz: 2dc0c584e4e5e4b829d0f8c8b12ef0664a78326f6d5d7769fdfbb4da53bd2c3a47688137ea17f39bd12042bb980b65a1770629307b7b086bcfb099801b9eddbf

data/lib/xasin/telegram/MQTT_Adapter.rb

@@ -9,6 +9,7 @@ module Telegram
 			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
@@ -28,24 +29,34 @@ module Telegram
 				setup_mqtt();
 			end
 
-			def _process_inline_keyboard(keyboardLayout, gID)
-				return nil unless (keyboardLayout.is_a? Array)
-				return nil unless gID
+			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
 
-				keyboardLayout = [keyboardLayout] unless(keyboardLayout[0].is_a? Array);
 				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
 
@@ -59,93 +70,105 @@ module Telegram
 			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 (uID = uID.to_i) == 0; # Return if a unknown Username was used
 
-				begin
-					data = JSON.parse(data, symbolize_names: true) if data.is_a? String
-				rescue
-					# Allow for pure-text to be sent (easier on the ESPs)
-					data = {text: data}
-				end
+				gID = data[:gid];
 
-				if(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] and @groupIDList[uID][gID])
+					elsif(data[:overwrite])
 						_handle_edit(data, uID);
-						return;
+						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"),
+					parse_mode: (data[:parse_mode] or "Markdown"), # Markdown parse mode is just nice
 					text:			data[:text]
 				}
 
-				if(ilk = data[:inline_keyboard] and data[:gid])
-					outData[:reply_markup] = _process_inline_keyboard(ilk, data[:gid]);
+				# 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]
+				return unless reply[:ok]	# Something was wrong about our message layout
+				# TODO Add a proper error handler here.
 
-				# Check if this message has a grouping ID
-				if(gID = data[:gid])
-					# Save this grouping ID
-					@groupIDList[uID][gID] = reply[:result][:message_id];
-				end
+				# 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;
-
-				begin
-					data = JSON.parse(data, symbolize_names: true) if data.is_a? String
+				return if (uID = uID.to_i) == 0; # Return if a unknown Username was used
 
-					# Fetch the target Message ID
-					return unless mID = @groupIDList[uID][data[:gid]]
+				# Fetch the target MessageID - Return if none is present
+				return unless mID = @groupIDList[uID][data[:gid]]
 
-					outData = {
-						chat_id: uID,
-						message_id: mID,
-					};
+				# Lay out all mandatory arguments for the edit POST
+				outData = {
+					chat_id: uID,
+					message_id: mID,
+				};
 
-					if(data[:inline_keyboard])
-						outData[:reply_markup] = _process_inline_keyboard(data[:inline_keyboard]);
-					end
+				# 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])
-						outData[:text] = data[:text];
-						# Send the POST request editing the message text
-						@httpCore.perform_post("editMessageText", outData);
-					else
-						@httpCore.perform_post("editMessageReplyMarkup", outData);
-					end
-				rescue
+				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 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);
+				@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);
+					rescue
+						data = {text: data}
+					end
+
 					_handle_send(data, tSplit[0]);
 				end
 
 				@mqtt.subscribe_to "Telegram/+/Edit" do |data, tSplit|
+					begin
+						data = JSON.parse(data);
+					rescue
+						next;
+					end
+
 					_handle_edit(data, tSplit[0])
 				end
 
@@ -195,12 +218,11 @@ module Telegram
 						uID = newUID
 					end
 
-					return unless /(\S+):(\S+)/ =~ msg[:data]
 					begin
 						data = JSON.parse(msg[:data], symbolize_names: true);
 
 						data = {
-							gid:  data[:g],
+							gid:  data[:i],
 							key: data[:k],
 						}
 

data/lib/xasin/telegram/TestHTTPCore.rb

@@ -0,0 +1,40 @@
+
+require_relative 'HTTPCore.rb'
+
+module Xasin
+	module Telegram
+		class TestCore < HTTPCore
+			attr_accessor :lastPostData, :lastPostRequest
+			attr_reader   :currentMessageID
+			attr_accessor :toReturn
+
+			def initialize()
+				prepare();
+			end
+
+			def prepare()
+				@lastPostData  	= Array.new();
+				@lastPostRequest 	= Array.new();
+
+				@currentMessageID = rand(0..9999);
+
+				@toReturn = {
+					ok: true,
+					result: {
+						message_id: @currentMessageID
+					}
+				}
+			end
+
+			def attach_receptor(receptor)
+			end
+
+			def perform_post(postRequest, postData)
+				@lastPostRequest << postRequest;
+				@lastPostData << postData;
+
+				return @toReturn;
+			end
+		end
+	end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xasin-telegram
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Xasin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-16 00:00:00.000000000 Z
+date: 2018-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mqtt-sub_handler
@@ -36,6 +36,7 @@ files:
 - lib/xasin/telegram/HTTPCore.rb
 - lib/xasin/telegram/MQTT_Adapter.rb
 - lib/xasin/telegram/SingleUser.rb
+- lib/xasin/telegram/TestHTTPCore.rb
 homepage: https://github.com/XasWorks/XasCode/tree/GEM_Telegram/Ruby/Telegram
 licenses:
 - GPL-3.0