Merge branch 'master' into openid
[rails.git] / app / models / way.rb
1 class Way < ActiveRecord::Base
2   require 'xml/libxml'
3   
4   include ConsistencyValidations
5
6   set_table_name 'current_ways'
7   
8   belongs_to :changeset
9
10   has_many :old_ways, :foreign_key => 'id', :order => 'version'
11
12   has_many :way_nodes, :foreign_key => 'id', :order => 'sequence_id'
13   has_many :nodes, :through => :way_nodes, :order => 'sequence_id'
14
15   has_many :way_tags, :foreign_key => 'id'
16
17   has_many :containing_relation_members, :class_name => "RelationMember", :as => :member
18   has_many :containing_relations, :class_name => "Relation", :through => :containing_relation_members, :source => :relation, :extend => ObjectFinder
19
20   validates_presence_of :id, :on => :update
21   validates_presence_of :changeset_id,:version,  :timestamp
22   validates_uniqueness_of :id
23   validates_inclusion_of :visible, :in => [ true, false ]
24   validates_numericality_of :changeset_id, :version, :integer_only => true
25   validates_numericality_of :id, :on => :update, :integer_only => true
26   validates_associated :changeset
27
28   # Read in xml as text and return it's Way object representation
29   def self.from_xml(xml, create=false)
30     begin
31       p = XML::Parser.string(xml)
32       doc = p.parse
33
34       doc.find('//osm/way').each do |pt|
35         return Way.from_xml_node(pt, create)
36       end
37       raise OSM::APIBadXMLError.new("node", xml, "XML doesn't contain an osm/way element.")
38     rescue LibXML::XML::Error, ArgumentError => ex
39       raise OSM::APIBadXMLError.new("way", xml, ex.message)
40     end
41   end
42
43   def self.from_xml_node(pt, create=false)
44     way = Way.new
45
46     raise OSM::APIBadXMLError.new("way", pt, "Version is required when updating") unless create or not pt['version'].nil?
47     way.version = pt['version']
48     raise OSM::APIBadXMLError.new("way", pt, "Changeset id is missing") if pt['changeset'].nil?
49     way.changeset_id = pt['changeset']
50
51     unless create
52       raise OSM::APIBadXMLError.new("way", pt, "ID is required when updating") if pt['id'].nil?
53       way.id = pt['id'].to_i
54       # .to_i will return 0 if there is no number that can be parsed. 
55       # We want to make sure that there is no id with zero anyway
56       raise OSM::APIBadUserInput.new("ID of way cannot be zero when updating.") if way.id == 0
57     end
58
59     # We don't care about the timestamp nor the visibility as these are either
60     # set explicitly or implicit in the action. The visibility is set to true, 
61     # and manually set to false before the actual delete.
62     way.visible = true
63
64     pt.find('tag').each do |tag|
65       raise OSM::APIBadXMLError.new("way", pt, "tag is missing key") if tag['k'].nil?
66       raise OSM::APIBadXMLError.new("way", pt, "tag is missing value") if tag['v'].nil?
67       way.add_tag_keyval(tag['k'], tag['v'])
68     end
69
70     pt.find('nd').each do |nd|
71       way.add_nd_num(nd['ref'])
72     end
73
74     return way
75   end
76
77   # Find a way given it's ID, and in a single SQL call also grab its nodes
78   #
79   
80   # You can't pull in all the tags too unless we put a sequence_id on the way_tags table and have a multipart key
81   def self.find_eager(id)
82     way = Way.find(id, :include => {:way_nodes => :node})
83     #If waytag had a multipart key that was real, you could do this:
84     #way = Way.find(id, :include => [:way_tags, {:way_nodes => :node}])
85   end
86
87   # Find a way given it's ID, and in a single SQL call also grab its nodes and tags
88   def to_xml
89     doc = OSM::API.new.get_xml_doc
90     doc.root << to_xml_node()
91     return doc
92   end
93
94   def to_xml_node(visible_nodes = nil, changeset_cache = {}, user_display_name_cache = {})
95     el1 = XML::Node.new 'way'
96     el1['id'] = self.id.to_s
97     el1['visible'] = self.visible.to_s
98     el1['timestamp'] = self.timestamp.xmlschema
99     el1['version'] = self.version.to_s
100     el1['changeset'] = self.changeset_id.to_s
101
102     if changeset_cache.key?(self.changeset_id)
103       # use the cache if available
104     else
105       changeset_cache[self.changeset_id] = self.changeset.user_id
106     end
107
108     user_id = changeset_cache[self.changeset_id]
109
110     if user_display_name_cache.key?(user_id)
111       # use the cache if available
112     elsif self.changeset.user.data_public?
113       user_display_name_cache[user_id] = self.changeset.user.display_name
114     else
115       user_display_name_cache[user_id] = nil
116     end
117
118     if not user_display_name_cache[user_id].nil?
119       el1['user'] = user_display_name_cache[user_id]
120       el1['uid'] = user_id.to_s
121     end
122
123     # make sure nodes are output in sequence_id order
124     ordered_nodes = []
125     self.way_nodes.each do |nd|
126       if visible_nodes
127         # if there is a list of visible nodes then use that to weed out deleted nodes
128         if visible_nodes[nd.node_id]
129           ordered_nodes[nd.sequence_id] = nd.node_id.to_s
130         end
131       else
132         # otherwise, manually go to the db to check things
133         if nd.node and nd.node.visible?
134           ordered_nodes[nd.sequence_id] = nd.node_id.to_s
135         end
136       end
137     end
138
139     ordered_nodes.each do |nd_id|
140       if nd_id and nd_id != '0'
141         e = XML::Node.new 'nd'
142         e['ref'] = nd_id
143         el1 << e
144       end
145     end
146
147     self.way_tags.each do |tag|
148       e = XML::Node.new 'tag'
149       e['k'] = tag.k
150       e['v'] = tag.v
151       el1 << e
152     end
153     return el1
154   end 
155
156   def nds
157     unless @nds
158       @nds = Array.new
159       self.way_nodes.each do |nd|
160         @nds += [nd.node_id]
161       end
162     end
163     @nds
164   end
165
166   def tags
167     unless @tags
168       @tags = {}
169       self.way_tags.each do |tag|
170         @tags[tag.k] = tag.v
171       end
172     end
173     @tags
174   end
175
176   def nds=(s)
177     @nds = s
178   end
179
180   def tags=(t)
181     @tags = t
182   end
183
184   def add_nd_num(n)
185     @nds = Array.new unless @nds
186     @nds << n.to_i
187   end
188
189   def add_tag_keyval(k, v)
190     @tags = Hash.new unless @tags
191
192     # duplicate tags are now forbidden, so we can't allow values
193     # in the hash to be overwritten.
194     raise OSM::APIDuplicateTagsError.new("way", self.id, k) if @tags.include? k
195
196     @tags[k] = v
197   end
198
199   ##
200   # the integer coords (i.e: unscaled) bounding box of the way, assuming
201   # straight line segments.
202   def bbox
203     lons = nodes.collect { |n| n.longitude }
204     lats = nodes.collect { |n| n.latitude }
205     [ lons.min, lats.min, lons.max, lats.max ]
206   end
207
208   def update_from(new_way, user)
209     Way.transaction do
210       self.lock!
211       check_consistency(self, new_way, user)
212       unless new_way.preconditions_ok?(self.nds)
213         raise OSM::APIPreconditionFailedError.new("Cannot update way #{self.id}: data is invalid.")
214       end
215       
216       self.changeset_id = new_way.changeset_id
217       self.changeset = new_way.changeset
218       self.tags = new_way.tags
219       self.nds = new_way.nds
220       self.visible = true
221       save_with_history!
222     end
223   end
224
225   def create_with_history(user)
226     check_create_consistency(self, user)
227     unless self.preconditions_ok?
228       raise OSM::APIPreconditionFailedError.new("Cannot create way: data is invalid.")
229     end
230     self.version = 0
231     self.visible = true
232     save_with_history!
233   end
234
235   def preconditions_ok?(old_nodes = [])
236     return false if self.nds.empty?
237     if self.nds.length > MAX_NUMBER_OF_WAY_NODES
238       raise OSM::APITooManyWayNodesError.new(self.id, self.nds.length, MAX_NUMBER_OF_WAY_NODES)
239     end
240
241     # check only the new nodes, for efficiency - old nodes having been checked last time and can't
242     # be deleted when they're in-use.
243     new_nds = (self.nds - old_nodes).sort.uniq
244
245     unless new_nds.empty?
246       db_nds = Node.find(:all, :conditions => { :id => new_nds, :visible => true })
247
248       if db_nds.length < new_nds.length
249         missing = new_nds - db_nds.collect { |n| n.id }
250         raise OSM::APIPreconditionFailedError.new("Way #{self.id} requires the nodes with id in (#{missing.join(',')}), which either do not exist, or are not visible.")
251       end
252     end
253
254     return true
255   end
256
257   def delete_with_history!(new_way, user)
258     unless self.visible
259       raise OSM::APIAlreadyDeletedError.new("way", new_way.id)
260     end
261     
262     # need to start the transaction here, so that the database can 
263     # provide repeatable reads for the used-by checks. this means it
264     # shouldn't be possible to get race conditions.
265     Way.transaction do
266       self.lock!
267       check_consistency(self, new_way, user)
268       rel = RelationMember.find(:first, :joins => :relation,
269                              :conditions => [ "visible = ? AND member_type='Way' and member_id=? ", true, self.id])
270       raise OSM::APIPreconditionFailedError.new("Way #{self.id} still used by relation #{rel.relation.id}.") if rel
271       
272       self.changeset_id = new_way.changeset_id
273       self.changeset = new_way.changeset
274
275       self.tags = []
276       self.nds = []
277       self.visible = false
278       save_with_history!
279     end
280   end
281
282   # Temporary method to match interface to nodes
283   def tags_as_hash
284     return self.tags
285   end
286
287   ##
288   # if any referenced nodes are placeholder IDs (i.e: are negative) then
289   # this calling this method will fix them using the map from placeholders 
290   # to IDs +id_map+. 
291   def fix_placeholders!(id_map, placeholder_id = nil)
292     self.nds.map! do |node_id|
293       if node_id < 0
294         new_id = id_map[:node][node_id]
295         raise OSM::APIBadUserInput.new("Placeholder node not found for reference #{node_id} in way #{self.id.nil? ? placeholder_id : self.id}") if new_id.nil?
296         new_id
297       else
298         node_id
299       end
300     end
301   end
302
303   private
304   
305   def save_with_history!
306     t = Time.now.getutc
307
308     # update the bounding box, note that this has to be done both before 
309     # and after the save, so that nodes from both versions are included in the 
310     # bbox. we use a copy of the changeset so that it isn't reloaded
311     # later in the save.
312     cs = self.changeset
313     cs.update_bbox!(bbox) unless nodes.empty?
314
315     Way.transaction do
316       self.version += 1
317       self.timestamp = t
318       self.save!
319
320       tags = self.tags
321       WayTag.delete_all(['id = ?', self.id])
322       tags.each do |k,v|
323         tag = WayTag.new
324         tag.k = k
325         tag.v = v
326         tag.id = self.id
327         tag.save!
328       end
329
330       nds = self.nds
331       WayNode.delete_all(['id = ?', self.id])
332       sequence = 1
333       nds.each do |n|
334         nd = WayNode.new
335         nd.id = [self.id, sequence]
336         nd.node_id = n
337         nd.save!
338         sequence += 1
339       end
340
341       old_way = OldWay.from_way(self)
342       old_way.timestamp = t
343       old_way.save_with_dependencies!
344
345       # reload the way so that the nodes array points to the correct
346       # new set of nodes.
347       self.reload
348
349       # update and commit the bounding box, now that way nodes 
350       # have been updated and we're in a transaction.
351       cs.update_bbox!(bbox) unless nodes.empty?
352
353       # tell the changeset we updated one element only
354       cs.add_changes! 1
355
356       cs.save!
357     end
358   end
359
360 end