acenda-client 0.0.11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6323bffab1ce23b5fcd8195814b6a450f6ec6a97
+  data.tar.gz: 8ca9a125d8cec204bfe552d9459d96301499f309
+SHA512:
+  metadata.gz: e81604031e2ebfcf91b5f7a637b1eb7da8e1795ba04dcb9691f2f041cdba702ebbb0e759843d29e6f0cc7290e6c8b9afea19924c868494725436a50c04dc72f5
+  data.tar.gz: 44fbdca6ca2a1f537fcf3e1b6703c432bbd44056b093f14473d4edc0b9f6601e5aa8c1abe4ecd5adf93654433cf3567da061fc447137e5123ca5e68cd9fa7c7c

data/lib/acenda-client.rb

@@ -0,0 +1,253 @@
+require 'uri'
+require 'logger'
+
+module URI
+  remove_const :DEFAULT_PARSER
+  unreserved = REGEXP::PATTERN::UNRESERVED
+  DEFAULT_PARSER = Parser.new(:UNRESERVED => unreserved + "\{\}")
+end
+
+module Acenda
+    class APIErrorHTTP < StandardError; end
+    class APIErrorClient < StandardError; end
+    class Response
+        require 'json'
+
+        def initialize(response, url="", params=[], debug = false)
+            @logger = Logger.new(STDOUT)
+            @url = url
+            @params = params
+            @response = treat_response(response)
+
+            @logger.info "Acenda:: response body:" if debug == true
+            @logger.info response.body if debug == true
+            @logger.info "Acenda:: response code:" if debug == true
+            @logger.info response.code if debug == true
+            puts "\r\n" if debug == true
+        end
+
+        def get_url()
+            return @url
+        end
+
+        def get_params()
+            return @params
+        end
+
+        def get_result()
+            return @response[:result]
+        end
+
+        def get_number()
+            return @response[:num_total]
+        end
+
+        def get_code()
+            raise Acenda::APIErrorHTTP, "Request didn't go through and error cannot be parsed." if @response[:code].to_i == 0
+            return @response[:code].to_i
+        end
+
+        def get_status()
+            return @response[:status]
+        end
+
+        private
+
+            def treat_response(http_response)
+                begin
+                    if http_response.class == String
+                        return symbolize_result(JSON.parse(http_response))
+                    else
+                        return {
+                            :result => symbolize_result(JSON.parse(http_response.body)),
+                            :code => http_response.code().to_i,
+                            :num_total => 1,
+                            :status => http_response.message()
+                        }
+                    end
+                rescue JSON::ParserError => e
+                    raise Acenda::APIErrorHTTP, "JSON response is not a good format for query #{@url.to_s} and params #{@params.to_json}"
+                end
+            end
+
+            def symbolize_result(source)
+                dest = source.is_a?(Array) ? [] : {}
+
+                source.each_with_index { |(key,value), index|
+                    k = key.is_a?(String) ? key.to_sym : key
+                    if value.is_a? Hash or value.is_a? Array
+                        dest[k] = symbolize_result(value)
+                    else
+                        dest[k] = value
+                    end
+                } if source.is_a? Hash
+
+                source.each_with_index { |value, index|
+                    dest[index] = symbolize_result(value)
+                } if source.class == Array
+
+                return dest
+            end
+    end
+
+    class API
+        require 'uri'
+        require 'openssl'
+        require 'net/https'
+
+        def initialize(client_id, client_secret, store_url, verify_ssl = true, debug = false)
+            if (client_id.is_a? String and client_secret.is_a? String and store_url.is_a? String)
+                raise Acenda::APIErrorClient, "store_url MUST be a valid URL" unless store_url =~ URI::regexp
+                @logger = Logger.new(STDOUT)
+                @config = {
+                    :client_id => client_id,
+                    :client_secret => client_secret,
+                    :store_url => store_url + (store_url.split('').last == '/' ? 'api' : '/api'),
+                    :access_token => nil,
+                    :acenda_api_url => store_url,
+                    :verify_ssl => verify_ssl,
+                    :debug => debug
+                }
+
+                @logger.info "Acenda:: Configuration:"  if @config[:debug] == true
+                @logger.info @config.to_json
+                puts "\r\n" if @config[:debug] == true
+
+            else
+                raise Acenda::APIErrorClient, "Wrong parameters type provided to Acenda::API"
+            end
+        end
+
+        def query(verb, uri, params={})
+            if (verb.is_a? String and uri.is_a? String and params.is_a? Hash)
+                generate_token() if (!@config[:access_token])
+
+                json_headers = {"Content-Type" => "application/json",
+                "Accept" => "application/json"}
+                begin
+                    case verb.downcase
+                    when "get"
+                        query = generate_query(uri, params)
+
+                        http = Net::HTTP.new(query.host, query.port)
+                        
+                        http.use_ssl = true if query.scheme == "https"
+                        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if query.scheme == "https" and !@config[:verify_ssl] 
+                        
+                        @logger.info "Acenda:: URI:" if @config[:debug] == true
+                        @logger.info uri.to_s if @config[:debug] == true
+                        @logger.info "Acenda:: PARAMS:" if @config[:debug] == true
+                        @logger.info params if @config[:debug] == true
+                        puts "\r\n" if @config[:debug] == true
+
+                        return Acenda::Response.new(http.get(query), query, params, @config[:debug])
+                    when "post"
+                        query = generate_query(uri)
+
+                        http = Net::HTTP.new(query.host, query.port)
+                        
+                        http.use_ssl = true if query.scheme == "https"
+                        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if query.scheme == "https" and !@config[:verify_ssl] 
+
+                        @logger.info "Acenda:: URI:" if @config[:debug] == true
+                        @logger.info uri.to_s if @config[:debug] == true
+                        @logger.info "Acenda:: PARAMS:" if @config[:debug] == true
+                        @logger.info params if @config[:debug] == true
+                        puts "\r\n" if @config[:debug] == true
+                        
+                        return Acenda::Response.new http.post(query, params.to_json, json_headers), query, params, @config[:debug]
+                    when "put"
+                        query = generate_query(uri)
+
+                        http = Net::HTTP.new(query.host, query.port)
+                        
+                        http.use_ssl = true if query.scheme == "https"
+                        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if query.scheme == "https" and !@config[:verify_ssl] 
+
+                        @logger.info "Acenda:: URI:" if @config[:debug] == true
+                        @logger.info uri.to_s if @config[:debug] == true
+                        @logger.info "Acenda:: PARAMS:" if @config[:debug] == true
+                        @logger.info params if @config[:debug] == true
+                        puts "\r\n" if @config[:debug] == true
+
+                        return Acenda::Response.new(http.put(query, params.to_json, json_headers), query, params, @config[:debug])
+                    when "delete"
+                        query = generate_query(uri, params)
+
+                        http = Net::HTTP.new(query.host, query.port)
+                        
+                        http.use_ssl = true if query.scheme == "https"
+                        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if query.scheme == "https" and !@config[:verify_ssl] 
+
+                        @logger.info "Acenda:: URI:" if @config[:debug] == true
+                        @logger.info uri.to_s if @config[:debug] == true
+                        @logger.info "Acenda:: PARAMS:" if @config[:debug] == true
+                        @logger.info params if @config[:debug] == true
+                        puts "\r\n" if @config[:debug] == true
+
+                        return Acenda::Response.new(http.delete(query), query, params, @config[:debug])
+                    else
+                        raise Acenda::APIErrorClient, "Verb not recognized yet"
+                    end
+                rescue => e
+                    e.backtrace.push("\r\nError custom trace:\r\nQuery: #{query}\r\n\r\nParams: #{params}\r\n")
+                end
+            else
+                raise Acenda::APIErrorClient, "Wrong parameters type provided to Acenda::API.query"
+            end
+        end
+
+        @config = {}
+
+        def generate_query(uri, params={})
+            params = params.merge :access_token => @config[:access_token]
+
+            parameters = ""
+            params.each_with_index do |(k,v), i|
+                parameters += "&" unless i < 1
+                parameters += k.to_s+"="+URI.encode(v.to_s)
+            end if params != ""
+
+            @route = @config[:store_url]
+            @route += (uri.split('').first == '/') ? uri : '/'+uri
+            @route += (uri.count('?') > 0 ? '&' : '?')+parameters
+            
+            @route = URI(@route)
+
+            return @route
+        end
+
+        def generate_token()
+            json_headers = {"Content-Type" => "application/json",
+                "Accept" => "application/json"}
+
+            uri = URI.parse(@config[:acenda_api_url]+"/oauth/token")
+            http = Net::HTTP.new(uri.host, uri.port)
+            
+            http.use_ssl = true if uri.scheme == "https"
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE if uri.scheme == "https" and !@config[:verify_ssl] 
+
+            params = {
+                "client_id" => @config[:client_id],
+                "client_secret" => @config[:client_secret],
+                "grant_type" => "client_credentials"
+            }
+
+            @logger.info "Acenda:: URI:" if @config[:debug] == true
+            @logger.info uri.to_s if @config[:debug] == true
+            @logger.info "Acenda:: PARAMS:" if @config[:debug] == true
+            @logger.info params if @config[:debug] == true
+            puts "\r\n" if @config[:debug] == true
+
+            begin
+                response = Acenda::Response.new http.post(uri, params.to_json, json_headers), uri, params, @config[:debug]
+            rescue => e
+                e.backtrace.push("\r\nError custom trace:\r\nQuery: #{query}\r\n\r\nParams: #{params}\r\n")
+            end
+            @config[:access_token] = response.get_result()[:access_token] unless response.get_code() != 200
+            raise Acenda::APIErrorHTTP, "Token generation failed #{response.get_code()}" if response.get_code() != 200
+        end
+
+        private :generate_query, :generate_token
+    end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: acenda-client
+version: !ruby/object:Gem::Version
+  version: 0.0.11
+platform: ruby
+authors:
+- Yoann Jaspar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+description: HTTP dialog for the Acenda API with the oAuth2 authentication.
+email: yoannj@acenda.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/acenda-client.rb
+homepage: https://github.com/torreycommerce/acenda-ruby-sdk
+licenses:
+- MIT
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Acenda client to access the API in Ruby.
+test_files: []