netsuite-soap 2025.2.3

data/lib/netsuite/actions/get_list.rb

@@ -0,0 +1,98 @@
+# https://system.netsuite.com/help/helpcenter/en_US/Output/Help/SuiteCloudCustomizationScriptingWebServices/SuiteTalkWebServices/getList.html
+module NetSuite
+  module Actions
+    class GetList < AbstractAction
+      include Support::Requests
+
+      def initialize(klass, options = { })
+        @klass = klass
+        @options = options
+      end
+
+      private
+
+      def request_body
+        # list of all netsuite types; useful for debugging
+        # https://webservices.netsuite.com/xsd/platform/v2025_2_0/coreTypes.xsd
+
+        list = @options.is_a?(Hash) ? @options[:list] : @options
+
+        formatted_list = if @options.is_a?(Hash) && @options[:type_id]
+          type = @options[:type_id]
+          record_type = 'platformCore:CustomRecordRef'
+
+          list.map do |internal_id|
+            {
+              '@internalId' => internal_id,
+              '@typeId' => type,
+              '@xsi:type' => record_type
+            }
+          end
+        else
+          type = NetSuite::Support::Records.netsuite_type(@klass)
+          record_type = 'platformCore:RecordRef'
+
+          list.map do |internal_id|
+            {
+              '@internalId' => internal_id,
+              '@type' => type,
+              '@xsi:type' => record_type
+            }
+          end
+        end
+
+        {
+          baseRef: formatted_list
+        }
+      end
+
+      def response_header
+        @response_header ||= response_header_hash
+      end
+
+      def response_header_hash
+        @response_header_hash = @response.header[:document_info]
+      end
+
+      def response_body
+        @response_body ||= @response.body[:get_list_response][:read_response_list][:read_response]
+        @response_body = [@response_body] unless @response_body.is_a? Array
+        @response_body
+      end
+
+      def action_name
+        :get_list
+      end
+
+      def success?
+        # each returned record has its own status; 
+        if @options.is_a?(Hash) && @options[:allow_incomplete]
+          @success ||= !response_body.detect { |r| r[:status][:@is_success] == 'true' }.nil?
+        else
+          @success ||= response_body.detect { |r| r[:status][:@is_success] != 'true' }.nil?
+        end
+      end
+
+      module Support
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def get_list(options = { }, credentials={})
+            response = NetSuite::Actions::GetList.call([self, options], credentials)
+
+            if response.success?
+              response.body.inject([]) do |arr, record|
+                arr << new(record[:record]) unless record[:status][:@is_success] != 'true'
+                arr
+              end
+            else
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/netsuite/actions/get_select_value.rb

@@ -0,0 +1,80 @@
+# https://system.netsuite.com/help/helpcenter/en_US/Output/Help/SuiteCloudCustomizationScriptingWebServices/SuiteTalkWebServices/getSelectValue.html
+module NetSuite
+  module Actions
+    class GetSelectValue < AbstractAction
+      include Support::Requests
+
+      def initialize(klass, options = {})
+        @klass   = klass
+        @options = options
+      end
+
+      private
+
+      def request_body
+        @options
+      end
+
+      def success?
+        @success ||= response_hash[:status][:@is_success] == 'true'
+      end
+
+      def response_body
+        @response_body ||= response_hash[:base_ref_list]
+      end
+
+      def response_hash
+        @response_hash = @response.body[:get_select_value_response][:get_select_value_result]
+      end
+
+      def request_options
+        {
+          namespaces: {
+            'xmlns:platformMsgs' => "urn:messages_#{NetSuite::Configuration.api_version}.platform.webservices.netsuite.com",
+            'xmlns:platformCore' => "urn:core_#{NetSuite::Configuration.api_version}.platform.webservices.netsuite.com"
+          }
+        }
+      end
+
+      def action_name
+        :get_select_value
+      end
+
+      module Support
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+
+          def get_select_value(options = {}, credentials={})
+            message = {
+              pageIndex: (options.delete(:pageIndex) || 1),
+              fieldDescription: field_description(options)
+            }
+
+            response = NetSuite::Actions::GetSelectValue.call([self, message], credentials)
+
+            if response.success?
+              new(response.body)
+            else
+              raise RecordNotFound, "#{self} with OPTIONS=#{options.inspect} could not be found"
+            end
+          end
+
+          private
+            # TODO this goes against the design of the rest of the gem; should be removed in the future
+            def field_description(options)
+              options.inject({}) do |h, (k, v)|
+                h["platformCore:#{k}"] = v
+                h
+              end
+            end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/netsuite/actions/initialize.rb

