X-Git-Url: https://git.openstreetmap.org/rails.git/blobdiff_plain/b03a3f8889d6f752881a24cd23e010a9ced89efc..ba6b3f355a6cfcb2f3d2c9a0d912ec6249264988:/app/controllers/amf_controller.rb

diff --git a/app/controllers/amf_controller.rb b/app/controllers/amf_controller.rb
index b91052266..8132b5311 100644
--- a/app/controllers/amf_controller.rb
+++ b/app/controllers/amf_controller.rb
@@ -1,6 +1,9 @@
 class AmfController < ApplicationController
   require 'stringio'
 
+  session :off
+  before_filter :check_write_availability
+
   # to log:
   # RAILS_DEFAULT_LOGGER.error("Args: #{args[0]}, #{args[1]}, #{args[2]}, #{args[3]}")
 
@@ -33,27 +36,30 @@ class AmfController < ApplicationController
       bytes=getlong(req)				#  | get total size in bytes
       args=getvalue(req)				#  | get response (probably an array)
 
-      ActiveRecord::Base.logger.info("  Message: #{message}")
-
       case message
-      when 'getpresets';	results[index]=putdata(index,getpresets)
-      when 'whichways';		results[index]=putdata(index,whichways(args))
-      when 'getway';		results[index]=putdata(index,getway(args))
-      when 'putway';		results[index]=putdata(index,putway(args))
-      when 'deleteway';		results[index]=putdata(index,deleteway(args))
+		  when 'getpresets';	results[index]=putdata(index,getpresets)
+		  when 'whichways';		results[index]=putdata(index,whichways(args))
+		  when 'getway';		results[index]=putdata(index,getway(args))
+		  when 'putway';		results[index]=putdata(index,putway(args))
+		  when 'deleteway';		results[index]=putdata(index,deleteway(args))
+		  when 'makeway';		results[index]=putdata(index,makeway(args))
+		  when 'putpoi';		results[index]=putdata(index,putpoi(args))
+		  when 'getpoi';		results[index]=putdata(index,getpoi(args))
       end
     end
 
     # ------------------
     # Write out response
 
-    response.headers["Content-Type"]="application/x-amf"
+    RAILS_DEFAULT_LOGGER.info("  Response: start")
     a,b=results.length.divmod(256)
-    ans=0.chr+0.chr+0.chr+0.chr+a.chr+b.chr
-    results.each do |k,v|
-      ans+=v
-    end
-    render :text => ans
+	render :content_type => "application/x-amf", :text => proc { |response, output| 
+        output.write 0.chr+0.chr+0.chr+0.chr+a.chr+b.chr
+		results.each do |k,v|
+		  output.write(v)
+		end
+	}
+    RAILS_DEFAULT_LOGGER.info("  Response: end")
 
   end
 
@@ -62,16 +68,18 @@ class AmfController < ApplicationController
   # ====================================================================
   # Remote calls
 
-  # -----	getpresets
-  #		return presets,presetmenus and presetnames arrays
+  # ----- getpresets
+  #	      return presets,presetmenus and presetnames arrays
 
   def getpresets
     presets={}
-    presetmenus={}; presetmenus['point']=[]; presetmenus['way']=[]
-    presetnames={}; presetnames['point']={}; presetnames['way']={}
+    presetmenus={}; presetmenus['point']=[]; presetmenus['way']=[]; presetmenus['POI']=[]
+    presetnames={}; presetnames['point']={}; presetnames['way']={}; presetnames['POI']={}
     presettype=''
     presetcategory=''
 
+    RAILS_DEFAULT_LOGGER.info("  Message: getpresets")
+
     #		File.open("config/potlatch/presets.txt") do |file|
 
     # Temporary patch to get around filepath problem
@@ -91,8 +99,8 @@ unclassified road: highway=unclassified,name=(type road name)
 
 way/footway
 footpath: highway=footway,foot=yes
-bridleway: highway=bridleway,foot=yes,horse=yes,bicycle=yes
-byway: highway=byway,foot=yes,horse=yes,bicycle=yes,motorcar=yes
+bridleway: highway=bridleway,foot=yes
+byway: highway=unsurfaced,foot=yes
 permissive path: highway=footway,foot=permissive
 
 way/cycleway
@@ -117,6 +125,10 @@ preserved railway: railway=preserved
 disused railway tracks: railway=disused
 course of old railway: railway=abandoned
 
+way/natural
+lake: landuse=water
+forest: landuse=forest
+
 point/road
 mini roundabout: highway=mini_roundabout
 traffic lights: highway=traffic_signals
