quickbooks 0.4.0 → 0.9.9

data/lib/quickbooks/extlib/time.rb

@@ -0,0 +1,41 @@
+require "date"
+
+class Time
+
+  ##
+  # Convert to ISO 8601 representation
+  #
+  #   Time.now.to_json        #=> "\"2008-03-28T17:54:20-05:00\""
+  #
+  # @return [String]
+  #   ISO 8601 compatible representation of the Time object.
+  #
+  # @api public
+  def to_json(*)
+    self.xmlschema.to_json
+  end
+
+  ##
+  # Return receiver (for DateTime/Time conversion protocol).
+  #
+  #   Time.now.to_time        #=> Wed Nov 19 20:08:28 -0800 2008
+  #
+  # @return [Time] Receiver
+  #
+  # @api public
+  def to_time
+    self
+  end
+
+  ##
+  # Convert to DateTime (for DateTime/Time conversion protocol).
+  #
+  #   Time.now.to_datetime    #=> #<DateTime: 106046956823/43200,-1/3,2299161>
+  #
+  # @return [DateTime] DateTime object representing the same moment as receiver
+  #
+  # @api public
+  def to_datetime
+    DateTime.parse self.to_s
+  end
+end

data/lib/quickbooks/model.rb

@@ -1,178 +1,560 @@
-require 'quickbooks/ruby_magic'
-
+require 'quickbooks/element'
 module Quickbooks
-  # These were all created from the info in qbxmlops70.xml, found in the docs in the QBSDK package.
-  CAMELIZE_EXCEPTIONS = {'list_id' => 'ListID', 'txn_id' => 'TxnID', 'owner_id' => 'OwnerID'}
-
+  # Model steps above related Element classes give you a way to manage your Quickbooks data like _objects_ rather than by managing the _communication_ of those objects.
   class Model
+    # A ModelProperty is just a little data store that keeps track of characteristics of each of the model's properties.
+    class ModelProperty
+      def initialize(klass_name, addable=false, writable=false, readable=false) #:nodoc:
+        @klass_name = klass_name
+        @addable = !!addable
+        @writable = !!writable
+        @readable = !!readable
+      end
+    
+      # Get the class name of the property.
+      def klass_name
+        @klass_name
+      end
+
+      # Get the class constant for the property.
+      def klass
+        QB[@klass_name]
+      end
+
+      # Can I include this property when creating a new object?
+      def addable?
+        @addable
+      end
+      def addable! #:nodoc:
+        @addable = true
+      end
+
+      # Can I include this property when modifying an existing object?
+      def writable?
+        @writable
+      end
+      def writable! #:nodoc:
+        @writable = true
+      end
+
+      # Is this property returned when reading back from QuickBooks?
+      def readable?
+        @readable
+      end
+      def readable! #:nodoc:
+        @readable = true
+      end
+    end
+    
     class << self
+      attr_reader :properties
 
-      def inherited(klass)
-        def klass.valid_filters
-          (superclass.valid_filters + (@valid_filters ||= []))
+      def help
+        "QB::#{short_name}.query_xsd for available query params\nQB::#{short_name}.write_xsd for create properties\nQB::#{short_name}.read_write_xsd for modifiable properties\nTry one of the above options to study this particular model's properties."
+      end
+
+      # Set or retrieve the XSD data for the Model's read elements -- properties that are readable.
+      def read_xsd(xsd=nil)
+        raise ArgumentError, "must be an Quickbooks::XSD::Element" unless xsd.nil? || xsd.is_a?(Quickbooks::XSD::Element)
+        if xsd
+          @read_xsd = xsd
+          create_combined_elements!
         end
-        def klass.filter_aliases
-          superclass.filter_aliases.slashed.merge(@filter_aliases ||= {}.slashed)
+        @read_xsd ||= nil
+      end
+
+      # Set or retrieve the XSD data for the Model's read/write elements -- properties that can be used in modifying objects.
+      # This is also the controller for validation of the object when you're modifying an existing object.
+      def read_write_xsd(xsd=nil)
+        raise ArgumentError, "must be an Quickbooks::XSD::Element" unless xsd.nil? || xsd.is_a?(Quickbooks::XSD::Element)
+        if xsd
+          @read_write_xsd = xsd
+          create_combined_elements!
         end
-        klass.instance_variable_set('@object_properties', {})
+        @read_write_xsd ||= nil
       end
