realpush 0.0.1

data/lib/realpush/api/base_list.rb

@@ -0,0 +1,22 @@
+module RealPush
+  module API
+    module BaseList
+      extend ActiveSupport::Concern
+
+      def self.included(base)
+        base.class_eval do
+          def list
+            content = execute :get, url("#{self.class.params[:base_path]}.json")
+            parse_content content
+          rescue RealPush::HTTPError => e
+            {
+                status: :ERROR,
+                message: e.message
+            }
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/realpush/api/base_update.rb

@@ -0,0 +1,21 @@
+module RealPush
+  module API
+    module BaseUpdate
+      extend ActiveSupport::Concern
+
+      def self.included(base)
+        base.class_eval do
+          def update(id, data)
+            valid_params? data
+            content = execute :patch, url("#{self.class.params[:base_path]}/#{id}.json"), {}, data
+            parse_content content
+          rescue RealPush::HTTPError,
+                 RealPush::ConfigurationError => e
+            raise RealPush::ConfigurationError, e.message
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/realpush/client.rb

@@ -0,0 +1,188 @@
+require 'signature'
+require 'multi_json'
+
+module RealPush
+
+  class Client
+
+    attr_accessor :scheme, :app_id, :privatekey, :hostname, :port
+    attr_writer :connect_timeout, :send_timeout, :receive_timeout,
+                :keep_alive_timeout
+
+    def initialize(options={})
+      options = {
+        port: 443,
+        scheme: 'http',
+        hostname: '127.0.0.1',
+        app_id: nil,
+        privatekey: nil
+      }.merge options
+
+      @encrypted = false
+
+      @scheme, @app_id, @privatekey, @hostname, @port = options.values_at(
+        :scheme, :app_id, :privatekey, :hostname, :port
+      )
+
+      # Default timeouts
+      @connect_timeout = 5
+      @send_timeout = 5
+      @receive_timeout = 5
+      @keep_alive_timeout = 30
+    end
+
+    def authenticate(publickey, privatekey)
+      @app_id, @privatekey = publickey, privatekey
+    end
+
+    # Generate the expected response for an authentication endpoint.
+    #
+    # @example Private channels
+    #   render :json => RealPush.default_client.authenticate(params[:realpush])
+    #
+    # @param custom_string [String | Hash]
+    #
+    # @return [Hash]
+    def authentication_string(custom_string=nil)
+      custom_string = MultiJson.encode(custom_string) if custom_string.kind_of?(Hash)
+      unless custom_string.nil? || custom_string.kind_of?(String)
+        raise Error, 'Custom argument must be a string'
+      end
+
+      string_to_sign = [app_id, custom_string].compact.map(&:to_s).join(':')
+      digest = OpenSSL::Digest::SHA256.new
+      signature = OpenSSL::HMAC.hexdigest(digest, privatekey, string_to_sign)
+      {auth:signature}
+    end
+
+    # @private Returns the authentication token for the client
+    def authentication_token
+      Signature::Token.new(app_id, privatekey)
+    end
+
+    def config(&block)
+      raise ConfigurationError, 'You need a block' unless block_given?
+      yield self
+    end
+
+    def encrypted=(bool)
+      @scheme = bool ? 'https' : 'http'
+      # Configure port if it hasn't already been configured
+      @port = bool ? 443 : 80
+    end
+
+    def encrypted?
+      scheme == 'https'
+    end
+
+    def get(path, params)
+      Resource.new(self, "/#{app_id}#{path}").get params
+    end
+
+    def get_async(path, params)
+      Resource.new(self, "/#{app_id}#{path}").get_async params
+    end
+
+    def post(path, body)
+      Resource.new(self, "/#{app_id}#{path}").post body
+    end
+
+    def post_async(path, body)
+      Resource.new(self, "/#{app_id}#{path}").post_async body
+    end
+
+    # @private Construct a net/http http client
+    def sync_http_client
+      @client ||= begin
+        require 'httpclient'
+
+        HTTPClient.new(default_header: {'X-RealPush-Secret-Key' => @privatekey}).tap do |c|
+          c.connect_timeout = @connect_timeout
+          c.send_timeout = @send_timeout
+          c.receive_timeout = @receive_timeout
+          c.keep_alive_timeout = @keep_alive_timeout
+        end
+      end
+    end
+
+    # Convenience method to set all timeouts to the same value (in seconds).
+    # For more control, use the individual writers.
+    def timeout=(value)
+      @connect_timeout, @send_timeout, @receive_timeout = value, value, value
+    end
+
+    # Trigger an event on one or more channels
+    #
+    # POST /api/[api_version]/events/[event_name]/
+    #
+    # @param channels [String or Array] 1-10 channel names
+    # @param event_name [String]
+    # @param data [Object] Event data to be triggered in javascript.
+    #   Objects other than strings will be converted to JSON
+    #
+    # @return [Hash] See Thunderpush API docs
+    #
+    # @raise [ThunderPush::Error] Unsuccessful response - see the error message
+    # @raise [ThunderPush::HTTPError] Error raised inside http client. The original error is wrapped in error.original_error
+    #
+    def trigger(channels, event_name, data)
+      post("/events/#{event_name}/", trigger_params(channels, data))
+    end
+
+    # Trigger an event on one or more channels
+    #
+    # POST /apps/[app_id]/events/[event_name]/
+    #
+    # @param channels [String or Array] 1-10 channel names
+    # @param event_name [String]
+    # @param data [Object] Event data to be triggered in javascript.
+    #   Objects other than strings will be converted to JSON
+    #
+    # @raise [ThunderPush::Error] Unsuccessful response - see the error message
+    # @raise [ThunderPush::HTTPError] Error raised inside http client. The original error is wrapped in error.original_error
+    #
+    def trigger_async(channels, event_name, data)
+      post_async("/events/#{event_name}/", trigger_params(channels, data))
+    end
+
+    # Configure Thunderpush connection by providing a url rather than specifying
+    # scheme, key, secret, and app_id separately.
+    #
+    # @example
+    #   ThunderPush.default_client.url = http://key:secret@127.0.0.1:5678
+    #
+    def url=(str)
+      regex = /^(?<scheme>http|https):\/\/((?<app_id>[\d-]+)(:(?<privatekey>[\w-]+){1})?@)?(?<hostname>[\w\.-]+)(:(?<port>[\d]+))?/
+      match = str.match regex
+      @scheme     = match[:scheme]     unless match[:scheme].nil?
+      self.encrypted= true if scheme == 'https'
+      @port       = match[:port].to_i  unless match[:port].nil?
+      @hostname   = match[:hostname]   unless match[:hostname].nil?
+      @app_id     = match[:app_id]     unless match[:app_id].nil?
+      @privatekey = match[:privatekey] unless match[:privatekey].nil?
+    end
+
+    # @private Builds a url for this app, optionally appending a path
+    def url(path = '')
+      path = "/#{path}" unless path.start_with? '/'
+      URI::Generic.build({
+        :scheme => @scheme,
+        :host => @hostname,
+        :port => @port,
+        :path => "/#{RealPush::API_VERSION_APP}#{path}"
+      })
+    end
+
+    protected
+
+    def trigger_params(channels, data)
+      data.merge! :channels => channels
+      begin
+        MultiJson.encode(data)
+      rescue MultiJson::DecodeError => e
+        ThunderPush.logger.error("Could not convert #{data.inspect} into JSON")
+        raise e
+      end
+    end
+  end
+end

