app/controllers/api/relations_controller.rb

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