fantastic_robot 0.1.1

data/lib/fantastic_robot/model/attachment/voice.rb

@@ -0,0 +1,12 @@
+module FantasticRobot
+  # This object represents a voice note.
+  class Model::Attachment::Voice < Model::Attachment::Base
+
+    attr_accessor :file_id, :file_size, :duration, :mime_type
+
+    validates :file_id, :duration, presence: true
+    validates :duration, numericality: true
+    validates :file_size, numericality: true, unless: 'file_size.blank?'
+
+  end
+end

data/lib/fantastic_robot/model/base.rb

@@ -0,0 +1,68 @@
+module FantasticRobot
+  module Model
+    class Base
+      include ::ActiveModel::Model
+      include ::ActiveModel::Validations
+      include ::ActiveModel::Serialization
+      include ::ActiveModel::Serializers::JSON
+
+      # As the models include a lot of different objects related,
+      # we build a conversion hash that indicates the type of objects
+      # required in special fields.
+      FIELD_CONVERSIONS = {}
+
+      # Initializer that converts the fields received if necessary
+      def initialize(attributes = {})
+
+        # Define a setter for each field that need to be converted
+        self.class::FIELD_CONVERSIONS.each do |field_name, field_type|
+          self.class.send(:define_method, "#{field_name}=") do |value|
+            if (value.is_a?(Array))
+              # If we receive an array, process each value
+              value.map! do |v|
+                # Convert each object except if it is already converted or nil
+                v = ((v.class == field_type || v.nil?) ? v : field_type.new(v))
+              end
+            else
+              # If it isn't an array, try to convert the object
+              value = field_type.new(value) unless (value.class == field_type || value.nil?)
+            end
+
+            # Set the result
+            instance_variable_set("@#{field_name}", value)
+          end
+        end
+
+        super(attributes)
+      end
+
+      # Attribute map for ActiveModel::Serialization.
+      def attributes
+        Hash[instance_variables.map{|attrib| [attrib.to_s[1..attrib.to_s.size], nil]}]
+      end
+
+      # Proxy to get a serialized version of the object.
+      def to_h
+        recursive_serialization(self)
+      end
+
+      private
+
+      # Method to try to recursively seralize the objects received
+      def recursive_serialization object
+        if (object.is_a?(Array))
+          # If it's an array, try to serialize each element
+          return object.map{|o| recursive_serialization(o)}
+        elsif (object.is_a?(Hash))
+          # It's a hash, convert each key to sym and try to serialize each value
+          return Hash[object.map{|k,v| [k.to_sym, recursive_serialization(v)]}]
+        elsif (object.respond_to?(:serializable_hash))
+          # If it can be seralized, serialize and try to recursively convert it's attributes
+          return recursive_serialization(object.serializable_hash)
+        else
+          return object
+        end
+      end
+    end
+  end
+end

data/lib/fantastic_robot/model/chat.rb

@@ -0,0 +1,14 @@
+module FantasticRobot
+  # This object represents a chat.
+  class Model::Chat < Model::Base
+
+    VALID_TYPES = ["private", "group", "supergroup", "channel"]
+
+    attr_accessor :id, :type, :title, :username, :first_name, :last_name
+
+    validates :id, :type, presence: true
+    validates :id, numericality: true
+    validates :type, inclusion: {in: VALID_TYPES}
+
+  end
+end

data/lib/fantastic_robot/model/file.rb

@@ -0,0 +1,14 @@
+module FantasticRobot
+  # This object represents a file.
+  class Model::File < Model::Base
+
+    attr_accessor :file_id, :file_size, :file_path
+
+    validates :file_id, presence: true
+    validates :file_size, numericality: true, allow_blank: true
+
+    def self.file
+      FantasticRobot.connection.get_by_path(self.file_path) unless self.file_path.blank?
+    end
+  end
+end

data/lib/fantastic_robot/model/message.rb

