tpaga 0.0.3 → 0.0.4

data/lib/tpaga/models/davi_plata_chargeback.rb

@@ -0,0 +1,60 @@
+module Tpaga
+  # 
+  class DaviPlataChargeback < BaseObject
+    attr_accessor :id, :davi_plata_charge, :davi_plata, :reimbursed
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'id' => :'id',
+        
+        # 
+        :'davi_plata_charge' => :'daviPlataCharge',
+        
+        # 
+        :'davi_plata' => :'daviPlata',
+        
+        # 
+        :'reimbursed' => :'reimbursed'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'id' => :'string',
+        :'davi_plata_charge' => :'string',
+        :'davi_plata' => :'string',
+        :'reimbursed' => :'boolean'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'id']
+        @id = attributes[:'id']
+      end
+      
+      if attributes[:'daviPlataCharge']
+        @davi_plata_charge = attributes[:'daviPlataCharge']
+      end
+      
+      if attributes[:'daviPlata']
+        @davi_plata = attributes[:'daviPlata']
+      end
+      
+      if attributes[:'reimbursed']
+        @reimbursed = attributes[:'reimbursed']
+      end
+      
+    end
+  end
+end

data/lib/tpaga/models/davi_plata_verification.rb

@@ -0,0 +1,44 @@
+module Tpaga
+  # 
+  class DaviPlataVerification < BaseObject
+    attr_accessor :davi_plata, :pin_number
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'davi_plata' => :'daviPlata',
+        
+        # 
+        :'pin_number' => :'pinNumber'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'davi_plata' => :'string',
+        :'pin_number' => :'string'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'daviPlata']
+        @davi_plata = attributes[:'daviPlata']
+      end
+      
+      if attributes[:'pinNumber']
+        @pin_number = attributes[:'pinNumber']
+      end
+      
+    end
+  end
+end

data/lib/tpaga/monkey.rb

@@ -87,4 +87,4 @@
     end
   
   end
-# end
+# end

data/lib/tpaga/swagger.rb

@@ -1,99 +1,76 @@
 require 'logger'
+require 'json'
 
 module Tpaga