-      
-      def valid_filters=(v)
-        raise TypeError, "must be only strings" unless v.all? {|e| e.is_a?(String)}
-        @valid_filters = v
+
+      # Set or retrieve the XSD data for the Model's write elements -- properties that can be used in creating a new object.
+      # This is also the controller for validation of the object when you're creating a new object.
+      def write_xsd(xsd=nil)
+        raise ArgumentError, "must be an Quickbooks::XSD::Element" if !xsd.nil? && !xsd.is_a?(Quickbooks::XSD::Element)
+        if xsd
+          @write_xsd = xsd
+          create_combined_elements!
+        end
+        @write_xsd ||= nil
       end
-      def valid_filters
-        (@valid_filters ||= [])
+
+      # Set or retrieve the XSD data for the Model's write elements -- properties that can be used in creating a new object.
+      # This is also the controller for validation of the object when you're creating a new object.
+      def query_xsd(xsd=nil)
+        raise ArgumentError, "must be an Quickbooks::XSD::Element" if !xsd.nil? && !xsd.is_a?(Quickbooks::XSD::Element)
+        @query_xsd = xsd if xsd
+        @query_xsd ||= nil
       end
-      def filter_aliases=(v)
-        (@filter_aliases = v.empty? ? {} : v).slashed
+
+      def query_attributes
+        if query_xsd
+          query_xsd.attributes
+        else
+          raise RuntimeError, "You must first initialize query_xsd."
+        end
       end
-      def filter_aliases
-        @filter_aliases ||= {}
+
+      def create_combined_elements!
+        # If this runs more than once it's okay; but it shouldn't ever because the attributes are written in order so write_xsd are done last.
+        if read_xsd
+          @properties = {}
+          @associations = {}
+          [read_xsd, read_write_xsd, write_xsd].compact.inject([]) {|a,e| a.concat(e.children)}.each do |prop_xsd|
+            @properties[prop_xsd.name.to_sym] = ModelProperty.new(Quickbooks.get_constant(prop_xsd.name).short_name, write_xsd && write_xsd.include?(prop_xsd.name), read_write_xsd && read_write_xsd.include?(prop_xsd.name), read_xsd && read_xsd.include?(prop_xsd.name))
+            @associations[prop_xsd.name[0..-4].to_sym] = @properties[prop_xsd.name.to_sym] if prop_xsd.name =~ /Ref$/
+          end
+        end
       end
-      def camelized_valid_filters
-        cvf = []
-        valid_filters.each do |v|
-          cvf << (Quickbooks::CAMELIZE_EXCEPTIONS.has_key?(v) ? Quickbooks::CAMELIZE_EXCEPTIONS[v] : (v.is_a?(Symbol) ? v.to_s.camelize.to_sym : v.split('/').map {|e| e.camelize}.join('/')))
+      private :create_combined_elements!
+
+      # Emulated Associations
+      attr_reader :associations # set up in .create_combined_elements!
+      # * * * *
+
+      # Request an array of whatever QuickBooks objects match the query. The args presented should be attributes with which to construct
+      # a *QueryRq for whatever model you're in.
+      def all(args={})
+        process_finder_args(args)
+        # This includes DataExt if user has asked for it.
+        if args.has_key?(:IncludeExtData)
+          data_scope = args.delete(:IncludeExtData)
+          args[:OwnerID] = [data_scope == true ? '0' : data_scope] if data_scope
+        end
+        # Create a #{short_name}Query out of the filters, and send it to quickbooks for a response; instantiate the response objects.
+        query = Quickbooks.get_constant("#{short_name}QueryRq").new(args)
+        if caller.join =~ /lib\/quickbooks\.rb:\d+:in `qbxml'/
+          Quickbooks.requestify(query).to_xml
+        else
+          catch :response do
+            response = Quickbooks.execute(query)[:QBXMLMsgsRs]["#{short_name}QueryRs"][0]
+            (response.nil? || response["#{short_name}Ret"].nil? || response["#{short_name}Ret"].empty?) ?
+              [] : response["#{short_name}Ret"].collect {|r| r.to_model}
+          end
         end
-        cvf
       end
-      
-      # Register multiple read/writable properties at once. For example:
-      #   read_write :first_name, :last_name, :phone, :alt_phone
-      # For reference attributes (like parent_ref), use ParentRef - a class constant for that object.
-      # _read_write_ will set the property setter and accessor accordingly.
-      def read_write(*args)
-        if args.empty?
-          @read_write || (@read_write = [])
+      # Request a single QuickBooks object that matches the query. The args presented should be attributes with which to construct
+      # a *QueryRq for whatever model you're in. This simply adds the property :MaxReturned => 1, if the request is still valid with it.
+      def first(args={})
+        process_finder_args(args)
+        # Create a #{short_name}Query out of the filters, and send it to quickbooks for a response; instantiate the response objects.
+        query = QB["#{short_name}QueryRq"].new(args)
+        started_valid = query.valid?
+        query[:MaxReturned] = 1
+        query.delete(:MaxReturned) if started_valid && !query.valid?
+        if caller.join =~ /lib\/quickbooks\.rb:\d+:in `qbxml'/
+          Quickbooks.requestify(query).to_xml
         else
