app/controllers/amf_controller.rb

   1 # amf_controller is a semi-standalone API for Flash clients, particularly
   2 # Potlatch. All interaction between Potlatch (as a .SWF application) and the
   3 # OSM database takes place using this controller. Messages are
   4 # encoded in the Actionscript Message Format (AMF).
   5 #
   6 # Helper functions are in /lib/potlatch.
   7 #
   8 # Author::      editions Systeme D / Richard Fairhurst 2004-2008
   9 # Licence::     public domain.
  10 #
  11 # == General structure
  12 #
  13 # Apart from the amf_read and amf_write methods (which distribute the requests
  14 # from the AMF message), each method generally takes arguments in the order
  15 # they were sent by the Potlatch SWF. Do not assume typing has been preserved.
  16 # Methods all return an array to the SWF.
  17 #
  18 # == API 0.6
  19 #
  20 # Note that this requires a patched version of composite_primary_keys 1.1.0
  21 # (see http://groups.google.com/group/compositekeys/t/a00e7562b677e193)
  22 # if you are to run with POTLATCH_USE_SQL=false .
  23 #
  24 # == Debugging
  25 #
  26 # Any method that returns a status code (0 for ok) can also send:
  27 #       return(-1,"message")            <-- just puts up a dialogue
  28 #       return(-2,"message")            <-- also asks the user to e-mail me
  29 #
  30 # To write to the Rails log, use RAILS_DEFAULT_LOGGER.info("message").
  31
  32 class AmfController < ApplicationController
  33   require 'stringio'
  34
  35   include Potlatch
  36
  37   # Help methods for checking boundary sanity and area size
  38   include MapBoundary
  39
  40   session :off
  41   before_filter :check_write_availability
  42
  43   # Main AMF handlers: process the raw AMF string (using AMF library) and
  44   # calls each action (private method) accordingly.
  45   # ** FIXME: refactor to reduce duplication of code across read/write
  46
  47   def amf_read
  48         req=StringIO.new(request.raw_post+0.chr)# Get POST data as request
  49                                                                                         # (cf http://www.ruby-forum.com/topic/122163)
  50         req.read(2)                                                             # Skip version indicator and client ID
  51         results={}                                                              # Results of each body
  52
  53         # Parse request
  54
  55         headers=AMF.getint(req)                                 # Read number of headers
  56
  57         headers.times do                                                # Read each header
  58           name=AMF.getstring(req)                               #  |
  59           req.getc                                                              #  | skip boolean
  60           value=AMF.getvalue(req)                               #  |
  61           header["name"]=value                                  #  |
  62         end
  63
  64         bodies=AMF.getint(req)                                  # Read number of bodies
  65         bodies.times do                                                 # Read each body
  66           message=AMF.getstring(req)                    #  | get message name
  67           index=AMF.getstring(req)                              #  | get index in response sequence
  68           bytes=AMF.getlong(req)                                #  | get total size in bytes
  69           args=AMF.getvalue(req)                                #  | get response (probably an array)
  70       logger.info "Executing AMF #{message}:#{index}"
  71
  72           case message
  73                 when 'getpresets';                      results[index]=AMF.putdata(index,getpresets())
  74                 when 'whichways';                       results[index]=AMF.putdata(index,whichways(*args))
  75                 when 'whichways_deleted';       results[index]=AMF.putdata(index,whichways_deleted(*args))
  76                 when 'getway';                          results[index]=AMF.putdata(index,getway(args[0].to_i))
  77                 when 'getrelation';                     results[index]=AMF.putdata(index,getrelation(args[0].to_i))
  78                 when 'getway_old';                      results[index]=AMF.putdata(index,getway_old(args[0].to_i,args[1].to_i))
  79                 when 'getway_history';          results[index]=AMF.putdata(index,getway_history(args[0].to_i))
  80                 when 'getnode_history';         results[index]=AMF.putdata(index,getnode_history(args[0].to_i))
  81                 when 'findgpx';                         results[index]=AMF.putdata(index,findgpx(*args))
  82                 when 'findrelations';           results[index]=AMF.putdata(index,findrelations(*args))
  83                 when 'getpoi';                          results[index]=AMF.putdata(index,getpoi(*args))
  84           end
  85         end
  86     logger.info("encoding AMF results")
  87     sendresponse(results)
  88   end
  89
  90   def amf_write
  91         req=StringIO.new(request.raw_post+0.chr)
  92         req.read(2)
  93         results={}
  94         renumberednodes={}                                              # Shared across repeated putways
  95         renumberedways={}                                               # Shared across repeated putways
  96
  97         headers=AMF.getint(req)                                 # Read number of headers
  98         headers.times do                                                # Read each header
  99           name=AMF.getstring(req)                               #  |
 100           req.getc                                                              #  | skip boolean
 101           value=AMF.getvalue(req)                               #  |
 102           header["name"]=value                                  #  |
 103         end
 104
 105         bodies=AMF.getint(req)                                  # Read number of bodies
 106         bodies.times do                                                 # Read each body
 107           message=AMF.getstring(req)                    #  | get message name
 108           index=AMF.getstring(req)                              #  | get index in response sequence
 109           bytes=AMF.getlong(req)                                #  | get total size in bytes
 110           args=AMF.getvalue(req)                                #  | get response (probably an array)
 111
 112           case message
 113                 when 'putway';                          r=putway(renumberednodes,*args)
 114                                                                         renumberednodes=r[3]
 115                                                                         if r[1] != r[2]
 116                                                                           renumberedways[r[1]] = r[2]
 117                                                                         end
 118                                                                         results[index]=AMF.putdata(index,r)
 119                 when 'putrelation';                     results[index]=AMF.putdata(index,putrelation(renumberednodes, renumberedways, *args))
 120                 when 'deleteway';                       results[index]=AMF.putdata(index,deleteway(*args))
 121                 when 'putpoi';                          results[index]=AMF.putdata(index,putpoi(*args))
 122                 when 'startchangeset';          results[index]=AMF.putdata(index,startchangeset(*args))
 123           end
 124         end
 125     sendresponse(results)
 126   end
 127
 128   private
 129
 130   # Start new changeset
 131
 132   def startchangeset(usertoken, cstags, closeid, closecomment)
 133         uid = getuserid(usertoken)
 134         if !uid then return -1,"You are not logged in, so Potlatch can't write any changes to the database." end
 135
 136         # close previous changeset and add comment
 137         if closeid
 138           cs = Changeset.find(closeid)
 139           cs.open = false
 140           if closecomment.empty?
 141                 cs.save!
 142           else
 143             cs.tags['comment']=closecomment
 144             cs.save_with_tags!
 145           end
 146         end
 147
 148         # open a new changeset
 149         cs = Changeset.new
 150         cs.tags = cstags
 151         cs.user_id = uid
 152         cs.created_at = Time.now
 153         cs.save_with_tags!
 154         return [0,cs.id]
 155   end
 156
 157   # Return presets (default tags, localisation etc.):
 158   # uses POTLATCH_PRESETS global, set up in OSM::Potlatch.
 159
 160   def getpresets() #:doc:
 161         return POTLATCH_PRESETS
 162   end
 163
 164   # Find all the ways, POI nodes (i.e. not part of ways), and relations
 165   # in a given bounding box. Nodes are returned in full; ways and relations
 166   # are IDs only.
 167
 168   def whichways(xmin, ymin, xmax, ymax) #:doc:
 169         xmin -= 0.01; ymin -= 0.01
 170         xmax += 0.01; ymax += 0.01
 171
 172     # check boundary is sane and area within defined
 173     # see /config/application.yml
 174     begin
 175       check_boundaries(xmin, ymin, xmax, ymax)
 176     rescue Exception => err
 177       return [-2,"Sorry - I can't get the map for that area."]
 178     end
 179
 180         if POTLATCH_USE_SQL then
 181           ways = sql_find_ways_in_area(xmin, ymin, xmax, ymax)
 182           points = sql_find_pois_in_area(xmin, ymin, xmax, ymax)
 183           relations = sql_find_relations_in_area_and_ways(xmin, ymin, xmax, ymax, ways.collect {|x| x[0]})
 184         else
 185           # find the way ids in an area
 186           nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => ["current_nodes.visible = ?", true], :include => :ways)
 187           ways = nodes_in_area.collect { |node|
 188                 node.ways.collect { |w| [w.id,w.version] }.flatten
 189           }.uniq
 190           ways.delete([])
 191
 192           # find the node ids in an area that aren't part of ways
 193           nodes_not_used_in_area = nodes_in_area.select { |node| node.ways.empty? }
 194           points = nodes_not_used_in_area.collect { |n| [n.id, n.lon, n.lat, n.tags] }
 195
 196           # find the relations used by those nodes and ways
 197           relations = Relation.find_for_nodes(nodes_in_area.collect { |n| n.id }, :conditions => {:visible => true}) +
 198                   Relation.find_for_ways(ways.collect { |w| w[0] }, :conditions => {:visible => true})
 199           relations = relations.collect { |relation| [relation.id,relation.version] }.uniq
 200         end
 201
 202         [0,ways, points, relations]
 203   end
 204
 205   # Find deleted ways in current bounding box (similar to whichways, but ways
 206   # with a deleted node only - not POIs or relations).
 207
 208   def whichways_deleted(xmin, ymin, xmax, ymax) #:doc:
 209         xmin -= 0.01; ymin -= 0.01
 210         xmax += 0.01; ymax += 0.01
 211
 212     # check boundary is sane and area within defined
 213     # see /config/application.yml
 214     begin
 215       check_boundaries(xmin, ymin, xmax, ymax)
 216     rescue Exception => err
 217       return [-2,"Sorry - I can't get the map for that area."]
 218     end
 219
 220         nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => ["current_ways.visible = ?", false], :include => :ways_via_history)
 221         way_ids = nodes_in_area.collect { |node| node.ways_via_history_ids }.flatten.uniq
 222
 223         [0,way_ids]
 224   end
 225
 226   # Get a way including nodes and tags.
 227   # Returns the way id, a Potlatch-style array of points, a hash of tags, and the version number.
 228
 229   def getway(wayid) #:doc:
 230         if POTLATCH_USE_SQL then
 231           points = sql_get_nodes_in_way(wayid)
 232           tags = sql_get_tags_in_way(wayid)
 233           version = sql_get_way_version(wayid)
 234         else
 235           # Ideally we would do ":include => :nodes" here but if we do that
 236           # then rails only seems to return the first copy of a node when a
 237           # way includes a node more than once
 238       begin
 239             way = Way.find(wayid)
 240       rescue ActiveRecord::RecordNotFound
 241         return [wayid,[],{}]
 242       end
 243
 244       # check case where way has been deleted or doesn't exist
 245       return [wayid,[],{}] if way.nil? or !way.visible
 246
 247           points = way.nodes.collect do |node|
 248                 nodetags=node.tags
 249                 nodetags.delete('created_by')
 250                 [node.lon, node.lat, node.id, nodetags]
 251           end
 252           tags = way.tags
 253           version = way.version
 254         end
 255
 256         [wayid, points, tags, version]
 257   end
 258
 259   # Get an old version of a way, and all constituent nodes.
 260   #
 261   # For undelete (version<0), always uses the most recent version of each node,
 262   # even if it's moved.  For revert (version >= 0), uses the node in existence
 263   # at the time, generating a new id if it's still visible and has been moved/
 264   # retagged.
 265   #
 266   # Returns:
 267   # 0. success code,
 268   # 1. id,
 269   # 2. array of points,
 270   # 3. hash of tags,
 271   # 4. version,
 272   # 5. is this the current, visible version? (boolean)
 273
 274   def getway_old(id, version) #:doc:
 275         if version < 0
 276           old_way = OldWay.find(:first, :conditions => ['visible = ? AND id = ?', true, id], :order => 'version DESC')
 277           points = old_way.get_nodes_undelete unless old_way.nil?
 278         else
 279           old_way = OldWay.find(:first, :conditions => ['id = ? AND version = ?', id, version])
 280           points = old_way.get_nodes_revert unless old_way.nil?
 281         end
 282
 283     if old_way.nil?
 284       return [-1, id, [], {}, -1,0]
 285     else
 286           curway=Way.find(id)
 287           old_way.tags['history'] = "Retrieved from v#{old_way.version}"
 288           return [0, id, points, old_way.tags, old_way.version, (curway.version==old_way.version and curway.visible)]
 289     end
 290   end
 291
 292   # Find history of a way. Returns 'way', id, and
 293   # an array of previous versions.
 294
 295   def getway_history(wayid) #:doc:
 296     begin
 297           history = Way.find(wayid).old_ways.reverse.collect do |old_way|
 298         user_object = old_way.changeset.user
 299             user = user_object.data_public? ? user_object.display_name : 'anonymous'
 300             uid  = user_object.data_public? ? user_object.id : 0
 301             [old_way.version, old_way.timestamp.strftime("%d %b %Y, %H:%M"), old_way.visible ? 1 : 0, user, uid]
 302           end
 303
 304           return ['way',wayid,history]
 305     rescue ActiveRecord::RecordNotFound
 306       return ['way', wayid, []]
 307     end
 308   end
 309
 310   # Find history of a node. Returns 'node', id, and
 311   # an array of previous versions.
 312
 313   def getnode_history(nodeid) #:doc:
 314     begin
 315           history = Node.find(nodeid).old_nodes.reverse.collect do |old_node|
 316         user_object = old_node.changeset.user
 317             user = user_object.data_public? ? user_object.display_name : 'anonymous'
 318             uid  = user_object.data_public? ? user_object.id : 0
 319             [old_node.version, old_node.timestamp.strftime("%d %b %Y, %H:%M"), old_node.visible ? 1 : 0, user, uid]
 320           end
 321
 322           return ['node',nodeid,history]
 323     rescue ActiveRecord::RecordNotFound
 324       return ['node', nodeid, []]
 325     end
 326   end
 327
 328   # Find GPS traces with specified name/id.
 329   # Returns array listing GPXs, each one comprising id, name and description.
 330
 331   def findgpx(searchterm, usertoken)
 332         uid = getuserid(usertoken)
 333         if !uid then return -1,"You must be logged in to search for GPX traces." end
 334
 335         gpxs = []
 336         if searchterm.to_i>0 then
 337           gpx = Trace.find(searchterm.to_i, :conditions => ["visible=? AND (public=? OR user_id=?)",true,true,uid] )
 338           if gpx then
 339             gpxs.push([gpx.id, gpx.name, gpx.description])
 340           end
 341         else
 342           Trace.find(:all, :limit => 21, :conditions => ["visible=? AND (public=? OR user_id=?) AND MATCH(name) AGAINST (?)",true,true,uid,searchterm] ).each do |gpx|
 343                 gpxs.push([gpx.id, gpx.name, gpx.description])
 344           end
 345         end
 346         gpxs
 347   end
 348
 349   # Get a relation with all tags and members.
 350   # Returns:
 351   # 0. relation id,
 352   # 1. hash of tags,
 353   # 2. list of members,
 354   # 3. version.
 355
 356   def getrelation(relid) #:doc:
 357     begin
 358           rel = Relation.find(relid)
 359     rescue ActiveRecord::RecordNotFound
 360       return [relid, {}, []]
 361     end
 362
 363     return [relid, {}, [], nil] if rel.nil? or !rel.visible
 364         [relid, rel.tags, rel.members, rel.version]
 365   end
 366
 367   # Find relations with specified name/id.
 368   # Returns array of relations, each in same form as getrelation.
 369
 370   def findrelations(searchterm)
 371         rels = []
 372         if searchterm.to_i>0 then
 373           rel = Relation.find(searchterm.to_i)
 374           if rel and rel.visible then
 375             rels.push([rel.id, rel.tags, rel.members])
 376           end
 377         else
 378           RelationTag.find(:all, :limit => 11, :conditions => ["match(v) against (?)", searchterm] ).each do |t|
 379                 if t.relation.visible then
 380               rels.push([t.relation.id, t.relation.tags, t.relation.members])
 381             end
 382           end
 383         end
 384         rels
 385   end
 386
 387   # Save a relation.
 388   # Returns
 389   # 0. 0 (success),
 390   # 1. original relation id (unchanged),
 391   # 2. new relation id.
 392
 393   def putrelation(renumberednodes, renumberedways, usertoken, changeset, relid, tags, members, visible) #:doc:
 394         uid = getuserid(usertoken)
 395         if !uid then return -1,"You are not logged in, so the relation could not be saved." end
 396
 397         relid = relid.to_i
 398         visible = (visible.to_i != 0)
 399
 400         # create a new relation, or find the existing one
 401         if relid <= 0
 402           rel = Relation.new
 403           rel.version = 0
 404         else
 405           rel = Relation.find(relid)
 406         end
 407
 408         # check the members are all positive, and correctly type
 409         typedmembers = []
 410         members.each do |m|
 411           mid = m[1].to_i
 412           if mid < 0
 413                 mid = renumberednodes[mid] if m[0] == 'node'
 414                 mid = renumberedways[mid] if m[0] == 'way'
 415           end
 416       if mid
 417             typedmembers << [m[0], mid, m[2]]
 418           end
 419         end
 420
 421         # assign new contents
 422         rel.members = typedmembers
 423         rel.tags = tags
 424         rel.visible = visible
 425         rel.changeset_id = changeset
 426
 427         # check it then save it
 428         # BUG: the following is commented out because it always fails on my
 429         #  install. I think it's a Rails bug.
 430
 431         #if !rel.preconditions_ok?
 432         #  return -2, "Relation preconditions failed"
 433         #else
 434           rel.save_with_history!
 435         #end
 436
 437         [0, relid, rel.id]
 438   end
 439
 440   # Save a way to the database, including all nodes. Any nodes in the previous
 441   # version and no longer used are deleted.
 442   #
 443   # Returns:
 444   # 0. '0' (code for success),
 445   # 1. original way id (unchanged),
 446   # 2. new way id,
 447   # 3. hash of renumbered nodes (old id=>new id),
 448   # 4. version
 449
 450   def putway(renumberednodes, usertoken, changeset, originalway, points, attributes) #:doc:
 451
 452         # -- Initialise and carry out checks
 453
 454         uid = getuserid(usertoken)
 455         if !uid then return -1,"You are not logged in, so the way could not be saved." end
 456
 457         originalway = originalway.to_i
 458
 459         points.each do |a|
 460           if a[2] == 0 or a[2].nil? then return -2,"Server error - node with id 0 found in way #{originalway}." end
 461           if a[1] == 90 then return -2,"Server error - node with lat -90 found in way #{originalway}." end
 462         end
 463
 464         if points.length < 2 then return -2,"Server error - way is only #{points.length} points long." end
 465
 466         # -- Get unique nodes
 467
 468         if originalway < 0
 469           way = Way.new
 470           way.version = 0       # otherwise +=1 breaks
 471           uniques = []
 472         else
 473           way = Way.find(originalway)
 474           uniques = way.unshared_node_ids
 475         end
 476
 477         # -- Compare nodes and save changes to any that have changed
 478
 479         nodes = []
 480
 481         points.each do |n|
 482           lon = n[0].to_f
 483           lat = n[1].to_f
 484           id = n[2].to_i
 485           savenode = false
 486
 487           if renumberednodes[id]
 488             id = renumberednodes[id]
 489           elsif id < 0
 490                 # Create new node
 491                 node = Node.new
 492                 node.version = 0        # otherwise +=1 breaks
 493                 savenode = true
 494           else
 495                 node = Node.find(id)
 496                 nodetags=node.tags
 497                 nodetags.delete('created_by')
 498                 if !fpcomp(lat, node.lat) or !fpcomp(lon, node.lon) or
 499                    n[4] != nodetags or !node.visible?
 500                   savenode = true
 501                 end
 502           end
 503
 504           if savenode
 505                 node.changeset_id = changeset
 506             node.lat = lat
 507         node.lon = lon
 508             node.tags = n[4]
 509             node.visible = true
 510             node.save_with_history!
 511
 512                 if id != node.id
 513                   renumberednodes[id] = node.id
 514                   id = node.id
 515             end
 516           end
 517
 518           uniques = uniques - [id]
 519           nodes.push(id)
 520         end
 521
 522         # -- Delete any unique nodes
 523
 524         uniques.each do |n|
 525           deleteitemrelations(n, 'node')
 526
 527           node = Node.find(n)
 528           node.changeset_id = changeset
 529           node.visible = false
 530           node.save_with_history!
 531         end
 532
 533         # -- Save revised way
 534
 535         if way.tags!=attributes or way.nds!=nodes or !way.visible?
 536           way.tags = attributes
 537           way.nds = nodes
 538           way.changeset_id = changeset
 539           way.visible = true
 540           way.save_with_history!
 541         end
 542
 543         [0, originalway, way.id, renumberednodes, way.version]
 544   end
 545
 546   # Save POI to the database.
 547   # Refuses save if the node has since become part of a way.
 548   # Returns:
 549   # 0. 0 (success),
 550   # 1. original node id (unchanged),
 551   # 2. new node id,
 552   # 3. version.
 553
 554   def putpoi(usertoken, changeset, id, lon, lat, tags, visible) #:doc:
 555         uid = getuserid(usertoken)
 556         if !uid then return -1,"You are not logged in, so the point could not be saved." end
 557
 558         id = id.to_i
 559         visible = (visible.to_i == 1)
 560
 561         if id > 0 then
 562           node = Node.find(id)
 563
 564           if !visible then
 565             unless node.ways.empty? then return -1,"The point has since become part of a way, so you cannot save it as a POI." end
 566             deleteitemrelations(id, 'node')
 567           end
 568         else
 569           node = Node.new
 570           node.version = 0
 571         end
 572
 573         node.changeset_id = changeset
 574         node.lat = lat
 575         node.lon = lon
 576         node.tags = tags
 577         node.visible = visible
 578         node.save_with_history!
 579
 580         [0, id, node.id, node.version]
 581   end
 582
 583   # Read POI from database
 584   # (only called on revert: POIs are usually read by whichways).
 585   #
 586   # Returns array of id, long, lat, hash of tags, version.
 587
 588   def getpoi(id,version) #:doc:
 589         if version>0 then
 590           n = OldNode.find(id, :conditions=>['version=?',version])
 591         else
 592           n = Node.find(id)
 593         end
 594
 595         if n
 596           return [n.id, n.lon, n.lat, n.tags, n.version]
 597         else
 598           return [nil, nil, nil, {}, nil]
 599         end
 600   end
 601
 602   # Delete way and all constituent nodes. Also removes from any relations.
 603   # Returns 0 (success), unchanged way id.
 604
 605   def deleteway(usertoken, changeset_id, way_id) #:doc:
 606         if !getuserid(usertoken) then return -1,"You are not logged in, so the way could not be deleted." end
 607
 608         way_id = way_id.to_i
 609
 610         # FIXME: would be good not to make two history entries when removing
 611         #                two nodes from the same relation
 612         way = Way.find(way_id)
 613         way.unshared_node_ids.each do |n|
 614           deleteitemrelations(n, 'node')
 615         end
 616         deleteitemrelations(way_id, 'way')
 617
 618         way.delete_with_relations_and_nodes_and_history(changeset_id.to_i)
 619
 620         [0, way_id]
 621   end
 622
 623
 624   # ====================================================================
 625   # Support functions
 626
 627   # Remove a node or way from all relations
 628
 629   def deleteitemrelations(objid, type) #:doc:
 630         relations = RelationMember.find(:all,
 631                                                                         :conditions => ['member_type = ? and member_id = ?', type, objid],
 632                                                                         :include => :relation).collect { |rm| rm.relation }.uniq
 633
 634         relations.each do |rel|
 635           rel.members.delete_if { |x| x[0] == type and x[1] == objid }
 636           rel.save_with_history!
 637         end
 638   end
 639
 640   # Break out node tags into a hash
 641   # (should become obsolete as of API 0.6)
 642
 643   def tagstring_to_hash(a) #:doc:
 644         tags={}
 645         Tags.split(a) do |k, v|
 646           tags[k]=v
 647         end
 648         tags
 649   end
 650
 651   # Authenticate token
 652   # (can also be of form user:pass)
 653
 654   def getuserid(token) #:doc:
 655         if (token =~ /^(.+)\:(.+)$/) then
 656           user = User.authenticate(:username => $1, :password => $2)
 657         else
 658           user = User.authenticate(:token => token)
 659         end
 660
 661         return user ? user.id : nil;
 662   end
 663
 664   # Compare two floating-point numbers to within 0.0000001
 665
 666   def fpcomp(a,b) #:doc:
 667         return ((a/0.0000001).round==(b/0.0000001).round)
 668   end
 669
 670   # Send AMF response
 671
 672   def sendresponse(results)
 673         a,b=results.length.divmod(256)
 674         render :content_type => "application/x-amf", :text => proc { |response, output|
 675           # ** move amf writing loop into here -
 676           # basically we read the messages in first (into an array of some sort),
 677           # then iterate through that array within here, and do all the AMF writing
 678           output.write 0.chr+0.chr+0.chr+0.chr+a.chr+b.chr
 679           results.each do |k,v|
 680                 output.write(v)
 681           end
 682         }
 683   end
 684
 685
 686   # ====================================================================
 687   # Alternative SQL queries for getway/whichways
 688
 689   def sql_find_ways_in_area(xmin,ymin,xmax,ymax)
 690         sql=<<-EOF
 691   SELECT DISTINCT current_ways.id AS wayid,current_ways.version AS version
 692                 FROM current_way_nodes
 693   INNER JOIN current_nodes ON current_nodes.id=current_way_nodes.node_id
 694   INNER JOIN current_ways  ON current_ways.id =current_way_nodes.id
 695            WHERE current_nodes.visible=TRUE
 696                  AND current_ways.visible=TRUE
 697                  AND #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")}
 698         EOF
 699         return ActiveRecord::Base.connection.select_all(sql).collect { |a| [a['wayid'].to_i,a['version'].to_i] }
 700   end
 701
 702   def sql_find_pois_in_area(xmin,ymin,xmax,ymax)
 703         pois=[]
 704         sql=<<-EOF
 705                   SELECT current_nodes.id,current_nodes.latitude*0.0000001 AS lat,current_nodes.longitude*0.0000001 AS lon,current_nodes.version
 706                         FROM current_nodes
 707  LEFT OUTER JOIN current_way_nodes cwn ON cwn.node_id=current_nodes.id
 708                    WHERE current_nodes.visible=TRUE
 709                          AND cwn.id IS NULL
 710                          AND #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")}
 711         EOF
 712         ActiveRecord::Base.connection.select_all(sql).each do |row|
 713           poitags={}
 714           ActiveRecord::Base.connection.select_all("SELECT k,v FROM current_node_tags WHERE id=#{row['id']}").each do |n|
 715                 poitags[n['k']]=n['v']
 716           end
 717           pois << [row['id'].to_i, row['lon'].to_f, row['lat'].to_f, poitags, row['version'].to_i]
 718         end
 719         pois
 720   end
 721
 722   def sql_find_relations_in_area_and_ways(xmin,ymin,xmax,ymax,way_ids)
 723         # ** It would be more Potlatchy to get relations for nodes within ways
 724         #    during 'getway', not here
 725         sql=<<-EOF
 726           SELECT DISTINCT cr.id AS relid,cr.version AS version
 727                 FROM current_relations cr
 728   INNER JOIN current_relation_members crm ON crm.id=cr.id
 729   INNER JOIN current_nodes cn ON crm.member_id=cn.id AND crm.member_type='node'
 730            WHERE #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "cn.")}
 731         EOF
 732         unless way_ids.empty?
 733           sql+=<<-EOF
 734            UNION
 735           SELECT DISTINCT cr.id AS relid,cr.version AS version
 736                 FROM current_relations cr
 737   INNER JOIN current_relation_members crm ON crm.id=cr.id
 738            WHERE crm.member_type='way'
 739                  AND crm.member_id IN (#{way_ids.join(',')})
 740           EOF
 741         end
 742         return ActiveRecord::Base.connection.select_all(sql).collect { |a| [a['relid'].to_i,a['version'].to_i] }
 743   end
 744
 745   def sql_get_nodes_in_way(wayid)
 746         points=[]
 747         sql=<<-EOF
 748                 SELECT latitude*0.0000001 AS lat,longitude*0.0000001 AS lon,current_nodes.id
 749                   FROM current_way_nodes,current_nodes
 750                  WHERE current_way_nodes.id=#{wayid.to_i}
 751                    AND current_way_nodes.node_id=current_nodes.id
 752                    AND current_nodes.visible=TRUE
 753           ORDER BY sequence_id
 754           EOF
 755         ActiveRecord::Base.connection.select_all(sql).each do |row|
 756           nodetags={}
 757           ActiveRecord::Base.connection.select_all("SELECT k,v FROM current_node_tags WHERE id=#{row['id']}").each do |n|
 758                 nodetags[n['k']]=n['v']
 759           end
 760           nodetags.delete('created_by')
 761           points << [row['lon'].to_f,row['lat'].to_f,row['id'].to_i,nodetags]
 762         end
 763         points
 764   end
 765
 766   def sql_get_tags_in_way(wayid)
 767         tags={}
 768         ActiveRecord::Base.connection.select_all("SELECT k,v FROM current_way_tags WHERE id=#{wayid.to_i}").each do |row|
 769           tags[row['k']]=row['v']
 770         end
 771         tags
 772   end
 773
 774   def sql_get_way_version(wayid)
 775     ActiveRecord::Base.connection.select_one("SELECT version FROM current_ways WHERE id=#{wayid.to_i}")
 776   end
 777 end
 778
 779 # Local Variables:
 780 # indent-tabs-mode: t
 781 # tab-width: 4
 782 # End: