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