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