netsuite_rails 0.1.0 → 0.2.0

data/lib/netsuite_rails/record_sync/push_manager.rb

@@ -4,18 +4,27 @@ module NetSuiteRails
     class PushManager
       class << self
 
-        def push(local_record, opts)
+        def push(local_record, opts = {})
           # TODO check to see if anything is changed before moving forward
           # if changes_keys.blank? && local_record.netsuite_manual_fields
 
-          netsuite_record = build_netsuite_record(local_record)
+          if opts[:modified_fields]
+            # if Array, we need to convert info fields hash based on the record definition
+            if opts[:modified_fields].is_a?(Array)
+              opts[:modified_fields] = all_netsuite_fields(local_record).select { |k,v| opts[:modified_fields].include?(k) }
+            end
+          else
+            opts[:modified_fields] = modified_local_fields(local_record)
+          end
+
+          netsuite_record = build_netsuite_record(local_record, opts)
 
           local_record.netsuite_execute_callbacks(local_record.class.before_netsuite_push, netsuite_record)
 
           if !local_record.new_netsuite_record?
-            push_update(local_record, netsuite_record)
+            push_update(local_record, netsuite_record, opts)
           else
-            push_add(local_record, netsuite_record)
+            push_add(local_record, netsuite_record, opts)
           end
 
           # :aggressive is for custom fields which are based on input – need pull updated values after
@@ -30,7 +39,7 @@ module NetSuiteRails
           true
         end
 
-        def push_add(local_record, netsuite_record)
+        def push_add(local_record, netsuite_record, opts = {})
           if netsuite_record.add
             # update_column to avoid triggering another save
             local_record.update_column(:netsuite_id, netsuite_record.internal_id)
@@ -40,17 +49,17 @@ module NetSuiteRails
           end
         end
 
-        def push_update(local_record, netsuite_record)
+        def push_update(local_record, netsuite_record, opts = {})
           # build change hash to limit the number of fields pushed to NS on change
           # NS could have logic which could change field functionality depending on
           # input data; it's safest to limit the number of field changes pushed to NS
 
           custom_field_list = local_record.netsuite_field_map[:custom_field_list] || {}
-          all_field_list = eligible_local_fields(local_record)
+          modified_fields_list = opts[:modified_fields]
 
           update_list = {}
 
-          all_field_list.each do |local_field, netsuite_field|
+          modified_fields_list.each do |local_field, netsuite_field|
             if custom_field_list.keys.include?(local_field)
               # if custom field has changed, mark and copy over customFieldList later
               update_list[:custom_field_list] = true
@@ -87,15 +96,21 @@ module NetSuiteRails
           end
         end
 
-        def build_netsuite_record(local_record)
+        def build_netsuite_record(local_record, opts = {})
           netsuite_record = build_netsuite_record_reference(local_record)
 
           # TODO need to normalize datetime fields
 
-          all_field_list = eligible_local_fields(local_record)
+          all_field_list = opts[:modified_fields]
           custom_field_list = local_record.netsuite_field_map[:custom_field_list] || {}
           field_hints = local_record.netsuite_field_hints
 
+          reflections = if NetSuiteRails.rails4?
+            local_record.class.reflections
+          else
+            local_record.reflections
+          end
+
           all_field_list.each do |local_field, netsuite_field|
             # allow Procs as field mapping in the record definition for custom mapping
             if netsuite_field.is_a?(Proc)
@@ -105,7 +120,7 @@ module NetSuiteRails
 
             # TODO pretty sure this will break if we are dealing with has_many 
 
-            netsuite_field_value = if local_record.reflections.has_key?(local_field)
+            netsuite_field_value = if reflections.has_key?(local_field)
               if (remote_internal_id = local_record.send(local_field).try(:netsuite_id)).present?
                 { internal_id: remote_internal_id }
               else
@@ -145,20 +160,24 @@ module NetSuiteRails
           netsuite_record
         end
 
-        def eligible_local_fields(local_record)
-          custom_field_list = local_record.netsuite_field_map[:custom_field_list] || {}
-          all_field_list = local_record.netsuite_field_map.except(:custom_field_list) || {}
-
-          all_field_list.merge!(custom_field_list)
+        def modified_local_fields(local_record)
+          synced_netsuite_fields = all_netsuite_fields(local_record)
 
           changed_keys = changed_attributes(local_record)
 
           # filter out unchanged keys when updating record
           unless local_record.new_netsuite_record?
