]> git.openstreetmap.org Git - rails.git/blob - lib/osm.rb
a4ac7fc576aa91db7d47131e7c4866c7d4db0fbd
[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 initialize(message)
251       super message
252     end
253
254     def status
255       :bad_request
256     end
257   end
258
259   ##
260   # raised when bounding box is invalid
261   class APIBadBoundingBox < APIError
262     def initialize(message)
263       super message
264     end
265
266     def status
267       :bad_request
268     end
269   end
270
271   ##
272   # raised when an API call is made using a method not supported on that URI
273   class APIBadMethodError < APIError
274     def initialize(supported_method)
275       super "Only method #{supported_method} is supported on this URI"
276     end
277
278     def status
279       :method_not_allowed
280     end
281   end
282
283   ##
284   # raised when an API call takes too long
285   class APITimeoutError < APIError
286     def initialize
287       super "Request timed out"
288     end
289
290     def status
291       :request_timeout
292     end
293   end
294
295   ##
296   # raised when someone tries to redact a current version of
297   # an element - only historical versions can be redacted.
298   class APICannotRedactError < APIError
299     def initialize
300       super "Cannot redact current version of element, only historical versions may be redacted."
301     end
302
303     def status
304       :bad_request
305     end
306   end
307
308   # Raised when the note provided is already closed
309   class APINoteAlreadyClosedError < APIError
310     def initialize(note)
311       @note = note
312
313       super "The note #{note.id} was closed at #{note.closed_at}"
314     end
315
316     attr_reader :note
317
318     def status
319       :conflict
320     end
321   end
322
323   # Raised when the note provided is already open
324   class APINoteAlreadyOpenError < APIError
325     def initialize(note)
326       @note = note
327
328       super "The note #{note.id} is already open"
329     end
330
331     attr_reader :note
332
333     def status
334       :conflict
335     end
336   end
337
338   # raised when a two preferences have a duplicate key string.
339   class APIDuplicatePreferenceError < APIError
340     def initialize(key)
341       @key = key
342
343       super "Duplicate preferences with key #{key}"
344     end
345
346     attr_reader :key
347
348     def status
349       :bad_request
350     end
351   end
352
353   # Helper methods for going to/from mercator and lat/lng.
354   class Mercator
355     include Math
356
357     # init me with your bounding box and the size of your image
358     def initialize(min_lat, min_lon, max_lat, max_lon, width, height)
359       xsize = xsheet(max_lon) - xsheet(min_lon)
360       ysize = ysheet(max_lat) - ysheet(min_lat)
361       xscale = xsize / width
362       yscale = ysize / height
363       scale = [xscale, yscale].max
364
365       xpad = width * scale - xsize
366       ypad = height * scale - ysize
367
368       @width = width
369       @height = height
370
371       @tx = xsheet(min_lon) - xpad / 2
372       @ty = ysheet(min_lat) - ypad / 2
373
374       @bx = xsheet(max_lon) + xpad / 2
375       @by = ysheet(max_lat) + ypad / 2
376     end
377
378     # the following two functions will give you the x/y on the entire sheet
379
380     def ysheet(lat)
381       log(tan(PI / 4 + (lat * PI / 180 / 2))) / (PI / 180)
382     end
383
384     def xsheet(lon)
385       lon
386     end
387
388     # and these two will give you the right points on your image. all the constants can be reduced to speed things up. FIXME
389
390     def y(lat)
391       @height - ((ysheet(lat) - @ty) / (@by - @ty) * @height)
392     end
393
394     def x(lon)
395       ((xsheet(lon) - @tx) / (@bx - @tx) * @width)
396     end
397   end
398
399   class GreatCircle
400     include Math
401
402     # initialise with a base position
403     def initialize(lat, lon)
404       @lat = lat * PI / 180
405       @lon = lon * PI / 180
406     end
407
408     # get the distance from the base position to a given position
409     def distance(lat, lon)
410       lat = lat * PI / 180
411       lon = lon * PI / 180
412       6372.795 * 2 * asin(sqrt(sin((lat - @lat) / 2)**2 + cos(@lat) * cos(lat) * sin((lon - @lon) / 2)**2))
413     end
414
415     # get the worst case bounds for a given radius from the base position
416     def bounds(radius)
417       latradius = 2 * asin(sqrt(sin(radius / 6372.795 / 2)**2))
418
419       begin
420         lonradius = 2 * asin(sqrt(sin(radius / 6372.795 / 2)**2 / cos(@lat)**2))
421       rescue Errno::EDOM, Math::DomainError
422         lonradius = PI
423       end
424
425       minlat = [(@lat - latradius) * 180 / PI, -90].max
426       maxlat = [(@lat + latradius) * 180 / PI, 90].min
427       minlon = [(@lon - lonradius) * 180 / PI, -180].max
428       maxlon = [(@lon + lonradius) * 180 / PI, 180].min
429
430       BoundingBox.new(minlon, minlat, maxlon, maxlat)
431     end
432
433     # get the SQL to use to calculate distance
434     def sql_for_distance(lat_field, lon_field)
435       "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)))"
436     end
437   end
438
439   class API
440     def get_xml_doc
441       doc = XML::Document.new
442       doc.encoding = XML::Encoding::UTF_8
443       root = XML::Node.new "osm"
444       xml_root_attributes.each do |k, v|
445         root[k] = v
446       end
447       doc.root = root
448       doc
449     end
450
451     def xml_root_attributes
452       { "version" => Settings.api_version,
453         "generator" => Settings.generator,
454         "copyright" => Settings.copyright_owner,
455         "attribution" => Settings.attribution_url,
456         "license" => Settings.license_url }
457     end
458   end
459
460   def self.ip_to_country(ip_address)
461     ipinfo = maxmind_database.lookup(ip_address) if Settings.key?(:maxmind_database)
462
463     return ipinfo.country.iso_code if ipinfo&.found?
464
465     nil
466   end
467
468   def self.ip_location(ip_address)
469     code = OSM.ip_to_country(ip_address)
470
471     if code && country = Country.find(code)
472       return { :minlon => country.min_lon, :minlat => country.min_lat, :maxlon => country.max_lon, :maxlat => country.max_lat }
473     end
474
475     nil
476   end
477
478   # Parse a float, raising a specified exception on failure
479   def self.parse_float(str, klass, *args)
480     Float(str)
481   rescue StandardError
482     raise klass.new(*args)
483   end
484
485   # Construct a random token of a given length
486   def self.make_token(length = 30)
487     chars = "abcdefghijklmnopqrtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
488     token = ""
489
490     length.times do
491       token += chars[(rand * chars.length).to_i].chr
492     end
493
494     token
495   end
496
497   # Return an SQL fragment to select a given area of the globe
498   def self.sql_for_area(bbox, prefix = nil)
499     tilesql = QuadTile.sql_for_area(bbox, prefix)
500     bbox = bbox.to_scaled
501
502     "#{tilesql} AND #{prefix}latitude BETWEEN #{bbox.min_lat} AND #{bbox.max_lat} " \
503       "AND #{prefix}longitude BETWEEN #{bbox.min_lon} AND #{bbox.max_lon}"
504   end
505
506   # Return the terms and conditions text for a given country
507   def self.legal_text_for_country(country_code)
508     file_name = Rails.root.join("config", "legales", country_code.to_s + ".yml")
509     file_name = Rails.root.join("config", "legales", Settings.default_legale + ".yml") unless File.exist? file_name
510     YAML.load_file(file_name).transform_values!(&:html_safe)
511   end
512
513   # Return the HTTP client to use
514   def self.http_client
515     @http_client ||= Faraday.new
516   end
517
518   # Return the MaxMindDB database handle
519   def self.maxmind_database
520     @maxmind_database ||= MaxMindDB.new(Settings.maxmind_database) if Settings.key?(:maxmind_database)
521   end
522 end