zuora_api_D 1.6.06

data/lib/zuora_api.rb

@@ -0,0 +1,9 @@
+require 'rails'
+require "zuora_api/login"
+require "zuora_api/logins/basic"
+require "zuora_api/logins/oauth"
+require 'zuora_api/exceptions'
+require "insights_api/login"
+module ZuoraAPI
+  # Your code goes here...
+end

data/lib/zuora_api/exceptions.rb

@@ -0,0 +1,106 @@
+module ZuoraAPI
+  module Exceptions
+    class Error < StandardError; end
+    class AuthorizationNotPerformed < Error; end
+    class ZuoraAPISessionError < Error
+      attr_reader :code, :response
+      attr_writer :default_message
+
+      def initialize(message = nil,response=nil, code =nil)
+        @code = code
+        @message = message
+        @response = response
+        @default_message = "Error with Zuora Session."
+      end
+
+      def to_s
+        @message || @default_message
+      end
+    end
+
+    class BadEntityError < Error
+      attr_reader :code, :response, :errors, :successes
+      attr_writer :default_message
+
+      def initialize(message = nil,response=nil, code =nil, errors = [], successes = [])
+        @code = code
+        @message = message
+        @response = response
+        @default_message = "Error with Zuora Entity"
+        @errors = errors
+        @successes = successes
+      end
+
+      def to_s
+        @message || @default_message
+      end
+    end
+
+    class ZuoraAPIError < Error
+      attr_reader :code, :response, :errors, :successes
+      attr_writer :default_message
+
+      def initialize(message = nil,response=nil, code =nil, errors = [], successes = [])
+        @code = code
+        @message = message
+        @response = response
+        @default_message = "Error communicating with Zuora."
+        @errors = errors
+        @successes = successes
+      end
+
+      def to_s
+        @message || @default_message
+      end
+    end
+
+    class ZuoraAPIRequestLimit < Error
+      attr_reader :code, :response
+      attr_writer :default_message
+
+      def initialize(message = nil,response=nil, code =nil)
+        @code = code
+        @message = message
+        @response = response
+        @default_message = "Your request limit has been exceeded for zuora."
+      end
+
+      def to_s
+        @message || @default_message
+      end
+    end
+
+    class ZuoraAPILockCompetition < Error
+      attr_reader :code, :response
+      attr_writer :default_message
+
+      def initialize(message = nil,response=nil, code =nil)
+        @code = code
+        @message = message
+        @response = response
+        @default_message = "Operation failed due to lock competition. Please retry"
+      end
+
+      def to_s
+        @message || @default_message
+      end
+    end
+
+
+    class ZuoraAPIAuthenticationTypeError < Error
+      attr_reader :code, :response
+      attr_writer :default_message
+
+      def initialize(message = nil,response=nil, code =nil)
+        @code = code
+        @message = message
+        @response = response
+        @default_message = "Authentication type is not supported by this Login"
+      end
+
+      def to_s
+        @message || @default_message
+      end
+    end
+  end
+end

data/lib/zuora_api/login.rb