@@ -0,0 +1,86 @@
+# https://system.netsuite.com/help/helpcenter/en_US/Output/Help/SuiteCloudCustomizationScriptingWebServices/SuiteTalkWebServices/initializeinitializeList.html
+module NetSuite
+  module Actions
+    class Initialize < AbstractAction
+      include Support::Requests
+
+      def initialize(klass, object)
+        @klass  = klass
+        @object = object
+      end
+
+      # <platformMsgs:initializeRecord>
+      #   <platformCore:type>invoice</platformCore:type>
+      #   <platformCore:reference internalId="1513" type="salesOrder">
+      #     <platformCore:name>1511</platformCore:name>
+      #   </platformCore:reference>
+      # </platformMsgs:initializeRecord>
+      def request_body
+        {
+          'platformMsgs:initializeRecord' => {
+            'platformCore:type'      => NetSuite::Support::Records.netsuite_type(@klass),
+            'platformCore:reference' => {},
+            :attributes!             => {
+              'platformCore:reference' => {
+                'internalId' => @object.internal_id,
+                :type        => NetSuite::Support::Records.netsuite_type(@object)
+              }
+            }
+          }
+        }
+      end
+
+      def response_hash
+        @response_hash ||= @response.to_hash[:initialize_response][:read_response]
+      end
+
+      def success?
+        @success ||= response_hash[:status][:@is_success] == 'true'
+      end
+
+      def response_body
+        @response_body ||= response_hash[:record]
+      end
+
+      def request_options
+        {
+          namespaces: {
+            'xmlns:platformMsgs'    => "urn:messages_#{NetSuite::Configuration.api_version}.platform.webservices.netsuite.com",
+            'xmlns:platformCore'    => "urn:core_#{NetSuite::Configuration.api_version}.platform.webservices.netsuite.com",
+            'xmlns:platformCoreTyp' => "urn:types.core_#{NetSuite::Configuration.api_version}.platform.webservices.netsuite.com",
+          }
+        }
+      end
+
+      def action_name
+        :initialize
+      end
+
+      module Support
+
+        def self.included(base)
+          (class << base; self; end).instance_eval do # We have to do this because Class has a private
+            define_method :initialize do |*args|      # #initialize method that this method will override.
+              super(*args)
+            end
+          end
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+
+          def initialize(object, credentials={})
+            response = NetSuite::Actions::Initialize.call([self, object], credentials)
+            if response.success?
+              new(response.body)
+            else
+              raise InitializationError, "#{self}.initialize with #{object} failed."
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/netsuite/actions/search.rb

