active-fedora 8.7.0 → 9.0.0.beta1

data/lib/active_fedora/indexing_service.rb

@@ -0,0 +1,70 @@
+module ActiveFedora
+  class IndexingService
+    attr_reader :object
+    # Object must respond to
+    #   create_date
+    #   modified_date
+    #   has_model
+    #   id
+    #   to_json
+    #   attached_files
+    #   []
+    # and it's class must respond to
+    #   inspect
+    #   outgoing_reflections
+    def initialize(obj)
+      @object = obj
+    end
+
+    def self.profile_solr_name
+      ActiveFedora::SolrService.solr_name("object_profile", :displayable)
+    end
+
+
+    def generate_solr_document
+      solr_doc = {}
+      Solrizer.set_field(solr_doc, 'system_create', c_time, :stored_sortable)
+      Solrizer.set_field(solr_doc, 'system_modified', m_time, :stored_sortable)
+      Solrizer.set_field(solr_doc, 'active_fedora_model', object.class.inspect, :stored_sortable)
+      solr_doc.merge!(SolrService::HAS_MODEL_SOLR_FIELD => object.has_model)
+      solr_doc.merge!(SOLR_DOCUMENT_ID.to_sym => object.id)
+      solr_doc.merge!(self.class.profile_solr_name => object.to_json)
+      object.attached_files.each do |name, file|
+        solr_doc.merge! file.to_solr(solr_doc, name: name.to_s)
+      end
+      solr_doc = solrize_relationships(solr_doc)
+      solr_doc
+    end
+
+    protected
+
+    def c_time
+      c_time = object.create_date.present? ? object.create_date : DateTime.now
+      c_time = DateTime.parse(c_time) unless c_time.is_a?(DateTime)
+      c_time
+    end
+
+    def m_time
+      m_time = object.modified_date.present? ? object.modified_date : DateTime.now
+      m_time = DateTime.parse(m_time) unless m_time.is_a?(DateTime)
+      m_time
+    end
+
+    # Serialize the datastream's RDF relationships to solr
+    # @param [Hash] solr_doc @deafult an empty Hash
+    def solrize_relationships(solr_doc = Hash.new)
+      object.class.outgoing_reflections.values.each do |reflection|
+        solr_key = reflection.solr_key
+        Array(object[reflection.foreign_key]).compact.each do |v|
+          ::Solrizer::Extractor.insert_solr_field_value(solr_doc, solr_key, v )
+        end
+      end
+      solr_doc
+    end
+
+    def solr_name(*args)
+      ActiveFedora::SolrService.solr_name(*args)
+    end
+
+  end
+end

data/lib/active_fedora/ldp_resource.rb

@@ -0,0 +1,26 @@
+module ActiveFedora
+  class LdpResource < Ldp::Resource::RdfSource
+    def build_empty_graph
+      graph_class.new(subject_uri)
+    end
+
+    def self.graph_class
+      ActiveTriples::Resource
+    end
+
+    def graph_class
+      self.class.graph_class
+    end
+
+    ##
+    # @param [RDF::Graph] original_graph The graph returned by the LDP server
+    # @return [RDF::Graph] A graph striped of any inlined resources present in the original
+    def build_graph(original_graph)
+      inlined_resources = get.graph.query(predicate: Ldp.contains).map { |x| x.object }
+
+      # ActiveFedora always wants to copy the resources to a new graph because it
+      # forces a cast to FedoraRdfResource
+      graph_without_inlined_resources(original_graph, inlined_resources)
+    end
+  end
+end

data/lib/active_fedora/loadable_from_json.rb