@@ -0,0 +1,51 @@
+require 'fantastic_robot/model/attachment/base'
+require 'fantastic_robot/model/attachment/photo_size'
+require 'fantastic_robot/model/attachment/audio'
+require 'fantastic_robot/model/attachment/contact'
+require 'fantastic_robot/model/attachment/document'
+require 'fantastic_robot/model/attachment/location'
+require 'fantastic_robot/model/attachment/sticker'
+require 'fantastic_robot/model/attachment/video'
+require 'fantastic_robot/model/attachment/voice'
+
+module FantasticRobot
+  class Model::Message < Model::Base
+
+    attr_accessor :message_id, :from, :date, :chat, :forward_from, :fordward_date,
+      :reply_to_message
+
+    validates :message_id, :date, :chat, presence: true
+    validates :message_id, :date, numericality: true
+    validates :fordward_date, numericality: true, unless: 'fordward_date.blank?'
+
+    attr_accessor :text, :audio, :document, :photo, :sticker, :video, :voice,
+      :caption, :contact, :location
+
+    attr_accessor :new_chat_participant, :left_chat_participant, :new_chat_title, :new_chat_photo,
+      :delete_chat_photo, :group_chat_created, :supergroup_chat_created,
+      :channel_chat_created, :migrate_to_chat_id, :migrate_from_chat_id
+
+    validates :migrate_to_chat_id, numericality: true, unless: 'migrate_to_chat_id.blank?'
+    validates :migrate_from_chat_id, numericality: true, unless: 'migrate_from_chat_id.blank?'
+
+    # Field conversions of this model
+    FIELD_CONVERSIONS = {
+      from: FantasticRobot::Model::User,
+      chat: FantasticRobot::Model::Chat,
+      forward_from: FantasticRobot::Model::User,
+      reply_to_message: FantasticRobot::Model::Message,
+      audio: FantasticRobot::Model::Attachment::Audio,
+      document: FantasticRobot::Model::Attachment::Document,
+      photo: FantasticRobot::Model::Attachment::PhotoSize,
+      sticker: FantasticRobot::Model::Attachment::Sticker,
+      video: FantasticRobot::Model::Attachment::Video,
+      voice: FantasticRobot::Model::Attachment::Voice,
+      contact: FantasticRobot::Model::Attachment::Contact,
+      location: FantasticRobot::Model::Attachment::Location,
+      new_chat_participant: FantasticRobot::Model::User,
+      left_chat_participant: FantasticRobot::Model::User,
+      new_chat_photo: FantasticRobot::Model::Attachment::PhotoSize
+    }
+
+  end
+end

data/lib/fantastic_robot/model/update.rb

@@ -0,0 +1,15 @@
+module FantasticRobot
+  class Model::Update < Model::Base
+
+    attr_accessor :update_id, :message
+
+    validates :update_id, presence: true
+    validates :update_id, numericality: true
+
+    # Field conversions of this model
+    FIELD_CONVERSIONS = {
+      message: FantasticRobot::Model::Message
+    }
+
+  end
+end

data/lib/fantastic_robot/model/user.rb

@@ -0,0 +1,11 @@
+module FantasticRobot
+  # This object represents a Telegram user or bot.
+  class Model::User < Model::Base
+
+    attr_accessor :id, :first_name, :last_name, :username
+
+    validates :id, :first_name, presence: true
+    validates :id, numericality: true
+    
+  end
+end

data/lib/fantastic_robot/models.rb

@@ -0,0 +1,6 @@
+require "fantastic_robot/model/base"
+require "fantastic_robot/model/user"
+require "fantastic_robot/model/chat"
+require "fantastic_robot/model/file"
+require "fantastic_robot/model/message"
+require "fantastic_robot/model/update"

data/lib/fantastic_robot/request/base.rb

@@ -0,0 +1,59 @@
+module FantasticRobot
+  module Request
+    class Base
+      include ::ActiveModel::Model
+      include ::ActiveModel::Validations
+      include ::ActiveModel::Serialization
+      include ::ActiveModel::Serializers::JSON
+
+      attr_reader :method
+
+      # Initializer that assigns the fields received
+      def initialize(attributes = {})
+        super(attributes)
+      end
+
+      # Attribute map for ActiveModel::Serialization.
+      def attributes
+        Hash[instance_variables.map{|attrib| [attrib.to_s[1..attrib.to_s.size], nil]}]
+      end
+
+      # Proxy to get a serialized version of the object.
+      def to_h
+        recursive_serialization(self)
+      end
+
+      # Send request to Telegram API
+      def send_request
+        raise ArgumentError, "Method name not defined" if (self.method.blank?)
+
+        payload = self.to_h
+        payload.delete(:method)
+
+        payload.each do |key, value|
+          payload[key] = Faraday::UploadIO.new(payload[key], MIME::Types.type_for(payload[key].path).first.content_type) if (value.is_a?(File))
+        end
+
+        FantasticRobot.connection.api_call self.method, payload
+      end
+
+      private
+
+      # Method to try to recursively seralize the objects received
+      def recursive_serialization object
+        if (object.is_a?(Array))
+          # If it's an array, try to serialize each element
+          return object.map{|o| recursive_serialization(o)}
+        elsif (object.is_a?(Hash))
+          # It's a hash, convert each key to sym and try to serialize each value
+          return Hash[object.map{|k,v| [k.to_sym, recursive_serialization(v)]}]
+        elsif (object.respond_to?(:serializable_hash))
+          # If it can be seralized, serialize and try to recursively convert it's attributes
+          return recursive_serialization(object.serializable_hash)
+        else
+          return object
+        end
+      end
+    end
+  end
+end

