X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/183ffc78648938ca079f7ea5f899d3e71e829333..e825f8b2647fb1bc62fb017149930b94ec4d4ea2:/lib/osm.rb?ds=inline diff --git a/lib/osm.rb b/lib/osm.rb index 223e351f4..a2432c1e6 100644 --- a/lib/osm.rb +++ b/lib/osm.rb @@ -5,52 +5,104 @@ module OSM require 'rexml/parsers/sax2parser' require 'rexml/text' require 'xml/libxml' - require 'digest/md5' - require 'RMagick' + + if defined?(SystemTimer) + Timer = SystemTimer + else + require 'timeout' + Timer = Timeout + end # The base class for API Errors. class APIError < RuntimeError - def render_opts - { :text => "", :status => :internal_server_error } + def status + :internal_server_error + end + + def to_s + "Generic API Error" end end # Raised when an API object is not found. class APINotFoundError < APIError + def status + :not_found + end + + def to_s + "Object 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 = "") + @message = message + end + + def status + :precondition_failed + end + + def to_s + "Precondition failed: #{@message}" 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_id = object, object_id + end + + attr_reader :object, :object_id + + def status + :gone + end + + def to_s + "The #{object} with the id #{object_id} has already been deleted" 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 status + :conflict + end + + def to_s + "The user doesn't own that changeset" 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 + end + + attr_reader :changeset + + def status + :conflict + end + + def to_s + "The changeset #{@changeset.id} was closed at #{@changeset.closed_at}" 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 status + :conflict + end + + def to_s + "You need to supply a changeset to be able to make a change" end end @@ -60,50 +112,62 @@ module OSM def initialize(provided, allowed) @provided, @allowed = provided, allowed end - - def render_opts - { :text => "Changeset mismatch: Provided #{@provided} but only " + - "#{@allowed} is allowed.", :status => :conflict } + + def status + :conflict + end + + def to_s + "Changeset mismatch: Provided #{@provided} but only #{@allowed} is allowed" 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) @provided = provided end - - def render_opts - { :text => "Unknown action #{@provided}, choices are create, modify, delete.", - :status => :bad_request } + + def status + :bad_request + end + + def to_s + "Unknown action #{@provided}, choices are create, modify, delete" end end # Raised when bad XML is encountered which stops things parsing as # they should. class APIBadXMLError < APIError - def initialize(model, xml) - @model, @xml = model, xml + def initialize(model, xml, message="") + @model, @xml, @message = model, xml, message + end + + def status + :bad_request end - def render_opts - { :text => "Cannot parse valid #{@model} from xml string #{@xml}", - :status => :bad_request } + def to_s + "Cannot parse valid #{@model} from xml string #{@xml}. #{@message}" 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, @type, @provided, @latest = id, type, provided, latest 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 + + def to_s + "Version mismatch: Provided #{provided}, server had: #{latest} of #{type} #{id}" end end @@ -116,24 +180,154 @@ module OSM 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 + + def to_s + "Element #{@type}/#{@id} has duplicate tags with key #{@tag_key}" 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(provided, max) - @provided, @max = provided, max + def initialize(id, provided, max) + @id, @provided, @max = id, provided, max end - - attr_reader :provided, :max - - def render_opts - { :text => "You tried to add #{provided} nodes to the way, however only #{max} are allowed", - :status => :bad_request } + + attr_reader :id, :provided, :max + + def status + :bad_request + end + + def to_s + "You tried to add #{provided} nodes to way #{id}, however only #{max} are allowed" + end + end + + ## + # raised when user input couldn't be parsed + class APIBadUserInput < APIError + def initialize(message) + @message = message + end + + def status + :bad_request + end + + def to_s + @message + end + end + + ## + # raised when bounding box is invalid + class APIBadBoundingBox < APIError + def initialize(message) + @message = message + end + + def status + :bad_request + end + + def to_s + @message + end + end + + ## + # raised when an API call is made using a method not supported on that URI + class APIBadMethodError < APIError + def initialize(supported_method) + @supported_method = supported_method + end + + def status + :method_not_allowed + end + + def to_s + "Only method #{@supported_method} is supported on this URI" + end + end + + ## + # raised when an API call takes too long + class APITimeoutError < APIError + def status + :request_timeout + end + + def to_s + "Request timed out" + end + end + + ## + # raised when someone tries to redact a current version of + # an element - only historical versions can be redacted. + class APICannotRedactError < APIError + def status + :bad_request + end + + def to_s + "Cannot redact current version of element, only historical versions may be redacted." + end + end + + # Raised when the note provided is already closed + class APINoteAlreadyClosedError < APIError + def initialize(note) + @note = note + end + + attr_reader :note + + def status + :conflict + end + + def to_s + "The note #{@note.id} was closed at #{@note.closed_at}" + end + end + + # Raised when the note provided is already open + class APINoteAlreadyOpenError < APIError + def initialize(note) + @note = note + end + + attr_reader :note + + def status + :conflict + end + + def to_s + "The note #{@note.id} is already open" + end + end + + # raised when a two preferences have a duplicate key string. + class APIDuplicatePreferenceError < APIError + def initialize(key) + @key = key + end + + attr_reader :key + + def status + :bad_request + end + + def to_s + "Duplicate preferences with key #{@key}" end end @@ -202,129 +396,56 @@ module OSM # 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)) + + begin + lonradius = 2 * asin(sqrt(sin(radius / 6372.795 / 2) ** 2 / cos(@lat) ** 2)) + rescue Errno::EDOM + lonradius = PI + end + 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 - if longitude - lon_el = XML::Node.new 'geo:long' - lon_el << longitude.to_s - item << lon_el - end - - @channel << item - 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 doc = XML::Document.new - doc.encoding = 'UTF-8' + doc.encoding = XML::Encoding::UTF_8 root = XML::Node.new 'osm' - root['version'] = API_VERSION + root['version'] = API_VERSION.to_s root['generator'] = GENERATOR + root['copyright'] = COPYRIGHT_OWNER + root['attribution'] = ATTRIBUTION_URL + root['license'] = LICENSE_URL 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 + def self.IPToCountry(ip_address) + Timer.timeout(4) do + ipinfo = Quova::IpInfo.new(ip_address) + + if ipinfo.status == Quova::Success then + country = ipinfo.country_code + else + Net::HTTP.start('api.hostip.info') do |http| + country = http.get("/country.php?ip=#{ip_address}").body + country = "GB" if country == "UK" end end + + return country.upcase end return nil @@ -332,6 +453,23 @@ module OSM return nil end + def self.IPLocation(ip_address) + code = OSM.IPToCountry(ip_address) + + if code and country = Country.find_by_code(code) + return { :minlon => country.min_lon, :minlat => country.min_lat, :maxlon => country.max_lon, :maxlat => country.max_lat } + end + + return nil + end + + # Parse a float, raising a specified exception on failure + def self.parse_float(str, klass, *args) + Float(str) + rescue + raise klass.new(*args) + end + # Construct a random token of a given length def self.make_token(length = 30) chars = 'abcdefghijklmnopqrtuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789' @@ -344,22 +482,18 @@ module OSM return token 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) - 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 - - return "#{tilesql} AND #{prefix}latitude BETWEEN #{minlat} AND #{maxlat} AND #{prefix}longitude BETWEEN #{minlon} AND #{maxlon}" - end + 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 #{bbox.min_lat} AND #{bbox.max_lat} " + + "AND #{prefix}longitude BETWEEN #{bbox.min_lon} AND #{bbox.max_lon}" + end + def self.legal_text_for_country(country_code) + file_name = File.join(Rails.root, "config", "legales", country_code.to_s + ".yml") + file_name = File.join(Rails.root, "config", "legales", DEFAULT_LEGALE + ".yml") unless File.exist? file_name + YAML::load_file(file_name) + end end