Merge remote-tracking branch 'upstream/pull/2907' into master
[rails.git] / lib / osm.rb
1 # The OSM module provides support functions for OSM.
2 module OSM
3   require "time"
4   require "rexml/parsers/sax2parser"
5   require "rexml/text"
6   require "xml/libxml"
7
8   if defined?(SystemTimer)
9     Timer = SystemTimer
10   else
11     require "timeout"
12     Timer = Timeout
13   end
14
15   # The base class for API Errors.
16   class APIError < RuntimeError
17     def initialize(message = "Generic API Error")
18       super message
19     end
20
21     def status
22       :internal_server_error
23     end
24   end
25
26   # Raised when access is denied.
27   class APIAccessDenied < APIError
28     def initialize
29       super "Access denied"
30     end
31
32     def status
33       :forbidden
34     end
35   end
36
37   # Raised when an API object is not found.
38   class APINotFoundError < APIError
39     def initialize
40       super "Object not found"
41     end
42
43     def status
44       :not_found
45     end
46   end
47
48   # Raised when a precondition to an API action fails sanity check.
49   class APIPreconditionFailedError < APIError
50     def initialize(message = "")
51       super "Precondition failed: #{message}"
52     end
53
54     def status
55       :precondition_failed
56     end
57   end
58
59   # Raised when to delete an already-deleted object.
60   class APIAlreadyDeletedError < APIError
61     def initialize(object = "object", object_id = "")
62       @object = object
63       @object_id = object_id
64
65       super "The #{object} with the id #{object_id} has already been deleted"
66     end
67
68     attr_reader :object, :object_id
69
70     def status
71       :gone
72     end
73   end
74
75   # Raised when the user logged in isn't the same as the changeset
76   class APIUserChangesetMismatchError < APIError
77     def initialize
78       super "The user doesn't own that changeset"
79     end
80
81     def status
82       :conflict
83     end
84   end
85
86   # Raised when the changeset provided is already closed
87   class APIChangesetAlreadyClosedError < APIError
88     def initialize(changeset)
89       @changeset = changeset
90
91       super "The changeset #{changeset.id} was closed at #{changeset.closed_at}"
92     end
93
94     attr_reader :changeset
95
96     def status
97       :conflict
98     end
99   end
100
101   # Raised when the changeset provided is not yet closed
102   class APIChangesetNotYetClosedError < APIError
103     def initialize(changeset)
104       @changeset = changeset
105
106       super "The changeset #{changeset.id} is not yet closed."
107     end
108
109     attr_reader :changeset
110
111     def status
112       :conflict
113     end
114   end
115
116   # Raised when a user is already subscribed to the changeset
117   class APIChangesetAlreadySubscribedError < APIError
118     def initialize(changeset)
119       @changeset = changeset
120
121       super "You are already subscribed to changeset #{changeset.id}."
122     end
123
124     attr_reader :changeset
125
126     def status
127       :conflict
128     end
129   end
130
131   # Raised when a user is not subscribed to the changeset
132   class APIChangesetNotSubscribedError < APIError
133     def initialize(changeset)
134       @changeset = changeset
135
136       super "You are not subscribed to changeset #{changeset.id}."
137     end
138
139     attr_reader :changeset
140
141     def status
142       :not_found
143     end
144   end
145
146   # Raised when a change is expecting a changeset, but the changeset doesn't exist
147   class APIChangesetMissingError < APIError
148     def initialize
149       super "You need to supply a changeset to be able to make a change"
150     end
151
152     def status
153       :conflict
154     end
155   end
156
157   # Raised when a diff is uploaded containing many changeset IDs which don't match
158   # the changeset ID that the diff was uploaded to.
159   class APIChangesetMismatchError < APIError
160     def initialize(provided, allowed)
161       super "Changeset mismatch: Provided #{provided} but only #{allowed} is allowed"
162     end
163
164     def status
165       :conflict
166     end
167   end
168
169   # Raised when a diff upload has an unknown action. You can only have create,
170   # modify, or delete
171   class APIChangesetActionInvalid < APIError
172     def initialize(provided)
173       super "Unknown action #{provided}, choices are create, modify, delete"
174     end
175
176     def status
177       :bad_request
178     end
179   end
180
181   # Raised when bad XML is encountered which stops things parsing as
182   # they should.
183   class APIBadXMLError < APIError
184     def initialize(model, xml, message = "")
185       super "Cannot parse valid #{model} from xml string #{xml}. #{message}"
186     end
187
188     def status
189       :bad_request
190     end
191   end
192
193   # Raised when the provided version is not equal to the latest in the db.
194   class APIVersionMismatchError < APIError
195     def initialize(id, type, provided, latest)
196       @id = id
197       @type = type
198       @provided = provided
199       @latest = latest
200
201       super "Version mismatch: Provided #{provided}, server had: #{latest} of #{type} #{id}"
202     end
203
204     attr_reader :provided, :latest, :id, :type
205
206     def status
207       :conflict
208     end
209   end
210
211   # raised when a two tags have a duplicate key string in an element.
212   # this is now forbidden by the API.
213   class APIDuplicateTagsError < APIError
214     def initialize(type, id, tag_key)
215       @type = type
216       @id = id
217       @tag_key = tag_key
218
219       super "Element #{type}/#{id} has duplicate tags with key #{tag_key}"
220     end
221
222     attr_reader :type, :id, :tag_key
223
224     def status
225       :bad_request
226     end
227   end
228
229   # Raised when a way has more than the configured number of way nodes.
230   # This prevents ways from being to long and difficult to work with
231   class APITooManyWayNodesError < APIError
232     def initialize(id, provided, max)
233       super "You tried to add #{provided} nodes to way #{id}, however only #{max} are allowed"
234
235       @id = id
236       @provided = provided
237       @max = max
238     end
239
240     attr_reader :id, :provided, :max
241
242     def status
243       :bad_request
244     end
245   end
246
247   ##
248   # raised when user input couldn't be parsed
249   class APIBadUserInput < APIError
250     def status
251       :bad_request
252     end
253   end
254
255   ##
256   # raised when bounding box is invalid
257   class APIBadBoundingBox < APIError
258     def status
259       :bad_request
260     end
261   end
262
263   ##
264   # raised when an API call is made using a method not supported on that URI
265   class APIBadMethodError < APIError
266     def initialize(supported_method)
267       super "Only method #{supported_method} is supported on this URI"
268     end
269
270     def status
271       :method_not_allowed
272     end
273   end
274
275   ##
276   # raised when an API call takes too long
277   class APITimeoutError < APIError
278     def initialize
279       super "Request timed out"
280     end
281
282     def status
283       :request_timeout
284     end
285   end
286
287   ##
288   # raised when someone tries to redact a current version of
289   # an element - only historical versions can be redacted.
290   class APICannotRedactError < APIError
291     def initialize
292       super "Cannot redact current version of element, only historical versions may be redacted."
293     end
294
295     def status
296       :bad_request
297     end
298   end
299
300   # Raised when the note provided is already closed
301   class APINoteAlreadyClosedError < APIError
302     def initialize(note)
303       @note = note
304
305       super "The note #{note.id} was closed at #{note.closed_at}"
306     end
307
308     attr_reader :note
309
310     def status
311       :conflict
312     end
313   end
314
315   # Raised when the note provided is already open
316   class APINoteAlreadyOpenError < APIError
317     def initialize(note)
318       @note = note
319
320       super "The note #{note.id} is already open"
321     end
322
323     attr_reader :note
324
325     def status
326       :conflict
327     end
328   end
329
330   # raised when a two preferences have a duplicate key string.
331   class APIDuplicatePreferenceError < APIError
332     def initialize(key)
333       @key = key
334
335       super "Duplicate preferences with key #{key}"
336     end
337
338     attr_reader :key
339
340     def status
341       :bad_request
342     end
343   end
344
345   # Helper methods for going to/from mercator and lat/lng.
346   class Mercator
347     include Math
348
349     # init me with your bounding box and the size of your image
350     def initialize(min_lat, min_lon, max_lat, max_lon, width, height)
351       xsize = xsheet(max_lon) - xsheet(min_lon)
352       ysize = ysheet(max_lat) - ysheet(min_lat)
353       xscale = xsize / width
354       yscale = ysize / height
355       scale = [xscale, yscale].max
356
357       xpad = width * scale - xsize
358       ypad = height * scale - ysize
359
360       @width = width
361       @height = height
362
363       @tx = xsheet(min_lon) - xpad / 2
364       @ty = ysheet(min_lat) - ypad / 2
365
366       @bx = xsheet(max_lon) + xpad / 2
367       @by = ysheet(max_lat) + ypad / 2
368     end
369
370     # the following two functions will give you the x/y on the entire sheet
371
372     def ysheet(lat)
373       log(tan(PI / 4 + (lat * PI / 180 / 2))) / (PI / 180)
374     end
375
376     def xsheet(lon)
377       lon
378     end
379
380     # and these two will give you the right points on your image. all the constants can be reduced to speed things up. FIXME
381
382     def y(lat)
383       @height - ((ysheet(lat) - @ty) / (@by - @ty) * @height)
384     end
385
386     def x(lon)
387       ((xsheet(lon) - @tx) / (@bx - @tx) * @width)
388     end
389   end
390
391   class GreatCircle
392     include Math
393
394     # initialise with a base position
395     def initialize(lat, lon)
396       @lat = lat * PI / 180
397       @lon = lon * PI / 180
398     end
399
400     # get the distance from the base position to a given position
401     def distance(lat, lon)
402       lat = lat * PI / 180
403       lon = lon * PI / 180
404       6372.795 * 2 * asin(sqrt(sin((lat - @lat) / 2)**2 + cos(@lat) * cos(lat) * sin((lon - @lon) / 2)**2))
405     end
406
407     # get the worst case bounds for a given radius from the base position
408     def bounds(radius)
409       latradius = 2 * asin(sqrt(sin(radius / 6372.795 / 2)**2))
410
411       begin
412         lonradius = 2 * asin(sqrt(sin(radius / 6372.795 / 2)**2 / cos(@lat)**2))
413       rescue Errno::EDOM, Math::DomainError
414         lonradius = PI
415       end
416
417       minlat = [(@lat - latradius) * 180 / PI, -90].max
418       maxlat = [(@lat + latradius) * 180 / PI, 90].min
419       minlon = [(@lon - lonradius) * 180 / PI, -180].max
420       maxlon = [(@lon + lonradius) * 180 / PI, 180].min
421
422       BoundingBox.new(minlon, minlat, maxlon, maxlat)
423     end
424
425     # get the SQL to use to calculate distance
426     def sql_for_distance(lat_field, lon_field)
427       "6372.795 * 2 * asin(sqrt(power(sin((radians(#{lat_field}) - #{@lat}) / 2), 2) + cos(#{@lat}) * cos(radians(#{lat_field})) * power(sin((radians(#{lon_field}) - #{@lon})/2), 2)))"
428     end
429   end
430
431   class API
432     def get_xml_doc
433       doc = XML::Document.new
434       doc.encoding = XML::Encoding::UTF_8
435       root = XML::Node.new "osm"
436       xml_root_attributes.each do |k, v|
437         root[k] = v
438       end
439       doc.root = root
440       doc
441     end
442
443     def xml_root_attributes
444       { "version" => Settings.api_version,
445         "generator" => Settings.generator,
446         "copyright" => Settings.copyright_owner,
447         "attribution" => Settings.attribution_url,
448         "license" => Settings.license_url }
449     end
450   end
451
452   def self.ip_to_country(ip_address)
453     ipinfo = maxmind_database.lookup(ip_address) if Settings.key?(:maxmind_database)
454
455     return ipinfo.country.iso_code if ipinfo&.found?
456
457     nil
458   end
459
460   def self.ip_location(ip_address)
461     code = OSM.ip_to_country(ip_address)
462
463     if code && country = Country.find(code)
464       return { :minlon => country.min_lon, :minlat => country.min_lat, :maxlon => country.max_lon, :maxlat => country.max_lat }
465     end
466
467     nil
468   end
469
470   # Parse a float, raising a specified exception on failure
471   def self.parse_float(str, klass, *args)
472     Float(str)
473   rescue StandardError
474     raise klass.new(*args)
475   end
476
477   # Construct a random token of a given length
478   def self.make_token(length = 30)
479     chars = "abcdefghijklmnopqrtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
480     token = ""
481
482     length.times do
483       token += chars[(rand * chars.length).to_i].chr
484     end
485
486     token
487   end
488
489   # Return an SQL fragment to select a given area of the globe
490   def self.sql_for_area(bbox, prefix = nil)
491     tilesql = QuadTile.sql_for_area(bbox, prefix)
492     bbox = bbox.to_scaled
493
494     "#{tilesql} AND #{prefix}latitude BETWEEN #{bbox.min_lat} AND #{bbox.max_lat} " \
495       "AND #{prefix}longitude BETWEEN #{bbox.min_lon} AND #{bbox.max_lon}"
496   end
497
498   # Return the terms and conditions text for a given country
499   def self.legal_text_for_country(country_code)
500     file_name = Rails.root.join("config", "legales", country_code.to_s + ".yml")
501     file_name = Rails.root.join("config", "legales", Settings.default_legale + ".yml") unless File.exist? file_name
502     YAML.load_file(file_name).transform_values!(&:html_safe)
503   end
504
505   # Return the HTTP client to use
506   def self.http_client
507     @http_client ||= Faraday.new
508   end
509
510   # Return the MaxMindDB database handle
511   def self.maxmind_database
512     @maxmind_database ||= MaxMindDB.new(Settings.maxmind_database) if Settings.key?(:maxmind_database)
513   end
514 end