source: subversion/sites/rails_port/lib/osm.rb @ 20148

Last change on this file since 20148 was 18788, checked in by tomhughes, 11 years ago

Add support for GeoIP lookups using Quova.

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