session :off
before_filter :check_write_availability
+ # AMF controller for 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).
+ #
+ # Public domain. Set your tab width to 4 to read this document. :)
+ # editions Systeme D / Richard Fairhurst 2004-2007
+
+ # to trap errors (getway_old,putway,putpoi,deleteway only):
+ # return(-1,"message") <-- just puts up a dialogue
+ # 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]}")
+ # RAILS_DEFAULT_LOGGER.error("Args: #{args[0]}, #{args[1]}, #{args[2]}, #{args[3]}")
# ====================================================================
# Main AMF handler
args=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 'getway'; results[index]=putdata(index,getway(args))
- when 'putway'; results[index]=putdata(index,putway(args))
- when 'deleteway'; results[index]=putdata(index,deleteway(args))
- when 'putpoi'; results[index]=putdata(index,putpoi(args))
- when 'getpoi'; results[index]=putdata(index,getpoi(args))
+ 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 'putway'; results[index]=putdata(index,putway(args))
+ when 'deleteway'; results[index]=putdata(index,deleteway(args))
+ when 'putpoi'; results[index]=putdata(index,putpoi(args))
+ when 'getpoi'; results[index]=putdata(index,getpoi(args))
end
end
end
}
end
- return [presets,presetmenus,presetnames]
+ [presets,presetmenus,presetnames]
end
# ----- whichways(left,bottom,right,top)
" AND current_ways.visible=1 "+
" AND "+OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes."))
- ways = waylist.collect {|a| a['wayid'].to_i } # get an array of way id's
+ ways = waylist.collect {|a| a['wayid'].to_i } # get an array of way IDs
pointlist = ActiveRecord::Base.connection.select_all("SELECT current_nodes.id,current_nodes.latitude*0.0000001 AS lat,current_nodes.longitude*0.0000001 AS lng,current_nodes.tags "+
" FROM current_nodes "+
points = pointlist.collect {|a| [a['id'],long2coord(a['lng'].to_f,baselong,masterscale),lat2coord(a['lat'].to_f,basey,masterscale),tag2array(a['tags'])] } # get a list of node ids and their tags
- return [ways,points]
+ [ways,points]
end
+ # ----- whichways_deleted(left,bottom,right,top)
+ # return array of deleted ways in current bounding box
+
+ def whichways_deleted(args)
+ xmin = args[0].to_f-0.01
+ ymin = args[1].to_f-0.01
+ xmax = args[2].to_f+0.01
+ ymax = args[3].to_f+0.01
+ baselong = args[4]
+ basey = args[5]
+ masterscale = args[6]
+
+ sql=<<-EOF
+ SELECT DISTINCT current_ways.id
+ FROM current_nodes,way_nodes,current_ways
+ WHERE #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")}
+ AND way_nodes.node_id=current_nodes.id
+ AND way_nodes.id=current_ways.id
+ AND current_nodes.visible=0
+ AND current_ways.visible=0
+ EOF
+ waylist = ActiveRecord::Base.connection.select_all(sql)
+ ways = waylist.collect {|a| a['id'].to_i }
+ [ways]
+ end
+
# ----- getway (objectname, way, baselong, basey, masterscale)
# returns objectname, array of co-ordinates, attributes,
# xmin,xmax,ymin,ymax
objname,wayid,baselong,basey,masterscale=args
wayid = wayid.to_i
points = []
- lastid = -1
- xmin = ymin = 999999
+ xmin = ymin = 999999
xmax = ymax = -999999
RAILS_DEFAULT_LOGGER.info(" Message: getway, id=#{wayid}")
[objname,points,attributes,xmin,xmax,ymin,ymax]
end
+
+ # ----- getway_old (objectname, way, version, baselong, basey, masterscale)
+ # returns old version of way
+
+ def getway_old(args)
+ 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
+
+ objname,wayid,version,baselong,basey,masterscale=args
+ wayid = wayid.to_i
+ version = version.to_i
+ xmin = ymin = 999999
+ xmax = ymax = -999999
+ points=[]
+ if version<0
+ historic=false
+ version=getlastversion(wayid,version)
+ else
+ historic=true
+ end
+ readwayquery_old(wayid,version,historic).each { |row|
+ points<<[long2coord(row['longitude'].to_f,baselong,masterscale),lat2coord(row['latitude'].to_f,basey,masterscale),row['id'].to_i,row['visible'].to_i,tag2array(row['tags'].to_s)]
+ xmin=[xmin,row['longitude'].to_f].min
+ xmax=[xmax,row['longitude'].to_f].max
+ ymin=[ymin,row['latitude' ].to_f].min
+ ymax=[ymax,row['latitude' ].to_f].max
+ }
+
+ # get tags from this version
+ attributes={}
+ attrlist=ActiveRecord::Base.connection.select_all "SELECT k,v FROM way_tags WHERE id=#{wayid} AND version=#{version}"
+ attrlist.each {|a| attributes[a['k'].gsub(':','|')]=a['v'] }
+ attributes['history']="Retrieved from v"+version.to_s
+
+ [0,objname,points,attributes,xmin,xmax,ymin,ymax,version]
+ end
+
+ # ----- getway_history (way)
+ # returns array of previous versions (version,timestamp,visible,user)
+ # should also show 'created_by'
+
+ def getway_history(wayid)
+ history=[]
+ sql=<<-EOF
+ SELECT version,timestamp,visible,display_name,data_public
+ FROM ways,users
+ WHERE ways.id=#{wayid}
+ AND ways.user_id=users.id
+ ORDER BY version DESC
+ EOF
+ histlist=ActiveRecord::Base.connection.select_all(sql)
+ histlist.each { |row|
+ if row['data_public'] then user=row['display_name'] else user='anonymous' end
+ history<<[row['version'],row['timestamp'],row['visible'],user]
+ }
+ [history]
+ end
# ----- putway (user token, way, array of co-ordinates, array of attributes,
# baselong, basey, masterscale)
def putway(args)
RAILS_DEFAULT_LOGGER.info(" putway started")
- usertoken,originalway,points,attributes,baselong,basey,masterscale=args
+ usertoken,originalway,points,attributes,oldversion,baselong,basey,masterscale=args
uid=getuserid(usertoken)
- return if !uid
+ if !uid then return -1,"You are not logged in, so the way could not be saved." end
+
RAILS_DEFAULT_LOGGER.info(" putway authenticated happily")
- db_uqn='unin'+uid.to_s+originalway.to_i.abs.to_s+Time.new.to_i.to_s # temp uniquenodes table name, typically 51 chars
- db_now='@now'+uid.to_s+originalway.to_i.abs.to_s+Time.new.to_i.to_s # 'now' variable name, typically 51 chars
+ db_uqn='unin'+(rand*100).to_i.to_s+uid.to_s+originalway.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+originalway.to_i.abs.to_s+Time.new.to_i.to_s # 'now' variable name, typically 51 chars
ActiveRecord::Base.connection.execute("SET #{db_now}=NOW()")
originalway=originalway.to_i
-
+ oldversion=oldversion.to_i
+
RAILS_DEFAULT_LOGGER.info(" Message: putway, id=#{originalway}")
+ # -- Temporary check for null IDs
+
+ 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
+
# -- 3. read original way into memory
- xc={}; yc={}; tagc={}
+ xc={}; yc={}; tagc={}; vc={}
if originalway>0
way=originalway
- readwayquery(way).each { |row|
- id=row['id'].to_i
- xc[id]=row['longitude'].to_f
- yc[id]=row['latitude' ].to_f
- tagc[id]=row['tags']
- }
+ if oldversion==0
+ readwayquery(way).each { |row|
+ id=row['id'].to_i
+ xc[id]=row['longitude'].to_f
+ yc[id]=row['latitude' ].to_f
+ tagc[id]=row['tags']
+ vc[id]=1
+ }
+ else
+ readwayquery_old(way,oldversion,true).each { |row|
+ id=row['id'].to_i
+ if (id>0) then
+ xc[id]=row['longitude'].to_f
+ yc[id]=row['latitude' ].to_f
+ tagc[id]=row['tags']
+ vc[id]=row['visible'].to_i
+ end
+ }
+ end
ActiveRecord::Base.connection.update("UPDATE current_ways SET timestamp=#{db_now},user_id=#{uid},visible=1 WHERE id=#{way}")
else
way=ActiveRecord::Base.connection.insert("INSERT INTO current_ways (user_id,timestamp,visible) VALUES (#{uid},#{db_now},1)")
elsif xc.has_key?(node)
nodelist.push(node)
# old node from original way - update
- if (xs!=xc[node] or (ys/0.0000001).round!=(yc[node]/0.0000001).round or tagstr!=tagc[node])
+ if (xs!=xc[node] or (ys/0.0000001).round!=(yc[node]/0.0000001).round or tagstr!=tagc[node] or vc[node]==0)
ActiveRecord::Base.connection.insert("INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tags,tile) VALUES (#{node},#{lat},#{long},#{db_now},#{uid},1,#{tagsql},#{tile})")
ActiveRecord::Base.connection.update("UPDATE current_nodes SET latitude=#{lat},longitude=#{long},timestamp=#{db_now},user_id=#{uid},tags=#{tagsql},visible=1,tile=#{tile} WHERE id=#{node}")
end
if (insertsql !='') then ActiveRecord::Base.connection.insert("INSERT INTO way_tags (id,k,v,version) VALUES #{insertsql}" ) end
if (currentsql!='') then ActiveRecord::Base.connection.insert("INSERT INTO current_way_tags (id,k,v) VALUES #{currentsql}") end
- [originalway,way,renumberednodes,xmin,xmax,ymin,ymax]
+ [0,originalway,way,renumberednodes,xmin,xmax,ymin,ymax]
end
# ----- putpoi (user token, id, x,y,tag array,visible,baselong,basey,masterscale)
def putpoi(args)
usertoken,id,x,y,tags,visible,baselong,basey,masterscale=args
uid=getuserid(usertoken)
- return if !uid
- db_now='@now'+uid.to_s+id.to_i.abs.to_s+Time.new.to_i.to_s # 'now' variable name, typically 51 chars
+ if !uid then return -1,"You are not logged in, so the point could not be saved." end
+
+ db_now='@now'+(rand*100).to_i.to_s+uid.to_s+id.to_i.abs.to_s+Time.new.to_i.to_s # 'now' variable name, typically 51 chars
ActiveRecord::Base.connection.execute("SET #{db_now}=NOW()")
id=id.to_i
if visible==0 then
# if deleting, check node hasn't become part of a way
inway=ActiveRecord::Base.connection.select_one("SELECT cw.id FROM current_ways cw,current_way_nodes cwn WHERE cw.id=cwn.id AND cw.visible=1 AND cwn.node_id=#{id} LIMIT 1")
- unless inway.nil? then return [id,id] end # should really return an error
+ unless inway.nil? then return -1,"The point has since become part of a way, so you cannot save it as a POI." end
deleteitemrelations(id,'node',uid,db_now)
end
newid=ActiveRecord::Base.connection.insert("INSERT INTO current_nodes (latitude,longitude,timestamp,user_id,visible,tags,tile) VALUES (#{lat},#{long},#{db_now},#{uid},#{visible},#{tagsql},#{tile})");
ActiveRecord::Base.connection.update("INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tags,tile) VALUES (#{newid},#{lat},#{long},#{db_now},#{uid},#{visible},#{tagsql},#{tile})");
end
- [id,newid]
+ [0,id,newid]
end
# ----- getpoi (id,baselong,basey,masterscale)
# returns way ID only
def deleteway(args)
- usertoken,way,preserve=args
+ usertoken,way=args
RAILS_DEFAULT_LOGGER.info(" Message: deleteway, id=#{way}")
+ uid=getuserid(usertoken)
+ if !uid then return -1,"You are not logged in, so the way could not be deleted." end
- uid=getuserid(usertoken); if !uid then return end
way=way.to_i
-
- db_uqn='unin'+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'+uid.to_s+way.to_i.abs.to_s+Time.new.to_i.to_s # 'now' variable name, typically 51 chars
+ 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
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
+# 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)
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)
- way
+ [0,way]
end
" ORDER BY sequence_id"
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']
+end
+
+def readwayquery_old(id,version,historic)
+ # Node handling on undelete (historic=false):
+ # - always use the node specified, even if it's moved
+
+ # Node handling on revert (historic=true):
+ # - if it's a visible node, use a new node id (i.e. not mucking up the old one)
+ # which means the SWF needs to allocate new ids
+ # - if it's an invisible node, we can reuse the old node id
+
+ # get node list from specified version of way,
+ # and the _current_ lat/long/tags of each node
+
+ row=ActiveRecord::Base.connection.select_one("SELECT timestamp FROM ways WHERE version=#{version} AND id=#{id}")
+ waytime=row['timestamp']
+
+ sql=<<-EOF
+ SELECT cn.id,visible,latitude*0.0000001 AS latitude,longitude*0.0000001 AS longitude,tags
+ FROM way_nodes wn,current_nodes cn
+ WHERE wn.version=#{version}
+ AND wn.id=#{id}
+ AND wn.node_id=cn.id
+ ORDER BY sequence_id
+ EOF
+ rows=ActiveRecord::Base.connection.select_all(sql)
+
+ # if historic (full revert), get the old version of each node,
+ # and use this (though with a new id) if it differs from the current one
+ if historic then
+ rows.each_index do |i|
+ sql=<<-EOF
+ SELECT latitude*0.0000001 AS latitude,longitude*0.0000001 AS longitude,tags
+ FROM nodes
+ WHERE id=#{rows[i]['id']}
+ AND timestamp<="#{waytime}"
+ ORDER BY timestamp DESC
+ LIMIT 1
+ EOF
+ row=ActiveRecord::Base.connection.select_one(sql)
+ unless row.nil? then
+ nx=row['longitude'].to_f
+ ny=row['latitude'].to_f
+ if (nx!=rows[i]['longitude'].to_f or ny!=rows[i]['latitude'].to_f or row['tags']!=rows[i]['tags']) then
+ rows[i]['id']=-1
+ # This generates a new node id if x/y/tags differ from current node.
+ # Strictly speaking, it need only do this for uniquenodes, but we're
+ # not generating uniquenodes for historic ways (yet!).
+ end
+ rows[i]['longitude']=nx
+ rows[i]['latitude' ]=ny
+ rows[i]['tags' ]=row['tags']
+ end
+ end
+ end
+ rows
+end
+
def createuniquenodes(way,uqn_name,nodelist)
# Find nodes which appear in this way but no others
sql=<<-EOF
projects / rails.git / blobdiff