netsuite 0.7.1 → 0.7.2

data/lib/netsuite/records/inventory_transfer_inventory_list.rb

@@ -1,33 +1,12 @@
 module NetSuite
   module Records
-    class InventoryTransferInventoryList
+    class InventoryTransferInventoryList < Support::Sublist
       include Support::RecordRefs
       include Support::Records
-      include Support::Fields
       include Namespaces::TranInvt
 
-      fields :inventory
+      sublist :inventory, InventoryTransferInventory
 
-      def initialize(attributes = {})
-        initialize_from_attributes_hash(attributes)
-      end
-
-      def inventory=(items)
-        case items
-        when Hash
-          self.inventory << InventoryTransferInventory.new(items)
-        when Array
-          items.each { |item| self.inventory << InventoryTransferInventory.new(item) }
-        end
-      end
-
-      def inventory
-        @inventory ||= []
-      end
-
-      def to_record
-        { "#{record_namespace}:inventory" => inventory.map(&:to_record) }
-      end
     end
   end
 end

data/lib/netsuite/records/item_fulfillment_package_list.rb

@@ -1,11 +1,9 @@
 module NetSuite
   module Records
-    class ItemFulfillmentPackageList
-      include Support::Fields
-      include Support::Records
+    class ItemFulfillmentPackageList < Support::Sublist
       include Namespaces::TranSales
 
-      fields :package
+      sublist :package, ItemFulfillmentPackage
 
       def initialize(attributes = {})
         if attributes.keys != [:package] && attributes.first
@@ -32,22 +30,8 @@ module NetSuite
         initialize_from_attributes_hash(attributes)
       end
 
-      def package=(packages)
-        case packages
-        when Hash
-          self.packages << ItemFulfillmentPackage.new(packages)
-        when Array
-          packages.each { |package| self.packages << ItemFulfillmentPackage.new(package) }
-        end
-      end
+      alias :packages :package
 
-      def packages
-        @packages ||= []
-      end
-
-      def to_record
-        { "#{record_namespace}:package" => packages.map(&:to_record) }
-      end
     end
   end
 end

data/lib/netsuite/records/journal_entry_line_list.rb

@@ -1,31 +1,11 @@
 module NetSuite
   module Records
-    class JournalEntryLineList
-      include Support::Fields
+    class JournalEntryLineList < Support::Sublist
       include Namespaces::TranGeneral
-      
-      fields :line
 
-      def initialize(attributes = {})
-        initialize_from_attributes_hash(attributes)
-      end
+      sublist :line, JournalEntryLine
 
-      def line=(lines)
-        case lines
-        when Hash
-          self.lines << JournalEntryLine.new(lines)
-        when Array
-          lines.each { |line| self.lines << JournalEntryLine.new(line) }
-        end
-      end
-
-      def lines
-        @items ||= []
-      end
-
-      def to_record
-        { "#{record_namespace}:line" => lines.map(&:to_record) }
-      end
+      alias :lines :line
 
     end
   end

data/lib/netsuite/records/member_list.rb

@@ -1,32 +1,13 @@
 module NetSuite
   module Records
-    class MemberList
-      include Support::Fields
+    class MemberList < Support::Sublist
       include Support::Records
       include Namespaces::ListAcct
 
-      fields :replace_all, :item_member
+      fields :replace_all
 
-      def initialize(attrs = {})
-        initialize_from_attributes_hash(attrs)
-      end
+      sublist :item_member, ItemMember
 
-      def item_member=(items)
-        case items
-        when Hash
-          self.item_member << ItemMember.new(items)
-        when Array
-          items.each { |ref| self.item_member << ItemMember.new(ref) }
-        end
-      end
-
-      def item_member
-        @item_member ||= []
-      end
-
-      def to_record
-        { "#{record_namespace}:itemMember" => item_member.map(&:to_record) }
-      end
     end
   end
 end

data/lib/netsuite/records/other_charge_sale_item.rb

