netsuite-soap 2025.2.3

data/lib/netsuite/support/search_result.rb

@@ -0,0 +1,150 @@
+module NetSuite
+  module Support
+    class SearchResult
+      attr_accessor :response
+
+      attr_reader :total_records
+      attr_reader :total_pages
+      attr_reader :current_page
+
+      # header from a basic customer search:
+
+      # <platformCore:searchResult xmlns:platformCore="urn:core_2012_1.platform.webservices.netsuite.com">
+      #   <platformCore:status isSuccess="true"/>
+      #   <platformCore:totalRecords>2770</platformCore:totalRecords>
+      #   <platformCore:pageSize>5</platformCore:pageSize>
+      #   <platformCore:totalPages>554</platformCore:totalPages>
+      #   <platformCore:pageIndex>1</platformCore:pageIndex>
+      #   <platformCore:searchId>WEBSERVICES_738944_SB2_03012013650784545962753432_28d96bd280</platformCore:searchId>
+
+      def initialize(response, result_class, credentials)
+        @result_class = result_class
+        @response = response
+        @credentials = credentials
+
+        @total_records = response.body[:total_records].to_i
+        @total_pages = response.body[:total_pages].to_i
+        @current_page = response.body[:page_index].to_i
+
+        if @total_records > 0
+          if response.body.has_key?(:record_list)
+            # basic search results
+
+            #  `recordList` node can contain several nested `record` nodes, only one node or be empty
+            #  so we have to handle all these cases:
+            #    * { record_list: nil }
+            #    * { record_list: { record: => {...} } }
+            #    * { record_list: { record: => [{...}, {...}, ...] } }
+            record_list = if response.body[:record_list].nil?
+              []
+            elsif response.body[:record_list][:record].is_a?(Array)
+              response.body[:record_list][:record]
+            else
+              [response.body[:record_list][:record]]
+            end
+
+            record_list.each do |record|
+              results << result_class.new(record)
+            end
+          elsif response.body.has_key? :search_row_list
+            # advanced search results
+            record_list = response.body[:search_row_list]
+            record_list = record_list ? record_list[:search_row] : []
+            record_list = [record_list] unless record_list.is_a?(Array)
+
+            record_list.each do |record|
+              record.each_pair do |search_group, search_data|
+                # skip all attributes: look for :basic and all :xxx_join
+                next if search_group.to_s.start_with?('@')
+
+                record[search_group].each_pair do |k, v|
+                  # all return values are wrapped in a <SearchValue/>
+                  # extract the value from <SearchValue/> to make results easier to work with
+
+                  if k == :custom_field_list
+                    # Here's an example of a response
+
+                    # <platformCommon:customFieldList>
+                    #   <platformCore:customField internalId="1756" scriptId="custitem_stringfield" xsi:type="platformCore:SearchColumnStringCustomField">
+                    #     <platformCore:searchValue>sample string value</platformCore:searchValue>
+                    #   </platformCore:customField>
+                    #   <platformCore:customField internalId="1713" scriptId="custitem_apcategoryforsales" xsi:type="platformCore:SearchColumnSelectCustomField">
+                    #     <platformCore:searchValue internalId="4" typeId="464"/>
+                    #   </platformCore:customField>
+                    # </platformCommon:customFieldList>
+
+                    custom_field_list = v.fetch(:custom_field)
+                    custom_field_list = [custom_field_list] unless custom_field_list.is_a?(Array)
+                    record[search_group][k][:custom_field] = custom_field_list.map do |custom_field|
+                      custom_field[:value] = custom_field.fetch(:search_value)
+                      custom_field
+                    end
+                  elsif v.is_a?(Hash) && v.has_key?(:search_value)
+                    # Here's an example of a record ref and string response
+
+                    # <platformCommon:entity>
+                    #   <platformCore:searchValue internalId="446515"/>
+                    # </platformCommon:entity>
+                    # <platformCommon:status>
+                    #   <platformCore:searchValue>open</platformCore:searchValue>
+                    # </platformCommon:status>
+
+                    # in both cases, header-level field's value should be set to the
+                    # child `searchValue` result: if it's a record ref, the internalId
+                    # attribute will be transitioned to the parent, and in the case
+                    # of a string response the parent node's value will be to the string
+
+                    record[search_group][k] = v[:search_value]
+                  else
+                    # NOTE need to understand this case more, in testing, only the namespace definition hits this condition
+                  end
+                end
+              end
+
+              if record[:basic][:internal_id]
+                record[:basic][:internal_id] = record[:basic][:internal_id][:@internal_id]
+              end
+
+              if record[:basic][:external_id]
+                record[:basic][:external_id] = record[:basic][:external_id][:@external_id]
+              end
+
+              result_wrapper = result_class.new(record.delete(:basic))
+              result_wrapper.search_joins = record
+              results << result_wrapper
+            end
+          else
+            raise "uncaught search result"
+          end
+        end
+      end
+
+      def results
+        @results ||= []
+      end
+
+      def results_in_batches
+        return if self.total_records.zero?
+
+        while @response.body[:total_pages] != @response.body[:page_index]
+          yield results
+
+          next_search = @result_class.search(
+            {
+              search_id: @response.body[:search_id],
+              page_index: @response.body[:page_index].to_i + 1
+            },
+            @credentials
+          )
+
+          @results = next_search.results
+          @response = next_search.response
+          @current_page = response.body[:page_index].to_i
+        end
+
+        yield results
+      end
+
+    end
+  end
+end