data/lib/fantastic_robot/request/forward_message.rb

@@ -0,0 +1,18 @@
+module FantasticRobot
+  # This object represents a forwardMessage request
+  class Request::ForwardMessage < Request::Base
+
+    attr_accessor :chat_id, :from_chat_id, :message_id, :disable_web_page_preview, :reply_to_message_id, :reply_markup
+
+    validates :chat_id, :from_chat_id, :message_id, presence: true
+    validates :message_id, presence: true
+    validates :chat_id, numericality: true, unless: "chat_id.to_s[0,1] == '@'"
+    validates :from_chat_id, numericality: true, unless: "from_chat_id.to_s[0,1] == '@'"
+    validates :reply_to_message_id, numericality: true, allow_blank: true
+
+    def initialize(attributes = {})
+      super(attributes)
+      @method = :forwardMessage
+    end
+  end
+end

data/lib/fantastic_robot/request/get_me.rb

@@ -0,0 +1,9 @@
+module FantasticRobot
+  # This object represents a getMe request
+  class Request::GetMe < Request::Base
+    def initialize(attributes = {})
+      super(attributes)
+      @method = :getMe
+    end
+  end
+end

data/lib/fantastic_robot/request/send_audio.rb

@@ -0,0 +1,32 @@
+module FantasticRobot
+  # This object represents a sendAudio request
+  class Request::SendAudio < Request::Base
+
+    MAX_FILE_SIZE = 50*1024*1024
+
+    attr_accessor :chat_id, :audio, :duration, :performer, :title, :reply_to_message_id, :reply_markup
+
+    validates :chat_id, :audio, presence: true
+    validates :chat_id, numericality: true, unless: "chat_id.to_s[0,1] == '@'"
+    validates :duration, :reply_to_message_id, numericality: true, allow_blank: true
+
+    validate :file_length
+
+    def initialize(attributes = {})
+      super(attributes)
+      @method = :sendAudio
+    end
+
+    private
+
+    # Function to check that the file size isn't excesive.
+    def file_length
+      if self.audio.is_a?(File) && self.audio.size > MAX_FILE_SIZE
+        self.errors.add :audio, "It's length is excesive. #{MAX_FILE_SIZE} is the limit."
+        return false
+      end
+
+      return true
+    end
+  end
+end

data/lib/fantastic_robot/request/send_chat_action.rb

@@ -0,0 +1,18 @@
+module FantasticRobot
+  # This object represents a sendChatAction request
+  class Request::SendChatAction < Request::Base
+
+    attr_accessor :chat_id, :action
+
+    VALID_ACTIONS = [:typing, :upload_photo, :record_video, :upload_video, :record_audio, :upload_audio, :upload_document, :find_location]
+
+    validates :chat_id, :action, presence: true
+    validates :chat_id, numericality: true, unless: "chat_id.to_s[0,1] == '@'"
+    validates :action, inclusion: { in: VALID_ACTIONS }
+
+    def initialize(attributes = {})
+      super(attributes)
+      @method = :sendChatAction
+    end
+  end
+end

data/lib/fantastic_robot/request/send_document.rb

@@ -0,0 +1,32 @@
+module FantasticRobot
+  # This object represents a sendDocument request
+  class Request::SendDocument < Request::Base
+
+    MAX_FILE_SIZE = 50*1024*1024
+
+    attr_accessor :chat_id, :document, :reply_to_message_id, :reply_markup
+
+    validates :chat_id, :document, presence: true
+    validates :chat_id, numericality: true, unless: "chat_id.to_s[0,1] == '@'"
+    validates :reply_to_message_id, numericality: true, allow_blank: true
+
+    validate :file_length
+
+    def initialize(attributes = {})
+      super(attributes)
+      @method = :sendDocument
+    end
+
+    private
+
+    # Function to check that the file size isn't excesive.
+    def file_length
+      if self.document.is_a?(File) && self.document.size > MAX_FILE_SIZE
+        self.errors.add :document, "It's length is excesive. #{MAX_FILE_SIZE} is the limit."
+        return false
+      end
+
+      return true
+    end
+  end
+end