-module Swagger
-    
-  class << self
-    attr_accessor :logger
-    
-    # A Swagger configuration object. Must act like a hash and return sensible
-    # values for all Swagger configuration options. See Swagger::Configuration.
-    attr_accessor :configuration
-
-    attr_accessor :resources
-    
-    # Call this method to modify defaults in your initializers.
-    #
-    # @example
-    #   Swagger.configure do |config|
-    #     config.api_key = '1234567890abcdef'     # required
-    #     config.username = 'wordlover'           # optional, but needed for user-related functions
-    #     config.password = 'i<3words'            # optional, but needed for user-related functions
-    #     config.format = 'json'                  # optional, defaults to 'json'
-    #   end
-    #
-    def configure
-      self.configuration ||= Configuration.new
-      yield(configuration) if block_given?
-
-      # Configure logger.  Default to use Rails
-      self.logger ||= configuration.logger || (defined?(Rails) ? Rails.logger : Logger.new(STDOUT))
-
-      # remove :// from scheme
-      configuration.scheme.sub!(/:\/\//, '')
-
-      # remove http(s):// and anything after a slash
-      configuration.host.sub!(/https?:\/\//, '')
-      configuration.host = configuration.host.split('/').first
-
-      # Add leading and trailing slashes to base_path
-      configuration.base_path = "/#{configuration.base_path}".gsub(/\/+/, '/')
-      configuration.base_path = "" if configuration.base_path == "/"
-    end
-    
-    def authenticated?
-      Swagger.configuration.auth_token.present?
-    end
-    
-    def de_authenticate
-      Swagger.configuration.auth_token = nil
-    end
-    
-    def authenticate
-      return if Swagger.authenticated?
-      
-      if Swagger.configuration.username.blank? || Swagger.configuration.password.blank?
-        raise ClientError, "Username and password are required to authenticate."
+  module Swagger
+    class << self
+      attr_accessor :logger
+
+      # A Swagger configuration object. Must act like a hash and return sensible
+      # values for all Swagger configuration options. See Swagger::Configuration.
+      attr_accessor :configuration
+
+      attr_accessor :resources
+
+      # Call this method to modify defaults in your initializers.
+      #
+      # @example
+      #   Swagger.configure do |config|
+      #     config.api_key = '1234567890abcdef'     # api key authentication
+      #     config.format = 'json'                  # optional, defaults to 'json'
+      #   end
+      #
+      def configure
+        yield(configuration) if block_given?
+
+        # Configure logger.  Default to use Rails
+        self.logger ||= configuration.logger || (defined?(Rails) ? Rails.logger : Logger.new(STDOUT))
+
+        # remove :// from scheme
+        configuration.scheme.sub!(/:\/\//, '')
+
+        # remove http(s):// and anything after a slash
+        configuration.host.sub!(/https?:\/\//, '')
+        configuration.host = configuration.host.split('/').first
+
+        # Add leading and trailing slashes to base_path
+        configuration.base_path = "/#{configuration.base_path}".gsub(/\/+/, '/')
+        configuration.base_path = "" if configuration.base_path == "/"
       end
-      
-      request = Swagger::Request.new(
-        :get, 
-        "account/authenticate/{username}", 
-        :params => {
-          :username => Swagger.configuration.username, 
-          :password => Swagger.configuration.password
-        }
-      )
-      
-      response_body = request.response.body
-      Swagger.configuration.auth_token = response_body['token']
-    end
 
-    def to_body(obj)
-      return nil if obj.nil?
-      return obj.to_body if obj.respond_to? :to_body
-      return obj.map{|x| to_body(x) } if obj.is_a? Array
-      return obj
-    end
+      def authenticated?
+        Swagger.configuration.auth_token.present?
+      end
 
-  end
-  
-end
+      def de_authenticate
+        Swagger.configuration.auth_token = nil
+      end
 
-class HTTPError < StandardError
-  attr_accessor :response
+      def authenticate
+        return if Swagger.authenticated?
 
-  def initialize(message = nil, response = nil)
-    super(message)
-    @response = response
-  end
-end
+        if Swagger.configuration.username.blank? || Swagger.configuration.password.blank?
+          raise ClientError, "Username and password are required to authenticate."
+        end
 
-class ServerError < HTTPError
-end
+        request = Swagger::Request.new(
+          :get,
+          "account/authenticate/{username}",
+          :params => {
+            :username => Swagger.configuration.username,
+            :password => Swagger.configuration.password
+          }
+        )
 
-class ClientError < HTTPError
-end
+        response_body = request.response.body
+        Swagger.configuration.auth_token = response_body['token']
+      end
+    end
+  end
 
-end
+  class ServerError < StandardError
+  end
 
+  class ClientError < StandardError
+  end
+end

data/lib/tpaga/swagger/configuration.rb

@@ -1,32 +1,29 @@
 module Tpaga
-module Swagger
+  module Swagger
+    class Configuration
+      attr_accessor :format, :api_key, :api_key_prefix, :username, :password, :auth_token, :scheme, :host, :base_path, :user_agent, :logger, :inject_format, :force_ending_format, :camelize_params, :user_agent, :verify_ssl
 
-  class Configuration
-    
-    attr_accessor :format, :api_key, :username, :password, :auth_token, :scheme, :host, :base_path, :user_agent, :logger, :inject_format, :force_ending_format, :camelize_params, :api_key_type, :api_key_name, :api_key_prefix
-    
-    # Defaults go in here..
-    def initialize
-      @format = 'json'
-      @scheme = 'https'
-      @host = 'api.tpaga.co.local:8443'
-      @base_path = '/api'
-      @user_agent = 'Swagger/Ruby/0.0.2/dev'
-      @inject_format = false
-      @force_ending_format = false
-      @camelize_params = false
-      # for API key/token authentication
-      @api_key = '';
-      @api_key_type = '';
-      @api_key_name = '';
-      @api_key_prefix = '';
-      # for http basic authentication
-      @username = ''
-      @password = ''
-    end
+      # Defaults go in here..
+      def initialize
+        @format = 'json'
+        @scheme = 'https'
+        @host = 'sandbox.tpaga.co'
+        @base_path = '/api'
+        @user_agent = "ruby-swagger-#{Swagger::VERSION}"
+        @inject_format = false
+        @force_ending_format = false
+        @camelize_params = true
 
-  end
+        # keys for API key authentication (param-name => api-key)
+        @api_key = {}
+        # api-key prefix for API key authentication, e.g. "Bearer" (param-name => api-key-prefix)
+        @api_key_prefix = {}
 
+        # whether to verify SSL certificate, default to true
+        # Note: do NOT set it to false in production code, otherwise you would
+        #   face multiple types of cryptographic attacks
+        @verify_ssl = true
+      end
+    end
+  end
 end
-end
-

data/lib/tpaga/swagger/request.rb

@@ -1,215 +1,270 @@
 module Tpaga
-module Swagger
-
-  class Request
-    require 'uri'
-    require 'addressable/uri'
-    require 'typhoeus'
-
-    attr_accessor :host, :path, :format, :params, :body, :http_method, :headers, :form_params
-
-
-    # All requests must have an HTTP method and a path
-    # Optionals parameters are :params, :headers, :body, :format, :host
-    # 
-    def initialize(http_method, path, attributes={})
-      # initialize Swagger configuraiton if it has not been done so
-      Swagger.configure if Swagger.configuration.nil?
-
-      attributes[:format] ||= Swagger.configuration.format
-      attributes[:params] ||= {}
-
-      # set authentication based on configuration setting
-      if attributes[:require_auth]
-        case Swagger.configuration.api_key_type
-        when 'header' # API key in http header
-          # only header supports prefix
-          if Swagger.configuration.api_key_prefix.present?
-            attributes[:headers][Swagger.configuration.api_key_name] = "#{Swagger.configuration.api_key_prefix} #{Swagger.configuration.api_key}"
-          else
-            attributes[:headers][Swagger.configuration.api_key_name] = Swagger.configuration.api_key
+  module Swagger
+    class Request
+      require 'uri'
+      require 'addressable/uri'
+      require 'typhoeus'
+
+      attr_accessor :host, :path, :format, :params, :body, :http_method, :headers, :form_params, :auth_names
+
+      # All requests must have an HTTP method and a path
+      # Optionals parameters are :params, :headers, :body, :format, :host
+      def initialize(http_method, path, attributes={})
+        attributes[:format] ||= Swagger.configuration.format
+        attributes[:params] ||= {}
+
+        # Set default headers
+        default_headers = {
+          'Content-Type' => "application/#{attributes[:format].downcase}",
+          'User-Agent' => Swagger.configuration.user_agent
+        }
+
+        # Merge argument headers into defaults
+        attributes[:headers] = default_headers.merge(attributes[:headers] || {})
+
+        # Stick in the auth token if there is one
+        if Swagger.authenticated?
+          attributes[:headers].merge!({:auth_token => Swagger.configuration.auth_token})
+        end
+
+        self.http_method = http_method.to_sym
+        self.path = path
+        attributes.each do |name, value|
+          send("#{name.to_s.underscore.to_sym}=", value)
+        end
+
+        update_params_for_auth!
+      end
+
+      # Update hearder and query params based on authentication settings.
+      def update_params_for_auth!
+        (@auth_names || []).each do |auth_name|
+          case auth_name
+          when 'api_key'
+            @headers ||= {}
+            http_auth_header = 'Basic ' + ["#{Swagger.configuration.api_key}:"].pack('m').delete("\r\n")
+            @headers['Authorization'] = http_auth_header
+          
           end
-        when 'query' # API key in url query
-          attributes[:params][Swagger.configuration.api_key_name] = Swagger.configuration.api_key
+        end
+      end
+
+      # Get API key (with prefix if set).
+      # @param [String] param_name the parameter name of API key auth
+      def get_api_key_with_prefix(param_name)
+        if Swagger.configuration.api_key_prefix[param_name].present?
+          "#{Swagger.configuration.api_key_prefix[param_name]} #{Swagger.configuration.api_key[param_name]}"
         else
-          unless Swagger.configuration.api_key.blank?
-            # HTTP basic
-            http_auth_header = 'Basic ' + ["#{Swagger.configuration.api_key}:"].pack('m').delete("\r\n")
-            attributes[:headers]['Authorization'] = http_auth_header
-          else
-            # throw error before sending the request to server
+          Swagger.configuration.api_key[param_name]
+        end
+      end
+
+      # Construct a base URL
+      def url(options = {})
+        u = Addressable::URI.new(
+          :scheme => Swagger.configuration.scheme,
+          :host => Swagger.configuration.host,
+          :path => self.interpreted_path,
+          :query => self.query_string.sub(/\?/, '')
+        ).to_s
+
+        # Drop trailing question mark, if present
+        u.sub! /\?$/, ''
+
+        u
+      end
+
+      # Iterate over the params hash, injecting any path values into the path string
+      # e.g. /word.{format}/{word}/entries => /word.json/cat/entries
+      def interpreted_path
+        p = self.path.dup
+
+        # Stick a .{format} placeholder into the path if there isn't
+        # one already or an actual format like json or xml
+        # e.g. /words/blah => /words.{format}/blah
+        if Swagger.configuration.inject_format
+          unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
+            p = p.sub(/^(\/?\w+)/, "\\1.#{format}")
+          end
+        end
+
+        # Stick a .{format} placeholder on the end of the path if there isn't
+        # one already or an actual format like json or xml
+        # e.g. /words/blah => /words/blah.{format}
+        if Swagger.configuration.force_ending_format
+          unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
+            p = "#{p}.#{format}"
           end
         end
+
+        p = p.sub("{format}", self.format.to_s)
+
+        URI.encode [Swagger.configuration.base_path, p].join("/").gsub(/\/+/, '/')
       end
 
-      self.http_method = http_method.to_sym
-      self.path = path
-      attributes.each do |name, value|
-        #send("#{name.to_s.underscore.to_sym}=", value)
-        attr = name.to_s.underscore.to_sym
-        send("#{attr}=", value) if respond_to? attr
+      # Massage the request body into a state of readiness
+      # If body is a hash, camelize all keys then convert to a json string
+      def body=(value)
+        if value.is_a?(Hash)
+          value = value.inject({}) do |memo, (k,v)|
+            memo[k.to_s.camelize(:lower).to_sym] = v
+            memo
+          end
+        end
+        @body = value
       end
-    end
 
-    # Construct a base URL
-    #
-    def url(options = {})  
-      u = Addressable::URI.new(
-        :scheme => Swagger.configuration.scheme,
-        :host => Swagger.configuration.host,
-        :path => self.interpreted_path,
-        :query => self.query_string.sub(/\?/, '')
-      ).to_s
-      
-      # Drop trailing question mark, if present
-      u.sub! /\?$/, ''
-     
-      # no longer needed as we no longer support obfuscated
-      ## Obfuscate API key?
-      #u.sub! /api\_key=\w+/, 'api_key=YOUR_API_KEY' if options[:obfuscated]
-      
-      u
-    end
+      # If body is an object, JSONify it before making the actual request.
+      # For form parameters, remove empty value
+      def outgoing_body
+        # http form
+        if headers['Content-Type'] == 'application/x-www-form-urlencoded'
+          data = form_params.dup
+          data.each do |key, value|
+            data[key] = value.to_s if value && !value.is_a?(File) # remove emtpy form parameter
+          end
+          data
+        elsif @body # http body is JSON
+          @body.is_a?(String) ? @body : @body.to_json
+        else
+          nil
+        end
+      end
 
-    # Iterate over the params hash, injecting any path values into the path string
-    #
-    # e.g. /word.{format}/{word}/entries => /word.json/cat/entries
-    def interpreted_path
-      p = self.path.dup
+      # Construct a query string from the query-string-type params
+      def query_string
+        # Iterate over all params,
+        # .. removing the ones that are part of the path itself.
+        # .. stringifying values so Addressable doesn't blow up.
+        query_values = {}
+        self.params.each_pair do |key, value|
+          next if self.path.include? "{#{key}}"                                   # skip path params
+          next if value.blank? && value.class != FalseClass                       # skip empties
+          if Swagger.configuration.camelize_params
+            key = key.to_s.camelize(:lower).to_sym
+          end
+          query_values[key] = value.to_s
+        end
 
-      # Fill in the path params
-      self.params.each_pair do |key, value|
-        p = p.gsub("{#{key}}", value.to_s)
+        # We don't want to end up with '?' as our query string
+        # if there aren't really any params
+        return "" if query_values.blank?
+
+        # Addressable requires query_values to be set after initialization..
+        qs = Addressable::URI.new
+        qs.query_values = query_values
+        qs.to_s
       end
 
-      # Stick a .{format} placeholder into the path if there isn't
-      # one already or an actual format like json or xml
-      # e.g. /words/blah => /words.{format}/blah
-      if Swagger.configuration.inject_format
-        unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
-          p = p.sub(/^(\/?\w+)/, "\\1.#{format}")
+      def make
+        #TODO use configuration setting to determine if debugging
+        #logger = Logger.new STDOUT
+        #logger.debug self.url
+
+        request_options = {
+          :ssl_verifypeer => Swagger.configuration.verify_ssl,
+          :headers => self.headers.stringify_keys
+        }
+        response = case self.http_method.to_sym
+        when :get,:GET
+          Typhoeus::Request.get(
+            self.url,
+            request_options
+          )
+
+        when :post,:POST
+          Typhoeus::Request.post(
+            self.url,
+            request_options.merge(:body => self.outgoing_body)
+          )
+
+        when :patch,:PATCH
+          Typhoeus::Request.patch(
+            self.url,
+            request_options.merge(:body => self.outgoing_body)
+          )
+
+        when :put,:PUT
+          Typhoeus::Request.put(
+            self.url,
+            request_options.merge(:body => self.outgoing_body)
+          )
+
+        when :delete,:DELETE
+          Typhoeus::Request.delete(
+            self.url,
+            request_options.merge(:body => self.outgoing_body)
+          )
         end
+        Response.new(response)
       end
 
-      # Stick a .{format} placeholder on the end of the path if there isn't
-      # one already or an actual format like json or xml
-      # e.g. /words/blah => /words/blah.{format}
-      if Swagger.configuration.force_ending_format
-        unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
-          p = "#{p}.#{format}"   
+      def response
+        self.make
+      end
+
+      def response_code_pretty
+        return unless @response.present?
+        @response.code.to_s
+      end
+
+      def response_headers_pretty
+        return unless @response.present?
+        # JSON.pretty_generate(@response.headers).gsub(/\n/, '<br/>') # <- This was for RestClient
+        @response.headers.gsub(/\n/, '<br/>') # <- This is for Typhoeus
+      end
+
+      # return 'Accept' based on an array of accept provided
+      # @param [Array] header_accept_array Array fo 'Accept'
+      # @return String Accept (e.g. application/json)
+      def self.select_header_accept header_accept_array
+        if header_accept_array.empty?
+          return
+        elsif header_accept_array.any?{ |s| s.casecmp('application/json')==0 }
+          'application/json' # look for json data by default
+        else
+          header_accept_array.join(',')
         end
       end
 
-      p = p.sub("{format}", self.format.to_s)
-      
-      URI.encode [Swagger.configuration.base_path, p].join("/").gsub(/\/+/, '/')
-    end
-  
-    # Massage the request body into a state of readiness
-    # If body is a hash, camelize all keys then convert to a json string
-    #
-    def body=(value)      
-      #comment: no need to use camelize keys
-      #if value.is_a?(Hash)
-      #  value = value.inject({}) do |memo, (k,v)|
-      #    memo[k.to_s.camelize(:lower).to_sym] = v
-      #    memo
-      #  end
-      #end
-      @body = value
-    end
-    
-    # If body is an object, JSONify it before making the actual request.
-    # 
-    def outgoing_body
-      if @body.nil? && @form_params && !@form_params.empty?
-        data = form_params.dup
-        data.each do |key, value|
-          data[key] = value.to_s if value && !value.is_a?(File)
+      # return the content type based on an array of content-type provided
+      # @param [Array] content_type_array Array fo content-type
+      # @return String Content-Type (e.g. application/json)
+      def self.select_header_content_type content_type_array
+        if content_type_array.empty?
+          'application/json' # use application/json by default
+        elsif content_type_array.any?{ |s| s.casecmp('application/json')==0 }
+          'application/json' # use application/json if it's included
+        else
+          content_type_array[0]; # otherwise, use the first one
         end
-        data
-      else
-        @body.is_a?(String) ? @body : @body.to_json
-      end
-    end 
-   
-    # Construct a query string from the query-string-type params
-    def query_string
-
-      # Iterate over all params,
-      # .. removing the ones that are part of the path itself.
-      # .. stringifying values so Addressable doesn't blow up.
-      query_values = {}
-      self.params.each_pair do |key, value|
-        next if self.path.include? "{#{key}}"                                   # skip path params
-        next if value.blank? && value.class != FalseClass                       # skip empties
-
-        # no longer support Swagger.configuration.camelize_params
-        #if Swagger.configuration.camelize_params
-        #  key = key.to_s.camelize(:lower).to_sym unless key.to_sym == :api_key    # api_key is not a camelCased param
-        #end
-
-        query_values[key] = value.to_s
-      end
-    
-      # We don't want to end up with '?' as our query string
-      # if there aren't really any params
-      return "" if query_values.blank?
-    
-      # Addressable requires query_values to be set after initialization..
-      qs = Addressable::URI.new
-      qs.query_values = query_values
-      qs.to_s
-    end
-  
-    def make
-      response = case self.http_method.to_sym
-      when :get,:GET
-        Typhoeus::Request.get(
-          self.url,
-          :headers => self.headers.stringify_keys,
-        )
-
-      when :post,:POST
-        Typhoeus::Request.post(
-          self.url,
-          :body => self.outgoing_body,
-          :headers => self.headers.stringify_keys,
-        )
-
-      when :put,:PUT
-        Typhoeus::Request.put(
-          self.url,
-          :body => self.outgoing_body,
-          :headers => self.headers.stringify_keys,
-        )
-      
-      when :delete,:DELETE
-        Typhoeus::Request.delete(
-          self.url,
-          :body => self.outgoing_body,
-          :headers => self.headers.stringify_keys,
-        )
-      end
-      Response.new(response)
-    end
-  
-    def response
-      self.make
-    end
-  
-    def response_code_pretty
-      return unless @response.present?
-      @response.code.to_s    
-    end
-  
-    def response_headers_pretty
-      return unless @response.present?
-      # JSON.pretty_generate(@response.headers).gsub(/\n/, '<br/>') # <- This was for RestClient
-      @response.headers.gsub(/\n/, '<br/>') # <- This is for Typhoeus
-    end
+      end
+
+      # static method to convert object (array, hash, object, etc) to JSON string
+      # @param model object to be converted into JSON string
+      # @return string JSON string representation of the object
+      def self.object_to_http_body model
+        return if model.nil?
+        _body = nil
+        if model.is_a?(Array)
+          _body = model.map{|m| object_to_hash(m) }
+        else
+          _body = object_to_hash(model)
+        end
+        _body.to_json
+      end
 
+      # static method to convert object(non-array) to hash
+      # @param obj object to be converted into JSON string
+      # @return string JSON string representation of the object
+      def self.object_to_hash obj
+        if obj.respond_to?(:to_hash)
+          obj.to_hash
+        else
+          obj
+        end
+      end
+
+    end
   end
 end
-end
-