app/controllers/amf_controller.rb

   1 class AmfController < ApplicationController
   2   require 'stringio'
   3
   4   session :off
   5   before_filter :check_write_availability
   6
   7   # AMF controller for Potlatch
   8   # ---------------------------
   9   # All interaction between Potlatch (as a .SWF application) and the
  10   # OSM database takes place using this controller. Messages are
  11   # encoded in the Actionscript Message Format (AMF).
  12   #
  13   # Public domain. Set your tab width to 4 to read this document. :)
  14   # editions Systeme D / Richard Fairhurst 2004-2007
  15
  16   # to trap errors (getway_old,putway,putpoi,deleteway only):
  17   #   return(-1,"message")              <-- just puts up a dialogue
  18   #   return(-2,"message")              <-- also asks the user to e-mail me
  19   # to log:
  20   #   RAILS_DEFAULT_LOGGER.error("Args: #{args[0]}, #{args[1]}, #{args[2]}, #{args[3]}")
  21
  22   # ====================================================================
  23   # Main AMF handler
  24
  25   # ---- talk   process AMF request
  26
  27   def talk
  28     req=StringIO.new(request.raw_post+0.chr)    # Get POST data as request
  29                                                                                         # (cf http://www.ruby-forum.com/topic/122163)
  30     req.read(2)                                                                 # Skip version indicator and client ID
  31     results={}                                                                  # Results of each body
  32     renumberednodes={}                                                  # Shared across repeated putways
  33
  34     # -------------
  35     # Parse request
  36
  37     headers=getint(req)                                 # Read number of headers
  38
  39     headers.times do                                # Read each header
  40       name=getstring(req)                               #  |
  41       req.getc                                  #  | skip boolean
  42       value=getvalue(req)                               #  |
  43       header["name"]=value                              #  |
  44     end
  45
  46     bodies=getint(req)                                  # Read number of bodies
  47     bodies.times do                                     # Read each body
  48       message=getstring(req)                    #  | get message name
  49       index=getstring(req)                              #  | get index in response sequence
  50       bytes=getlong(req)                                #  | get total size in bytes
  51       args=getvalue(req)                                #  | get response (probably an array)
  52
  53       case message
  54                   when 'getpresets';            results[index]=putdata(index,getpresets)
  55                   when 'whichways';                     results[index]=putdata(index,whichways(args))
  56                   when 'whichways_deleted';     results[index]=putdata(index,whichways_deleted(args))
  57                   when 'getway';                        results[index]=putdata(index,getway(args))
  58                   when 'getway_old';            results[index]=putdata(index,getway_old(args))
  59                   when 'getway_history';        results[index]=putdata(index,getway_history(args))
  60                   when 'putway';                        r=putway(args,renumberednodes)
  61                                                                         renumberednodes=r[3]
  62                                                                         results[index]=putdata(index,r)
  63                   when 'deleteway';                     results[index]=putdata(index,deleteway(args))
  64                   when 'putpoi';                        results[index]=putdata(index,putpoi(args))
  65                   when 'getpoi';                        results[index]=putdata(index,getpoi(args))
  66       end
  67     end
  68
  69     # ------------------
  70     # Write out response
  71
  72     RAILS_DEFAULT_LOGGER.info("  Response: start")
  73     a,b=results.length.divmod(256)
  74         render :content_type => "application/x-amf", :text => proc { |response, output|
  75         output.write 0.chr+0.chr+0.chr+0.chr+a.chr+b.chr
  76                 results.each do |k,v|
  77                   output.write(v)
  78                 end
  79         }
  80     RAILS_DEFAULT_LOGGER.info("  Response: end")
  81
  82   end
  83
  84   private
  85
  86   # ====================================================================
  87   # Remote calls
  88
  89   # ----- getpresets
  90   #           return presets,presetmenus and presetnames arrays
  91
  92   def getpresets
  93     RAILS_DEFAULT_LOGGER.info("  Message: getpresets")
  94
  95         # Read preset menus
  96     presets={}
  97     presetmenus={}; presetmenus['point']=[]; presetmenus['way']=[]; presetmenus['POI']=[]
  98     presetnames={}; presetnames['point']={}; presetnames['way']={}; presetnames['POI']={}
  99     presettype=''
 100     presetcategory=''
 101
 102 #       StringIO.open(txt) do |file|
 103         File.open("#{RAILS_ROOT}/config/potlatch/presets.txt") do |file|
 104       file.each_line {|line|
 105         t=line.chomp
 106         if (t=~/(\w+)\/(\w+)/) then
 107           presettype=$1
 108           presetcategory=$2
 109           presetmenus[presettype].push(presetcategory)
 110           presetnames[presettype][presetcategory]=["(no preset)"]
 111         elsif (t=~/^(.+):\s?(.+)$/) then
 112           pre=$1; kv=$2
 113           presetnames[presettype][presetcategory].push(pre)
 114           presets[pre]={}
 115           kv.split(',').each {|a|
 116             if (a=~/^(.+)=(.*)$/) then presets[pre][$1]=$2 end
 117           }
 118         end
 119       }
 120     end
 121
 122     # Read colours/styling
 123         colours={}; casing={}; areas={}
 124         File.open("#{RAILS_ROOT}/config/potlatch/colours.txt") do |file|
 125           file.each_line {|line|
 126                 t=line.chomp
 127                 if (t=~/(\w+)\t+([^\t]+)\t+([^\t]+)\t+([^\t]+)/) then
 128                   tag=$1
 129                   if ($2!='-') then colours[tag]=$2.hex end
 130                   if ($3!='-') then casing[tag]=$3.hex end
 131                   if ($4!='-') then areas[tag]=$4.hex end
 132                 end
 133           }
 134         end
 135     [presets,presetmenus,presetnames,colours,casing,areas]
 136   end
 137
 138   # ----- whichways(left,bottom,right,top)
 139   #               return array of ways in current bounding box
 140   #               at present, instead of using correct (=more complex) SQL to find
 141   #               corner-crossing ways, it simply enlarges the bounding box by +/- 0.01
 142
 143   def whichways(args)
 144     xmin = args[0].to_f-0.01
 145     ymin = args[1].to_f-0.01
 146     xmax = args[2].to_f+0.01
 147     ymax = args[3].to_f+0.01
 148     baselong    = args[4]
 149     basey       = args[5]
 150     masterscale = args[6]
 151
 152     RAILS_DEFAULT_LOGGER.info("  Message: whichways, bbox=#{xmin},#{ymin},#{xmax},#{ymax}")
 153
 154     waylist = ActiveRecord::Base.connection.select_all("SELECT DISTINCT current_way_nodes.id AS wayid"+
 155        "  FROM current_way_nodes,current_nodes,current_ways "+
 156        " WHERE current_nodes.id=current_way_nodes.node_id "+
 157        "   AND current_nodes.visible=1 "+
 158        "   AND current_ways.id=current_way_nodes.id "+
 159        "   AND current_ways.visible=1 "+
 160        "   AND "+OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes."))
 161
 162     ways = waylist.collect {|a| a['wayid'].to_i } # get an array of way IDs
 163
 164     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 "+
 165        "  FROM current_nodes "+
 166        "  LEFT OUTER JOIN current_way_nodes cwn ON cwn.node_id=current_nodes.id "+
 167        " WHERE "+OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")+
 168        "   AND cwn.id IS NULL "+
 169        "   AND current_nodes.visible=1")
 170
 171     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
 172
 173     [ways,points]
 174   end
 175
 176   # ----- whichways_deleted(left,bottom,right,top)
 177   #               return array of deleted ways in current bounding box
 178
 179   def whichways_deleted(args)
 180     xmin = args[0].to_f-0.01
 181     ymin = args[1].to_f-0.01
 182     xmax = args[2].to_f+0.01
 183     ymax = args[3].to_f+0.01
 184     baselong    = args[4]
 185     basey       = args[5]
 186     masterscale = args[6]
 187
 188         sql=<<-EOF
 189                  SELECT DISTINCT current_ways.id
 190                    FROM current_nodes,way_nodes,current_ways
 191                   WHERE #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")}
 192                         AND way_nodes.node_id=current_nodes.id
 193                         AND way_nodes.id=current_ways.id
 194                         AND current_nodes.visible=0
 195                         AND current_ways.visible=0
 196         EOF
 197     waylist = ActiveRecord::Base.connection.select_all(sql)
 198     ways = waylist.collect {|a| a['id'].to_i }
 199         [ways]
 200   end
 201
 202   # ----- getway (objectname, way, baselong, basey, masterscale)
 203   #               returns objectname, array of co-ordinates, attributes,
 204   #                               xmin,xmax,ymin,ymax
 205
 206   def getway(args)
 207     objname,wayid,baselong,basey,masterscale=args
 208     wayid = wayid.to_i
 209     points = []
 210     xmin = ymin =  999999
 211     xmax = ymax = -999999
 212
 213     RAILS_DEFAULT_LOGGER.info("  Message: getway, id=#{wayid}")
 214
 215     readwayquery(wayid).each {|row|
 216       points<<[long2coord(row['longitude'].to_f,baselong,masterscale),lat2coord(row['latitude'].to_f,basey,masterscale),row['id'].to_i,nil,tag2array(row['tags'])]
 217       xmin = [xmin,row['longitude'].to_f].min
 218       xmax = [xmax,row['longitude'].to_f].max
 219       ymin = [ymin,row['latitude'].to_f].min
 220       ymax = [ymax,row['latitude'].to_f].max
 221     }
 222
 223     attributes={}
 224     attrlist=ActiveRecord::Base.connection.select_all "SELECT k,v FROM current_way_tags WHERE id=#{wayid}"
 225     attrlist.each {|a| attributes[a['k'].gsub(':','|')]=a['v'] }
 226
 227     [objname,points,attributes,xmin,xmax,ymin,ymax]
 228   end
 229
 230   # -----       getway_old (objectname, way, version, baselong, basey, masterscale)
 231   #                     returns old version of way
 232
 233   def getway_old(args)
 234     RAILS_DEFAULT_LOGGER.info("  Message: getway_old (server is #{SERVER_URL})")
 235         if SERVER_URL=="www.openstreetmap.org" then return -1,"Revert is not currently enabled on the OpenStreetMap server." end
 236
 237     objname,wayid,version,baselong,basey,masterscale=args
 238     wayid = wayid.to_i
 239     version = version.to_i
 240     xmin = ymin =  999999
 241     xmax = ymax = -999999
 242         points=[]
 243         if version<0
 244           historic=false
 245           version=getlastversion(wayid,version)
 246         else
 247           historic=true
 248         end
 249         readwayquery_old(wayid,version,historic).each { |row|
 250       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)]
 251       xmin=[xmin,row['longitude'].to_f].min
 252       xmax=[xmax,row['longitude'].to_f].max
 253       ymin=[ymin,row['latitude' ].to_f].min
 254       ymax=[ymax,row['latitude' ].to_f].max
 255         }
 256
 257         # get tags from this version
 258     attributes={}
 259     attrlist=ActiveRecord::Base.connection.select_all "SELECT k,v FROM way_tags WHERE id=#{wayid} AND version=#{version}"
 260     attrlist.each {|a| attributes[a['k'].gsub(':','|')]=a['v'] }
 261         attributes['history']="Retrieved from v"+version.to_s
 262
 263     [0,objname,points,attributes,xmin,xmax,ymin,ymax,version]
 264   end
 265
 266   # -----       getway_history (way)
 267   #                     returns array of previous versions (version,timestamp,visible,user)
 268   #                     should also show 'created_by'
 269
 270   def getway_history(wayid)
 271         history=[]
 272         sql=<<-EOF
 273         SELECT version,timestamp,visible,display_name,data_public
 274           FROM ways,users
 275          WHERE ways.id=#{wayid}
 276            AND ways.user_id=users.id
 277            AND ways.visible=1
 278          ORDER BY version DESC
 279         EOF
 280         histlist=ActiveRecord::Base.connection.select_all(sql)
 281         histlist.each { |row|
 282                 if row['data_public'] then user=row['display_name'] else user='anonymous' end
 283                 history<<[row['version'],row['timestamp'],row['visible'],user]
 284         }
 285         [history]
 286   end
 287
 288   # -----       putway (user token, way, array of co-ordinates, array of attributes,
 289   #                                     baselong, basey, masterscale)
 290   #                     returns current way ID, new way ID, hash of renumbered nodes,
 291   #                                     xmin,xmax,ymin,ymax
 292
 293   def putway(args,renumberednodes)
 294     RAILS_DEFAULT_LOGGER.info("  putway started")
 295     usertoken,originalway,points,attributes,oldversion,baselong,basey,masterscale=args
 296     uid=getuserid(usertoken)
 297     if !uid then return -1,"You are not logged in, so the way could not be saved." end
 298
 299     RAILS_DEFAULT_LOGGER.info("  putway authenticated happily")
 300     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
 301     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
 302     ActiveRecord::Base.connection.execute("SET #{db_now}=NOW()")
 303     originalway=originalway.to_i
 304         oldversion=oldversion.to_i
 305
 306     RAILS_DEFAULT_LOGGER.info("  Message: putway, id=#{originalway}")
 307
 308         # -- Temporary check for null IDs
 309
 310         points.each do |a|
 311           if a[2]==0 or a[2].nil? then return -2,"Server error - node with id 0 found in way #{originalway}." end
 312         end
 313
 314     # -- 3.     read original way into memory
 315
 316     xc={}; yc={}; tagc={}; vc={}
 317     if originalway>0
 318       way=originalway
 319           if oldversion==0
 320             readwayquery(way).each { |row|
 321                   id=row['id'].to_i
 322                   xc[id]=row['longitude'].to_f
 323                   yc[id]=row['latitude' ].to_f
 324                   tagc[id]=row['tags']
 325                   vc[id]=1
 326                 }
 327           else
 328             readwayquery_old(way,oldversion,true).each { |row|
 329                   id=row['id'].to_i
 330                   if (id>0) then
 331                         xc[id]=row['longitude'].to_f
 332                         yc[id]=row['latitude' ].to_f
 333                         tagc[id]=row['tags']
 334                         vc[id]=row['visible'].to_i
 335                   end
 336                 }
 337           end
 338       ActiveRecord::Base.connection.update("UPDATE current_ways SET timestamp=#{db_now},user_id=#{uid},visible=1 WHERE id=#{way}")
 339     else
 340       way=ActiveRecord::Base.connection.insert("INSERT INTO current_ways (user_id,timestamp,visible) VALUES (#{uid},#{db_now},1)")
 341     end
 342
 343     # -- 4.     get version by inserting new row into ways
 344
 345     version=ActiveRecord::Base.connection.insert("INSERT INTO ways (id,user_id,timestamp,visible) VALUES (#{way},#{uid},#{db_now},1)")
 346
 347     # -- 5. compare nodes and update xmin,xmax,ymin,ymax
 348
 349     xmin=ymin= 999999
 350     xmax=ymax=-999999
 351     insertsql=''
 352         nodelist=[]
 353
 354     points.each_index do |i|
 355       xs=coord2long(points[i][0],masterscale,baselong)
 356       ys=coord2lat(points[i][1],masterscale,basey)
 357       xmin=[xs,xmin].min; xmax=[xs,xmax].max
 358       ymin=[ys,ymin].min; ymax=[ys,ymax].max
 359       node=points[i][2].to_i
 360           tagstr=array2tag(points[i][4])
 361       tagsql="'"+sqlescape(tagstr)+"'"
 362       lat=(ys * 10000000).round
 363       long=(xs * 10000000).round
 364       tile=QuadTile.tile_for_point(ys, xs)
 365
 366       # compare node
 367       if node<0
 368         # new node - create
 369                 if renumberednodes[node.to_s].nil?
 370           newnode=ActiveRecord::Base.connection.insert("INSERT INTO current_nodes (   latitude,longitude,timestamp,user_id,visible,tags,tile) VALUES (           #{lat},#{long},#{db_now},#{uid},1,#{tagsql},#{tile})")
 371                   ActiveRecord::Base.connection.insert("INSERT INTO nodes         (id,latitude,longitude,timestamp,user_id,visible,tags,tile) VALUES (#{newnode},#{lat},#{long},#{db_now},#{uid},1,#{tagsql},#{tile})")
 372           points[i][2]=newnode
 373           nodelist.push(newnode)
 374           renumberednodes[node.to_s]=newnode.to_s
 375                 else
 376           points[i][2]=renumberednodes[node.to_s].to_i
 377                 end
 378
 379       elsif xc.has_key?(node)
 380                 nodelist.push(node)
 381         # old node from original way - update
 382         if (xs!=xc[node] or (ys/0.0000001).round!=(yc[node]/0.0000001).round or tagstr!=tagc[node] or vc[node]==0)
 383           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})")
 384           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}")
 385         end
 386       else
 387         # old node, created in another way and now added to this way
 388       end
 389     end
 390
 391
 392         # -- 6a. delete any nodes not in modified way
 393
 394     createuniquenodes(way,db_uqn,nodelist)      # nodes which appear in this way but no other
 395
 396     sql=<<-EOF
 397         INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tile)
 398         SELECT DISTINCT cn.id,cn.latitude,cn.longitude,#{db_now},#{uid},0,cn.tile
 399           FROM current_nodes AS cn,#{db_uqn}
 400          WHERE cn.id=node_id
 401     EOF
 402     ActiveRecord::Base.connection.insert(sql)
 403
 404     sql=<<-EOF
 405       UPDATE current_nodes AS cn, #{db_uqn}
 406          SET cn.timestamp=#{db_now},cn.visible=0,cn.user_id=#{uid}
 407        WHERE cn.id=node_id
 408     EOF
 409     ActiveRecord::Base.connection.update(sql)
 410
 411         deleteuniquenoderelations(db_uqn,uid,db_now)
 412     ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqn}")
 413
 414         #       6b. insert new version of route into way_nodes
 415
 416     insertsql =''
 417     currentsql=''
 418     sequence  =1
 419     points.each do |p|
 420       if insertsql !='' then insertsql +=',' end
 421       if currentsql!='' then currentsql+=',' end
 422       insertsql +="(#{way},#{p[2]},#{sequence},#{version})"
 423       currentsql+="(#{way},#{p[2]},#{sequence})"
 424       sequence  +=1
 425     end
 426
 427     ActiveRecord::Base.connection.execute("DELETE FROM current_way_nodes WHERE id=#{way}");
 428     ActiveRecord::Base.connection.insert( "INSERT INTO         way_nodes (id,node_id,sequence_id,version) VALUES #{insertsql}");
 429     ActiveRecord::Base.connection.insert( "INSERT INTO current_way_nodes (id,node_id,sequence_id        ) VALUES #{currentsql}");
 430
 431     # -- 7. insert new way tags
 432
 433     insertsql =''
 434     currentsql=''
 435     attributes.each do |k,v|
 436       if v=='' or v.nil? then next end
 437       if v[0,6]=='(type ' then next end
 438       if insertsql !='' then insertsql +=',' end
 439       if currentsql!='' then currentsql+=',' end
 440       insertsql +="(#{way},'"+sqlescape(k.gsub('|',':'))+"','"+sqlescape(v)+"',#{version})"
 441       currentsql+="(#{way},'"+sqlescape(k.gsub('|',':'))+"','"+sqlescape(v)+"')"
 442     end
 443
 444     ActiveRecord::Base.connection.execute("DELETE FROM current_way_tags WHERE id=#{way}")
 445     if (insertsql !='') then ActiveRecord::Base.connection.insert("INSERT INTO way_tags (id,k,v,version) VALUES #{insertsql}" ) end
 446     if (currentsql!='') then ActiveRecord::Base.connection.insert("INSERT INTO current_way_tags (id,k,v) VALUES #{currentsql}") end
 447
 448     [0,originalway,way,renumberednodes,xmin,xmax,ymin,ymax]
 449   end
 450
 451   # -----       putpoi (user token, id, x,y,tag array,visible,baselong,basey,masterscale)
 452   #                     returns current id, new id
 453   #                     if new: add new row to current_nodes and nodes
 454   #                     if old: add new row to nodes, update current_nodes
 455
 456   def putpoi(args)
 457     usertoken,id,x,y,tags,visible,baselong,basey,masterscale=args
 458     uid=getuserid(usertoken)
 459     if !uid then return -1,"You are not logged in, so the point could not be saved." end
 460
 461     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
 462     ActiveRecord::Base.connection.execute("SET #{db_now}=NOW()")
 463
 464     id=id.to_i
 465     visible=visible.to_i
 466         if visible==0 then
 467                 # if deleting, check node hasn't become part of a way
 468                 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")
 469                 unless inway.nil? then return -1,"The point has since become part of a way, so you cannot save it as a POI." end
 470                 deleteitemrelations(id,'node',uid,db_now)
 471         end
 472
 473     x=coord2long(x.to_f,masterscale,baselong)
 474     y=coord2lat(y.to_f,masterscale,basey)
 475     tagsql="'"+sqlescape(array2tag(tags))+"'"
 476     lat=(y * 10000000).round
 477     long=(x * 10000000).round
 478     tile=QuadTile.tile_for_point(y, x)
 479
 480     if (id>0) then
 481         ActiveRecord::Base.connection.insert("INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tags,tile) VALUES (#{id},#{lat},#{long},#{db_now},#{uid},#{visible},#{tagsql},#{tile})");
 482         ActiveRecord::Base.connection.update("UPDATE current_nodes SET latitude=#{lat},longitude=#{long},timestamp=#{db_now},user_id=#{uid},visible=#{visible},tags=#{tagsql},tile=#{tile} WHERE id=#{id}");
 483         newid=id
 484     else
 485         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})");
 486               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})");
 487     end
 488     [0,id,newid]
 489   end
 490
 491   # -----       getpoi (id,baselong,basey,masterscale)
 492   #                     returns id,x,y,tag array
 493
 494   def getpoi(args)
 495         id,baselong,basey,masterscale=args; id=id.to_i
 496         poi=ActiveRecord::Base.connection.select_one("SELECT latitude*0.0000001 AS lat,longitude*0.0000001 AS lng,tags "+
 497                 "FROM current_nodes WHERE visible=1 AND id=#{id}")
 498         if poi.nil? then return [nil,nil,nil,''] end
 499         [id,
 500          long2coord(poi['lng'].to_f,baselong,masterscale),
 501          lat2coord(poi['lat'].to_f,basey,masterscale),
 502          tag2array(poi['tags'])]
 503   end
 504
 505   # -----       deleteway (user token, way, nodes to keep)
 506   #                     returns way ID only
 507
 508   def deleteway(args)
 509     usertoken,way=args
 510
 511     RAILS_DEFAULT_LOGGER.info("  Message: deleteway, id=#{way}")
 512     uid=getuserid(usertoken)
 513     if !uid then return -1,"You are not logged in, so the way could not be deleted." end
 514
 515     way=way.to_i
 516     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
 517     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
 518     ActiveRecord::Base.connection.execute("SET #{db_now}=NOW()")
 519
 520     # - delete any otherwise unused nodes
 521
 522     createuniquenodes(way,db_uqn,[])
 523
 524 #       unless (preserve.empty?) then
 525 #               ActiveRecord::Base.connection.execute("DELETE FROM #{db_uqn} WHERE node_id IN ("+preserve.join(',')+")")
 526 #       end
 527
 528     sql=<<-EOF
 529         INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tile)
 530         SELECT DISTINCT cn.id,cn.latitude,cn.longitude,#{db_now},#{uid},0,cn.tile
 531           FROM current_nodes AS cn,#{db_uqn}
 532          WHERE cn.id=node_id
 533     EOF
 534     ActiveRecord::Base.connection.insert(sql)
 535
 536     sql=<<-EOF
 537       UPDATE current_nodes AS cn, #{db_uqn}
 538          SET cn.timestamp=#{db_now},cn.visible=0,cn.user_id=#{uid}
 539        WHERE cn.id=node_id
 540     EOF
 541     ActiveRecord::Base.connection.update(sql)
 542
 543         deleteuniquenoderelations(db_uqn,uid,db_now)
 544     ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqn}")
 545
 546     # - delete way
 547
 548     ActiveRecord::Base.connection.insert("INSERT INTO ways (id,user_id,timestamp,visible) VALUES (#{way},#{uid},#{db_now},0)")
 549     ActiveRecord::Base.connection.update("UPDATE current_ways SET user_id=#{uid},timestamp=#{db_now},visible=0 WHERE id=#{way}")
 550     ActiveRecord::Base.connection.execute("DELETE FROM current_way_nodes WHERE id=#{way}")
 551     ActiveRecord::Base.connection.execute("DELETE FROM current_way_tags WHERE id=#{way}")
 552         deleteitemrelations(way,'way',uid,db_now)
 553     [0,way]
 554 end
 555
 556
 557
 558 # ====================================================================
 559 # Support functions for remote calls
 560
 561 def readwayquery(id)
 562   ActiveRecord::Base.connection.select_all "SELECT latitude*0.0000001 AS latitude,longitude*0.0000001 AS longitude,current_nodes.id,tags "+
 563       "    FROM current_way_nodes,current_nodes "+
 564       "   WHERE current_way_nodes.id=#{id} "+
 565       "     AND current_way_nodes.node_id=current_nodes.id "+
 566       "     AND current_nodes.visible=1 "+
 567       "   ORDER BY sequence_id"
 568 end
 569
 570 def getlastversion(id,version)
 571   row=ActiveRecord::Base.connection.select_one("SELECT version FROM ways WHERE id=#{id} AND visible=1 ORDER BY version DESC LIMIT 1")
 572   row['version']
 573 end
 574
 575 def readwayquery_old(id,version,historic)
 576   # Node handling on undelete (historic=false):
 577   # - always use the node specified, even if it's moved
 578
 579   # Node handling on revert (historic=true):
 580   # - if it's a visible node, use a new node id (i.e. not mucking up the old one)
 581   #   which means the SWF needs to allocate new ids
 582   # - if it's an invisible node, we can reuse the old node id
 583
 584   # get node list from specified version of way,
 585   # and the _current_ lat/long/tags of each node
 586
 587   row=ActiveRecord::Base.connection.select_one("SELECT timestamp FROM ways WHERE version=#{version} AND id=#{id}")
 588   waytime=row['timestamp']
 589
 590   sql=<<-EOF
 591         SELECT cn.id,visible,latitude*0.0000001 AS latitude,longitude*0.0000001 AS longitude,tags
 592           FROM way_nodes wn,current_nodes cn
 593          WHERE wn.version=#{version}
 594            AND wn.id=#{id}
 595            AND wn.node_id=cn.id
 596          ORDER BY sequence_id
 597   EOF
 598   rows=ActiveRecord::Base.connection.select_all(sql)
 599
 600   # if historic (full revert), get the old version of each node
 601   # - if it's in another way now, generate a new id
 602   # - if it's not in another way, use the old ID
 603   if historic then
 604         rows.each_index do |i|
 605           sql=<<-EOF
 606           SELECT latitude*0.0000001 AS latitude,longitude*0.0000001 AS longitude,tags,cwn.id AS currentway
 607             FROM nodes n
 608    LEFT JOIN current_way_nodes cwn
 609                   ON cwn.node_id=n.id
 610            WHERE n.id=#{rows[i]['id']}
 611              AND n.timestamp<="#{waytime}"
 612                  AND cwn.id!=#{id}
 613            ORDER BY n.timestamp DESC
 614            LIMIT 1
 615           EOF
 616           row=ActiveRecord::Base.connection.select_one(sql)
 617           unless row.nil? then
 618             nx=row['longitude'].to_f
 619             ny=row['latitude'].to_f
 620             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
 621                 rows[i]['longitude']=nx
 622                 rows[i]['latitude' ]=ny
 623                 rows[i]['tags'     ]=row['tags']
 624           end
 625     end
 626   end
 627   rows
 628 end
 629
 630 def createuniquenodes(way,uqn_name,nodelist)
 631         # Find nodes which appear in this way but no others
 632         sql=<<-EOF
 633         CREATE TEMPORARY TABLE #{uqn_name}
 634                                         SELECT a.node_id
 635                                           FROM (SELECT DISTINCT node_id FROM current_way_nodes
 636                                                         WHERE id=#{way}) a
 637                                  LEFT JOIN current_way_nodes b
 638                                                 ON b.node_id=a.node_id
 639                                            AND b.id!=#{way}
 640                                          WHERE b.node_id IS NULL
 641         EOF
 642         unless nodelist.empty? then
 643           sql+="AND a.node_id NOT IN ("+nodelist.join(',')+")"
 644         end
 645         ActiveRecord::Base.connection.execute(sql)
 646 end
 647
 648
 649
 650 # ====================================================================
 651 # Relations handling
 652 # deleteuniquenoderelations(uqn_name,uid,db_now)
 653 # deleteitemrelations(way|node,'way'|'node',uid,db_now)
 654
 655 def deleteuniquenoderelations(uqn_name,uid,db_now)
 656         sql=<<-EOF
 657         SELECT node_id,cr.id FROM #{uqn_name},current_relation_members crm,current_relations cr
 658          WHERE crm.member_id=node_id
 659            AND crm.member_type='node'
 660            AND crm.id=cr.id
 661            AND cr.visible=1
 662         EOF
 663
 664         relnodes=ActiveRecord::Base.connection.select_all(sql)
 665         relnodes.each do |a|
 666                 removefromrelation(a['node_id'],'node',a['id'],uid,db_now)
 667         end
 668 end
 669
 670 def deleteitemrelations(objid,type,uid,db_now)
 671         sql=<<-EOF
 672         SELECT cr.id FROM current_relation_members crm,current_relations cr
 673          WHERE crm.member_id=#{objid}
 674            AND crm.member_type='#{type}'
 675            AND crm.id=cr.id
 676            AND cr.visible=1
 677         EOF
 678
 679         relways=ActiveRecord::Base.connection.select_all(sql)
 680         relways.each do |a|
 681                 removefromrelation(objid,type,a['id'],uid,db_now)
 682         end
 683 end
 684
 685 def removefromrelation(objid,type,relation,uid,db_now)
 686         rver=ActiveRecord::Base.connection.insert("INSERT INTO relations (id,user_id,timestamp,visible) VALUES (#{relation},#{uid},#{db_now},1)")
 687
 688         tagsql=<<-EOF
 689         INSERT INTO relation_tags (id,k,v,version)
 690         SELECT id,k,v,#{rver} FROM current_relation_tags
 691          WHERE id=#{relation}
 692         EOF
 693         ActiveRecord::Base.connection.insert(tagsql)
 694
 695         membersql=<<-EOF
 696         INSERT INTO relation_members (id,member_type,member_id,member_role,version)
 697         SELECT id,member_type,member_id,member_role,#{rver} FROM current_relation_members
 698          WHERE id=#{relation}
 699            AND (member_id!=#{objid} OR member_type!='#{type}')
 700         EOF
 701         ActiveRecord::Base.connection.insert(membersql)
 702
 703         ActiveRecord::Base.connection.update("UPDATE current_relations SET user_id=#{uid},timestamp=#{db_now} WHERE id=#{relation}")
 704         ActiveRecord::Base.connection.execute("DELETE FROM current_relation_members WHERE id=#{relation} AND member_type='#{type}' AND member_id=#{objid}")
 705 end
 706
 707
 708 def sqlescape(a)
 709   a.gsub(/[\000-\037]/,"").gsub("'","''").gsub(92.chr) {92.chr+92.chr}
 710 end
 711
 712 def tag2array(a)
 713   tags={}
 714   Tags.split(a) do |k, v|
 715     tags[k.gsub(':','|')]=v
 716   end
 717   tags
 718 end
 719
 720 def array2tag(a)
 721   tags = []
 722   a.each do |k,v|
 723     if v=='' then next end
 724     if v[0,6]=='(type ' then next end
 725     tags << [k.gsub('|',':'), v]
 726   end
 727   return Tags.join(tags)
 728 end
 729
 730 def getuserid(token)
 731   if (token =~ /^(.+)\+(.+)$/) then
 732     user = User.authenticate(:username => $1, :password => $2)
 733   else
 734     user = User.authenticate(:token => token)
 735   end
 736
 737   return user ? user.id : nil;
 738 end
 739
 740
 741
 742 # ====================================================================
 743 # AMF read subroutines
 744
 745 # ----- getint          return two-byte integer
 746 # ----- getlong         return four-byte long
 747 # ----- getstring       return string with two-byte length
 748 # ----- getdouble       return eight-byte double-precision float
 749 # ----- getobject       return object/hash
 750 # ----- getarray        return numeric array
 751
 752 def getint(s)
 753   s.getc*256+s.getc
 754 end
 755
 756 def getlong(s)
 757   ((s.getc*256+s.getc)*256+s.getc)*256+s.getc
 758 end
 759
 760 def getstring(s)
 761   len=s.getc*256+s.getc
 762   s.read(len)
 763 end
 764
 765 def getdouble(s)
 766   a=s.read(8).unpack('G')                       # G big-endian, E little-endian
 767   a[0]
 768 end
 769
 770 def getarray(s)
 771   len=getlong(s)
 772   arr=[]
 773   for i in (0..len-1)
 774     arr[i]=getvalue(s)
 775   end
 776   arr
 777 end
 778
 779 def getobject(s)
 780   arr={}
 781   while (key=getstring(s))
 782     if (key=='') then break end
 783     arr[key]=getvalue(s)
 784   end
 785   s.getc                # skip the 9 'end of object' value
 786   arr
 787 end
 788
 789 # ----- getvalue        parse and get value
 790
 791 def getvalue(s)
 792   case s.getc
 793         when 0; return getdouble(s)                     # number
 794         when 1; return s.getc                           # boolean
 795         when 2; return getstring(s)                     # string
 796         when 3; return getobject(s)                     # object/hash
 797         when 5; return nil                                      # null
 798         when 6; return nil                                      # undefined
 799         when 8; s.read(4)                                       # mixedArray
 800                         return getobject(s)                     #  |
 801         when 10;return getarray(s)                      # array
 802         else;   return nil                                      # error
 803   end
 804 end
 805
 806 # ====================================================================
 807 # AMF write subroutines
 808
 809 # ----- putdata         envelope data into AMF writeable form
 810 # ----- encodevalue     pack variables as AMF
 811
 812 def putdata(index,n)
 813   d =encodestring(index+"/onResult")
 814   d+=encodestring("null")
 815   d+=[-1].pack("N")
 816   d+=encodevalue(n)
 817 end
 818
 819 def encodevalue(n)
 820   case n.class.to_s
 821   when 'Array'
 822     a=10.chr+encodelong(n.length)
 823     n.each do |b|
 824       a+=encodevalue(b)
 825     end
 826     a
 827   when 'Hash'
 828     a=3.chr
 829     n.each do |k,v|
 830       a+=encodestring(k)+encodevalue(v)
 831     end
 832     a+0.chr+0.chr+9.chr
 833   when 'String'
 834     2.chr+encodestring(n)
 835   when 'Bignum','Fixnum','Float'
 836     0.chr+encodedouble(n)
 837   when 'NilClass'
 838     5.chr
 839   else
 840     RAILS_DEFAULT_LOGGER.error("Unexpected Ruby type for AMF conversion: "+n.class.to_s)
 841   end
 842 end
 843
 844 # ----- encodestring    encode string with two-byte length
 845 # ----- encodedouble    encode number as eight-byte double precision float
 846 # ----- encodelong              encode number as four-byte long
 847
 848 def encodestring(n)
 849   a,b=n.size.divmod(256)
 850   a.chr+b.chr+n
 851 end
 852
 853 def encodedouble(n)
 854   [n].pack('G')
 855 end
 856
 857 def encodelong(n)
 858   [n].pack('N')
 859 end
 860
 861 # ====================================================================
 862 # Co-ordinate conversion
 863
 864 def lat2coord(a,basey,masterscale)
 865   -(lat2y(a)-basey)*masterscale+250
 866 end
 867
 868 def long2coord(a,baselong,masterscale)
 869   (a-baselong)*masterscale+350
 870 end
 871
 872 def lat2y(a)
 873   180/Math::PI * Math.log(Math.tan(Math::PI/4+a*(Math::PI/180)/2))
 874 end
 875
 876 def coord2lat(a,masterscale,basey)
 877   y2lat((a-250)/-masterscale+basey)
 878 end
 879
 880 def coord2long(a,masterscale,baselong)
 881   (a-350)/masterscale+baselong
 882 end
 883
 884 def y2lat(a)
 885   180/Math::PI * (2*Math.atan(Math.exp(a*Math::PI/180))-Math::PI/2)
 886 end
 887
 888 end