@@ -141,6 +153,35 @@ point/railway
 station: railway=station
 viaduct: railway=viaduct
 level crossing: railway=crossing
+
+point/natural
+peak: point=peak
+
+POI/road
+car park: amenity=parking
+petrol station: amenity=fuel
+
+POI/cycleway
+bike park: amenity=bicycle_parking
+
+POI/place
+city: place=city,name=(type name here),is_in=(type region or county)
+town: place=town,name=(type name here),is_in=(type region or county)
+suburb: place=suburb,name=(type name here),is_in=(type region or county)
+village: place=village,name=(type name here),is_in=(type region or county)
+hamlet: place=hamlet,name=(type name here),is_in=(type region or county)
+
+POI/tourism
+attraction: tourism=attraction,amenity=,religion=,denomination=
+church: tourism=,amenity=place_of_worship,name=(type name here),religion=christian,denomination=(type denomination here)
+hotel: tourism=hotel,amenity=,religion=,denomination=
+other religious: tourism=,amenity=place_of_worship,name=(type name here),religion=(type religion),denomination=
+post box: amenity=post_box,tourism=,name=,religion=,denomination=
+post office: amenity=post_office,tourism=,name=,religion=,denomination=
+pub: tourism=,amenity=pub,name=(type name here),religion=,denomination=
+
+POI/natural
+peak: point=peak
 EOF
 
     StringIO.open(txt) do |file|
@@ -164,48 +205,49 @@ EOF
     return [presets,presetmenus,presetnames]
   end
 
-  # -----	whichways(left,bottom,right,top)
-  #		return array of ways in current bounding box
-  #		at present, instead of using correct (=more complex) SQL to find
-  #		corner-crossing ways, it simply enlarges the bounding box by +/- 0.01
+  # ----- whichways(left,bottom,right,top)
+  #		  return array of ways in current bounding box
+  #		  at present, instead of using correct (=more complex) SQL to find
+  #		  corner-crossing ways, it simply enlarges the bounding box by +/- 0.01
 
   def whichways(args)
     xmin = args[0].to_f-0.01
     ymin = args[1].to_f-0.01
-    xmax = args[2].to+f-0.01
-    ymax = args[3].to+f-0.01
+    xmax = args[2].to_f+0.01
+    ymax = args[3].to_f+0.01
+    baselong    = args[4]
+    basey       = args[5]
+    masterscale = args[6]
 
-    ActiveRecord::Base.logger.info("  Bounding Box: #{xmin},#{ymin},#{xmax},#{ymax}")
+    RAILS_DEFAULT_LOGGER.info("  Message: whichways, bbox=#{xmin},#{ymin},#{xmax},#{ymax}")
 