data/lib/realpush/request.rb

@@ -0,0 +1,89 @@
+module RealPush
+  class Request
+    attr_reader :body, :params
+
+    def initialize(client, verb, uri, params={}, body = nil)
+      @client, @verb, @uri, @params = client, verb, uri, params
+
+      raise ConfigurationError, "Invalid verb ('#{verb}')" unless %w{GET POST}.include? verb.to_s.upcase
+      raise ConfigurationError, "Invalid client #{client.inspect}" unless client.is_a? Client
+      raise ConfigurationError, "Invalid uri #{uri.inspect}" unless uri.is_a? URI
+
+      @head = {}
+
+      @body = body
+      if body
+        @params[:body_md5] = Digest::MD5.hexdigest(body)
+        @head['Content-Type'] = 'application/json'
+      end
+
+      sign_params
+    end
+
+    def sign_params
+      auth_hash = {
+          :auth_version => "1.0",
+          :auth_key => @client.app_id,
+          :auth_timestamp => Time.now.to_i.to_s
+      }
+      params_string = auth_hash.sort.map do |k, v|
+        "#{k}=#{v}"
+      end.join('&')
+      string_to_sign = [@verb.to_s.upcase, @uri.path, params_string].join "\n"
+      digest = OpenSSL::Digest::SHA256.new
+      auth_hash[:auth_signature] = OpenSSL::HMAC.hexdigest(digest, @client.privatekey, string_to_sign)
+      @params = @params.merge(auth_hash)
+    end
+    private :sign_params
+
+    def send_sync
+      http = @client.sync_http_client
+
+      begin
+        response = http.request(@verb, @uri, @params, @body, @head)
+      rescue HTTPClient::BadResponseError,
+             HTTPClient::TimeoutError,
+             SocketError,
+             Errno::ECONNREFUSED => e
+        raise RealPush::HTTPError, "#{e.message} (#{e.class})"
+      end
+
+      body = response.body ? response.body.chomp : nil
+
+      return handle_response(response.code.to_i, body)
+    end
+
+    def send_async
+      http = @client.sync_http_client
+      http.request_async(@verb, @uri, @params, @body, @head)
+    end
+
+    private
+
+    def handle_response(status_code, body)
+      case status_code
+        when 200
+          return symbolize_first_level(MultiJson.decode(body))
+        when 202
+          return true
+        when 400
+          raise Error, "Bad request: #{body}"
+        when 401
+          raise AuthenticationError, body
+        when 404
+          raise Error, "404 Not found (#{@uri.path})"
+        when 407
+          raise Error, "Proxy Authentication Required"
+        else
+          raise Error, "Unknown error (status code #{status_code}): #{body}"
+      end
+    end
+
+    def symbolize_first_level(hash)
+      hash.inject({}) do |result, (key, value)|
+        result[key.to_sym] = value
+        result
+      end
+    end
+  end
+end