data/lib/fantastic_robot/request/send_location.rb

@@ -0,0 +1,17 @@
+module FantasticRobot
+  # This object represents a sendLocation request
+  class Request::SendLocation < Request::Base
+
+    attr_accessor :chat_id, :latitude, :longitude, :reply_to_message_id, :reply_markup
+
+    validates :chat_id, :latitude, :longitude, presence: true
+    validates :latitude, :longitude, numericality: true
+    validates :chat_id, numericality: true, unless: "chat_id.to_s[0,1] == '@'"
+    validates :reply_to_message_id, numericality: true, allow_blank: true
+
+    def initialize(attributes = {})
+      super(attributes)
+      @method = :sendLocation
+    end
+  end
+end

data/lib/fantastic_robot/request/send_message.rb

@@ -0,0 +1,17 @@
+module FantasticRobot
+  # This object represents a sendMessage request
+  class Request::SendMessage < Request::Base
+
+    attr_accessor :chat_id, :text, :parse_mode, :disable_web_page_preview, :reply_to_message_id, :reply_markup
+
+    validates :chat_id, :text, presence: true
+    validates :chat_id, numericality: true, unless: "chat_id.to_s[0,1] == '@'"
+    validates :disable_web_page_preview, inclusion: {in: [true, false]}, allow_blank: true
+    validates :reply_to_message_id, numericality: true, allow_blank: true
+
+    def initialize(attributes = {})
+      super(attributes)
+      @method = :sendMessage
+    end
+  end
+end

data/lib/fantastic_robot/request/send_photo.rb

@@ -0,0 +1,16 @@
+module FantasticRobot
+  # This object represents a sendPhoto request
+  class Request::SendPhoto < Request::Base
+
+    attr_accessor :chat_id, :photo, :caption, :reply_to_message_id, :reply_markup
+
+    validates :chat_id, :photo, presence: true
+    validates :chat_id, numericality: true, unless: "chat_id.to_s[0,1] == '@'"
+    validates :reply_to_message_id, numericality: true, allow_blank: true
+
+    def initialize(attributes = {})
+      super(attributes)
+      @method = :sendPhoto
+    end
+  end
+end

data/lib/fantastic_robot/request/send_sticker.rb

@@ -0,0 +1,18 @@
+module FantasticRobot
+  # This object represents a sendSticker request
+  class Request::SendSticker < Request::Base
+
+    MAX_FILE_SIZE = 50*1024*1024
+
+    attr_accessor :chat_id, :sticker, :reply_to_message_id, :reply_markup
+
+    validates :chat_id, :sticker, presence: true
+    validates :chat_id, numericality: true, unless: "chat_id.to_s[0,1] == '@'"
+    validates :reply_to_message_id, numericality: true, allow_blank: true
+
+    def initialize(attributes = {})
+      super(attributes)
+      @method = :sendSticker
+    end
+  end
+end

data/lib/fantastic_robot/request/send_video.rb

@@ -0,0 +1,32 @@
+module FantasticRobot
+  # This object represents a sendVideo request
+  class Request::SendVideo < Request::Base
+
+    MAX_FILE_SIZE = 50*1024*1024
+
+    attr_accessor :chat_id, :video, :duration, :caption, :reply_to_message_id, :reply_markup
+
+    validates :chat_id, :video, presence: true
+    validates :chat_id, numericality: true, unless: "chat_id.to_s[0,1] == '@'"
+    validates :duration, :reply_to_message_id, numericality: true, allow_blank: true
+
+    validate :file_length
+
+    def initialize(attributes = {})
+      super(attributes)
+      @method = :sendVideo
+    end
+
+    private
+
+    # Function to check that the file size isn't excesive.
+    def file_length
+      if self.video.is_a?(File) && self.video.size > MAX_FILE_SIZE
+        self.errors.add :video, "It's length is excesive. #{MAX_FILE_SIZE} is the limit."
+        return false
+      end
+
+      return true
+    end
+  end
+end

data/lib/fantastic_robot/request/send_voice.rb

