xasin-telegram 0.1.1.dev

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: '08a672d2bfc09cc9300f4079e89d575885db4d50'
+  data.tar.gz: c3cc7d5cc307f94739eb6d18ab6c8f69c7d088c6
+SHA512:
+  metadata.gz: a5dc1b8a37e4b39036a1bdcfa36ce98c533c0db87944074aae5464364cecf62d8afe9e56c9db39ac67e56990dcd1f87bd612934a3e66c076f734bb791b3599ca
+  data.tar.gz: 62cd7a35febfa417839088c9f0806c4a66086f53b1d21b1ed1e75f6e6e7f7ce98de360127f63488cb44f14cfb2094a779be76c2fc26f56edec441ba1e97ca755

data/README.md

@@ -0,0 +1,41 @@
+
+# Xasin's simplifying Telegram gem
+This gem is mainly meant for personal use.
+Many of the existing Ruby gems for Telegram have all the functionality you want,
+but also require a fairly complex setup, and good knowledge of the Telegram API.
+
+My gem doesn't include all functionality, but aims to provide a somewhat simpler interface of
+interaction with a small number (or just a single) of users.
+I mainly use it for my own smart home system, to easily send and receive messages, but not much more.
+
+## Single-User mode
+The main element of this gem is the single user mode.
+It discards messages of all users except one, and provides a simple "send" and "on_message" interface:
+
+```Ruby
+require 'xasin/telegram.rb'
+
+# The HTTP "core" handles sending raw commands and getting updates, but not much more.
+httpCore = Xasin::Telegram::HTTPCore.new(APIKEY);
+
+# The SingleUser class handles the aforementioned sending/receiving of messages.
+# Its first argument is the Chat-ID it should use, which is NOT the user ID
+# To find it out you have to perform an update request to the Telegram API, send a message to your bot,
+# and get the Chat_ID from there.
+# I'm working on a better way >.>
+singleUser = Xasin::Telegram::SingleUser.new(CHAT_ID, httpCore);
+
+
+# From then, using the user is simple. Only text is required!
+returned_id = singleUser.send_message(TEXT, **args);
+
+# The ID that is returned can then be used to edit or delete the message:
+singleUser.edit_message(returned_id, NEW_TEXT);
+singleUser.delete_message(returned_id);
+
+# And to receive messages:
+singleUser.on_message do |message|
+	# Fetch the text from the message first!
+	text = message[:text];
+end
+```

data/lib/xasin/telegram/HTTPCore.rb

@@ -0,0 +1,66 @@
+
+require 'net/http'
+require 'json'
+
+module Xasin
+module Telegram
+	class HTTPCore
+		def initialize(apikey)
+			@apikey = apikey;
+
+			@lastUpdateID = 0;
+			Thread.new do
+				receive_loop();
+			end.abort_on_exception = true
+
+			@receptors = Array.new();
+		end
+
+		def perform_post(method, data = nil)
+			callAddress = URI "https://api.telegram.org/bot#{@apikey}/#{method}"
+
+			begin
+				if data
+					response = Net::HTTP.post_form(callAddress, data);
+				else
+					response = Net::HTTP.get callAddress
+				end
+
+				response = JSON.parse(response.body, symbolize_names: true);
+			rescue
+				sleep 0.5;
+				retry
+			end
+
+			return response;
+		end
+
+		def receive_loop()
+			loop do
+				begin
+					packet = perform_post("getUpdates", {timeout: 20, offset: @lastUpdateID + 1})
+
+					next unless packet[:ok];
+					next if packet[:result].length == 0;
+
+					packet[:result].each do |data|
+						hUpdateID = data[:update_id].to_i
+						@lastUpdateID = [hUpdateID, @lastUpdateID].max
+
+						@receptors.each do |r|
+							r.handle_packet(data);
+						end
+					end
+				rescue
+					sleep 1
+					retry
+				end
+			end
+		end
+
+		def attach_receptor(receptorClass)
+			@receptors << receptorClass;
+		end
+	end
+end
+end

data/lib/xasin/telegram/MQTT_Adapter.rb

