include Potlatch
+ # Help methods for checking boundary sanity and area size
+ include MapBoundary
+
session :off
before_filter :check_write_availability
def whichways(xmin, ymin, xmax, ymax) #:doc:
xmin -= 0.01; ymin -= 0.01
xmax += 0.01; ymax += 0.01
+
+ # check boundary is sane and area within defined
+ # see /config/application.yml
+ begin
+ check_boundaries(xmin, ymin, xmax, ymax)
+ rescue Exception => err
+ # FIXME: report an error rather than just return an empty result
+ return [[],[],[]]
+ end
if POTLATCH_USE_SQL then
way_ids = sql_find_way_ids_in_area(xmin, ymin, xmax, ymax)
relation_ids = sql_find_relations_in_area_and_ways(xmin, ymin, xmax, ymax, way_ids)
else
# find the way ids in an area
- nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => "current_nodes.visible = 1", :include => :ways)
+ nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => ["current_nodes.visible = ?", true], :include => :ways)
way_ids = nodes_in_area.collect { |node| node.way_ids }.flatten.uniq
# find the node ids in an area that aren't part of ways
points = nodes_not_used_in_area.collect { |n| [n.id, n.lon, n.lat, n.tags_as_hash] }
# find the relations used by those nodes and ways
- relations = Relation.find_for_nodes(nodes_in_area.collect { |n| n.id }, :conditions => "visible = 1") +
- Relation.find_for_ways(way_ids, :conditions => "visible = 1")
+ relations = Relation.find_for_nodes(nodes_in_area.collect { |n| n.id }, :conditions => {:visible => true}) +
+ Relation.find_for_ways(way_ids, :conditions => {:visible => true})
relation_ids = relations.collect { |relation| relation.id }.uniq
end
xmin -= 0.01; ymin -= 0.01
xmax += 0.01; ymax += 0.01
- nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => "current_nodes.visible = 0 AND current_ways.visible = 0", :include => :ways_via_history)
+ # check boundary is sane and area within defined
+ # see /config/application.yml
+ begin
+ check_boundaries(xmin, ymin, xmax, ymax)
+ rescue Exception => err
+ # FIXME: report an error rather than just return an empty result
+ return [[]]
+ end
+
+ nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => ["current_ways.visible = ?", false], :include => :ways_via_history)
way_ids = nodes_in_area.collect { |node| node.ways_via_history_ids }.flatten.uniq
[way_ids]
# Ideally we would do ":include => :nodes" here but if we do that
# then rails only seems to return the first copy of a node when a
# way includes a node more than once
- way = Way.find(wayid)
+ begin
+ way = Way.find(wayid)
+ rescue ActiveRecord::RecordNotFound
+ return [wayid,[],{}]
+ end
+
+ # check case where way has been deleted or doesn't exist
+ return [wayid,[],{}] if way.nil? or !way.visible
+
points = way.nodes.collect do |node|
nodetags=node.tags_as_hash
nodetags.delete('created_by')
def getway_old(id, version) #:doc:
if version < 0
- old_way = OldWay.find(:first, :conditions => ['visible = 1 AND id = ?', id], :order => 'version DESC')
+ old_way = OldWay.find(:first, :conditions => ['visible = ? AND id = ?', true, id], :order => 'version DESC')
points = old_way.get_nodes_undelete
else
old_way = OldWay.find(:first, :conditions => ['id = ? AND version = ?', id, version])
# 2. list of members.
def getrelation(relid) #:doc:
- rel = Relation.find(relid)
+ begin
+ rel = Relation.find(relid)
+ rescue ActiveRecord::RecordNotFound
+ return [relid, {}, []]
+ end
+
+ return [relid, {}, []] if rel.nil? or !rel.visible
[relid, rel.tags, rel.members]
end
if !uid then return -1,"You are not logged in, so the relation could not be saved." end
relid = relid.to_i
- visible = visible.to_i
+ visible = (visible.to_i != 0)
# create a new relation, or find the existing one
if relid <= 0
FROM current_way_nodes
INNER JOIN current_nodes ON current_nodes.id=current_way_nodes.node_id
INNER JOIN current_ways ON current_ways.id =current_way_nodes.id
- WHERE current_nodes.visible=1
- AND current_ways.visible=1
+ WHERE current_nodes.visible=TRUE
+ AND current_ways.visible=TRUE
AND #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")}
EOF
return ActiveRecord::Base.connection.select_all(sql).collect { |a| a['wayid'].to_i }
SELECT current_nodes.id,current_nodes.latitude*0.0000001 AS lat,current_nodes.longitude*0.0000001 AS lon,current_nodes.tags
FROM current_nodes
LEFT OUTER JOIN current_way_nodes cwn ON cwn.node_id=current_nodes.id
- WHERE current_nodes.visible=1
+ WHERE current_nodes.visible=TRUE
AND cwn.id IS NULL
AND #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")}
EOF
FROM current_way_nodes,current_nodes
WHERE current_way_nodes.id=#{wayid.to_i}
AND current_way_nodes.node_id=current_nodes.id
- AND current_nodes.visible=1
+ AND current_nodes.visible=TRUE
ORDER BY sequence_id
EOF
ActiveRecord::Base.connection.select_all(sql).each do |row|
require File.dirname(__FILE__) + '/../test_helper'
+require 'stringio'
+include Potlatch
class AmfControllerTest < ActionController::TestCase
- # Replace this with your real tests.
- def test_truth
- assert true
+ api_fixtures
+
+ def test_getway
+ # check a visible way
+ id = current_ways(:visible_way).id
+ amf_content "getway", "/1", [id]
+ post :amf_read
+ assert_response :success
+ amf_parse_response
+ assert_equal amf_result("/1")[0], id
+ end
+
+ def test_getway_invisible
+ # check an invisible way
+ id = current_ways(:invisible_way).id
+ amf_content "getway", "/1", [id]
+ post :amf_read
+ assert_response :success
+ amf_parse_response
+ way = amf_result("/1")
+ assert_equal way[0], id
+ assert way[1].empty? and way[2].empty?
+ end
+
+ def test_getway_nonexistent
+ # check chat a non-existent way is not returned
+ amf_content "getway", "/1", [0]
+ post :amf_read
+ assert_response :success
+ amf_parse_response
+ way = amf_result("/1")
+ assert_equal way[0], 0
+ assert way[1].empty? and way[2].empty?
+ end
+
+ def test_whichways
+ node = current_nodes(:used_node_1)
+ minlon = node.lon-0.1
+ minlat = node.lat-0.1
+ maxlon = node.lon+0.1
+ maxlat = node.lat+0.1
+ amf_content "whichways", "/1", [minlon, minlat, maxlon, maxlat]
+ post :amf_read
+ assert_response :success
+ amf_parse_response
+
+ # check contents of message
+ map = amf_result "/1"
+ assert map[0].include?(current_ways(:used_way).id)
+ assert !map[0].include?(current_ways(:invisible_way).id)
+ end
+
+ def test_whichways_toobig
+ bbox = [-0.1,-0.1,1.1,1.1]
+ amf_content "whichways", "/1", bbox
+ post :amf_read
+ assert_response :success
+ amf_parse_response
+
+ # FIXME: whichways needs to reject large bboxes and the test needs to check for this
+ map = amf_result "/1"
+ assert map[0].empty? and map[1].empty? and map[2].empty?
+ end
+
+ def test_whichways_badlat
+ bboxes = [[0,0.1,0.1,0], [-0.1,80,0.1,70], [0.24,54.34,0.25,54.33]]
+ bboxes.each do |bbox|
+ amf_content "whichways", "/1", bbox
+ post :amf_read
+ assert_response :success
+ amf_parse_response
+
+ # FIXME: whichways needs to reject bboxes with illegal lats and the test needs to check for this
+ map = amf_result "/1"
+ assert map[0].empty? and map[1].empty? and map[2].empty?
+ end
+ end
+
+ def test_whichways_badlon
+ bboxes = [[80,-0.1,70,0.1], [54.34,0.24,54.33,0.25]]
+ bboxes.each do |bbox|
+ amf_content "whichways", "/1", bbox
+ post :amf_read
+ assert_response :success
+ amf_parse_response
+
+ # FIXME: whichways needs to reject bboxes with illegal lons and the test needs to check for this
+ map = amf_result "/1"
+ assert map[0].empty? and map[1].empty? and map[2].empty?
+ end
+ end
+
+ def test_whichways_deleted
+ node = current_nodes(:used_node_1)
+ minlon = node.lon-0.1
+ minlat = node.lat-0.1
+ maxlon = node.lon+0.1
+ maxlat = node.lat+0.1
+ amf_content "whichways_deleted", "/1", [minlon, minlat, maxlon, maxlat]
+ post :amf_read
+ assert_response :success
+ amf_parse_response
+
+ # check contents of message
+ ways = amf_result "/1"
+ assert ways[0].include?(current_ways(:invisible_way).id)
+ assert !ways[0].include?(current_ways(:used_way).id)
end
+
+ def test_whichways_deleted_toobig
+ bbox = [-0.1,-0.1,1.1,1.1]
+ amf_content "whichways_deleted", "/1", bbox
+ post :amf_read
+ assert_response :success
+ amf_parse_response
+
+ ways = amf_result "/1"
+ assert ways[0].empty?
+ end
+
+ def test_getrelation
+ id = current_relations(:visible_relation).id
+ amf_content "getrelation", "/1", [id]
+ post :amf_read
+ assert_response :success
+ amf_parse_response
+ assert_equal amf_result("/1")[0], id
+ end
+
+ def test_getrelation_invisible
+ id = current_relations(:invisible_relation).id
+ amf_content "getrelation", "/1", [id]
+ post :amf_read
+ assert_response :success
+ amf_parse_response
+ rel = amf_result("/1")
+ assert_equal rel[0], id
+ assert rel[1].empty? and rel[2].empty?
+ end
+
+ def test_getrelation_nonexistent
+ id = 0
+ amf_content "getrelation", "/1", [id]
+ post :amf_read
+ assert_response :success
+ amf_parse_response
+ rel = amf_result("/1")
+ assert_equal rel[0], id
+ assert rel[1].empty? and rel[2].empty?
+ end
+
+ # Get the result record for the specified ID
+ # It's an assertion FAIL if the record does not exist
+ def amf_result ref
+ assert @amf_result.has_key?("#{ref}/onResult")
+ @amf_result["#{ref}/onResult"]
+ end
+
+ # Encode the AMF message to invoke "target" with parameters as
+ # the passed data. The ref is used to retrieve the results.
+ def amf_content(target, ref, data)
+ a,b=1.divmod(256)
+ c = StringIO.new()
+ c.write 0.chr+0.chr # version 0
+ c.write 0.chr+0.chr # n headers
+ c.write a.chr+b.chr # n bodies
+ c.write AMF.encodestring(target)
+ c.write AMF.encodestring(ref)
+ c.write [-1].pack("N")
+ c.write AMF.encodevalue(data)
+
+ @request.env["RAW_POST_DATA"] = c.string
+ end
+
+ # Parses the @response object as an AMF messsage.
+ # The result is a hash of message_ref => data.
+ # The attribute @amf_result is initialised to this hash.
+ def amf_parse_response
+ if @response.body.class.to_s == 'Proc'
+ res = StringIO.new()
+ @response.body.call @response, res
+ req = StringIO.new(res.string)
+ else
+ req = StringIO.new(@response.body)
+ end
+ req.read(2) # version
+
+ # parse through any headers
+ headers=AMF.getint(req) # Read number of headers
+ headers.times do # Read each header
+ name=AMF.getstring(req) # |
+ req.getc # | skip boolean
+ value=AMF.getvalue(req) # |
+ end
+
+ # parse through responses
+ results = {}
+ bodies=AMF.getint(req) # Read number of bodies
+ bodies.times do # Read each body
+ message=AMF.getstring(req) # | get message name
+ index=AMF.getstring(req) # | get index in response sequence
+ bytes=AMF.getlong(req) # | get total size in bytes
+ args=AMF.getvalue(req) # | get response (probably an array)
+ results[message] = args
+ end
+ @amf_result = results
+ results
+ end
+
end
projects / rails.git / commitdiff