-            all_field_list.select! { |k,v| changed_keys.include?(k) }
+            synced_netsuite_fields.select! { |k,v| changed_keys.include?(k) }
           end
 
-          all_field_list
+          synced_netsuite_fields
+        end
+
+        def all_netsuite_fields(local_record)
+          custom_netsuite_field_list = local_record.netsuite_field_map[:custom_field_list] || {}
+          standard_netsuite_field_list = local_record.netsuite_field_map.except(:custom_field_list) || {}
+
+          custom_netsuite_field_list.merge(standard_netsuite_field_list)
         end
 
         def changed_attributes(local_record)
@@ -167,13 +186,32 @@ module NetSuiteRails
 
           # TODO think about has_many / join table changes
 
-          association_field_key_mapping = local_record.reflections.values.reject(&:collection?).inject({}) do |h, a|
-            h[a.association_foreign_key.to_sym] = a.name
+          reflections = if NetSuiteRails.rails4?
+            local_record.class.reflections
+          else
+            local_record.reflections
+          end
+
+          association_field_key_mapping = reflections.values.reject(&:collection?).inject({}) do |h, a|
+            begin
+              h[a.association_foreign_key.to_sym] = a.name
+            rescue Exception => e
+              # occurs when `has_one through:` exists on a record but `through` is not a valid reference
+              Rails.logger.error "NetSuite: error detecting foreign key #{a.name}"
+            end
+
             h
           end
 
+          changed_attributes_keys = local_record.changed_attributes.keys
+
+          # TODO documentation about serialized values
+          changed_attributes_keys += local_record.serialized_attributes.keys.map do |k|
+            local_record.send(k.to_sym).keys.map(&:to_s)
+          end.flatten
+
           # convert relationship symbols from :object_id to :object
-          local_record.changed_attributes.keys.map do |k|
+          changed_attributes_keys.map do |k|
             association_field_key_mapping[k.to_sym] || k.to_sym
           end
         end

data/lib/netsuite_rails/record_sync.rb

@@ -2,72 +2,81 @@ module NetSuiteRails
   module RecordSync
 
     def self.included(klass)
+      klass.class_eval do
+        class_attribute :netsuite_settings
+
+        self.netsuite_settings = {
+          before_netsuite_push: [],
+          after_netsuite_push: [],
+          after_netsuite_pull: [],
+
+          netsuite_sync: :read,
+          netsuite_field_map: {},
+          netsuite_field_hints: {},
+          netsuite_record_class: nil,
+        }
+
+        cattr_accessor :netsuite_custom_record_type_id
+        cattr_accessor :netsuite_sync_options
+      end
+
       klass.send(:extend, ClassMethods)
+      klass.send(:include, InstanceMethods)
 
       SyncTrigger.attach(klass)
-      PollManager.attach(klass)
+      PollTrigger.attach(klass)
     end
 
     module ClassMethods
       def netsuite_poll(opts = {})
-        RecordSync::PullManager.poll(self, opts)
+        RecordSync::PollManager.poll(self, opts)
       end
 
       attr_accessor :netsuite_custom_record_type_id
       attr_accessor :netsuite_sync_options
-      attr_accessor :netsuite_credentials
 
       # TODO is there a better way to implement callback chains?
       #      https://github.com/rails/rails/blob/0c0f278ab20f3042cdb69604166e18a61f8605ad/activesupport/lib/active_support/callbacks.rb#L491
 
       def before_netsuite_push(callback = nil, &block)
-        @before_netsuite_push ||= []
-        @before_netsuite_push << (callback || block) if callback || block
-        @before_netsuite_push
+        self.netsuite_settings[:before_netsuite_push] << (callback || block) if callback || block
+        self.netsuite_settings[:before_netsuite_push]
       end
 
       def after_netsuite_push(callback = nil, &block)
-        @after_netsuite_push ||= []
-        @after_netsuite_push << (callback || block) if callback || block
-        @after_netsuite_push
+        self.netsuite_settings[:after_netsuite_push] << (callback || block) if callback || block
+        self.netsuite_settings[:after_netsuite_push]
       end
 
       def after_netsuite_pull(callback = nil, &block)
