Fixed bug in changeset idle timeout. Fixed another with a spurious require.

[rails.git] / app / models / relation.rb

diff --git a/app/models/relation.rb b/app/models/relation.rb
index cc7977833679b617ccea4807a2ff16c4b4d58a0d..2607e7f2fd3c0f17ecb314730248839f494e7f52 100644 (file)
--- 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 :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 :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
 
       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
 
     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
       # 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
       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
           members.delete key

-

         else
           changed_members << 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
         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 = 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
 
         mem.save!
       end
 


@@ -304,6 +307,9 @@ class Relation < ActiveRecord::Base
         end
       end
 
         end
       end
 

+      # tell the changeset we updated one element only
+      changeset.add_changes! 1
+

       # save the (maybe updated) changeset bounding box
       changeset.save!
     end
       # 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)
   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
         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.
   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}
     # 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|
     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
           return false

-        else
-          relations[m[1]] = true

         end
         end

-      else
-        return false
+        hash[m[1]] = true

       end
     end
       end
     end

+

     return true
   rescue
     return false
   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
   # Temporary method to match interface to nodes
   def tags_as_hash
     return self.tags