-    waylist=WaySegment.find_by_sql("SELECT DISTINCT current_way_segments.id AS wayid"+
+    waylist = WaySegment.find_by_sql("SELECT DISTINCT current_way_segments.id AS wayid"+
        "  FROM current_way_segments,current_segments,current_nodes,current_ways "+
        " WHERE segment_id=current_segments.id "+
        "   AND current_segments.visible=1 "+
        "   AND node_a=current_nodes.id "+
-	   "   AND current_ways.id=current_way_segments.id "+
-	   "   AND current_ways.visible=1 "+
-       "   AND (latitude  BETWEEN "+ymin.to_s+" AND "+ymax.to_s+") "+
-       "   AND (longitude BETWEEN "+xmin.to_s+" AND "+xmax.to_s+")")
+       "   AND current_ways.id=current_way_segments.id "+
+       "   AND current_ways.visible=1 "+
+       "   AND "+OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes."))
 
-       ways = waylist.collect {|a| a.wayid.to_i } # get an array of way id's
+    ways = waylist.collect {|a| a.wayid.to_i } # get an array of way id's
 
-       pointlist =ActiveRecord::Base.connection.select_all("SELECT current_nodes.id,current_nodes.tags "+
+    pointlist = ActiveRecord::Base.connection.select_all("SELECT current_nodes.id,current_nodes.latitude*0.0000001 AS lat,current_nodes.longitude*0.0000001 AS lng,current_nodes.tags "+
        "  FROM current_nodes "+
        "  LEFT OUTER JOIN current_segments cs1 ON cs1.node_a=current_nodes.id "+
        "  LEFT OUTER JOIN current_segments cs2 ON cs2.node_b=current_nodes.id "+
-       " WHERE (latitude  BETWEEN "+ymin.to_s+" AND "+ymax.to_s+") "+
-       "   AND (longitude BETWEEN "+xmin.to_s+" AND "+xmax.to_s+") "+
+       " WHERE "+OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")+
        "   AND cs1.id IS NULL AND cs2.id IS NULL "+
        "   AND current_nodes.visible=1")
 
-	    points = pointlist.collect {|a| [a['id'],tag2array(a['tags'])]	} # get a list of node ids and their tags
+    points = pointlist.collect {|a| [a['id'],long2coord(a['lng'].to_f,baselong,masterscale),lat2coord(a['lat'].to_f,basey,masterscale),tag2array(a['tags'])]	} # get a list of node ids and their tags
 
     return [ways,points]
   end
 
-  # -----	getway (objectname, way, baselong, basey, masterscale)
-  #			returns objectname, array of co-ordinates, attributes,
-  #					xmin,xmax,ymin,ymax
+  # ----- getway (objectname, way, baselong, basey, masterscale)
+  #		  returns objectname, array of co-ordinates, attributes,
+  #				  xmin,xmax,ymin,ymax
 
   def getway(args)
     objname,wayid,baselong,basey,masterscale=args
@@ -215,6 +257,8 @@ EOF
     xmin = ymin = 999999
     xmax = ymax = -999999
 
+    RAILS_DEFAULT_LOGGER.info("  Message: getway, id=#{wayid}")
+
     readwayquery(wayid).each {|row|
       xs1=long2coord(row['long1'].to_f,baselong,masterscale); ys1=lat2coord(row['lat1'].to_f,basey,masterscale)
       xs2=long2coord(row['long2'].to_f,baselong,masterscale); ys2=lat2coord(row['lat2'].to_f,basey,masterscale)
@@ -249,6 +293,8 @@ EOF
     ActiveRecord::Base.connection.execute("SET #{db_now}=NOW()")
     originalway=originalway.to_i
 
+    RAILS_DEFAULT_LOGGER.info("  Message: putway, id=#{originalway}")
+
     # -- 3.	read original way into memory
 
     xc={}; yc={}; tagc={}; seg={}
@@ -259,7 +305,7 @@ EOF
         id2=row['id2'].to_i; xc[id2]=row['long2'].to_f; yc[id2]=row['lat2'].to_f; tagc[id2]=row['tags2']
         seg[row['segment_id'].to_i]=id1.to_s+'-'+id2.to_s
       }
-	  ActiveRecord::Base.connection.update("UPDATE current_ways SET timestamp=#{db_now},user_id=#{uid},visible=1 WHERE id=#{way}")
+      ActiveRecord::Base.connection.update("UPDATE current_ways SET timestamp=#{db_now},user_id=#{uid},visible=1 WHERE id=#{way}")
     else
       way=ActiveRecord::Base.connection.insert("INSERT INTO current_ways (user_id,timestamp,visible) VALUES (#{uid},#{db_now},1)")
     end
@@ -282,26 +328,33 @@ EOF
       ymin=[ys,ymin].min; ymax=[ys,ymax].max
       node=points[i][2].to_i
       tagstr=array2tag(points[i][4])
+      tagstr=tagstr.gsub(/[\000-\037]/,"")
       tagsql="'"+sqlescape(tagstr)+"'"
+      lat=(ys * 10000000).round
+      long=(xs * 10000000).round
+      tile=QuadTile.tile_for_point(ys, xs)
 
       # compare node
       if node<0
         # new node - create
-        newnode=ActiveRecord::Base.connection.insert("INSERT INTO current_nodes (   latitude,longitude,timestamp,user_id,visible,tags) VALUES (           #{ys},#{xs},#{db_now},#{uid},1,#{tagsql})")
-        		ActiveRecord::Base.connection.insert("INSERT INTO nodes         (id,latitude,longitude,timestamp,user_id,visible,tags) VALUES (#{newnode},#{ys},#{xs},#{db_now},#{uid},1,#{tagsql})")
-        points[i][2]=newnode
-        renumberednodes[node.to_s]=newnode.to_s
+	if renumberednodes[node.to_s].nil?
+          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})")
+                  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})")
+          points[i][2]=newnode
+          renumberednodes[node.to_s]=newnode.to_s
+	else
+          points[i][2]=renumberednodes[node.to_s].to_i
+	end
 
       elsif xc.has_key?(node)
         # old node from original way - update
