app/controllers/relation_controller.rb

   1 class RelationController < ApplicationController
   2   require 'xml/libxml'
   3
   4   skip_before_filter :verify_authenticity_token
   5   before_filter :authorize, :only => [:create, :update, :delete]
   6   before_filter :require_allow_write_api, :only => [:create, :update, :delete]
   7   before_filter :require_public_data, :only => [:create, :update, :delete]
   8   before_filter :check_api_writable, :only => [:create, :update, :delete]
   9   before_filter :check_api_readable, :except => [:create, :update, :delete]
  10   after_filter :compress_output
  11   around_filter :api_call_handle_error, :api_call_timeout
  12
  13   def create
  14     assert_method :put
  15
  16     relation = Relation.from_xml(request.raw_post, true)
  17
  18     # We assume that an exception has been thrown if there was an error
  19     # generating the relation
  20     #if relation
  21     relation.create_with_history @user
  22     render :text => relation.id.to_s, :content_type => "text/plain"
  23     #else
  24     # render :text => "Couldn't get turn the input into a relation.", :status => :bad_request
  25     #end
  26   end
  27
  28   def read
  29     relation = Relation.find(params[:id])
  30     response.last_modified = relation.timestamp
  31     if relation.visible
  32       render :text => relation.to_xml.to_s, :content_type => "text/xml"
  33     else
  34       render :text => "", :status => :gone
  35     end
  36   end
  37
  38   def update
  39     logger.debug request.raw_post
  40
  41     relation = Relation.find(params[:id])
  42     new_relation = Relation.from_xml(request.raw_post)
  43
  44     if new_relation and new_relation.id == relation.id
  45       relation.update_from new_relation, @user
  46       render :text => relation.version.to_s, :content_type => "text/plain"
  47     else
  48       render :text => "", :status => :bad_request
  49     end
  50   end
  51
  52   def delete
  53     relation = Relation.find(params[:id])
  54     new_relation = Relation.from_xml(request.raw_post)
  55     if new_relation and new_relation.id == relation.id
  56       relation.delete_with_history!(new_relation, @user)
  57       render :text => relation.version.to_s, :content_type => "text/plain"
  58     else
  59       render :text => "", :status => :bad_request
  60     end
  61   end
  62
  63   # -----------------------------------------------------------------
  64   # full
  65   #
  66   # input parameters: id
  67   #
  68   # returns XML representation of one relation object plus all its
  69   # members, plus all nodes part of member ways
  70   # -----------------------------------------------------------------
  71   def full
  72     relation = Relation.find(params[:id])
  73
  74     if relation.visible
  75
  76       # first find the ids of nodes, ways and relations referenced by this
  77       # relation - note that we exclude this relation just in case.
  78
  79       node_ids = relation.members.select { |m| m[0] == 'Node' }.map { |m| m[1] }
  80       way_ids = relation.members.select { |m| m[0] == 'Way' }.map { |m| m[1] }
  81       relation_ids = relation.members.select { |m| m[0] == 'Relation' and m[1] != relation.id }.map { |m| m[1] }
  82
  83       # next load the relations and the ways.
  84
  85       relations = Relation.where(:id => relation_ids).includes(:relation_tags)
  86       ways = Way.where(:id => way_ids).includes(:way_nodes, :way_tags)
  87
  88       # now additionally collect nodes referenced by ways. Note how we
  89       # recursively evaluate ways but NOT relations.
  90
  91       way_node_ids = ways.collect { |way|
  92         way.way_nodes.collect { |way_node| way_node.node_id }
  93       }
  94       node_ids += way_node_ids.flatten
  95       nodes = Node.where(:id => node_ids.uniq).includes(:node_tags)
  96
  97       # create XML.
  98       doc = OSM::API.new.get_xml_doc
  99       visible_nodes = {}
 100       visible_members = { "Node" => {}, "Way" => {}, "Relation" => {} }
 101       changeset_cache = {}
 102       user_display_name_cache = {}
 103
 104       nodes.each do |node|
 105         if node.visible? # should be unnecessary if data is consistent.
 106           doc.root << node.to_xml_node(changeset_cache, user_display_name_cache)
 107           visible_nodes[node.id] = node
 108           visible_members["Node"][node.id] = true
 109         end
 110       end
 111       ways.each do |way|
 112         if way.visible? # should be unnecessary if data is consistent.
 113           doc.root << way.to_xml_node(visible_nodes, changeset_cache, user_display_name_cache)
 114           visible_members["Way"][way.id] = true
 115         end
 116       end
 117       relations.each do |rel|
 118         if rel.visible? # should be unnecessary if data is consistent.
 119           doc.root << rel.to_xml_node(nil, changeset_cache, user_display_name_cache)
 120           visible_members["Relation"][rel.id] = true
 121         end
 122       end
 123       # finally add self and output
 124       doc.root << relation.to_xml_node(visible_members, changeset_cache, user_display_name_cache)
 125       render :text => doc.to_s, :content_type => "text/xml"
 126
 127     else
 128       render :text => "", :status => :gone
 129     end
 130   end
 131
 132   def relations
 133     if not params['relations']
 134       raise OSM::APIBadUserInput.new("The parameter relations is required, and must be of the form relations=id[,id[,id...]]")
 135     end
 136
 137     ids = params['relations'].split(',').collect { |w| w.to_i }
 138
 139     if ids.length == 0
 140       raise OSM::APIBadUserInput.new("No relations were given to search for")
 141     end
 142
 143     doc = OSM::API.new.get_xml_doc
 144
 145     Relation.find(ids).each do |relation|
 146       doc.root << relation.to_xml_node
 147     end
 148
 149     render :text => doc.to_s, :content_type => "text/xml"
 150   end
 151
 152   def relations_for_way
 153     relations_for_object("Way")
 154   end
 155
 156   def relations_for_node
 157     relations_for_object("Node")
 158   end
 159
 160   def relations_for_relation
 161     relations_for_object("Relation")
 162   end
 163
 164   def relations_for_object(objtype)
 165     relationids = RelationMember.where(:member_type => objtype, :member_id => params[:id]).collect { |ws| ws.relation_id }.uniq
 166
 167     doc = OSM::API.new.get_xml_doc
 168
 169     Relation.find(relationids).each do |relation|
 170       doc.root << relation.to_xml_node if relation.visible
 171     end
 172
 173     render :text => doc.to_s, :content_type => "text/xml"
 174   end
 175 end