dwolla_swagger 1.0.0

data/lib/dwolla_swagger/api/webhooksubscriptions_api.rb

@@ -0,0 +1,179 @@
+require "uri"
+
+module DwollaSwagger
+  class WebhooksubscriptionsApi
+    basePath = "https://localhost/"
+    # apiInvoker = APIInvoker
+    @auth_names = ['oauth2']
+  
+
+    # Get the list of webhooks.
+    # 
+    # @param [Hash] opts the optional parameters
+    # @return [WebhookListResponse]
+    def self.list(opts = {})
+      
+
+      # resource path
+      path = "/webhook-subscriptions".sub('{format}','json')
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = ['application/vnd.dwolla.v1.hal+json']
+      _header_accept_result = Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] = Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      
+
+      if :GET == :POST
+        response = Swagger::Request.new(:GET, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => @auth_names}).make.headers
+        response['Location']
+      else
+        response = Swagger::Request.new(:GET, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => @auth_names}).make.body
+        obj = WebhookListResponse.new() and obj.build_from_hash(response)
+      end
+    end
+
+    # Create a new webhook subscription.
+    # 
+    # @param [Hash] opts the optional parameters
+    # @option opts [CreateWebhook] :body Webhook subscription to create.
+    # @return [WebhookSubscription]
+    def self.create(opts = {})
+      
+
+      # resource path
+      path = "/webhook-subscriptions".sub('{format}','json')
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = ['application/vnd.dwolla.v1.hal+json']
+      _header_accept_result = Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = ['application/vnd.dwolla.v1.hal+json']
+      header_params['Content-Type'] = Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = Swagger::Request.object_to_http_body(opts[:'body'])
+      
+
+      if :POST == :POST
+        response = Swagger::Request.new(:POST, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => @auth_names}).make.headers
+        response['Location']
+      else
+        response = Swagger::Request.new(:POST, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => @auth_names}).make.body
+        obj = WebhookSubscription.new() and obj.build_from_hash(response)
+      end
+    end
+
+    # Get a webhook subscription by id.
+    # 
+    # @param id ID of webhook subscription to get.
+    # @param [Hash] opts the optional parameters
+    # @return [WebhookSubscription]
+    def self.id(id, opts = {})
+      
+      # verify the required parameter 'id' is set
+      raise "Missing the required parameter 'id' when calling id" if id.nil?
+      
+
+      # resource path
+      path = "/webhook-subscriptions/{id}".sub('{format}','json').sub('{' + 'id' + '}', id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = ['application/vnd.dwolla.v1.hal+json']
+      _header_accept_result = Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] = Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      
+
+      if :GET == :POST
+        response = Swagger::Request.new(:GET, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => @auth_names}).make.headers
+        response['Location']
+      else
+        response = Swagger::Request.new(:GET, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => @auth_names}).make.body
+        obj = WebhookSubscription.new() and obj.build_from_hash(response)
+      end
+    end
+
+    # Delete a webhook subscription by id.
+    # 
+    # @param id ID of webhook subscription to delete.
+    # @param [Hash] opts the optional parameters
+    # @return [WebhookSubscription]
+    def self.delete_by_id(id, opts = {})
+      
+      # verify the required parameter 'id' is set
+      raise "Missing the required parameter 'id' when calling delete_by_id" if id.nil?
+      
+
+      # resource path
+      path = "/webhook-subscriptions/{id}".sub('{format}','json').sub('{' + 'id' + '}', id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = ['application/vnd.dwolla.v1.hal+json']
+      _header_accept_result = Swagger::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] = Swagger::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+      
+
+      if :DELETE == :POST
+        response = Swagger::Request.new(:DELETE, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => @auth_names}).make.headers
+        response['Location']
+      else
+        response = Swagger::Request.new(:DELETE, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => @auth_names}).make.body
+        obj = WebhookSubscription.new() and obj.build_from_hash(response)
+      end
+    end
+  end
+end

data/lib/dwolla_swagger/models/account_info.rb

