xero-ruby 3.2.1 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcc8e88d077eb5b42f9a9c8a206ce6c7fb62589e7179932764a70cc28c3f821a
-  data.tar.gz: 8c25945749aaca49892462186f749701255022d05ea498645a3b1e59c10a5e52
+  metadata.gz: 3a94136a3e2a31cc4d5c7a162116bdd8705800ac2fc2732907a80286950fa376
+  data.tar.gz: 340b78c53b08a37f04b79d642bf0fc7e4e1c109595ef86b596398aa9c2b87be3
 SHA512:
-  metadata.gz: 4196ec14ceaa6179bbbedb856b447e7af947ba96e4af24ab8130835af5660a8e6787fbf3261c3f6c5c605d0f81436559bd37e1e0a7252bab42feb752f4634d31
-  data.tar.gz: c99e89b1f45563b72023ad5d5ceb3632fe5661068ad5ee89d672194fca72ddccbb1967d9f9796098d12ff9b649f03dfa5b26d3eb08b3daf756bef0e3a7f3fe5f
+  metadata.gz: 1275a668a399320fa11e6ccbcacd9eac6d4cf4ffb939108d1962ccede318376b1ee3236b4cdbb95e0db45e8e1695f860508861c4097da7c1d6a12e22cfe3672f
+  data.tar.gz: 49de788f087c577474ad556ed9188c0e75ccb46256f52ff6639e2fdf82ed732fceb9eebfb825a9d17cb2f6370c4b52c78c4b1ebc0b5484554e565089e5f5052d

data/README.md