-        @after_netsuite_pull ||= []
-        @after_netsuite_pull << (callback || block) if callback || block
-        @after_netsuite_pull
+        self.netsuite_settings[:after_netsuite_pull] << (callback || block) if callback || block
+        self.netsuite_settings[:after_netsuite_pull]
       end
 
       def netsuite_field_map(field_mapping = nil)
-        if field_mapping.nil?
-          @netsuite_field_map ||= {}
-        else
-          @netsuite_field_map = field_mapping
+        if !field_mapping.nil?
+          self.netsuite_settings[:netsuite_field_map] = field_mapping
         end
 
-        @netsuite_field_map
-      end
-
-      def netsuite_local_fields
-        @netsuite_field_map.except(:custom_field_list).keys + (@netsuite_field_map[:custom_field_list] || {}).keys
+        self.netsuite_settings[:netsuite_field_map]
       end
 
       def netsuite_field_hints(list = nil)
-        if list.nil?
-          @netsuite_field_hints ||= {}
-        else
-          @netsuite_field_hints = list
+        if !list.nil?
+          self.netsuite_settings[:netsuite_field_hints] = list
         end
+
+        self.netsuite_settings[:netsuite_field_hints]
       end
 
       # TODO persist type for CustomRecordRef
       def netsuite_record_class(record_class = nil, custom_record_type_id = nil)
-        if record_class.nil?
-          @netsuite_record_class
-        else
-          @netsuite_record_class = record_class
-          @netsuite_custom_record_type_id = custom_record_type_id
+        if !record_class.nil?
+          self.netsuite_settings[:netsuite_record_class] = record_class
+          self.netsuite_custom_record_type_id = custom_record_type_id
         end
+
+        self.netsuite_settings[:netsuite_record_class]
       end
 
       # there is a model level of this method in order to be based on the model level record class
@@ -75,160 +84,153 @@ module NetSuiteRails
         self.netsuite_record_class == NetSuite::Records::CustomRecord
       end
 
-      # :read_only, :aggressive (push & update on save), :write_only, :read_write
+      # :read, :aggressive (push & update on save), :write_only, :read_write
       def netsuite_sync(flag = nil, opts = {})
-        if flag.nil?
-          @netsuite_sync_options ||= {}
-          @netsuite_sync ||= :read_only
-        else
-          @netsuite_sync = flag
-          @netsuite_sync_options = opts
+        if !flag.nil?
+          self.netsuite_sync_options = opts
+          self.netsuite_settings[:netsuite_sync] = flag
         end
+
+        self.netsuite_settings[:netsuite_sync]
       end
     end
 
-    attr_accessor :netsuite_manual_fields
+    module InstanceMethods
+      attr_accessor :netsuite_manual_fields
 
-    # these methods are here for easy model override
+      # these methods are here for easy model override
 
-    def netsuite_sync_options
-      self.class.netsuite_sync_options
-    end
-
-    def netsuite_sync
-      self.class.netsuite_sync
-    end
+      def netsuite_sync_options
+        self.class.netsuite_sync_options
+      end
 
-    def netsuite_record_class
-      self.class.netsuite_record_class
-    end
+      def netsuite_sync
+        self.class.netsuite_sync
+      end
 
-    def netsuite_field_map
-      self.class.netsuite_field_map
-    end
+      def netsuite_record_class
+        self.class.netsuite_record_class
+      end
 
-    def netsuite_field_hints
-      self.class.netsuite_field_hints
-    end
+      def netsuite_field_map
+        self.class.netsuite_field_map
+      end
 
-    # assumes netsuite_id field on activerecord
+      def netsuite_field_hints
+        self.class.netsuite_field_hints
+      end
 
-    def netsuite_pulling?
-      @netsuite_pulling ||= false
-    end
+      # assumes netsuite_id field on activerecord
 
-    def netsuite_pulled?
-      @netsuite_pulled ||= false
-    end
+      def netsuite_pulling?
+        @netsuite_pulling ||= false
+      end
 
-    def netsuite_pull
-      netsuite_extract_from_record(netsuite_pull_record)
-    end
+      def netsuite_pulled?
+        @netsuite_pulled ||= false
+      end
 
