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).
6 # Helper functions are in /lib/potlatch.
8 # Author:: editions Systeme D / Richard Fairhurst 2004-2008
9 # Licence:: public domain.
11 # == General structure
13 # Apart from the talk method (which distributes the requests from the
14 # AMF message), each method generally takes arguments in the order they were
15 # sent by the Potlatch SWF. Do not assume typing has been preserved. Methods
16 # all return an array to the SWF.
20 # Any method that returns a status code (0 for ok) can also send:
21 # return(-1,"message") <-- just puts up a dialogue
22 # return(-2,"message") <-- also asks the user to e-mail me
24 # To write to the Rails log, use RAILS_DEFAULT_LOGGER.info("message").
28 # - Check authentication
29 # - Check the right things are being written to the database!
31 class AmfController < ApplicationController
37 before_filter :check_write_availability
39 # Main AMF handler: processes the raw AMF string (using AMF library) and
40 # calls each action (private method) accordingly.
43 req=StringIO.new(request.raw_post+0.chr) # Get POST data as request
44 # (cf http://www.ruby-forum.com/topic/122163)
45 req.read(2) # Skip version indicator and client ID
46 results={} # Results of each body
47 renumberednodes={} # Shared across repeated putways
48 renumberedways={} # Shared across repeated putways
52 headers=AMF.getint(req) # Read number of headers
54 headers.times do # Read each header
55 name=AMF.getstring(req) # |
56 req.getc # | skip boolean
57 value=AMF.getvalue(req) # |
58 header["name"]=value # |
61 bodies=AMF.getint(req) # Read number of bodies
62 bodies.times do # Read each body
63 message=AMF.getstring(req) # | get message name
64 index=AMF.getstring(req) # | get index in response sequence
65 bytes=AMF.getlong(req) # | get total size in bytes
66 args=AMF.getvalue(req) # | get response (probably an array)
69 when 'getpresets'; results[index]=AMF.putdata(index,getpresets())
70 when 'whichways'; results[index]=AMF.putdata(index,whichways(*args))
71 when 'whichways_deleted'; results[index]=AMF.putdata(index,whichways_deleted(*args))
72 when 'getway'; results[index]=AMF.putdata(index,getway(args[0].to_i))
73 when 'getrelation'; results[index]=AMF.putdata(index,getrelation(args[0].to_i))
74 when 'getway_old'; results[index]=AMF.putdata(index,getway_old(args[0].to_i,args[1].to_i))
75 when 'getway_history'; results[index]=AMF.putdata(index,getway_history(args[0].to_i))
76 when 'putway'; r=putway(renumberednodes,*args)
79 renumberedways[r[1]] = r[2]
81 results[index]=AMF.putdata(index,r)
82 when 'putrelation'; results[index]=AMF.putdata(index,putrelation(renumberednodes, renumberedways, *args))
83 when 'findrelations'; results[index]=AMF.putdata(index,findrelations(*args))
84 when 'deleteway'; results[index]=AMF.putdata(index,deleteway(args[0],args[1].to_i))
85 when 'putpoi'; results[index]=AMF.putdata(index,putpoi(*args))
86 when 'getpoi'; results[index]=AMF.putdata(index,getpoi(args[0].to_i))
92 a,b=results.length.divmod(256)
93 render :content_type => "application/x-amf", :text => proc { |response, output|
94 output.write 0.chr+0.chr+0.chr+0.chr+a.chr+b.chr
103 # Return presets (default tags, localisation etc.):
104 # uses POTLATCH_PRESETS global, set up in OSM::Potlatch.
106 def getpresets() #:doc:
107 return POTLATCH_PRESETS
110 # Find all the ways, POI nodes (i.e. not part of ways), and relations
111 # in a given bounding box. Nodes are returned in full; ways and relations
114 def whichways(xmin, ymin, xmax, ymax) #:doc:
115 xmin -= 0.01; ymin -= 0.01
116 xmax += 0.01; ymax += 0.01
118 if POTLATCH_USE_SQL then
119 way_ids = sql_find_way_ids_in_area(xmin, ymin, xmax, ymax)
120 points = sql_find_pois_in_area(xmin, ymin, xmax, ymax)
121 relation_ids = sql_find_relations_in_area_and_ways(xmin, ymin, xmax, ymax, way_ids)
123 # find the way ids in an area
124 nodes_in_area = Node.find_by_area(ymin, xmin, ymax, xmax, :conditions => "current_nodes.visible = 1", :include => :ways)
125 way_ids = nodes_in_area.collect { |node| node.way_ids }.flatten.uniq
127 # find the node ids in an area that aren't part of ways
128 nodes_not_used_in_area = nodes_in_area.select { |node| node.ways.empty? }
129 points = nodes_not_used_in_area.collect { |n| [n.id, n.lon, n.lat, n.tags_as_hash] }
131 # find the relations used by those nodes and ways
132 relations = Relation.find_for_nodes(nodes_in_area.collect { |n| n.id }, :conditions => "visible = 1") +
133 Relation.find_for_ways(way_ids, :conditions => "visible = 1")
134 relation_ids = relations.collect { |relation| relation.id }.uniq
137 [way_ids, points, relation_ids]
140 # Find deleted ways in current bounding box (similar to whichways, but ways
141 # with a deleted node only - not POIs or relations).
143 def whichways_deleted(xmin, ymin, xmax, ymax) #:doc:
144 xmin -= 0.01; ymin -= 0.01
145 xmax += 0.01; ymax += 0.01
147 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)
148 way_ids = nodes_in_area.collect { |node| node.ways_via_history_ids }.flatten.uniq
153 # Get a way including nodes and tags.
154 # Returns 0 (success), a Potlatch-style array of points, and a hash of tags.
156 def getway(wayid) #:doc:
157 if POTLATCH_USE_SQL then
158 points = sql_get_nodes_in_way(wayid)
159 tags = sql_get_tags_in_way(wayid)
161 # Ideally we would do ":include => :nodes" here but if we do that
162 # then rails only seems to return the first copy of a node when a
163 # way includes a node more than once
164 way = Way.find(wayid)
165 points = way.nodes.collect do |node|
166 [node.lon, node.lat, node.id, nil, node.tags_as_hash]
171 [wayid, points, tags]
174 # Get an old version of a way, and all constituent nodes.
176 # For undelete (version=0), always uses the most recent version of each node,
177 # even if it's moved. For revert (version=1+), uses the node in existence
178 # at the time, generating a new id if it's still visible and has been moved/
181 def getway_old(id, version) #:doc:
183 old_way = OldWay.find(:first, :conditions => ['visible = 1 AND id = ?', id], :order => 'version DESC')
184 points = old_way.get_nodes_undelete
186 old_way = OldWay.find(:first, :conditions => ['id = ? AND version = ?', id, version])
187 points = old_way.get_nodes_revert
190 old_way.tags['history'] = "Retrieved from v#{old_way.version}"
192 [0, id, points, old_way.tags, old_way.version]
195 # Find history of a way. Returns an array of previous versions.
197 def getway_history(wayid) #:doc:
198 history = Way.find(wayid).old_ways.collect do |old_way|
199 user = old_way.user.data_public? ? old_way.user.display_name : 'anonymous'
200 [old_way.version, old_way.timestamp.strftime("%d %b %Y, %H:%M"), old_way.visible ? 1 : 0, user]
206 # Get a relation with all tags and members.
210 # 2. list of members.
212 def getrelation(relid) #:doc:
213 rel = Relation.find(relid)
215 [relid, rel.tags, rel.members]
218 # Find relations with specified name/id.
219 # Returns array of relations, each in same form as getrelation.
221 def findrelations(searchterm)
223 if searchterm.to_i>0 then
224 rel = Relation.find(searchterm.to_i)
225 if rel and rel.visible then
226 rels.push([rel.id, rel.tags, rel.members])
229 RelationTag.find(:all, :limit => 11, :conditions => ["match(v) against (?)", searchterm] ).each do |t|
230 if t.relation.visible then
231 rels.push([t.relation.id, t.relation.tags, t.relation.members])
241 # 1. original relation id (unchanged),
242 # 2. new relation id.
244 def putrelation(renumberednodes, renumberedways, usertoken, relid, tags, members, visible) #:doc:
245 uid = getuserid(usertoken)
246 if !uid then return -1,"You are not logged in, so the relation could not be saved." end
249 visible = visible.to_i
251 # create a new relation, or find the existing one
255 rel = Relation.find(relid)
258 # check the members are all positive, and correctly type
263 mid = renumberednodes[mid] if m[0] == 'node'
264 mid = renumberedways[mid] if m[0] == 'way'
266 return -2, "Negative ID unresolved"
269 typedmembers << [m[0], mid, m[2]]
272 # assign new contents
273 rel.members = typedmembers
275 rel.visible = visible
278 # check it then save it
279 # BUG: the following is commented out because it always fails on my
280 # install. I think it's a Rails bug.
282 #if !rel.preconditions_ok?
283 # return -2, "Relation preconditions failed"
285 rel.save_with_history!
291 # Save a way to the database, including all nodes. Any nodes in the previous
292 # version and no longer used are deleted.
295 # 0. '0' (code for success),
296 # 1. original way id (unchanged),
298 # 3. hash of renumbered nodes (old id=>new id)
300 def putway(renumberednodes, usertoken, originalway, points, attributes) #:doc:
302 # -- Initialise and carry out checks
304 uid = getuserid(usertoken)
305 if !uid then return -1,"You are not logged in, so the way could not be saved." end
307 originalway = originalway.to_i
310 if a[2] == 0 or a[2].nil? then return -2,"Server error - node with id 0 found in way #{originalway}." end
311 if a[1] == 90 then return -2,"Server error - node with lat -90 found in way #{originalway}." end
314 if points.length < 2 then return -2,"Server error - way is only #{points.length} points long." end
316 # -- Get unique nodes
322 way = Way.find(originalway)
323 uniques = way.unshared_node_ids
326 # -- Compare nodes and save changes to any that have changed
336 if renumberednodes[id]
337 id = renumberednodes[id]
344 if !fpcomp(lat, node.lat) or !fpcomp(lon, node.lon) or
345 Tags.join(n[4]) != node.tags or !node.visible?
354 node.tags = Tags.join(n[4])
356 node.save_with_history!
359 renumberednodes[id] = node.id
364 uniques = uniques - [id]
368 # -- Delete any unique nodes
371 deleteitemrelations(n, 'node')
376 node.save_with_history!
379 # -- Save revised way
381 way.tags = attributes
385 way.save_with_history!
387 [0, originalway, way.id, renumberednodes]
390 # Save POI to the database.
391 # Refuses save if the node has since become part of a way.
394 # 1. original node id (unchanged),
397 def putpoi(usertoken, id, lon, lat, tags, visible) #:doc:
398 uid = getuserid(usertoken)
399 if !uid then return -1,"You are not logged in, so the point could not be saved." end
402 visible = (visible.to_i == 1)
408 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
409 deleteitemrelations(id, 'node')
418 node.tags = Tags.join(tags)
419 node.visible = visible
420 node.save_with_history!
425 # Read POI from database
426 # (only called on revert: POIs are usually read by whichways).
428 # Returns array of id, long, lat, hash of tags.
430 def getpoi(id) #:doc:
434 return [n.id, n.lon, n.lat, n.tags_as_hash]
436 return [nil, nil, nil, '']
440 # Delete way and all constituent nodes. Also removes from any relations.
441 # Returns 0 (success), unchanged way id.
443 def deleteway(usertoken, way_id) #:doc:
444 uid = getuserid(usertoken)
445 if !uid then return -1,"You are not logged in, so the way could not be deleted." end
447 # FIXME: would be good not to make two history entries when removing
448 # two nodes from the same relation
449 user = User.find(uid)
450 way = Way.find(way_id)
451 way.unshared_node_ids.each do |n|
452 deleteitemrelations(n, 'node')
455 way.delete_with_relations_and_nodes_and_history(user)
461 # ====================================================================
464 # Remove a node or way from all relations
466 def deleteitemrelations(objid, type) #:doc:
467 relations = RelationMember.find(:all,
468 :conditions => ['member_type = ? and member_id = ?', type, objid],
469 :include => :relation).collect { |rm| rm.relation }.uniq
471 relations.each do |rel|
472 rel.members.delete_if { |x| x[0] == type and x[1] == objid }
473 rel.save_with_history!
477 # Break out node tags into a hash
478 # (should become obsolete as of API 0.6)
480 def tagstring_to_hash(a) #:doc:
482 Tags.split(a) do |k, v|
489 # (could be removed if no-one uses the username+password form)
491 def getuserid(token) #:doc:
492 if (token =~ /^(.+)\+(.+)$/) then
493 user = User.authenticate(:username => $1, :password => $2)
495 user = User.authenticate(:token => token)
498 return user ? user.id : nil;
501 # Compare two floating-point numbers to within 0.0000001
503 def fpcomp(a,b) #:doc:
504 return ((a/0.0000001).round==(b/0.0000001).round)
508 # ====================================================================
509 # Alternative SQL queries for getway/whichways
511 def sql_find_way_ids_in_area(xmin,ymin,xmax,ymax)
513 SELECT DISTINCT current_way_nodes.id AS wayid
514 FROM current_way_nodes
515 INNER JOIN current_nodes ON current_nodes.id=current_way_nodes.node_id
516 INNER JOIN current_ways ON current_ways.id =current_way_nodes.id
517 WHERE current_nodes.visible=1
518 AND current_ways.visible=1
519 AND #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")}
521 return ActiveRecord::Base.connection.select_all(sql).collect { |a| a['wayid'].to_i }
524 def sql_find_pois_in_area(xmin,ymin,xmax,ymax)
526 SELECT current_nodes.id,current_nodes.latitude*0.0000001 AS lat,current_nodes.longitude*0.0000001 AS lon,current_nodes.tags
528 LEFT OUTER JOIN current_way_nodes cwn ON cwn.node_id=current_nodes.id
529 WHERE current_nodes.visible=1
531 AND #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")}
533 return ActiveRecord::Base.connection.select_all(sql).collect { |n| [n['id'].to_i,n['lon'].to_f,n['lat'].to_f,tagstring_to_hash(n['tags'])] }
536 def sql_find_relations_in_area_and_ways(xmin,ymin,xmax,ymax,way_ids)
537 # ** It would be more Potlatchy to get relations for nodes within ways
538 # during 'getway', not here
540 SELECT DISTINCT cr.id AS relid
541 FROM current_relations cr
542 INNER JOIN current_relation_members crm ON crm.id=cr.id
543 INNER JOIN current_nodes cn ON crm.member_id=cn.id AND crm.member_type='node'
544 WHERE #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "cn.")}
546 unless way_ids.empty?
549 SELECT DISTINCT cr.id AS relid
550 FROM current_relations cr
551 INNER JOIN current_relation_members crm ON crm.id=cr.id
552 WHERE crm.member_type='way'
553 AND crm.member_id IN (#{way_ids.join(',')})
556 return ActiveRecord::Base.connection.select_all(sql).collect { |a| a['relid'].to_i }.uniq
559 def sql_get_nodes_in_way(wayid)
562 SELECT latitude*0.0000001 AS lat,longitude*0.0000001 AS lon,current_nodes.id,tags
563 FROM current_way_nodes,current_nodes
564 WHERE current_way_nodes.id=#{wayid.to_i}
565 AND current_way_nodes.node_id=current_nodes.id
566 AND current_nodes.visible=1
569 ActiveRecord::Base.connection.select_all(sql).each do |row|
570 points << [row['lon'].to_f,row['lat'].to_f,row['id'].to_i,nil,tagstring_to_hash(row['tags'])]
575 def sql_get_tags_in_way(wayid)
577 ActiveRecord::Base.connection.select_all("SELECT k,v FROM current_way_tags WHERE id=#{wayid.to_i}").each do |row|
578 tags[row['k']]=row['v']
586 # indent-tabs-mode: t