X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/d43a327a950591278f56041ced57986582dbcfb2..783528830ad1b0d5f07c8e758747841a0b4e5cc6:/app/models/relation.rb?ds=inline diff --git a/app/models/relation.rb b/app/models/relation.rb index cc7977833..2607e7f2f 100644 --- a/app/models/relation.rb +++ b/app/models/relation.rb @@ -9,7 +9,7 @@ class Relation < ActiveRecord::Base has_many :old_relations, :foreign_key => 'id', :order => 'version' - has_many :relation_members, :foreign_key => 'id' + has_many :relation_members, :foreign_key => 'id', :order => 'sequence_id' has_many :relation_tags, :foreign_key => 'id' has_many :containing_relation_members, :class_name => "RelationMember", :as => :member @@ -83,7 +83,10 @@ class Relation < ActiveRecord::Base user_display_name_cache[self.changeset.user_id] = nil end - el1['user'] = user_display_name_cache[self.changeset.user_id] unless user_display_name_cache[self.changeset.user_id].nil? + if not user_display_name_cache[self.changeset.user_id].nil? + el1['user'] = user_display_name_cache[self.changeset.user_id] + el1['uid'] = self.changeset.user_id.to_s + end self.relation_members.each do |member| p=0 @@ -240,33 +243,33 @@ class Relation < ActiveRecord::Base # changed members in an array, as the bounding box updates for # elements are per-element, not blanked on/off like for tags. changed_members = Array.new - members = self.members_as_hash + members = Hash.new + self.members.each do |m| + # should be: h[[m.id, m.type]] = m.role, but someone prefers arrays + members[[m[1], m[0]]] = m[2] + end relation_members.each do |old_member| key = [old_member.member_id.to_s, old_member.member_type] if members.has_key? key - # i'd love to rely on rails' dirty handling here, but the - # relation members are always dirty because of the member_class - # handling. - if members[key] != old_member.member_role - old_member.member_role = members[key] - changed_members << key - old_member.save! - end members.delete key - else changed_members << key - RelationMember.delete_all ['id = ? and member_id = ? and member_type = ?', self.id, old_member.member_id, old_member.member_type] end end # any remaining members must be new additions changed_members += members.keys - members.each do |k,v| + + # update the members. first delete all the old members, as the new + # members may be in a different order and i don't feel like implementing + # a longest common subsequence algorithm to optimise this. + members = self.members + RelationMember.delete_all(:id => self.id) + members.each_with_index do |m,i| mem = RelationMember.new - mem.id = self.id - mem.member_type = k[1]; - mem.member_id = k[0]; - mem.member_role = v; + mem.id = [self.id, i] + mem.member_type = m[0] + mem.member_id = m[1] + mem.member_role = m[2] mem.save! end @@ -304,6 +307,9 @@ class Relation < ActiveRecord::Base end end + # tell the changeset we updated one element only + changeset.add_changes! 1 + # save the (maybe updated) changeset bounding box changeset.save! end @@ -322,7 +328,7 @@ class Relation < ActiveRecord::Base def delete_with_history!(new_relation, user) if self.visible check_consistency(self, new_relation, user) - if RelationMember.find(:first, :joins => "INNER JOIN current_relations ON current_relations.id=current_relation_members.id", :conditions => [ "visible = 1 AND member_type='relation' and member_id=? ", self.id ]) + if RelationMember.find(:first, :joins => "INNER JOIN current_relations ON current_relations.id=current_relation_members.id", :conditions => [ "visible = ? AND member_type='relation' and member_id=? ", true, self.id ]) raise OSM::APIPreconditionFailedError.new else self.changeset_id = new_relation.changeset_id @@ -361,67 +367,37 @@ class Relation < ActiveRecord::Base def preconditions_ok? # These are hastables that store an id in the index of all # the nodes/way/relations that have already been added. - # Once we know the id of the node/way/relation exists - # we check to see if it is already existing in the hashtable - # if it does, then we return false. Otherwise - # we add it to the relevant hash table, with the value true.. + # If the member is valid and visible then we add it to the + # relevant hash table, with the value true as a cache. # Thus if you have nodes with the ids of 50 and 1 already in the # relation, then the hash table nodes would contain: # => {50=>true, 1=>true} - nodes = Hash.new - ways = Hash.new - relations = Hash.new + elements = { :node => Hash.new, :way => Hash.new, :relation => Hash.new } self.members.each do |m| - if (m[0] == "node") - n = Node.find(:first, :conditions => ["id = ?", m[1]]) - unless n and n.visible - return false - end - if nodes[m[1]] - return false - else - nodes[m[1]] = true - end - elsif (m[0] == "way") - w = Way.find(:first, :conditions => ["id = ?", m[1]]) - unless w and w.visible and w.preconditions_ok? - return false - end - if ways[m[1]] - return false - else - ways[m[1]] = true - end - elsif (m[0] == "relation") - e = Relation.find(:first, :conditions => ["id = ?", m[1]]) - unless e and e.visible and e.preconditions_ok? - return false - end - if relations[m[1]] + # find the hash for the element type or die + hash = elements[m[0].to_sym] or return false + + # unless its in the cache already + unless hash.key? m[1] + # use reflection to look up the appropriate class + model = Kernel.const_get(m[0].capitalize) + + # get the element with that ID + element = model.find(m[1]) + + # and check that it is OK to use. + unless element and element.visible? and element.preconditions_ok? return false - else - relations[m[1]] = true end - else - return false + hash[m[1]] = true end end + return true rescue return false end - ## - # members in a hash table [id,type] => role - def members_as_hash - h = Hash.new - members.each do |m| - # should be: h[[m.id, m.type]] = m.role, but someone prefers arrays - h[[m[1], m[0]]] = m[2] - end - return h - end - # Temporary method to match interface to nodes def tags_as_hash return self.tags