-          args.each do |prop|
-            if prop.is_a?(Symbol)
-              read_write << prop
-              attr_accessor prop
-            else
-              @object_properties[prop.class_leaf_name.underscore.to_sym] = prop
-              read_write << prop.class_leaf_name.underscore.to_sym
-              class_eval "def #{prop.class_leaf_name.underscore}=(v); @#{prop.class_leaf_name.underscore} = #{prop.name}.new(v); end
-                def #{prop.class_leaf_name.underscore}; @#{prop.class_leaf_name.underscore}; end"
-            end
+          catch :response do
+            response = Quickbooks.execute(query)[:QBXMLMsgsRs]["#{short_name}QueryRs"][0]
+            response.nil? || response["#{short_name}Ret"].nil? || response["#{short_name}Ret"][0].nil? ?
+              nil : response["#{short_name}Ret"][0].to_model
           end
         end
       end
 
-      # Read-only attributes: These are attributes, but not modifiable in Quickbooks
-      def read_only(*args)
-        if args.empty?
-          @read_only || (@read_only = [])
+      # Iterates through all records matching *args, but only grabs 70 at a time from QuickBooks.
+      def each(args={})
+        process_finder_args(args)
+        query = Quickbooks.get_constant("#{short_name}QueryRq").new(args)
+        started_valid = query.valid?
+        query[:iterator] = 'Start'
+        query[:MaxReturned] = 70
+        query.delete(:iterator, :MaxReturned) if started_valid && !query.valid?
+        if caller.join =~ /lib\/quickbooks\.rb:\d+:in `qbxml'/
+          Quickbooks.requestify(query).to_xml
         else
-          args.each do |prop|
-            if prop.is_a?(Symbol)
-              read_only << prop
-              attr_accessor prop
-            else
-              @object_properties[prop.class_leaf_name.underscore.to_sym] = prop
-              read_only << prop.class_leaf_name.underscore.to_sym
-              class_eval "def #{prop.class_leaf_name.underscore}=(v); @#{prop.class_leaf_name.underscore} = #{prop.name}.new(v); end
-                def #{prop.class_leaf_name.underscore}; @#{prop.class_leaf_name.underscore}; end"
+          catch :response do
+            result = Quickbooks.execute(query)
+            ary = result[:QBXMLMsgsRs]["#{short_name}QueryRs"][0]["#{short_name}Ret"].each {|e| yield e.to_model}
+            if iteratorID = result[:QBXMLMsgsRs]["#{short_name}QueryRs"][0][:iteratorID]
+              query[:iteratorID] = iteratorID
+              query[:iterator] = 'Continue'
+              until(result[:QBXMLMsgsRs]["#{short_name}QueryRs"][0][:iteratorRemainingCount].to_i == 0)
+                result = Quickbooks.execute(query)
+                ary.concat result[:QBXMLMsgsRs]["#{short_name}QueryRs"][0]["#{short_name}Ret"].each {|e| yield e.to_model}
+              end
             end
+            ary
           end
         end
       end
-
-      def properties
-        read_only + read_write
+    
+      # Should be used only internally, but if you need this - use it to paint a new QuickBooks model object that thinks it already exists in QuickBooks.
+      def instantiate(attrs={})
+        obj = allocate
+        obj.instance_variable_set(:@new_record, nil)
+        obj.attributes = attrs
+        obj.instance_variable_set(:@new_record, false)
+        obj.send :clean!
+        obj
       end
-    end
 
-    self.valid_filters = ['max_returned']
+      # Replies whether it's a :List or a :Txn item.
+      def item_type
+        @properties.has_key?(:ListID) ? :List : :Txn
+      end
 
-    # The default for all subclasses is simply to apply the attributes given, and mark the object as a new_record?
-    def initialize(args={})
-      self.attributes = args
+      private
+        def process_finder_args(args)
+          # This includes DataExt if user has asked for it.
+          if args.has_key?(:IncludeExtData)
+            data_scope = args.delete(:IncludeExtData)
+            args[:OwnerID] = [data_scope == true ? '0' : data_scope] if data_scope
+          end
+        end
     end
-
-    # Returns a hash that represents all this object's attributes.
-    def attributes(include_read_only=false)
-      attrs = {}
-      (include_read_only ? self.class.read_only + self.class.read_write : self.class.read_write).each do |column|
-        attrs[column.to_s] = instance_variable_get('@' + column.to_s)
+    
+    # Paints up a new QuickBooks model object with the attributes you give it. Marked as new, so when you hit save, it will actually create it.
+    def initialize(attrs={})
+      @new_record = :init
+      self.attributes = attrs
+      @new_record = true
+    end
+    
+    def inspect #:nodoc:
+      "<#{self.class.short_name}:##{object_id}\n  #{attributes.collect {|k,v| v.inspect}.join("\n").gsub(/\n/, "\n  ")}>"
+    end
+    
+    # true if new record, false if already exists.
+    # 
+    # For deeper inspection, @new_record is set to:
+    # * :init if being initialized
+    # * true if new_record
+    # * nil if being instantiated
+    # * false if not new_record
+    def new_record?
+      !!@new_record
+    end
+    
+    # Returns the ListID or TxnID value respective of its type.
+    def id
+      self[:"#{self.class.item_type}ID"]
+    end
+    
+    # Display a list of the available attribute names
+    def properties(key=nil)
+      if key
+        self.class.properties[key]
+      else
+        self.class.properties.keys
       end
-      attrs
     end
-    # Updates all attributes included in _attrs_ to the values given. The object will now be dirty?.
+    
+    # Just return the attributes hash.
+    def attributes
+      @attributes ||= {}
+    end
+    
+    # Pass a hash of attributes, and it'll set each one one by one via []=.
     def attributes=(attrs)
-      raise ArgumentError, "attributes can only be set to a hash of attributes" unless attrs.is_a?(Hash)
-      attrs.each do |key,value|
-        if self.respond_to?(key.to_s.underscore+'=')
-          self.send(key.to_s.underscore+'=', value)
+      raise ArgumentError, "must be a hash" unless attrs.is_a?(Hash)
+      attrs.each do |k,v|
+        if self.class.properties.has_key?(k.to_sym) || self.class.associations.has_key?(k.to_sym)
+          self[k.to_sym] = v
+        else
+          raise "Model #{self.class.short_name} does not have property #{k}!"
         end
       end
     end
+    
+    # Access attribute values by key. Also access associations this way.
+    def [](key)
+      return self.attributes = key if key.is_a?(Hash)
+      key = case key # make a string
+      when String
+        key.to_sym
+      when Symbol
+        key
+      when Module
+        key.short_name.to_sym
+      end
+      return get_associated(key) if self.class.associations.has_key?(key)
+      attr_klass = begin
+        QB[key.to_s]
+      rescue RuntimeError
+        raise "Invalid key '#{key.inspect}'"
+      end
+      repeatable = (new_record? ? self.class.write_xsd : (@new_record == false ? self.class.read_write_xsd : self.class.read_xsd)).repeatable?(key.to_s)
+      attributes[key] = ElementCollection.new(self, key) if repeatable && !attributes[key].is_a?(ElementCollection)
+      attributes[key]
+    end
+    
+    # Set attribute values by key. Also set associated objects here.
+    def []=(key,value)
+      key = case key # make a symbol
+      when String
+        key.to_sym
+      when Symbol
+        key
+      when Module
+        key.short_name.to_sym
+      end
+      return associate(key, value) if self.class.associations.include?(key)
+      raise RuntimeError, "'#{key}' is not a valid property name for #{self.class.name}!" unless self.class.properties.has_key?(key)
+      raise RuntimeError, "'#{key}' cannot be assigned on creation" if new_record? && !self.class.properties[key].addable?
+      raise RuntimeError, "'#{key}' cannot be modified"             if @new_record == false && !self.class.properties[key].writable?
+      # Instantiate the value into the attribute class, if necessary
+      attr_klass = QB[key.to_s]
+      # If it *should* be an ElementCollection, it shouldn't be set here at all!
+      if (new_record? ? self.class.write_xsd : (@new_record == false ? self.class.read_write_xsd : self.class.read_xsd)).repeatable?(key.to_s)
+        if @new_record.in?(nil, :init) || value.is_a?(Array)
+          attributes[key] = ElementCollection.new(self, key, value)
+          attributes[key].send(:dirty!)
+        else
+          # If it *should* be an array element, it shouldn't be set here as a single value. This is just for safeguard, so that syntax
+          # always shows what is going on. For an array element, set it with: object.some_attr = [value]
+          raise RuntimeError, "You can't set a single value into a multi-value element to using equals(=). Use \"model[:#{key}] << value\" to append, or wrap the value in an array -- \"model[:#{key}] = [ value ]\" -- if you want to completely replace the current value set."
+        end
+      else
+        value = @new_record.nil? ? attr_klass.instantiate(value) : attr_klass.new(value) unless value.is_a?(attr_klass)
+        value.send(:dirty!)
+        attributes[key] = value
+      end
+      remove_incorrect_associated(key.to_s.sub(/Ref$/,'').to_sym, value) if self.class.associations.include?(key.to_s.sub(/Ref$/,'').to_sym)
+    end
+    
+    # Completely remove an attribute value from the object. This is different from setting the attribute to nil.
+    def delete(*keys)
+      keys.each do |key|
+        key = case key # make a string
+        when String
+          key.to_sym
+        when Symbol
+          key
+        when Module
+          key.short_name.to_sym
+        end
+        attributes.delete(key)
+      end
+    end
+
+    # Return only the attributes that have been changed or whose descendents have changed. If include_required is true, then whatever is necessary to make the set of attributes valid is returned as well.
+    def dirty_attributes(include_required=false)
+      Hash[*((include_required ?
+        attributes.select {|k,v| v.dirty? || (new_record? ? self.class.write_xsd : self.class.read_write_xsd).required?(k) || !(new_record? ? self.class.write_xsd : self.class.read_write_xsd).validate(self.class.short_name => attributes.except(v.class.short_name))} :
+        attributes.select {|k,v| v.dirty?}).flatten)]
+    end
 
-    # Keeps track of the original values the object had when it was instantiated from a quickbooks response. dirty? and dirty_attributes compare the current values with these ones.
-    def original_values
-      @original_values || (@original_values = {})
+    # Return only the attributes that have not been modified.
+    def clean_attributes
+      attributes.except(dirty_attributes.keys)
     end
 
-    # Returns true if any attributes have changed since the object was last loaded or updated from Quickbooks.
+    # Have any of my values, or my descendents' values, been changed?
     def dirty?
-      # Concept: For each column that the current model includes, has the value been changed?
-      self.class.read_write.any? do |column|
-        self.instance_variable_get('@' + column.to_s) != original_values[column.to_s]
-      end
+      # Test for any dirty elements
+      @dirty || attributes.any? {|k,v| v.dirty?}
     end
 
-    # Returns a hash of the attributes and their (new) values that have been changed since the object was last loaded or updated from Quickbooks.
-    # If you send in some attributes, it will compare to those given instead of original_attributes.
-    def dirty_attributes(compare={})
-      compare = original_values if compare.empty?
-      pairs = {}
-      self.class.read_write.each do |column|
-        value = instance_variable_get('@' + column.to_s)
-        if value != compare[column.to_s]
-          pairs[column.to_s] = value
-        end
-      end
-      pairs
+    # Do I have a relative *Ref class?
+    def can_ref?
+      Quickbooks.get_constant(self.class.short_name.gsub(/(Add|Mod|Ret)/,'') + 'Ref') && true rescue false
     end
 
-    def to_dirty_hash
-      hsh = SlashedHash.new.ordered!(self.class.read_write.stringify_values)
-      self.dirty_attributes.each do |key,value|
-        if value.is_a?(Quickbooks::Model)
-          hsh[key] = value.to_dirty_hash
+    # Make a Ref object out of me.
+    def to_ref
+      begin
+        attrs = {}
+        idsym = :"#{self.class.item_type}ID"
+        if self[idsym]
+          attrs[idsym] = self[idsym]
+        elsif self[:FullName]
+          attrs[:FullName] = self[:FullName]
         else
-          hsh[key] = value
+          return nil # Not able to ref
         end
+        Quickbooks.get_constant(self.class.short_name.gsub(/(Add|Mod|Ret)/,'') + 'Ref').new(attrs)
+      rescue NameError => e
+        nil
       end
-      hsh
     end
 
-    def to_hash(include_read_only=false)
-      hsh = SlashedHash.new.ordered!((include_read_only ? self.class.read_only + self.class.read_write : self.class.read_write).stringify_values)
-      self.attributes(include_read_only).each do |key,value|
-        if value.is_a?(Quickbooks::Model)
-          hsh[key] = value.to_hash(include_read_only)
-        else
-          hsh[key] = value
+    # Turn me into an element (ending in *Add or *Mod, depending on my new_record? situation).
+    def to_element
+      # List clean attributes
+      clean_attrs = clean_attributes.collect {|k,v| v.respond_to?(:to_element) ? v.to_element : v}.to_hash_via {|e| [(e.is_a?(ElementCollection) ? e.type.short_name : e.class.short_name), e]}
+      # List dirty attributes
+      dirty_attrs = dirty_attributes.collect {|k,v| v.respond_to?(:to_element) ? v.to_element : v}.to_hash_via {|e| [(e.is_a?(ElementCollection) ? e.type.short_name : e.class.short_name), e]}
+      # Set up the corresponding element with corresponding properties
+      element = element_klass.instantiate(clean_attrs)
+      element.attributes = dirty_attrs
+      # Transfer the order index (for attribute sorting) from elements that were in a collection.
+      element.instance_variable_set(:@collection_index, @collection_index) if instance_variables.include?('@collection_index')
+      element
+    end
+    
+    # I don't think this is actually being used anywhere...
+    def to_update_element
+      to_element.to_update_element
+    end
+    
+    def to_xml
+      to_element.to_xml
+    end
+    def to_dirty_xml(include_required=false)
+      to_element.to_dirty_xml(include_required)
+    end
+    
+    # Am I completely valid?
+    def valid?
+      validate.perfect?
+    end
+
+    # Use this to validate the object and get the Valean result instead of just a true/false value.
+    def validate
+      r = new_record? ? self.class.write_xsd.validate(self) : self.class.read_write_xsd.validate(self)
+      errors.replace(r.errors)
+      r
+    end
+
+    # The errors returned by the latest validate call.
+    def errors
+      @errors ||= []
+    end
+    def add_error(msg) #:nodoc:
+      errors << [nil, msg]
+    end
+
+    # Save the object to QuickBooks, whether that means creating a new record or updating an existing one.
+    def save
+      save_associations
+      query = Quickbooks.get_constant("#{element_klass.short_name}Rq").new([ to_element.to_update_element ])
+      if caller.join =~ /lib\/quickbooks\.rb:\d+:in `qbxml'/
+        Quickbooks.requestify(query).to_xml
+      else
+        catch :response do
+          @last_response = Quickbooks.execute(query)
+          response = @last_response[:QBXMLMsgsRs]["#{element_klass.short_name}Rs"][0]
+          reload = if response.nil? || response["#{self.class.short_name}Ret"].nil? || response["#{self.class.short_name}Ret"].nil?
+            raise "Response doesn't make sense after saving #{inspect}: #{@last_response.inspect} (#{@last_response[:QBXMLMsgsRs]["#{element_klass.short_name}Rs"][0].nil?})"
+          else
+            response["#{self.class.short_name}Ret"].to_model
+          end
+          @attributes = reload.attributes
+          true
         end
       end
