X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/a424b6282f1587eb02f2add29b85958a86fc79c1..d626256bc2f2798202dbb4656f2f53aab0815f2c:/app/controllers/amf_controller.rb?ds=sidebyside diff --git a/app/controllers/amf_controller.rb b/app/controllers/amf_controller.rb index 8e23a18cc..950fd848f 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]}") @@ -10,9 +13,10 @@ class AmfController < ApplicationController # ---- talk process AMF request def talk - req=StringIO.new(request.raw_post) # Get POST data as request - req.read(2) # Skip version indicator and client ID - results={} # Results of each body + req=StringIO.new(request.raw_post+0.chr) # Get POST data as request + # (cf http://www.ruby-forum.com/topic/122163) + req.read(2) # Skip version indicator and client ID + results={} # Results of each body # ------------- # Parse request @@ -34,11 +38,13 @@ class AmfController < ApplicationController args=getvalue(req) # | get response (probably an array) case message - when 'getpresets'; results[index]=putdata(index,getpresets) - when 'whichways'; results[index]=putdata(index,whichways(args)) - when '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 'putpoi'; results[index]=putdata(index,putpoi(args)) + when 'getpoi'; results[index]=putdata(index,getpoi(args)) end end @@ -46,15 +52,14 @@ class AmfController < ApplicationController # Write out response RAILS_DEFAULT_LOGGER.info(" Response: start") - response.headers["Content-Type"]="application/x-amf" a,b=results.length.divmod(256) - ans=0.chr+0.chr+0.chr+0.chr+a.chr+b.chr - results.each do |k,v| - RAILS_DEFAULT_LOGGER.info(" Response: encode #{k}") - ans+=v - end + 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") - render :text => ans end @@ -63,13 +68,13 @@ 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='' @@ -89,13 +94,14 @@ motorway: highway=motorway,ref=(type road number) trunk road: highway=trunk,ref=(type road number),name=(type road name) primary road: highway=primary,ref=(type road number),name=(type road name) secondary road: highway=secondary,ref=(type road number),name=(type road name) -residential road: highway=residential,name=(type road name) -unclassified road: highway=unclassified,name=(type road name) +tertiary road: highway=tertiary,ref=,name=(type road name) +residential road: highway=residential,ref=,name=(type road name) +unclassified road: highway=unclassified,ref=,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 @@ -120,6 +126,10 @@ preserved railway: railway=preserved disused railway tracks: railway=disused course of old railway: railway=abandoned +way/natural +lake: natural=water,landuse= +forest: landuse=forest,natural= + point/road mini roundabout: highway=mini_roundabout traffic lights: highway=traffic_signals @@ -144,6 +154,35 @@ point/railway station: railway=station viaduct: railway=viaduct level crossing: railway=crossing + +point/natural +peak: natural=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| @@ -167,48 +206,47 @@ 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 + baselong = args[4] + basey = args[5] + masterscale = args[6] RAILS_DEFAULT_LOGGER.info(" Message: whichways, bbox=#{xmin},#{ymin},#{xmax},#{ymax}") - 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+")") + waylist = ActiveRecord::Base.connection.select_all("SELECT DISTINCT current_way_nodes.id AS wayid"+ + " FROM current_way_nodes,current_nodes,current_ways "+ + " WHERE current_nodes.id=current_way_nodes.node_id "+ + " AND current_nodes.visible=1 "+ + " AND current_ways.id=current_way_nodes.id "+ + " AND current_ways.visible=1 "+ + " AND "+OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")) - 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+") "+ - " AND cs1.id IS NULL AND cs2.id IS NULL "+ + " LEFT OUTER JOIN current_way_nodes cwn ON cwn.node_id=current_nodes.id "+ + " WHERE "+OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")+ + " AND cwn.id IS NULL "+ " AND current_nodes.visible=1") - 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 @@ -221,20 +259,16 @@ EOF 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) - points << [xs1,ys1,row['id1'].to_i,0,tag2array(row['tags1']),0] if (row['id1'].to_i!=lastid) - lastid = row['id2'].to_i - points << [xs2,ys2,row['id2'].to_i,1,tag2array(row['tags2']),row['segment_id'].to_i] - xmin = [xmin,row['long1'].to_f,row['long2'].to_f].min - xmax = [xmax,row['long1'].to_f,row['long2'].to_f].max - ymin = [ymin,row['lat1'].to_f,row['lat2'].to_f].min - ymax = [ymax,row['lat1'].to_f,row['lat2'].to_f].max + points<<[long2coord(row['longitude'].to_f,baselong,masterscale),lat2coord(row['latitude'].to_f,basey,masterscale),row['id'].to_i,nil,tag2array(row['tags'])] + xmin = [xmin,row['longitude'].to_f].min + xmax = [xmax,row['longitude'].to_f].max + ymin = [ymin,row['latitude'].to_f].min + ymax = [ymax,row['latitude'].to_f].max } attributes={} attrlist=ActiveRecord::Base.connection.select_all "SELECT k,v FROM current_way_tags WHERE id=#{wayid}" - attrlist.each {|a| attributes[a['k']]=a['v'] } + attrlist.each {|a| attributes[a['k'].gsub(':','|')]=a['v'] } [objname,points,attributes,xmin,xmax,ymin,ymax] end @@ -245,28 +279,30 @@ EOF # xmin,xmax,ymin,ymax def putway(args) + RAILS_DEFAULT_LOGGER.info(" putway started") usertoken,originalway,points,attributes,baselong,basey,masterscale=args uid=getuserid(usertoken) return if !uid - 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 + RAILS_DEFAULT_LOGGER.info(" putway authenticated happily") 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 db_now='@now'+uid.to_s+originalway.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()") originalway=originalway.to_i - RAILS_DEFAULT_LOGGER.info(" Message: putway, id=#{way}") + RAILS_DEFAULT_LOGGER.info(" Message: putway, id=#{originalway}") # -- 3. read original way into memory - xc={}; yc={}; tagc={}; seg={} + xc={}; yc={}; tagc={} if originalway>0 way=originalway readwayquery(way).each { |row| - id1=row['id1'].to_i; xc[id1]=row['long1'].to_f; yc[id1]=row['lat1'].to_f; tagc[id1]=row['tags1'] - 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 + id=row['id'].to_i + xc[id]=row['longitude'].to_f + yc[id]=row['latitude' ].to_f + tagc[id]=row['tags'] } - 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 @@ -277,10 +313,11 @@ EOF # -- 5. compare nodes and update xmin,xmax,ymin,ymax - xmin = ymin = 999999 - xmax = ymax = -999999 - insertsql = '' + xmin=ymin= 999999 + xmax=ymax=-999999 + insertsql='' renumberednodes={} + nodelist=[] points.each_index do |i| xs=coord2long(points[i][0],masterscale,baselong) @@ -288,83 +325,47 @@ EOF xmin=[xs,xmin].min; xmax=[xs,xmax].max ymin=[ys,ymin].min; ymax=[ys,ymax].max node=points[i][2].to_i - tagstr=array2tag(points[i][4]) + tagstr=array2tag(points[i][4]) 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 + nodelist.push(newnode) + renumberednodes[node.to_s]=newnode.to_s + else + points[i][2]=renumberednodes[node.to_s].to_i + end elsif xc.has_key?(node) + nodelist.push(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}") + 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 - # -- 6.i compare segments - - numberedsegments={} - seglist='' # list of existing segments that we want to keep - for i in (0..(points.length-2)) - if (points[i+1][3].to_i==0) then next end - segid=points[i+1][5].to_i - from =points[i ][2].to_i - to =points[i+1][2].to_i - if seg.has_key?(segid) - if seg[segid]=="#{from}-#{to}" then - if (seglist!='') then seglist+=',' end; seglist+=segid.to_s - next - end - 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,'')") - 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 - - createuniquesegments(way,db_uqs,seglist) # segments which appear in this way but no other - - # delete segments from uniquesegments (and not in modified way) - - 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 AND cs.visible=1 - EOF - ActiveRecord::Base.connection.insert(sql) - - 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 AND cs.visible=1 - EOF - ActiveRecord::Base.connection.update(sql) - - # delete nodes not in modified way or any other segments + # -- 6a. delete any nodes not in modified way - createuniquenodes(db_uqs,db_uqn) # nodes which appear in this way but no other + createuniquenodes(way,db_uqn,nodelist) # 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) @@ -375,165 +376,244 @@ EOF EOF ActiveRecord::Base.connection.update(sql) - ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqs}") + deleteuniquenoderelations(db_uqn,uid,db_now) ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqn}") - # insert new version of route into way_segments + # 6b. insert new version of route into way_nodes insertsql ='' currentsql='' sequence =1 - for i in (0..(points.length-2)) - if (points[i+1][3].to_i==0) then next end + points.each do |p| if insertsql !='' then insertsql +=',' end if currentsql!='' then currentsql+=',' end - insertsql +="(#{way},#{points[i+1][5]},#{version})" - currentsql+="(#{way},#{points[i+1][5]},#{sequence})" + insertsql +="(#{way},#{p[2]},#{sequence},#{version})" + currentsql+="(#{way},#{p[2]},#{sequence})" sequence +=1 end - ActiveRecord::Base.connection.execute("DELETE FROM current_way_segments WHERE id=#{way}"); - ActiveRecord::Base.connection.insert("INSERT INTO way_segments (id,segment_id,version ) VALUES #{insertsql}"); - ActiveRecord::Base.connection.insert("INSERT INTO current_way_segments (id,segment_id,sequence_id) VALUES #{currentsql}"); + ActiveRecord::Base.connection.execute("DELETE FROM current_way_nodes WHERE id=#{way}"); + ActiveRecord::Base.connection.insert( "INSERT INTO way_nodes (id,node_id,sequence_id,version) VALUES #{insertsql}"); + ActiveRecord::Base.connection.insert( "INSERT INTO current_way_nodes (id,node_id,sequence_id ) VALUES #{currentsql}"); # -- 7. insert new way tags 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 - insertsql +="(#{way},'"+sqlescape(k)+"','"+sqlescape(v)+"',#{version})" - currentsql+="(#{way},'"+sqlescape(k)+"','"+sqlescape(v)+"')" + insertsql +="(#{way},'"+sqlescape(k.gsub('|',':'))+"','"+sqlescape(v)+"',#{version})" + currentsql+="(#{way},'"+sqlescape(k.gsub('|',':'))+"','"+sqlescape(v)+"')" end ActiveRecord::Base.connection.execute("DELETE FROM current_way_tags WHERE id=#{way}") if (insertsql !='') then ActiveRecord::Base.connection.insert("INSERT INTO way_tags (id,k,v,version) VALUES #{insertsql}" ) end if (currentsql!='') then ActiveRecord::Base.connection.insert("INSERT INTO current_way_tags (id,k,v) VALUES #{currentsql}") end - [originalway,way,renumberednodes,numberedsegments,xmin,xmax,ymin,ymax] + [originalway,way,renumberednodes,xmin,xmax,ymin,ymax] end - # ----- deleteway (user token, way) + # ----- 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 + if visible==0 then + # if deleting, check node hasn't become part of a way + inway=ActiveRecord::Base.connection.select_one("SELECT cw.id FROM current_ways cw,current_way_nodes cwn WHERE cw.id=cwn.id AND cw.visible=1 AND cwn.node_id=#{id} LIMIT 1") + unless inway.nil? then return [id,id] end # should really return an error + deleteitemrelations(id,'node',uid,db_now) + end + + 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, nodes to keep) # returns way ID only def deleteway(args) - usertoken,way=args + usertoken,way,preserve=args RAILS_DEFAULT_LOGGER.info(" Message: deleteway, id=#{way}") uid=getuserid(usertoken); if !uid then return end - 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,'') - - # - delete any otherwise unused segments - - 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) + way=way.to_i - 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) + 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()") - # - delete any unused nodes + # - delete any otherwise unused nodes - createuniquenodes(db_uqs,db_uqn) + createuniquenodes(way,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 + unless (preserve.empty?) then + ActiveRecord::Base.connection.execute("DELETE FROM #{db_uqn} WHERE node_id IN ("+preserve.join(',')+")") + end + + sql=<<-EOF + INSERT INTO nodes (id,latitude,longitude,timestamp,user_id,visible,tile) + SELECT DISTINCT cn.id,cn.latitude,cn.longitude,#{db_now},#{uid},0,cn.tile + FROM current_nodes AS cn,#{db_uqn} + WHERE cn.id=node_id EOF - ActiveRecord::Base.connection.insert(sql) + 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.execute("DROP TABLE #{db_uqs}") - ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqn}") + ActiveRecord::Base.connection.update(sql) - # - 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}") + deleteuniquenoderelations(db_uqn,uid,db_now) + ActiveRecord::Base.connection.execute("DROP TABLE #{db_uqn}") + + # - delete way - way + ActiveRecord::Base.connection.insert("INSERT INTO ways (id,user_id,timestamp,visible) VALUES (#{way},#{uid},#{db_now},0)") + ActiveRecord::Base.connection.update("UPDATE current_ways SET user_id=#{uid},timestamp=#{db_now},visible=0 WHERE id=#{way}") + ActiveRecord::Base.connection.execute("DELETE FROM current_way_nodes WHERE id=#{way}") + ActiveRecord::Base.connection.execute("DELETE FROM current_way_tags WHERE id=#{way}") + deleteitemrelations(way,'way',uid,db_now) + way 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 "+ - " 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 n1.visible=1 AND n2.visible=1 "+ + ActiveRecord::Base.connection.select_all "SELECT latitude*0.0000001 AS latitude,longitude*0.0000001 AS longitude,current_nodes.id,tags "+ + " FROM current_way_nodes,current_nodes "+ + " WHERE current_way_nodes.id=#{id} "+ + " AND current_way_nodes.node_id=current_nodes.id "+ + " AND current_nodes.visible=1 "+ " ORDER BY sequence_id" end -def createuniquesegments(way,uqs_name,seglist) - # Finds segments which appear in (previous version of) this way and no other - sql=<<-EOF - CREATE TEMPORARY TABLE #{uqs_name} - SELECT a.segment_id - FROM (SELECT DISTINCT segment_id FROM current_way_segments - WHERE id = #{way}) a - LEFT JOIN current_way_segments b - ON b.segment_id = a.segment_id - AND b.id != #{way} - WHERE b.segment_id IS NULL - EOF - if (seglist!='') then sql+=" AND a.segment_id NOT IN (#{seglist})" end - ActiveRecord::Base.connection.execute(sql) +def createuniquenodes(way,uqn_name,nodelist) + # Find nodes which appear in this way but no others + sql=<<-EOF + CREATE TEMPORARY TABLE #{uqn_name} + SELECT a.node_id + FROM (SELECT DISTINCT node_id FROM current_way_nodes + WHERE id=#{way}) a + LEFT JOIN current_way_nodes b + ON b.node_id=a.node_id + AND b.id!=#{way} + WHERE b.node_id IS NULL + EOF + unless nodelist.empty? then + sql+="AND a.node_id NOT IN ("+nodelist.join(',')+")" + end + ActiveRecord::Base.connection.execute(sql) end -def createuniquenodes(uqs_name,uqn_name) - # Finds nodes which appear in uniquesegments but no other segments + + +# ==================================================================== +# Relations handling +# deleteuniquenoderelations(uqn_name,uid,db_now) +# deleteitemrelations(way|node,'way'|'node',uid,db_now) + +def deleteuniquenoderelations(uqn_name,uid,db_now) 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 + SELECT node_id,cr.id FROM #{uqn_name},current_relation_members crm,current_relations cr + WHERE crm.member_id=node_id + AND crm.member_type='node' + AND crm.id=cr.id + AND cr.visible=1 EOF - ActiveRecord::Base.connection.execute(sql) + + relnodes=ActiveRecord::Base.connection.select_all(sql) + relnodes.each do |a| + removefromrelation(a['node_id'],'node',a['id'],uid,db_now) + end end +def deleteitemrelations(objid,type,uid,db_now) + sql=<<-EOF + SELECT cr.id FROM current_relation_members crm,current_relations cr + WHERE crm.member_id=#{objid} + AND crm.member_type='#{type}' + AND crm.id=cr.id + AND cr.visible=1 + EOF + + relways=ActiveRecord::Base.connection.select_all(sql) + relways.each do |a| + removefromrelation(objid,type,a['id'],uid,db_now) + end +end + +def removefromrelation(objid,type,relation,uid,db_now) + rver=ActiveRecord::Base.connection.insert("INSERT INTO relations (id,user_id,timestamp,visible) VALUES (#{relation},#{uid},#{db_now},1)") + + tagsql=<<-EOF + INSERT INTO relation_tags (id,k,v,version) + SELECT id,k,v,#{rver} FROM current_relation_tags + WHERE id=#{relation} + EOF + ActiveRecord::Base.connection.insert(tagsql) + + membersql=<<-EOF + INSERT INTO relation_members (id,member_type,member_id,member_role,version) + SELECT id,member_type,member_id,member_role,#{rver} FROM current_relation_members + WHERE id=#{relation} + AND (member_id!=#{objid} OR member_type!='#{type}') + EOF + ActiveRecord::Base.connection.insert(membersql) + + ActiveRecord::Base.connection.update("UPDATE current_relations SET user_id=#{uid},timestamp=#{db_now} WHERE id=#{relation}") + ActiveRecord::Base.connection.execute("DELETE FROM current_relation_members WHERE id=#{relation} AND member_type='#{type}' AND member_id=#{objid}") +end + + def sqlescape(a) - a.gsub("'","''").gsub(92.chr,92.chr+92.chr) + a.gsub(/[\000-\037]/,"").gsub("'","''").gsub(92.chr,92.chr+92.chr) end def tag2array(a) @@ -544,7 +624,7 @@ def tag2array(a) k,v=b.split('=') if k.nil? then k='' end if v.nil? then v='' end - tags[k.gsub('#%','=')]=v.gsub('#%','=') + tags[k.gsub('#%','=').gsub(':','|')]=v.gsub('#%','=') end tags end @@ -555,18 +635,19 @@ def array2tag(a) if v=='' then next end if v[0,6]=='(type ' then next end if str!='' then str+=';' end - str+=k.gsub(';',';;;').gsub('=','===')+'='+v.gsub(';',';;;').gsub('=','===') + str+=k.gsub(';',';;;').gsub('=','===').gsub('|',':')+'='+v.gsub(';',';;;').gsub('=','===') end str 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 @@ -622,16 +703,16 @@ end def getvalue(s) case s.getc - when 0; return getdouble(s) # number - when 1; return s.getc # boolean - when 2; return getstring(s) # string - when 3; return getobject(s) # object/hash - when 5; return nil # null - when 6; return nil # undefined - when 8; s.read(4) # mixedArray - return getobject(s) # | - when 10;return getarray(s) # array - else; return nil # error + when 0; return getdouble(s) # number + when 1; return s.getc # boolean + when 2; return getstring(s) # string + when 3; return getobject(s) # object/hash + when 5; return nil # null + when 6; return nil # undefined + when 8; s.read(4) # mixedArray + return getobject(s) # | + when 10;return getarray(s) # array + else; return nil # error end end