@@ -4,7 +4,7 @@
 [![Github stars](https://img.shields.io/github/stars/XeroAPI/xero-ruby.svg)](https://github.com/XeroAPI/xero-ruby/stargazers)
 ![total downloads](https://ruby-gem-downloads-badge.herokuapp.com/xero-ruby?type=total)
 
-The xero-ruby SDK makes it easy for developers to access Xero's APIs in their Ruby code, and build robust applications and software using small business & general ledget accounting data.
+The xero-ruby SDK makes it easy for developers to access Xero's APIs in their Ruby code, and build robust applications and software using small business & general ledger accounting data.
 # Table of Contents
 - [API Client documentation](#api-client-documentation)
 - [Sample Applications](#sample-applications)
@@ -13,6 +13,7 @@ The xero-ruby SDK makes it easy for developers to access Xero's APIs in their Ru
 - [Configuration](#configuration)
 - [Authentication](#authentication)
 - [Custom Connections](#custom-connections)
+- [App Store Subscriptions](#app-store-subscriptions)
 - [API Clients](#api-clients)
 - [Helper Methods](#helper-methods)
 - [Usage Examples](#usage-examples)
@@ -46,6 +47,7 @@ Sample apps can get you started quickly with simple auth flows to advanced usage
 | [`xero-ruby-oauth2-starter`](https://github.com/XeroAPI/Xero-ruby-oauth2-starter) | A Sinatra application showing the basic getting started code to work with the sdk | <img src="https://i.imgur.com/9H4F98M.png" alt="drawing" width="300"/>
 | [`xero-ruby-oauth2-app`](https://github.com/XeroAPI/Xero-ruby-oauth2-app) | Complete rails app with +95% of api set examples, complex filters, pagination, and user/token management in postgres | <img src="https://i.imgur.com/XsAp9Ww.png" alt="drawing" width="500"/>
 | [`xero-ruby-custom-connections-starter`](https://github.com/XeroAPI/xero-ruby-custom-connections-starter) | A getting started Sinatra app showing Custom Connections - a Xero [premium option](https://developer.xero.com/documentation/oauth2/custom-connections) for building M2M integrations to a single org | <img src="https://i.imgur.com/YEkScui.png" alt="drawing" width="300"/>
+| [`xero-ruby-sso-form`](https://github.com/XeroAPI/xero-ruby-sso-form) | A basic Sinatra app showing how to implement SSU to Lead | <img src="https://i.imgur.com/Nf95GVd.png" alt="drawing" width="300"/>
 
 <hr>
 
@@ -155,6 +157,73 @@ Because Custom Connections are only valid for a single organisation you don't ne
 However - due to the nature of how our SDK's are generated from our OpenAPI spec, the parameter remains which requires you to pass an empty string for now to use the SDK with a Custom Connection.
 
 ---
+
+## App Store Subscriptions
+
+If you are implementing subscriptions to participate in Xero's App Store you will need to setup [App Store subscriptions](https://developer.xero.com/documentation/guides/how-to-guides/xero-app-store-referrals/) endpoints.
+
+When a plan is successfully purchased, the user is redirected back to the URL specified in the setup process. The Xero App Store appends the subscription Id to this URL so you can immediately determine what plan the user has subscribed to through the subscriptions API.
+
+With your app credentials you can create a client via `client_credentials` grant_type with the `marketplace.billing` scope. This unique access_token will allow you to query any functions in `appStoreApi`. Client Credentials tokens to query app store endpoints will only work for apps that have completed the App Store on-boarding process.
+
+```ruby
+// => /post-purchase-url?subscriptionId=03bc74f2-1237-4477-b782-2dfb1a6d8b21
+
+subscription_id = params[:subscriptionId]
+
+xero_app_store_client ||= XeroRuby::ApiClient.new(credentials: {
+  client_id: ENV['CLIENT_ID'],
+  client_secret: ENV['CLIENT_SECRET'],
+  grant_type: 'client_credentials'
+  scopes: ['marketplace.billing']
+})
+
+xero_app_store_client.get_client_credentials_token
+
+@subscription = xero_app_store_client.app_store_api.get_subscription(subscription_id)
+
+puts @subscription.to_attributes
+{
+  :current_period_end => Thu, 02 Sep 2021 14:08:58 +0000,
+  :id => "03bc74f2-1237-4477-b782-2dfb1a6d8b21",
+  :organisation_id => "79e8b2e5-c63d-4dce-888f-e0f3e9eac647",
+  :plans => [
+    {
+      :id => "6abc26f3-9390-4194-8b25-ce8b9942fda9",
+      :name => "Small",
+      :status => "ACTIVE",
+      :subscription_items => [
+        {
+          :id => "834cff4c-b753-4de2-9e7a-3451e14fa17a",
+          :price => {
+            :amount => 0.1e0,
+            :currency => "NZD",
+            :id => "2310de92-c7c0-4bcb-b972-fb7612177bc7"
+          },
+          :product => {
+            :id => "9586421f-7325-4493-bac9-d93be06a6a38",
+            :name => "",
+            :type => "FIXED"
+          },
+          :start_date => Mon, 02 Aug 2021 14:08:58 +0000,
+          :test_mode => true
+        }
+      ]
+    }
+  ],
+  :start_date => Mon, 02 Aug 2021 14:08:58 +0000,
+  :status => "ACTIVE",
+  :test_mode => true
+}
+```
+You should use this subscription data to provision user access/permissions to your application.
+### App Store Subscription Webhooks
+
+In additon to a subscription Id being passed through the URL, when a purchase or an upgrade takes place you will be notified via a webhook. You can then use the subscription Id in the webhook payload to query the AppStore endpoints and determine what plan the user purchased, upgraded, downgraded or cancelled.
+
+Refer to Xero's documenation to learn more about setting up and receiving webhooks.
+> https://developer.xero.com/documentation/guides/webhooks/overview/
+
 ## API Clients
 You can access the different API sets and their available methods through the following:
 

data/lib/xero-ruby.rb

@@ -18,6 +18,12 @@ require 'xero-ruby/version'
 require 'xero-ruby/configuration'
 
 # Models
+require 'xero-ruby/models/app_store/plan'
+require 'xero-ruby/models/app_store/price'
+require 'xero-ruby/models/app_store/problem_details'
+require 'xero-ruby/models/app_store/product'
+require 'xero-ruby/models/app_store/subscription'
+require 'xero-ruby/models/app_store/subscription_item'
 require 'xero-ruby/models/payroll_uk/account'
 require 'xero-ruby/models/payroll_uk/accounts'
 require 'xero-ruby/models/payroll_uk/address'
@@ -456,6 +462,7 @@ require 'xero-ruby/models/accounting/users'
 require 'xero-ruby/models/accounting/validation_error'
 
 # APIs
+require 'xero-ruby/api/app_store_api'
 require 'xero-ruby/api/payroll_uk_api'
 require 'xero-ruby/api/payroll_nz_api'
 require 'xero-ruby/api/payroll_au_api'

data/lib/xero-ruby/api/app_store_api.rb

@@ -0,0 +1,87 @@
+=begin
+#Xero AppStore API
+
+#These endpoints are for Xero Partners to interact with the App Store Billing platform
+
+Contact: api@xero.com
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 4.3.1
+
+=end
+
+module XeroRuby
+  class AppStoreApi
+    attr_accessor :api_client
+
+    def initialize(api_client = ApiClient.new)
+      @api_client = api_client
+    end
+    # Retrieves a subscription for a given subscriptionId
+    # @param subscription_id [String] Unique identifier for Subscription object
+    # @param [Hash] opts the optional parameters
+    # @return [Subscription]
+    def get_subscription(subscription_id, opts = {})
+      data, _status_code, _headers = get_subscription_with_http_info(subscription_id, opts)
+      data
+    end
+
+    # Retrieves a subscription for a given subscriptionId
+    # @param subscription_id [String] Unique identifier for Subscription object
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Subscription, Integer, Hash)>] Subscription data, response status code and response headers
+    def get_subscription_with_http_info(subscription_id, options = {})
+      opts = options.dup
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: AppStoreApi.get_subscription ...'
+      end
+      # verify the required parameter 'subscription_id' is set
+      if @api_client.config.client_side_validation && subscription_id.nil?
+        fail ArgumentError, "Missing the required parameter 'subscription_id' when calling AppStoreApi.get_subscription"
+      end
+      # resource path
+      local_var_path = '/subscriptions/{subscriptionId}'.sub('{' + 'subscriptionId' + '}', subscription_id.to_s)
+
+      # camelize keys of incoming `where` opts
+      opts[:'where'] = @api_client.parameterize_where(opts[:'where']) if !opts[:'where'].nil?
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      
+      # XeroAPI's `IDs` convention openapi-generator does not snake_case properly.. manual over-riding `i_ds` malformations:
+      query_params[:'IDs'] = @api_client.build_collection_param(opts[:'ids'], :csv) if !opts[:'ids'].nil?
+      query_params[:'ContactIDs'] = @api_client.build_collection_param(opts[:'contact_ids'], :csv) if !opts[:'contact_ids'].nil?
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:body] 
+
+      # return_type
+      return_type = opts[:return_type] || 'Subscription' 
+
+      # auth_names
+      auth_names = opts[:auth_names] || ['OAuth2']
+
+      new_options = opts.merge(
+        :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, "AppStoreApi", new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: AppStoreApi#get_subscription\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+  end
+end

data/lib/xero-ruby/api_client.rb

@@ -57,7 +57,7 @@ module XeroRuby
     end
 
     def authorization_url
-      url = URI.parse @config.login_url
+      url = URI.parse(@config.login_url)
       url.query = URI.encode_www_form(
         {
           response_type: 'code',
@@ -105,6 +105,11 @@ module XeroRuby
       XeroRuby::PayrollUkApi.new(self)
     end
 
+    def app_store_api
+      @config.base_url = @config.app_store_url
+      XeroRuby::AppStoreApi.new(self)
+    end
+
     # Token Helpers
     def token_set
       @config.token_set
@@ -501,6 +506,8 @@ module XeroRuby
           XeroRuby::PayrollNz.const_get(return_type).build_from_hash(data)
         when 'PayrollUkApi'
           XeroRuby::PayrollUk.const_get(return_type).build_from_hash(data)
+        when 'AppStoreApi'
+          XeroRuby::AppStore.const_get(return_type).build_from_hash(data)
         else
           XeroRuby::Accounting.const_get(return_type).build_from_hash(data)
         end

data/lib/xero-ruby/configuration.rb

@@ -33,6 +33,7 @@ module XeroRuby
     attr_accessor :payroll_au_url
     attr_accessor :payroll_nz_url
     attr_accessor :payroll_uk_url
+    attr_accessor :app_store_url
 
     # Defines API keys used with API Key authentications.
     #
@@ -149,6 +150,7 @@ module XeroRuby
       @payroll_au_url = 'https://api.xero.com/payroll.xro/1.0/'
       @payroll_nz_url = 'https://api.xero.com/payroll.xro/2.0/'
       @payroll_uk_url = 'https://api.xero.com/payroll.xro/2.0/'
+      @app_store_url = 'https://api.xero.com/appstore/2.0/'
       @access_token = nil
       @id_token = nil
       @api_key = {}

data/lib/xero-ruby/models/accounting/payment.rb

@@ -49,6 +49,9 @@ module XeroRuby::Accounting
     # The amount of the payment. Must be less than or equal to the outstanding amount owing on the invoice e.g. 200.00
     attr_accessor :amount
     
+    # The amount of the payment in the currency of the bank account.
+    attr_accessor :bank_amount
+    
     # An optional description for the payment e.g. Direct Debit
     attr_accessor :reference
     
@@ -137,6 +140,7 @@ module XeroRuby::Accounting
         :'date' => :'Date',
         :'currency_rate' => :'CurrencyRate',
         :'amount' => :'Amount',
+        :'bank_amount' => :'BankAmount',
         :'reference' => :'Reference',
         :'is_reconciled' => :'IsReconciled',
         :'status' => :'Status',
@@ -168,6 +172,7 @@ module XeroRuby::Accounting
         :'date' => :'Date',
         :'currency_rate' => :'BigDecimal',
         :'amount' => :'BigDecimal',
+        :'bank_amount' => :'BigDecimal',
         :'reference' => :'String',
         :'is_reconciled' => :'Boolean',
         :'status' => :'String',
@@ -244,6 +249,10 @@ module XeroRuby::Accounting
         self.amount = attributes[:'amount']
       end
 
+      if attributes.key?(:'bank_amount')
+        self.bank_amount = attributes[:'bank_amount']
+      end
+
       if attributes.key?(:'reference')
         self.reference = attributes[:'reference']
       end
@@ -360,6 +369,7 @@ module XeroRuby::Accounting
           date == o.date &&
           currency_rate == o.currency_rate &&
           amount == o.amount &&
+          bank_amount == o.bank_amount &&
           reference == o.reference &&
           is_reconciled == o.is_reconciled &&
           status == o.status &&
@@ -385,7 +395,7 @@ module XeroRuby::Accounting
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [invoice, credit_note, prepayment, overpayment, invoice_number, credit_note_number, account, code, date, currency_rate, amount, reference, is_reconciled, status, payment_type, updated_date_utc, payment_id, batch_payment_id, bank_account_number, particulars, details, has_account, has_validation_errors, status_attribute_string, validation_errors].hash
+      [invoice, credit_note, prepayment, overpayment, invoice_number, credit_note_number, account, code, date, currency_rate, amount, bank_amount, reference, is_reconciled, status, payment_type, updated_date_utc, payment_id, batch_payment_id, bank_account_number, particulars, details, has_account, has_validation_errors, status_attribute_string, validation_errors].hash
     end
 
     # Builds the object from hash

data/lib/xero-ruby/models/accounting/time_zone.rb

@@ -122,6 +122,7 @@ module XeroRuby::Accounting
     HAWAIIANSTANDARDTIME = "HAWAIIANSTANDARDTIME".freeze
     UTC11 = "UTC11".freeze
     DATELINESTANDARDTIME = "DATELINESTANDARDTIME".freeze
+    EASTERISLANDSTANDARDTIME = "EASTERISLANDSTANDARDTIME".freeze
 
     # Builds the enum from string
     # @param [String] The enum value in the form of the string

data/lib/xero-ruby/models/app_store/plan.rb

@@ -0,0 +1,310 @@
+=begin
+#Xero AppStore API
+
+#These endpoints are for Xero Partners to interact with the App Store Billing platform
+
+Contact: api@xero.com
+Generated by: https://openapi-generator.tech
+OpenAPI Generator version: 4.3.1
+
+=end
+
+require 'time'
+require 'date'
+
+module XeroRuby::AppStore
+  require 'bigdecimal'
+
+  class Plan
+    # The unique identifier of the plan
+    attr_accessor :id
+    
+    # The name of the plan. It is used in the invoice line item description. 
+    attr_accessor :name
+    
+    # Status of the plan. Available statuses are ACTIVE, PENDING_ACTIVATION. 
+    attr_accessor :status
+    ACTIVE = "ACTIVE".freeze
+    PENDING_ACTIVATION = "PENDING_ACTIVATION".freeze
+    
+    # List of the subscription items belonging to the plan. It does not include cancelled subscription items. 
+    attr_accessor :subscription_items
+    
+    class EnumAttributeValidator
+      attr_reader :datatype
+      attr_reader :allowable_values
+
+      def initialize(datatype, allowable_values)
+        @allowable_values = allowable_values.map do |value|
+          case datatype.to_s
+          when /Integer/i
+            value.to_i
+          when /Float/i
+            value.to_f
+          else
+            value
+          end
+        end
+      end
+
+      def valid?(value)
+        !value || allowable_values.include?(value)
+      end
+    end
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'id' => :'id',
+        :'name' => :'name',
+        :'status' => :'status',
+        :'subscription_items' => :'subscriptionItems'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'id' => :'String',
+        :'name' => :'String',
+        :'status' => :'String',
+        :'subscription_items' => :'Array<SubscriptionItem>'
+      }
+    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 `XeroRuby::AppStore::Plan` 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 `XeroRuby::AppStore::Plan`. 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?(:'id')
+        self.id = attributes[:'id']
+      end
+
+      if attributes.key?(:'name')
+        self.name = attributes[:'name']
+      end
+
+      if attributes.key?(:'status')
+        self.status = attributes[:'status']
+      end
+
+      if attributes.key?(:'subscription_items')
+        if (value = attributes[:'subscription_items']).is_a?(Array)
+          self.subscription_items = value
+        end
+      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
+      if @id.nil?
+        invalid_properties.push('invalid value for "id", id cannot be nil.')
+      end
+
+      if @name.nil?
+        invalid_properties.push('invalid value for "name", name cannot be nil.')
+      end
+
+      if @status.nil?
+        invalid_properties.push('invalid value for "status", status cannot be nil.')
+      end
+
+      if @subscription_items.nil?
+        invalid_properties.push('invalid value for "subscription_items", subscription_items cannot be nil.')
+      end
+
+      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?
+      return false if @id.nil?
+      return false if @name.nil?
+      return false if @status.nil?
+      status_validator = EnumAttributeValidator.new('String', ["ACTIVE", "PENDING_ACTIVATION"])
+      return false unless status_validator.valid?(@status)
+      return false if @subscription_items.nil?
+      true
+    end
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] status Object to be assigned
+    def status=(status)
+      validator = EnumAttributeValidator.new('String', ["ACTIVE", "PENDING_ACTIVATION"])
+      unless validator.valid?(status)
+        fail ArgumentError, "invalid value for \"status\", must be one of #{validator.allowable_values}."
+      end
+      @status = status
+    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 &&
+          id == o.id &&
+          name == o.name &&
+          status == o.status &&
+          subscription_items == o.subscription_items
+    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
+      [id, name, status, subscription_items].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 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 # or else data not found in attributes(hash), not an issue as the data can be optional
+      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 :DateTime
+        DateTime.parse(parse_date(value))
+      when :Date
+        Date.parse(parse_date(value))
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BigDecimal
+        BigDecimal(value.to_s)
+      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
+        XeroRuby::AppStore.const_get(type).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(downcase: false)
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        key = downcase ? attr : param
+        hash[key] = _to_hash(value, downcase: downcase)
+      end
+      hash
+    end
+
+    # Returns the object in the form of hash with snake_case
+    def to_attributes
+      to_hash(downcase: true)
+    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, downcase: false)
+      if value.is_a?(Array)
+        value.map do |v|
+          v.to_hash(downcase: downcase)
+        end
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.map { |k, v| hash[k] = _to_hash(v, downcase: downcase) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash(downcase: downcase)
+      else
+        value
+      end
+    end
+
+    def parse_date(datestring)
+      if datestring.include?('Date')
+        date_pattern = /\/Date\((-?\d+)(\+\d+)?\)\//
+        original, date, timezone = *date_pattern.match(datestring)
+        date = (date.to_i / 1000)
+        Time.at(date).utc.strftime('%Y-%m-%dT%H:%M:%S%z').to_s
+      elsif /(\d\d\d\d)-(\d\d)/.match(datestring) # handles dates w/out Days: YYYY-MM*-DD
+        Time.parse(datestring + '-01').strftime('%Y-%m-%dT%H:%M:%S').to_s
+      else # handle date 'types' for small subset of payroll API's
+        Time.parse(datestring).strftime('%Y-%m-%dT%H:%M:%S').to_s
+      end
+    end
+  end
+end