@@ -0,0 +1,112 @@
+module ActiveFedora
+  module LoadableFromJson
+    extend ActiveSupport::Concern
+
+    class SolrBackedMetadataFile
+      def freeze
+        @hash.freeze
+      end
+
+      def initialize
+        @hash = {}
+      end
+
+      def term_values *terminology
+        @hash.fetch(terminology.first, [])
+      end
+
+      def update_indexed_attributes hash
+        hash.each do |k, v|
+          @hash[k.first] = v
+        end
+      end
+    end
+
+    class SolrBackedResource
+      def freeze
+        @hash.freeze
+      end
+
+      def initialize(model)
+        @model = model
+        @hash = {}
+      end
+
+      def to_s
+        @hash.to_s
+      end
+
+      # It is expected that the singular filter gets applied after fetching the value from this
+      # resource, so cast everything back to an array.
+      def set_value(k, v)
+        @hash[k] = Array(v)
+      end
+
+      def get_values(k)
+        @hash[k]
+      end
+
+      # FakeQuery exists to adapt the hash to the RDF interface used by RDF associations in ActiveFedora
+      class FakeQuery
+        def initialize(values)
+          @values = values || []
+        end
+
+        def enum_statement
+          @values.map {|v| FakeStatement.new(v) }
+        end
+
+        class FakeStatement
+          def initialize(value)
+            @value = value
+          end
+
+          def object
+            @value
+          end
+        end
+      end
+
+      def query(args={})
+        predicate = args[:predicate]
+        reflection = reflection(predicate)
+        FakeQuery.new(get_values(reflection))
+      end
+
+      def rdf_subject
+        ::RDF::URI.new(nil)
+      end
+
+      def insert(vals)
+        _, pred, val = vals
+        set_value(reflection(pred), [val])
+      end
+
+      def reflection(predicate)
+        @model.outgoing_reflections.find { |key, reflection| reflection.predicate == predicate }.first
+      end
+    end
+
+    # @param json [String] json to be parsed into attributes
+    def init_with_json(json)
+      attrs = JSON.parse(json)
+      id = attrs.delete('id')
+
+      @ldp_source = build_ldp_resource(id)
+      @association_cache = {}
+      datastream_keys = self.class.child_resource_reflections.keys
+      datastream_keys.each do |key|
+        attached_files[key] = SolrBackedMetadataFile.new
+      end
+      @resource = SolrBackedResource.new(self.class)
+      self.attributes = attrs.except(datastream_keys)
+      # TODO Should we clear the change tracking, or make this object Read-only?
+
+      run_callbacks :find
+      run_callbacks :initialize
+      freeze
+      self
+    end
+
+  end
+end

data/lib/active_fedora/model.rb

@@ -5,38 +5,24 @@ module ActiveFedora
   # This module mixes various methods into the including class,
   # much in the way ActiveRecord does.  
   module Model 
-    # Takes a Fedora URI for a cModel and returns classname, namespace
-    def self.classname_from_uri(uri)
-      local_path = uri.split('/')[1]
-      parts = local_path.split(':')
-      return parts[-1].split(/_/).map(&:camelize).join('::'), parts[0]
-    end
 
     # Takes a Fedora URI for a cModel, and returns a 
     # corresponding Model if available
     # This method should reverse ClassMethods#to_class_uri
     # @return [Class, False] the class of the model or false, if it does not exist
-    def self.from_class_uri(uri)
-      model_value, pid_ns = classname_from_uri(uri)
-      raise "model URI incorrectly formatted: #{uri}" unless model_value
+    def self.from_class_uri(model_value)
 
       unless class_exists?(model_value)
-        ActiveFedora::Base.logger.warn "#{model_value} is not a real class" if ActiveFedora::Base.logger
-        return false
-      end
-      result = ActiveFedora.class_from_string(model_value)
-      unless result.nil?
-        model_ns = (result.respond_to? :pid_namespace) ? result.pid_namespace : ContentModel::CMODEL_NAMESPACE
-        if model_ns != pid_ns
-          ActiveFedora::Base.logger.warn "Model class namespace '#{model_ns}' does not match uri: '#{uri}'" if ActiveFedora::Base.logger
-        end
+        ActiveFedora::Base.logger.warn "'#{model_value}' is not a real class" if ActiveFedora::Base.logger
+        return nil
       end
-      result
+      ActiveFedora.class_from_string(model_value)
     end
 
     private 
     
     def self.class_exists?(class_name)
+      return false if class_name.empty?
       klass = class_name.constantize
       return klass.is_a?(Class)
     rescue NameError

data/lib/active_fedora/nested_attributes.rb

@@ -64,8 +64,8 @@ module ActiveFedora
         attr_names.each do |association_name|
           if reflection = reflect_on_association(association_name)
             reflection.options[:autosave] = true
-            # add_autosave_association_callbacks(reflection)
-            ## TODO this ought to work, but doesn't seem to do the class inheitance right
+            add_autosave_association_callbacks(reflection)
+            ## TODO this ought to work, but doesn't seem to do the class inheritance right
 
             nested_attributes_options = self.nested_attributes_options.dup
             nested_attributes_options[association_name.to_sym] = options