@@ -0,0 +1,265 @@
+# https://system.netsuite.com/help/helpcenter/en_US/Output/Help/SuiteCloudCustomizationScriptingWebServices/SuiteTalkWebServices/search.html
+module NetSuite
+  module Actions
+    class Search < AbstractAction
+      include Support::Requests
+
+      def initialize(klass, options = { })
+        @klass = klass
+        @options = options
+      end
+
+      def class_name
+        @class_name ||= if @klass.respond_to? :search_class_name
+          @klass.search_class_name
+        else
+          @klass.to_s.split("::").last
+        end
+      end
+
+      private
+      # basic search XML
+
+      # <soap:Body>
+      # <platformMsgs:search>
+      # <searchRecord xsi:type="ContactSearch">
+      #   <customerJoin xsi:type="CustomerSearchBasic">
+      #     <email operator="contains" xsi:type="platformCore:SearchStringField">
+      #     <platformCore:searchValue>shutterfly.com</platformCore:searchValue>
+      #     <email>
+      #   <customerJoin>
+      # </searchRecord>
+      # </search>
+      # </soap:Body>
+
+      def request_body
+        if @options.has_key?(:search_id)
+          return {
+            'pageIndex' => @options[:page_index],
+            'searchId' => @options[:search_id],
+          }
+        end
+
+        # columns is only needed for advanced search results
+        columns = @options[:columns] || {}
+        criteria = @options[:criteria] || @options
+
+        # TODO find cleaner solution for pulling the namespace of the record, which is a instance method
+        namespace = if @klass.respond_to?(:search_class_namespace)
+          @klass.search_class_namespace
+        else
+          @klass.new.record_namespace
+        end
+
+        # extract the class name
+
+        criteria_structure = {}
+        columns_structure = columns
+        saved_search_id = criteria.delete(:saved)
+        criteria.delete(:preferences) # consumed later by soap_header_extra_info
+
+        # TODO this whole thing needs to be refactored so we can apply some of the same logic to the
+        #      column creation xml
+
+        criteria.each_pair do |condition_category, conditions|
+          criteria_structure["#{namespace}:#{condition_category}"] = conditions.inject({}) do |h, condition|
+            element_name = "platformCommon:#{condition[:field]}"
+
+            case condition[:field]
+            when 'recType'
+              # TODO this seems a bit brittle, look into a way to handle this better
+              h[element_name] = {
+                :@internalId => condition[:value].internal_id
+              }
+            when 'customFieldList'
+              # === START CUSTOM FIELD
+
+              # there isn't a clean way to do lists of the same element
+              # Gyoku doesn't seem support the nice :@attribute and :content! syntax for lists of elements of the same name
+              # https://github.com/savonrb/gyoku/issues/18#issuecomment-17825848
+
+              # TODO with the latest version of savon we can easily improve the code here, should be rewritten with new attribute syntax
+
+              custom_field_list = condition[:value].map do |h|
+                if h[:value].is_a?(Array) && h[:value].first.respond_to?(:to_record)
+                  {
+                    "platformCore:searchValue" => h[:value].map(&:to_record),
+                    :attributes! => {
+                      'platformCore:searchValue' => {
+                        'internalId' => h[:value].map(&:internal_id)
+                      }
+                    }
+                  }
+                elsif h[:value].respond_to?(:to_record)
+                  {
+                    "platformCore:searchValue" => {
+                      :content! => h[:value].to_record,
+                      :@internalId => h[:value].internal_id
+                    }
+                  }
+                else
+                  { "platformCore:searchValue" => h[:value] }
+                end
+              end
+
+              h[element_name] = {
+                'platformCore:customField' => custom_field_list,
+                :attributes! => {
+                  'platformCore:customField' => {
+                    'scriptId' => condition[:value].map { |h| h[:field] },
+                    'operator' => condition[:value].map { |h| h[:operator] },
+                    'xsi:type' => condition[:value].map { |h| "platformCore:#{h[:type]}" }
+                  }
+                }
+              }
+
+              # https://github.com/NetSweet/netsuite/commit/54d7b011d9485dad33504135dfe8153c86cae9a0#commitcomment-8443976
+              if NetSuite::Configuration.api_version < "2013_2"
+                h[element_name][:attributes!]['platformCore:customField']['internalId'] = h[element_name][:attributes!]['platformCore:customField'].delete('scriptId')
+              end
+
+              # === END CUSTOM FIELD
+            else
+              if condition[:value].is_a?(Array) && condition[:value].first.respond_to?(:to_record)
+                # TODO need to update to the latest savon so we don't need to duplicate the same workaround above again
+                # TODO it's possible that this might break, not sure if platformCore:SearchMultiSelectField is the right type in every situation
+
+                h[element_name] = {
+                  '@operator' => condition[:operator],
+                  '@xsi:type' => 'platformCore:SearchMultiSelectField',
+                  "platformCore:searchValue" => condition[:value].map do |value|
+                    search_value = {
+                      :content! => value.to_record,
+                      '@xsi:type' => 'platformCore:RecordRef',
+                      '@type' => 'account'
+                    }
+
+                    if value.internal_id
+                      search_value['@internalId'] = value.internal_id
+                    end
+
+                    if value.external_id
+                      search_value['@externalId'] = value.external_id
+                    end
+
+                    search_value
+                  end
+                }
+              elsif condition[:value].is_a?(Array) && condition[:type] == 'SearchDateField'
+                # date ranges are handled via searchValue (start range) and searchValue2 (end range)
+
+                h[element_name] = {
+                  '@operator' => condition[:operator],
+                  "platformCore:searchValue" => condition[:value].first.to_s,
+                  "platformCore:searchValue2" => condition[:value].last.to_s
+                }
+              elsif condition[:value].is_a?(Array) && condition[:operator] == 'between'
+
+                h[element_name] = {
+                  '@operator' => condition[:operator],
+                  "platformCore:searchValue" => condition[:value].first.to_s,
+                  "platformCore:searchValue2" => condition[:value].last.to_s
+                }
+              else
+                h[element_name] = {
+                  :content! => { "platformCore:searchValue" => condition[:value] },
+                }
+
+                h[element_name][:@operator] = condition[:operator] if condition[:operator]
+              end
+            end
+
+            h
+          end
+        end
+
+        if saved_search_id || !columns_structure.empty?
+          search_structure = {
+            'searchRecord' => {
+              '@xsi:type' => "#{namespace}:#{class_name}SearchAdvanced",
+              :content! => {
+                "#{namespace}:criteria" => criteria_structure
+              }
+            }
+          }
+
+          if saved_search_id
+            search_structure['searchRecord']['@savedSearchId'] = saved_search_id
+          end
+
+          if !columns_structure.empty?
+            search_structure['searchRecord'][:content!]["#{namespace}:columns"] = columns_structure
+          end
+
+          search_structure
+        else
+          {
+            'searchRecord' => {
+              :content! => criteria_structure,
+              '@xsi:type' => "#{namespace}:#{class_name}Search"
+            }
+          }
+        end
+      end
+
+      def response_header
+        @response_header ||= response_header_hash
+      end
+
+      def response_header_hash
+        @response_header_hash = @response.header[:document_info]
+      end
+
+      def response_body
+        @response_body ||= search_result
+      end
+
+      def search_result
+        @search_result = if @response.body.has_key?(:search_more_with_id_response)
+          @response.body[:search_more_with_id_response]
+        else
+          @response.body[:search_response]
+        end[:search_result]
+      end
+
+      def action_name
+        @options.has_key?(:search_id)? :search_more_with_id : :search
+      end
+
+      def soap_header_extra_info
+        # https://system.netsuite.com/help/helpcenter/en_US/Output/Help/SuiteCloudCustomizationScriptingWebServices/SuiteTalkWebServices/SettingSearchPreferences.html
+        # https://webservices.netsuite.com/xsd/platform/v2025_2_0/messages.xsd
+
+        (@options.delete(:preferences) || {})
+          .inject({'platformMsgs:SearchPreferences' => {}}) do |h, (k, v)|
+            h['platformMsgs:SearchPreferences'][NetSuite::Utilities::Strings.lower_camelcase(k.to_s)] = v
+            h
+          end
+      end
+
+      def success?
+        @success ||= search_result[:status][:@is_success] == 'true'
+      end
+
+      module Support
+        attr_accessor :search_joins
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def search(options = { }, credentials={})
+            response = NetSuite::Actions::Search.call([self, options], credentials)
+
+            if response.success?
+              NetSuite::Support::SearchResult.new(response, self, credentials)
+            else
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/netsuite/actions/update.rb