-        if (xs!=xc[node] or (ys/0.0000001).round!=(yc[node]/0.0000001).round or tagstr!=tagc[node])
-          ActiveRecord::Base.connection.insert("INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tags) VALUES (#{node},#{ys},#{xs},#{db_now},#{uid},1,#{tagsql})")
-          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}")
+        if (xs!=xc[node] or ys!=yc[node] or tagstr!=tagc[node])
+          ActiveRecord::Base.connection.insert("INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tags,tile) VALUES (#{node},#{lat},#{long},#{db_now},#{uid},1,#{tagsql},#{tile})")
+          ActiveRecord::Base.connection.update("UPDATE current_nodes SET latitude=#{lat},longitude=#{long},timestamp=#{db_now},user_id=#{uid},tags=#{tagsql},visible=1,tile=#{tile} WHERE id=#{node}")
         end
       else
         # old node, created in another way and now added to this way
       end
-
     end
 
 
@@ -315,17 +368,22 @@ EOF
       from =points[i  ][2].to_i
       to   =points[i+1][2].to_i
       if seg.has_key?(segid)
+	# if segment exists, check it still refers to the same nodes
         if seg[segid]=="#{from}-#{to}" then 
           if (seglist!='') then seglist+=',' end; seglist+=segid.to_s
           next
         end
+      elsif segid>0
+        # not in previous version of way, but supplied, so assume
+        # that it's come from makeway (i.e. unwayed segments)
+        if (seglist!='') then seglist+=',' end; seglist+=segid.to_s
+        next
       end
       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,'')")
-      		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,'')")
+            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,'')")
       points[i+1][5]=segid
       numberedsegments[(i+1).to_s]=segid.to_s
     end
-    # numberedsegments.each{|a,b| RAILS_DEFAULT_LOGGER.error("Sending back: seg no. #{a} -> id #{b}") }
 
 
     # -- 6.ii insert new way segments
@@ -354,10 +412,10 @@ EOF
     createuniquenodes(db_uqs,db_uqn)	# nodes which appear in this way but no other
 
     sql=<<-EOF
-		INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible)  
-		SELECT DISTINCT cn.id,cn.latitude,cn.longitude,#{db_now},#{uid},0 
-		  FROM current_nodes AS cn,#{db_uqn}
-		 WHERE cn.id=node_id
+	INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tile)  
+	SELECT DISTINCT cn.id,cn.latitude,cn.longitude,#{db_now},#{uid},0,cn.tile
+	  FROM current_nodes AS cn,#{db_uqn}
+	 WHERE cn.id=node_id
     EOF
     ActiveRecord::Base.connection.insert(sql)
 
@@ -394,10 +452,12 @@ EOF
     insertsql =''
     currentsql=''
     attributes.each do |k,v|
-      if v=='' then next end
+      if v=='' or v.nil? then next end
       if v[0,6]=='(type ' then next end
       if insertsql !='' then insertsql +=',' end
       if currentsql!='' then currentsql+=',' end
+	  k=k.gsub(/[\000-\037]/,"")
+	  v=v.gsub(/[\000-\037]/,"")
       insertsql +="(#{way},'"+sqlescape(k)+"','"+sqlescape(v)+"',#{version})"
       currentsql+="(#{way},'"+sqlescape(k)+"','"+sqlescape(v)+"')"
     end
@@ -409,80 +469,276 @@ EOF
     [originalway,way,renumberednodes,numberedsegments,xmin,xmax,ymin,ymax]
   end
 
+  # -----	putpoi (user token, id, x,y,tag array,visible,baselong,basey,masterscale)
+  #			returns current id, new id
+  #			if new: add new row to current_nodes and nodes
+  #			if old: add new row to nodes, update current_nodes
+
+  def putpoi(args)
+    usertoken,id,x,y,tags,visible,baselong,basey,masterscale=args
+    uid=getuserid(usertoken)
+    return if !uid
+    db_now='@now'+uid.to_s+id.to_i.abs.to_s+Time.new.to_i.to_s	# 'now' variable name, typically 51 chars
+    ActiveRecord::Base.connection.execute("SET #{db_now}=NOW()")
+
+    id=id.to_i
+    visible=visible.to_i
+    x=coord2long(x.to_f,masterscale,baselong)
+    y=coord2lat(y.to_f,masterscale,basey)
+    tagsql="'"+sqlescape(array2tag(tags))+"'"
+    lat=(y * 10000000).round
+    long=(x * 10000000).round
+    tile=QuadTile.tile_for_point(y, x)
+	
+    if (id>0) then
+        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})");
+        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}");
+        newid=id
+    else
+        newid=ActiveRecord::Base.connection.insert("INSERT INTO current_nodes (latitude,longitude,timestamp,user_id,visible,tags,tile) VALUES (#{lat},#{long},#{db_now},#{uid},#{visible},#{tagsql},#{tile})");
+              ActiveRecord::Base.connection.update("INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tags,tile) VALUES (#{newid},#{lat},#{long},#{db_now},#{uid},#{visible},#{tagsql},#{tile})");
+    end
+    [id,newid]
+  end
+
+  # -----	getpoi (id,baselong,basey,masterscale)
+  #			returns id,x,y,tag array
+  
+  def getpoi(args)
+	id,baselong,basey,masterscale=args; id=id.to_i
+	poi=ActiveRecord::Base.connection.select_one("SELECT latitude*0.0000001 AS lat,longitude*0.0000001 AS lng,tags "+
+		"FROM current_nodes WHERE visible=1 AND id=#{id}")
+	if poi.nil? then return [nil,nil,nil,''] end
+	[id,
+	 long2coord(poi['lng'].to_f,baselong,masterscale),
+	 lat2coord(poi['lat'].to_f,basey,masterscale),
+	 tag2array(poi['tags'])]
+  end
+
   # -----	deleteway (user token, way)
   #			returns way ID only
 
   def deleteway(args)
     usertoken,way=args
