X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/09fdee54938792f06ce5b0636f01440a17117add..d887252eeb49f905a979c21f2559c85d9a0455bd:/app/controllers/api_controller.rb diff --git a/app/controllers/api_controller.rb b/app/controllers/api_controller.rb index 029e4c8a6..735e1bd59 100644 --- a/app/controllers/api_controller.rb +++ b/app/controllers/api_controller.rb @@ -1,268 +1,105 @@ class ApiController < ApplicationController - - session :off - before_filter :check_api_readable, :except => [:capabilities] - after_filter :compress_output - - # Help methods for checking boundary sanity and area size - include MapBoundary - - #COUNT is the number of map requests to allow before exiting and starting a new process - @@count = COUNT - - # The maximum area you're allowed to request, in square degrees - MAX_REQUEST_AREA = 0.25 - - # Number of GPS trace/trackpoints returned per-page - TRACEPOINTS_PER_PAGE = 5000 - - - def trackpoints - @@count+=1 - #retrieve the page number - page = params['page'].to_i - unless page - page = 0; - end - - unless page >= 0 - report_error("Page number must be greater than or equal to 0") - return - end - - offset = page * TRACEPOINTS_PER_PAGE - - # Figure out the bbox - bbox = params['bbox'] - unless bbox and bbox.count(',') == 3 - report_error("The parameter bbox is required, and must be of the form min_lon,min_lat,max_lon,max_lat") - return - end - - bbox = bbox.split(',') - min_lon, min_lat, max_lon, max_lat = sanitise_boundaries(bbox) - # check boundary is sane and area within defined - # see /config/application.yml - begin - check_boundaries(min_lon, min_lat, max_lon, max_lat) - rescue Exception => err - report_error(err.message) - return - end - - # get all the points - points = Tracepoint.find_by_area(min_lat, min_lon, max_lat, max_lon, :offset => offset, :limit => TRACEPOINTS_PER_PAGE, :order => "timestamp DESC" ) - - doc = XML::Document.new - doc.encoding = XML::Encoding::UTF_8 - root = XML::Node.new 'gpx' - root['version'] = '1.0' - root['creator'] = 'OpenStreetMap.org' - root['xmlns'] = "http://www.topografix.com/GPX/1/0/" - - doc.root = root - - track = XML::Node.new 'trk' - doc.root << track - - trkseg = XML::Node.new 'trkseg' - track << trkseg - - points.each do |point| - trkseg << point.to_xml_node() - end - - #exit when we have too many requests - if @@count > MAX_COUNT - render :text => doc.to_s, :content_type => "text/xml" - @@count = COUNT - exit! - end - - response.headers["Content-Disposition"] = "attachment; filename=\"map.osm\"" - - render :text => doc.to_s, :content_type => "text/xml" - end - + skip_before_action :verify_authenticity_token + before_action :api_deny_access_handler + + authorize_resource :class => false + + before_action :check_api_readable + around_action :api_call_handle_error, :api_call_timeout + + # This is probably the most common call of all. It is used for getting the + # OSM data for a specified bounding box, usually for editing. First the + # bounding box (bbox) is checked to make sure that it is sane. All nodes + # are searched, then all the ways that reference those nodes are found. + # All Nodes that are referenced by those ways are fetched and added to the list + # of nodes. + # Then all the relations that reference the already found nodes and ways are + # fetched. All the nodes and ways that are referenced by those ways are then + # fetched. Finally all the xml is returned. def map - GC.start - @@count+=1 # Figure out the bbox - bbox = params['bbox'] - - unless bbox and bbox.count(',') == 3 - # alternatively: report_error(TEXT['boundary_parameter_required'] - report_error("The parameter bbox is required, and must be of the form min_lon,min_lat,max_lon,max_lat") - return - end - - bbox = bbox.split(',') - - min_lon, min_lat, max_lon, max_lat = sanitise_boundaries(bbox) - # check boundary is sane and area within defined # see /config/application.yml begin - check_boundaries(min_lon, min_lat, max_lon, max_lat) - rescue Exception => err + bbox = BoundingBox.from_bbox_params(params) + bbox.check_boundaries + bbox.check_size + rescue StandardError => err report_error(err.message) return end - @nodes = Node.find_by_area(min_lat, min_lon, max_lat, max_lon, :conditions => "visible = 1", :limit => APP_CONFIG['max_number_of_nodes']+1) - # get all the nodes, by tag not yet working, waiting for change from NickB - # need to be @nodes (instance var) so tests in /spec can be performed - #@nodes = Node.search(bbox, params[:tag]) + nodes = Node.bbox(bbox).where(:visible => true).includes(:node_tags).limit(MAX_NUMBER_OF_NODES + 1) - node_ids = @nodes.collect(&:id) - if node_ids.length > APP_CONFIG['max_number_of_nodes'] - report_error("You requested too many nodes (limit is 50,000). Either request a smaller area, or use planet.osm") - return - end - if node_ids.length == 0 - render :text => "", :content_type => "text/xml" + node_ids = nodes.collect(&:id) + if node_ids.length > MAX_NUMBER_OF_NODES + report_error("You requested too many nodes (limit is #{MAX_NUMBER_OF_NODES}). Either request a smaller area, or use planet.osm") return end doc = OSM::API.new.get_xml_doc # add bounds - bounds = XML::Node.new 'bounds' - bounds['minlat'] = min_lat.to_s - bounds['minlon'] = min_lon.to_s - bounds['maxlat'] = max_lat.to_s - bounds['maxlon'] = max_lon.to_s - doc.root << bounds + doc.root << bbox.add_bounds_to(XML::Node.new("bounds")) # get ways # find which ways are needed - ways = Array.new - if node_ids.length > 0 - way_nodes = WayNode.find_all_by_node_id(node_ids) + ways = [] + if node_ids.empty? + list_of_way_nodes = [] + else + way_nodes = WayNode.where(:node_id => node_ids) way_ids = way_nodes.collect { |way_node| way_node.id[0] } - ways = Way.find(way_ids) + ways = Way.preload(:way_nodes, :way_tags).find(way_ids) - list_of_way_nodes = ways.collect { |way| - way.way_nodes.collect { |way_node| way_node.node_id } - } + list_of_way_nodes = ways.collect do |way| + way.way_nodes.collect(&:node_id) + end list_of_way_nodes.flatten! - - else - list_of_way_nodes = Array.new end # - [0] in case some thing links to node 0 which doesn't exist. Shouldn't actually ever happen but it does. FIXME: file a ticket for this nodes_to_fetch = (list_of_way_nodes.uniq - node_ids) - [0] - if nodes_to_fetch.length > 0 - @nodes += Node.find(nodes_to_fetch) - end + nodes += Node.includes(:node_tags).find(nodes_to_fetch) unless nodes_to_fetch.empty? visible_nodes = {} + changeset_cache = {} user_display_name_cache = {} - @nodes.each do |node| + nodes.each do |node| if node.visible? - doc.root << node.to_xml_node(user_display_name_cache) + doc.root << node.to_xml_node(changeset_cache, user_display_name_cache) visible_nodes[node.id] = node end end - way_ids = Array.new + way_ids = [] ways.each do |way| if way.visible? - doc.root << way.to_xml_node(visible_nodes, user_display_name_cache) + doc.root << way.to_xml_node(visible_nodes, changeset_cache, user_display_name_cache) way_ids << way.id end - end + end - relations = Relation.find_for_nodes(visible_nodes.keys, :conditions => "visible = 1") + - Relation.find_for_ways(way_ids, :conditions => "visible = 1") + relations = Relation.nodes(visible_nodes.keys).visible + + Relation.ways(way_ids).visible - # we do not normally return the "other" partners referenced by an relation, - # e.g. if we return a way A that is referenced by relation X, and there's - # another way B also referenced, that is not returned. But we do make - # an exception for cases where an relation references another *relation*; + # we do not normally return the "other" partners referenced by an relation, + # e.g. if we return a way A that is referenced by relation X, and there's + # another way B also referenced, that is not returned. But we do make + # an exception for cases where an relation references another *relation*; # in that case we return that as well (but we don't go recursive here) - relations += Relation.find_for_relations(relations.collect { |r| r.id }, :conditions => "visible = 1") + relations += Relation.relations(relations.collect(&:id)).visible # this "uniq" may be slightly inefficient; it may be better to first collect and output # all node-related relations, then find the *not yet covered* way-related ones etc. relations.uniq.each do |relation| - doc.root << relation.to_xml_node(user_display_name_cache) + doc.root << relation.to_xml_node(changeset_cache, user_display_name_cache) end response.headers["Content-Disposition"] = "attachment; filename=\"map.osm\"" - render :text => doc.to_s, :content_type => "text/xml" - - #exit when we have too many requests - if @@count > MAX_COUNT - @@count = COUNT - - exit! - end - end - - def changes - zoom = (params[:zoom] || '12').to_i - - if params.include?(:start) and params.include?(:end) - starttime = Time.parse(params[:start]) - endtime = Time.parse(params[:end]) - else - hours = (params[:hours] || '1').to_i.hours - endtime = Time.now - starttime = endtime - hours - end - - if zoom >= 1 and zoom <= 16 and - endtime >= starttime and endtime - starttime <= 24.hours - mask = (1 << zoom) - 1 - - tiles = Node.count(:conditions => ["timestamp BETWEEN ? AND ?", starttime, endtime], - :group => "maptile_for_point(latitude, longitude, #{zoom})") - - doc = OSM::API.new.get_xml_doc - changes = XML::Node.new 'changes' - changes["starttime"] = starttime.xmlschema - changes["endtime"] = endtime.xmlschema - - tiles.each do |tile, count| - x = (tile.to_i >> zoom) & mask - y = tile.to_i & mask - - t = XML::Node.new 'tile' - t["x"] = x.to_s - t["y"] = y.to_s - t["z"] = zoom.to_s - t["changes"] = count.to_s - - changes << t - end - - doc.root << changes - - render :text => doc.to_s, :content_type => "text/xml" - else - render :nothing => true, :status => :bad_request - end - end - - def capabilities - doc = OSM::API.new.get_xml_doc - - api = XML::Node.new 'api' - version = XML::Node.new 'version' - version['minimum'] = '0.5'; - version['maximum'] = '0.5'; - api << version - area = XML::Node.new 'area' - area['maximum'] = MAX_REQUEST_AREA.to_s; - api << area - - doc.root << api - - render :text => doc.to_s, :content_type => "text/xml" + render :xml => doc.to_s end end