-      hsh
     end
 
-    def ==(other)
-      return false unless other.is_a?(self.class)
-      !self.class.read_write.any? do |column|
-        self.instance_variable_get('@' + column.to_s) != other.instance_variable_get('@' + column.to_s)
+    # Update some extended data by key and value.
+    # By default, just include the key and value, and the owner id of '0' will be used.
+    # However, if you want to specify a different owner, just add that on as a third parameter.
+    def update_extended_data(key, value, owner=nil)
+      # First, see if this key already exists or not.
+      load_extended_data unless attributes[:DataExt]
+
+      attrs = {
+        # Use the same OwnerID that was supplied for getting the DataExt.
+        :OwnerID => owner || ((attributes[:DataExt] && attributes[:DataExt][0]) ? attributes[:DataExt][0][:OwnerID] : '0'),
+        :DataExtName => key,
+        :"#{self.class.short_name == 'Company' ? 'Other' : self.class.item_type}DataExtType" => self.class.short_name,
+        :DataExtValue => value
+      }
+      case self.class.item_type
+      when :List
+        attrs[:ListObjRef] = {:ListID => id}
+      when :Txn
+        attrs[:TxnID] = id
+        # We don't need to bother with LineID extended data.
+        # attrs[:TxnLineID]
+      end
+
+      de = if self[:DataExt] && self[:DataExt].select {|de| de[:DataExtName] == key}
+        # Modify it.
+        QB::DataExtModRq.new(:DataExtMod => attrs)
+      else
+        # Create it.
+        QB::DataExtAddRq.new(:DataExtAdd => attrs)
       end