+
+    RAILS_DEFAULT_LOGGER.info("  Message: deleteway, id=#{way}")
+
     uid=getuserid(usertoken); if !uid then return end
-	way=way.to_i
+    way=way.to_i
 
-	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
-	db_uqn='unin'+uid.to_s+way.to_i.abs.to_s+Time.new.to_i.to_s	# temp uniquenodes table name, typically 51 chars
-	db_now='@now'+uid.to_s+way.to_i.abs.to_s+Time.new.to_i.to_s	# 'now' variable name, typically 51 chars
-	ActiveRecord::Base.connection.execute("SET #{db_now}=NOW()")
-	createuniquesegments(way,db_uqs,'')
+    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
+    db_uqn='unin'+uid.to_s+way.to_i.abs.to_s+Time.new.to_i.to_s	# temp uniquenodes table name, typically 51 chars
+    db_now='@now'+uid.to_s+way.to_i.abs.to_s+Time.new.to_i.to_s	# 'now' variable name, typically 51 chars
+    ActiveRecord::Base.connection.execute("SET #{db_now}=NOW()")
+    createuniquesegments(way,db_uqs,'')
 
-	# -	delete any otherwise unused segments
+    # -	delete any otherwise unused segments
 
-	sql=<<-EOF
+    sql=<<-EOF
       INSERT INTO segments (id,node_a,node_b,timestamp,user_id,visible) 
       SELECT DISTINCT segment_id,node_a,node_b,#{db_now},#{uid},0 
         FROM current_segments AS cs, #{db_uqs} AS us
        WHERE cs.id=us.segment_id
     EOF
-	ActiveRecord::Base.connection.insert(sql)
+    ActiveRecord::Base.connection.insert(sql)
 
-	sql=<<-EOF
+    sql=<<-EOF
       UPDATE current_segments AS cs, #{db_uqs} AS us
          SET cs.timestamp=#{db_now},cs.visible=0,cs.user_id=#{uid} 
        WHERE cs.id=us.segment_id
     EOF
-	ActiveRecord::Base.connection.update(sql)
+    ActiveRecord::Base.connection.update(sql)
 
-	# - delete any unused nodes
+    # - delete any unused nodes
   
     createuniquenodes(db_uqs,db_uqn)
 
-	sql=<<-EOF
-		INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible)  
-		SELECT DISTINCT cn.id,cn.latitude,cn.longitude,#{db_now},#{uid},0 
-		  FROM current_nodes AS cn,#{db_uqn}
-		 WHERE cn.id=node_id
+    sql=<<-EOF
+	INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tile)
+	SELECT DISTINCT cn.id,cn.latitude,cn.longitude,#{db_now},#{uid},0,cn.tile
+	  FROM current_nodes AS cn,#{db_uqn}
+	 WHERE cn.id=node_id
     EOF
-	ActiveRecord::Base.connection.insert(sql)
+    ActiveRecord::Base.connection.insert(sql)
 
-	sql=<<-EOF
+    sql=<<-EOF
       UPDATE current_nodes AS cn, #{db_uqn}
          SET cn.timestamp=#{db_now},cn.visible=0,cn.user_id=#{uid} 
        WHERE cn.id=node_id
     EOF
-	ActiveRecord::Base.connection.update(sql)
+    ActiveRecord::Base.connection.update(sql)
 	
-	ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqs}")
-	ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqn}")
+    ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqs}")
+    ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqn}")
 
-	# - delete way
+    # - delete way
 	