data/lib/realpush/resource.rb

@@ -0,0 +1,36 @@
+module RealPush
+  class Resource
+    def initialize(client, path)
+      @client = client
+      @path = path
+    end
+
+    def get(params)
+      create_request(:get, params).send_sync
+    end
+
+    def get_async(params)
+      create_request(:get, params).send_async
+    end
+
+    def post(body)
+      body = MultiJson.encode(body) unless body.is_a? String
+      create_request(:post, {}, body).send_sync
+    end
+
+    def post_async(body)
+      body = MultiJson.encode(body) unless body.is_a? String
+      create_request(:post, {}, body).send_async
+    end
+
+    private
+
+    def create_request(verb, params, body = nil)
+      Request.new(@client, verb, url, params, body)
+    end
+
+    def url
+      @_url ||= @client.url(@path)
+    end
+  end
+end

data/lib/realpush/version.rb

@@ -0,0 +1,6 @@
+module RealPush
+  MAJOR = 0
+  MINOR = 0
+  PATCH = 1
+  VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
+end

data/realpush.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'realpush/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'realpush'
+  spec.version       = RealPush::VERSION
+  spec.authors       = ['Zaez Team']
+  spec.email         = ['contato@zaez.net']
+  spec.summary       = %q{Library of integration with RealPush system. Written in Ruby.}
+  spec.description   = %q{RealPush is a private and commercial system to send notifications via websocket.
+The system allows the creation of applications based on its quota through access API.
+Sending notifications to trigger customers with private and public channels. Synchronous and asynchronous requests..}
+  spec.homepage      = 'http://realpush.cc/'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'multi_json', '~> 1.0'
+  spec.add_dependency 'httpclient', '~> 2.6'
+  spec.add_dependency 'signature', '~> 0.1.6'
+  spec.add_dependency 'activesupport', '>= 4'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rspec',   '~> 3.1.0'
+  spec.add_development_dependency 'pry',     '>= 0.9.12'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'codeclimate-test-reporter'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'growl'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'em-http-request', '~> 1.1.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

