X-Git-Url: https://git.openstreetmap.org/rails.git/blobdiff_plain/7058d836f75c845b7790c7ab6eb2f75844ce0c1c..8348493ccb02fd0bb3f46733d8176b503f9f9883:/app/models/relation.rb diff --git a/app/models/relation.rb b/app/models/relation.rb index be990e589..0159c60b8 100644 --- a/app/models/relation.rb +++ b/app/models/relation.rb @@ -9,12 +9,22 @@ 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 has_many :containing_relations, :class_name => "Relation", :through => :containing_relation_members, :source => :relation, :extend => ObjectFinder + validates_presence_of :id, :on => :update + validates_presence_of :timestamp,:version, :changeset_id + validates_uniqueness_of :id + validates_inclusion_of :visible, :in => [ true, false ] + validates_numericality_of :id, :on => :update, :integer_only => true + validates_numericality_of :changeset_id, :version, :integer_only => true + validates_associated :changeset + + TYPES = ["node", "way", "relation"] + def self.from_xml(xml, create=false) begin p = XML::Parser.new @@ -22,10 +32,10 @@ class Relation < ActiveRecord::Base doc = p.parse doc.find('//osm/relation').each do |pt| - return Relation.from_xml_node(pt, create) + return Relation.from_xml_node(pt, create) end - rescue - return nil + rescue LibXML::XML::Error => ex + raise OSM::APIBadXMLError.new("relation", xml, ex.message) end end @@ -36,16 +46,18 @@ class Relation < ActiveRecord::Base relation.id = pt['id'].to_i end - relation.version = pt['version'] + raise OSM::APIBadXMLError.new("relation", pt, "You are missing the required changeset in the relation") if pt['changeset'].nil? relation.changeset_id = pt['changeset'] if create relation.timestamp = Time.now relation.visible = true + relation.version = 0 else if pt['timestamp'] relation.timestamp = Time.parse(pt['timestamp']) end + relation.version = pt['version'] end pt.find('tag').each do |tag| @@ -53,8 +65,17 @@ class Relation < ActiveRecord::Base end pt.find('member').each do |member| + #member_type = + logger.debug "each member" + raise OSM::APIBadXMLError.new("relation", pt, "The #{member['type']} is not allowed only, #{TYPES.inspect} allowed") unless TYPES.include? member['type'] + logger.debug "after raise" + #member_ref = member['ref'] + #member_role + member['role'] ||= "" # Allow the upload to not include this, in which case we default to an empty string. + logger.debug member['role'] relation.add_member(member['type'], member['ref'], member['role']) end + raise OSM::APIBadUserInput.new("Some bad xml in relation") if relation.nil? return relation end @@ -83,7 +104,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 +264,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 +328,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,15 +349,15 @@ class Relation < ActiveRecord::Base def delete_with_history!(new_relation, user) if self.visible check_consistency(self, new_relation, user) + # This will check to see if this relation is used by another relation 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 - self.tags = {} - self.members = [] - self.visible = false - save_with_history! + raise OSM::APIPreconditionFailedError.new("The relation #{new_relation.id} is a used in another relation") end + self.changeset_id = new_relation.changeset_id + self.tags = {} + self.members = [] + self.visible = false + save_with_history! else raise OSM::APIAlreadyDeletedError.new end @@ -361,67 +388,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? + # 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 end - if relations[m[1]] - 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