@@ -0,0 +1,73 @@
+module NetSuite
+  module Records
+    class OtherChargeSaleItem
+      include Support::Fields
+      include Support::RecordRefs
+      include Support::Records
+      include Support::Actions
+      include Namespaces::ListAcct
+
+      actions :get, :get_list, :add, :update, :delete, :upsert, :search
+
+      attr_reader   :internal_id
+      attr_accessor :external_id
+
+      fields :accounting_book_detail_list,
+        :available_to_partners,
+        :cost_estimate,
+        :cost_estimate_type,
+        :cost_estimate_units,
+        :created_date,
+        :display_name,
+        :enforce_min_qty_internally,
+        :include_children,
+        :is_fulfillable,
+        :is_gco_compliant,
+        :is_inactive,
+        :is_online,
+        :is_taxable,
+        :item_id,
+        :last_modified_date,
+        :minimum_quantity,
+        :minimum_quantity_units,
+        :offer_support,
+        :overall_quantity_pricing_type,
+        :prices_include_tax,
+        :pricing_group,
+        :purchase_tax_code,
+        :quantity_pricing_schedule,
+        :rate,
+        :sales_description,
+        :soft_descriptor,
+        :upc_code,
+        :use_marginal_rates,
+        :vsoe_deferral,
+        :vsoe_delivered,
+        :vsoe_permit_discount,
+        :vsoe_price,
+        :vsoe_sop_group
+
+      record_refs :billing_schedule, :klass, :cost_category, :custom_form, :deferred_revenue_account,
+                  :department, :income_account, :issue_product, :location, :matrix_type, :rev_rec_schedule,
+                  :units_type, :sales_tax_code, :sale_unit, :tax_schedule, :parent
+
+      field :custom_field_list, CustomFieldList
+      # :pricing_matrix,
+      # :translations_list,
+      # :matrix_option_list,
+      # :item_options_list
+      # :subsidiary_list,
+
+      def initialize(attributes = {})
+        @internal_id = attributes.delete(:internal_id) || attributes.delete(:@internal_id)
+        @external_id = attributes.delete(:external_id) || attributes.delete(:@external_id)
+        initialize_from_attributes_hash(attributes)
+      end
+
+      def self.search_class_name
+        "Item"
+      end
+
+    end
+  end
+end

data/lib/netsuite/records/record_ref_list.rb

@@ -1,28 +1,10 @@
 module NetSuite
   module Records
-    class RecordRefList
-      include Support::Fields
+    class RecordRefList < Support::Sublist
       include Support::Records
       include Namespaces::PlatformCore
 
