]> git.openstreetmap.org Git - rails.git/blob - app/controllers/api/changesets_controller.rb
Merge remote-tracking branch 'upstream/pull/4358'
[rails.git] / app / controllers / api / changesets_controller.rb
1 # The ChangesetController is the RESTful interface to Changeset objects
2
3 module Api
4   class ChangesetsController < ApiController
5     require "xml/libxml"
6
7     before_action :check_api_writable, :only => [:create, :update, :upload, :subscribe, :unsubscribe]
8     before_action :check_api_readable, :except => [:create, :update, :upload, :download, :query, :subscribe, :unsubscribe]
9     before_action :authorize, :only => [:create, :update, :upload, :close, :subscribe, :unsubscribe]
10
11     authorize_resource
12
13     before_action :require_public_data, :only => [:create, :update, :upload, :close, :subscribe, :unsubscribe]
14     before_action :set_request_formats, :except => [:create, :close, :upload]
15
16     around_action :api_call_handle_error
17     around_action :api_call_timeout, :except => [:upload]
18
19     # Helper methods for checking consistency
20     include ConsistencyValidations
21
22     ##
23     # Return XML giving the basic info about the changeset. Does not
24     # return anything about the nodes, ways and relations in the changeset.
25     def show
26       @changeset = Changeset.find(params[:id])
27       @include_discussion = params[:include_discussion].presence
28       render "changeset"
29
30       respond_to do |format|
31         format.xml
32         format.json
33       end
34     end
35
36     # Create a changeset from XML.
37     def create
38       assert_method :put
39
40       cs = Changeset.from_xml(request.raw_post, :create => true)
41
42       # Assume that Changeset.from_xml has thrown an exception if there is an error parsing the xml
43       cs.user = current_user
44       cs.save_with_tags!
45
46       # Subscribe user to changeset comments
47       cs.subscribers << current_user
48
49       render :plain => cs.id.to_s
50     end
51
52     ##
53     # marks a changeset as closed. this may be called multiple times
54     # on the same changeset, so is idempotent.
55     def close
56       assert_method :put
57
58       changeset = Changeset.find(params[:id])
59       check_changeset_consistency(changeset, current_user)
60
61       # to close the changeset, we'll just set its closed_at time to
62       # now. this might not be enough if there are concurrency issues,
63       # but we'll have to wait and see.
64       changeset.set_closed_time_now
65
66       changeset.save!
67       head :ok
68     end
69
70     ##
71     # Upload a diff in a single transaction.
72     #
73     # This means that each change within the diff must succeed, i.e: that
74     # each version number mentioned is still current. Otherwise the entire
75     # transaction *must* be rolled back.
76     #
77     # Furthermore, each element in the diff can only reference the current
78     # changeset.
79     #
80     # Returns: a diffResult document, as described in
81     # http://wiki.openstreetmap.org/wiki/OSM_Protocol_Version_0.6
82     def upload
83       # only allow POST requests, as the upload method is most definitely
84       # not idempotent, as several uploads with placeholder IDs will have
85       # different side-effects.
86       # see http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.1.2
87       assert_method :post
88
89       changeset = Changeset.find(params[:id])
90       check_changeset_consistency(changeset, current_user)
91
92       diff_reader = DiffReader.new(request.raw_post, changeset)
93       Changeset.transaction do
94         result = diff_reader.commit
95         # the number of changes in this changeset has already been
96         # updated and is visible in this transaction so we don't need
97         # to allow for any more when checking the limit
98         check_rate_limit(0)
99         render :xml => result.to_s
100       end
101     end
102
103     ##
104     # download the changeset as an osmChange document.
105     #
106     # to make it easier to revert diffs it would be better if the osmChange
107     # format were reversible, i.e: contained both old and new versions of
108     # modified elements. but it doesn't at the moment...
109     #
110     # this method cannot order the database changes fully (i.e: timestamp and
111     # version number may be too coarse) so the resulting diff may not apply
112     # to a different database. however since changesets are not atomic this
113     # behaviour cannot be guaranteed anyway and is the result of a design
114     # choice.
115     def download
116       changeset = Changeset.find(params[:id])
117
118       # get all the elements in the changeset which haven't been redacted
119       # and stick them in a big array.
120       elements = [changeset.old_nodes.unredacted,
121                   changeset.old_ways.unredacted,
122                   changeset.old_relations.unredacted].flatten
123
124       # sort the elements by timestamp and version number, as this is the
125       # almost sensible ordering available. this would be much nicer if
126       # global (SVN-style) versioning were used - then that would be
127       # unambiguous.
128       elements.sort! do |a, b|
129         if a.timestamp == b.timestamp
130           a.version <=> b.version
131         else
132           a.timestamp <=> b.timestamp
133         end
134       end
135
136       # generate an output element for each operation. note: we avoid looking
137       # at the history because it is simpler - but it would be more correct to
138       # check these assertions.
139       @created = []
140       @modified = []
141       @deleted = []
142
143       elements.each do |elt|
144         if elt.version == 1
145           # first version, so it must be newly-created.
146           @created << elt
147         elsif elt.visible
148           # must be a modify
149           @modified << elt
150         else
151           # if the element isn't visible then it must have been deleted
152           @deleted << elt
153         end
154       end
155
156       respond_to do |format|
157         format.xml
158       end
159     end
160
161     ##
162     # query changesets by bounding box, time, user or open/closed status.
163     def query
164       raise OSM::APIBadUserInput, "cannot use order=oldest with time" if params[:time] && params[:order] == "oldest"
165
166       # find any bounding box
167       bbox = BoundingBox.from_bbox_params(params) if params["bbox"]
168
169       # create the conditions that the user asked for. some or all of
170       # these may be nil.
171       changesets = Changeset.all
172       changesets = conditions_bbox(changesets, bbox)
173       changesets = conditions_user(changesets, params["user"], params["display_name"])
174       changesets = conditions_time(changesets, params["time"])
175       changesets = conditions_from_to(changesets, params["from"], params["to"])
176       changesets = conditions_open(changesets, params["open"])
177       changesets = conditions_closed(changesets, params["closed"])
178       changesets = conditions_ids(changesets, params["changesets"])
179
180       # sort the changesets
181       changesets = if params[:order] == "oldest"
182                      changesets.order(:created_at => :asc)
183                    else
184                      changesets.order(:created_at => :desc)
185                    end
186
187       # limit the result
188       changesets = changesets.limit(result_limit)
189
190       # preload users, tags and comments, and render result
191       @changesets = changesets.preload(:user, :changeset_tags, :comments)
192       render "changesets"
193
194       respond_to do |format|
195         format.xml
196         format.json
197       end
198     end
199
200     ##
201     # updates a changeset's tags. none of the changeset's attributes are
202     # user-modifiable, so they will be ignored.
203     #
204     # changesets are not (yet?) versioned, so we don't have to deal with
205     # history tables here. changesets are locked to a single user, however.
206     #
207     # after succesful update, returns the XML of the changeset.
208     def update
209       # request *must* be a PUT.
210       assert_method :put
211
212       @changeset = Changeset.find(params[:id])
213       new_changeset = Changeset.from_xml(request.raw_post)
214
215       check_changeset_consistency(@changeset, current_user)
216       @changeset.update_from(new_changeset, current_user)
217       render "changeset"
218
219       respond_to do |format|
220         format.xml
221         format.json
222       end
223     end
224
225     ##
226     # Adds a subscriber to the changeset
227     def subscribe
228       # Check the arguments are sane
229       raise OSM::APIBadUserInput, "No id was given" unless params[:id]
230
231       # Extract the arguments
232       id = params[:id].to_i
233
234       # Find the changeset and check it is valid
235       changeset = Changeset.find(id)
236       raise OSM::APIChangesetAlreadySubscribedError, changeset if changeset.subscribers.exists?(current_user.id)
237
238       # Add the subscriber
239       changeset.subscribers << current_user
240
241       # Return a copy of the updated changeset
242       @changeset = changeset
243       render "changeset"
244
245       respond_to do |format|
246         format.xml
247         format.json
248       end
249     end
250
251     ##
252     # Removes a subscriber from the changeset
253     def unsubscribe
254       # Check the arguments are sane
255       raise OSM::APIBadUserInput, "No id was given" unless params[:id]
256
257       # Extract the arguments
258       id = params[:id].to_i
259
260       # Find the changeset and check it is valid
261       changeset = Changeset.find(id)
262       raise OSM::APIChangesetNotSubscribedError, changeset unless changeset.subscribers.exists?(current_user.id)
263
264       # Remove the subscriber
265       changeset.subscribers.delete(current_user)
266
267       # Return a copy of the updated changeset
268       @changeset = changeset
269       render "changeset"
270
271       respond_to do |format|
272         format.xml
273         format.json
274       end
275     end
276
277     private
278
279     #------------------------------------------------------------
280     # utility functions below.
281     #------------------------------------------------------------
282
283     ##
284     # if a bounding box was specified do some sanity checks.
285     # restrict changesets to those enclosed by a bounding box
286     def conditions_bbox(changesets, bbox)
287       if bbox
288         bbox.check_boundaries
289         bbox = bbox.to_scaled
290
291         changesets.where("min_lon < ? and max_lon > ? and min_lat < ? and max_lat > ?",
292                          bbox.max_lon.to_i, bbox.min_lon.to_i,
293                          bbox.max_lat.to_i, bbox.min_lat.to_i)
294       else
295         changesets
296       end
297     end
298
299     ##
300     # restrict changesets to those by a particular user
301     def conditions_user(changesets, user, name)
302       if user.nil? && name.nil?
303         changesets
304       else
305         # shouldn't provide both name and UID
306         raise OSM::APIBadUserInput, "provide either the user ID or display name, but not both" if user && name
307
308         # use either the name or the UID to find the user which we're selecting on.
309         u = if name.nil?
310               # user input checking, we don't have any UIDs < 1
311               raise OSM::APIBadUserInput, "invalid user ID" if user.to_i < 1
312
313               u = User.find_by(:id => user.to_i)
314             else
315               u = User.find_by(:display_name => name)
316             end
317
318         # make sure we found a user
319         raise OSM::APINotFoundError if u.nil?
320
321         # should be able to get changesets of public users only, or
322         # our own changesets regardless of public-ness.
323         unless u.data_public?
324           # get optional user auth stuff so that users can see their own
325           # changesets if they're non-public
326           setup_user_auth
327
328           raise OSM::APINotFoundError if current_user.nil? || current_user != u
329         end
330
331         changesets.where(:user => u)
332       end
333     end
334
335     ##
336     # restrict changesets to those during a particular time period
337     def conditions_time(changesets, time)
338       if time.nil?
339         changesets
340       elsif time.count(",") == 1
341         # if there is a range, i.e: comma separated, then the first is
342         # low, second is high - same as with bounding boxes.
343
344         # check that we actually have 2 elements in the array
345         times = time.split(",")
346         raise OSM::APIBadUserInput, "bad time range" if times.size != 2
347
348         from, to = times.collect { |t| Time.parse(t).utc }
349         changesets.where("closed_at >= ? and created_at <= ?", from, to)
350       else
351         # if there is no comma, assume its a lower limit on time
352         changesets.where("closed_at >= ?", Time.parse(time).utc)
353       end
354       # stupid Time seems to throw both of these for bad parsing, so
355       # we have to catch both and ensure the correct code path is taken.
356     rescue ArgumentError, RuntimeError => e
357       raise OSM::APIBadUserInput, e.message.to_s
358     end
359
360     ##
361     # restrict changesets to those opened during a particular time period
362     # works similar to from..to of notes controller, including the requirement of 'from' when specifying 'to'
363     def conditions_from_to(changesets, from, to)
364       if from
365         begin
366           from = Time.parse(from).utc
367         rescue ArgumentError
368           raise OSM::APIBadUserInput, "Date #{from} is in a wrong format"
369         end
370
371         begin
372           to = if to
373                  Time.parse(to).utc
374                else
375                  Time.now.utc
376                end
377         rescue ArgumentError
378           raise OSM::APIBadUserInput, "Date #{to} is in a wrong format"
379         end
380
381         changesets.where(:created_at => from..to)
382       else
383         changesets
384       end
385     end
386
387     ##
388     # return changesets which are open (haven't been closed yet)
389     # we do this by seeing if the 'closed at' time is in the future. Also if we've
390     # hit the maximum number of changes then it counts as no longer open.
391     # if parameter 'open' is nill then open and closed changesets are returned
392     def conditions_open(changesets, open)
393       if open.nil?
394         changesets
395       else
396         changesets.where("closed_at >= ? and num_changes <= ?",
397                          Time.now.utc, Changeset::MAX_ELEMENTS)
398       end
399     end
400
401     ##
402     # query changesets which are closed
403     # ('closed at' time has passed or changes limit is hit)
404     def conditions_closed(changesets, closed)
405       if closed.nil?
406         changesets
407       else
408         changesets.where("closed_at < ? or num_changes > ?",
409                          Time.now.utc, Changeset::MAX_ELEMENTS)
410       end
411     end
412
413     ##
414     # query changesets by a list of ids
415     # (either specified as array or comma-separated string)
416     def conditions_ids(changesets, ids)
417       if ids.nil?
418         changesets
419       elsif ids.empty?
420         raise OSM::APIBadUserInput, "No changesets were given to search for"
421       else
422         ids = ids.split(",").collect(&:to_i)
423         changesets.where(:id => ids)
424       end
425     end
426
427     ##
428     # Get the maximum number of results to return
429     def result_limit
430       if params[:limit]
431         if params[:limit].to_i.positive? && params[:limit].to_i <= Settings.max_changeset_query_limit
432           params[:limit].to_i
433         else
434           raise OSM::APIBadUserInput, "Changeset limit must be between 1 and #{Settings.max_changeset_query_limit}"
435         end
436       else
437         Settings.default_changeset_query_limit
438       end
439     end
440   end
441 end