data/spec/realpush/api/app_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe RealPush::API::App do
+  data = {
+      alias_name: 'APP 1',
+      max_connections: '0',
+      max_daily_messages: '0',
+      status: 'active'
+  }
+
+  it 'should try exception when token has invalid format' do
+    50.times do
+      expect { RealPush::API::App.new( SecureRandom.urlsafe_base64(32, true) ) }.not_to raise_error
+    end
+    expect { RealPush::API::App.new( '' ) }.to           raise_error(RealPush::ConfigurationError)
+    expect { RealPush::API::App.new( '@'+('2'*42) ) }.to raise_error(RealPush::ConfigurationError)
+    expect { RealPush::API::App.new( 'a'*44 ) }.to       raise_error(RealPush::ConfigurationError)
+  end
+
+  describe 'Methods from base configuration' do
+
+    let(:app) { RealPush::API::App.new( SecureRandom.urlsafe_base64(32, true) ) }
+
+    it 'should accept the params in requests (alias_name, max_connections, max_daily_messages, status)' do
+      [:alias_name, :max_connections, :max_daily_messages, :status].each do |p|
+        expect(RealPush::API::App.params_accept.include? p).to eql true
+      end
+    end
+
+    it 'should have a instance method to LIST all APPs' do
+      expect(app.respond_to? :list).to be_truthy
+    end
+
+    it 'should have a instance method to DESTROY an app' do
+      expect(app.respond_to? :destroy).to be_truthy
+    end
+
+    it 'should have a instance method to CREATE an app' do
+      expect(app.respond_to? :create).to be_truthy
+    end
+
+    it 'should have a instance method to UPDATE an app' do
+      expect(app.respond_to? :update).to be_truthy
+    end
+
+  end
+
+  describe 'List method' do
+
+    let(:app) { RealPush::API::App.new( SecureRandom.urlsafe_base64(32, true) ) }
+
+    before do
+      api_path = %r{apps\.json}
+      stub_request(:get, api_path).
+          with({
+                   :headers => { 'X-RealPush-Token' => app.token }
+               }).
+          to_return({
+                        :status => 200,
+                        :body => MultiJson.encode([
+                                                      {id: SecureRandom.hex(12)},
+                                                      {id: SecureRandom.hex(12)},
+                                                      {id: SecureRandom.hex(12)}
+                                                  ])
+                    })
+    end
+
+    it 'testing connection and requesting' do
+      app.list
+    end
+
+    it 'should contains a tree elements in response' do
+      list = app.list
+      expect(list.count).to eql 3
+    end
+
+  end
+
+  describe 'Destroy method' do
+
+    let(:app) { RealPush::API::App.new( SecureRandom.urlsafe_base64(32, true) ) }
+
+    before do
+      api_path = %r{apps/123\.json}
+      stub_request(:delete, api_path).
+          with({
+                   :headers => { 'X-RealPush-Token' => app.token }
+               }).
+          to_return({
+                        :status => 204
+                    })
+    end
+
+    it 'testing connection and requesting, with response 204' do
+      app.destroy(123)
+    end
+
+  end
+
+  describe 'Create method' do
+    let(:app) { RealPush::API::App.new( SecureRandom.urlsafe_base64(32, true) ) }
+
+    before do
+      api_path = %r{apps\.json}
+      stub_request(:post, api_path).
+          with({
+                   :headers => { 'X-RealPush-Token' => app.token },
+                   :body => data
+               }).
+          to_return({
+                        :status => 200,
+                        body: MultiJson.encode( data.merge(id: SecureRandom.hex(12) ) )
+                    })
+    end
+
+    it 'testing connection and requesting, with response 200' do
+      app.create(data)
+    end
+
+    it 'must try exception when has invalid parameter' do
+      expect {app.create({asd: 1}) }.to raise_error(RealPush::ConfigurationError)
+    end
+
+    it 'should returns a App data when successfully' do
+      app_return = app.create(data).symbolize_keys
+      data.keys.each { |key| expect(app_return.keys.include? key.to_sym).to be_truthy }
+      expect(app_return[:id]).to be_truthy
+    end
+
+    it 'should returns error in Hash, when invalid data' do
+      api_path = %r{apps\.json}
+      stub_request(:post, api_path).
+          with({
+                   :headers => { 'X-RealPush-Token' => app.token }
+               }).
+          to_return({
+                        :status => 500,
+                        body: MultiJson.encode( { error: 'Message' } )
+                    })
+      app_return = app.create(data).symbolize_keys
+      data.keys.each { |key| expect(app_return.keys.include? key.to_sym).to be_falsey }
+      expect(app_return[:id]).to be_falsey
+      expect(app_return[:error]).to be_truthy
+    end
+
+  end
+
+  describe 'Update method' do
+    let(:app) { RealPush::API::App.new( SecureRandom.urlsafe_base64(32, true) ) }
+
+    before do
+      api_path = %r{apps/123\.json}
+      stub_request(:patch, api_path).
+          with({
+                   :headers => { 'X-RealPush-Token' => app.token },
+                   :body => data
+               }).
+          to_return({
+                        :status => 200,
+                        body: MultiJson.encode( data.merge(id: 123 ) )
+                    })
+    end
+
+    it 'testing connection and requesting, with response 200' do
+      app.update(123, data)
+    end
+
+    it 'must try exception when has invalid parameter' do
+      expect {app.update(123, {asd: 1}) }.to raise_error(RealPush::ConfigurationError)
+    end
+
+    it 'should returns a App data when successfully' do
+      app_return = app.update(123, data).symbolize_keys
+      data.keys.each { |key| expect(app_return.keys.include? key.to_sym).to be_truthy }
+      expect(app_return[:id]).to be_truthy
+    end
+
+  end
+
+
+
+end