-    def netsuite_pull_record
-      if netsuite_custom_record?
-        NetSuite::Records::CustomRecord.get(
-          internal_id: self.netsuite_id,
-          type_id: self.class.netsuite_custom_record_type_id
-        )
-      else
-        self.netsuite_record_class.get(self.netsuite_id)
+      def netsuite_pull
+        netsuite_extract_from_record(netsuite_pull_record)
       end
-    end
 
-    def netsuite_push(opts = {})
-      NetSuiteRails::RecordSync::PushManager.push(self, opts)
-    end
+      def netsuite_pull_record
+        if netsuite_custom_record?
+          NetSuite::Records::CustomRecord.get(
+            internal_id: self.netsuite_id,
+            type_id: self.class.netsuite_custom_record_type_id
+          )
+        else
+          self.netsuite_record_class.get(self.netsuite_id)
+        end
+      end
 
-    def netsuite_extract_from_record(netsuite_record)
-      @netsuite_pulling = true
+      def netsuite_push(opts = {})
+        NetSuiteRails::RecordSync::PushManager.push(self, opts)
+      end
 
-      field_hints = self.netsuite_field_hints
+      def netsuite_extract_from_record(netsuite_record)
+        @netsuite_pulling = true
 
-      custom_field_list = self.netsuite_field_map[:custom_field_list] || {}
+        field_hints = self.netsuite_field_hints
 
-      all_field_list = self.netsuite_field_map.except(:custom_field_list) || {}
-      all_field_list.merge!(custom_field_list)
+        custom_field_list = self.netsuite_field_map[:custom_field_list] || {}
 
-      # self.netsuite_normalize_datetimes(:pull)
+        all_field_list = self.netsuite_field_map.except(:custom_field_list) || {}
+        all_field_list.merge!(custom_field_list)
 
-      # handle non-collection associations
-      association_keys = self.reflections.values.reject(&:collection?).map(&:name)
+        # self.netsuite_normalize_datetimes(:pull)
 
-      all_field_list.each do |local_field, netsuite_field|
-        is_custom_field = custom_field_list.keys.include?(local_field)
+        # handle non-collection associations
+        association_keys = self.reflections.values.reject(&:collection?).map(&:name)
 
-        if netsuite_field.is_a?(Proc)
-          netsuite_field.call(self, netsuite_record, :pull)
-          next
-        end
+        all_field_list.each do |local_field, netsuite_field|
+          is_custom_field = custom_field_list.keys.include?(local_field)
 
-        field_value = if is_custom_field
-          netsuite_record.custom_field_list.send(netsuite_field).value rescue ""
-        else
-          netsuite_record.send(netsuite_field)
-        end
+          if netsuite_field.is_a?(Proc)
+            netsuite_field.call(self, netsuite_record, :pull)
+            next
+          end
 
-        if field_value.blank?
-          # TODO possibly nil out the local value?
-          next
-        end
+          field_value = if is_custom_field
+            netsuite_record.custom_field_list.send(netsuite_field).value rescue ""
+          else
+            netsuite_record.send(netsuite_field)
+          end
 
-        if association_keys.include?(local_field)
-          field_value = self.reflections[local_field].klass.where(netsuite_id: field_value.internal_id).first_or_initialize
-        elsif is_custom_field
-          # TODO I believe this only handles a subset of all the possibly CustomField values
-          if field_value.present? && field_value.is_a?(Hash) && field_value.has_key?(:name)
-            field_value = field_value[:name]
+          if field_value.blank?
+            # TODO possibly nil out the local value?
+            next
           end
 
-          if field_value.present? && field_value.is_a?(NetSuite::Records::CustomRecordRef)
-            field_value = field_value.attributes[:name]
+          if association_keys.include?(local_field)
+            field_value = self.reflections[local_field].klass.where(netsuite_id: field_value.internal_id).first_or_initialize
+          elsif is_custom_field
+            field_value = NetSuiteRails::RecordSync::PullManager.extract_custom_field_value(field_value)
+          else
+            # then it's not a custom field
           end
-        else
-          # then it's not a custom field
-        end
 
-        # TODO should we just check for nil? vs present?
+          # TODO should we just check for nil? vs present?
 
