X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/ae142c554b0356aabc11dbe0f93482d361b32e4b..c2854a8056a19219d4ecd4e29099f2ef6224f2d0:/app/models/relation.rb diff --git a/app/models/relation.rb b/app/models/relation.rb index 74832a7d9..c8516b58a 100644 --- a/app/models/relation.rb +++ b/app/models/relation.rb @@ -1,14 +1,17 @@ class Relation < ActiveRecord::Base require 'xml/libxml' + set_table_name 'current_relations' + belongs_to :user + has_many :old_relations, :foreign_key => 'id', :order => 'version' + has_many :relation_members, :foreign_key => 'id' has_many :relation_tags, :foreign_key => 'id' - has_many :old_relations, :foreign_key => 'id', :order => 'version' - - set_table_name 'current_relations' + 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 def self.from_xml(xml, create=false) begin @@ -102,41 +105,53 @@ class Relation < ActiveRecord::Base return el1 end - def self.find_for_nodes_and_ways(node_ids, way_ids) - # collect relationships. currently done in one big block at the end; - # may need to move this upwards if people want automatic completion of - # relationships, i.e. deliver referenced objects like we do with ways... - relations = Array.new - if node_ids.length > 0 - relations += Relation.find_by_sql("select e.* from current_relations e,current_relation_members em where " + - "e.visible=1 and " + - "em.id = e.id and em.member_type='node' and em.member_id in (#{node_ids.join(',')})") + def self.find_for_nodes(ids, options = {}) + if ids.empty? + return [] + else + self.with_scope(:find => { :joins => "INNER JOIN current_relation_members ON current_relation_members.id = current_relations.id", :conditions => "current_relation_members.member_type = 'node' AND current_relation_members.member_id IN (#{ids.join(',')})" }) do + return self.find(:all, options) + end end - if way_ids.length > 0 - relations += Relation.find_by_sql("select e.* from current_relations e,current_relation_members em where " + - "e.visible=1 and " + - "em.id = e.id and em.member_type='way' and em.member_id in (#{way_ids.join(',')})") + end + + def self.find_for_ways(ids, options = {}) + if ids.empty? + return [] + else + self.with_scope(:find => { :joins => "INNER JOIN current_relation_members ON current_relation_members.id = current_relations.id", :conditions => "current_relation_members.member_type = 'way' AND current_relation_members.member_id IN (#{ids.join(',')})" }) do + return self.find(:all, options) + end end end + def self.find_for_relations(ids, options = {}) + if ids.empty? + return [] + else + self.with_scope(:find => { :joins => "INNER JOIN current_relation_members ON current_relation_members.id = current_relations.id", :conditions => "current_relation_members.member_type = 'relation' AND current_relation_members.member_id IN (#{ids.join(',')})" }) do + return self.find(:all, options) + end + end + end # FIXME is this really needed? def members unless @members - @members = Array.new - self.relation_members.each do |member| - @members += [[member.member_type,member.member_id,member.member_role]] - end + @members = Array.new + self.relation_members.each do |member| + @members += [[member.member_type,member.member_id,member.member_role]] + end end @members end def tags unless @tags - @tags = Hash.new - self.relation_tags.each do |tag| - @tags[tag.k] = tag.v - end + @tags = Hash.new + self.relation_tags.each do |tag| + @tags[tag.k] = tag.v + end end @tags end @@ -170,11 +185,11 @@ class Relation < ActiveRecord::Base RelationTag.delete_all(['id = ?', self.id]) tags.each do |k,v| - tag = RelationTag.new - tag.k = k - tag.v = v - tag.id = self.id - tag.save! + tag = RelationTag.new + tag.k = k + tag.v = v + tag.id = self.id + tag.save! end members = self.members @@ -182,12 +197,12 @@ class Relation < ActiveRecord::Base RelationMember.delete_all(['id = ?', self.id]) members.each do |n| - mem = RelationMember.new - mem.id = self.id - mem.member_type = n[0]; - mem.member_id = n[1]; - mem.member_role = n[2]; - mem.save! + mem = RelationMember.new + mem.id = self.id + mem.member_type = n[0]; + mem.member_id = n[1]; + mem.member_role = n[2]; + mem.save! end old_relation = OldRelation.from_relation(self) @@ -197,22 +212,49 @@ class Relation < ActiveRecord::Base end 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.. + # 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 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]] + return false + else + relations[m[1]] = true + end else return false end @@ -222,4 +264,8 @@ class Relation < ActiveRecord::Base return false end + # Temporary method to match interface to nodes + def tags_as_hash + return self.tags + end end