]> git.openstreetmap.org Git - rails.git/blob - app/controllers/relation_controller.rb
Pass a list of visible nodes when generating XML for a way. Closes #553.
[rails.git] / app / controllers / relation_controller.rb
1 class RelationController < ApplicationController
2   require 'xml/libxml'
3
4   session :off
5   before_filter :authorize, :only => [:create, :update, :delete]
6   before_filter :check_write_availability, :only => [:create, :update, :delete]
7   before_filter :check_read_availability, :except => [:create, :update, :delete]
8   after_filter :compress_output
9
10   def create
11     if request.put?
12       relation = Relation.from_xml(request.raw_post, true)
13
14       if relation
15         if !relation.preconditions_ok?
16           render :nothing => true, :status => :precondition_failed
17         else
18           relation.user_id = @user.id
19           relation.save_with_history!
20
21           render :text => relation.id.to_s, :content_type => "text/plain"
22         end
23       else
24         render :nothing => true, :status => :bad_request
25       end
26     else
27       render :nothing => true, :status => :method_not_allowed
28     end
29   end
30
31   def read
32     begin
33       relation = Relation.find(params[:id])
34
35       if relation.visible
36         render :text => relation.to_xml.to_s, :content_type => "text/xml"
37       else
38         render :nothing => true, :status => :gone
39       end
40     rescue ActiveRecord::RecordNotFound
41       render :nothing => true, :status => :not_found
42     rescue
43       render :nothing => true, :status => :internal_server_error
44     end
45   end
46
47   def update
48     begin
49       relation = Relation.find(params[:id])
50
51       if relation.visible
52         new_relation = Relation.from_xml(request.raw_post)
53
54         if new_relation and new_relation.id == relation.id
55           if !new_relation.preconditions_ok?
56             render :nothing => true, :status => :precondition_failed
57           else
58             relation.user_id = @user.id
59             relation.tags = new_relation.tags
60             relation.members = new_relation.members
61             relation.visible = true
62             relation.save_with_history!
63
64             render :nothing => true
65           end
66         else
67           render :nothing => true, :status => :bad_request
68         end
69       else
70         render :nothing => true, :status => :gone
71       end
72     rescue ActiveRecord::RecordNotFound
73       render :nothing => true, :status => :not_found
74     rescue
75       render :nothing => true, :status => :internal_server_error
76     end
77   end
78
79   def delete
80 #XXX check if member somewhere!
81     begin
82       relation = Relation.find(params[:id])
83
84       if relation.visible
85         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=?", params[:id]])
86           render :nothing => true, :status => :precondition_failed
87         else
88           relation.user_id = @user.id
89           relation.tags = []
90           relation.members = []
91           relation.visible = false
92           relation.save_with_history!
93
94           render :nothing => true
95         end
96       else
97         render :nothing => true, :status => :gone
98       end
99     rescue ActiveRecord::RecordNotFound
100       render :nothing => true, :status => :not_found
101     rescue
102       render :nothing => true, :status => :internal_server_error
103     end
104   end
105
106   # -----------------------------------------------------------------
107   # full
108   # 
109   # input parameters: id
110   #
111   # returns XML representation of one relation object plus all its
112   # members, plus all nodes part of member ways
113   # -----------------------------------------------------------------
114   def full
115     begin
116       relation = Relation.find(params[:id])
117
118       if relation.visible
119
120         # first collect nodes, ways, and relations referenced by this relation.
121         
122         ways = Way.find_by_sql("select w.* from current_ways w,current_relation_members rm where "+
123             "rm.member_type='way' and rm.member_id=w.id and rm.id=#{relation.id}");
124         nodes = Node.find_by_sql("select n.* from current_nodes n,current_relation_members rm where "+
125             "rm.member_type='node' and rm.member_id=n.id and rm.id=#{relation.id}");
126         # note query is built to exclude self just in case.
127         relations = Relation.find_by_sql("select r.* from current_relations r,current_relation_members rm where "+
128             "rm.member_type='relation' and rm.member_id=r.id and rm.id=#{relation.id} and r.id<>rm.id");
129
130         # now additionally collect nodes referenced by ways. Note how we recursively 
131         # evaluate ways but NOT relations.
132
133         node_ids = nodes.collect {|node| node.id }
134         way_node_ids = ways.collect { |way|
135            way.way_nodes.collect { |way_node| way_node.node_id }
136         }
137         way_node_ids.flatten!
138         way_node_ids.uniq
139         way_node_ids -= node_ids
140         nodes += Node.find(way_node_ids)
141     
142         # create XML.
143         doc = OSM::API.new.get_xml_doc
144         visible_nodes = {}
145         user_display_name_cache = {}
146
147         nodes.each do |node|
148           if node.visible? # should be unnecessary if data is consistent.
149             doc.root << node.to_xml_node(user_display_name_cache)
150             visible_nodes[node.id] = node
151           end
152         end
153         ways.each do |way|
154           if way.visible? # should be unnecessary if data is consistent.
155             doc.root << way.to_xml_node(visible_nodes, user_display_name_cache)
156           end
157         end
158         relations.each do |rel|
159           if rel.visible? # should be unnecessary if data is consistent.
160             doc.root << rel.to_xml_node(user_display_name_cache)
161           end
162         end
163         # finally add self and output
164         doc.root << relation.to_xml_node(user_display_name_cache)
165         render :text => doc.to_s, :content_type => "text/xml"
166
167       else
168
169         render :nothing => true, :status => :gone
170       end
171
172     rescue ActiveRecord::RecordNotFound
173       render :nothing => true, :status => :not_found
174
175     rescue
176       render :nothing => true, :status => :internal_server_error
177     end
178   end
179
180   def relations
181     ids = params['relations'].split(',').collect { |w| w.to_i }
182
183     if ids.length > 0
184       doc = OSM::API.new.get_xml_doc
185
186       Relation.find(ids).each do |relation|
187         doc.root << relation.to_xml_node
188       end
189
190       render :text => doc.to_s, :content_type => "text/xml"
191     else
192       render :nothing => true, :status => :bad_request
193     end
194   end
195
196   def relations_for_way
197     relations_for_object("way")
198   end
199   def relations_for_node
200     relations_for_object("node")
201   end
202   def relations_for_relation
203     relations_for_object("relation")
204   end
205
206   def relations_for_object(objtype)
207     relationids = RelationMember.find(:all, :conditions => ['member_type=? and member_id=?', objtype, params[:id]]).collect { |ws| ws.id }.uniq
208
209     if relationids.length > 0
210       doc = OSM::API.new.get_xml_doc
211
212       Relation.find(relationids).each do |relation|
213         doc.root << relation.to_xml_node
214       end
215
216       render :text => doc.to_s, :content_type => "text/xml"
217     else
218       render :nothing => true, :status => :not_found
219     end
220   end
221 end