]> git.openstreetmap.org Git - rails.git/blob - app/controllers/api/relations_controller.rb
Bump puma from 5.6.8 to 5.6.9
[rails.git] / app / controllers / api / relations_controller.rb
1 module Api
2   class RelationsController < ApiController
3     before_action :check_api_writable, :only => [:create, :update, :delete]
4     before_action :authorize, :only => [:create, :update, :delete]
5
6     authorize_resource
7
8     before_action :require_public_data, :only => [:create, :update, :delete]
9     around_action :api_call_handle_error, :api_call_timeout
10
11     before_action :set_request_formats, :except => [:create, :update, :delete]
12     before_action :check_rate_limit, :only => [:create, :update, :delete]
13
14     def index
15       raise OSM::APIBadUserInput, "The parameter relations is required, and must be of the form relations=id[,id[,id...]]" unless params["relations"]
16
17       ids = params["relations"].split(",").collect(&:to_i)
18
19       raise OSM::APIBadUserInput, "No relations were given to search for" if ids.empty?
20
21       @relations = Relation.find(ids)
22
23       # Render the result
24       respond_to do |format|
25         format.xml
26         format.json
27       end
28     end
29
30     def show
31       @relation = Relation.find(params[:id])
32       response.last_modified = @relation.timestamp
33       if @relation.visible
34         # Render the result
35         respond_to do |format|
36           format.xml
37           format.json
38         end
39       else
40         head :gone
41       end
42     end
43
44     def create
45       relation = Relation.from_xml(request.raw_post, :create => true)
46
47       # Assume that Relation.from_xml has thrown an exception if there is an error parsing the xml
48       relation.create_with_history current_user
49       render :plain => relation.id.to_s
50     end
51
52     def update
53       logger.debug request.raw_post
54
55       relation = Relation.find(params[:id])
56       new_relation = Relation.from_xml(request.raw_post)
57
58       raise OSM::APIBadUserInput, "The id in the url (#{relation.id}) is not the same as provided in the xml (#{new_relation.id})" unless new_relation && new_relation.id == relation.id
59
60       relation.update_from new_relation, current_user
61       render :plain => relation.version.to_s
62     end
63
64     def delete
65       relation = Relation.find(params[:id])
66       new_relation = Relation.from_xml(request.raw_post)
67       if new_relation && new_relation.id == relation.id
68         relation.delete_with_history!(new_relation, current_user)
69         render :plain => relation.version.to_s
70       else
71         head :bad_request
72       end
73     end
74
75     # -----------------------------------------------------------------
76     # full
77     #
78     # input parameters: id
79     #
80     # returns XML representation of one relation object plus all its
81     # members, plus all nodes part of member ways
82     # -----------------------------------------------------------------
83     def full
84       relation = Relation.find(params[:id])
85
86       if relation.visible
87
88         # first find the ids of nodes, ways and relations referenced by this
89         # relation - note that we exclude this relation just in case.
90
91         node_ids = relation.members.select { |m| m[0] == "Node" }.pluck(1)
92         way_ids = relation.members.select { |m| m[0] == "Way" }.pluck(1)
93         relation_ids = relation.members.select { |m| m[0] == "Relation" && m[1] != relation.id }.pluck(1)
94
95         # next load the relations and the ways.
96
97         relations = Relation.where(:id => relation_ids).includes(:relation_tags)
98         ways = Way.where(:id => way_ids).includes(:way_nodes, :way_tags)
99
100         # now additionally collect nodes referenced by ways. Note how we
101         # recursively evaluate ways but NOT relations.
102
103         way_node_ids = ways.collect do |way|
104           way.way_nodes.collect(&:node_id)
105         end
106         node_ids += way_node_ids.flatten
107         nodes = Node.where(:id => node_ids.uniq).includes(:node_tags)
108
109         visible_nodes = {}
110
111         @nodes = []
112         nodes.each do |node|
113           next unless node.visible? # should be unnecessary if data is consistent.
114
115           @nodes << node
116           visible_nodes[node.id] = node
117         end
118
119         @ways = []
120         ways.each do |way|
121           next unless way.visible? # should be unnecessary if data is consistent.
122
123           @ways << way
124         end
125
126         @relations = []
127         relations.each do |rel|
128           next unless rel.visible? # should be unnecessary if data is consistent.
129
130           @relations << rel
131         end
132
133         # finally add self
134         @relations << relation
135
136         # Render the result
137         respond_to do |format|
138           format.xml
139           format.json
140         end
141       else
142         head :gone
143       end
144     end
145
146     def relations_for_way
147       relations_for_object("Way")
148     end
149
150     def relations_for_node
151       relations_for_object("Node")
152     end
153
154     def relations_for_relation
155       relations_for_object("Relation")
156     end
157
158     private
159
160     def relations_for_object(objtype)
161       relationids = RelationMember.where(:member_type => objtype, :member_id => params[:id]).collect(&:relation_id).uniq
162
163       @relations = []
164
165       Relation.find(relationids).each do |relation|
166         @relations << relation if relation.visible
167       end
168
169       # Render the result
170       respond_to do |format|
171         format.xml
172         format.json
173       end
174     end
175   end
176 end