X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/db33aa6ff66a85207c8706c1a18f91ae9111c2b0..d13ef1db021391e677a2c3d75f3b0999064ffb3a:/app/controllers/amf_controller.rb?ds=sidebyside diff --git a/app/controllers/amf_controller.rb b/app/controllers/amf_controller.rb index 9def5104e..4afba1484 100644 --- a/app/controllers/amf_controller.rb +++ b/app/controllers/amf_controller.rb @@ -1,8 +1,10 @@ -# AMF Controller is a semi-standalone API for Flash clients, particularly Potlatch +# AMF Controller is a semi-standalone API for Flash clients, particularly Potlatch. # All interaction between Potlatch (as a .SWF application) and the # OSM database takes place using this controller. Messages are # encoded in the Actionscript Message Format (AMF). # +# See Also Potlatch::Potlatch and Potlatch::AMF +# # Public domain. # editions Systeme D / Richard Fairhurst 2004-2008 # @@ -13,10 +15,11 @@ # return(-2,"message") <-- also asks the user to e-mail me # to log: # RAILS_DEFAULT_LOGGER.error("Args: #{args[0]}, #{args[1]}, #{args[2]}, #{args[3]}") - class AmfController < ApplicationController require 'stringio' + include Potlatch + session :off before_filter :check_write_availability @@ -27,39 +30,45 @@ class AmfController < ApplicationController req.read(2) # Skip version indicator and client ID results={} # Results of each body renumberednodes={} # Shared across repeated putways + renumberedways={} # Shared across repeated putways # ------------- # Parse request - headers=getint(req) # Read number of headers + headers=AMF.getint(req) # Read number of headers headers.times do # Read each header - name=getstring(req) # | + name=AMF.getstring(req) # | req.getc # | skip boolean - value=getvalue(req) # | + value=AMF.getvalue(req) # | header["name"]=value # | end - bodies=getint(req) # Read number of bodies + bodies=AMF.getint(req) # Read number of bodies bodies.times do # Read each body - message=getstring(req) # | get message name - index=getstring(req) # | get index in response sequence - bytes=getlong(req) # | get total size in bytes - args=getvalue(req) # | get response (probably an array) + 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 'getpresets'; results[index]=putdata(index,getpresets) - when 'whichways'; results[index]=putdata(index,whichways(args)) - when 'whichways_deleted'; results[index]=putdata(index,whichways_deleted(args)) - when 'getway'; results[index]=putdata(index,getway(args)) - when 'getway_old'; results[index]=putdata(index,getway_old(args)) - when 'getway_history'; results[index]=putdata(index,getway_history(args)) + when 'getpresets'; results[index]=AMF.putdata(index,getpresets) + when 'whichways'; results[index]=AMF.putdata(index,whichways(args)) + when 'whichways_deleted'; results[index]=AMF.putdata(index,whichways_deleted(args)) + when 'getway'; results[index]=AMF.putdata(index,getway(args)) + when 'getrelation'; results[index]=AMF.putdata(index,getrelation(args)) + when 'getway_old'; results[index]=AMF.putdata(index,getway_old(args)) + when 'getway_history'; results[index]=AMF.putdata(index,getway_history(args)) when 'putway'; r=putway(args,renumberednodes) - renumberednodes=r[3] - results[index]=putdata(index,r) - when 'deleteway'; results[index]=putdata(index,deleteway(args)) - when 'putpoi'; results[index]=putdata(index,putpoi(args)) - when 'getpoi'; results[index]=putdata(index,getpoi(args)) + renumberednodes=r[3] + if r[1] != r[2] + renumberedways[r[1]] = r[2] + end + results[index]=AMF.putdata(index,r) + when 'putrelation'; results[index]=AMF.putdata(index,putrelation(args, renumberednodes, renumberedways)) + when 'deleteway'; results[index]=AMF.putdata(index,deleteway(args)) + when 'putpoi'; results[index]=AMF.putdata(index,putpoi(args)) + when 'getpoi'; results[index]=AMF.putdata(index,getpoi(args)) end end @@ -75,20 +84,16 @@ class AmfController < ApplicationController end } RAILS_DEFAULT_LOGGER.info(" Response: end") - end private - # Return presets (default tags and crap) to potlatch - # Global is set up in config/environment.rb on startup, code is in lib/osm.rb - def getpresets + # Return presets (default tags and crap) to potlatch. + # Uses POTLATCH_PRESETS global, set up in OSM::Potlatch + def getpresets #:doc: return POTLATCH_PRESETS end - # ==================================================================== - # Remote calls - # ----- whichways # Find all the way ids and nodes (including tags and projected lat/lng) which aren't part of those ways in an are # @@ -98,7 +103,7 @@ class AmfController < ApplicationController # 2. maximum longitude # 3. maximum latitude # 4. baselong, 5. basey, 6. masterscale as above - def whichways(args) + def whichways(args) #:doc: xmin = args[0].to_f-0.01 ymin = args[1].to_f-0.01 xmax = args[2].to_f+0.01 @@ -110,18 +115,17 @@ class AmfController < ApplicationController RAILS_DEFAULT_LOGGER.info(" Message: whichways, bbox=#{xmin},#{ymin},#{xmax},#{ymax}") # find the way ids in an area - nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax,:conditions => "visible = 1", :include => :way_nodes) - waynodes_in_area = nodes_in_area.collect {|node| node.way_nodes }.flatten - ways = waynodes_in_area.collect {|way_node| way_node.id[0]}.uniq + nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => "current_nodes.visible = 1", :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 - node_ids_in_area = nodes_in_area.collect {|node| node.id}.uniq - node_ids_used_in_ways = waynodes_in_area.collect {|way_node| way_node.node_id}.uniq - node_ids_not_used_in_area = node_ids_in_area - node_ids_used_in_ways - nodes_not_used_in_area = Node.find(node_ids_not_used_in_area) - points = nodes_not_used_in_area.collect {|n| [n.id, n.lon_potlatch(baselong,masterscale), n.lat_potlatch(basey,masterscale), n.tags_as_hash] } + nodes_not_used_in_area = nodes_in_area.select { |node| node.ways.empty? } + points = nodes_not_used_in_area.collect { |n| [n.id, n.lon_potlatch(baselong,masterscale), n.lat_potlatch(basey,masterscale), n.tags_as_hash] } + + # find the relations used by those nodes and ways + relation_ids = (Relation.find_for_nodes_and_ways(nodes_in_area.collect {|n| n.id}, way_ids)).collect {|n| n.id}.uniq - [ways,points] + [way_ids,points,relation_ids] end # ----- whichways_deleted @@ -129,7 +133,7 @@ class AmfController < ApplicationController # in: as whichways # does: finds all deleted ways with a deleted node in bounding box # out: [0] array of way ids - def whichways_deleted(args) + def whichways_deleted(args) #:doc: xmin = args[0].to_f-0.01 ymin = args[1].to_f-0.01 xmax = args[2].to_f+0.01 @@ -166,20 +170,22 @@ class AmfController < ApplicationController # # FIXME: The server really shouldn't be figuring out a ways bounding box and doing projection for potlatch # FIXME: the argument splitting should be done in the 'talk' method, not here - - def getway(args) + def getway(args) #:doc: wayid,baselong,basey,masterscale = args wayid = wayid.to_i RAILS_DEFAULT_LOGGER.info(" Message: getway, id=#{wayid}") - way = Way.find_eager(wayid) + # 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) + long_array = [] lat_array = [] points = [] - way.way_nodes.each do |way_node| - node = way_node.node # get the node record + way.nodes.each do |node| projected_longitude = node.lon_potlatch(baselong,masterscale) # do projection for potlatch projected_latitude = node.lat_potlatch(basey,masterscale) id = node.id @@ -207,7 +213,7 @@ class AmfController < ApplicationController # [2] array of points (as getway _except_ [3] is node.visible?, 0 or 1), # [4] xmin, [5] xmax, [6] ymin, [7] ymax (unprojected bbox), # [8] way version - def getway_old(args) + def getway_old(args) #:doc: RAILS_DEFAULT_LOGGER.info(" Message: getway_old (server is #{SERVER_URL})") # if SERVER_URL=="www.openstreetmap.org" then return -1,"Revert is not currently enabled on the OpenStreetMap server." end @@ -248,7 +254,7 @@ class AmfController < ApplicationController # [0] version, [1] db timestamp (string), # [2] visible 0 or 1, # [3] username or 'anonymous' (string)) - def getway_history(args) + def getway_history(args) #:doc: wayid=args[0] history=[] sql=<<-EOF @@ -267,6 +273,80 @@ class AmfController < ApplicationController [history] end + # ----- getrelation + # Get a relation with all of it's tags, and member IDs + # The input is an array with the following components, in order: + # 0. relid - the ID of the relation to get + # + # The output is an array which contains: + # [0] relation id, [1] hash of tags, [2] list of members + def getrelation(args) #:doc: + relid = args[0] + relid = relid.to_i + + RAILS_DEFAULT_LOGGER.info(" Message: getrel, id=#{relid}") + + rel = Relation.find(relid) + + [relid,rel.tags,rel.members]#nodes,ways] + end + + # ----- getrelation + # save relation to the database + # in: [0] user token (string), + # [1] original relation id (may be negative), + # [2] hash of tags, [3] list of members, + # [4] visible + # out: [0] 0 (success), [1] original relation id (unchanged), + # [2] new relation id + def putrelation(args, renumberednodes, renumberedways) #:doc: + usertoken,relid,tags,members,visible=args + uid=getuserid(usertoken) + if !uid then return -1,"You are not logged in, so the point could not be saved." end + + relid = relid.to_i + visible = visible.to_i + + # create a new relation, or find the existing one + if relid <= 0 + rel = Relation.new + else + rel = Relation.find(relid) + end + + # check the members are all positive, and correctly type + typedmembers = [] + members.each do |m| + mid = m[1].to_i + 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]] + end + + # assign new contents + rel.members = typedmembers + rel.tags = tags + rel.visible = visible + rel.user_id = uid + + # check it then save it + # BUG: the following is commented out because it always fails on my + # install. I think it's a Rails bug. + + #if !rel.preconditions_ok? + # return -2, "Relation preconditions failed" + #else + rel.save_with_history! + #end + + [0,relid,rel.id] + end + # ----- putway # saves a way to the database # in: [0] user token (string), @@ -281,7 +361,7 @@ class AmfController < ApplicationController # out: [0] 0 (code for success), [1] original way id (unchanged), # [2] new way id, [3] hash of renumbered nodes (old id=>new id), # [4] xmin, [5] xmax, [6] ymin, [7] ymax (unprojected bbox) - def putway(args,renumberednodes) + def putway(args,renumberednodes) #:doc: RAILS_DEFAULT_LOGGER.info(" putway started") usertoken,originalway,points,attributes,oldversion,baselong,basey,masterscale=args uid=getuserid(usertoken) @@ -296,11 +376,13 @@ class AmfController < ApplicationController RAILS_DEFAULT_LOGGER.info(" Message: putway, id=#{originalway}") - # -- Temporary check for null IDs + # -- Check for null IDs or short ways points.each do |a| if a[2]==0 or a[2].nil? then return -2,"Server error - node with id 0 found in way #{originalway}." end end + + if points.length<2 then return -2,"Server error - way is only #{points.length} points long." end # -- 3. read original way into memory @@ -441,7 +523,7 @@ class AmfController < ApplicationController # refuses save if the node has since become part of a way # out: [0] 0 (success), [1] original node id (unchanged), # [2] new node id - def putpoi(args) + def putpoi(args) #:doc: usertoken,id,x,y,tags,visible,baselong,basey,masterscale=args uid=getuserid(usertoken) if !uid then return -1,"You are not logged in, so the point could not be saved." end @@ -477,87 +559,59 @@ class AmfController < ApplicationController end # ----- getpoi - # read POI from database + # read POI from database # (only called on revert: POIs are usually read by whichways) - # in: [0] node id, [1] baselong, [2] basey, [3] masterscale # does: reads POI # out: [0] id (unchanged), [1] projected long, [2] projected lat, # [3] hash of tags - - def getpoi(args) - id,baselong,basey,masterscale=args; id=id.to_i - poi=ActiveRecord::Base.connection.select_one("SELECT latitude*0.0000001 AS lat,longitude*0.0000001 AS lng,tags "+ - "FROM current_nodes WHERE visible=1 AND id=#{id}") - if poi.nil? then return [nil,nil,nil,''] end - [id, - long2coord(poi['lng'].to_f,baselong,masterscale), - lat2coord(poi['lat'].to_f,basey,masterscale), - tag2array(poi['tags'])] + def getpoi(args) #:doc: + id,baselong,basey,masterscale = args + + n = Node.find(id.to_i) + if n + return [n.id, n.lon_potlatch(baselong,masterscale), n.lat_potlatch(basey,masterscale), n.tags_as_hash] + else + return [nil,nil,nil,''] + end end # ----- deleteway # delete way and constituent nodes from database - # in: [0] user token (string), [1] way id # does: deletes way from db and any constituent nodes not used elsewhere # also removes ways/nodes from any relations they're in # out: [0] 0 (success), [1] way id (unchanged) - def deleteway(args) - usertoken,way=args - - RAILS_DEFAULT_LOGGER.info(" Message: deleteway, id=#{way}") + def deleteway(args) #:doc: + usertoken,way_id=args + RAILS_DEFAULT_LOGGER.info(" Message: deleteway, id=#{way_id}") uid=getuserid(usertoken) if !uid then return -1,"You are not logged in, so the way could not be deleted." end - way=way.to_i - db_uqn='unin'+(rand*100).to_i.to_s+uid.to_s+way.to_i.abs.to_s+Time.new.to_i.to_s # temp uniquenodes table name, typically 51 chars - db_now='@now'+(rand*100).to_i.to_s+uid.to_s+way.to_i.abs.to_s+Time.new.to_i.to_s # 'now' variable name, typically 51 chars + # FIXME + # the next bit removes the way from any relations + # the delete_with_relations_and_nodes_and_history method should do this, + # but at present it just throws a 'precondition failed' + way=way.to_i + db_now='@now'+(rand*100).to_i.to_s+uid.to_s+id.to_i.abs.to_s+Time.new.to_i.to_s + db_uqn='unin'+(rand*100).to_i.to_s+uid.to_s+way.to_i.abs.to_s+Time.new.to_i.to_s ActiveRecord::Base.connection.execute("SET #{db_now}=NOW()") - - # - delete any otherwise unused nodes - - createuniquenodes(way,db_uqn,[]) - - # unless (preserve.empty?) then - # ActiveRecord::Base.connection.execute("DELETE FROM #{db_uqn} WHERE node_id IN ("+preserve.join(',')+")") - # end - - sql=<<-EOF - INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tile) - SELECT DISTINCT cn.id,cn.latitude,cn.longitude,#{db_now},#{uid},0,cn.tile - FROM current_nodes AS cn,#{db_uqn} - WHERE cn.id=node_id - EOF - ActiveRecord::Base.connection.insert(sql) - - sql=<<-EOF - UPDATE current_nodes AS cn, #{db_uqn} - SET cn.timestamp=#{db_now},cn.visible=0,cn.user_id=#{uid} - WHERE cn.id=node_id - EOF - ActiveRecord::Base.connection.update(sql) - - deleteuniquenoderelations(db_uqn,uid,db_now) + createuniquenodes(way,db_uqn,[]) + deleteuniquenoderelations(db_uqn,uid,db_now) + deleteitemrelations(way_id,'way',uid,db_now) ActiveRecord::Base.connection.execute("DROP TEMPORARY TABLE #{db_uqn}") + # end of FIXME - # - delete way - - ActiveRecord::Base.connection.insert("INSERT INTO ways (id,user_id,timestamp,visible) VALUES (#{way},#{uid},#{db_now},0)") - ActiveRecord::Base.connection.update("UPDATE current_ways SET user_id=#{uid},timestamp=#{db_now},visible=0 WHERE id=#{way}") - ActiveRecord::Base.connection.execute("DELETE FROM current_way_nodes WHERE id=#{way}") - ActiveRecord::Base.connection.execute("DELETE FROM current_way_tags WHERE id=#{way}") - deleteitemrelations(way,'way',uid,db_now) - [0,way] + # now delete the way + user = User.find(uid) + way = Way.find(way_id) + way.delete_with_relations_and_nodes_and_history(user) + return [0,way_id] end - - # ==================================================================== - # Support functions for remote calls - - def readwayquery(id,insistonvisible) + def readwayquery(id,insistonvisible) #:doc: sql=<<-EOF SELECT latitude*0.0000001 AS latitude,longitude*0.0000001 AS longitude,current_nodes.id,tags,visible FROM current_way_nodes,current_nodes @@ -569,12 +623,13 @@ class AmfController < ApplicationController ActiveRecord::Base.connection.select_all(sql) end - def getlastversion(id,version) - row=ActiveRecord::Base.connection.select_one("SELECT version FROM ways WHERE id=#{id} AND visible=1 ORDER BY version DESC LIMIT 1") - row['version'] + # Get the latest version id of a way + def getlastversion(id,version) #:doc: + old_way = OldWay.find(:first, :conditions => ['visible=1 AND id=?' , id], :order => 'version DESC') + old_way.version end - def readwayquery_old(id,version,historic) + def readwayquery_old(id,version,historic) #:doc: # Node handling on undelete (historic=false): # - always use the node specified, even if it's moved @@ -629,7 +684,7 @@ class AmfController < ApplicationController rows end - def createuniquenodes(way,uqn_name,nodelist) + def createuniquenodes(way,uqn_name,nodelist) #:doc: # Find nodes which appear in this way but no others sql=<<-EOF CREATE TEMPORARY TABLE #{uqn_name} @@ -654,7 +709,7 @@ class AmfController < ApplicationController # deleteuniquenoderelations(uqn_name,uid,db_now) # deleteitemrelations(way|node,'way'|'node',uid,db_now) - def deleteuniquenoderelations(uqn_name,uid,db_now) + def deleteuniquenoderelations(uqn_name,uid,db_now) #:doc: sql=<<-EOF SELECT node_id,cr.id FROM #{uqn_name},current_relation_members crm,current_relations cr WHERE crm.member_id=node_id @@ -669,7 +724,7 @@ class AmfController < ApplicationController end end - def deleteitemrelations(objid,type,uid,db_now) + def deleteitemrelations(objid,type,uid,db_now) #:doc: sql=<<-EOF SELECT cr.id FROM current_relation_members crm,current_relations cr WHERE crm.member_id=#{objid} @@ -684,7 +739,7 @@ class AmfController < ApplicationController end end - def removefromrelation(objid,type,relation,uid,db_now) + def removefromrelation(objid,type,relation,uid,db_now) #:doc: rver=ActiveRecord::Base.connection.insert("INSERT INTO relations (id,user_id,timestamp,visible) VALUES (#{relation},#{uid},#{db_now},1)") tagsql=<<-EOF @@ -706,11 +761,11 @@ class AmfController < ApplicationController ActiveRecord::Base.connection.execute("DELETE FROM current_relation_members WHERE id=#{relation} AND member_type='#{type}' AND member_id=#{objid}") end - def sqlescape(a) + def sqlescape(a) #:doc: a.gsub(/[\000-\037]/,"").gsub("'","''").gsub(92.chr) {92.chr+92.chr} end - def tag2array(a) + def tag2array(a) #:doc: tags={} Tags.split(a) do |k, v| tags[k.gsub(':','|')]=v @@ -718,7 +773,7 @@ class AmfController < ApplicationController tags end - def array2tag(a) + def array2tag(a) #:doc: tags = [] a.each do |k,v| if v=='' then next end @@ -728,7 +783,7 @@ class AmfController < ApplicationController return Tags.join(tags) end - def getuserid(token) + def getuserid(token) #:doc: if (token =~ /^(.+)\+(.+)$/) then user = User.authenticate(:username => $1, :password => $2) else @@ -738,148 +793,27 @@ class AmfController < ApplicationController return user ? user.id : nil; end - - - # ==================================================================== - # AMF read subroutines - - # ----- getint return two-byte integer - # ----- getlong return four-byte long - # ----- getstring return string with two-byte length - # ----- getdouble return eight-byte double-precision float - # ----- getobject return object/hash - # ----- getarray return numeric array - - def getint(s) - s.getc*256+s.getc - end - - def getlong(s) - ((s.getc*256+s.getc)*256+s.getc)*256+s.getc - end - - def getstring(s) - len=s.getc*256+s.getc - s.read(len) - end - - def getdouble(s) - a=s.read(8).unpack('G') # G big-endian, E little-endian - a[0] - end - - def getarray(s) - len=getlong(s) - arr=[] - for i in (0..len-1) - arr[i]=getvalue(s) - end - arr - end - - def getobject(s) - arr={} - while (key=getstring(s)) - if (key=='') then break end - arr[key]=getvalue(s) - end - s.getc # skip the 9 'end of object' value - arr - end - - # ----- getvalue parse and get value - - def getvalue(s) - case s.getc - when 0; return getdouble(s) # number - when 1; return s.getc # boolean - when 2; return getstring(s) # string - when 3; return getobject(s) # object/hash - when 5; return nil # null - when 6; return nil # undefined - when 8; s.read(4) # mixedArray - return getobject(s) # | - when 10;return getarray(s) # array - else; return nil # error - end - end - - # ==================================================================== - # AMF write subroutines - - # ----- putdata envelope data into AMF writeable form - # ----- encodevalue pack variables as AMF - - def putdata(index,n) - d =encodestring(index+"/onResult") - d+=encodestring("null") - d+=[-1].pack("N") - d+=encodevalue(n) - end - - def encodevalue(n) - case n.class.to_s - when 'Array' - a=10.chr+encodelong(n.length) - n.each do |b| - a+=encodevalue(b) - end - a - when 'Hash' - a=3.chr - n.each do |k,v| - a+=encodestring(k)+encodevalue(v) - end - a+0.chr+0.chr+9.chr - when 'String' - 2.chr+encodestring(n) - when 'Bignum','Fixnum','Float' - 0.chr+encodedouble(n) - when 'NilClass' - 5.chr - else - RAILS_DEFAULT_LOGGER.error("Unexpected Ruby type for AMF conversion: "+n.class.to_s) - end - end - - # ----- encodestring encode string with two-byte length - # ----- encodedouble encode number as eight-byte double precision float - # ----- encodelong encode number as four-byte long - - def encodestring(n) - a,b=n.size.divmod(256) - a.chr+b.chr+n - end - - def encodedouble(n) - [n].pack('G') - end - - def encodelong(n) - [n].pack('N') - end - # ==================================================================== # Co-ordinate conversion - def lat2coord(a,basey,masterscale) - -(lat2y(a)-basey)*masterscale+250 + def lat2coord(a,basey,masterscale) #:doc: + -(lat2y(a)-basey)*masterscale end - def long2coord(a,baselong,masterscale) - (a-baselong)*masterscale+350 + def long2coord(a,baselong,masterscale) #:doc: + (a-baselong)*masterscale end - def lat2y(a) + def lat2y(a) #:doc: 180/Math::PI * Math.log(Math.tan(Math::PI/4+a*(Math::PI/180)/2)) end - def coord2lat(a,masterscale,basey) - y2lat((a-250)/-masterscale+basey) + def coord2lat(a,masterscale,basey) #:doc: + y2lat(a/-masterscale+basey) end - def coord2long(a,masterscale,baselong) - (a-350)/masterscale+baselong + def coord2long(a,masterscale,baselong) #:doc: + a/masterscale+baselong end def y2lat(a)