X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/e79fd0763854f8cf41aefd7364c6bdf476280811..fa13a11a94a96e47582483503753ced3db438f6f:/app/controllers/relation_controller.rb diff --git a/app/controllers/relation_controller.rb b/app/controllers/relation_controller.rb index cdd1d34d6..63e58819b 100644 --- a/app/controllers/relation_controller.rb +++ b/app/controllers/relation_controller.rb @@ -3,8 +3,9 @@ class RelationController < ApplicationController session :off before_filter :authorize, :only => [:create, :update, :delete] - before_filter :check_write_availability, :only => [:create, :update, :delete] - before_filter :check_read_availability, :except => [:create, :update, :delete] + before_filter :require_public_data, :only => [:create, :update, :delete] + before_filter :check_api_writable, :only => [:create, :update, :delete] + before_filter :check_api_readable, :except => [:create, :update, :delete] after_filter :compress_output def create @@ -12,12 +13,14 @@ class RelationController < ApplicationController if request.put? relation = Relation.from_xml(request.raw_post, true) - if relation + # We assume that an exception has been thrown if there was an error + # generating the relation + #if relation relation.create_with_history @user render :text => relation.id.to_s, :content_type => "text/plain" - else - render :nothing => true, :status => :bad_request - end + #else + # render :text => "Couldn't get turn the input into a relation.", :status => :bad_request + #end else render :nothing => true, :status => :method_not_allowed end @@ -62,7 +65,6 @@ class RelationController < ApplicationController end def delete -#XXX check if member somewhere! begin relation = Relation.find(params[:id]) new_relation = Relation.from_xml(request.raw_post) @@ -93,56 +95,59 @@ class RelationController < ApplicationController if relation.visible - # first collect nodes, ways, and relations referenced by this relation. - - ways = Way.find_by_sql("select w.* from current_ways w,current_relation_members rm where "+ - "rm.member_type='way' and rm.member_id=w.id and rm.id=#{relation.id}"); - nodes = Node.find_by_sql("select n.* from current_nodes n,current_relation_members rm where "+ - "rm.member_type='node' and rm.member_id=n.id and rm.id=#{relation.id}"); - # note query is built to exclude self just in case. - relations = Relation.find_by_sql("select r.* from current_relations r,current_relation_members rm where "+ - "rm.member_type='relation' and rm.member_id=r.id and rm.id=#{relation.id} and r.id<>rm.id"); + # first find the ids of nodes, ways and relations referenced by this + # relation - note that we exclude this relation just in case. + + node_ids = relation.members.select { |m| m[0] == 'Node' }.map { |m| m[1] } + way_ids = relation.members.select { |m| m[0] == 'Way' }.map { |m| m[1] } + relation_ids = relation.members.select { |m| m[0] == 'Relation' and m[1] != relation.id }.map { |m| m[1] } + + # next load the relations and the ways. - # now additionally collect nodes referenced by ways. Note how we recursively - # evaluate ways but NOT relations. + relations = Relation.find(relation_ids, :include => [:relation_tags]) + ways = Way.find(way_ids, :include => [:way_nodes, :way_tags]) + + # now additionally collect nodes referenced by ways. Note how we + # recursively evaluate ways but NOT relations. - node_ids = nodes.collect {|node| node.id } way_node_ids = ways.collect { |way| way.way_nodes.collect { |way_node| way_node.node_id } } - way_node_ids.flatten! - way_node_ids.uniq - way_node_ids -= node_ids - nodes += Node.find(way_node_ids) + node_ids += way_node_ids.flatten + nodes = Node.find(node_ids.uniq, :include => :node_tags) # create XML. doc = OSM::API.new.get_xml_doc visible_nodes = {} + visible_members = { "Node" => [], "Way" => [], "Relation" => [] } + changeset_cache = {} user_display_name_cache = {} nodes.each do |node| if node.visible? # should be unnecessary if data is consistent. - 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 + visible_members["Node"][node.id] = true end end ways.each do |way| if way.visible? # should be unnecessary if data is consistent. - 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) + visible_members["Way"][way.id] = true end end relations.each do |rel| if rel.visible? # should be unnecessary if data is consistent. - doc.root << rel.to_xml_node(user_display_name_cache) + doc.root << rel.to_xml_node(nil, changeset_cache, user_display_name_cache) + visible_members["Relation"][rel.id] = true end end # finally add self and output - doc.root << relation.to_xml_node(user_display_name_cache) + doc.root << relation.to_xml_node(visible_members, changeset_cache, user_display_name_cache) render :text => doc.to_s, :content_type => "text/xml" else - - render :text => "", :status => :gone + render :nothing => true, :status => :gone end rescue ActiveRecord::RecordNotFound @@ -165,18 +170,20 @@ class RelationController < ApplicationController render :text => doc.to_s, :content_type => "text/xml" else - render :nothing => true, :status => :bad_request + render :text => "You need to supply a comma separated list of ids.", :status => :bad_request end + rescue ActiveRecord::RecordNotFound + render :text => "Could not find one of the relations", :status => :not_found end def relations_for_way - relations_for_object("way") + relations_for_object("Way") end def relations_for_node - relations_for_object("node") + relations_for_object("Node") end def relations_for_relation - relations_for_object("relation") + relations_for_object("Relation") end def relations_for_object(objtype)