X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/b56f57ec43dfefa4171dc0cefe26d9e75d4ca2bc..0f50292784a4353e883ddc3771e52b8d4b8a4133:/lib/osm.rb diff --git a/lib/osm.rb b/lib/osm.rb index ae8b81f5b..46f37036f 100644 --- a/lib/osm.rb +++ b/lib/osm.rb @@ -1,70 +1,203 @@ # The OSM module provides support functions for OSM. module OSM - - require 'time' - require 'rexml/parsers/sax2parser' - require 'rexml/text' - require 'xml/libxml' - require 'digest/md5' - require 'RMagick' + require "time" + require "rexml/parsers/sax2parser" + require "rexml/text" + require "xml/libxml" # The base class for API Errors. class APIError < RuntimeError - def render_opts - { :text => "", :status => :internal_server_error } + def initialize(message = "Generic API Error") + super + end + + def status + :internal_server_error + end + end + + # Raised when access is denied. + class APIAccessDenied < APIError + def initialize + super("Access denied") + end + + def status + :forbidden end end # Raised when an API object is not found. class APINotFoundError < APIError + def initialize + super("Object not found") + end + + def status + :not_found + end end # Raised when a precondition to an API action fails sanity check. class APIPreconditionFailedError < APIError - def render_opts - { :text => "", :status => :precondition_failed } + def initialize(message = "") + super("Precondition failed: #{message}") + end + + def status + :precondition_failed end end # Raised when to delete an already-deleted object. class APIAlreadyDeletedError < APIError - def render_opts - { :text => "", :status => :gone } + def initialize(object = "object", object_id = "") + @object = object + @object_id = object_id + + super("The #{object} with the id #{object_id} has already been deleted") + end + + attr_reader :object, :object_id + + def status + :gone end end # Raised when the user logged in isn't the same as the changeset class APIUserChangesetMismatchError < APIError - def render_opts - { :text => "The user doesn't own that changeset", :status => :conflict } + def initialize + super("The user doesn't own that changeset") + end + + def status + :conflict end end # Raised when the changeset provided is already closed class APIChangesetAlreadyClosedError < APIError - def render_opts - { :text => "The supplied changeset has already been closed", :status => :conflict } + def initialize(changeset) + @changeset = changeset + + super("The changeset #{changeset.id} was closed at #{changeset.closed_at}") + end + + attr_reader :changeset + + def status + :conflict end end - + + # Raised when the changeset provided is not yet closed + class APIChangesetNotYetClosedError < APIError + def initialize(changeset) + @changeset = changeset + + super("The changeset #{changeset.id} is not yet closed.") + end + + attr_reader :changeset + + def status + :conflict + end + end + + # Raised when a user is already subscribed to the changeset + class APIChangesetAlreadySubscribedError < APIError + def initialize(changeset) + @changeset = changeset + + super("You are already subscribed to changeset #{changeset.id}.") + end + + attr_reader :changeset + + def status + :conflict + end + end + + # Raised when a user is not subscribed to the changeset + class APIChangesetNotSubscribedError < APIError + def initialize(changeset) + @changeset = changeset + + super("You are not subscribed to changeset #{changeset.id}.") + end + + attr_reader :changeset + + def status + :not_found + end + end + # Raised when a change is expecting a changeset, but the changeset doesn't exist class APIChangesetMissingError < APIError - def render_opts - { :text => "You need to supply a changeset to be able to make a change", :status => :conflict } + def initialize + super("You need to supply a changeset to be able to make a change") + end + + def status + :conflict + end + end + + # Raised when a diff is uploaded containing many changeset IDs which don't match + # the changeset ID that the diff was uploaded to. + class APIChangesetMismatchError < APIError + def initialize(provided, allowed) + super("Changeset mismatch: Provided #{provided} but only #{allowed} is allowed") + end + + def status + :conflict + end + end + + # Raised when a diff upload has an unknown action. You can only have create, + # modify, or delete + class APIChangesetActionInvalid < APIError + def initialize(provided) + super("Unknown action #{provided}, choices are create, modify, delete") + end + + def status + :bad_request + end + end + + # Raised when bad XML is encountered which stops things parsing as + # they should. + class APIBadXMLError < APIError + def initialize(model, xml, message = "") + super("Cannot parse valid #{model} from xml string #{xml}. #{message}") + end + + def status + :bad_request end end # Raised when the provided version is not equal to the latest in the db. class APIVersionMismatchError < APIError - def initialize(provided, latest) - @provided, @latest = provided, latest + def initialize(id, type, provided, latest) + @id = id + @type = type + @provided = provided + @latest = latest + + super("Version mismatch: Provided #{provided}, server had: #{latest} of #{type} #{id}") end - attr_reader :provided, :latest + attr_reader :provided, :latest, :id, :type - def render_opts - { :text => "Version mismatch: Provided " + provided.to_s + - ", server had: " + latest.to_s, :status => :conflict } + def status + :conflict end end @@ -72,14 +205,173 @@ module OSM # this is now forbidden by the API. class APIDuplicateTagsError < APIError def initialize(type, id, tag_key) - @type, @id, @tag_key = type, id, tag_key + @type = type + @id = id + @tag_key = tag_key + + super("Element #{type}/#{id} has duplicate tags with key #{tag_key}") end attr_reader :type, :id, :tag_key - def render_opts - { :text => "Element #{@type}/#{@id} has duplicate tags with key #{@tag_key}.", - :status => :bad_request } + def status + :bad_request + end + end + + # Raised when a way has more than the configured number of way nodes. + # This prevents ways from being to long and difficult to work with + class APITooManyWayNodesError < APIError + def initialize(id, provided, max) + super("You tried to add #{provided} nodes to way #{id}, however only #{max} are allowed") + + @id = id + @provided = provided + @max = max + end + + attr_reader :id, :provided, :max + + def status + :bad_request + end + end + + # Raised when a relation has more than the configured number of relation members. + # This prevents relations from being too complex and difficult to work with + class APITooManyRelationMembersError < APIError + def initialize(id, provided, max) + super("You tried to add #{provided} members to relation #{id}, however only #{max} are allowed") + + @id = id + @provided = provided + @max = max + end + + attr_reader :id, :provided, :max + + def status + :bad_request + end + end + + ## + # raised when user input couldn't be parsed + class APIBadUserInput < APIError + def status + :bad_request + end + end + + ## + # raised when bounding box is invalid + class APIBadBoundingBox < APIError + def status + :bad_request + end + end + + ## + # raised when an API call is made using a method not supported on that URI + class APIBadMethodError < APIError + def initialize(supported_method) + super("Only method #{supported_method} is supported on this URI") + end + + def status + :method_not_allowed + end + end + + ## + # raised when an API call takes too long + class APITimeoutError < APIError + def initialize + super("Request timed out") + end + + def status + :request_timeout + end + end + + ## + # raised when someone tries to redact a current version of + # an element - only historical versions can be redacted. + class APICannotRedactError < APIError + def initialize + super("Cannot redact current version of element, only historical versions may be redacted.") + end + + def status + :bad_request + end + end + + # Raised when the note provided is already closed + class APINoteAlreadyClosedError < APIError + def initialize(note) + @note = note + + super("The note #{note.id} was closed at #{note.closed_at}") + end + + attr_reader :note + + def status + :conflict + end + end + + # Raised when the note provided is already open + class APINoteAlreadyOpenError < APIError + def initialize(note) + @note = note + + super("The note #{note.id} is already open") + end + + attr_reader :note + + def status + :conflict + end + end + + # raised when a two preferences have a duplicate key string. + class APIDuplicatePreferenceError < APIError + def initialize(key) + @key = key + + super("Duplicate preferences with key #{key}") + end + + attr_reader :key + + def status + :bad_request + end + end + + # Raised when a rate limit is exceeded + class APIRateLimitExceeded < APIError + def initialize + super("Rate limit exceeded") + end + + def status + :too_many_requests + end + end + + # Raised when a size limit is exceeded + class APISizeLimitExceeded < APIError + def initialize + super("Size limit exceeded") + end + + def status + :payload_too_large end end @@ -87,7 +379,7 @@ module OSM class Mercator include Math - #init me with your bounding box and the size of your image + # init me with your bounding box and the size of your image def initialize(min_lat, min_lon, max_lat, max_lon, width, height) xsize = xsheet(max_lon) - xsheet(min_lon) ysize = ysheet(max_lat) - ysheet(min_lat) @@ -95,37 +387,42 @@ module OSM yscale = ysize / height scale = [xscale, yscale].max - xpad = width * scale - xsize - ypad = height * scale - ysize + xpad = (width * scale) - xsize + ypad = (height * scale) - ysize @width = width @height = height - @tx = xsheet(min_lon) - xpad / 2 - @ty = ysheet(min_lat) - ypad / 2 + @tx = xsheet(min_lon) - (xpad / 2) + @ty = ysheet(min_lat) - (ypad / 2) - @bx = xsheet(max_lon) + xpad / 2 - @by = ysheet(max_lat) + ypad / 2 + @bx = xsheet(max_lon) + (xpad / 2) + @by = ysheet(max_lat) + (ypad / 2) end - #the following two functions will give you the x/y on the entire sheet + # the following two functions will give you the x/y on the entire sheet def ysheet(lat) - log(tan(PI / 4 + (lat * PI / 180 / 2))) / (PI / 180) + log(tan((PI / 4) + (lat * PI / 180 / 2))) / (PI / 180) end def xsheet(lon) lon end - #and these two will give you the right points on your image. all the constants can be reduced to speed things up. FIXME + # and these two will give you the right points on your image. all the constants can be reduced to speed things up. FIXME + # If the bbox has no extent, return the centre of the image to avoid dividing by zero. def y(lat) - return @height - ((ysheet(lat) - @ty) / (@by - @ty) * @height) + return @height / 2 if (@by - @ty).zero? + + @height - ((ysheet(lat) - @ty) / (@by - @ty) * @height) end def x(lon) - return ((xsheet(lon) - @tx) / (@bx - @tx) * @width) + return @width / 2 if (@bx - @tx).zero? + + ((xsheet(lon) - @tx) / (@bx - @tx) * @width) end end @@ -142,170 +439,108 @@ module OSM def distance(lat, lon) lat = lat * PI / 180 lon = lon * PI / 180 - return 6372.795 * 2 * asin(sqrt(sin((lat - @lat) / 2) ** 2 + cos(@lat) * cos(lat) * sin((lon - @lon)/2) ** 2)) + 6372.795 * 2 * asin(sqrt((sin((lat - @lat) / 2)**2) + (cos(@lat) * cos(lat) * (sin((lon - @lon) / 2)**2)))) end # get the worst case bounds for a given radius from the base position def bounds(radius) - latradius = 2 * asin(sqrt(sin(radius / 6372.795 / 2) ** 2)) - lonradius = 2 * asin(sqrt(sin(radius / 6372.795 / 2) ** 2 / cos(@lat) ** 2)) - minlat = (@lat - latradius) * 180 / PI - maxlat = (@lat + latradius) * 180 / PI - minlon = (@lon - lonradius) * 180 / PI - maxlon = (@lon + lonradius) * 180 / PI - return { :minlat => minlat, :maxlat => maxlat, :minlon => minlon, :maxlon => maxlon } - end - end - - class GeoRSS - def initialize(feed_title='OpenStreetMap GPS Traces', feed_description='OpenStreetMap GPS Traces', feed_url='http://www.openstreetmap.org/traces/') - @doc = XML::Document.new - @doc.encoding = 'UTF-8' - - rss = XML::Node.new 'rss' - @doc.root = rss - rss['version'] = "2.0" - rss['xmlns:geo'] = "http://www.w3.org/2003/01/geo/wgs84_pos#" - @channel = XML::Node.new 'channel' - rss << @channel - title = XML::Node.new 'title' - title << feed_title - @channel << title - description_el = XML::Node.new 'description' - @channel << description_el - - description_el << feed_description - link = XML::Node.new 'link' - link << feed_url - @channel << link - image = XML::Node.new 'image' - @channel << image - url = XML::Node.new 'url' - url << 'http://www.openstreetmap.org/images/mag_map-rss2.0.png' - image << url - title = XML::Node.new 'title' - title << "OpenStreetMap" - image << title - width = XML::Node.new 'width' - width << '100' - image << width - height = XML::Node.new 'height' - height << '100' - image << height - link = XML::Node.new 'link' - link << feed_url - image << link - end - - 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) - item = XML::Node.new 'item' - - title = XML::Node.new 'title' - item << title - title << title_text - link = XML::Node.new 'link' - link << url - item << link - - guid = XML::Node.new 'guid' - guid << url - item << guid - - description = XML::Node.new 'description' - description << description_text - item << description - - author = XML::Node.new 'author' - author << author_text - item << author - - pubDate = XML::Node.new 'pubDate' - pubDate << timestamp.to_s(:rfc822) - item << pubDate - - if latitude - lat_el = XML::Node.new 'geo:lat' - lat_el << latitude.to_s - item << lat_el - end + latradius = 2 * asin(sqrt(sin(radius / 6372.795 / 2)**2)) - if longitude - lon_el = XML::Node.new 'geo:long' - lon_el << longitude.to_s - item << lon_el + begin + lonradius = 2 * asin(sqrt((sin(radius / 6372.795 / 2)**2) / (cos(@lat)**2))) + rescue Errno::EDOM, Math::DomainError + lonradius = PI end - @channel << item + minlat = [(@lat - latradius) * 180 / PI, -90].max + maxlat = [(@lat + latradius) * 180 / PI, 90].min + minlon = [(@lon - lonradius) * 180 / PI, -180].max + maxlon = [(@lon + lonradius) * 180 / PI, 180].min + + BoundingBox.new(minlon, minlat, maxlon, maxlat) end - def to_s - return @doc.to_s + # get the SQL to use to calculate distance + def sql_for_distance(lat_field, lon_field) + "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)))" end end class API - def get_xml_doc + def xml_doc doc = XML::Document.new - doc.encoding = 'UTF-8' - root = XML::Node.new 'osm' - root['version'] = API_VERSION - root['generator'] = 'OpenStreetMap server' - doc.root = root - return doc - end - end - - def self.IPLocation(ip_address) - Timeout::timeout(4) do - Net::HTTP.start('api.hostip.info') do |http| - country = http.get("/country.php?ip=#{ip_address}").body - country = "GB" if country == "UK" - Net::HTTP.start('ws.geonames.org') do |http| - xml = REXML::Document.new(http.get("/countryInfo?country=#{country}").body) - xml.elements.each("geonames/country") do |ele| - minlon = ele.get_text("bBoxWest").to_s - minlat = ele.get_text("bBoxSouth").to_s - maxlon = ele.get_text("bBoxEast").to_s - maxlat = ele.get_text("bBoxNorth").to_s - return { :minlon => minlon, :minlat => minlat, :maxlon => maxlon, :maxlat => maxlat } - end - end + doc.encoding = XML::Encoding::UTF_8 + root = XML::Node.new "osm" + xml_root_attributes.each do |k, v| + root[k] = v end + doc.root = root + doc end - return nil - rescue Exception - return nil + def xml_root_attributes + { "version" => Settings.api_version, + "generator" => Settings.generator, + "copyright" => Settings.copyright_owner, + "attribution" => Settings.attribution_url, + "license" => Settings.license_url } + end end - # Construct a random token of a given length - def self.make_token(length = 30) - chars = 'abcdefghijklmnopqrtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789' - token = '' + def self.ip_to_country(ip_address) + ipinfo = maxmind_database.lookup(ip_address) if Settings.key?(:maxmind_database) + + return ipinfo.country.iso_code if ipinfo&.found? + + nil + end + + def self.ip_location(ip_address) + code = OSM.ip_to_country(ip_address) - length.times do - token += chars[(rand * chars.length).to_i].chr + if code && country = Country.find(code) + return { :minlon => country.min_lon, :minlat => country.min_lat, :maxlon => country.max_lon, :maxlat => country.max_lat } end - return token + nil end - # Return an encrypted version of a password - def self.encrypt_password(password, salt) - return Digest::MD5.hexdigest(password) if salt.nil? - return Digest::MD5.hexdigest(salt + password) + # Parse a float, raising a specified exception on failure + def self.parse_float(str, klass, *args) + Float(str) + rescue StandardError + raise klass.new(*args) + end + + # Construct a random token of a given length + def self.make_token(length = 24) + SecureRandom.urlsafe_base64(length) end # Return an SQL fragment to select a given area of the globe - def self.sql_for_area(minlat, minlon, maxlat, maxlon, prefix = nil) - tilesql = QuadTile.sql_for_area(minlat, minlon, maxlat, maxlon, prefix) - minlat = (minlat * 10000000).round - minlon = (minlon * 10000000).round - maxlat = (maxlat * 10000000).round - maxlon = (maxlon * 10000000).round + def self.sql_for_area(bbox, prefix = nil) + tilesql = QuadTile.sql_for_area(bbox, prefix) + bbox = bbox.to_scaled - return "#{tilesql} AND #{prefix}latitude BETWEEN #{minlat} AND #{maxlat} AND #{prefix}longitude BETWEEN #{minlon} AND #{maxlon}" + "#{tilesql} AND #{prefix}latitude BETWEEN #{bbox.min_lat} AND #{bbox.max_lat} " \ + "AND #{prefix}longitude BETWEEN #{bbox.min_lon} AND #{bbox.max_lon}" end + # Return the terms and conditions text for a given country + def self.legal_text_for_country(country_code) + file_name = Rails.root.join("config", "legales", "#{country_code}.yml") + file_name = Rails.root.join("config", "legales", "#{Settings.default_legale}.yml") unless File.exist? file_name + YAML.load_file(file_name).transform_values!(&:html_safe) + end + + # Return the HTTP client to use + def self.http_client + @http_client ||= Faraday.new(:request => { :timeout => 15 }, + :headers => { :user_agent => Settings.server_url }) + end + # Return the MaxMindDB database handle + def self.maxmind_database + @maxmind_database ||= MaxMindDB.new(Settings.maxmind_database) if Settings.key?(:maxmind_database) + end end