-        # TODO should be moved to Transformations with a direction flag
-        if field_hints.has_key?(local_field) && field_value.present?
-          case field_hints[local_field]
-          when :datetime
-            field_value = field_value.change(offset: "00:00") - (Time.zone.utc_offset / 3600).hours + (8 + NetSuiteRails::Configuration.netsuite_instance_time_zone_offset).hours
+          # TODO should be moved to Transformations with a direction flag
+          if field_hints.has_key?(local_field) && field_value.present?
+            case field_hints[local_field]
+            when :datetime
+              field_value = field_value.change(offset: "00:00") - (Time.zone.utc_offset / 3600).hours + (8 + NetSuiteRails::Configuration.netsuite_instance_time_zone_offset).hours
+            end
           end
-        end
 
-        self.send(:"#{local_field}=", field_value)
-      end
+          self.send(:"#{local_field}=", field_value)
+        end
 
-      netsuite_execute_callbacks(self.class.after_netsuite_pull, netsuite_record)
+        netsuite_execute_callbacks(self.class.after_netsuite_pull, netsuite_record)
 
-      @netsuite_pulling = false
-      @netsuite_pulled = true
+        @netsuite_pulling = false
+        @netsuite_pulled = true
+      end
 
-      # return netsuite record for debugging
-      netsuite_record
-    end
 
-    def new_netsuite_record?
-      self.netsuite_id.blank?
-    end
+      def new_netsuite_record?
+        self.netsuite_id.blank?
+      end
 
-    def netsuite_custom_record?
-      self.netsuite_record_class == NetSuite::Records::CustomRecord
-    end
+      def netsuite_custom_record?
+        self.netsuite_record_class == NetSuite::Records::CustomRecord
+      end
 
-    # TODO this should be protected; it needs to be pushed down to the Push/Pull manager level
+      # TODO this should be protected; it needs to be pushed down to the Push/Pull manager level
 
-    def netsuite_execute_callbacks(list, record)
-      list.each do |callback|
-        if callback.is_a?(Symbol)
-          self.send(callback, record)
-        else
-          instance_exec(record, &callback)
+      def netsuite_execute_callbacks(list, record)
+        list.each do |callback|
+          if callback.is_a?(Symbol)
+            self.send(callback, record)
+          else
+            instance_exec(record, &callback)
+          end
         end
       end
+
     end
 
   end

data/lib/netsuite_rails/spec/spec_helper.rb

@@ -10,15 +10,26 @@ module NetSuiteRails::TestHelpers
     if stamp.nil?
       @netsuite_timestamp ||= (Time.now - (60 * 2)).to_datetime
     else
-      @netsuite_timestamp ||= stamp
+      @netsuite_timestamp = stamp
     end
   end
 
   def get_last_netsuite_object(record)
-    search = record.netsuite_record_class.search({
+    # TODO support passing custom record ref
+
+    if record.is_a?(Class)
+      record_class = record
+      is_custom_record = false
+    else
+      record_class = record.netsuite_record_class
+      is_custom_record = record.netsuite_custom_record?
+    end
+
+    search = record_class.search({
       criteria: {
         basic:
-        if record.netsuite_custom_record?
+        (
+        if is_custom_record
           [
             {
               field: 'recType',
@@ -39,18 +50,35 @@ module NetSuiteRails::TestHelpers
               value: netsuite_timestamp
             }
           ]
+        end + 
+
+        if record_class == NetSuite::Records::SalesOrder
+          [
+            {
+              field: 'type',
+              operator: 'anyOf',
+              value: [ '_salesOrder' ]
+            }
+          ]
+        else
+          []
         end
+        )
       }
     })
 
-    if record.netsuite_custom_record?
+    if is_custom_record
       NetSuite::Records::CustomRecord.get(
         internal_id: search.results.first.internal_id.to_i,
         type_id: record.class.netsuite_custom_record_type_id
       )
     else
-      record.netsuite_record_class.get(search.results.first.internal_id.to_i)
+      record_class.get(search.results.first.internal_id.to_i)
     end
   end
 
-end
+end
+
+RSpec.configure do |config|
+  config.include NetSuiteRails::TestHelpers, type: :feature
+end