-	ActiveRecord::Base.connection.insert("INSERT INTO ways (id,user_id,timestamp,visible) VALUES (#{way},#{uid},#{db_now},0)")
-	ActiveRecord::Base.connection.update("UPDATE current_ways SET user_id=#{uid},timestamp=#{db_now},visible=0 WHERE id=#{way}")
-	ActiveRecord::Base.connection.execute("DELETE FROM current_way_segments WHERE id=#{way}")
-	ActiveRecord::Base.connection.execute("DELETE FROM current_way_tags WHERE id=#{way}")
+    ActiveRecord::Base.connection.insert("INSERT INTO ways (id,user_id,timestamp,visible) VALUES (#{way},#{uid},#{db_now},0)")
+    ActiveRecord::Base.connection.update("UPDATE current_ways SET user_id=#{uid},timestamp=#{db_now},visible=0 WHERE id=#{way}")
+    ActiveRecord::Base.connection.execute("DELETE FROM current_way_segments WHERE id=#{way}")
+    ActiveRecord::Base.connection.execute("DELETE FROM current_way_tags WHERE id=#{way}")
 	
-	way
+    way
 end
 
+# ----- makeway(x,y,baselong,basey,masterscale)
+#		returns way made from unwayed segments
+
+def makeway(args)
+	usertoken,x,y,baselong,basey,masterscale=args
+    uid=getuserid(usertoken)
+    return if !uid
+
+	points=[]
+	toreverse=[]				# segments to reverse
+	nodesused={}				# so we don't go over the same node twice
+
+	# - find start point near x
+	
+	xc=coord2long(x,masterscale,baselong)
+	yc=coord2lat(y,masterscale,basey)
+
+        RAILS_DEFAULT_LOGGER.info("  Message: makeway, xc=#{xc}, y=#{yc}")
+
+	xs1=xc-0.001; xs2=xc+0.001
+	ys1=yc-0.001; ys2=yc+0.001
+	
+	sql=<<-EOF
+		SELECT cn1.latitude*0.0000001 AS lat1,cn1.longitude*0.0000001 AS lon1,cn1.id AS id1,
+		       cn2.latitude*0.0000001 AS lat2,cn2.longitude*0.0000001 AS lon2,cn2.id AS id2, cs.id AS segid
+		  FROM current_nodes AS cn1,
+		       current_nodes AS cn2,
+		       current_segments AS cs 
+		       LEFT OUTER JOIN current_way_segments ON segment_id=cs.id 
+		 WHERE #{OSM.sql_for_area(ys1,xs1,ys2,xs2,"cn1.")}
+		   AND segment_id IS NULL 
+                   AND cs.visible=1
+		   AND cn1.id=node_a AND cn1.visible=1 
+		   AND cn2.id=node_b AND cn2.visible=1 
+	      ORDER BY SQRT(POW(cn1.longitude-#{xc},2)+
+      				POW(cn1.latitude -#{yc},2)) 
+      	 LIMIT 1
+	EOF
+	row=ActiveRecord::Base.connection.select_one sql
+	if row.nil? then return [0,0,0,0,0] end
+	xs1=long2coord(row['lon1'].to_f,baselong,masterscale); ys1=lat2coord(row['lat1'].to_f,basey,masterscale)
+	xs2=long2coord(row['lon2'].to_f,baselong,masterscale); ys2=lat2coord(row['lat2'].to_f,basey,masterscale)
+	xmin=[xs1,xs2].min; xmax=[xs1,xs2].max
+	ymin=[ys1,ys2].min; ymax=[ys1,ys2].max
+	nodesused[row['id1'].to_i]=true
+	nodesused[row['id2'].to_i]=true
+	points<<[xs1,ys1,row['id1'].to_i,1,{},0]
+	points<<[xs2,ys2,row['id2'].to_i,1,{},row['segid'].to_i]
+	
+	# - extend at start, then end
+	while (a,point,nodesused,toreverse=findconnect(points[0][2],nodesused,'b',toreverse,baselong,basey,masterscale))[0]
+		points[0][5]=point[5]; point[5]=0	# segment leads to next node
+		points.unshift(point)
+		xmin=[point[0],xmin].min; xmax=[point[0],xmax].max
+		ymin=[point[1],ymin].min; ymax=[point[1],ymax].max
+	end
+	while (a,point,nodesused,toreverse=findconnect(points[-1][2],nodesused,'a',toreverse,baselong,basey,masterscale))[0]
+		points.push(point)
+		xmin=[point[0],xmin].min; xmax=[point[0],xmax].max
+		ymin=[point[1],ymin].min; ymax=[point[1],ymax].max
+	end
+	points[0][3]=0	# start with a move
+
+	# reverse segments in toreverse
+	if toreverse.length>0
+		sql=<<-EOF
+			UPDATE current_segments c1, current_segments c2 
+			   SET c1.node_a=c2.node_b,c1.node_b=c2.node_a,
+			       c1.timestamp=NOW(),c1.user_id=#{uid} 
+			 WHERE c1.id=c2.id 
+			   AND c1.id IN (#{toreverse.join(',')})
+		EOF
+		ActiveRecord::Base.connection.update sql
+		sql=<<-EOF
+			INSERT INTO segments 
+		   (SELECT * FROM current_segments 
+		     WHERE id IN (#{toreverse.join(',')}))
+		EOF
+		ActiveRecord::Base.connection.insert sql
+	end
+
+	[points,xmin,xmax,ymin,ymax]
+end
+
+def findconnect(id,nodesused,lookfor,toreverse,baselong,basey,masterscale)
+	# get all segments with 'id' as a point
+	# (to look for both node_a and node_b, UNION is faster than node_a=id OR node_b=id)!
+	sql=<<-EOF
+		SELECT cn1.latitude*0.0000001 AS lat1,cn1.longitude*0.0000001 AS lon1,cn1.id AS id1,
+		       cn2.latitude*0.0000001 AS lat2,cn2.longitude*0.0000001 AS lon2,cn2.id AS id2, cs.id AS segid
+		  FROM current_nodes AS cn1,
+		       current_nodes AS cn2,
+		       current_segments AS cs 
+		       LEFT OUTER JOIN current_way_segments ON segment_id=cs.id 
+		 WHERE segment_id IS NULL 
+                   AND cs.visible=1
+		   AND cn1.id=node_a AND cn1.visible=1 
+		   AND cn2.id=node_b AND cn2.visible=1 
+		   AND node_a=#{id}
+	UNION
+		SELECT cn1.latitude*0.0000001 AS lat1,cn1.longitude*0.0000001 AS lon1,cn1.id AS id1,
+		       cn2.latitude*0.0000001 AS lat2,cn2.longitude*0.0000001 AS lon2,cn2.id AS id2, cs.id AS segid
+		  FROM current_nodes AS cn1,
+		       current_nodes AS cn2,
+		       current_segments AS cs 
+		       LEFT OUTER JOIN current_way_segments ON segment_id=cs.id 
+		 WHERE segment_id IS NULL 
+                   AND cs.visible=1
+		   AND cn1.id=node_a AND cn1.visible=1 
+		   AND cn2.id=node_b AND cn2.visible=1 
+		   AND node_b=#{id}
+	EOF
+	connectlist=ActiveRecord::Base.connection.select_all sql
+	
+	if lookfor=='b' then tocol='id1'; tolat='lat1'; tolon='lon1'; fromcol='id2'; fromlat='lat2'; fromlon='lon2'
+					else tocol='id2'; tolat='lat2'; tolon='lon2'; fromcol='id1'; fromlat='lat1'; fromlon='lon1'
+	end
+	
+	# eliminate those already in the hash
+	connex=0
+	point=nil
+	connectlist.each { |row|
+		tonode=row[tocol].to_i
+		fromnode=row[fromcol].to_i
+		if id==tonode and !nodesused.has_key?(fromnode)
+			# wrong way round; add, then add to 'segments to reverse' list
+			connex+=1
+			nodesused[fromnode]=true
+			point=[long2coord(row[fromlon].to_f,baselong,masterscale),lat2coord(row[fromlat].to_f,basey,masterscale),fromnode,1,{},row['segid'].to_i]
+			toreverse.push(row['segid'].to_i)
+		elsif id==fromnode and !nodesused.has_key?(tonode)
+			# right way round; just add
+			connex+=1
+			point=[long2coord(row[tolon].to_f,baselong,masterscale),lat2coord(row[tolat].to_f,basey,masterscale),tonode,1,{},row['segid'].to_i]
+			nodesused[tonode]=true
+		end
+	}
+	
+	# if only one left, then add it; otherwise return false
+	if connex!=1 or point.nil? then
+		return [false,[],nodesused,toreverse]
+	else
+		return [true,point,nodesused,toreverse]
+	end
+end
+
+
 # ====================================================================
 # Support functions for remote calls
 
 def readwayquery(id)
-  ActiveRecord::Base.connection.select_all "SELECT n1.latitude AS lat1,n1.longitude AS long1,n1.id AS id1,n1.tags as tags1, "+
-      "		  n2.latitude AS lat2,n2.longitude AS long2,n2.id AS id2,n2.tags as tags2,segment_id "+
+  ActiveRecord::Base.connection.select_all "SELECT n1.latitude*0.0000001 AS lat1,n1.longitude*0.0000001 AS long1,n1.id AS id1,n1.tags as tags1, "+
+      "		  n2.latitude*0.0000001 AS lat2,n2.longitude*0.0000001 AS long2,n2.id AS id2,n2.tags as tags2,segment_id "+
       "    FROM current_way_segments,current_segments,current_nodes AS n1,current_nodes AS n2 "+
       "   WHERE current_way_segments.id=#{id} "+
       "     AND segment_id=current_segments.id "+
-	  "     AND current_segments.visible=1 "+
-      "     AND n1.id=node_a and n2.id=node_b "+
+      "     AND current_segments.visible=1 "+
+      "     AND n1.id=node_a AND n2.id=node_b "+
       "     AND n1.visible=1 AND n2.visible=1 "+
       "   ORDER BY sequence_id"
 end
@@ -506,18 +762,33 @@ end
 def createuniquenodes(uqs_name,uqn_name)
 	# Finds nodes which appear in uniquesegments but no other segments
 	sql=<<-EOF
-		CREATE TEMPORARY TABLE #{uqn_name}
-			   SELECT DISTINCT node_id
-			      FROM (SELECT cn.id AS node_id
-						  FROM current_nodes AS cn,
-						       current_segments AS cs,
-						       #{uqs_name} AS us
-						 WHERE cs.id=us.segment_id
-						   AND (cn.id=cs.node_a OR cn.id=cs.node_b)) AS n
-					 LEFT JOIN current_segments AS cs2 ON node_id=cs2.node_a AND cs2.visible=1
-					 LEFT JOIN current_segments AS cs3 ON node_id=cs3.node_b AND cs3.visible=1
-					     WHERE cs2.node_a IS NULL
-					       AND cs3.node_b IS NULL
+	CREATE TEMPORARY TABLE #{uqn_name}
+	   SELECT DISTINCT node_id
+	   FROM (SELECT cn.id AS node_id
+	         FROM current_nodes AS cn,
+  	              current_segments AS cs,
+	              #{uqs_name} AS us
+	         WHERE cs.id=us.segment_id
+	           AND cn.id=cs.node_a) AS n
+	   LEFT JOIN current_segments AS cs2 ON node_id=cs2.node_a AND cs2.visible=1
+	   LEFT JOIN current_segments AS cs3 ON node_id=cs3.node_b AND cs3.visible=1
+	   WHERE cs2.node_a IS NULL
+	     AND cs3.node_b IS NULL
+	EOF
+	ActiveRecord::Base.connection.execute(sql)
+	sql=<<-EOF
+	INSERT INTO #{uqn_name}
+	   SELECT DISTINCT node_id
+	   FROM (SELECT cn.id AS node_id
+	         FROM current_nodes AS cn,
+  	              current_segments AS cs,
+	              #{uqs_name} AS us
+	         WHERE cs.id=us.segment_id
+	           AND cn.id=cs.node_b) AS n
+	   LEFT JOIN current_segments AS cs2 ON node_id=cs2.node_a AND cs2.visible=1
+	   LEFT JOIN current_segments AS cs3 ON node_id=cs3.node_b AND cs3.visible=1
+	   WHERE cs2.node_a IS NULL
+	     AND cs3.node_b IS NULL
 	EOF
 	ActiveRecord::Base.connection.execute(sql)
 end
@@ -551,12 +822,13 @@ def array2tag(a)
 end
 
 def getuserid(token)
-  token=sqlescape(token)
-  if (token=~/^(.+)\+(.+)$/) then
-    return ActiveRecord::Base.connection.select_value("SELECT id FROM users WHERE active=1 AND email='#{$1}' AND pass_crypt=MD5('#{$2}')")
+  if (token =~ /^(.+)\+(.+)$/) then
+    user = User.authenticate(:username => $1, :password => $2)
   else
-    return ActiveRecord::Base.connection.select_value("SELECT id FROM users WHERE active=1 AND token='#{token}'")
+    user = User.authenticate(:token => token)
   end
+
+  return user ? user.id : nil;
 end
 
 
@@ -619,9 +891,9 @@ def getvalue(s)
   when 5;	return nil					# null
   when 6;	return nil					# undefined
   when 8;	s.read(4)					# mixedArray
-    return getobject(s)			#  |
-  when 10;return getarray(s)			# array
-  else;	return nil					# error
+		    return getobject(s)			#  |
+  when 10;	return getarray(s)			# array
+  else;		return nil					# error
   end
 end