X-Git-Url: https://git.openstreetmap.org/rails.git/blobdiff_plain/d6e047d7d45ea76d56dccb53cc1fe1f5b54734d5..436470b0576574971ea13b9754142047a6d109df:/app/controllers/amf_controller.rb diff --git a/app/controllers/amf_controller.rb b/app/controllers/amf_controller.rb index ce3dc91d5..f90a62a9a 100644 --- a/app/controllers/amf_controller.rb +++ b/app/controllers/amf_controller.rb @@ -10,10 +10,10 @@ # # == General structure # -# Apart from the talk method (which distributes the requests from the -# AMF message), each method generally takes arguments in the order they were -# sent by the Potlatch SWF. Do not assume typing has been preserved. Methods -# all return an array to the SWF. +# Apart from the amf_read and amf_write methods (which distribute the requests +# from the AMF message), each method generally takes arguments in the order +# they were sent by the Potlatch SWF. Do not assume typing has been preserved. +# Methods all return an array to the SWF. # # == Debugging # @@ -22,30 +22,27 @@ # return(-2,"message") <-- also asks the user to e-mail me # # To write to the Rails log, use RAILS_DEFAULT_LOGGER.info("message"). -# -# == To do -# -# - Check authentication -# - Check the right things are being written to the database! class AmfController < ApplicationController require 'stringio' include Potlatch + # Help methods for checking boundary sanity and area size + include MapBoundary + session :off before_filter :check_write_availability - # Main AMF handler: processes the raw AMF string (using AMF library) and + # Main AMF handlers: process the raw AMF string (using AMF library) and # calls each action (private method) accordingly. + # ** FIXME: refactor to reduce duplication of code across read/write - def talk - req=StringIO.new(request.raw_post+0.chr) # Get POST data as request - # (cf http://www.ruby-forum.com/topic/122163) - req.read(2) # Skip version indicator and client ID - results={} # Results of each body - renumberednodes={} # Shared across repeated putways - renumberedways={} # Shared across repeated putways + def amf_read + req=StringIO.new(request.raw_post+0.chr)# Get POST data as request + # (cf http://www.ruby-forum.com/topic/122163) + req.read(2) # Skip version indicator and client ID + results={} # Results of each body # Parse request @@ -64,6 +61,7 @@ class AmfController < ApplicationController index=AMF.getstring(req) # | get index in response sequence bytes=AMF.getlong(req) # | get total size in bytes args=AMF.getvalue(req) # | get response (probably an array) + logger.info "Executing AMF #{message}:#{index}" case message when 'getpresets'; results[index]=AMF.putdata(index,getpresets()) @@ -73,6 +71,38 @@ class AmfController < ApplicationController when 'getrelation'; results[index]=AMF.putdata(index,getrelation(args[0].to_i)) when 'getway_old'; results[index]=AMF.putdata(index,getway_old(args[0].to_i,args[1].to_i)) when 'getway_history'; results[index]=AMF.putdata(index,getway_history(args[0].to_i)) + when 'getnode_history'; results[index]=AMF.putdata(index,getnode_history(args[0].to_i)) + when 'findrelations'; results[index]=AMF.putdata(index,findrelations(*args)) + when 'getpoi'; results[index]=AMF.putdata(index,getpoi(*args)) + end + end + logger.info("encoding AMF results") + sendresponse(results) + end + + def amf_write + req=StringIO.new(request.raw_post+0.chr) + req.read(2) + results={} + renumberednodes={} # Shared across repeated putways + renumberedways={} # Shared across repeated putways + + headers=AMF.getint(req) # Read number of headers + headers.times do # Read each header + name=AMF.getstring(req) # | + req.getc # | skip boolean + value=AMF.getvalue(req) # | + header["name"]=value # | + end + + bodies=AMF.getint(req) # Read number of bodies + bodies.times do # Read each body + message=AMF.getstring(req) # | get message name + index=AMF.getstring(req) # | get index in response sequence + bytes=AMF.getlong(req) # | get total size in bytes + args=AMF.getvalue(req) # | get response (probably an array) + + case message when 'putway'; r=putway(renumberednodes,*args) renumberednodes=r[3] if r[1] != r[2] @@ -82,19 +112,9 @@ class AmfController < ApplicationController when 'putrelation'; results[index]=AMF.putdata(index,putrelation(renumberednodes, renumberedways, *args)) when 'deleteway'; results[index]=AMF.putdata(index,deleteway(args[0],args[1].to_i)) when 'putpoi'; results[index]=AMF.putdata(index,putpoi(*args)) - when 'getpoi'; results[index]=AMF.putdata(index,getpoi(args[0].to_i)) end end - - # Write out response - - a,b=results.length.divmod(256) - render :content_type => "application/x-amf", :text => proc { |response, output| - output.write 0.chr+0.chr+0.chr+0.chr+a.chr+b.chr - results.each do |k,v| - output.write(v) - end - } + sendresponse(results) end private @@ -113,6 +133,15 @@ class AmfController < ApplicationController def whichways(xmin, ymin, xmax, ymax) #:doc: xmin -= 0.01; ymin -= 0.01 xmax += 0.01; ymax += 0.01 + + # check boundary is sane and area within defined + # see /config/application.yml + begin + check_boundaries(xmin, ymin, xmax, ymax) + rescue Exception => err + # FIXME: report an error rather than just return an empty result + return [[],[],[]] + end if POTLATCH_USE_SQL then way_ids = sql_find_way_ids_in_area(xmin, ymin, xmax, ymax) @@ -120,7 +149,7 @@ class AmfController < ApplicationController relation_ids = sql_find_relations_in_area_and_ways(xmin, ymin, xmax, ymax, way_ids) else # find the way ids in an area - nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => "current_nodes.visible = 1", :include => :ways) + nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => ["current_nodes.visible = ?", true], :include => :ways) way_ids = nodes_in_area.collect { |node| node.way_ids }.flatten.uniq # find the node ids in an area that aren't part of ways @@ -128,8 +157,8 @@ class AmfController < ApplicationController points = nodes_not_used_in_area.collect { |n| [n.id, n.lon, n.lat, n.tags_as_hash] } # find the relations used by those nodes and ways - relations = Relation.find_for_nodes(nodes_in_area.collect { |n| n.id }, :conditions => "visible = 1") + - Relation.find_for_ways(way_ids, :conditions => "visible = 1") + relations = Relation.find_for_nodes(nodes_in_area.collect { |n| n.id }, :conditions => {:visible => true}) + + Relation.find_for_ways(way_ids, :conditions => {:visible => true}) relation_ids = relations.collect { |relation| relation.id }.uniq end @@ -143,7 +172,16 @@ class AmfController < ApplicationController xmin -= 0.01; ymin -= 0.01 xmax += 0.01; ymax += 0.01 - nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => "current_nodes.visible = 0 AND current_ways.visible = 0", :include => :ways_via_history) + # check boundary is sane and area within defined + # see /config/application.yml + begin + check_boundaries(xmin, ymin, xmax, ymax) + rescue Exception => err + # FIXME: report an error rather than just return an empty result + return [[]] + end + + nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => ["current_ways.visible = ?", false], :include => :ways_via_history) way_ids = nodes_in_area.collect { |node| node.ways_via_history_ids }.flatten.uniq [way_ids] @@ -160,9 +198,19 @@ class AmfController < ApplicationController # Ideally we would do ":include => :nodes" here but if we do that # then rails only seems to return the first copy of a node when a # way includes a node more than once - way = Way.find(wayid) + begin + way = Way.find(wayid) + rescue ActiveRecord::RecordNotFound + return [wayid,[],{}] + end + + # check case where way has been deleted or doesn't exist + return [wayid,[],{}] if way.nil? or !way.visible + points = way.nodes.collect do |node| - [node.lon, node.lat, node.id, nil, node.tags_as_hash] + nodetags=node.tags_as_hash + nodetags.delete('created_by') + [node.lon, node.lat, node.id, nodetags] end tags = way.tags end @@ -172,34 +220,52 @@ class AmfController < ApplicationController # Get an old version of a way, and all constituent nodes. # - # For undelete (version=0), always uses the most recent version of each node, - # even if it's moved. For revert (version=1+), uses the node in existence + # For undelete (version<0), always uses the most recent version of each node, + # even if it's moved. For revert (version >= 0), uses the node in existence # at the time, generating a new id if it's still visible and has been moved/ # retagged. def getway_old(id, version) #:doc: if version < 0 - old_way = OldWay.find(:first, :conditions => ['visible = 1 AND id = ?', id], :order => 'version DESC') - points = old_way.get_nodes_undelete + old_way = OldWay.find(:first, :conditions => ['visible = ? AND id = ?', true, id], :order => 'version DESC') + points = old_way.get_nodes_undelete unless old_way.nil? else old_way = OldWay.find(:first, :conditions => ['id = ? AND version = ?', id, version]) - points = old_way.get_nodes_revert + points = old_way.get_nodes_revert unless old_way.nil? end - old_way.tags['history'] = "Retrieved from v#{old_way.version}" - - [0, id, points, old_way.tags, old_way.version] + if old_way.nil? + return [0, id, [], {}, -1] + else + old_way.tags['history'] = "Retrieved from v#{old_way.version}" + return [0, id, points, old_way.tags, old_way.version] + end end - # Find history of a way. Returns an array of previous versions. + # Find history of a way. Returns 'way', id, and + # an array of previous versions. def getway_history(wayid) #:doc: - history = Way.find(wayid).old_ways.collect do |old_way| + history = Way.find(wayid).old_ways.reverse.collect do |old_way| user = old_way.user.data_public? ? old_way.user.display_name : 'anonymous' - [old_way.version, old_way.timestamp.strftime("%d %b %Y, %H:%M"), old_way.visible ? 1 : 0, user] + uid = old_way.user.data_public? ? old_way.user.id : 0 + [old_way.version, old_way.timestamp.strftime("%d %b %Y, %H:%M"), old_way.visible ? 1 : 0, user, uid] + end + + ['way',wayid,history] + end + + # Find history of a node. Returns 'node', id, and + # an array of previous versions. + + def getnode_history(nodeid) #:doc: + history = Node.find(nodeid).old_nodes.reverse.collect do |old_node| + user = old_node.user.data_public? ? old_node.user.display_name : 'anonymous' + uid = old_node.user.data_public? ? old_node.user.id : 0 + [old_node.timestamp.to_i, old_node.timestamp.strftime("%d %b %Y, %H:%M"), old_node.visible ? 1 : 0, user, uid] end - [history] + ['node',nodeid,history] end # Get a relation with all tags and members. @@ -209,11 +275,37 @@ class AmfController < ApplicationController # 2. list of members. def getrelation(relid) #:doc: - rel = Relation.find(relid) + begin + rel = Relation.find(relid) + rescue ActiveRecord::RecordNotFound + return [relid, {}, []] + end + + return [relid, {}, []] if rel.nil? or !rel.visible [relid, rel.tags, rel.members] end + # Find relations with specified name/id. + # Returns array of relations, each in same form as getrelation. + + def findrelations(searchterm) + rels = [] + if searchterm.to_i>0 then + rel = Relation.find(searchterm.to_i) + if rel and rel.visible then + rels.push([rel.id, rel.tags, rel.members]) + end + else + RelationTag.find(:all, :limit => 11, :conditions => ["match(v) against (?)", searchterm] ).each do |t| + if t.relation.visible then + rels.push([t.relation.id, t.relation.tags, t.relation.members]) + end + end + end + rels + end + # Save a relation. # Returns # 0. 0 (success), @@ -225,7 +317,7 @@ class AmfController < ApplicationController if !uid then return -1,"You are not logged in, so the relation could not be saved." end relid = relid.to_i - visible = visible.to_i + visible = (visible.to_i != 0) # create a new relation, or find the existing one if relid <= 0 @@ -241,11 +333,10 @@ class AmfController < ApplicationController if mid < 0 mid = renumberednodes[mid] if m[0] == 'node' mid = renumberedways[mid] if m[0] == 'way' - if mid < 0 - return -2, "Negative ID unresolved" - end end - typedmembers << [m[0], mid, m[2]] + if mid + typedmembers << [m[0], mid, m[2]] + end end # assign new contents @@ -320,8 +411,10 @@ class AmfController < ApplicationController savenode = true else node = Node.find(id) + nodetags=node.tags_as_hash + nodetags.delete('created_by') if !fpcomp(lat, node.lat) or !fpcomp(lon, node.lon) or - Tags.join(n[4]) != node.tags or !node.visible? + n[4] != nodetags or !node.visible? savenode = true end end @@ -406,8 +499,12 @@ class AmfController < ApplicationController # # Returns array of id, long, lat, hash of tags. - def getpoi(id) #:doc: - n = Node.find(id) + def getpoi(id,timestamp) #:doc: + if timestamp>0 then + n = OldNode.find(id, :conditions=>['UNIX_TIMESTAMP(timestamp)=?',timestamp]) + else + n = Node.find(id) + end if n return [n.id, n.lon, n.lat, n.tags_as_hash] @@ -430,6 +527,7 @@ class AmfController < ApplicationController way.unshared_node_ids.each do |n| deleteitemrelations(n, 'node') end + deleteitemrelations(way_id, 'way') way.delete_with_relations_and_nodes_and_history(user) @@ -483,6 +581,18 @@ class AmfController < ApplicationController return ((a/0.0000001).round==(b/0.0000001).round) end + # Send AMF response + + def sendresponse(results) + a,b=results.length.divmod(256) + render :content_type => "application/x-amf", :text => proc { |response, output| + output.write 0.chr+0.chr+0.chr+0.chr+a.chr+b.chr + results.each do |k,v| + output.write(v) + end + } + end + # ==================================================================== # Alternative SQL queries for getway/whichways @@ -493,8 +603,8 @@ class AmfController < ApplicationController FROM current_way_nodes INNER JOIN current_nodes ON current_nodes.id=current_way_nodes.node_id INNER JOIN current_ways ON current_ways.id =current_way_nodes.id - WHERE current_nodes.visible=1 - AND current_ways.visible=1 + WHERE current_nodes.visible=TRUE + AND current_ways.visible=TRUE AND #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")} EOF return ActiveRecord::Base.connection.select_all(sql).collect { |a| a['wayid'].to_i } @@ -505,7 +615,7 @@ class AmfController < ApplicationController SELECT current_nodes.id,current_nodes.latitude*0.0000001 AS lat,current_nodes.longitude*0.0000001 AS lon,current_nodes.tags FROM current_nodes LEFT OUTER JOIN current_way_nodes cwn ON cwn.node_id=current_nodes.id - WHERE current_nodes.visible=1 + WHERE current_nodes.visible=TRUE AND cwn.id IS NULL AND #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")} EOF @@ -542,11 +652,13 @@ class AmfController < ApplicationController FROM current_way_nodes,current_nodes WHERE current_way_nodes.id=#{wayid.to_i} AND current_way_nodes.node_id=current_nodes.id - AND current_nodes.visible=1 + AND current_nodes.visible=TRUE ORDER BY sequence_id EOF ActiveRecord::Base.connection.select_all(sql).each do |row| - points << [row['lon'].to_f,row['lat'].to_f,row['id'].to_i,nil,tagstring_to_hash(row['tags'])] + nodetags=tagstring_to_hash(row['tags']) + nodetags.delete('created_by') + points << [row['lon'].to_f,row['lat'].to_f,row['id'].to_i,nodetags] end points end