app/controllers/changeset_controller.rb

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