@@ -0,0 +1,808 @@
+require "httparty"
+require "nokogiri"
+require "uri"
+
+module ZuoraAPI
+  class Login
+    ENVIRONMENTS = [SANDBOX = 'Sandbox', PRODUCTION = 'Production', PREFORMANCE = 'Preformance', SERVICES = 'Services', UNKNOWN = 'Unknown' ]
+    REGIONS = [EU = 'EU', US = 'US', NA = 'NA' ]
+    MIN_Endpoint = '91.0'
+    XML_SAVE_OPTIONS = Nokogiri::XML::Node::SaveOptions::AS_XML | Nokogiri::XML::Node::SaveOptions::NO_DECLARATION 
+    attr_accessor :region, :url, :wsdl_number, :current_session, :environment, :status, :errors, :current_error, :user_info, :tenant_id, :tenant_name, :entity_id, :timeout_sleep
+
+    def initialize(url: nil, entity_id: nil, session: nil, status: nil, **keyword_args)
+      @url = url.gsub(/(\d{2}\.\d)$/, MIN_Endpoint)
+      @entity_id = entity_id
+      @errors = Hash.new
+      @current_session = session
+      @status = status.blank? ? "Active" : status
+      @user_info = Hash.new
+      self.update_environment
+      @timeout_sleep = 5
+    end
+
+    def self.environments
+      %w(Sandbox Production Services Performance Staging)
+    end
+
+    def self.regions
+      %w(US EU NA)
+    end
+
+    def self.endpoints
+      return {"US" => {"Sandbox" => "https://apisandbox.zuora.com/apps/services/a/",
+                       "Production" => "https://www.zuora.com/apps/services/a/",
+                       "Performance" => "https://pt1.zuora.com/apps/services/a/",
+                       "Services" => "https://services347.zuora.com/apps/services/a/"},
+              "EU" => {"Sandbox" => "https://sandbox.eu.zuora.com/apps/services/a/",
+                       "Production" => "https://eu.zuora.com/apps/services/a/",
+                       "Performance" => "https://pt1.eu.zuora.com/apps/services/a/",
+                       "Services" => "https://services347.eu.zuora.com/apps/services/a/"},
+              "NA" => {"Sandbox" => "https://sandbox.na.zuora.com/apps/services/a/",
+                       "Production" => "https://na.zuora.com/apps/services/a/",
+                       "Performance" => "https://pt1.na.zuora.com/apps/services/a/",
+                       "Services" => "https://services347.na.zuora.com/apps/services/a/"}
+            }
+    end
+
+    def update_environment
+      if !self.url.blank?
+        env_path = self.url.split('https://').last.split('.zuora.com').first
+        self.region = self.url.include?("eu.") ? "EU" : self.url.include?("na.") ? "NA" : "US"
+        if  env_path == 'apisandbox' || self.url.include?('sandbox')
+          self.environment = 'Sandbox'
+        elsif env_path == 'www' || env_path == 'api' || self.url.include?('tls10.zuora.com') || self.url.include?('origin-www.zuora.com') || self.url.include?('zforsf.zuora.com') || self.url.include?('https://zuora.com') || self.url.include?('eu.zuora.com') || self.url.include?('https://na.zuora.com')
+          self.environment = 'Production'
+        elsif env_path.include?('service') || env_path.include?('ep-edge')
+          self.environment = 'Services'
+        elsif env_path.include?('pt')
+          self.environment = 'Performance'
+        elsif env_path.include?('staging2') || env_path.include?('staging1')
+          self.region = 'US'
+          self.environment = 'Staging'
+        else
+          self.environment = 'Unknown'
+        end
+      end
+    end
+
+    def aqua_endpoint(url="")
+      return  "#{self.url.split("/apps").first}/apps/api/".concat(url)
+    end
+
+    def rest_endpoint(url="")
+      if self.environment == 'Sandbox'
+        return self.region == "US" ? "https://rest.apisandbox.zuora.com/v1/".concat(url) : self.region == "EU" ? "https://rest.sandbox.eu.zuora.com/v1/".concat(url) : "https://rest.sandbox.na.zuora.com/v1/".concat(url)
+      elsif  self.environment == 'Production'
+        return  self.region == "US" ? "https://rest.zuora.com/v1/".concat(url) : self.region == "EU" ? "https://rest.eu.zuora.com/v1/".concat(url) : "https://rest.na.zuora.com/v1/".concat(url)
+      elsif self.environment == 'Services'
+        return  self.url.split('/')[0..2].join('/').concat('/apps/v1/').concat(url)
+      elsif self.environment == 'Performance'
+        return  self.url.split('/')[0..2].join('/').concat('/apps/v1/').concat(url)
+      else self.environment == 'Unknown'
+        return url
+      end
+    end
+
+    def fileURL(url="")
+      return self.url.split(".com").first.concat(".com/apps/api/file/").concat(url)
+    end
+
+    def dateFormat
+      return self.wsdl_number > 68 ? '%Y-%m-%d' : '%Y-%m-%dT%H:%M:%S'
+    end
+
+    def new_session(auth_type: :basic, debug: false) 
+    end
+
+    def get_session(prefix: false, auth_type: :basic)
+      Rails.logger.debug("Get session for #{auth_type} - #{self.class.to_s}") 
+      case auth_type
+      when :basic
+        if self.current_session.blank?
+          Rails.logger.debug("Create new session") 
+          case self.class.to_s
+          when 'ZuoraAPI::Oauth'
+            if self.bearer_token.blank? || self.oauth_expired?
+              self.new_session(auth_type: :bearer)
+            end
+            self.get_z_session
+          when 'ZuoraAPI::Basic'
+            self.new_session(auth_type: :basic)
+          else
+            raise "No Zuora Login Specified"
+          end
+        end
+        raise ZuoraAPI::Exceptions::ZuoraAPISessionError.new(self.current_error) if self.status != 'Active'
+        return prefix ? "ZSession #{self.current_session}" : self.current_session.to_s
+      when :bearer
+        case self.class.to_s
+        when 'ZuoraAPI::Oauth'
+          if self.bearer_token.blank? || self.oauth_expired?
+            self.new_session(auth_type: :bearer)
+          end
+        when 'ZuoraAPI::Basic'
+          raise ZuoraAPI::Exceptions::ZuoraAPIAuthenticationTypeError.new("Basic Login, does not support Authentication of Type: #{auth_type}")
+        end
+        raise ZuoraAPI::Exceptions::ZuoraAPISessionError.new(self.current_error) if self.status != 'Active'
+        return prefix ? "Bearer #{self.bearer_token}" : self.bearer_token.to_s
+      end
+    end
+
+    def soap_call(ns1: 'ns1', ns2: 'ns2', batch_size: nil, single_transaction: false, debug: false, errors: [ZuoraAPI::Exceptions::ZuoraAPISessionError, ZuoraAPI::Exceptions::ZuoraAPIError, ZuoraAPI::Exceptions::ZuoraAPIRequestLimit, ZuoraAPI::Exceptions::ZuoraAPILockCompetition], z_session: true, timeout_retry: false, timeout: 120,**keyword_args)
+      tries ||= 2
+      xml = Nokogiri::XML::Builder.new do |xml|
+        xml['SOAP-ENV'].Envelope('xmlns:SOAP-ENV' => "http://schemas.xmlsoap.org/soap/envelope/",
+                                 "xmlns:#{ns2}" => "http://object.api.zuora.com/",
+                                 'xmlns:xsi' => "http://www.w3.org/2001/XMLSchema-instance",
+                                 'xmlns:api' => "http://api.zuora.com/",
+                                 "xmlns:#{ns1}" => "http://api.zuora.com/") do
+          xml['SOAP-ENV'].Header do
+            xml["#{ns1}"].SessionHeader do
+              xml["#{ns1}"].session self.get_session(prefix: false, auth_type: :basic)
+            end
+            if single_transaction
+              xml["#{ns1}"].CallOptions do
+                xml.useSingleTransaction single_transaction
+              end
+            end
+            if batch_size
+              xml["#{ns1}"].QueryOptions do
+                xml.batchSize batch_size
+              end
+            end
+          end
+          xml['SOAP-ENV'].Body do
+            yield xml, keyword_args
+          end
+        end
+      end
+
+      input_xml = Nokogiri::XML(xml.to_xml(:save_with => XML_SAVE_OPTIONS).strip)
+      input_xml.xpath('//ns1:session', 'ns1' =>'http://api.zuora.com/').children.remove
+      Rails.logger.debug("Request SOAP XML: #{input_xml.to_xml(:save_with => XML_SAVE_OPTIONS).strip}") if debug
+
+      response = HTTParty.post(self.url,:body => xml.doc.to_xml(:save_with => XML_SAVE_OPTIONS).strip, :headers => {'Content-Type' => "text/xml; charset=utf-8"}, :timeout => timeout)
+      output_xml = Nokogiri::XML(response.body)
+      Rails.logger.debug("Response SOAP XML: #{output_xml.to_xml(:save_with => XML_SAVE_OPTIONS).strip}") if debug
+
+      raise_errors(type: :SOAP, body: output_xml, response: response)
+    rescue ZuoraAPI::Exceptions::ZuoraAPISessionError => ex
+      if !(tries -= 1).zero? && z_session
+        Rails.logger.debug("SOAP Call - Session Invalid")
+        self.new_session(auth_type: :basic)
+        retry
+      else
+        if errors.include?(ex.class)
+          raise ex
+        else
+          return output_xml, input_xml, response
+        end
+      end
+    rescue ZuoraAPI::Exceptions::ZuoraAPIError, ZuoraAPI::Exceptions::ZuoraAPIRequestLimit, ZuoraAPI::Exceptions::ZuoraAPILockCompetition => ex
+      if errors.include?(ex.class)
+        raise ex
+      else
+        return output_xml, input_xml, response
+      end
+    rescue Net::OpenTimeout, Errno::ECONNRESET, OpenSSL::SSL::SSLError, Errno::ECONNREFUSED, SocketError => ex
+      if !(tries -= 1).zero? && timeout_retry
+        Rails.logger.info("SOAP Call - #{ex.class} Timed out will retry after 5 seconds")
+        sleep(self.timeout_sleep)
+        retry
+      else
+        raise ex
+      end
+    rescue => ex
+      raise ex
+    else
+      return output_xml, input_xml, response
+    end
+
+    def raise_errors(type: :SOAP, body: nil, response: nil)
+      case type
+      when :SOAP
+        error   = body.xpath('//fns:FaultCode', 'fns' =>'http://fault.api.zuora.com/').text
+        message = body.xpath('//fns:FaultMessage', 'fns' =>'http://fault.api.zuora.com/').text
+
+        if error.blank? || message.blank?
+          error   = body.xpath('//faultcode').text
+          message = body.xpath('//faultstring').text
+        end
+
+        if error.blank? || message.blank?
+          error   = body.xpath('//ns1:Code', 'ns1' =>'http://api.zuora.com/').text
+          message = body.xpath('//ns1:Message', 'ns1' =>'http://api.zuora.com/').text
+        end
+
+        #Update/Create/Delete Calls with multiple requests and responses
+        if body.xpath('//ns1:result', 'ns1' =>'http://api.zuora.com/').size > 0 && body.xpath('//ns1:Errors', 'ns1' =>'http://api.zuora.com/').size > 0
+          error = []
+          success = []
+          body.xpath('//ns1:result', 'ns1' =>'http://api.zuora.com/').each_with_index do |call, object_index|
+
+            if call.xpath('./ns1:Success', 'ns1' =>'http://api.zuora.com/').text == 'false'
+              message = "#{call.xpath('./*/ns1:Code', 'ns1' =>'http://api.zuora.com/').text}::#{call.xpath('./*/ns1:Message', 'ns1' =>'http://api.zuora.com/').text}"
+              error.push(message)
+            else
+              success.push(call.xpath('./ns1:Id', 'ns1' =>'http://api.zuora.com/').text)
+            end
+          end
+        end
+
+        #By default response if not passed in for SOAP as all SOAP is 200
+        if error.present?
+          if error.class == String
+            if error == "INVALID_SESSION"
+              raise ZuoraAPI::Exceptions::ZuoraAPISessionError.new("#{error}::#{message}", body, response.code )
+            end
+            if error == "REQUEST_EXCEEDED_LIMIT"
+              raise ZuoraAPI::Exceptions::ZuoraAPIRequestLimit.new("#{error}::#{message}", body, response.code)
+            end
+            if error == "LOCK_COMPETITION"
+              raise ZuoraAPI::Exceptions::ZuoraAPILockCompetition.new("#{error}::#{message}", body, response.code)
+            end
+            if error.present?
+              raise ZuoraAPI::Exceptions::ZuoraAPIError.new("#{error}::#{message}", body, response.code)
+            end
+          elsif error.class == Array
+              if error[0].include?("LOCK_COMPETITION") && error.count == 1
+                raise ZuoraAPI::Exceptions::ZuoraAPILockCompetition.new(error.group_by {|v| v}.map {|k,v| "(#{v.size}x) - #{k == "::" ? 'UNKNOWN::No error provided' : k}"}.join(', '), body, response.code)
+              else 
+                raise ZuoraAPI::Exceptions::ZuoraAPIError.new(error.group_by {|v| v}.map {|k,v| "(#{v.size}x) - #{k == "::" ? 'UNKNOWN::No error provided' : k}"}.join(', '), body, response.code, error, success)
+              end
+          end
+        end
+
+        if response.code == 429
+          raise ZuoraAPI::Exceptions::ZuoraAPIRequestLimit.new("The total number of concurrent requests has exceeded the limit allowed by the system. Please resubmit your request later.", body, response.code)
+        end
+
+      when :JSON
+        if body.class == Hash && (!body["success"] || !body["Success"] || response.code != 200)
+          messages_array = (body["reasons"] || []).map {|error| error['message']}.compact
+          codes_array = (body["reasons"] || []).map {|error| error['code']}.compact
+
+          if body['message'] == "No bearer token" && response.code == 400
+            raise ZuoraAPI::Exceptions::ZuoraAPIAuthenticationTypeError.new()
+          end
+
+          if body.dig("reasons").nil? ? false : body.dig("reasons")[0].dig("code") == 90000020
+            raise ZuoraAPI::Exceptions::BadEntityError.new("#{messages_array.join(', ')}", body, response.code)
+          end
+
+          if body['error'] == 'Unauthorized' && body['status'] = 401
+            raise ZuoraAPI::Exceptions::ZuoraAPISessionError.new("#{messages_array.join(', ')}", body, response.code)
+          end
+          #Authentication failed
+          if codes_array.map{|code| code.to_s.slice(6,7).to_i}.include?(11) || response.code == 401
+            raise ZuoraAPI::Exceptions::ZuoraAPISessionError.new("#{messages_array.join(', ')}", body, response.code)
+          end
+
+          #Zuora REST Create Amendment error #Authentication failed
+          if body["faultcode"].present? && body["faultcode"] == "fns:INVALID_SESSION"
+            raise ZuoraAPI::Exceptions::ZuoraAPISessionError.new("#{body['faultstring']}", body, response.code)
+          end
+
+          #Request exceeded limit
+          if codes_array.map{|code| code.to_s.slice(6,7).to_i}.include?(70)
+            raise ZuoraAPI::Exceptions::ZuoraAPIRequestLimit.new("#{messages_array.join(', ')}", body, response.code)
+          end
+
+          #Locking contention
+          if codes_array.map{|code| code.to_s.slice(6,7).to_i}.include?(50)
+            raise ZuoraAPI::Exceptions::ZuoraAPILockCompetition.new("#{messages_array.join(', ')}", body, response.code)
+          end
+
+          #All Errors catch
+          if codes_array.size > 0
+            raise ZuoraAPI::Exceptions::ZuoraAPIError.new("#{messages_array.join(', ')}", body, response.code)
+          end
+
+          #Zuora REST Query Errors
+          if body["faultcode"].present?
+            case body["faultcode"]
+            when "fns:MALFORMED_QUERY"
+              raise ZuoraAPI::Exceptions::ZuoraAPIError.new("#{body["faultcode"]}::#{body["faultstring"]}", body, response.code)
+            when "fns:REQUEST_EXCEEDED_LIMIT"
+              raise ZuoraAPI::Exceptions::ZuoraAPIRequestLimit.new("#{body["faultcode"]}::#{body["faultstring"]}", body, response.code)
+            when "fns:LOCK_COMPETITION"
+              raise ZuoraAPI::Exceptions::ZuoraAPILockCompetition.new("#{body["faultcode"]}::#{body["faultstring"]}", body, response.code)
+            when "INVALID_SESSION"
+              raise ZuoraAPI::Exceptions::ZuoraAPISessionError.new("#{body["faultcode"]}::#{body["faultstring"]}", body, response.code)
+            else
+              raise ZuoraAPI::Exceptions::ZuoraAPIError.new("#{body["faultcode"]}::#{body["faultstring"]}", body, response.code)
+            end
+          end
+
+          if body["Errors"].present? || body["errors"].present?
+            errors = []
+            (body["Errors"] || []).select { |obj| errors.push(obj["Message"]) }.compact
+            (body["errors"] || []).select { |obj| errors.push(obj["Message"]) }.compact
+            if errors.size > 0
+              raise ZuoraAPI::Exceptions::ZuoraAPIError.new("#{errors.join(", ")}", body, response.code, errors)
+            end
+          end
+        end
+
+        #Zuora REST Actions error (Create, Update, Delete)
+        if body.class == Array
+          all_errors = body.select {|obj| !obj['Success'] || !obj['success'] }.map {|obj| obj['Errors'] || obj['errors'] }.compact
+          all_success = body.select {|obj| obj['Success'] || obj['success']}.compact
+
+          if all_errors.size > 0
+            raise ZuoraAPI::Exceptions::ZuoraAPIError.new("#{all_errors.flatten.group_by {|error| error['Message']}.keys.uniq.join(' ')}", body, response.code, all_errors, all_success  )
+          end
+        end
+
+        #All other errors
+        if response.code != 200
+          if response.code == 429
+            raise ZuoraAPI::Exceptions::ZuoraAPIRequestLimit.new("The total number of concurrent requests has exceeded the limit allowed by the system. Please resubmit your request later.", body, response.code)
+          else
+            raise ZuoraAPI::Exceptions::ZuoraAPIError.new("#{response.message}", body, response.code)
+          end
+        end
+      end
+    end
+
+    def aqua_query(queryName: '', query: '', version: '1.2', jobName: 'Aqua',partner: '', project: '')
+      params = {
+        "format" => 'csv',
+        "version" => version,
+        "name" => jobName,
+        "encrypted" => 'none',
+        "useQueryLabels" => 'true',
+        "partner" => partner,
+        "project" => project,
+        "queries" => [{
+          "name" => queryName,
+          "query" => query,
+          "type" => 'zoqlexport'
+          }]
+      }
+      response = self.rest_call(method: :post, body: params.to_json, url: self.aqua_endpoint("batch-query/"))
+      if(response[0]["id"].nil?)
+        raise ZuoraAPI::Exceptions::ZuoraAPIError.new("Error in AQuA Process. #{response}")
+      end
+      return getFileById(id: response[0]["id"])
+    end
+
+    def getFileById(id: "2c92c0f85e7f88ff015e86b8f8f4517f")
+      response = nil
+      result = "new"
+      while result != "completed" do
+        sleep(2)#sleep 2 seconds
+        response, fullResponse = self.rest_call(method: :get, body: {}, url: self.aqua_endpoint("batch-query/jobs/#{id}"))
+        result = response["batches"][0]["status"]
+        if result == "error"
+          raise ZuoraAPI::Exceptions::ZuoraAPIError.new("Aqua Error: #{response}")
+          break
+        end
+      end
+      fileId = response["batches"][0]["fileId"]
+      return self.get_file(url: self.aqua_endpoint("file/#{fileId}"))
+    end
+
+    def describe_call(object = nil)
+      tries ||= 2
+
+      base = self.url.include?(".com") ? self.url.split(".com")[0].concat(".com") : self.url.split(".eu")[0].concat(".eu")
+      url = object ? "#{base}/apps/api/describe/#{object}" : "#{base}/apps/api/describe/"
+      headers = !self.entity_id.blank? ? {"entityId" => self.entity_id, 'Content-Type' => "text/xml; charset=utf-8"} : {'Content-Type' => "text/xml; charset=utf-8"}
+      response = HTTParty.get(url,  headers: {"Authorization" => self.get_session(prefix: true, auth_type: :basic)}.merge(headers), :timeout => 120)
+
+      raise ZuoraAPI::Exceptions::ZuoraAPISessionError.new("Session Expired") if response.code.to_s == "401"
+      output_xml = Nokogiri::XML(response.body)
+      des_hash = Hash.new
+      if object == nil
+        output_xml.xpath("//object").each do |object|
+          temp = {:label => object.xpath(".//label").text, :url => object.attributes["href"].value }
+          des_hash[object.xpath(".//name").text] = temp
+        end
+      else
+        output_xml.xpath("//field").each do |object|
+          temp = {:label => object.xpath(".//label").text,:selectable => object.xpath(".//selectable").text,
+                  :createable => object.xpath(".//label").text == "ID" ? "false" : object.xpath(".//createable").text,
+                  :filterable => object.xpath(".//filterable").text,
+                  :updateable => object.xpath(".//label").text == "ID" ? "false" : object.xpath(".//updateable").text,
+                  :custom => object.xpath(".//custom").text,:maxlength => object.xpath(".//maxlength").text,
+                  :required => object.xpath(".//required").text,
+                  :type => object.xpath(".//type").text,
+                  :context => object.xpath(".//context").collect{ |x| x.text } }
+          temp[:options] = object.xpath(".//option").collect{ |x| x.text } if object.xpath(".//option").size > 0
+          des_hash[object.xpath(".//name").text.to_sym] = temp
+          des_hash[:fieldsToNull] = {:label => "FieldsToNull",:selectable => "false",
+                                     :createable => "false",:filterable => "false",
+                                     :updateable => "true",:custom => "false",
+                                     :required => "false",:type => "picklist",
+                                     :maxlength => "" ,:context => ["soap"],
+                                     :options => des_hash.map {|k,v| k if  v[:updateable] == "true" && v[:required] == "false"}.compact.uniq }
+
+        end
+        des_hash[:related_objects] = output_xml.xpath(".//related-objects").xpath(".//object").map{ |x| [x.xpath(".//name").text.to_sym, [ [:url, x.attributes["href"].value], [:label, x.xpath(".//name").text ] ].to_h] }.to_h
+      end
+    rescue Net::ReadTimeout, Net::OpenTimeout, Errno::EPIPE, Errno::ECONNRESET, OpenSSL::SSL::SSLError, Errno::ECONNREFUSED, SocketError => ex
+      if !(tries -= 1).zero?
+        Rails.logger.info("Describe - #{ex.class} Timed out will retry after 5 seconds")
+        sleep(self.timeout_sleep)
+        retry
+      else
+        raise ex
+      end
+    rescue ZuoraAPI::Exceptions::ZuoraAPISessionError => ex
+      if !(tries -= 1).zero?
+        Rails.logger.info("Session expired. Starting new session.")
+        self.new_session
+        retry
+      else
+        raise ex
+      end
+    rescue => ex
+      raise ex
+    else
+      return des_hash
+    end
+
+    def rest_call(method: :get, body: nil,headers: {}, url: rest_endpoint("catalog/products?pageSize=4"), debug: false, errors: [ZuoraAPI::Exceptions::ZuoraAPISessionError, ZuoraAPI::Exceptions::ZuoraAPIError, ZuoraAPI::Exceptions::ZuoraAPIRequestLimit, ZuoraAPI::Exceptions::ZuoraAPILockCompetition], z_session: true, session_type: :basic, timeout_retry: false, timeout: 120, **keyword_args)
+      tries ||= 2
+      headers["entityId"] = self.entity_id if !self.entity_id.blank?
+      raise "Method not supported, supported methods include: :get, :post, :put, :delete, :patch, :head, :options" if ![:get, :post, :put, :delete, :patch, :head, :options].include?(method)
+      
+      authentication_headers = z_session ? {"Authorization" =>  self.get_session(prefix: true, auth_type: session_type) } : {}
+      headers = {'Content-Type' => "application/json; charset=utf-8"}.merge(headers).merge(authentication_headers)
+
+      response = HTTParty::Request.new("Net::HTTP::#{method.to_s.capitalize}".constantize, url, body: body, headers: headers, timeout: timeout).perform
+      Rails.logger.debug("Response Code: #{response.code}") if debug
+      begin
+        output_json = JSON.parse(response.body)
+      rescue JSON::ParserError => ex
+        output_json = {}
+      end
+      Rails.logger.debug("Response JSON: #{output_json}") if debug && output_json.present?
+
+      raise_errors(type: :JSON, body: output_json, response: response)
+    rescue ZuoraAPI::Exceptions::ZuoraAPIAuthenticationTypeError => ex
+      if self.class.to_s == 'ZuoraAPI::Oauth'
+        self.rest_call(method: method.to_sym, url: url, debug: debug, errors: errors, z_session: z_session, session_type: :bearer, timeout_retry: timeout_retry, timeout: timeout)
+      else 
+        Rails.logger.debug("Rest Call - Session Bad Auth type")
+        raise ex
+      end
+    rescue ZuoraAPI::Exceptions::ZuoraAPISessionError => ex
+      if !(tries -= 1).zero? && z_session
+        Rails.logger.debug("Rest Call - Session Invalid #{session_type}")
+        self.new_session(auth_type: session_type)
+        retry
+      else
+        if errors.include?(ex.class)
+          raise ex
+        else
+          return [output_json, response]
+        end
+      end
+    rescue ZuoraAPI::Exceptions::ZuoraAPIError, ZuoraAPI::Exceptions::ZuoraAPIRequestLimit, ZuoraAPI::Exceptions::ZuoraAPILockCompetition  => ex
+      if errors.include?(ex.class)
+        raise ex
+      else
+        return [output_json, response]
+      end
+    rescue ZuoraAPI::Exceptions::BadEntityError => ex
+      raise ex
+    rescue Net::OpenTimeout, Errno::ECONNRESET, OpenSSL::SSL::SSLError, Errno::ECONNREFUSED, SocketError => ex
+      if !(tries -= 1).zero? && timeout_retry
+        Rails.logger.info("Rest Call - #{ex.class} Timed out will retry after 5 seconds")
+        sleep(self.timeout_sleep)
+        retry
+      else
+        raise ex
+      end
+    rescue => ex
+      raise ex
+    else
+      return [output_json, response]
+    end
+
+    def update_create_tenant
+      Rails.logger.debug("Update and/or Create Tenant")
+      output_xml, input_xml = soap_call() do |xml|
+        xml['api'].getUserInfo
+      end
+      user_info = output_xml.xpath('//ns1:getUserInfoResponse', 'ns1' =>'http://api.zuora.com/')
+      output_hash = Hash[user_info.children.map {|x| [x.name.to_sym, x.text] }]
+      self.user_info = output_hash
+      self.user_info['entities'] = self.rest_call(:url => self.rest_endpoint("user-access/user-profile/#{self.user_info['UserId']}/accessible-entities"))['entities']
+      self.tenant_name = output_hash[:TenantName]
+      self.tenant_id = output_hash[:TenantId]
+      return self
+    end
+
+    def get_catalog(page_size: 40)
+      products, catalog_map, response = [{}, {}, {'nextPage' => self.rest_endpoint("catalog/products?pageSize=#{page_size}") }]
+      while !response["nextPage"].blank?
+        url = self.rest_endpoint(response["nextPage"].split('/v1/').last)
+        Rails.logger.debug("Fetch Catalog URL #{url}")
+        output_json, response = self.rest_call(:debug => false, :url => url, :errors => [ZuoraAPI::Exceptions::ZuoraAPISessionError], :timeout_retry => true )
+        if !output_json['success'] =~ (/(true|t|yes|y|1)$/i) || output_json['success'].class != TrueClass
+          raise ZuoraAPI::Exceptions::ZuoraAPIError.new("Error Getting Catalog: #{output_json}")
+        end
+        output_json["products"].each do |product|
+          catalog_map[product["id"]] = {"productId" => product["id"]}
+          rateplans = {}
+
+          product["productRatePlans"].each do |rateplan|
+            catalog_map[rateplan["id"]] = {"productId" => product["id"], "productRatePlanId" => rateplan["id"]}
+            charges = {}
+
+            rateplan["productRatePlanCharges"].each do |charge|
+              catalog_map[charge["id"]] = {"productId" => product["id"], "productRatePlanId" => rateplan["id"], "productRatePlanChargeId" => charge["id"]}
+              charges[charge["id"]] = charge.merge({"productId" => product["id"], "productName" => product["name"], "productRatePlanId" => rateplan["id"], "productRatePlanName" => rateplan["name"] })
+            end
+
+            rateplan["productRatePlanCharges"] = charges
+            rateplans[rateplan["id"]] = rateplan.merge({"productId" => product["id"], "productName" => product["name"]})
+          end
+          product["productRatePlans"] = rateplans
+          products[product['id']] = product
+        end
+      end
+      return products, catalog_map
+    end
+
+    def get_file(url: nil, headers: {}, count: 3, z_session: true, tempfile: true, file_path: defined?(Rails.root.join('tmp')) ? Rails.root.join('tmp') : Pathname.new(Dir.pwd), timeout_retries: 2, timeout: 120, **execute_params)
+      raise "file_path must be of class Pathname" if file_path.class != Pathname
+
+      #Make sure directory exists
+      require 'fileutils'
+      FileUtils.mkdir_p(file_path) unless File.exists?(file_path)
+
+      begin
+        status_code = nil
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.read_timeout = timeout #Seconds
+        http.use_ssl = true  if uri.scheme.downcase == 'https'
+        headers = headers.merge({"Authorization" => self.get_session(prefix: true)}) if z_session
+
+        response_save = nil
+        http.request_get(uri.path, headers) do |response|
+          response_save = response
+          status_code = response.code if response
+
+          case response
+          when Net::HTTPNotFound
+            Rails.logger.fatal("404 - Not Found")
+            raise response
+
+          when Net::HTTPUnauthorized
+            raise ZuoraAPI::Exceptions::ZuoraAPISessionError.new(self.current_error) if count <= 0
+            Rails.logger.fatal("Unauthorized: Retry")
+            self.new_session
+            return get_file(:url => url, :headers => headers, :count => count - 1, :z_session => z_session, :tempfile => tempfile, :file_path => file_path, :timeout_retries => timeout_retries, :timeout => timeout)
+
+          when Net::ReadTimeout, Net::OpenTimeout, Errno::EPIPE, Errno::ECONNRESET, OpenSSL::SSL::SSLError, Errno::ECONNREFUSED, SocketError
+            Rails.logger.fatal("#{response.class} timeout - retry")
+            return get_file(:url => url, :headers => headers, :count => count, :z_session => z_session, :tempfile => tempfile, :file_path => file_path, :timeout_retries => timeout_retries - 1, :timeout => timeout)
+
+          when Net::HTTPClientError
+            Rails.logger.fatal("Login: #{self.username} Export")
+            raise response
+
+          when Net::HTTPOK
+            headers = {}
+            response.each_header do |k,v|
+              headers[k] = v
+            end
+            Rails.logger.debug("Headers: #{headers.to_s}")
+
+            size, export_progress = [0, 0]
+            encoding, type, full_filename = [nil, nil, nil]
+            if response.header["Content-Disposition"].present?
+              case response.header["Content-Disposition"]
+              when /.*; filename\*=.*/
+                full_filename = /.*; filename\*=(.*)''(.*)/.match(response.header["Content-Disposition"])[2].strip
+                encoding = /.*; filename\*=(.*)''(.*)/.match(response.header["Content-Disposition"])[1].strip
+              when /.*; filename=/
+                full_filename = /.*; filename=(.*)/.match(response.header["Content-Disposition"])[1].strip
+              end
+              file_ending = ".#{full_filename.partition(".").last}"
+            end
+            #If user supplied a filename use it, else default to content header filename, else default to uri pattern
+            filename =  full_filename.present? ? full_filename.split(file_ending).first : File.basename(uri.path).rpartition('.').first
+
+            if response.header["Content-Type"].present?
+              case response.header["Content-Type"]
+              when /.*;charset=.*/
+                type = /(.*);charset=(.*)/.match(response.header["Content-Type"])[1]
+                encoding = /(.*);charset=(.*)/.match(response.header["Content-Type"])[2]
+              else
+                type = response.header["Content-Type"]
+                encoding ||= 'UTF-8'
+              end
+            end
+            Rails.logger.info("File: #{filename}#{file_ending}  #{encoding}  #{type}")
+
+            if response.header["Content-Length"].present?
+              export_size = response.header["Content-Length"].to_i
+            elsif response.header["ContentLength"].present?
+              export_size = response.header["ContentLength"].to_i
+            end
+
+            file_handle = nil
+            timestamp =  Time.now.to_i
+            if tempfile
+              require 'tempfile'
+              file_handle = ::Tempfile.new(["#{filename}_#{timestamp}", "#{file_ending}"], file_path)
+              file_handle.binmode
+            else
+              file_handle = File.new(file_path.join("#{filename}_#{timestamp}#{file_ending}"), "w+")
+              file_handle.binmode
+            end
+
+            response.read_body do |chunk|
+              file_handle << chunk.force_encoding(encoding)
+
+              if defined?(export_size) && export_size != 0  && export_size.class == Integer
+                size += chunk.size
+                new_progress = (size * 100) / export_size
+                unless new_progress == export_progress
+                  Rails.logger.debug("Login: #{self.username} Export Downloading %s (%3d%%)" % [filename, new_progress])
+                end
+                export_progress = new_progress
+              end
+            end
+
+            file_handle.close
+            Rails.logger.debug("Filepath: #{file_handle.path} Size: #{File.size(file_handle.path).to_f/1000000} mb")
+
+            return file_handle
+          end
+        end
+      rescue Exception => e
+        Rails.logger.fatal("Download Failed: #{response_save} - #{e.class} : #{e.message}")
+        Rails.logger.fatal("Download Failed: #{e.backtrace.join("\n")}")
+        raise
+      end
+    end
+
+    def getDataSourceExport(query, extract: true, encrypted: false, zip: true)
+      Rails.logger.debug("Build export")
+      Rails.logger.debug("#{query}")
+      request = Nokogiri::XML::Builder.new do |xml|
+        xml['SOAP-ENV'].Envelope('xmlns:SOAP-ENV' => "http://schemas.xmlsoap.org/soap/envelope/", 'xmlns:ns2' => "http://object.api.zuora.com/", 'xmlns:xsi' => "http://www.w3.org/2001/XMLSchema-instance", 'xmlns:ns1' => "http://api.zuora.com/") do
+          xml['SOAP-ENV'].Header do
+            xml['ns1'].SessionHeader do
+              xml['ns1'].session self.get_session(prefix: false, auth_type: :basic)
+            end
+          end
+          xml['SOAP-ENV'].Body do
+            xml['ns1'].create do
+              xml['ns1'].zObjects('xsi:type' => "ns2:Export") do
+                xml['ns2'].Format 'csv'
+                xml['ns2'].Zip zip
+                xml['ns2'].Name 'googman'
+                xml['ns2'].Query query
+                xml['ns2'].Encrypted encrypted
+              end
+            end
+          end
+        end
+      end
+
+      response_query = HTTParty.post(self.url, body: request.to_xml(:save_with => XML_SAVE_OPTIONS).strip, headers: {'Content-Type' => "application/json; charset=utf-8"}, :timeout => 120)
+      
+      output_xml = Nokogiri::XML(response_query.body)
+      raise 'Export Creation Unsuccessful : ' + output_xml.xpath('//ns1:Message', 'ns1' =>'http://api.zuora.com/').text if  output_xml.xpath('//ns1:Success', 'ns1' =>'http://api.zuora.com/').text != "true"
+      id = output_xml.xpath('//ns1:Id', 'ns1' =>'http://api.zuora.com/').text
+
+      confirmRequest = Nokogiri::XML::Builder.new do |xml|
+        xml['SOAP-ENV'].Envelope('xmlns:SOAP-ENV' => "http://schemas.xmlsoap.org/soap/envelope/", 'xmlns:ns2' => "http://object.api.zuora.com/", 'xmlns:xsi' => "http://www.w3.org/2001/XMLSchema-instance", 'xmlns:ns1' => "http://api.zuora.com/") do
+          xml['SOAP-ENV'].Header do
+            xml['ns1'].SessionHeader do
+              xml['ns1'].session self.get_session(prefix: false, auth_type: :basic)
+            end
+          end
+          xml['SOAP-ENV'].Body do
+            xml['ns1'].query do
+              xml['ns1'].queryString "SELECT  Id, CreatedById, CreatedDate, Encrypted, FileId, Format, Name, Query, Size, Status, StatusReason, UpdatedById, UpdatedDate, Zip From Export where Id = '#{id}'"
+            end
+          end
+        end
+      end
+      result = 'Waiting'
+
+      while result != "Completed"
+        sleep 3
+        response_query = HTTParty.post(self.url, body: confirmRequest.to_xml(:save_with => XML_SAVE_OPTIONS).strip, headers: {'Content-Type' => "application/json; charset=utf-8"}, :timeout => 120)
+  
+        output_xml = Nokogiri::XML(response_query.body)
+        result = output_xml.xpath('//ns2:Status',  'ns2' =>'http://object.api.zuora.com/').text
+        status_code = response_query.code if response_query
+        raise "Export Creation Unsuccessful : #{output_xml.xpath('//ns1:Message', 'ns1' =>'http://api.zuora.com/').text}" if result.blank? || result == "Failed"
+      end
+
+      file_id = output_xml.xpath('//ns2:FileId',  'ns2' =>'http://object.api.zuora.com/').text
+      Rails.logger.debug('=====> Export finished')
+      export_file = get_file(:url => self.fileURL(file_id))
+      export_file_path = export_file.path
+      Rails.logger.debug("=====> Export path #{export_file.path}")
+
+      if extract && zip
+        require "zip"
+        new_path = export_file_path.partition('.zip').first
+        zipped = Zip::File.open(export_file_path)
+        file_handle = zipped.entries.first
+        file_handle.extract(new_path)
+        File.delete(export_file_path)
+        return new_path
+      else
+        return export_file_path
+      end
+    end
+
+    def query(query, parse = false)
+      Rails.logger.debug("Querying Zuora for #{query}")
+      output_xml, input_xml = self.soap_call({:debug => false, :timeout_retry => true}) do |xml|
+        xml['ns1'].query do
+          xml['ns1'].queryString query
+        end
+      end
+      if parse
+        return [] if output_xml.xpath('//ns1:size', 'ns1' =>'http://api.zuora.com/').text == '0'
+        data = output_xml.xpath('//ns1:records', 'ns1' =>'http://api.zuora.com/').map {|record| record.children.map {|element| [element.name, element.text]}.to_h}
+        return data
+      else
+        return output_xml
+      end
+    end
+
+    def createJournalRun(call)
+      url = rest_endpoint("/journal-runs")
+      uri = URI(url)
+      req = Net::HTTP::Post.new(uri,initheader = {'Content-Type' =>'application/json'})
+      req["Authorization"] = self.get_session(prefix: true)
+      req.body = call
+
+      response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
+        http.request req
+      end
+      
+      Rails.logger.debug("Response #{response.code} #{response.message}: #{response.body}")
+
+      result = JSON.parse(response.body)
+      if result["success"]
+        jrNumber = result["journalRunNumber"]
+        return jrNumber
+      else
+        message = result["reasons"][0]["message"]
+        Rails.logger.error("Journal Run failed with message #{message}")
+        return result
+      end
+
+    end
+
+    def checkJRStatus(jrNumber)
+      Rails.logger.info("Check for completion")
+      url = rest_endpoint("/journal-runs/#{jrNumber}")
+      uri = URI(url)
+      req = Net::HTTP::Get.new(uri,initheader = {'Content-Type' =>'application/json'})
+      req["Authorization"] = self.get_session(prefix: true)
+
+      response = Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
+        http.request req
+      end
+
+      result = JSON.parse(response.body)
+      if result["success"]
+        if !(result["status"].eql? "Completed")
+          sleep(20.seconds)
+        end
+        return result["status"]
+      else
+        message = result["reasons"][0]["message"]
+        Rails.logger.info("Checking status of journal run failed with message #{message}")
+      end
+      return "failure"
+    end
+  end
+end