data/lib/netsuite/support/sublist.rb

@@ -0,0 +1,71 @@
+module NetSuite
+  module Support
+    class Sublist
+      include Support::Fields
+
+      def self.inherited(subclass)
+        subclass.class_eval do
+          field :replace_all
+        end
+      end
+
+      class << self
+
+        def sublist(key, klass)
+          fields << key.to_sym
+
+          # TODO setting class methods might be better? How to reach into the subclass?
+
+          define_method(:sublist_key) { key }
+          define_method(:sublist_class) { klass }
+
+          define_method("#{key}=") do |list|
+            self.process_sublist(list)
+          end
+
+          define_method("#{key}") do
+            @list ||= []
+          end
+        end
+
+      end
+
+      def initialize(attributes = {})
+        initialize_from_attributes_hash(attributes || {})
+      end
+
+      def to_record
+        rec = { "#{record_namespace}:#{NetSuite::Utilities::Strings.lower_camelcase(sublist_key.to_s)}" => send(self.sublist_key).map(&:to_record) }
+
+        if !replace_all.nil?
+          rec["#{record_namespace}:replaceAll"] = !!replace_all
+        end
+
+        rec
+      end
+
+      def <<(item)
+        @list ||= []
+        @list << self.process_sublist_item(item)
+      end
+
+      protected
+        def process_sublist(list)
+          list = [ list ] if !list.is_a?(Array)
+
+          @list = list.map do |item|
+            self.process_sublist_item(item)
+          end
+        end
+
+        def process_sublist_item(item)
+          if item.class == self.sublist_class
+            item
+          else
+            self.sublist_class.new(item)
+          end
+        end
+
+    end
+  end
+end

data/lib/netsuite/utilities/data_center.rb

@@ -0,0 +1,53 @@
+module NetSuite
+  module Utilities
+    class DataCenter
+      class << self
+
+        def clear_cache!
+          @cache = {}
+        end
+
+        def get(netsuite_account, opts = {})
+          if opts[:cache] && wsdl=fetch_from_cache(netsuite_account)
+            return wsdl
+          end
+
+          response = make_data_center_call(netsuite_account)
+          if response.success?
+            wsdl = extract_wsdl_from_response(response)
+            cache[netsuite_account.to_s] = wsdl if opts[:cache]
+            return wsdl
+          else
+            return nil
+          end
+        end
+
+        private
+
+          def cache
+            @cache ||= {}
+          end
+
+          def make_data_center_call(netsuite_account)
+            NetSuite::Client.call(:get_data_center_urls, message: {
+              'platformMsgs:account' => netsuite_account
+            }, credentials: { email: '', password: '', account: '' })
+            # allow errors to bubble up, log if patterns emerge
+          end
+
+          def fetch_from_cache(netsuite_account)
+            return cache.fetch(netsuite_account.to_s, nil)
+          end
+
+          def extract_wsdl_from_response(response)
+            response.body
+              .fetch(:get_data_center_urls_response)
+              .fetch(:get_data_center_urls_result)
+              .fetch(:data_center_urls)
+              .fetch(:webservices_domain)
+          end
+
+      end
+    end
+  end
+end

data/lib/netsuite/utilities/strings.rb

