mx-platform-ruby 0.10.0 → 0.11.2

data/lib/mx-platform-ruby/api/mx_platform_api.rb

@@ -768,7 +768,7 @@ module MxPlatformRuby
     end
 
     # Create user
-    # Call this endpoint to create a new user. The MX Platform API will respond with the newly-created user object if successful. This endpoint accepts several parameters - id, metadata, and is_disabled. Disabling a user means that accounts and transactions associated with it will not be updated in the background by MX. It will also restrict access to that users data until they are no longer disabled. Users who are disabled for the entirety of an MX Platform API billing period will not be factored into that months bill.
+    # Use this endpoint to create a new user. The API will respond with the newly-created user object if successful. Disabling a user means that accounts and transactions associated with it will not be updated in the background by MX. It will also restrict access to that user’s data until they are no longer disabled.
     # @param user_create_request_body [UserCreateRequestBody] User object to be created. (None of these parameters are required, but the user object cannot be empty)
     # @param [Hash] opts the optional parameters
     # @return [UserResponseBody]
@@ -778,7 +778,7 @@ module MxPlatformRuby
     end
 
     # Create user
-    # Call this endpoint to create a new user. The MX Platform API will respond with the newly-created user object if successful. This endpoint accepts several parameters - id, metadata, and is_disabled. Disabling a user means that accounts and transactions associated with it will not be updated in the background by MX. It will also restrict access to that users data until they are no longer disabled. Users who are disabled for the entirety of an MX Platform API billing period will not be factored into that months bill.
+    # Use this endpoint to create a new user. The API will respond with the newly-created user object if successful. Disabling a user means that accounts and transactions associated with it will not be updated in the background by MX. It will also restrict access to that user’s data until they are no longer disabled.
     # @param user_create_request_body [UserCreateRequestBody] User object to be created. (None of these parameters are required, but the user object cannot be empty)
     # @param [Hash] opts the optional parameters
     # @return [Array<(UserResponseBody, Integer, Hash)>] UserResponseBody data, response status code and response headers
@@ -5363,6 +5363,194 @@ module MxPlatformRuby
       return data, status_code, headers
     end
 
