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.rb
8 # Author:: editions Systeme D / Richard Fairhurst 2004-2008
9 # Licence:: public domain.
11 # == General structure
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.
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 .
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 # return(-3,["type",v],id) <-- version conflict
30 # return(-4,"type",id) <-- object not found
31 # -5 indicates the method wasn't called (due to a previous error)
33 # To write to the Rails log, use logger.info("message").
36 # * version conflict when POIs and ways are reverted
38 class AmfController < ApplicationController
41 # Help methods for checking boundary sanity and area size
44 before_filter :check_api_writable
46 # Main AMF handlers: process the raw AMF string (using AMF library) and
47 # calls each action (private method) accordingly.
52 self.content_type = Mime::AMF
53 self.response_body = Dispatcher.new(request.raw_post) do |message,*args|
54 logger.info("Executing AMF #{message}(#{args.join(',')})")
57 when 'getpresets'; result = getpresets(*args)
58 when 'whichways'; result = whichways(*args)
59 when 'whichways_deleted'; result = whichways_deleted(*args)
60 when 'getway'; result = getway(args[0].to_i)
61 when 'getrelation'; result = getrelation(args[0].to_i)
62 when 'getway_old'; result = getway_old(args[0].to_i,args[1])
63 when 'getway_history'; result = getway_history(args[0].to_i)
64 when 'getnode_history'; result = getnode_history(args[0].to_i)
65 when 'findgpx'; result = findgpx(*args)
66 when 'findrelations'; result = findrelations(*args)
67 when 'getpoi'; result = getpoi(*args)
73 render :nothing => true, :status => :method_not_allowed
79 renumberednodes = {} # Shared across repeated putways
80 renumberedways = {} # Shared across repeated putways
81 err = false # Abort batch on error
84 self.content_type = Mime::AMF
85 self.response_body = Dispatcher.new(request.raw_post) do |message,*args|
86 logger.info("Executing AMF #{message}")
92 when 'putway'; orn = renumberednodes.dup
93 result = putway(renumberednodes, *args)
94 result[4] = renumberednodes.reject { |k,v| orn.has_key?(k) }
95 if result[0] == 0 and result[2] != result[3] then renumberedways[result[2]] = result[3] end
96 when 'putrelation'; result = putrelation(renumberednodes, renumberedways, *args)
97 when 'deleteway'; result = deleteway(*args)
98 when 'putpoi'; result = putpoi(*args)
99 if result[0] == 0 and result[2] != result[3] then renumberednodes[result[2]] = result[3] end
100 when 'startchangeset'; result = startchangeset(*args)
103 err = true if result[0] == -3 # If a conflict is detected, don't execute any more writes
109 render :nothing => true, :status => :method_not_allowed
115 def amf_handle_error(call,rootobj,rootid)
117 rescue OSM::APIAlreadyDeletedError => ex
118 return [-4, ex.object, ex.object_id]
119 rescue OSM::APIVersionMismatchError => ex
120 return [-3, [rootobj, rootid], [ex.type.downcase, ex.id, ex.latest]]
121 rescue OSM::APIUserChangesetMismatchError => ex
123 rescue OSM::APIBadBoundingBox => ex
124 return [-2, "Sorry - I can't get the map for that area. The server said: #{ex.to_s}"]
125 rescue OSM::APIError => ex
127 rescue Exception => ex
128 return [-2, "An unusual error happened (in #{call}). The server said: #{ex.to_s}"]
131 def amf_handle_error_with_timeout(call,rootobj,rootid)
132 amf_handle_error(call,rootobj,rootid) do
133 Timeout::timeout(API_TIMEOUT, OSM::APITimeoutError) do
139 # Start new changeset
140 # Returns success_code,success_message,changeset id
142 def startchangeset(usertoken, cstags, closeid, closecomment, opennew)
143 amf_handle_error("'startchangeset'",nil,nil) do
144 user = getuser(usertoken)
145 if !user then return -1,"You are not logged in, so Potlatch can't write any changes to the database." end
146 unless user.active_blocks.empty? then return -1,t('application.setup_user_auth.blocked') end
147 if REQUIRE_TERMS_AGREED and user.terms_agreed.nil? then return -1,"You must accept the contributor terms before you can edit." end
150 if !tags_ok(cstags) then return -1,"One of the tags is invalid. Linux users may need to upgrade to Flash Player 10.1." end
151 cstags = strip_non_xml_chars cstags
154 # close previous changeset and add comment
156 cs = Changeset.find(closeid.to_i)
157 cs.set_closed_time_now
158 if cs.user_id!=user.id
159 raise OSM::APIUserChangesetMismatchError.new
160 elsif closecomment.empty?
163 cs.tags['comment']=closecomment
164 # in case closecomment has chars not allowed in xml
165 cs.tags = strip_non_xml_chars cs.tags
170 # open a new changeset
175 if !closecomment.empty?
176 cs.tags['comment']=closecomment
177 # in case closecomment has chars not allowed in xml
178 cs.tags = strip_non_xml_chars cs.tags
180 # smsm1 doesn't like the next two lines and thinks they need to be abstracted to the model more/better
181 cs.created_at = Time.now.getutc
182 cs.closed_at = cs.created_at + Changeset::IDLE_TIMEOUT
191 # Return presets (default tags, localisation etc.):
192 # uses POTLATCH_PRESETS global, set up in OSM::Potlatch.
194 def getpresets(usertoken,lang) #:doc:
195 user = getuser(usertoken)
197 if user && !user.languages.empty?
198 request.user_preferred_languages = user.languages
201 lang = request.compatible_language_from(getlocales)
202 (real_lang, localised) = getlocalized(lang)
204 # Tell Potlatch what language it's using
205 localised["__potlatch_locale"] = real_lang
207 # Get help from i18n but delete it so we won't pass it around
209 help = localised["help_html"]
210 localised.delete("help_html")
212 # Populate icon names
213 POTLATCH_PRESETS[10].each { |id|
214 POTLATCH_PRESETS[11][id] = localised["preset_icon_#{id}"]
215 localised.delete("preset_icon_#{id}")
218 return POTLATCH_PRESETS+[localised,help]
221 def getlocalized(lang)
222 # What we end up actually using. Reported in Potlatch's created_by=* string
225 # Load English defaults
226 en = YAML::load(File.open("#{Rails.root}/config/potlatch/locales/en.yml"))["en"]
229 return [loaded_lang, en]
231 # Use English as a fallback
233 other = YAML::load(File.open("#{Rails.root}/config/potlatch/locales/#{lang}.yml"))[lang]
239 # We have to return a flat list and some of the keys won't be
240 # translated (probably)
241 return [loaded_lang, en.merge(other)]
246 # Find all the ways, POI nodes (i.e. not part of ways), and relations
247 # in a given bounding box. Nodes are returned in full; ways and relations
250 # return is of the form:
251 # [success_code, success_message,
252 # [[way_id, way_version], ...],
253 # [[node_id, lat, lon, [tags, ...], node_version], ...],
254 # [[rel_id, rel_version], ...]]
255 # where the ways are any visible ways which refer to any visible
256 # nodes in the bbox, nodes are any visible nodes in the bbox but not
257 # used in any way, rel is any relation which refers to either a way
258 # or node that we're returning.
259 def whichways(xmin, ymin, xmax, ymax) #:doc:
260 amf_handle_error_with_timeout("'whichways'",nil,nil) do
261 enlarge = [(xmax-xmin)/8,0.01].min
262 xmin -= enlarge; ymin -= enlarge
263 xmax += enlarge; ymax += enlarge
265 # check boundary is sane and area within defined
266 # see /config/application.yml
267 check_boundaries(xmin, ymin, xmax, ymax)
269 if POTLATCH_USE_SQL then
270 ways = sql_find_ways_in_area(xmin, ymin, xmax, ymax)
271 points = sql_find_pois_in_area(xmin, ymin, xmax, ymax)
272 relations = sql_find_relations_in_area_and_ways(xmin, ymin, xmax, ymax, ways.collect {|x| x[0]})
274 # find the way ids in an area
275 nodes_in_area = Node.bbox(ymin, xmin, ymax, xmax).visible.includes(:ways)
276 ways = nodes_in_area.inject([]) { |sum, node|
277 visible_ways = node.ways.select { |w| w.visible? }
278 sum + visible_ways.collect { |w| [w.id,w.version] }
282 # find the node ids in an area that aren't part of ways
283 nodes_not_used_in_area = nodes_in_area.select { |node| node.ways.empty? }
284 points = nodes_not_used_in_area.collect { |n| [n.id, n.lon, n.lat, n.tags, n.version] }.uniq
286 # find the relations used by those nodes and ways
287 relations = Relation.nodes(nodes_in_area.collect { |n| n.id }).visible +
288 Relation.ways(ways.collect { |w| w[0] }).visible
289 relations = relations.collect { |relation| [relation.id,relation.version] }.uniq
292 [0, '', ways, points, relations]
296 # Find deleted ways in current bounding box (similar to whichways, but ways
297 # with a deleted node only - not POIs or relations).
299 def whichways_deleted(xmin, ymin, xmax, ymax) #:doc:
300 amf_handle_error_with_timeout("'whichways_deleted'",nil,nil) do
301 enlarge = [(xmax-xmin)/8,0.01].min
302 xmin -= enlarge; ymin -= enlarge
303 xmax += enlarge; ymax += enlarge
305 # check boundary is sane and area within defined
306 # see /config/application.yml
307 check_boundaries(xmin, ymin, xmax, ymax)
309 nodes_in_area = Node.bbox(ymin, xmin, ymax, xmax).joins(:ways_via_history).where(:current_ways => { :visible => false })
310 way_ids = nodes_in_area.collect { |node| node.ways_via_history.invisible.collect { |way| way.id } }.flatten.uniq
316 # Get a way including nodes and tags.
317 # Returns the way id, a Potlatch-style array of points, a hash of tags, the version number, and the user ID.
319 def getway(wayid) #:doc:
320 amf_handle_error_with_timeout("'getway' #{wayid}" ,'way',wayid) do
321 if POTLATCH_USE_SQL then
322 points = sql_get_nodes_in_way(wayid)
323 tags = sql_get_tags_in_way(wayid)
324 version = sql_get_way_version(wayid)
325 uid = sql_get_way_user(wayid)
327 # Ideally we would do ":include => :nodes" here but if we do that
328 # then rails only seems to return the first copy of a node when a
329 # way includes a node more than once
330 way = Way.where(:id => wayid).preload(:nodes => :node_tags).first
332 # check case where way has been deleted or doesn't exist
333 return [-4, 'way', wayid] if way.nil? or !way.visible
335 points = way.nodes.collect do |node|
337 nodetags.delete('created_by')
338 [node.lon, node.lat, node.id, nodetags, node.version]
341 version = way.version
342 uid = way.changeset.user.id
345 [0, '', wayid, points, tags, version, uid]
349 # Get an old version of a way, and all constituent nodes.
351 # For undelete (version<0), always uses the most recent version of each node,
352 # even if it's moved. For revert (version >= 0), uses the node in existence
353 # at the time, generating a new id if it's still visible and has been moved/
359 # 2. array of points,
362 # 5. is this the current, visible version? (boolean)
364 def getway_old(id, timestamp) #:doc:
365 amf_handle_error_with_timeout("'getway_old' #{id}, #{timestamp}", 'way',id) do
368 old_way = OldWay.where(:visible => true, :way_id => id).order("version DESC").first
369 points = old_way.get_nodes_undelete unless old_way.nil?
373 timestamp = DateTime.strptime(timestamp.to_s, "%d %b %Y, %H:%M:%S")
374 old_way = OldWay.where("way_id = ? AND timestamp <= ?", id, timestamp).order("timestamp DESC").first
376 points = old_way.get_nodes_revert(timestamp)
378 return [-1, "Sorry, the way was deleted at that time - please revert to a previous version.", id]
382 # thrown by date parsing method. leave old_way as nil for
383 # the error handler below.
388 return [-1, "Sorry, the server could not find a way at that time.", id]
391 old_way.tags['history'] = "Retrieved from v#{old_way.version}"
392 return [0, '', id, points, old_way.tags, curway.version, (curway.version==old_way.version and curway.visible)]
397 # Find history of a way.
398 # Returns 'way', id, and an array of previous versions:
399 # - formerly [old_way.version, old_way.timestamp.strftime("%d %b %Y, %H:%M"), old_way.visible ? 1 : 0, user, uid]
400 # - now [timestamp,user,uid]
402 # Heuristic: Find all nodes that have ever been part of the way;
403 # get a list of their revision dates; add revision dates of the way;
404 # sort and collapse list (to within 2 seconds); trim all dates before the
405 # start date of the way.
407 def getway_history(wayid) #:doc:
409 # Find list of revision dates for way and all constituent nodes
412 Way.find(wayid).old_ways.collect do |a|
413 revdates.push(a.timestamp)
414 unless revusers.has_key?(a.timestamp.to_i) then revusers[a.timestamp.to_i]=change_user(a) end
416 Node.find(n).old_nodes.collect do |o|
417 revdates.push(o.timestamp)
418 unless revusers.has_key?(o.timestamp.to_i) then revusers[o.timestamp.to_i]=change_user(o) end
422 waycreated=revdates[0]
427 # Remove any dates (from nodes) before first revision date of way
428 revdates.delete_if { |d| d<waycreated }
429 # Remove any elements where 2 seconds doesn't elapse before next one
430 revdates.delete_if { |d| revdates.include?(d+1) or revdates.include?(d+2) }
431 # Collect all in one nested array
432 revdates.collect! {|d| [d.succ.strftime("%d %b %Y, %H:%M:%S")] + revusers[d.to_i] }
435 return ['way', wayid, revdates]
436 rescue ActiveRecord::RecordNotFound
437 return ['way', wayid, []]
441 # Find history of a node. Returns 'node', id, and an array of previous versions as above.
443 def getnode_history(nodeid) #:doc:
445 history = Node.find(nodeid).old_nodes.reverse.collect do |old_node|
446 [old_node.timestamp.succ.strftime("%d %b %Y, %H:%M:%S")] + change_user(old_node)
448 return ['node', nodeid, history]
449 rescue ActiveRecord::RecordNotFound
450 return ['node', nodeid, []]
455 user_object = obj.changeset.user
456 user = user_object.data_public? ? user_object.display_name : 'anonymous'
457 uid = user_object.data_public? ? user_object.id : 0
461 # Find GPS traces with specified name/id.
462 # Returns array listing GPXs, each one comprising id, name and description.
464 def findgpx(searchterm, usertoken)
465 amf_handle_error_with_timeout("'findgpx'" ,nil,nil) do
466 user = getuser(usertoken)
467 if !user then return -1,"You must be logged in to search for GPX traces." end
468 unless user.active_blocks.empty? then return -1,t('application.setup_user_auth.blocked') end
470 query = Trace.visible_to(user)
471 if searchterm.to_i > 0 then
472 query = query.where(:id => searchterm.to_i)
474 query = query.where("MATCH(name) AGAINST (?)", searchterm).limit(21)
476 gpxs = query.collect do |gpx|
477 [gpx.id, gpx.name, gpx.description]
483 # Get a relation with all tags and members.
489 # 4. list of members,
492 def getrelation(relid) #:doc:
493 amf_handle_error("'getrelation' #{relid}" ,'relation',relid) do
494 rel = Relation.where(:id => relid).first
496 return [-4, 'relation', relid] if rel.nil? or !rel.visible
497 [0, '', relid, rel.tags, rel.members, rel.version]
501 # Find relations with specified name/id.
502 # Returns array of relations, each in same form as getrelation.
504 def findrelations(searchterm)
506 if searchterm.to_i>0 then
507 rel = Relation.where(:id => searchterm.to_i).first
508 if rel and rel.visible then
509 rels.push([rel.id, rel.tags, rel.members, rel.version])
512 RelationTag.where("v like ?", "%#{searchterm}%").limit(11).each do |t|
513 if t.relation.visible then
514 rels.push([t.relation.id, t.relation.tags, t.relation.members, t.relation.version])
524 # 1. original relation id (unchanged),
525 # 2. new relation id,
528 def putrelation(renumberednodes, renumberedways, usertoken, changeset_id, version, relid, tags, members, visible) #:doc:
529 amf_handle_error("'putrelation' #{relid}" ,'relation',relid) do
530 user = getuser(usertoken)
531 if !user then return -1,"You are not logged in, so the relation could not be saved." end
532 unless user.active_blocks.empty? then return -1,t('application.setup_user_auth.blocked') end
533 if REQUIRE_TERMS_AGREED and user.terms_agreed.nil? then return -1,"You must accept the contributor terms before you can edit." end
535 if !tags_ok(tags) then return -1,"One of the tags is invalid. Linux users may need to upgrade to Flash Player 10.1." end
536 tags = strip_non_xml_chars tags
539 visible = (visible.to_i != 0)
543 Relation.transaction do
544 # create a new relation, or find the existing one
546 relation = Relation.find(relid)
548 # We always need a new node, based on the data that has been sent to us
549 new_relation = Relation.new
551 # check the members are all positive, and correctly type
556 mid = renumberednodes[mid] if m[0] == 'Node'
557 mid = renumberedways[mid] if m[0] == 'Way'
560 typedmembers << [m[0], mid, m[2]]
564 # assign new contents
565 new_relation.members = typedmembers
566 new_relation.tags = tags
567 new_relation.visible = visible
568 new_relation.changeset_id = changeset_id
569 new_relation.version = version
572 # We're creating the relation
573 new_relation.create_with_history(user)
575 # We're updating the relation
576 new_relation.id = relid
577 relation.update_from(new_relation, user)
579 # We're deleting the relation
580 new_relation.id = relid
581 relation.delete_with_history!(new_relation, user)
586 return [0, '', relid, new_relation.id, new_relation.version]
588 return [0, '', relid, relid, relation.version]
593 # Save a way to the database, including all nodes. Any nodes in the previous
594 # version and no longer used are deleted.
597 # 0. hash of renumbered nodes (added by amf_controller)
598 # 1. current user token (for authentication)
599 # 2. current changeset
602 # 5. list of nodes in way
603 # 6. hash of way tags
604 # 7. array of nodes to change (each one is [lon,lat,id,version,tags]),
605 # 8. hash of nodes to delete (id->version).
608 # 0. '0' (code for success),
610 # 2. original way id (unchanged),
612 # 4. hash of renumbered nodes (old id=>new id),
614 # 6. hash of node versions (node=>version)
616 def putway(renumberednodes, usertoken, changeset_id, wayversion, originalway, pointlist, attributes, nodes, deletednodes) #:doc:
617 amf_handle_error("'putway' #{originalway}" ,'way',originalway) do
620 user = getuser(usertoken)
621 if !user then return -1,"You are not logged in, so the way could not be saved." end
622 unless user.active_blocks.empty? then return -1,t('application.setup_user_auth.blocked') end
623 if REQUIRE_TERMS_AGREED and user.terms_agreed.nil? then return -1,"You must accept the contributor terms before you can edit." end
625 if pointlist.length < 2 then return -2,"Server error - way is only #{points.length} points long." end
627 if !tags_ok(attributes) then return -1,"One of the tags is invalid. Linux users may need to upgrade to Flash Player 10.1." end
628 attributes = strip_non_xml_chars attributes
630 originalway = originalway.to_i
631 pointlist.collect! {|a| a.to_i }
633 way=nil # this is returned, so scope it outside the transaction
637 # -- Update each changed node
645 if id == 0 then return -2,"Server error - node with id 0 found in way #{originalway}." end
646 if lat== 90 then return -2,"Server error - node with latitude -90 found in way #{originalway}." end
647 if renumberednodes[id] then id = renumberednodes[id] end
650 node.changeset_id = changeset_id
655 # fixup node tags in a way as well
656 if !tags_ok(node.tags) then return -1,"One of the tags is invalid. Linux users may need to upgrade to Flash Player 10.1." end
657 node.tags = strip_non_xml_chars node.tags
659 node.tags.delete('created_by')
660 node.version = version
662 # We're creating the node
663 node.create_with_history(user)
664 renumberednodes[id] = node.id
665 nodeversions[node.id] = node.version
667 # We're updating an existing node
668 previous=Node.find(id)
670 previous.update_from(node, user)
671 nodeversions[previous.id] = previous.version
675 # -- Save revised way
677 pointlist.collect! {|a|
678 renumberednodes[a] ? renumberednodes[a]:a
681 new_way.tags = attributes
682 new_way.nds = pointlist
683 new_way.changeset_id = changeset_id
684 new_way.version = wayversion
686 new_way.create_with_history(user)
687 way=new_way # so we can get way.id and way.version
689 way = Way.find(originalway)
690 if way.tags!=attributes or way.nds!=pointlist or !way.visible?
691 new_way.id=originalway
692 way.update_from(new_way, user)
696 # -- Delete unwanted nodes
698 deletednodes.each do |id,v|
699 node = Node.find(id.to_i)
701 new_node.changeset_id = changeset_id
702 new_node.version = v.to_i
703 new_node.id = id.to_i
705 node.delete_with_history!(new_node, user)
706 rescue OSM::APIPreconditionFailedError => ex
707 # We don't do anything here as the node is being used elsewhere
708 # and we don't want to delete it
714 [0, '', originalway, way.id, renumberednodes, way.version, nodeversions, deletednodes]
718 # Save POI to the database.
719 # Refuses save if the node has since become part of a way.
720 # Returns array with:
722 # 1. success message,
723 # 2. original node id (unchanged),
727 def putpoi(usertoken, changeset_id, version, id, lon, lat, tags, visible) #:doc:
728 amf_handle_error("'putpoi' #{id}", 'node',id) do
729 user = getuser(usertoken)
730 if !user then return -1,"You are not logged in, so the point could not be saved." end
731 unless user.active_blocks.empty? then return -1,t('application.setup_user_auth.blocked') end
732 if REQUIRE_TERMS_AGREED and user.terms_agreed.nil? then return -1,"You must accept the contributor terms before you can edit." end
734 if !tags_ok(tags) then return -1,"One of the tags is invalid. Linux users may need to upgrade to Flash Player 10.1." end
735 tags = strip_non_xml_chars tags
738 visible = (visible.to_i == 1)
746 unless node.ways.empty? then return -1,"Point #{id} has since become part of a way, so you cannot save it as a POI.",id,id,version end
749 # We always need a new node, based on the data that has been sent to us
752 new_node.changeset_id = changeset_id
753 new_node.version = version
758 # We're creating the node
759 new_node.create_with_history(user)
761 # We're updating the node
763 node.update_from(new_node, user)
765 # We're deleting the node
767 node.delete_with_history!(new_node, user)
773 return [0, '', id, new_node.id, new_node.version]
775 return [0, '', id, node.id, node.version]
780 # Read POI from database
781 # (only called on revert: POIs are usually read by whichways).
783 # Returns array of id, long, lat, hash of tags, (current) version.
785 def getpoi(id,timestamp) #:doc:
786 amf_handle_error("'getpoi' #{id}" ,'node',id) do
790 unless timestamp == ''
791 n = OldNode.where("id = ? AND timestamp <= ?", id, timestamp).order("timestamp DESC").first
795 return [0, '', n.id, n.lon, n.lat, n.tags, v]
797 return [-4, 'node', id]
802 # Delete way and all constituent nodes.
806 # * the id of the way to change
807 # * the version of the way that was downloaded
808 # * a hash of the id and versions of all the nodes that are in the way, if any
809 # of the nodes have been changed by someone else then, there is a problem!
810 # Returns 0 (success), unchanged way id, new way version, new node versions.
812 def deleteway(usertoken, changeset_id, way_id, way_version, deletednodes) #:doc:
813 amf_handle_error("'deleteway' #{way_id}" ,'way', way_id) do
814 user = getuser(usertoken)
815 unless user then return -1,"You are not logged in, so the way could not be deleted." end
816 unless user.active_blocks.empty? then return -1,t('application.setup_user_auth.blocked') end
817 if REQUIRE_TERMS_AGREED and user.terms_agreed.nil? then return -1,"You must accept the contributor terms before you can edit." end
821 old_way=nil # returned, so scope it outside the transaction
822 # Need a transaction so that if one item fails to delete, the whole delete fails.
827 old_way = Way.find(way_id)
829 delete_way.version = way_version
830 delete_way.changeset_id = changeset_id
831 delete_way.id = way_id
832 old_way.delete_with_history!(delete_way, user)
834 # -- Delete unwanted nodes
836 deletednodes.each do |id,v|
837 node = Node.find(id.to_i)
839 new_node.changeset_id = changeset_id
840 new_node.version = v.to_i
841 new_node.id = id.to_i
843 node.delete_with_history!(new_node, user)
844 nodeversions[node.id]=node.version
845 rescue OSM::APIPreconditionFailedError => ex
846 # We don't do anything with the exception as the node is in use
847 # elsewhere and we don't want to delete it
852 [0, '', way_id, old_way.version, nodeversions]
857 # ====================================================================
861 # (can also be of form user:pass)
862 # When we are writing to the api, we need the actual user model,
863 # not just the id, hence this abstraction
865 def getuser(token) #:doc:
866 if (token =~ /^(.+)\:(.+)$/) then
867 user = User.authenticate(:username => $1, :password => $2)
869 user = User.authenticate(:token => token)
875 Dir.glob("#{Rails.root}/config/potlatch/locales/*").collect { |f| File.basename(f, ".yml") }
879 # check that all key-value pairs are valid UTF-8.
882 return false unless UTF8.valid? k
883 return false unless UTF8.valid? v
889 # strip characters which are invalid in XML documents from the strings
890 # in the +tags+ hash.
891 def strip_non_xml_chars(tags)
895 new_k = k.delete "\000-\037", "^\011\012\015"
896 new_v = v.delete "\000-\037", "^\011\012\015"
897 new_tags[new_k] = new_v
903 # ====================================================================
904 # Alternative SQL queries for getway/whichways
906 def sql_find_ways_in_area(xmin,ymin,xmax,ymax)
908 SELECT DISTINCT current_ways.id AS wayid,current_ways.version AS version
909 FROM current_way_nodes
910 INNER JOIN current_nodes ON current_nodes.id=current_way_nodes.node_id
911 INNER JOIN current_ways ON current_ways.id =current_way_nodes.id
912 WHERE current_nodes.visible=TRUE
913 AND current_ways.visible=TRUE
914 AND #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")}
916 return ActiveRecord::Base.connection.select_all(sql).collect { |a| [a['wayid'].to_i,a['version'].to_i] }
919 def sql_find_pois_in_area(xmin,ymin,xmax,ymax)
922 SELECT current_nodes.id,current_nodes.latitude*0.0000001 AS lat,current_nodes.longitude*0.0000001 AS lon,current_nodes.version
924 LEFT OUTER JOIN current_way_nodes cwn ON cwn.node_id=current_nodes.id
925 WHERE current_nodes.visible=TRUE
927 AND #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "current_nodes.")}
929 ActiveRecord::Base.connection.select_all(sql).each do |row|
931 ActiveRecord::Base.connection.select_all("SELECT k,v FROM current_node_tags WHERE id=#{row['id']}").each do |n|
932 poitags[n['k']]=n['v']
934 pois << [row['id'].to_i, row['lon'].to_f, row['lat'].to_f, poitags, row['version'].to_i]
939 def sql_find_relations_in_area_and_ways(xmin,ymin,xmax,ymax,way_ids)
940 # ** It would be more Potlatchy to get relations for nodes within ways
941 # during 'getway', not here
943 SELECT DISTINCT cr.id AS relid,cr.version AS version
944 FROM current_relations cr
945 INNER JOIN current_relation_members crm ON crm.id=cr.id
946 INNER JOIN current_nodes cn ON crm.member_id=cn.id AND crm.member_type='Node'
947 WHERE #{OSM.sql_for_area(ymin, xmin, ymax, xmax, "cn.")}
949 unless way_ids.empty?
952 SELECT DISTINCT cr.id AS relid,cr.version AS version
953 FROM current_relations cr
954 INNER JOIN current_relation_members crm ON crm.id=cr.id
955 WHERE crm.member_type='Way'
956 AND crm.member_id IN (#{way_ids.join(',')})
959 ActiveRecord::Base.connection.select_all(sql).collect { |a| [a['relid'].to_i,a['version'].to_i] }
962 def sql_get_nodes_in_way(wayid)
965 SELECT latitude*0.0000001 AS lat,longitude*0.0000001 AS lon,current_nodes.id,current_nodes.version
966 FROM current_way_nodes,current_nodes
967 WHERE current_way_nodes.id=#{wayid.to_i}
968 AND current_way_nodes.node_id=current_nodes.id
969 AND current_nodes.visible=TRUE
972 ActiveRecord::Base.connection.select_all(sql).each do |row|
974 ActiveRecord::Base.connection.select_all("SELECT k,v FROM current_node_tags WHERE id=#{row['id']}").each do |n|
975 nodetags[n['k']]=n['v']
977 nodetags.delete('created_by')
978 points << [row['lon'].to_f,row['lat'].to_f,row['id'].to_i,nodetags,row['version'].to_i]
983 def sql_get_tags_in_way(wayid)
985 ActiveRecord::Base.connection.select_all("SELECT k,v FROM current_way_tags WHERE id=#{wayid.to_i}").each do |row|
986 tags[row['k']]=row['v']
991 def sql_get_way_version(wayid)
992 ActiveRecord::Base.connection.select_one("SELECT version FROM current_ways WHERE id=#{wayid.to_i}")['version']
995 def sql_get_way_user(wayid)
996 ActiveRecord::Base.connection.select_one("SELECT user FROM current_ways,changesets WHERE current_ways.id=#{wayid.to_i} AND current_ways.changeset=changesets.id")['user']