@@ -0,0 +1,62 @@
+module DwollaSwagger
+  # 
+  class AccountInfo < BaseObject
+    attr_accessor :_links, :id, :name, :_embedded
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'_links' => :'_links',
+        
+        # 
+        :'id' => :'id',
+        
+        # 
+        :'name' => :'name',
+        
+        # 
+        :'_embedded' => :'_embedded'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'_links' => :'map[string,HalLink]',
+        :'id' => :'string',
+        :'name' => :'string',
+        :'_embedded' => :'object'
+        
+      }
+    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[:'_links']
+        if (value = attributes[:'_links']).is_a?(Array)
+          @_links = value
+        end
+      end
+      
+      if attributes[:'id']
+        @id = attributes[:'id']
+      end
+      
+      if attributes[:'name']
+        @name = attributes[:'name']
+      end
+      
+      if attributes[:'_embedded']
+        @_embedded = attributes[:'_embedded']
+      end
+      
+    end
+  end
+end

data/lib/dwolla_swagger/models/amount.rb

@@ -0,0 +1,44 @@
+module DwollaSwagger
+  # 
+  class Amount < BaseObject
+    attr_accessor :value, :currency
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'value' => :'value',
+        
+        # 
+        :'currency' => :'currency'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'value' => :'string',
+        :'currency' => :'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[:'value']
+        @value = attributes[:'value']
+      end
+      
+      if attributes[:'currency']
+        @currency = attributes[:'currency']
+      end
+      
+    end
+  end
+end

data/lib/dwolla_swagger/models/application_event.rb

@@ -0,0 +1,86 @@
+module DwollaSwagger
+  # 
+  class ApplicationEvent < BaseObject
+    attr_accessor :_links, :_embedded, :id, :created, :account_id, :topic, :resource_id
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # 
+        :'_links' => :'_links',
+        
+        # 
+        :'_embedded' => :'_embedded',
+        
+        # 
+        :'id' => :'id',
+        
+        # 
+        :'created' => :'created',
+        
+        # 
+        :'account_id' => :'accountId',
+        
+        # 
+        :'topic' => :'topic',
+        
+        # 
+        :'resource_id' => :'resourceId'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'_links' => :'map[string,HalLink]',
+        :'_embedded' => :'object',
+        :'id' => :'string',
+        :'created' => :'DateTime',
+        :'account_id' => :'string',
+        :'topic' => :'string',
+        :'resource_id' => :'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[:'_links']
+        if (value = attributes[:'_links']).is_a?(Array)
+          @_links = value
+        end
+      end
+      
+      if attributes[:'_embedded']
+        @_embedded = attributes[:'_embedded']
+      end
+      
+      if attributes[:'id']
+        @id = attributes[:'id']
+      end
+      
+      if attributes[:'created']
+        @created = attributes[:'created']
+      end
+      
+      if attributes[:'accountId']
+        @account_id = attributes[:'accountId']
+      end
+      
+      if attributes[:'topic']
+        @topic = attributes[:'topic']
+      end
+      
+      if attributes[:'resourceId']
+        @resource_id = attributes[:'resourceId']
+      end
+      
+    end
+  end
+end

data/lib/dwolla_swagger/models/base_object.rb

@@ -0,0 +1,84 @@
+module DwollaSwagger
+  # base class containing fundamental method such as to_hash, build_from_hash and more
+  class BaseObject
+
+    # return the object in the form of hash
+    def to_body
+      body = {}
+      self.class.attribute_map.each_pair do |key, value|
+        body[value] = self.send(key) unless self.send(key).nil?
+      end
+      body
+    end
+
+    # build the object from hash
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^array\[(.*)\]/i
+          # Deserialize array types to lowest denomination
+          self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        else
+          # data not found in attributes(hash), not an issue as the data can be optional
+        end
+      end
+
+      self
+    end
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :string
+        value.to_s
+      when :int
+        value.to_i
+      when :double
+        value.to_f
+      when :boolean
+        if value =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      when :object
+        value
+      when /^map\[(.*)\]/i
+        value
+      else # model
+        _model = DwollaSwagger.const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    # to_body is an alias to to_body (backward compatibility)
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |key, value|
+        if self.send(key).is_a?(Array)
+          next if self.send(key).empty?
+          hash[value] = self.send(key).select{|v| !v.nil?}.map{ |v| _to_hash v} unless self.send(key).nil?
+        else
+          unless (_tmp_value = _to_hash self.send(key)).nil?
+            hash[value] = _tmp_value
+          end
+        end
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    def _to_hash(value)
+      if value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+end