+# 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
+#
+# All in/out parameters are floats unless explicitly stated.
+#
+# 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]}")
class AmfController < ApplicationController
require 'stringio'
+ include Potlatch
+
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-2008
- #
- # All in/out parameters are floats unless explicitly stated.
- # Note that in getway/getway_old, SWF object name and way id are
- #Êidentical and one could probably be eliminated.
- #
- # 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]}")
-
- # ====================================================================
- # Main AMF handler
-
- # ---- talk process AMF request
-
+ # Main AMF handler. Tha talk method takes in AMF, figures out what to do and dispatched to the appropriate private method
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
# -------------
# 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
end
}
RAILS_DEFAULT_LOGGER.info(" Response: end")
-
end
private
-
- # ====================================================================
- # Remote calls
-
- # ----- getpresets
- # in: none
- # does: reads tag preset menus, colours, and autocomplete config files
- # out: [0] presets, [1] presetmenus, [2] presetnames,
- # [3] colours, [4] casing, [5] areas, [6] autotags
- # (all hashes)
-
- def getpresets
- RAILS_DEFAULT_LOGGER.info(" Message: getpresets")
-
- # Read preset menus
- presets={}
- presetmenus={}; presetmenus['point']=[]; presetmenus['way']=[]; presetmenus['POI']=[]
- presetnames={}; presetnames['point']={}; presetnames['way']={}; presetnames['POI']={}
- presettype=''
- presetcategory=''
- # StringIO.open(txt) do |file|
- File.open("#{RAILS_ROOT}/config/potlatch/presets.txt") do |file|
- file.each_line {|line|
- t=line.chomp
- if (t=~/(\w+)\/(\w+)/) then
- presettype=$1
- presetcategory=$2
- presetmenus[presettype].push(presetcategory)
- presetnames[presettype][presetcategory]=["(no preset)"]
- elsif (t=~/^(.+):\s?(.+)$/) then
- pre=$1; kv=$2
- presetnames[presettype][presetcategory].push(pre)
- presets[pre]={}
- kv.split(',').each {|a|
- if (a=~/^(.+)=(.*)$/) then presets[pre][$1]=$2 end
- }
- end
- }
- end
-
- # Read colours/styling
- colours={}; casing={}; areas={}
- File.open("#{RAILS_ROOT}/config/potlatch/colours.txt") do |file|
- file.each_line {|line|
- t=line.chomp
- if (t=~/(\w+)\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)/) then
- tag=$1
- if ($2!='-') then colours[tag]=$2.hex end
- if ($3!='-') then casing[tag]=$3.hex end
- if ($4!='-') then areas[tag]=$4.hex end
- end
- }
- end
-
- # Read auto-complete
- autotags={}; autotags['point']={}; autotags['way']={}; autotags['POI']={};
- File.open("#{RAILS_ROOT}/config/potlatch/autocomplete.txt") do |file|
- file.each_line {|line|
- t=line.chomp
- if (t=~/^(\w+)\/(\w+)\s+(.+)$/) then
- tag=$1; type=$2; values=$3
- if values=='-' then autotags[type][tag]=[]
- else autotags[type][tag]=values.split(',').sort.reverse end
- end
- }
- end
-
- [presets,presetmenus,presetnames,colours,casing,areas,autotags]
+ # Return presets (default tags and crap) to potlatch.
+ # Uses POTLATCH_PRESETS global, set up in OSM::Potlatch
+ def getpresets #:doc:
+ return POTLATCH_PRESETS
end
# ----- whichways
- # return array of ways in current bounding box
-
- # in: [0] xmin, [1] ymin, [2] xmax, [3] ymax (bbox in degrees)
- # [4] baselong (longitude of SWF map origin),
- # [5] basey (projected latitude of SWF map origin),
- # [6] masterscale (SWF map scale)
- # does: finds all ways and POI nodes in bounding box
- # at present, instead of using correct (=more complex) SQL to find
- # corner-crossing ways, it simply enlarges the bounding box
- # out: [0] array of way ids,
- # [1] array of POIs
- # (where each POI is an array containing:
- # [0] id, [1] projected long, [2] projected lat, [3] hash of tags)
-
- def whichways(args)
+ # Find all the way ids and nodes (including tags and projected lat/lng) which aren't part of those ways in an are
+ #
+ # The argument is an array containing the following, in order:
+ # 0. minimum longitude
+ # 1. minimum latitude
+ # 2. maximum longitude
+ # 3. maximum latitude
+ # 4. baselong, 5. basey, 6. masterscale as above
+ 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
RAILS_DEFAULT_LOGGER.info(" Message: whichways, bbox=#{xmin},#{ymin},#{xmax},#{ymax}")
- waylist = ActiveRecord::Base.connection.select_all("SELECT DISTINCT current_way_nodes.id AS wayid"+
- " FROM current_way_nodes,current_nodes,current_ways "+
- " WHERE current_nodes.id=current_way_nodes.node_id "+
- " AND current_nodes.visible=1 "+
- " AND current_ways.id=current_way_nodes.id "+
- " AND current_ways.visible=1 "+
- " AND "+OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes."))
+ # 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)
+ way_ids = nodes_in_area.collect { |node| node.way_ids }.flatten.uniq
- ways = waylist.collect {|a| a['wayid'].to_i } # get an array of way IDs
+ # find the node ids in an area that aren't part of ways
+ 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] }
- 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 "+
- " LEFT OUTER JOIN current_way_nodes cwn ON cwn.node_id=current_nodes.id "+
- " WHERE "+OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")+
- " AND cwn.id IS NULL "+
- " AND current_nodes.visible=1")
+ # 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
- 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
-
- [ways,points]
+ [way_ids,points,relation_ids]
end
# ----- whichways_deleted
# return array of deleted ways in current bounding box
-
# 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
[ways]
end
+ # ----- getway
# Get a way with all of it's nodes and tags
# The input is an array with the following components, in order:
- # 0. SWF object name (String?) - fuck knows
- # 1. wayid (String?) - the ID of the way to get
- # 2. baselong - fuck knows
- # 3. basey - fuck knows
- # 4. masterscale - fuck knows
+ # 0. wayid - the ID of the way to get
+ # 1. baselong - origin of SWF map (longitude)
+ # 2. basey - origin of SWF map (latitude)
+ # 3. masterscale - SWF map scale
#
- # The output is an array which contains all the nodes (with projected latitude and longitude) and tags for a way (and all the nodes tags). It also has the way's unprojected (WGS84) bbox.
+ # The output is an array which contains all the nodes (with projected
+ # latitude and longitude) and tags for a way (and all the nodes tags).
+ # It also has the way's unprojected (WGS84) bbox.
#
# 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)
- objname,wayid,baselong,basey,masterscale = 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 # node ide
- tags_hash = node.tags_as_hash # hash of tags
-
- points << [projected_longitude, projected_latitude, id, nil, tags_hash] # FIXME remove the nil in potlatch. performance matters y'know!
+ id = node.id
+ tags_hash = node.tags_as_hash
+
+ points << [projected_longitude, projected_latitude, id, nil, tags_hash]
long_array << projected_longitude
lat_array << projected_latitude
end
- [objname,points,way.tags,long_array.min,long_array.max,lat_array.min,lat_array.max]
+ [wayid,points,way.tags,long_array.min,long_array.max,lat_array.min,lat_array.max]
end
# ----- getway_old
# returns old version of way
-
- # in: [0] SWF object name, [1] way id,
- # [2] way version to get (or -1 for "last deleted version")
- # [3] baselong, [4] basey, [5] masterscale
+ # in: [0] way id,
+ # [1] way version to get (or -1 for "last deleted version")
+ # [2] baselong, [3] basey, [4] masterscale
# does: gets old version of way and all constituent nodes
# for undelete, always uses the most recent version of each node
# (even if it's moved)
# [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
- objname,wayid,version,baselong,basey,masterscale=args
+ wayid,version,baselong,basey,masterscale=args
wayid = wayid.to_i
version = version.to_i
xmin = ymin = 999999
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]
+ [0,wayid,points,attributes,xmin,xmax,ymin,ymax,version]
end
# ----- getway_history
# find history of a way
-
# in: [0] way id
# does: finds history of a way
# out: [0] array of previous versions (where each is
# [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
[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),
# [1] original way id (may be negative),
# [2] array of points (as getway/getway_old),
# 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)
RAILS_DEFAULT_LOGGER.info(" Message: putway, id=#{originalway}")
- # -- Temporary check for null IDs
+ # -- Check for null IDs, short ways or lats=90
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
+ if coord2lat(a[1],masterscale,basey)==90 then return -2,"Server error - node with lat -90 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
end
end
-
# -- 6a. delete any nodes not in modified way
createuniquenodes(way,db_uqn,nodelist) # nodes which appear in this way but no other
# ----- putpoi
# save POI to the database
-
# in: [0] user token (string),
# [1] original node id (may be negative),
# [2] projected longitude, [3] projected latitude,
# 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
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+way.abs.to_s+Time.new.to_i.to_s
+ db_uqn='unin'+(rand*100).to_i.to_s+uid.to_s+way.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
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
# 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
+ # ----- 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']
EOF
rows=ActiveRecord::Base.connection.select_all(sql)
- # if historic (full revert), get the old version of each node
- # - if it's in another way now, generate a new id
- # - if it's not in another way, use the old ID
+ # ----- if historic (full revert), get the old version of each node
+ # - if it's in another way now, generate a new id
+ # - if it's not in another way, use the old ID
+
if historic then
rows.each_index do |i|
sql=<<-EOF
SELECT latitude*0.0000001 AS latitude,longitude*0.0000001 AS longitude,tags,cwn.id AS currentway
FROM nodes n
- LEFT JOIN current_way_nodes cwn
- ON cwn.node_id=n.id
+ LEFT JOIN current_way_nodes cwn
+ ON cwn.node_id=n.id AND cwn.id!=#{id}
WHERE n.id=#{rows[i]['id']}
AND n.timestamp<="#{waytime}"
- AND cwn.id!=#{id}
- ORDER BY n.timestamp DESC
+ ORDER BY n.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
+ nx=row['longitude'].to_f
+ ny=row['latitude'].to_f
+ if (!row.nil?)
if (row['currentway'] && (nx!=rows[i]['longitude'].to_f or ny!=rows[i]['latitude'].to_f or row['tags']!=rows[i]['tags'])) then rows[i]['id']=-1 end
- rows[i]['longitude']=nx
- rows[i]['latitude' ]=ny
- rows[i]['tags' ]=row['tags']
- end
+ end
+ rows[i]['longitude']=nx
+ rows[i]['latitude' ]=ny
+ rows[i]['tags' ]=row['tags']
end
end
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}
# 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
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}
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
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
tags
end
- def array2tag(a)
+ def array2tag(a) #:doc:
tags = []
a.each do |k,v|
if v=='' then next end
return Tags.join(tags)
end
- def getuserid(token)
+ def getuserid(token) #:doc:
if (token =~ /^(.+)\+(.+)$/) then
user = User.authenticate(:username => $1, :password => $2)
else
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)
projects / rails.git / blobdiff