@@ -0,0 +1,145 @@
+
+require 'mqtt/sub_handler'
+
+module Xasin
+module Telegram
+	module MQTT
+		class Server
+			attr_accessor :usernameList
+
+			def initialize(httpCore, mqtt)
+				if(httpCore.is_a? Telegram::HTTPCore)
+					@httpCore = httpCore;
+				else
+					@httpCore = Telegram::HTTPCore.new(httpCore);
+				end
+				@httpCore.attach_receptor(self);
+
+				@mqtt = mqtt;
+
+				# Hash {username => ChatID}
+				@usernameList 	= Hash.new();
+				# Hash {ChatID => {GroupID => MessageID}}
+				@groupIDList 	= Hash.new();
+
+				setup_mqtt();
+			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)
+				uID = uID.to_i;
+
+				begin
+					data = JSON.parse(data, symbolize_names: true);
+				rescue
+					# Allow for pure-text to be sent (easier on the ESPs)
+					data = {text: data}
+				end
+
+				data[:parse_mode] ||= "Markdown";
+				data[:chat_id]		= uID;
+
+				reply = @httpCore.perform_post("sendMessage", data);
+
+				# Check if this message has a grouping ID
+				if(gID = data[:GID])
+					# If the message has the :single flag, delete the last one
+					if(data[:single])
+						_handle_delete(gID, uID);
+					end
+
+					# Save this grouping ID
+					@groupIDList[uID][gID] = reply[:result][:message_id];
+				end
+			end
+
+			def _handle_edit(data, uID)
+				# Resolve a saved Username to a User-ID
+				uID = @usernameList[uID] if(@usernameList.key? uID)
+				uID = uID.to_i;
+
+				begin
+					data = JSON.parse(data, symbolize_names: true);
+
+					return unless data[:text];
+					# Fetch the target Message ID
+					return unless mID = @groupIDList[uID][data[:GID]]
+
+					# Send the POST request editing the message text
+					@httpCore.perform_post("editMessageText",
+							{	text: data[:text],
+								chat_id: 	uID,
+								message_id:	mID});
+				rescue
+				end
+			end
+
+			def _handle_delete(data, uID)
+				# Resolve a saved Username to a User-ID
+				uID = @usernameList[uID] if(@usernameList.key? uID)
+				uID = uID.to_i;
+
+				# Fetch the real message ID held by a grouping ID
+				return unless mID = @groupIDList[uID][data]
+				@groupIDList[uID].delete(data);
+
+				@httpCore.perform_post("deleteMessage", {chat_id: uID, message_id: mID});
+			end
+
+			def setup_mqtt()
+				@mqtt.subscribe_to "Telegram/+/Send" do |data, tSplit|
+					_handle_send(data, tSplit[0]);
+				end
+
+				@mqtt.subscribe_to "Telegram/+/Edit" do |data, tSplit|
+					_handle_edit(data, tSplit[0])
+				end
+
+				@mqtt.subscribe_to "Telegram/+/Delete" do |data, tSplit|
+					_handle_delete(data, tSplit[0])
+				end
+
+				@mqtt.subscribe_to "Telegram/+/Release" do |data, tSplit|
+					# Resolve a saved Username to a User-ID
+					uID = tSplit[0];
+					uID = @usernameList[uID] if(@usernameList.key? uID)
+					uID = uID.to_i;
+
+					# Delete the stored GID key
+					@groupIDList[uID].delete(data);
+				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[:reply_GID])
+						@mqtt.publish_to "Telegram/#{uID}/Reply", data;
+					else
+						@mqtt.publish_to "Telegram/#{uID}/Received", data;
+					end
+				end
+			end
+		end
+	end
+end
+end

data/lib/xasin/telegram/SingleUser.rb

@@ -0,0 +1,73 @@
+
+require_relative "HTTPCore.rb"
+
+module Xasin
+module Telegram
+	class SingleUser
+		attr_reader :httpCore
+
+		def initialize(userChat, httpCore)
+			@httpCore = httpCore.is_a?(Telegram::HTTPCore) ? httpCore : HTTPCore.new(httpCore);
+			@httpCore.attach_receptor(self);
+
+			@userID = userChat;
+
+			@message_procs 		= Array.new();
+			@inlinebutton_procs	= Array.new();
+		end
+
+		def handle_packet(packet)
+			if(packet[:message]) then
+				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;
+
+				@inlinebutton_procs.each do |cb| cb.call(packet[:callback_query]); end
+				packet[:has_been_handled] = true;
+			end
+		end
+
+		def send_message(text, **args)
+			args ||= Hash.new();
+			args[:text] = text;
+
+			args[:chat_id] 	=   @userID;
+			args[:parse_mode]	||= "Markdown";
+
+			sent_message = @httpCore.perform_post("sendMessage", args);
+
+			return sent_message[:result][:message_id];
+		end
+
+		def edit_message(mID, text=nil, **args)
+			args[:chat_id] 		= @userID;
+			args[:message_id] 	= mID;
+
+			args[:parse_mode]		||= "Markdown";
+
+			if(text) then
+				args[:text] = text;
+				@httpCore.perform_post("editMessageText", args);
+			else
+				@httpCore.perform_post("editMessageReplyMarkup", args);
+			end
+		end
+
+		def delete_message(mID)
+			@httpCore.perform_post("deleteMessage", {chat_id: @userID, message_id: mID});
+		end
+
+		def on_message(&block)
+			@message_procs << block;
+		end
+		def on_inlinebutton_press(&block)
+			@inlinebutton_procs << block;
+		end
+	end
+end
+end

data/lib/xasin/telegram.rb

@@ -0,0 +1,3 @@
+
+require_relative "Telegram/HTTPCore.rb"
+require_relative "Telegram/SingleUser.rb"

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: xasin-telegram
+version: !ruby/object:Gem::Version
+  version: 0.1.1.dev
+platform: ruby
+authors:
+- Xasin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mqtt-sub_handler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Multi-Purpose Telegram gem. Mainly for personal use, but also used as
+  a Telegram to MQTT Bridge for IoT devices
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/xasin/telegram.rb
+- lib/xasin/telegram/HTTPCore.rb
+- lib/xasin/telegram/MQTT_Adapter.rb
+- lib/xasin/telegram/SingleUser.rb
+homepage: https://github.com/XasWorks/XasCode/tree/GEM_Telegram/Ruby/Telegram
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14.1
+signing_key: 
+specification_version: 4
+summary: Xasin's Telegram gem
+test_files: []