+    # Request payment account
+    # Use this endpoint to request a payment account.
+    # @param [Hash] opts the optional parameters
+    # @return [PaymentAccountResponseBody]
+    def request_payment_account(opts = {})
+      data, _status_code, _headers = request_payment_account_with_http_info(opts)
+      data
+    end
+
+    # Request payment account
+    # Use this endpoint to request a payment account.
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(PaymentAccountResponseBody, Integer, Hash)>] PaymentAccountResponseBody data, response status code and response headers
+    def request_payment_account_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: MxPlatformApi.request_payment_account ...'
+      end
+      # resource path
+      local_var_path = '/payment_account'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/vnd.mx.api.v1+json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'PaymentAccountResponseBody'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['bearerAuth']
+
+      new_options = opts.merge(
+        :operation => :"MxPlatformApi.request_payment_account",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: MxPlatformApi#request_payment_account\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Request payment processor authorization code
+    # Use this endpoint to request a payment processor authorization code.
+    # @param payment_processor_authorization_code_request_body [PaymentProcessorAuthorizationCodeRequestBody] Payment processor authorization code object containing account_guid, member_guid, and user_guid.
+    # @param [Hash] opts the optional parameters
+    # @return [PaymentProcessorAuthorizationCodeResponseBody]
+    def request_payment_processor_authorization_code(payment_processor_authorization_code_request_body, opts = {})
+      data, _status_code, _headers = request_payment_processor_authorization_code_with_http_info(payment_processor_authorization_code_request_body, opts)
+      data
+    end
+
+    # Request payment processor authorization code
+    # Use this endpoint to request a payment processor authorization code.
+    # @param payment_processor_authorization_code_request_body [PaymentProcessorAuthorizationCodeRequestBody] Payment processor authorization code object containing account_guid, member_guid, and user_guid.
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(PaymentProcessorAuthorizationCodeResponseBody, Integer, Hash)>] PaymentProcessorAuthorizationCodeResponseBody data, response status code and response headers
+    def request_payment_processor_authorization_code_with_http_info(payment_processor_authorization_code_request_body, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: MxPlatformApi.request_payment_processor_authorization_code ...'
+      end
+      # verify the required parameter 'payment_processor_authorization_code_request_body' is set
+      if @api_client.config.client_side_validation && payment_processor_authorization_code_request_body.nil?
+        fail ArgumentError, "Missing the required parameter 'payment_processor_authorization_code_request_body' when calling MxPlatformApi.request_payment_processor_authorization_code"
+      end
+      # resource path
+      local_var_path = '/payment_processor_authorization_code'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/vnd.mx.api.v1+json'])
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(payment_processor_authorization_code_request_body)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'PaymentProcessorAuthorizationCodeResponseBody'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['basicAuth']
+
+      new_options = opts.merge(
+        :operation => :"MxPlatformApi.request_payment_processor_authorization_code",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: MxPlatformApi#request_payment_processor_authorization_code\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Request payment processor token
+    # Use this endpoint to request a payment processor token.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :code Code to request processor token.
+    # @option opts [String] :grant_type Specify grant type.
+    # @return [PaymentProcessorTokenResponseBody]
+    def request_payment_processor_token(opts = {})
+      data, _status_code, _headers = request_payment_processor_token_with_http_info(opts)
+      data
+    end
+
+    # Request payment processor token
+    # Use this endpoint to request a payment processor token.
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :code Code to request processor token.
+    # @option opts [String] :grant_type Specify grant type.
+    # @return [Array<(PaymentProcessorTokenResponseBody, Integer, Hash)>] PaymentProcessorTokenResponseBody data, response status code and response headers
+    def request_payment_processor_token_with_http_info(opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: MxPlatformApi.request_payment_processor_token ...'
+      end
+      # resource path
+      local_var_path = '/payment_processor_token'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'code'] = opts[:'code'] if !opts[:'code'].nil?
+      query_params[:'grant_type'] = opts[:'grant_type'] if !opts[:'grant_type'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/vnd.mx.api.v1+json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'PaymentProcessorTokenResponseBody'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['basicAuth']
+
+      new_options = opts.merge(
+        :operation => :"MxPlatformApi.request_payment_processor_token",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: MxPlatformApi#request_payment_processor_token\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # Request widget url
     # This endpoint allows partners to get a URL by passing the `widget_type` in the request body, as well as configuring it in several different ways. In the case of Connect, that means setting the `widget_type` to `connect_widget`. Partners may also pass an optional `Accept-Language` header as well as a number of configuration options. Note that this is a `POST` request.
     # @param user_guid [String] The unique id for a &#x60;user&#x60;.
@@ -6345,7 +6533,7 @@ module MxPlatformRuby
     end
 
     # Update user
-    # Use this endpoint to update the attributes of a specific user. The MX Platform API will respond with the updated user object. Disabling a user means that accounts and transactions associated with it will not be updated in the background by MX. It will also restrict access to that users data until they are no longer disabled. Users who are disabled for the entirety of an MX Platform API billing period will not be factored into that months bill. To disable a user, update it and set the is_disabled parameter to true. Set it to false to re-enable the user.
+    # Use this endpoint to update the attributes of the specified user.
     # @param user_guid [String] The unique id for a &#x60;user&#x60;.
     # @param user_update_request_body [UserUpdateRequestBody] User object to be updated (None of these parameters are required, but the user object cannot be empty.)
     # @param [Hash] opts the optional parameters
@@ -6356,7 +6544,7 @@ module MxPlatformRuby
     end
 
     # Update user
-    # Use this endpoint to update the attributes of a specific user. The MX Platform API will respond with the updated user object. Disabling a user means that accounts and transactions associated with it will not be updated in the background by MX. It will also restrict access to that users data until they are no longer disabled. Users who are disabled for the entirety of an MX Platform API billing period will not be factored into that months bill. To disable a user, update it and set the is_disabled parameter to true. Set it to false to re-enable the user.
+    # Use this endpoint to update the attributes of the specified user.
     # @param user_guid [String] The unique id for a &#x60;user&#x60;.
     # @param user_update_request_body [UserUpdateRequestBody] User object to be updated (None of these parameters are required, but the user object cannot be empty.)
     # @param [Hash] opts the optional parameters

data/lib/mx-platform-ruby/configuration.rb

@@ -220,6 +220,13 @@ module MxPlatformRuby
             key: 'Authorization',
             value: basic_auth_token
           },
+        'bearerAuth' =>
+          {
+            type: 'bearer',
+            in: 'header',
+            key: 'Authorization',
+            value: "Bearer #{access_token}"
+          },
       }
     end
 

data/lib/mx-platform-ruby/models/credential_response.rb

@@ -25,6 +25,8 @@ module MxPlatformRuby
 
     attr_accessor :label
 
+    attr_accessor :type
+
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
@@ -32,7 +34,8 @@ module MxPlatformRuby
         :'field_name' => :'field_name',
         :'field_type' => :'field_type',
         :'guid' => :'guid',
-        :'label' => :'label'
+        :'label' => :'label',
+        :'type' => :'type'
       }
     end
 
@@ -48,7 +51,8 @@ module MxPlatformRuby
         :'field_name' => :'String',
         :'field_type' => :'String',
         :'guid' => :'String',
-        :'label' => :'String'
+        :'label' => :'String',
+        :'type' => :'String'
       }
     end
 
