app/controllers/relation_controller.rb

   1 class RelationController < ApplicationController
   2   require 'xml/libxml'
   3
   4   session :off
   5   before_filter :authorize, :only => [:create, :update, :delete]
   6   before_filter :check_write_availability, :only => [:create, :update, :delete]
   7   before_filter :check_read_availability, :except => [:create, :update, :delete]
   8   after_filter :compress_output
   9
  10   def create
  11     if request.put?
  12       relation = Relation.from_xml(request.raw_post, true)
  13
  14       if relation
  15         if !relation.preconditions_ok?
  16           render :text => "", :status => :precondition_failed
  17         else
  18           relation.user_id = @user.id
  19           relation.save_with_history!
  20
  21           render :text => relation.id.to_s, :content_type => "text/plain"
  22         end
  23       else
  24         render :nothing => true, :status => :bad_request
  25       end
  26     else
  27       render :nothing => true, :status => :method_not_allowed
  28     end
  29   end
  30
  31   def read
  32     begin
  33       relation = Relation.find(params[:id])
  34
  35       if relation.visible
  36         render :text => relation.to_xml.to_s, :content_type => "text/xml"
  37       else
  38         render :text => "", :status => :gone
  39       end
  40     rescue ActiveRecord::RecordNotFound
  41       render :nothing => true, :status => :not_found
  42     rescue
  43       render :nothing => true, :status => :internal_server_error
  44     end
  45   end
  46
  47   def update
  48     begin
  49       relation = Relation.find(params[:id])
  50
  51       if relation.visible
  52         new_relation = Relation.from_xml(request.raw_post)
  53
  54         if new_relation and new_relation.id == relation.id
  55           if !new_relation.preconditions_ok?
  56             render :text => "", :status => :precondition_failed
  57           else
  58             relation.user_id = @user.id
  59             relation.tags = new_relation.tags
  60             relation.members = new_relation.members
  61             relation.visible = true
  62             relation.save_with_history!
  63
  64             render :nothing => true
  65           end
  66         else
  67           render :nothing => true, :status => :bad_request
  68         end
  69       else
  70         render :text => "", :status => :gone
  71       end
  72     rescue ActiveRecord::RecordNotFound
  73       render :nothing => true, :status => :not_found
  74     rescue
  75       render :nothing => true, :status => :internal_server_error
  76     end
  77   end
  78
  79   def delete
  80 #XXX check if member somewhere!
  81     begin
  82       relation = Relation.find(params[:id])
  83
  84       if relation.visible
  85         if RelationMember.find(:first, :joins => "INNER JOIN current_relations ON current_relations.id=current_relation_members.id", :conditions => [ "visible = 1 AND member_type='relation' and member_id=?", params[:id]])
  86           render :text => "", :status => :precondition_failed
  87         else
  88           relation.user_id = @user.id
  89           relation.tags = []
  90           relation.members = []
  91           relation.visible = false
  92           relation.save_with_history!
  93
  94           render :nothing => true
  95         end
  96       else
  97         render :text => "", :status => :gone
  98       end
  99     rescue ActiveRecord::RecordNotFound
 100       render :nothing => true, :status => :not_found
 101     rescue
 102       render :nothing => true, :status => :internal_server_error
 103     end
 104   end
 105
 106   # -----------------------------------------------------------------
 107   # full
 108   #
 109   # input parameters: id
 110   #
 111   # returns XML representation of one relation object plus all its
 112   # members, plus all nodes part of member ways
 113   # -----------------------------------------------------------------
 114   def full
 115     begin
 116       relation = Relation.find(params[:id])
 117
 118       if relation.visible
 119
 120         # first collect nodes, ways, and relations referenced by this relation.
 121
 122         ways = Way.find_by_sql("select w.* from current_ways w,current_relation_members rm where "+
 123             "rm.member_type='way' and rm.member_id=w.id and rm.id=#{relation.id}");
 124         nodes = Node.find_by_sql("select n.* from current_nodes n,current_relation_members rm where "+
 125             "rm.member_type='node' and rm.member_id=n.id and rm.id=#{relation.id}");
 126         # note query is built to exclude self just in case.
 127         relations = Relation.find_by_sql("select r.* from current_relations r,current_relation_members rm where "+
 128             "rm.member_type='relation' and rm.member_id=r.id and rm.id=#{relation.id} and r.id<>rm.id");
 129
 130         # now additionally collect nodes referenced by ways. Note how we recursively
 131         # evaluate ways but NOT relations.
 132
 133         node_ids = nodes.collect {|node| node.id }
 134         way_node_ids = ways.collect { |way|
 135            way.way_nodes.collect { |way_node| way_node.node_id }
 136         }
 137         way_node_ids.flatten!
 138         way_node_ids.uniq
 139         way_node_ids -= node_ids
 140         nodes += Node.find(way_node_ids)
 141
 142         # create XML.
 143         doc = OSM::API.new.get_xml_doc
 144         visible_nodes = {}
 145         user_display_name_cache = {}
 146
 147         nodes.each do |node|
 148           if node.visible? # should be unnecessary if data is consistent.
 149             doc.root << node.to_xml_node(user_display_name_cache)
 150             visible_nodes[node.id] = node
 151           end
 152         end
 153         ways.each do |way|
 154           if way.visible? # should be unnecessary if data is consistent.
 155             doc.root << way.to_xml_node(visible_nodes, user_display_name_cache)
 156           end
 157         end
 158         relations.each do |rel|
 159           if rel.visible? # should be unnecessary if data is consistent.
 160             doc.root << rel.to_xml_node(user_display_name_cache)
 161           end
 162         end
 163         # finally add self and output
 164         doc.root << relation.to_xml_node(user_display_name_cache)
 165         render :text => doc.to_s, :content_type => "text/xml"
 166
 167       else
 168
 169         render :text => "", :status => :gone
 170       end
 171
 172     rescue ActiveRecord::RecordNotFound
 173       render :nothing => true, :status => :not_found
 174
 175     rescue
 176       render :nothing => true, :status => :internal_server_error
 177     end
 178   end
 179
 180   def relations
 181     ids = params['relations'].split(',').collect { |w| w.to_i }
 182
 183     if ids.length > 0
 184       doc = OSM::API.new.get_xml_doc
 185
 186       Relation.find(ids).each do |relation|
 187         doc.root << relation.to_xml_node
 188       end
 189
 190       render :text => doc.to_s, :content_type => "text/xml"
 191     else
 192       render :nothing => true, :status => :bad_request
 193     end
 194   end
 195
 196   def relations_for_way
 197     relations_for_object("way")
 198   end
 199   def relations_for_node
 200     relations_for_object("node")
 201   end
 202   def relations_for_relation
 203     relations_for_object("relation")
 204   end
 205
 206   def relations_for_object(objtype)
 207     relationids = RelationMember.find(:all, :conditions => ['member_type=? and member_id=?', objtype, params[:id]]).collect { |ws| ws.id }.uniq
 208
 209     if relationids.length > 0
 210       doc = OSM::API.new.get_xml_doc
 211
 212       Relation.find(relationids).each do |relation|
 213         doc.root << relation.to_xml_node
 214       end
 215
 216       render :text => doc.to_s, :content_type => "text/xml"
 217     else
 218       render :nothing => true, :status => :not_found
 219     end
 220   end
 221 end