app/controllers/amf_controller.rb

   1 class AmfController < ApplicationController
   2   require 'stringio'
   3
   4   session :off
   5   before_filter :check_availability
   6
   7   # to log:
   8   # RAILS_DEFAULT_LOGGER.error("Args: #{args[0]}, #{args[1]}, #{args[2]}, #{args[3]}")
   9
  10   # ====================================================================
  11   # Main AMF handler
  12
  13   # ---- talk   process AMF request
  14
  15   def talk
  16     req=StringIO.new(request.raw_post)  # Get POST data as request
  17     req.read(2)                                                 # Skip version indicator and client ID
  18     results={}                                                  # Results of each body
  19
  20     # -------------
  21     # Parse request
  22
  23     headers=getint(req)                                 # Read number of headers
  24
  25     headers.times do                                # Read each header
  26       name=getstring(req)                               #  |
  27       req.getc                                  #  | skip boolean
  28       value=getvalue(req)                               #  |
  29       header["name"]=value                              #  |
  30     end
  31
  32     bodies=getint(req)                                  # Read number of bodies
  33     bodies.times do                                     # Read each body
  34       message=getstring(req)                    #  | get message name
  35       index=getstring(req)                              #  | get index in response sequence
  36       bytes=getlong(req)                                #  | get total size in bytes
  37       args=getvalue(req)                                #  | get response (probably an array)
  38
  39       case message
  40                   when 'getpresets';    results[index]=putdata(index,getpresets)
  41                   when 'whichways';             results[index]=putdata(index,whichways(args))
  42                   when 'getway';                results[index]=putdata(index,getway(args))
  43                   when 'putway';                results[index]=putdata(index,putway(args))
  44                   when 'deleteway';             results[index]=putdata(index,deleteway(args))
  45                   when 'makeway';               results[index]=putdata(index,makeway(args))
  46                   when 'putpoi';                results[index]=putdata(index,putpoi(args))
  47                   when 'getpoi';                results[index]=putdata(index,getpoi(args))
  48       end
  49     end
  50
  51     # ------------------
  52     # Write out response
  53
  54     RAILS_DEFAULT_LOGGER.info("  Response: start")
  55     a,b=results.length.divmod(256)
  56         render :content_type => "application/x-amf", :text => proc { |response, output|
  57         output.write 0.chr+0.chr+0.chr+0.chr+a.chr+b.chr
  58                 results.each do |k,v|
  59                   output.write(v)
  60                 end
  61         }
  62     RAILS_DEFAULT_LOGGER.info("  Response: end")
  63
  64   end
  65
  66   private
  67
  68   # ====================================================================
  69   # Remote calls
  70
  71   # ----- getpresets
  72   #           return presets,presetmenus and presetnames arrays
  73
  74   def getpresets
  75     presets={}
  76     presetmenus={}; presetmenus['point']=[]; presetmenus['way']=[]; presetmenus['POI']=[]
  77     presetnames={}; presetnames['point']={}; presetnames['way']={}; presetnames['POI']={}
  78     presettype=''
  79     presetcategory=''
  80
  81     RAILS_DEFAULT_LOGGER.info("  Message: getpresets")
  82
  83     #           File.open("config/potlatch/presets.txt") do |file|
  84
  85     # Temporary patch to get around filepath problem
  86     # To remove this patch and make the code nice again:
  87     # 1. uncomment above line
  88     # 2. fix the path in the above line
  89     # 3. delete this here document, and the following line (StringIO....)
  90
  91     txt=<<-EOF
  92 way/road
  93 motorway: highway=motorway,ref=(type road number)
  94 trunk road: highway=trunk,ref=(type road number),name=(type road name)
  95 primary road: highway=primary,ref=(type road number),name=(type road name)
  96 secondary road: highway=secondary,ref=(type road number),name=(type road name)
  97 residential road: highway=residential,name=(type road name)
  98 unclassified road: highway=unclassified,name=(type road name)
  99
 100 way/footway
 101 footpath: highway=footway,foot=yes
 102 bridleway: highway=bridleway,foot=yes
 103 byway: highway=unsurfaced,foot=yes
 104 permissive path: highway=footway,foot=permissive
 105
 106 way/cycleway
 107 cycle lane: highway=cycleway,cycleway=lane,ncn_ref=
 108 cycle track: highway=cycleway,cycleway=track,ncn_ref=
 109 cycle lane (NCN): highway=cycleway,cycleway=lane,name=(type name here),ncn_ref=(type route number)
 110 cycle track (NCN): highway=cycleway,cycleway=track,name=(type name here),ncn_ref=(type route number)
 111
 112 way/waterway
 113 canal: waterway=canal,name=(type name here)
 114 navigable river: waterway=river,boat=yes,name=(type name here)
 115 navigable drain: waterway=drain,boat=yes,name=(type name here)
 116 derelict canal: waterway=derelict_canal,name=(type name here)
 117 unnavigable river: waterway=river,boat=no,name=(type name here)
 118 unnavigable drain: waterway=drain,boat=no,name=(type name here)
 119
 120 way/railway
 121 railway: railway=rail
 122 tramway: railway=tram
 123 light railway: railway=light_rail
 124 preserved railway: railway=preserved
 125 disused railway tracks: railway=disused
 126 course of old railway: railway=abandoned
 127
 128 way/natural
 129 lake: landuse=water
 130 forest: landuse=forest
 131
 132 point/road
 133 mini roundabout: highway=mini_roundabout
 134 traffic lights: highway=traffic_signals
 135
 136 point/footway
 137 bridge: highway=bridge
 138 gate: highway=gate
 139 stile: highway=stile
 140 cattle grid: highway=cattle_grid
 141
 142 point/cycleway
 143 gate: highway=gate
 144
 145 point/waterway
 146 lock gate: waterway=lock_gate
 147 weir: waterway=weir
 148 aqueduct: waterway=aqueduct
 149 winding hole: waterway=turning_point
 150 mooring: waterway=mooring
 151
 152 point/railway
 153 station: railway=station
 154 viaduct: railway=viaduct
 155 level crossing: railway=crossing
 156
 157 point/natural
 158 peak: point=peak
 159
 160 POI/road
 161 car park: amenity=parking
 162 petrol station: amenity=fuel
 163
 164 POI/place
 165 city: place=city,name=(type name here),is_in=(type region or county)
 166 town: place=town,name=(type name here),is_in=(type region or county)
 167 suburb: place=suburb,name=(type name here),is_in=(type region or county)
 168 village: place=village,name=(type name here),is_in=(type region or county)
 169 hamlet: place=hamlet,name=(type name here),is_in=(type region or county)
 170
 171 POI/tourism
 172 attraction: tourism=attraction,amenity=,religion=,denomination=
 173 church: tourism=,amenity=place_of_worship,name=(type name here),religion=Christian,denomination=(type denomination here)
 174 hotel: tourism=hotel,amenity=,religion=,denomination=
 175 other religious: tourism=,amenity=place_of_worship,name=(type name here),religion=(type religion),denomation=
 176 pub: tourism=,amenity=pub,name=(type name here),religion=,denomination=
 177
 178 POI/natural
 179 peak: point=peak
 180 EOF
 181
 182     StringIO.open(txt) do |file|
 183       file.each_line {|line|
 184         t=line.chomp
 185         if (t=~/(\w+)\/(\w+)/) then
 186           presettype=$1
 187           presetcategory=$2
 188           presetmenus[presettype].push(presetcategory)
 189           presetnames[presettype][presetcategory]=["(no preset)"]
 190         elsif (t=~/^(.+):\s?(.+)$/) then
 191           pre=$1; kv=$2
 192           presetnames[presettype][presetcategory].push(pre)
 193           presets[pre]={}
 194           kv.split(',').each {|a|
 195             if (a=~/^(.+)=(.*)$/) then presets[pre][$1]=$2 end
 196           }
 197         end
 198       }
 199     end
 200     return [presets,presetmenus,presetnames]
 201   end
 202
 203   # ----- whichways(left,bottom,right,top)
 204   #               return array of ways in current bounding box
 205   #               at present, instead of using correct (=more complex) SQL to find
 206   #               corner-crossing ways, it simply enlarges the bounding box by +/- 0.01
 207
 208   def whichways(args)
 209     xmin = args[0].to_f-0.01
 210     ymin = args[1].to_f-0.01
 211     xmax = args[2].to_f+0.01
 212     ymax = args[3].to_f+0.01
 213         baselong    = args[4]
 214         basey       = args[5]
 215         masterscale = args[6]
 216
 217     RAILS_DEFAULT_LOGGER.info("  Message: whichways, bbox=#{xmin},#{ymin},#{xmax},#{ymax}")
 218
 219     waylist=WaySegment.find_by_sql("SELECT DISTINCT current_way_segments.id AS wayid"+
 220        "  FROM current_way_segments,current_segments,current_nodes,current_ways "+
 221        " WHERE segment_id=current_segments.id "+
 222        "   AND current_segments.visible=1 "+
 223        "   AND node_a=current_nodes.id "+
 224            "   AND current_ways.id=current_way_segments.id "+
 225            "   AND current_ways.visible=1 "+
 226        "   AND (latitude  BETWEEN "+ymin.to_s+" AND "+ymax.to_s+") "+
 227        "   AND (longitude BETWEEN "+xmin.to_s+" AND "+xmax.to_s+")")
 228
 229        ways = waylist.collect {|a| a.wayid.to_i } # get an array of way id's
 230
 231        pointlist =ActiveRecord::Base.connection.select_all("SELECT current_nodes.id,latitude,longitude,current_nodes.tags "+
 232        "  FROM current_nodes "+
 233        "  LEFT OUTER JOIN current_segments cs1 ON cs1.node_a=current_nodes.id "+
 234        "  LEFT OUTER JOIN current_segments cs2 ON cs2.node_b=current_nodes.id "+
 235        " WHERE (latitude  BETWEEN "+ymin.to_s+" AND "+ymax.to_s+") "+
 236        "   AND (longitude BETWEEN "+xmin.to_s+" AND "+xmax.to_s+") "+
 237        "   AND cs1.id IS NULL AND cs2.id IS NULL "+
 238        "   AND current_nodes.visible=1")
 239
 240             points = pointlist.collect {|a| [a['id'],long2coord(a['longitude'].to_f,baselong,masterscale),lat2coord(a['latitude'].to_f,basey,masterscale),tag2array(a['tags'])] } # get a list of node ids and their tags
 241
 242     return [ways,points]
 243   end
 244
 245   # ----- getway (objectname, way, baselong, basey, masterscale)
 246   #               returns objectname, array of co-ordinates, attributes,
 247   #                               xmin,xmax,ymin,ymax
 248
 249   def getway(args)
 250     objname,wayid,baselong,basey,masterscale=args
 251     wayid = wayid.to_i
 252     points = []
 253     lastid = -1
 254     xmin = ymin = 999999
 255     xmax = ymax = -999999
 256
 257     RAILS_DEFAULT_LOGGER.info("  Message: getway, id=#{wayid}")
 258
 259     readwayquery(wayid).each {|row|
 260       xs1=long2coord(row['long1'].to_f,baselong,masterscale); ys1=lat2coord(row['lat1'].to_f,basey,masterscale)
 261       xs2=long2coord(row['long2'].to_f,baselong,masterscale); ys2=lat2coord(row['lat2'].to_f,basey,masterscale)
 262       points << [xs1,ys1,row['id1'].to_i,0,tag2array(row['tags1']),0] if (row['id1'].to_i!=lastid)
 263       lastid = row['id2'].to_i
 264       points << [xs2,ys2,row['id2'].to_i,1,tag2array(row['tags2']),row['segment_id'].to_i]
 265       xmin = [xmin,row['long1'].to_f,row['long2'].to_f].min
 266       xmax = [xmax,row['long1'].to_f,row['long2'].to_f].max
 267       ymin = [ymin,row['lat1'].to_f,row['lat2'].to_f].min
 268       ymax = [ymax,row['lat1'].to_f,row['lat2'].to_f].max
 269     }
 270
 271     attributes={}
 272     attrlist=ActiveRecord::Base.connection.select_all "SELECT k,v FROM current_way_tags WHERE id=#{wayid}"
 273     attrlist.each {|a| attributes[a['k']]=a['v'] }
 274
 275     [objname,points,attributes,xmin,xmax,ymin,ymax]
 276   end
 277
 278   # -----       putway (user token, way, array of co-ordinates, array of attributes,
 279   #                                     baselong, basey, masterscale)
 280   #                     returns current way ID, new way ID, hash of renumbered nodes,
 281   #                                     xmin,xmax,ymin,ymax
 282
 283   def putway(args)
 284     usertoken,originalway,points,attributes,baselong,basey,masterscale=args
 285     uid=getuserid(usertoken)
 286     return if !uid
 287     db_uqs='uniq'+uid.to_s+originalway.to_i.abs.to_s+Time.new.to_i.to_s # temp uniquesegments table name, typically 51 chars
 288     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
 289     db_now='@now'+uid.to_s+originalway.to_i.abs.to_s+Time.new.to_i.to_s # 'now' variable name, typically 51 chars
 290     ActiveRecord::Base.connection.execute("SET #{db_now}=NOW()")
 291     originalway=originalway.to_i
 292
 293     RAILS_DEFAULT_LOGGER.info("  Message: putway, id=#{originalway}")
 294
 295     # -- 3.     read original way into memory
 296
 297     xc={}; yc={}; tagc={}; seg={}
 298     if originalway>0
 299       way=originalway
 300       readwayquery(way).each { |row|
 301         id1=row['id1'].to_i; xc[id1]=row['long1'].to_f; yc[id1]=row['lat1'].to_f; tagc[id1]=row['tags1']
 302         id2=row['id2'].to_i; xc[id2]=row['long2'].to_f; yc[id2]=row['lat2'].to_f; tagc[id2]=row['tags2']
 303         seg[row['segment_id'].to_i]=id1.to_s+'-'+id2.to_s
 304       }
 305           ActiveRecord::Base.connection.update("UPDATE current_ways SET timestamp=#{db_now},user_id=#{uid},visible=1 WHERE id=#{way}")
 306     else
 307       way=ActiveRecord::Base.connection.insert("INSERT INTO current_ways (user_id,timestamp,visible) VALUES (#{uid},#{db_now},1)")
 308     end
 309
 310     # -- 4.     get version by inserting new row into ways
 311
 312     version=ActiveRecord::Base.connection.insert("INSERT INTO ways (id,user_id,timestamp,visible) VALUES (#{way},#{uid},#{db_now},1)")
 313
 314     # -- 5. compare nodes and update xmin,xmax,ymin,ymax
 315
 316     xmin = ymin = 999999
 317     xmax = ymax = -999999
 318     insertsql = ''
 319     renumberednodes={}
 320
 321     points.each_index do |i|
 322       xs=coord2long(points[i][0],masterscale,baselong)
 323       ys=coord2lat(points[i][1],masterscale,basey)
 324       xmin=[xs,xmin].min; xmax=[xs,xmax].max
 325       ymin=[ys,ymin].min; ymax=[ys,ymax].max
 326       node=points[i][2].to_i
 327       tagstr=array2tag(points[i][4])
 328           tagstr=tagstr.gsub(/[\000-\037]/,"")
 329       tagsql="'"+sqlescape(tagstr)+"'"
 330
 331       # compare node
 332       if node<0
 333         # new node - create
 334                 if renumberednodes[node.to_s].nil?
 335                         newnode=ActiveRecord::Base.connection.insert("INSERT INTO current_nodes (   latitude,longitude,timestamp,user_id,visible,tags) VALUES (           #{ys},#{xs},#{db_now},#{uid},1,#{tagsql})")
 336                                         ActiveRecord::Base.connection.insert("INSERT INTO nodes         (id,latitude,longitude,timestamp,user_id,visible,tags) VALUES (#{newnode},#{ys},#{xs},#{db_now},#{uid},1,#{tagsql})")
 337                         points[i][2]=newnode
 338                         renumberednodes[node.to_s]=newnode.to_s
 339                 else
 340                         points[i][2]=renumberednodes[node.to_s].to_i
 341                 end
 342
 343       elsif xc.has_key?(node)
 344         # old node from original way - update
 345         if (xs!=xc[node] or (ys/0.0000001).round!=(yc[node]/0.0000001).round or tagstr!=tagc[node])
 346           ActiveRecord::Base.connection.insert("INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tags) VALUES (#{node},#{ys},#{xs},#{db_now},#{uid},1,#{tagsql})")
 347           ActiveRecord::Base.connection.update("UPDATE current_nodes SET latitude=#{ys},longitude=#{xs},timestamp=#{db_now},user_id=#{uid},tags=#{tagsql},visible=1 WHERE id=#{node}")
 348         end
 349       else
 350         # old node, created in another way and now added to this way
 351       end
 352
 353     end
 354
 355
 356     # -- 6.i compare segments
 357
 358     numberedsegments={}
 359     seglist=''                          # list of existing segments that we want to keep
 360     for i in (0..(points.length-2))
 361       if (points[i+1][3].to_i==0) then next end
 362       segid=points[i+1][5].to_i
 363       from =points[i  ][2].to_i
 364       to   =points[i+1][2].to_i
 365       if seg.has_key?(segid)
 366                 # if segment exists, check it still refers to the same nodes
 367         if seg[segid]=="#{from}-#{to}" then
 368           if (seglist!='') then seglist+=',' end; seglist+=segid.to_s
 369           next
 370         end
 371           elsif segid>0
 372                 # not in previous version of way, but supplied, so assume
 373                 # that it's come from makeway (i.e. unwayed segments)
 374                 if (seglist!='') then seglist+=',' end; seglist+=segid.to_s
 375                 next
 376       end
 377       segid=ActiveRecord::Base.connection.insert("INSERT INTO current_segments (   node_a,node_b,timestamp,user_id,visible,tags) VALUES (         #{from},#{to},#{db_now},#{uid},1,'')")
 378                 ActiveRecord::Base.connection.insert("INSERT INTO segments         (id,node_a,node_b,timestamp,user_id,visible,tags) VALUES (#{segid},#{from},#{to},#{db_now},#{uid},1,'')")
 379       points[i+1][5]=segid
 380       numberedsegments[(i+1).to_s]=segid.to_s
 381     end
 382
 383
 384     # -- 6.ii insert new way segments
 385
 386     createuniquesegments(way,db_uqs,seglist)    # segments which appear in this way but no other
 387
 388     #           delete segments from uniquesegments (and not in modified way)
 389
 390     sql=<<-EOF
 391       INSERT INTO segments (id,node_a,node_b,timestamp,user_id,visible)
 392       SELECT DISTINCT segment_id,node_a,node_b,#{db_now},#{uid},0
 393         FROM current_segments AS cs, #{db_uqs} AS us
 394        WHERE cs.id=us.segment_id AND cs.visible=1
 395     EOF
 396     ActiveRecord::Base.connection.insert(sql)
 397
 398     sql=<<-EOF
 399          UPDATE current_segments AS cs, #{db_uqs} AS us
 400           SET cs.timestamp=#{db_now},cs.visible=0,cs.user_id=#{uid}
 401         WHERE cs.id=us.segment_id AND cs.visible=1
 402     EOF
 403     ActiveRecord::Base.connection.update(sql)
 404
 405     #           delete nodes not in modified way or any other segments
 406
 407     createuniquenodes(db_uqs,db_uqn)    # nodes which appear in this way but no other
 408
 409     sql=<<-EOF
 410                 INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible)
 411                 SELECT DISTINCT cn.id,cn.latitude,cn.longitude,#{db_now},#{uid},0
 412                   FROM current_nodes AS cn,#{db_uqn}
 413                  WHERE cn.id=node_id
 414     EOF
 415     ActiveRecord::Base.connection.insert(sql)
 416
 417     sql=<<-EOF
 418       UPDATE current_nodes AS cn, #{db_uqn}
 419          SET cn.timestamp=#{db_now},cn.visible=0,cn.user_id=#{uid}
 420        WHERE cn.id=node_id
 421     EOF
 422     ActiveRecord::Base.connection.update(sql)
 423
 424     ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqs}")
 425     ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqn}")
 426
 427     #           insert new version of route into way_segments
 428
 429     insertsql =''
 430     currentsql=''
 431     sequence  =1
 432     for i in (0..(points.length-2))
 433       if (points[i+1][3].to_i==0) then next end
 434       if insertsql !='' then insertsql +=',' end
 435       if currentsql!='' then currentsql+=',' end
 436       insertsql +="(#{way},#{points[i+1][5]},#{version})"
 437       currentsql+="(#{way},#{points[i+1][5]},#{sequence})"
 438       sequence  +=1
 439     end
 440
 441     ActiveRecord::Base.connection.execute("DELETE FROM current_way_segments WHERE id=#{way}");
 442     ActiveRecord::Base.connection.insert("INSERT INTO         way_segments (id,segment_id,version    ) VALUES #{insertsql}");
 443     ActiveRecord::Base.connection.insert("INSERT INTO current_way_segments (id,segment_id,sequence_id) VALUES #{currentsql}");
 444
 445     # -- 7. insert new way tags
 446
 447     insertsql =''
 448     currentsql=''
 449     attributes.each do |k,v|
 450       if v=='' or v.nil? then next end
 451       if v[0,6]=='(type ' then next end
 452       if insertsql !='' then insertsql +=',' end
 453       if currentsql!='' then currentsql+=',' end
 454           k=k.gsub(/[\000-\037]/,"")
 455           v=v.gsub(/[\000-\037]/,"")
 456       insertsql +="(#{way},'"+sqlescape(k)+"','"+sqlescape(v)+"',#{version})"
 457       currentsql+="(#{way},'"+sqlescape(k)+"','"+sqlescape(v)+"')"
 458     end
 459
 460     ActiveRecord::Base.connection.execute("DELETE FROM current_way_tags WHERE id=#{way}")
 461     if (insertsql !='') then ActiveRecord::Base.connection.insert("INSERT INTO way_tags (id,k,v,version) VALUES #{insertsql}" ) end
 462     if (currentsql!='') then ActiveRecord::Base.connection.insert("INSERT INTO current_way_tags (id,k,v) VALUES #{currentsql}") end
 463
 464     [originalway,way,renumberednodes,numberedsegments,xmin,xmax,ymin,ymax]
 465   end
 466
 467   # -----       putpoi (user token, id, x,y,tag array,visible,baselong,basey,masterscale)
 468   #                     returns current id, new id
 469   #                     if new: add new row to current_nodes and nodes
 470   #                     if old: add new row to nodes, update current_nodes
 471
 472   def putpoi(args)
 473         usertoken,id,x,y,tags,visible,baselong,basey,masterscale=args
 474         uid=getuserid(usertoken)
 475         return if !uid
 476     db_now='@now'+uid.to_s+id.to_i.abs.to_s+Time.new.to_i.to_s  # 'now' variable name, typically 51 chars
 477     ActiveRecord::Base.connection.execute("SET #{db_now}=NOW()")
 478
 479         id=id.to_i
 480         visible=visible.to_i
 481         x=coord2long(x.to_f,masterscale,baselong)
 482         y=coord2lat(y.to_f,masterscale,basey)
 483         tagsql="'"+sqlescape(array2tag(tags))+"'"
 484
 485         if (id>0) then
 486                 ActiveRecord::Base.connection.insert("INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tags) VALUES (#{id},#{y},#{x},#{db_now},#{uid},#{visible},#{tagsql})");
 487                 ActiveRecord::Base.connection.update("UPDATE current_nodes SET latitude=#{y},longitude=#{x},timestamp=#{db_now},user_id=#{uid},visible=#{visible},tags=#{tagsql} WHERE id=#{id}");
 488                 newid=id
 489         else
 490                 newid=ActiveRecord::Base.connection.insert("INSERT INTO current_nodes (latitude,longitude,timestamp,user_id,visible,tags) VALUES (#{y},#{x},#{db_now},#{uid},#{visible},#{tagsql})");
 491                           ActiveRecord::Base.connection.update("INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tags) VALUES (#{newid},#{y},#{x},#{db_now},#{uid},#{visible},#{tagsql})");
 492         end
 493         [id,newid]
 494   end
 495
 496   # -----       getpoi (id,baselong,basey,masterscale)
 497   #                     returns id,x,y,tag array
 498
 499   def getpoi(args)
 500         id,baselong,basey,masterscale=args; id=id.to_i
 501         poi=ActiveRecord::Base.connection.select_one("SELECT latitude,longitude,tags "+
 502                 "FROM current_nodes WHERE visible=1 AND id=#{id}")
 503         if poi.nil? then return [nil,nil,nil,''] end
 504         [id,
 505          long2coord(poi['longitude'].to_f,baselong,masterscale),
 506          lat2coord(poi['latitude'].to_f,basey,masterscale),
 507          tag2array(poi['tags'])]
 508   end
 509
 510   # -----       deleteway (user token, way)
 511   #                     returns way ID only
 512
 513   def deleteway(args)
 514     usertoken,way=args
 515
 516     RAILS_DEFAULT_LOGGER.info("  Message: deleteway, id=#{way}")
 517
 518     uid=getuserid(usertoken); if !uid then return end
 519         way=way.to_i
 520
 521         db_uqs='uniq'+uid.to_s+way.to_i.abs.to_s+Time.new.to_i.to_s     # temp uniquesegments table name, typically 51 chars
 522         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
 523         db_now='@now'+uid.to_s+way.to_i.abs.to_s+Time.new.to_i.to_s     # 'now' variable name, typically 51 chars
 524         ActiveRecord::Base.connection.execute("SET #{db_now}=NOW()")
 525         createuniquesegments(way,db_uqs,'')
 526
 527         # -     delete any otherwise unused segments
 528
 529         sql=<<-EOF
 530       INSERT INTO segments (id,node_a,node_b,timestamp,user_id,visible)
 531       SELECT DISTINCT segment_id,node_a,node_b,#{db_now},#{uid},0
 532         FROM current_segments AS cs, #{db_uqs} AS us
 533        WHERE cs.id=us.segment_id
 534     EOF
 535         ActiveRecord::Base.connection.insert(sql)
 536
 537         sql=<<-EOF
 538       UPDATE current_segments AS cs, #{db_uqs} AS us
 539          SET cs.timestamp=#{db_now},cs.visible=0,cs.user_id=#{uid}
 540        WHERE cs.id=us.segment_id
 541     EOF
 542         ActiveRecord::Base.connection.update(sql)
 543
 544         # - delete any unused nodes
 545
 546     createuniquenodes(db_uqs,db_uqn)
 547
 548         sql=<<-EOF
 549                 INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible)
 550                 SELECT DISTINCT cn.id,cn.latitude,cn.longitude,#{db_now},#{uid},0
 551                   FROM current_nodes AS cn,#{db_uqn}
 552                  WHERE cn.id=node_id
 553     EOF
 554         ActiveRecord::Base.connection.insert(sql)
 555
 556         sql=<<-EOF
 557       UPDATE current_nodes AS cn, #{db_uqn}
 558          SET cn.timestamp=#{db_now},cn.visible=0,cn.user_id=#{uid}
 559        WHERE cn.id=node_id
 560     EOF
 561         ActiveRecord::Base.connection.update(sql)
 562
 563         ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqs}")
 564         ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqn}")
 565
 566         # - delete way
 567
 568         ActiveRecord::Base.connection.insert("INSERT INTO ways (id,user_id,timestamp,visible) VALUES (#{way},#{uid},#{db_now},0)")
 569         ActiveRecord::Base.connection.update("UPDATE current_ways SET user_id=#{uid},timestamp=#{db_now},visible=0 WHERE id=#{way}")
 570         ActiveRecord::Base.connection.execute("DELETE FROM current_way_segments WHERE id=#{way}")
 571         ActiveRecord::Base.connection.execute("DELETE FROM current_way_tags WHERE id=#{way}")
 572
 573         way
 574 end
 575
 576 # ----- makeway(x,y,baselong,basey,masterscale)
 577 #               returns way made from unwayed segments
 578
 579 def makeway(args)
 580         usertoken,x,y,baselong,basey,masterscale=args
 581     uid=getuserid(usertoken)
 582     return if !uid
 583
 584         points=[]
 585         toreverse=[]                            # segments to reverse
 586         nodesused={}                            # so we don't go over the same node twice
 587
 588         # - find start point near x
 589
 590         xc=coord2long(x,masterscale,baselong)
 591         yc=coord2lat(y,masterscale,basey)
 592
 593         RAILS_DEFAULT_LOGGER.info("  Message: makeway, xc=#{xc}, y=#{yc}")
 594
 595         xs1=xc-0.001; xs2=xc+0.001
 596         ys1=yc-0.001; ys2=yc+0.001
 597
 598         sql=<<-EOF
 599                 SELECT cn1.latitude AS lat1,cn1.longitude AS lon1,cn1.id AS id1,
 600                        cn2.latitude AS lat2,cn2.longitude AS lon2,cn2.id AS id2, cs.id AS segid
 601                   FROM current_nodes AS cn1,
 602                        current_nodes AS cn2,
 603                        current_segments AS cs
 604                        LEFT OUTER JOIN current_way_segments ON segment_id=cs.id
 605                  WHERE (cn1.longitude BETWEEN #{xs1} AND #{xs2})
 606                    AND (cn1.latitude  BETWEEN #{ys1} AND #{ys2})
 607                    AND segment_id IS NULL
 608                    AND cs.visible=1
 609                    AND cn1.id=node_a AND cn1.visible=1
 610                    AND cn2.id=node_b AND cn2.visible=1
 611               ORDER BY SQRT(POW(cn1.longitude-#{xc},2)+
 612                                 POW(cn1.latitude -#{yc},2))
 613          LIMIT 1
 614         EOF
 615         row=ActiveRecord::Base.connection.select_one sql
 616         if row.nil? then return [0,0,0,0,0] end
 617         xs1=long2coord(row['lon1'].to_f,baselong,masterscale); ys1=lat2coord(row['lat1'].to_f,basey,masterscale)
 618         xs2=long2coord(row['lon2'].to_f,baselong,masterscale); ys2=lat2coord(row['lat2'].to_f,basey,masterscale)
 619         xmin=[xs1,xs2].min; xmax=[xs1,xs2].max
 620         ymin=[ys1,ys2].min; ymax=[ys1,ys2].max
 621         nodesused[row['id1'].to_i]=true
 622         nodesused[row['id2'].to_i]=true
 623         points<<[xs1,ys1,row['id1'].to_i,1,{},0]
 624         points<<[xs2,ys2,row['id2'].to_i,1,{},row['segid'].to_i]
 625
 626         # - extend at start, then end
 627         while (a,point,nodesused,toreverse=findconnect(points[0][2],nodesused,'b',toreverse,baselong,basey,masterscale))[0]
 628                 points[0][5]=point[5]; point[5]=0       # segment leads to next node
 629                 points.unshift(point)
 630                 xmin=[point[0],xmin].min; xmax=[point[0],xmax].max
 631                 ymin=[point[1],ymin].min; ymax=[point[1],ymax].max
 632         end
 633         while (a,point,nodesused,toreverse=findconnect(points[-1][2],nodesused,'a',toreverse,baselong,basey,masterscale))[0]
 634                 points.push(point)
 635                 xmin=[point[0],xmin].min; xmax=[point[0],xmax].max
 636                 ymin=[point[1],ymin].min; ymax=[point[1],ymax].max
 637         end
 638         points[0][3]=0  # start with a move
 639
 640         # reverse segments in toreverse
 641         if toreverse.length>0
 642                 sql=<<-EOF
 643                         UPDATE current_segments c1, current_segments c2
 644                            SET c1.node_a=c2.node_b,c1.node_b=c2.node_a,
 645                                c1.timestamp=NOW(),c1.user_id=#{uid}
 646                          WHERE c1.id=c2.id
 647                            AND c1.id IN (#{toreverse.join(',')})
 648                 EOF
 649                 ActiveRecord::Base.connection.update sql
 650                 sql=<<-EOF
 651                         INSERT INTO segments
 652                    (SELECT * FROM current_segments
 653                      WHERE id IN (#{toreverse.join(',')}))
 654                 EOF
 655                 ActiveRecord::Base.connection.insert sql
 656         end
 657
 658         [points,xmin,xmax,ymin,ymax]
 659 end
 660
 661 def findconnect(id,nodesused,lookfor,toreverse,baselong,basey,masterscale)
 662         # get all segments with 'id' as a point
 663         # (to look for both node_a and node_b, UNION is faster than node_a=id OR node_b=id)!
 664         sql=<<-EOF
 665                 SELECT cn1.latitude AS lat1,cn1.longitude AS lon1,cn1.id AS id1,
 666                        cn2.latitude AS lat2,cn2.longitude AS lon2,cn2.id AS id2, cs.id AS segid
 667                   FROM current_nodes AS cn1,
 668                        current_nodes AS cn2,
 669                        current_segments AS cs
 670                        LEFT OUTER JOIN current_way_segments ON segment_id=cs.id
 671                  WHERE segment_id IS NULL
 672                    AND cs.visible=1
 673                    AND cn1.id=node_a AND cn1.visible=1
 674                    AND cn2.id=node_b AND cn2.visible=1
 675                    AND node_a=#{id}
 676         UNION
 677                 SELECT cn1.latitude AS lat1,cn1.longitude AS lon1,cn1.id AS id1,
 678                        cn2.latitude AS lat2,cn2.longitude AS lon2,cn2.id AS id2, cs.id AS segid
 679                   FROM current_nodes AS cn1,
 680                        current_nodes AS cn2,
 681                        current_segments AS cs
 682                        LEFT OUTER JOIN current_way_segments ON segment_id=cs.id
 683                  WHERE segment_id IS NULL
 684                    AND cs.visible=1
 685                    AND cn1.id=node_a AND cn1.visible=1
 686                    AND cn2.id=node_b AND cn2.visible=1
 687                    AND node_b=#{id}
 688         EOF
 689         connectlist=ActiveRecord::Base.connection.select_all sql
 690
 691         if lookfor=='b' then tocol='id1'; tolat='lat1'; tolon='lon1'; fromcol='id2'; fromlat='lat2'; fromlon='lon2'
 692                                         else tocol='id2'; tolat='lat2'; tolon='lon2'; fromcol='id1'; fromlat='lat1'; fromlon='lon1'
 693         end
 694
 695         # eliminate those already in the hash
 696         connex=0
 697         point=nil
 698         connectlist.each { |row|
 699                 tonode=row[tocol].to_i
 700                 fromnode=row[fromcol].to_i
 701                 if id==tonode and !nodesused.has_key?(fromnode)
 702                         # wrong way round; add, then add to 'segments to reverse' list
 703                         connex+=1
 704                         nodesused[fromnode]=true
 705                         point=[long2coord(row[fromlon].to_f,baselong,masterscale),lat2coord(row[fromlat].to_f,basey,masterscale),fromnode,1,{},row['segid'].to_i]
 706                         toreverse.push(row['segid'].to_i)
 707                 elsif id==fromnode and !nodesused.has_key?(tonode)
 708                         # right way round; just add
 709                         connex+=1
 710                         point=[long2coord(row[tolon].to_f,baselong,masterscale),lat2coord(row[tolat].to_f,basey,masterscale),tonode,1,{},row['segid'].to_i]
 711                         nodesused[tonode]=true
 712                 end
 713         }
 714
 715         # if only one left, then add it; otherwise return false
 716         if connex!=1 or point.nil? then
 717                 return [false,[],nodesused,toreverse]
 718         else
 719                 return [true,point,nodesused,toreverse]
 720         end
 721 end
 722
 723
 724 # ====================================================================
 725 # Support functions for remote calls
 726
 727 def readwayquery(id)
 728   ActiveRecord::Base.connection.select_all "SELECT n1.latitude AS lat1,n1.longitude AS long1,n1.id AS id1,n1.tags as tags1, "+
 729       "           n2.latitude AS lat2,n2.longitude AS long2,n2.id AS id2,n2.tags as tags2,segment_id "+
 730       "    FROM current_way_segments,current_segments,current_nodes AS n1,current_nodes AS n2 "+
 731       "   WHERE current_way_segments.id=#{id} "+
 732       "     AND segment_id=current_segments.id "+
 733           "     AND current_segments.visible=1 "+
 734       "     AND n1.id=node_a and n2.id=node_b "+
 735       "     AND n1.visible=1 AND n2.visible=1 "+
 736       "   ORDER BY sequence_id"
 737 end
 738
 739 def createuniquesegments(way,uqs_name,seglist)
 740   # Finds segments which appear in (previous version of) this way and no other
 741   sql=<<-EOF
 742       CREATE TEMPORARY TABLE #{uqs_name}
 743               SELECT a.segment_id
 744                 FROM (SELECT DISTINCT segment_id FROM current_way_segments
 745                   WHERE id = #{way}) a
 746              LEFT JOIN current_way_segments b
 747                 ON b.segment_id = a.segment_id
 748                  AND b.id != #{way}
 749                WHERE b.segment_id IS NULL
 750     EOF
 751   if (seglist!='') then sql+=" AND a.segment_id NOT IN (#{seglist})" end
 752   ActiveRecord::Base.connection.execute(sql)
 753 end
 754
 755 def createuniquenodes(uqs_name,uqn_name)
 756         # Finds nodes which appear in uniquesegments but no other segments
 757         sql=<<-EOF
 758         CREATE TEMPORARY TABLE #{uqn_name}
 759            SELECT DISTINCT node_id
 760            FROM (SELECT cn.id AS node_id
 761                  FROM current_nodes AS cn,
 762                       current_segments AS cs,
 763                       #{uqs_name} AS us
 764                  WHERE cs.id=us.segment_id
 765                    AND cn.id=cs.node_a) AS n
 766            LEFT JOIN current_segments AS cs2 ON node_id=cs2.node_a AND cs2.visible=1
 767            LEFT JOIN current_segments AS cs3 ON node_id=cs3.node_b AND cs3.visible=1
 768            WHERE cs2.node_a IS NULL
 769              AND cs3.node_b IS NULL
 770         EOF
 771         ActiveRecord::Base.connection.execute(sql)
 772         sql=<<-EOF
 773         INSERT INTO #{uqn_name}
 774            SELECT DISTINCT node_id
 775            FROM (SELECT cn.id AS node_id
 776                  FROM current_nodes AS cn,
 777                       current_segments AS cs,
 778                       #{uqs_name} AS us
 779                  WHERE cs.id=us.segment_id
 780                    AND cn.id=cs.node_b) AS n
 781            LEFT JOIN current_segments AS cs2 ON node_id=cs2.node_a AND cs2.visible=1
 782            LEFT JOIN current_segments AS cs3 ON node_id=cs3.node_b AND cs3.visible=1
 783            WHERE cs2.node_a IS NULL
 784              AND cs3.node_b IS NULL
 785         EOF
 786         ActiveRecord::Base.connection.execute(sql)
 787 end
 788
 789 def sqlescape(a)
 790   a.gsub("'","''").gsub(92.chr,92.chr+92.chr)
 791 end
 792
 793 def tag2array(a)
 794   tags={}
 795   a.gsub(';;;','#%').split(';').each do |b|
 796     b.gsub!('#%',';;;')
 797     b.gsub!('===','#%')
 798     k,v=b.split('=')
 799     if k.nil? then k='' end
 800     if v.nil? then v='' end
 801     tags[k.gsub('#%','=')]=v.gsub('#%','=')
 802   end
 803   tags
 804 end
 805
 806 def array2tag(a)
 807   str=''
 808   a.each do |k,v|
 809     if v=='' then next end
 810     if v[0,6]=='(type ' then next end
 811     if str!='' then str+=';' end
 812     str+=k.gsub(';',';;;').gsub('=','===')+'='+v.gsub(';',';;;').gsub('=','===')
 813   end
 814   str
 815 end
 816
 817 def getuserid(token)
 818   if (token =~ /^(.+)\+(.+)$/) then
 819     user = User.authenticate(:username => $1, :password => $2)
 820   else
 821     user = User.authenticate(:token => token)
 822   end
 823
 824   return user ? user.id : nil;
 825 end
 826
 827
 828
 829 # ====================================================================
 830 # AMF read subroutines
 831
 832 # ----- getint          return two-byte integer
 833 # ----- getlong         return four-byte long
 834 # ----- getstring       return string with two-byte length
 835 # ----- getdouble       return eight-byte double-precision float
 836 # ----- getobject       return object/hash
 837 # ----- getarray        return numeric array
 838
 839 def getint(s)
 840   s.getc*256+s.getc
 841 end
 842
 843 def getlong(s)
 844   ((s.getc*256+s.getc)*256+s.getc)*256+s.getc
 845 end
 846
 847 def getstring(s)
 848   len=s.getc*256+s.getc
 849   s.read(len)
 850 end
 851
 852 def getdouble(s)
 853   a=s.read(8).unpack('G')                       # G big-endian, E little-endian
 854   a[0]
 855 end
 856
 857 def getarray(s)
 858   len=getlong(s)
 859   arr=[]
 860   for i in (0..len-1)
 861     arr[i]=getvalue(s)
 862   end
 863   arr
 864 end
 865
 866 def getobject(s)
 867   arr={}
 868   while (key=getstring(s))
 869     if (key=='') then break end
 870     arr[key]=getvalue(s)
 871   end
 872   s.getc                # skip the 9 'end of object' value
 873   arr
 874 end
 875
 876 # ----- getvalue        parse and get value
 877
 878 def getvalue(s)
 879   case s.getc
 880   when 0;       return getdouble(s)                     # number
 881   when 1;       return s.getc                           # boolean
 882   when 2;       return getstring(s)                     # string
 883   when 3;       return getobject(s)                     # object/hash
 884   when 5;       return nil                                      # null
 885   when 6;       return nil                                      # undefined
 886   when 8;       s.read(4)                                       # mixedArray
 887                     return getobject(s)                 #  |
 888   when 10;      return getarray(s)                      # array
 889   else;         return nil                                      # error
 890   end
 891 end
 892
 893 # ====================================================================
 894 # AMF write subroutines
 895
 896 # ----- putdata         envelope data into AMF writeable form
 897 # ----- encodevalue     pack variables as AMF
 898
 899 def putdata(index,n)
 900   d =encodestring(index+"/onResult")
 901   d+=encodestring("null")
 902   d+=[-1].pack("N")
 903   d+=encodevalue(n)
 904 end
 905
 906 def encodevalue(n)
 907   case n.class.to_s
 908   when 'Array'
 909     a=10.chr+encodelong(n.length)
 910     n.each do |b|
 911       a+=encodevalue(b)
 912     end
 913     a
 914   when 'Hash'
 915     a=3.chr
 916     n.each do |k,v|
 917       a+=encodestring(k)+encodevalue(v)
 918     end
 919     a+0.chr+0.chr+9.chr
 920   when 'String'
 921     2.chr+encodestring(n)
 922   when 'Bignum','Fixnum','Float'
 923     0.chr+encodedouble(n)
 924   when 'NilClass'
 925     5.chr
 926   else
 927     RAILS_DEFAULT_LOGGER.error("Unexpected Ruby type for AMF conversion: "+n.class.to_s)
 928   end
 929 end
 930
 931 # ----- encodestring    encode string with two-byte length
 932 # ----- encodedouble    encode number as eight-byte double precision float
 933 # ----- encodelong              encode number as four-byte long
 934
 935 def encodestring(n)
 936   a,b=n.size.divmod(256)
 937   a.chr+b.chr+n
 938 end
 939
 940 def encodedouble(n)
 941   [n].pack('G')
 942 end
 943
 944 def encodelong(n)
 945   [n].pack('N')
 946 end
 947
 948 # ====================================================================
 949 # Co-ordinate conversion
 950
 951 def lat2coord(a,basey,masterscale)
 952   -(lat2y(a)-basey)*masterscale+250
 953 end
 954
 955 def long2coord(a,baselong,masterscale)
 956   (a-baselong)*masterscale+350
 957 end
 958
 959 def lat2y(a)
 960   180/Math::PI * Math.log(Math.tan(Math::PI/4+a*(Math::PI/180)/2))
 961 end
 962
 963 def coord2lat(a,masterscale,basey)
 964   y2lat((a-250)/-masterscale+basey)
 965 end
 966
 967 def coord2long(a,masterscale,baselong)
 968   (a-350)/masterscale+baselong
 969 end
 970
 971 def y2lat(a)
 972   180/Math::PI * (2*Math.atan(Math.exp(a*Math::PI/180))-Math::PI/2)
 973 end
 974
 975 end