+      Quickbooks.execute(de)
+      load_extended_data
+    end
+    # Use this to load extended data if you need to import into this same object.
+    def load_extended_data(owner='0')
+      attributes[:DataExt] = self.class.first(:"#{self.class.item_type}ID" => [id], :OwnerID => [owner])[:DataExt]
+    end
+
+    # Save any unsaved or dirty associations.
+    def save_associations
+      # first save any of my associated items that aren't already existing
+      self.class.associations.each_key do |association_name|
+        instance_variable_set("@#{association_name}", nil) unless self.instance_variables.include?("@#{association_name}") # just to avoid needless warnings.
+        if instance_variable_get("@#{association_name}") && self[association_name].new_record?
+          self[association_name].save
+          self[association_name] = self[association_name] # re-assigns the associated Ref
+        end
+      end
+      # then save any of my children's associated items that aren't already existing
+      attributes.each { |k,attv| attv.save_associations if attv.respond_to?(:save_associations) }
     end
 
-    def ===(other)
-      # other could be a hash
-      if other.is_a?(Hash)
-        self == self.class.new(other)
+    # That's right. Just get rid of that object. QuickBooks knows how to handle things, and it won't let you destroy items if it'll mess things up.
+    def destroy!
+      query = Quickbooks.get_constant("#{self.class.item_type}DelRq").new("#{self.class.item_type}DelType" => self.class.short_name, "#{self.class.item_type}ID" => self["#{self.class.item_type}ID"])
+      if caller.join =~ /lib\/quickbooks\.rb:\d+:in `qbxml'/
+        Quickbooks.requestify(query).to_xml
+      else
+        catch :response do
+          Quickbooks.execute(query)
+        end
+      end
+    end
+    
+    private
+    
+    def get_associated(association_name)
+      (self.instance_variables.include?("@#{association_name}") && instance_variable_get("@#{association_name}")) || begin
+        ref_klass = self.class.associations[association_name].klass
+        self[ref_klass].nil? ? nil : instance_variable_set("@#{association_name}", self[ref_klass].unref)
+      end
+    end
+    
+    def associate(association_name, value)
+      instance_variable_set("@#{association_name}", value)
+      ref = value.to_ref
+      ref_klass = self.class.associations[association_name].klass
+      !ref.nil? ?
+        self[ref_klass] = ref :
+        self.delete(ref_klass)
+    end
+    
+    def remove_incorrect_associated(association_name, value)
+      instance_variable_set("@#{association_name}", nil) if !self.instance_variables.include?("@#{association_name}") || (associated = instance_variable_get("@#{association_name}") && !associated.nil? && !associated.to_ref.nil? && (associated.to_ref[:ListID] || associated.to_ref[:TxnID] || associated.to_ref[:FullName]) != (value[:ListID] || value[:TxnID] || value[:FullName]))
+    end
+    
+    def element_klass
+      Quickbooks.get_constant(self.class.short_name + (new_record? ? 'Add' : 'Mod'))
+    end
+    
+    def clean!
+      @dirty = false
+      attributes.each {|k,v| v.send(:clean!)}
+    end
+    
+    def dirty!
+      @dirty = true
+    end
+    
+    def method_missing(method_name, *args)
+      if method_name.to_s =~ /^[A-Z]/
+        if method_name.to_s =~ /=$/
+          # Set property
+          self[method_name.to_s.gsub(/\=$/,'')] = *args
+        elsif args.empty?
+          # Get property
+          self[method_name.to_s.gsub(/\=$/,'')]
+        else
+          raise NoMethodError, "undefined method `#{method_name}' for #{self.inspect}:#{self.class.name}", caller[0..-1]
+        end
       else
-        self == other
+        raise NoMethodError, "undefined method `#{method_name}' for #{self.inspect}:#{self.class.name}", caller[0..-1]
       end
     end
   end