@@ -0,0 +1,15 @@
+module NetSuite
+  module Utilities
+    module Strings
+      class << self
+        def lower_camelcase(obj)
+          str = obj.is_a?(String) ? obj.dup : obj.to_s
+          str.gsub!(/\/(.?)/) { "::#{$1.upcase}" }
+          str.gsub!(/[-_]+([a-z0-9])/) { $1.upcase }
+          str.gsub!(/(\A|\s)([A-Z])/) { $1 + $2.downcase }
+          str
+        end
+      end
+    end
+  end
+end

data/lib/netsuite/utilities.rb

@@ -0,0 +1,324 @@
+require 'date'
+
+module NetSuite
+  module Utilities
+    extend self
+
+    # TODO need structured logger for various statements
+
+    def clear_cache!
+      if NetSuite::Configuration.multi_tenant?
+        Thread.current[:netsuite_gem_netsuite_get_record_cache] = {}
+        Thread.current[:netsuite_gem_netsuite_find_record_cache] = {}
+      else
+        @netsuite_get_record_cache = {}
+        @netsuite_find_record_cache = {}
+      end
+
+      DataCenter.clear_cache!
+    end
+
+    def netsuite_get_record_cache
+      if NetSuite::Configuration.multi_tenant?
+        Thread.current[:netsuite_gem_netsuite_get_record_cache] ||= {}
+      else
+        @netsuite_get_record_cache ||= {}
+      end
+    end
+
+    def netsuite_find_record_cache
+      if NetSuite::Configuration.multi_tenant?
+        Thread.current[:netsuite_gem_netsuite_find_record_cache] ||= {}
+      else
+        @netsuite_find_record_cache ||= {}
+      end
+    end
+
+    def append_memo(ns_record, added_memo, opts = {})
+      opts[:skip_if_exists] ||= false
+
+      memo_key = if ns_record.class == NetSuite::Records::Customer
+        :comments
+      else
+        :memo
+      end
+
+      return if opts[:skip_if_exists] &&
+        ns_record.send(memo_key) &&
+        ns_record.send(memo_key).include?(added_memo)
+
+      if ns_record.send(memo_key)
+        ns_record.send(:"#{memo_key}=", "#{ns_record.send(memo_key)}. #{added_memo}")
+      else
+        ns_record.send(:"#{memo_key}=", added_memo.to_s)
+      end
+
+      ns_record
+    end
+
+    def netsuite_server_time(credentials={})
+      server_time_response = NetSuite::Utilities.backoff { NetSuite::Client.call(:get_server_time, message: {}, credentials: credentials) }
+      server_time_response.body[:get_server_time_response][:get_server_time_result][:server_time]
+    end
+
+    def netsuite_data_center_urls(account_id, credentials={})
+      data_center_call_response = NetSuite::Client.call(:get_data_center_urls, message: {
+        'platformMsgs:account' => account_id
+      }, request_options: {
+        # NOTE force a production WSDL so the sandbox settings are ignored
+        wsdl: 'https://webservices.netsuite.com/wsdl/v2025_2_0/netsuite.wsdl',
+        namespaces: { 'xmlns:platformCore' => "urn:core_2025_2.platform.webservices.netsuite.com" },
+        soap_header: {}
+      }, credentials: credentials)
+
+      if data_center_call_response.success?
+        data_center_call_response.body[:get_data_center_urls_response][:get_data_center_urls_result][:data_center_urls]
+      else
+        false
+      end
+    end
+
+    # TODO consider what to dop with this duplicate data center implementation
+    def data_center_url(*args)
+      DataCenter.get(*args)
+    end
+
+    def backoff(options = {})
+      # TODO the default backoff attempts should be customizable the global config
+      options[:attempts] ||= 8
+
+      count = 0
+
+      begin
+        count += 1
+        yield
+      rescue StandardError => e
+        exceptions_to_retry = [
+          Errno::ECONNRESET,
+          Errno::ETIMEDOUT,
+          Errno::EHOSTUNREACH,
+          EOFError,
+          Wasabi::Resolver::HTTPError,
+          Savon::SOAPFault,
+          Savon::InvalidResponseError,
+          Zlib::BufError,
+          Savon::HTTPError,
+          SocketError,
+          Net::OpenTimeout
+        ]
+
+        # available in ruby > 1.9
+        if defined?(Net::ReadTimeout)
+          exceptions_to_retry << Net::ReadTimeout
+        end
+
+        # available in ruby > 2.2.0
+        exceptions_to_retry << IO::EINPROGRESSWaitWritable if defined?(IO::EINPROGRESSWaitWritable)
+        exceptions_to_retry << OpenSSL::SSL::SSLErrorWaitReadable if defined?(OpenSSL::SSL::SSLErrorWaitReadable)
+
+        # depends on the http library chosen
+        exceptions_to_retry << HTTPI::SSLError if defined?(HTTPI::SSLError)
+        exceptions_to_retry << HTTPI::TimeoutError if defined?(HTTPI::TimeoutError)
+        exceptions_to_retry << HTTPClient::TimeoutError if defined?(HTTPClient::TimeoutError)
+        exceptions_to_retry << HTTPClient::ConnectTimeoutError if defined?(HTTPClient::ConnectTimeoutError)
+        exceptions_to_retry << HTTPClient::ReceiveTimeoutError if defined?(HTTPClient::ReceiveTimeoutError)
+        exceptions_to_retry << HTTPClient::SendTimeoutError if defined?(HTTPClient::SendTimeoutError)
+        exceptions_to_retry << Excon::Error::Timeout if defined?(Excon::Error::Timeout)
+        exceptions_to_retry << Excon::Error::Socket if defined?(Excon::Error::Socket)
+
+        if !exceptions_to_retry.include?(e.class)
+          raise
+        end
+
+        # whitelist certain SOAPFaults; all other network errors should automatically retry
+        if e.is_a?(Savon::SOAPFault)
+          # https://github.com/stripe/stripe-netsuite/issues/815
+          if !e.message.include?("Only one request may be made against a session at a time") &&
+            !e.message.include?('java.util.ConcurrentModificationException') &&
+            !e.message.include?('java.lang.NullPointerException') &&
+            !e.message.include?('java.lang.IllegalStateException') &&
+            !e.message.include?('java.lang.reflect.InvocationTargetException') &&
+            !e.message.include?('com.netledger.common.exceptions.NLDatabaseOfflineException') &&
+            !e.message.include?('com.netledger.database.NLConnectionUtil$NoCompanyDbsOnlineException') &&
+            !e.message.include?('com.netledger.cache.CacheUnavailableException') &&
+            !e.message.include?('java.lang.IllegalStateException') &&
+            !e.message.include?('An unexpected error occurred.') &&
+            !e.message.include?('An unexpected error has occurred.  Technical Support has been alerted to this problem.') &&
+            !e.message.include?('Session invalidation is in progress with different thread') &&
+            !e.message.include?('[missing resource APP:ERRORMESSAGE:WS_AN_UNEXPECTED_ERROR_OCCURRED] [missing resource APP:ERRORMESSAGE:ERROR_ID_1]') &&
+            !e.message.include?('SuiteTalk concurrent request limit exceeded. Request blocked.') &&
+            # maintenance is the new outage: this message is being used for intermittent errors
+            !e.message.include?('The account you are trying to access is currently unavailable while we undergo our regularly scheduled maintenance.') &&
+            !e.message.include?('The Connection Pool is not intialized.') &&
+            # it looks like NetSuite mispelled their error message...
+            !e.message.include?('The Connection Pool is not intiialized.')
+            raise
+          end
+        end
+
+        if count >= options[:attempts]
+          raise
+        end
+
+        # log.warn("concurrent request failure", sleep: count, attempt: count)
+        sleep(count)
+
+        retry
+      end
+    end
+
+    def request_failed?(ns_object)
+      return false if ns_object.errors.nil? || ns_object.errors.empty?
+      ns_object.errors.any? { |x| x.type == "ERROR" }
+    end
+
+    def get_field_options(recordType, fieldName)
+      options = NetSuite::Records::BaseRefList.get_select_value(
+        field: fieldName,
+        recordType: recordType
+      )
+
+      options.base_refs
+    end
+
+    def get_item(ns_item_internal_id, opts = {})
+      # TODO add additional item types!
+      ns_item = NetSuite::Utilities.get_record(NetSuite::Records::InventoryItem, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::AssemblyItem, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::NonInventorySaleItem, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::NonInventoryResaleItem, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::DiscountItem, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::OtherChargeSaleItem, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::ServiceSaleItem, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::ServiceResaleItem, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::GiftCertificateItem, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::KitItem, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::ItemGroup, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::SerializedInventoryItem, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::SerializedAssemblyItem, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::LotNumberedAssemblyItem, ns_item_internal_id, opts)
+      ns_item ||= NetSuite::Utilities.get_record(NetSuite::Records::LotNumberedInventoryItem, ns_item_internal_id, opts)
+
+      if ns_item.nil?
+        fail NetSuite::RecordNotFound, "item with ID #{ns_item_internal_id} not found"
+      end
+
+      ns_item
+    end
+
+    def get_record(record_klass, id, opts = {})
+      opts[:external_id] ||= false
+
+      if opts[:cache]
+        netsuite_get_record_cache[record_klass.to_s] ||= {}
+
+        if netsuite_get_record_cache[record_klass.to_s].has_key?(id.to_i)
+          return netsuite_get_record_cache[record_klass.to_s][id.to_i]
+        end
+      end
+
+      begin
+        # log.debug("get record", netsuite_record_type: record_klass.name, netsuite_record_id: id)
+
+        ns_record = if opts[:external_id]
+          backoff { record_klass.get(external_id: id) }
+        else
+          backoff { record_klass.get(id) }
+        end
+
+        if opts[:cache]
+          netsuite_get_record_cache[record_klass.to_s][id.to_i] = ns_record
+        end
+
+        return ns_record
+      rescue ::NetSuite::RecordNotFound
+        # log.warn("record not found", ns_record_type: record_klass.name, ns_record_id: id)
+        if opts[:cache]
+          netsuite_get_record_cache[record_klass.to_s][id.to_i] = nil
+        end
+
+        return nil
+      end
+    end
+
+    def find_record(record, names, opts = {})
+      field_name = opts[:field_name]
+
+      names = [ names ] if names.is_a?(String)
+
+      # FIXME: Records that have the same name but different types will break
+      # the cache
+      names.each do |name|
+        if netsuite_find_record_cache.has_key?(name)
+          return netsuite_find_record_cache[name]
+        end
+
+        # sniff for an email-like input; useful for employee/customer searches
+        if !field_name && /@[^@]+\./ =~ name
+          field_name = 'email'
+        end
+
+        field_name ||= if record.to_s.end_with?('Item')
+          'displayName'
+        else
+          'name'
+        end
+
+        # TODO remove backoff when it's built-in to search
+        search = backoff { record.search({
+          basic: [
+            {
+              field: field_name,
+              operator: 'contains',
+              value: name,
+            }
+          ]
+        }) }
+
+        if search.results.first
+          return netsuite_find_record_cache[name] = search.results.first
+        end
+      end
+
+      nil
+    end
+
+    # http://mikebian.co/notes-on-dates-timezones-with-netsuites-suitetalk-api/
+    # https://wyeworks.com/blog/2016/6/22/behavior-changes-in-ruby-2.4
+    # https://github.com/rails/rails/commit/c9c5788a527b70d7f983e2b4b47e3afd863d9f48
+
+    # assumes UTC0 unix timestamp
+    def normalize_time_to_netsuite_date(unix_timestamp)
+      # convert to date to eliminate hr/min/sec
+      time = Time.at(unix_timestamp).
+        utc.
+        to_date.
+        to_datetime
+
+      # tzinfo allows us to determine the dst status of the time being passed in
+      # NetSuite requires that the time be passed to the API with the PDT TZ offset
+      # of the time passed in (i.e. not the current TZ offset of PDT)
+
+      if defined?(TZInfo)
+        # if no version is defined, less than 2.0
+        # https://github.com/tzinfo/tzinfo/blob/master/CHANGES.md#added
+        if !defined?(TZInfo::VERSION)
+          # https://stackoverflow.com/questions/2927111/ruby-get-time-in-given-timezone
+          offset = TZInfo::Timezone.get("America/Los_Angeles").period_for_utc(time).utc_total_offset_rational
+          time = time.new_offset(offset)
+        else
+          time = TZInfo::Timezone.get("America/Los_Angeles").utc_to_local(time)
+          offset = time.offset
+        end
+      else
+        # if tzinfo is not installed, let's give it our best guess: -7
+        offset = Rational(-7, 24)
+        time = time.new_offset("-07:00")
+      end
+
+      time = (time + (offset * -1))
+      time.iso8601
+    end
+
+  end
+end

data/lib/netsuite/version.rb

@@ -0,0 +1,3 @@
+module NetSuite
+  VERSION = '2025.2.3'
+end