xnm-telegram 0.4.0

data/lib/xnm/telegram/OnCommand.rb

@@ -0,0 +1,34 @@
+
+
+module XNM
+	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/xnm/telegram/OnMessage.rb

@@ -0,0 +1,29 @@
+
+
+module XNM
+	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/xnm/telegram/SingleUser.rb

@@ -0,0 +1,78 @@
+
+require_relative "HTTPCore.rb"
+
+module XNM
+module Telegram
+	class SingleUser
+		attr_reader :httpCore
+
+		def initialize(userChat, 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;
+
+			@message_procs 		= Array.new();
+			@inlinebutton_procs	= Array.new();
+		end
+
+		def handle_packet(packet)
+			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
+
+			return unless packet[:callback_query]
+			return unless packet[:callback_query][:message][:chat][:id] == @userID;
+
+			@inlinebutton_procs.each { |cb| cb.call(packet[:callback_query]); }
+			packet[:has_been_handled] = true;
+		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/xnm/telegram/TestHTTPCore.rb

@@ -0,0 +1,62 @@
+
+require_relative 'HTTPCore.rb'
+
+module XNM
+	module Telegram
+		# This is a purely test-related class. It implements all of HTTPCore's
+		# functionality, but does not connect to the Telegram API. Instead,
+		# it simply saves the last POST request, and simulates received requests,
+		# allowing testing.
+		class TestCore < HTTPCore
+			attr_accessor :lastPostData, :lastPostRequest
+			attr_reader   :currentMessageID
+			attr_accessor :toReturn
+
+			def initialize()
+				prepare();
+
+				@receptors = Array.new();
+			end
+
+			def prepare()
+				@lastPostData  	= Array.new();
+				@lastPostRequest 	= Array.new();
+
+				@currentMessageID = rand(0..9999);
+
+				@toReturn = {
+									ok: true,
+									result: {
+										message_id: @currentMessageID
+									}
+								}
+			end
+
+			def perform_post(postRequest, postData)
+				@lastPostRequest << postRequest;
+				@lastPostData << postData;
+
+				return @toReturn;
+			end
+
+			def simulate_send_packet(packet)
+				@receptors.each do |r|
+					r.handle_packet(packet);
+				end
+			end
+
+			def simulate_sent_message(text, chatID: "test", reply_id: nil )
+				outData = Hash.new();
+
+				outData[:chat] = {id: chatID};
+				outData[:text] = text;
+
+				if(reply_id)
+					outData[:reply_to_message] = reply_id;
+				end
+
+				simulate_send_packet({message: outData});
+			end
+		end
+	end
+end

data/lib/xnm/telegram/User.rb

@@ -0,0 +1,142 @@
+
+require_relative 'Chat.rb'
+
+module XNM
+	module Telegram
+		# Telegram User class.
+		#
+		# This class is an extension of a Telegram {Chat} object that
+		# represents a DM with a User, and represents the user himself.
+		# This is because Telegram's User ID is equivalent to the
+		# Chat ID of the DM with the User.
+		class User	< Chat
+			# Username, without the @
+			attr_reader :username
+			# First name, always guaranteed to be set.
+			attr_reader :first_name
+			# Last name, may not be set.
+			attr_reader :last_name
+
+			# A human readable name.
+			# Overrides {Chat#casual_name}
+			attr_reader :casual_name
+
+			# List of permissions this user has.
+			# This Array of Strings will be used to check against
+			# a executed command, to see if the User has appropriate rights
+			# to run said command.
+			#
+			# Note that the {Handler#permissions_list} will be used to expand
+			# this list, i.e. if the permissions list is:
+			# `{ 'admin' => ['basic_rights'] }`
+			# And the user has the 'admin' permission, he will also have
+			# basic_rights *without them being listed in {#permissions}*
+			#
+			# Use {#has_permissions?} to check if a user has a certain permission.
+			attr_reader :permissions
+
+			# Permanent user state. Will be saved to disk.
+			# @todo Actually save to disk.
+			attr_reader :perm_state
+
+			# Temporary state. Will be lost of restart, should be cleaned
+			# out and only used for intermediary work.
+			attr_accessor :temp_state
+
+			# Initialize a new user object.
+			#
+			# Pass the handler used for this User as well as the
+			# Hash containing Telegram's "User" Object.
+			def initialize(handler, user_info)
+				super(handler, user_info);
+
+				@username   = user_info[:username]
+				@first_name = user_info[:first_name]
+				@last_name  = user_info[:last_name]
+
+				@casual_name = user_info[:first_name]
+
+				@permissions = user_info[:permissions] || []
+				@perm_state  = user_info[:perm_state] || {}
+			end
+
+			def add_permissions(list)
+				list = [list].flatten
+
+				list.each do |perm|
+					next if perm.is_a? Symbol
+					next if perm.is_a? String
+
+					raise ArgumentError, "Permission must be String or Symbol!"
+				end
+
+				@permissions = (@permissions + list).uniq
+			end
+			alias add_permission add_permissions
+
+			def take_permissions(list)
+				list = [list].flatten
+
+				list.each do |perm|
+					next if perm.is_a? Symbol
+					next if perm.is_a? String
+
+					raise ArgumentError, "Permission must be String or Symbol!"
+				end
+
+				@permissions -= list;
+			end
+			alias take_permission take_permissions
+
+			# Check if a user has all given permissions.
+			# Will run {#has_permission} against every permission
+			# in the list, returns false if any one permission is not met.
+			#
+			# An empty list counts as true
+			def has_permissions?(*targets)
+				targets = targets.flatten
+
+				return true if targets.nil?
+				return true if @permissions.include? :sudo
+
+				targets.each do |perm|
+					return false unless has_permission? perm
+				end
+
+				true
+			end
+
+			# Check whether a user has a given permission.
+			#
+			# This function will check if the given permission is in the
+			# User's {#permissions}. It will also use the
+			# {Handler#permissions_list} to expand the user's permissions,
+			# i.e. if the permissions list is:
+			# `{ 'admin' => ['basic_rights'] }`
+			# And the user has the 'admin' permission, he will also have
+			# basic_rights *without them being listed in {#permissions}*
+			#
+			# nil will return true.
+			#
+			# @note This will always return true if the user has the :sudo
+			#   permission, use only for full admin access!
+			def has_permission?(target)
+				return true if @permissions.include? :sudo
+				return true if target.nil?
+
+				unchecked = @permissions.dup
+				checked = {}
+
+				while perm = unchecked.pop
+					next if checked[perm]
+					return true if perm == target
+
+					unchecked += @handler.permissions_list[perm] || []
+					checked[perm] = true
+				end
+
+				false
+			end
+		end
+	end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: xnm-telegram
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Xasin
+- Neira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-12 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/xnm/telegram.rb
+- lib/xnm/telegram/Chat.rb
+- lib/xnm/telegram/GroupingAdapter.rb
+- lib/xnm/telegram/HTTPCore.rb
+- lib/xnm/telegram/Handler.rb
+- lib/xnm/telegram/KeyboardLayout.rb
+- lib/xnm/telegram/MQTT_Adapter.rb
+- lib/xnm/telegram/Message.rb
+- lib/xnm/telegram/OnCommand.rb
+- lib/xnm/telegram/OnMessage.rb
+- lib/xnm/telegram/SingleUser.rb
+- lib/xnm/telegram/TestHTTPCore.rb
+- lib/xnm/telegram/User.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: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: XasinTheSystem's Telegram gem
+test_files: []