-      fields :record_ref
-
-      def initialize(attrs = {})
-        initialize_from_attributes_hash(attrs)
-      end
-
-      def record_ref=(items)
-        case items
-        when Hash
-          self.record_ref << RecordRef.new(items)
-        when Array
-          items.each { |ref| self.record_ref << RecordRef.new(ref) }
-        end
-      end
-
-      def record_ref
-        @record_ref ||= []
-      end
+      sublist :record_ref, RecordRef
 
       def to_record
         {

data/lib/netsuite/records/units_type_uom_list.rb

@@ -1,31 +1,10 @@
 module NetSuite
   module Records
-    class UnitsTypeUomList
-      include Support::Fields
+    class UnitsTypeUomList < Support::Sublist
       include Namespaces::ListAcct
 
-      fields :uom
+      sublist :uom, UnitsTypeUom
 
-      def initialize(attributes = {})
-        initialize_from_attributes_hash(attributes)
-      end
-
-      def uom=(items)
-        case items
-        when Hash
-          self.uom << UnitsTypeUom.new(items)
-        when Array
-          items.each { |item| self.uom << UnitsTypeUom.new(item) }
-        end
-      end
-
-      def uom
-        @uom ||= []
-      end
-
-      def to_record
-        { "#{record_namespace}:uom" => uom.map(&:to_record) }
-      end
     end
   end
 end

data/lib/netsuite/records/vendor.rb

@@ -7,7 +7,7 @@ module NetSuite
       include Support::Actions
       include Namespaces::ListRel
 
-      actions :get, :get_list, :add, :update, :delete, :search
+      actions :get, :get_list, :add, :update, :upsert, :delete, :search
 
       fields :account_number, :alt_email, :alt_name, :alt_phone, :balance,
              :balance_primary, :bcn, :bill_pay, :comments, :company_name, :credit_limit,
@@ -25,6 +25,9 @@ module NetSuite
       # TODO should change name to VendorAddressBookList
       field :addressbook_list, CustomerAddressbookList
 
+      read_only_fields :balance_primary, :balance, :last_modified_date, :unbilled_orders,
+                       :unbilled_orders_primary
+
       record_refs :custom_form, :category, :image, :subsidiary, :representing_subsidiary,
                   :expense_account, :payables_account, :terms, :opening_balance_account, :currency, :work_calendar,
                   :tax_item

data/lib/netsuite/records/vendor_bill_item_list.rb

@@ -1,31 +1,11 @@
 module NetSuite
   module Records
-    class VendorBillItemList
-      include Support::Fields
+    class VendorBillItemList < Support::Sublist
       include Namespaces::TranPurch
 
-      fields :item
+      sublist :item, VendorBillItem
 
-      def initialize(attributes = {})
-        initialize_from_attributes_hash(attributes)
-      end
-
-      def item=(items)
-        case items
-        when Hash
-          self.items << VendorBillItem.new(items)
-        when Array
-          items.each { |item| self.items << VendorBillItem.new(item) }
-        end
-      end
-
-      def items
-        @items ||= []
-      end
-
-      def to_record
-        { "#{record_namespace}:item" => items.map(&:to_record) }
-      end
+      alias :items :item
 
     end
   end

data/lib/netsuite/records/vendor_payment_apply_list.rb

@@ -1,31 +1,11 @@
 module NetSuite
   module Records
-    class VendorPaymentApplyList
-      include Support::Fields
+    class VendorPaymentApplyList < Support::Sublist
       include Namespaces::TranPurch
 
-      fields :apply
+      sublist :apply, VendorPaymentApply
 
-      def initialize(attributes = {})
-        initialize_from_attributes_hash(attributes)
-      end
-
-      def apply=(applies)
-        case applies
-          when Hash
-            @applies = [VendorPaymentApply.new(applies)]
-          when Array
-            @applies = applies.map { |apply| VendorPaymentApply.new(apply) }
-        end
-      end
-
-      def applies
-        @applies ||= []
-      end
-
-      def to_record
-        { "#{record_namespace}:apply" => applies.map(&:to_record) }
-      end
+      alias :applies :apply
 
     end
   end

data/lib/netsuite/records/work_order_item_list.rb

@@ -1,31 +1,11 @@
 module NetSuite
   module Records
-    class WorkOrderItemList
-      include Support::Fields
+    class WorkOrderItemList < Support::Sublist
       include Namespaces::TranInvt
 
-      fields :item
+      sublist :item, WorkOrderItem
 
-      def initialize(attributes = {})
-        initialize_from_attributes_hash(attributes)
-      end
-
-      def item=(items)
-        case items
-        when Hash
-          self.items << WorkOrderItem.new(items)
-        when Array
-          items.each { |item| self.items << WorkOrderItem.new(item) }
-        end
-      end
-
-      def items
-        @items ||= []
-      end
-
-      def to_record
-        { "#{record_namespace}:item" => items.map(&:to_record) }
-      end
+      alias :items :item
     end
   end
 end

data/lib/netsuite/rest/utilities/request.rb

@@ -0,0 +1,53 @@
+require 'net/http'
+require 'uri'
+require 'json'
+
+module NetSuite
+  module Rest
+    module Utilities
+      class Request
+
+        BASE_API = "https://rest.netsuite.com/rest"
+        DEFAULT_TIMEOUT = 30
+        USE_SSL = true
+
+        class << self
+
+          def get(options)
+            email       = encode(options.fetch :email)
+            signature   = encode(options.fetch :password)
+            uri         = options.fetch(:uri)
+            response    = make_request(:get, uri, email, signature)
+            [response.code, JSON.parse(response.body)]
+          end
+
+          private
+
+          def make_request(method_name, uri, email, signature)
+            uri = URI(BASE_API + uri)
+            klass = Module.const_get "Net::HTTP::#{method_name.to_s.capitalize}"
+            method = klass.new(uri)
+            method['AUTHORIZATION'] = auth_header(email, signature)
+
+            http = Net::HTTP.new(uri.hostname, uri.port)
+            http.use_ssl      = USE_SSL
+            http.read_timeout = DEFAULT_TIMEOUT
+            http.start {|http| http.request(method)}
+          end
+
+          def auth_header(email, signature)
+            "NLAuth nlauth_email=#{email},nlauth_signature=#{signature}"
+          end
+
+          def encode(unencoded_string)
+            URI.escape(
+              unencoded_string,
+              /[#{URI::PATTERN::RESERVED}]/
+            )
+          end
+
+        end
+      end
+    end
+  end
+end