adding the controller code to be able to get a specific version of a node, way or...
[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 :text => "", :status => :precondition_failed
17         else
18           relation.version = 0
19           #relation.user_id = @user.id
20           relation.save_with_history!
21
22           render :text => relation.id.to_s, :content_type => "text/plain"
23         end
24       else
25         render :nothing => true, :status => :bad_request
26       end
27     else
28       render :nothing => true, :status => :method_not_allowed
29     end
30   end
31
32   def read
33     begin
34       relation = Relation.find(params[:id])
35       response.headers['Last-Modified'] = relation.timestamp.rfc822
36       if relation.visible
37         render :text => relation.to_xml.to_s, :content_type => "text/xml"
38       else
39         render :text => "", :status => :gone
40       end
41     rescue ActiveRecord::RecordNotFound
42       render :nothing => true, :status => :not_found
43     rescue
44       render :nothing => true, :status => :internal_server_error
45     end
46   end
47
48   def update
49     logger.debug request.raw_post
50     begin
51       relation = Relation.find(params[:id])
52       new_relation = Relation.from_xml(request.raw_post)
53
54       if new_relation and new_relation.id == relation.id
55         relation.update_from new_relation, @user
56         render :text => relation.version.to_s, :content_type => "text/plain"
57       else
58         render :nothing => true, :status => :bad_request
59       end
60     rescue ActiveRecord::RecordNotFound
61       render :nothing => true, :status => :not_found
62     rescue OSM::APIError => ex
63       render ex.render_opts
64     end
65   end
66
67   def delete
68 #XXX check if member somewhere!
69     begin
70       relation = Relation.find(params[:id])
71       relation.delete_with_history(@user)
72     rescue OSM::APIError => ex
73       render ex.render_opts
74     rescue ActiveRecord::RecordNotFound
75       render :nothing => true, :status => :not_found
76     end
77   end
78
79   # -----------------------------------------------------------------
80   # full
81   # 
82   # input parameters: id
83   #
84   # returns XML representation of one relation object plus all its
85   # members, plus all nodes part of member ways
86   # -----------------------------------------------------------------
87   def full
88     begin
89       relation = Relation.find(params[:id])
90
91       if relation.visible
92
93         # first collect nodes, ways, and relations referenced by this relation.
94         
95         ways = Way.find_by_sql("select w.* from current_ways w,current_relation_members rm where "+
96             "rm.member_type='way' and rm.member_id=w.id and rm.id=#{relation.id}");
97         nodes = Node.find_by_sql("select n.* from current_nodes n,current_relation_members rm where "+
98             "rm.member_type='node' and rm.member_id=n.id and rm.id=#{relation.id}");
99         # note query is built to exclude self just in case.
100         relations = Relation.find_by_sql("select r.* from current_relations r,current_relation_members rm where "+
101             "rm.member_type='relation' and rm.member_id=r.id and rm.id=#{relation.id} and r.id<>rm.id");
102
103         # now additionally collect nodes referenced by ways. Note how we recursively 
104         # evaluate ways but NOT relations.
105
106         node_ids = nodes.collect {|node| node.id }
107         way_node_ids = ways.collect { |way|
108            way.way_nodes.collect { |way_node| way_node.node_id }
109         }
110         way_node_ids.flatten!
111         way_node_ids.uniq
112         way_node_ids -= node_ids
113         nodes += Node.find(way_node_ids)
114     
115         # create XML.
116         doc = OSM::API.new.get_xml_doc
117         visible_nodes = {}
118         user_display_name_cache = {}
119
120         nodes.each do |node|
121           if node.visible? # should be unnecessary if data is consistent.
122             doc.root << node.to_xml_node(user_display_name_cache)
123             visible_nodes[node.id] = node
124           end
125         end
126         ways.each do |way|
127           if way.visible? # should be unnecessary if data is consistent.
128             doc.root << way.to_xml_node(visible_nodes, user_display_name_cache)
129           end
130         end
131         relations.each do |rel|
132           if rel.visible? # should be unnecessary if data is consistent.
133             doc.root << rel.to_xml_node(user_display_name_cache)
134           end
135         end
136         # finally add self and output
137         doc.root << relation.to_xml_node(user_display_name_cache)
138         render :text => doc.to_s, :content_type => "text/xml"
139
140       else
141
142         render :text => "", :status => :gone
143       end
144
145     rescue ActiveRecord::RecordNotFound
146       render :nothing => true, :status => :not_found
147
148     rescue
149       render :nothing => true, :status => :internal_server_error
150     end
151   end
152
153   def relations
154     ids = params['relations'].split(',').collect { |w| w.to_i }
155
156     if ids.length > 0
157       doc = OSM::API.new.get_xml_doc
158
159       Relation.find(ids).each do |relation|
160         doc.root << relation.to_xml_node
161       end
162
163       render :text => doc.to_s, :content_type => "text/xml"
164     else
165       render :nothing => true, :status => :bad_request
166     end
167   end
168
169   def relations_for_way
170     relations_for_object("way")
171   end
172   def relations_for_node
173     relations_for_object("node")
174   end
175   def relations_for_relation
176     relations_for_object("relation")
177   end
178
179   def relations_for_object(objtype)
180     relationids = RelationMember.find(:all, :conditions => ['member_type=? and member_id=?', objtype, params[:id]]).collect { |ws| ws.id }.uniq
181
182     doc = OSM::API.new.get_xml_doc
183
184     Relation.find(relationids).each do |relation|
185       doc.root << relation.to_xml_node
186     end
187
188     render :text => doc.to_s, :content_type => "text/xml"
189   end
190 end