@@ -59,7 +63,8 @@ module MxPlatformRuby
         :'field_name',
         :'field_type',
         :'guid',
-        :'label'
+        :'label',
+        :'type'
       ])
     end
 
@@ -97,6 +102,10 @@ module MxPlatformRuby
       if attributes.key?(:'label')
         self.label = attributes[:'label']
       end
+
+      if attributes.key?(:'type')
+        self.type = attributes[:'type']
+      end
     end
 
     # Show invalid properties with the reasons. Usually used together with valid?
@@ -121,7 +130,8 @@ module MxPlatformRuby
           field_name == o.field_name &&
           field_type == o.field_type &&
           guid == o.guid &&
-          label == o.label
+          label == o.label &&
+          type == o.type
     end
 
     # @see the `==` method
@@ -133,7 +143,7 @@ module MxPlatformRuby
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [display_order, field_name, field_type, guid, label].hash
+      [display_order, field_name, field_type, guid, label, type].hash
     end
 
     # Builds the object from hash

data/lib/mx-platform-ruby/models/payment_account_response.rb

@@ -0,0 +1,279 @@
+=begin
+#MX Platform API
+
+#The MX Platform API is a powerful, fully-featured API designed to make aggregating and enhancing financial data easy and reliable. It can seamlessly connect your app or website to tens of thousands of financial institutions.
+
+The version of the OpenAPI document: 0.1.0
+
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 5.4.0
+
+=end
+
+require 'date'
+require 'time'
+
+module MxPlatformRuby
+  class PaymentAccountResponse
+    attr_accessor :account_name
+
+    attr_accessor :account_number
+
+    attr_accessor :account_type
+
+    attr_accessor :available_balance
+
+    attr_accessor :balance
+
+    attr_accessor :routing_number
+
+    attr_accessor :transit_number
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'account_name' => :'account_name',
+        :'account_number' => :'account_number',
+        :'account_type' => :'account_type',
+        :'available_balance' => :'available_balance',
+        :'balance' => :'balance',
+        :'routing_number' => :'routing_number',
+        :'transit_number' => :'transit_number'
+      }
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'account_name' => :'String',
+        :'account_number' => :'String',
+        :'account_type' => :'String',
+        :'available_balance' => :'Float',
+        :'balance' => :'Float',
+        :'routing_number' => :'String',
+        :'transit_number' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'account_name',
+        :'account_number',
+        :'account_type',
+        :'available_balance',
+        :'balance',
+        :'routing_number',
+        :'transit_number'
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `MxPlatformRuby::PaymentAccountResponse` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!self.class.attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `MxPlatformRuby::PaymentAccountResponse`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'account_name')
+        self.account_name = attributes[:'account_name']
+      end
+
+      if attributes.key?(:'account_number')
+        self.account_number = attributes[:'account_number']
+      end
+
+      if attributes.key?(:'account_type')
+        self.account_type = attributes[:'account_type']
+      end
+
+      if attributes.key?(:'available_balance')
+        self.available_balance = attributes[:'available_balance']
+      end
+
+      if attributes.key?(:'balance')
+        self.balance = attributes[:'balance']
+      end
+
+      if attributes.key?(:'routing_number')
+        self.routing_number = attributes[:'routing_number']
+      end
+
+      if attributes.key?(:'transit_number')
+        self.transit_number = attributes[:'transit_number']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          account_name == o.account_name &&
+          account_number == o.account_number &&
+          account_type == o.account_type &&
+          available_balance == o.available_balance &&
+          balance == o.balance &&
+          routing_number == o.routing_number &&
+          transit_number == o.transit_number
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [account_name, account_number, account_type, available_balance, balance, routing_number, transit_number].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      new.build_from_hash(attributes)
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.openapi_types.each_pair do |key, type|
+        if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
+          self.send("#{key}=", nil)
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = MxPlatformRuby.const_get(type)
+        klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end