@@ -0,0 +1,32 @@
+module FantasticRobot
+  # This object represents a sendVoice request
+  class Request::SendVoice < Request::Base
+
+    MAX_FILE_SIZE = 50*1024*1024
+
+    attr_accessor :chat_id, :voice, :duration, :reply_to_message_id, :reply_markup
+
+    validates :chat_id, :voice, presence: true
+    validates :chat_id, numericality: true, unless: "chat_id.to_s[0,1] == '@'"
+    validates :duration, :reply_to_message_id, numericality: true, allow_blank: true
+
+    validate :file_length
+
+    def initialize(attributes = {})
+      super(attributes)
+      @method = :sendVoice
+    end
+
+    private
+
+    # Function to check that the file size isn't excesive.
+    def file_length
+      if self.voice.is_a?(File) && self.voice.size > MAX_FILE_SIZE
+        self.errors.add :voice, "It's length is excesive. #{MAX_FILE_SIZE} is the limit."
+        return false
+      end
+
+      return true
+    end
+  end
+end

data/lib/fantastic_robot/request/set_webhook.rb

@@ -0,0 +1,29 @@
+module FantasticRobot
+  # This object represents a setWebhook request
+  class Request::SetWebhook < Request::Base
+
+    attr_accessor :url
+
+    validates :url, presence: true
+    validate :https_url
+
+    def initialize(attributes = {})
+      super(attributes)
+      @method = :setWebhook
+    end
+
+    private
+
+    # Check that the URL is a HTTPS one
+    def https_url
+      return false if (url.blank?)
+
+      unless (url[0,8] == "https://")
+        errors.add :url, "Must be an HTPPS URL."
+        return false
+      end
+
+      return true
+    end
+  end
+end

data/lib/fantastic_robot/requests.rb

@@ -0,0 +1,13 @@
+require "fantastic_robot/request/base"
+require "fantastic_robot/request/forward_message"
+require "fantastic_robot/request/get_me"
+require "fantastic_robot/request/send_audio"
+require "fantastic_robot/request/send_chat_action"
+require "fantastic_robot/request/send_document"
+require "fantastic_robot/request/send_location"
+require "fantastic_robot/request/send_message"
+require "fantastic_robot/request/send_photo"
+require "fantastic_robot/request/send_sticker"
+require "fantastic_robot/request/send_video"
+require "fantastic_robot/request/send_voice"
+require "fantastic_robot/request/set_webhook"

data/lib/fantastic_robot/version.rb

@@ -0,0 +1,3 @@
+module FantasticRobot
+  VERSION = "0.1.1"
+end

data/lib/fantastic_robot.rb

@@ -0,0 +1,56 @@
+require "active_model"
+require "faraday"
+require "fantastic_robot/models"
+require "fantastic_robot/requests"
+require "fantastic_robot/configuration"
+require "fantastic_robot/connection"
+require "fantastic_robot/version"
+
+module FantasticRobot
+  class << self
+    attr_accessor :configuration
+    attr_reader :connection
+  end
+
+  def self.initialize!
+    raise ArgumentError, "API Key is needed." if (self.configuration.api_key.blank?)
+
+    if (self.configuration.delivery_method == :webhook)
+      unless (self.configuration.callback_url.blank?)
+        # Register the webhook against Telegram
+        register_webhook
+      else
+        raise ArgumentError, 'Webhook method requires a callback URL'
+      end
+    end
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.connection
+    @connection ||= Connection.new
+  end
+
+  ##
+  # Function to register the configured webhook against the Telegram API.
+  #
+  def self.register_webhook
+    FantasticRobot::Request::SetWebhook.new(url: self.configuration.callback_url).send_request
+  end
+
+  ##
+  # Method to respond to an update with a request.
+  # It can manage a Request object or a hash.
+  #
+  def self.response_json(request)
+    return nil unless request.is_a?(Hash) || request.is_a?(FantasticRobot::Request::Base)
+    request.to_h
+  end
+end

data/lib/generators/fantastic_robot/files/fantastic_robot.rb

@@ -0,0 +1,12 @@
+FantasticRobot.configure do |config|
+  # Secret token of the API
+  config.api_key = 'your_bot_api_token'
+
+  # Delivery method (can be :polling or :webhook)
+  config.delivery_method = :webhook
+
+  # Callback URL of the webhook
+  config.callback_url = 'http://your_app.dev/receive'
+end
+
+FantasticRobot.initialize! if(defined?(::Thin) || defined?(::Unicorn) || defined?(::Passenger) || defined?(::Puma))

data/lib/generators/fantastic_robot/install_generator.rb

@@ -0,0 +1,13 @@
+require 'rails/generators/named_base'
+
+module FantasticRobot
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../files", __FILE__)
+
+      def copy_config_files
+        copy_file "fantastic_robot.rb", "config/initializers/fantastic_robot.rb"
+      end
+    end
+  end
+end