@@ -81,8 +81,6 @@ module ActiveFedora
 
               def #{association_name}_attributes=(attributes)
                 assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
-                ## in lieu of autosave_association_callbacks just save all of em.
-                send(:#{association_name}).each {|obj| obj.marked_for_destruction? ? obj.destroy : obj.save}
               end
             eoruby
           else
@@ -101,7 +99,7 @@ module ActiveFedora
       marked_for_destruction?
     end
 
-    private 
+    private
 
     # Attribute hash keys that should not be assigned as normal attributes.
     # These hash keys are nested attributes implementation details.
@@ -124,13 +122,14 @@ module ActiveFedora
         end
       end
 
+
       association = send(association_name)
 
       existing_records = if association.loaded?
         association.to_a
       else
         attribute_ids = attributes_collection.map {|a| a['id'] || a[:id] }.compact
-        attribute_ids.present? ? association.to_a.select{ |x| attribute_ids.include?(x.pid)} : []
+        attribute_ids.present? ? association.to_a.select{ |x| attribute_ids.include?(x.id)} : []
       end
 
       attributes_collection.each do |attributes|

data/lib/active_fedora/nom_datastream.rb

@@ -1,35 +1,25 @@
 require  "nom"
 
 module ActiveFedora
-  class NomDatastream < Datastream
+  class NomDatastream < File
 
-      include Datastreams::NokogiriDatastreams
+    include Datastreams::NokogiriDatastreams
 
-      def self.set_terminology(options = {}, &block)
-        @terminology_options = options || {}
-        @terminology = block
-      end
-
-      def self.terminology_options
-        @terminology_options
-      end
+    def self.set_terminology(options = {}, &block)
+      @terminology_options = options || {}
+      @terminology = block
+    end
 
-      def self.terminology
-        @terminology
-      end
+    def self.terminology_options
+      @terminology_options
+    end
 
-    def self.default_attributes
-      super.merge(:controlGroup => 'M', :mimeType => 'text/xml')
+    def self.terminology
+      @terminology
     end
 
-    # Create an instance of this class based on xml content
-    # @param [String, File, Nokogiri::XML::Node] xml the xml content to build from
-    # @param [ActiveFedora::MetadataDatastream] tmpl the Datastream object that you are building @default a new instance of this class
-    # Careful! If you call this from a constructor, be sure to provide something 'ie. self' as the @tmpl. Otherwise, you will get an infinite loop!
-    def self.from_xml(xml, tmpl=nil)
-      ds = self.new nil, nil
-      ds.content = xml.to_s
-      ds
+    def self.default_attributes
+      super.merge(:mimeType => 'text/xml')
     end
 
     def self.decorate_ng_xml(xml)
@@ -37,7 +27,7 @@ module ActiveFedora
       xml.nom!
       xml
     end
-    
+
     def serialize!
        self.content = @ng_xml.to_s if @ng_xml
     end
@@ -58,7 +48,7 @@ module ActiveFedora
         end
       end
 
-      solr_doc 
+      solr_doc
     end
 
     def method_missing method, *args, &block

data/lib/active_fedora/om_datastream.rb

@@ -1,18 +1,14 @@
 require  "om"
 
 module ActiveFedora
-  class OmDatastream < Datastream
+  class OmDatastream < File
 
-    before_save do
-      if content.blank?
-        ActiveFedora::Base.logger.warn "Cowardly refusing to save a datastream with empty content: #{self.inspect}" if ActiveFedora::Base.logger
-        if ActiveSupport.version >= Gem::Version.new('5.0')
-          throw(:abort)
-        else
-          false
-        end
-      end
-    end
+    # before_save do
+    #   if content.blank?
+    #     ActiveFedora::Base.logger.warn "Cowardly refusing to save a datastream with empty content: #{self.inspect}"
+    #     false
+    #   end
+    # end
 
     include OM::XML::Document
     include OM::XML::TerminologyBasedSolrizer # this adds support for calling .to_solr
@@ -20,177 +16,29 @@ module ActiveFedora
 
     alias_method(:om_term_values, :term_values) unless method_defined?(:om_term_values)
     alias_method(:om_update_values, :update_values) unless method_defined?(:om_update_values)
-    
-    attr_accessor :internal_solr_doc
 
-    def self.default_attributes
-      super.merge(:controlGroup => 'M', :mimeType => 'text/xml')
+    def default_mime_type
+      'text/xml'
     end
 
-    # Indicates that this datastream has metadata content. 
-    # @return true 
+    # Indicates that this datastream has metadata content.
+    # @return true
     def metadata?
       true
     end
 
-    # ** Experimental **
-    #
-    # This method is called by ActiveFedora::Base.load_instance_from_solr
-    # in order to initialize a nokogiri datastreams values from a solr document.
-    # This method merely sets the internal_solr_doc to the document passed in.
-    # Then any calls to get_values get values from the solr document on demand
-    # instead of directly from the xml stored in Fedora.  This should be used
-    # for read-only purposes only, and instances where you want to improve performance by
-    # getting data from solr instead of Fedora.
-    # 
-    # See ActiveFedora::Base.load_instance_from_solr and +get_values_from_solr+ for more information.
-    def from_solr(solr_doc)
-      #just initialize internal_solr_doc since any value retrieval will be done via lazy loading on this doc on-demand
-      @internal_solr_doc = solr_doc
-    end
-
     # Return a hash suitable for indexing in solr. Every field name is prefixed with the
     # value returned by the +prefix+ method.
-    def to_solr(solr_doc = {})
-      prefix = self.prefix
+    def to_solr(solr_doc = {}, opts = {})
+      prefix = self.prefix(opts[:name])
       solr_doc.merge super({}).each_with_object({}) { |(key, value), new| new[[prefix,key].join] = value }
     end
 
-    # This method is called by +get_values+ if this datastream has been initialized by calling from_solr method via
-    # ActiveFedora::Base.load_instance_from_solr. This method retrieves values from a preinitialized @internal_solr_doc instead of xml.
-    # This makes the datastream read-only and this method is not intended to be used in any other case.
-    #
-    # Values are retrieved from the @internal_solr_doc on-demand instead of via xml preloaded into memory.  
-    # A term_pointer is passed in and if it contains hierarchical indexes it will detect which solr field values need to be returned.
-    #
-    # ====Example 1 (non-hierarchical term_pointer):
-    #
-    #   term_pointer = [:image, :title_set, :title]
-    #
-    #   Returns value of "image_title_set_title_t" in @internal_solr_doc
-    #
-    # ====Example 2 (hierarchical term_pointer that contains one or more indexes):
-    #   term_pointer = [:image, {:title_set=>1}, :title]
-    #
-    #   relevant xml:  
-    #         <image>
-    #           <title_set>
-    #             <title>Title 1</title>
-    #           </title_set>
-    #         </image>
-    #         <image>
-    #           <title_set>
-    #             <title>Title 2</title>
-    #           </title_set>
-    #           <title_set>
-    #             <title>Title 3</title>
-    #           </title_set>
-    #         </image>
-    #    
-    #   Repeating element nodes are indexed and will be stored in solr as follows:
-    #     image_0_title_set_0_title_t = "Title 1"
-    #     image_1_title_set_0_title_t = "Title 2"
-    #     image_1_title_set_1_title_t = "Title 3"
-    #
-    #   Even though no image element index is specified, only the second image element has two title_set elements so the expected return value is
-    #     ["Title 3"]
-    #
-    #   While loading from solr the xml hierarchy is not immediately apparent so we must detect first how many image elements with a title_set element exist
-    #   and then check which of those elements have a second title element.
-    #   
-    #   As this nokogiri datastream is indexed in solr, a value at each level in the tree will be stored independently and therefore 
-    #   if 'image_0_title_set_0_title_t' exists in solr 'image_0_title_set_t' will also exist in solr.  
-    #   So, we will build up the relevant solr names incrementally for a given term_pointer.  The last element in the
-    #   solr_name will not contain an index.
-    #
-    #   It then will do the following:
-    #     Because no index is supplied for :image it will detect which indexes exist in solr
-    #        image_0_title_set_t   (found key and add 'image_0_title_set' to base solr_name list)
-    #        image_1_title_set_t   (found key and add 'image_0_title_set' to base solr_name list)
-    #        image_2_title_set_t   (not found and stop checking indexes for image)
-    #     After iteration 1:
-    #        bases = ["image_0_title_set","image_1_title_set"]
-    #
-    #     Two image nodes were found and next sees index of 1 supplied for title_set so just uses index of 1 building off bases found in previous iteration
-    #        image_0_title_set_1_title_t (not found remove 'image_0_title_set' from base solr_name list)
-    #        image_1_title_set_1_title_t (found and replace 'image_1_title_set' with new base 'image_1_title_set_1_title') 
-    #      
-    #     After iteration 2:
-    #        bases = ["image_1_title_set_1_title"]
-    #     It always looks ahead one element so we check if any elements are after title.  There are not any other elements so we are done iterating.
-    #        returns @internal_solr_doc["image_1_title_set_1_title_t"]
-    # @param [Array] term_pointer Term pointer similar to an xpath ie. [:image, :title_set, :title]
-    # @return [Array] If no values are found an empty Array is returned.
-    def get_values_from_solr(*term_pointer)
-      values = []
-      solr_doc = @internal_solr_doc
-      return values if solr_doc.nil?
-      term = self.class.terminology.retrieve_term(*OM.pointers_to_flat_array(term_pointer, false))
-      #check if hierarchical term pointer
-      if is_hierarchical_term_pointer?(*term_pointer)
-         # if we are hierarchical need to detect all possible node values that exist
-         # we do this by building up the possible solr names parent by parent and/or child by child
-         # if an index is supplied for any node in the pointer it will be used
-         # otherwise it will include all nodes and indexes that exist in solr
-         bases = []
-         #add first item in term_pointer as start of bases
-         # then iterate through possible nodes that might exist
-         term_pointer.first.kind_of?(Hash) ? bases << term_pointer.first.keys.first : bases << term_pointer.first
-         for i in 1..(term_pointer.length-1)
-           #iterate in reverse so that we can modify the bases array while iterating
-           (bases.length-1).downto(0) do |j|
-             current_last = (term_pointer[i].kind_of?(Hash) ? term_pointer[i].keys.first : term_pointer[i])
-             if (term_pointer[i-1].kind_of?(Hash))
-               #just use index supplied instead of trying possibilities
-               index = term_pointer[i-1].values.first
-               solr_name_base = OM::XML::Terminology.term_hierarchical_name({bases[j]=>index},current_last)
-               solr_name = generate_solr_symbol(solr_name_base, term.type)
-               bases.delete_at(j)
-               #insert the new solr name base if found
-               bases.insert(j,solr_name_base) if has_solr_name?(solr_name,solr_doc)
-             else
-               #detect how many nodes exist
-               index = 0
-               current_base = bases[j]
-               bases.delete_at(j)
-               solr_name_base = OM::XML::Terminology.term_hierarchical_name({current_base=>index},current_last)
-               solr_name = generate_solr_symbol(solr_name_base, term.type)
-               #check for indexes that exist until we find all nodes
-               while has_solr_name?(solr_name,solr_doc) do
-                 #only reinsert if it exists
-                 bases.insert(j,solr_name_base)
-                 index = index + 1
-                 solr_name_base = OM::XML::Terminology.term_hierarchical_name({current_base=>index},current_last)
-                 solr_name = generate_solr_symbol(solr_name_base, term.type)
-               end
-             end
-           end
-         end
-
-         #all existing applicable solr_names have been found and we can now grab all values and build up our value array
-         bases.each do |base|
-           field_name = generate_solr_symbol(base.to_sym, term.type)
-           value = (solr_doc[field_name].nil? ? solr_doc[field_name.to_s]: solr_doc[field_name])
-           unless value.nil?
-             value.is_a?(Array) ? values.concat(value) : values << value
-           end
-         end
-      else
-         #this is not hierarchical and we can simply look for the solr name created using the terms without any indexes
-         generic_field_name_base = OM::XML::Terminology.term_generic_name(*term_pointer)
-         generic_field_name = generate_solr_symbol(generic_field_name_base, term.type)
-         value = (solr_doc[generic_field_name].nil? ? solr_doc[generic_field_name.to_s]: solr_doc[generic_field_name])
-         unless value.nil?
-           value.is_a?(Array) ? values.concat(value) : values << value
-         end
-      end
-      values
-    end
-
     def generate_solr_symbol(base, data_type)
-      ActiveFedora::SolrService.solr_name([prefix, base].join, type: data_type)
+      ActiveFedora::SolrService.solr_name([prefix,base].join, type: data_type)
     end
 
+    # ** Experimental **
     #@return [Boolean] true if either the key for name exists in solr or if its string value exists
     #@param [String] name Name of key to look for
     #@param [Solr::Document] solr_doc Solr doc to query
@@ -198,6 +46,7 @@ module ActiveFedora
       !solr_doc[name].nil? || !solr_doc[name.to_s].nil?
     end
 
+    # ** Experimental **
     #@return true if the term_pointer contains an index
     # ====Example:
     #     [:image, {:title_set=>1}, :title] return true
@@ -238,16 +87,16 @@ module ActiveFedora
     #     </mods:role>
     #     </mods:name>
     #   </mods>
-    def update_indexed_attributes(params={}, opts={})    
+    def update_indexed_attributes(params={}, opts={})
       if self.class.terminology.nil?
         raise "No terminology is set for this OmDatastream class.  Cannot perform update_indexed_attributes"
       end
-      # remove any fields from params that this datastream doesn't recognize    
+      # remove any fields from params that this datastream doesn't recognize
       # make sure to make a copy of params so not to modify hash that might be passed to other methods
       current_params = params.clone
-      current_params.delete_if do |term_pointer,new_values| 
+      current_params.delete_if do |term_pointer,new_values|
         if term_pointer.kind_of?(String)
-          ActiveFedora::Base.logger.warn "WARNING: #{dsid} ignoring {#{term_pointer.inspect} => #{new_values.inspect}} because #{term_pointer.inspect} is a String (only valid OM Term Pointers will be used).  Make sure your html has the correct field_selector tags in it." if ActiveFedora::Base.logger
+          ActiveFedora::Base.logger.warn "WARNING: #{self.class.name} ignoring {#{term_pointer.inspect} => #{new_values.inspect}} because #{term_pointer.inspect} is a String (only valid OM Term Pointers will be used).  Make sure your html has the correct field_selector tags in it." if ActiveFedora::Base.logger
           true
         else
           !self.class.terminology.has_term?(*OM.destringify(term_pointer))
@@ -258,10 +107,10 @@ module ActiveFedora
       unless current_params.empty?
         result = update_values( current_params )
       end
-      
+
       return result
     end
-    
+
     def get_values(field_key,default=[])
       term_values(*field_key)
     end
@@ -276,32 +125,12 @@ module ActiveFedora
     #
     # @example Updating multiple values with a Hash of Term pointers and values
     #   ds.update_values( {[{":person"=>"0"}, "role", "text"]=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}, [{:person=>1}, :family_name]=>"Andronicus", [{"person"=>"1"},:given_name]=>["Titus"],[{:person=>1},:role,:text]=>["otherrole1","otherrole2"] } )
-    #   => {"person_0_role_text"=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}, "person_1_role_text"=>{"0"=>"otherrole1", "1"=>"otherrole2"}} 
+    #   => {"person_0_role_text"=>{"0"=>"role1", "1"=>"role2", "2"=>"role3"}, "person_1_role_text"=>{"0"=>"otherrole1", "1"=>"otherrole2"}}
     def update_values(params={})
       raise "can't modify frozen #{self.class}" if frozen?
-      if @internal_solr_doc
-        raise "No update performed, this object was initialized via Solr instead of Fedora and is therefore read-only.  Please utilize ActiveFedora::Base.find to first load object via Fedora instead."
-      else
-        ng_xml_will_change!
-        result = om_update_values(params)
-        return result
-      end
-    end
-
-    #override OM::XML::term_values so can lazy load from solr if this datastream initialized using +from_solr+
-    def term_values(*term_pointer)
-      # TODO if we can add primary_solr_name onto OmDatastream, we may be able to do away with get_values_from_solr.
-      if @internal_solr_doc
-        #lazy load values from solr on demand
-        get_values_from_solr(*term_pointer)
-      else
-        om_term_values(*term_pointer)
-      end
-    end
-
-    def reset_profile_attributes
-      super
-      clear_attribute_changes([:ng_xml])
+      ng_xml_will_change!
+      result = om_update_values(params)
+      return result
     end
 
   end