@@ -0,0 +1,86 @@
+# https://system.netsuite.com/help/helpcenter/en_US/Output/Help/SuiteCloudCustomizationScriptingWebServices/SuiteTalkWebServices/update.html
+module NetSuite
+  module Actions
+    class Update < AbstractAction
+      include Support::Requests
+
+      def initialize(klass, attributes)
+        @klass      = klass
+        @attributes = attributes
+      end
+
+      # <platformMsgs:update>
+      #   <platformMsgs:record internalId="980" xsi:type="listRel:Customer">
+      #     <listRel:companyName>Shutter Fly Corporation</listRel:companyName>
+      #   </platformMsgs:record>
+      # </platformMsgs:update>
+      def request_body
+        hash = {
+          'platformMsgs:record' => {
+            :content! => updated_record.to_record,
+            '@xsi:type' => updated_record.record_type
+          }
+        }
+
+        if updated_record.respond_to?(:internal_id) && updated_record.internal_id
+          hash['platformMsgs:record']['@platformMsgs:internalId'] = updated_record.internal_id
+        end
+
+        if updated_record.respond_to?(:external_id) && updated_record.external_id
+          hash['platformMsgs:record']['@platformMsgs:externalId'] = updated_record.external_id
+        end
+
+        hash
+      end
+
+      def updated_record
+        @updated_record ||= @klass.new(@attributes)
+      end
+
+      def success?
+        @success ||= response_hash[:status][:@is_success] == 'true'
+      end
+
+      def response_body
+        @response_body ||= response_hash[:base_ref]
+      end
+
+      def response_errors
+        if response_hash[:status] && response_hash[:status][:status_detail]
+          @response_errors ||= errors
+        end
+      end
+
+      def response_hash
+        @response_hash ||= @response.to_hash[:update_response][:write_response]
+      end
+
+      def errors
+        error_obj = response_hash[:status][:status_detail]
+        error_obj = [error_obj] if error_obj.class == Hash
+        error_obj.map do |error|
+          NetSuite::Error.new(error)
+        end
+      end
+
+      def action_name
+        :update
+      end
+
+      module Support
+        def update(options = {}, credentials={})
+          options[:internal_id] = internal_id if respond_to?(:internal_id) && internal_id
+
+          if !options.include?(:external_id) && (respond_to?(:external_id) && external_id)
+            options[:external_id] = external_id
+          end
+
+          response = NetSuite::Actions::Update.call([self.class, options], credentials)
+          @errors = response.errors
+          response.success?
+        end
+      end
+
+    end
+  end
+end