]> git.openstreetmap.org Git - rails.git/blob - app/controllers/api/amf_controller.rb
Remove link_to_if since it's in a clause with the same condition
[rails.git] / app / controllers / api / amf_controller.rb
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).
5 #
6 # Helper functions are in /lib/potlatch.rb
7 #
8 # Author::  editions Systeme D / Richard Fairhurst 2004-2008
9 # Licence:: public domain.
10 #
11 # == General structure
12 #
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.
17 #
18 # == API 0.6
19 #
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 .
23 #
24 # == Debugging
25 #
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)
32 #
33 # To write to the Rails log, use logger.info("message").
34
35 # Remaining issues:
36 # * version conflict when POIs and ways are reverted
37
38 module Api
39   class AmfController < ApiController
40     require "timeout"
41
42     include Potlatch
43
44     before_action :check_api_writable
45
46     # AMF Controller implements its own authentication and authorization checks
47     # completely independently of the rest of the codebase, so best just to let
48     # it keep doing its own thing.
49     skip_authorization_check
50
51     # Main AMF handlers: process the raw AMF string (using AMF library) and
52     # calls each action (private method) accordingly.
53
54     def amf_read
55       self.status = :ok
56       self.content_type = Mime[:amf]
57       self.response_body = Dispatcher.new(request.raw_post) do |message, *args|
58         logger.info("Executing AMF #{message}(#{args.join(',')})")
59
60         case message
61         when "getpresets" then        result = getpresets(*args)
62         when "whichways" then         result = whichways(*args)
63         when "whichways_deleted" then result = whichways_deleted(*args)
64         when "getway" then            result = getway(args[0].to_i)
65         when "getrelation" then       result = getrelation(args[0].to_i)
66         when "getway_old" then        result = getway_old(args[0].to_i, args[1])
67         when "getway_history" then    result = getway_history(args[0].to_i)
68         when "getnode_history" then   result = getnode_history(args[0].to_i)
69         when "findgpx" then           result = findgpx(*args)
70         when "findrelations" then     result = findrelations(*args)
71         when "getpoi" then            result = getpoi(*args)
72         end
73
74         result
75       end
76     end
77
78     def amf_write
79       renumberednodes = {}              # Shared across repeated putways
80       renumberedways = {}               # Shared across repeated putways
81       err = false                       # Abort batch on error
82
83       self.status = :ok
84       self.content_type = Mime[:amf]
85       self.response_body = Dispatcher.new(request.raw_post) do |message, *args|
86         logger.info("Executing AMF #{message}")
87
88         if err
89           result = [-5, nil]
90         else
91           case message
92           when "putway"
93             orn = renumberednodes.dup
94             result = putway(renumberednodes, *args)
95             result[4] = renumberednodes.reject { |k, _v| orn.key?(k) }
96             renumberedways[result[2]] = result[3] if result[0].zero? && result[2] != result[3]
97           when "putrelation"
98             result = putrelation(renumberednodes, renumberedways, *args)
99           when "deleteway"
100             result = deleteway(*args)
101           when "putpoi"
102             result = putpoi(*args)
103             renumberednodes[result[2]] = result[3] if result[0].zero? && result[2] != result[3]
104           when "startchangeset"
105             result = startchangeset(*args)
106           end
107
108           err = true if result[0] == -3 # If a conflict is detected, don't execute any more writes
109         end
110
111         result
112       end
113     end
114
115     private
116
117     def amf_handle_error(call, rootobj, rootid)
118       yield
119     rescue OSM::APIAlreadyDeletedError => e
120       [-4, e.object, e.object_id]
121     rescue OSM::APIVersionMismatchError => e
122       [-3, [rootobj, rootid], [e.type.downcase, e.id, e.latest]]
123     rescue OSM::APIUserChangesetMismatchError => e
124       [-2, e.to_s]
125     rescue OSM::APIBadBoundingBox => e
126       [-2, "Sorry - I can't get the map for that area. The server said: #{e}"]
127     rescue OSM::APIError => e
128       [-1, e.to_s]
129     rescue StandardError => e
130       [-2, "An unusual error happened (in #{call}). The server said: #{e}"]
131     end
132
133     def amf_handle_error_with_timeout(call, rootobj, rootid, &block)
134       amf_handle_error(call, rootobj, rootid) do
135         Timeout.timeout(Settings.api_timeout, OSM::APITimeoutError, &block)
136       end
137     end
138
139     # Start new changeset
140     # Returns success_code,success_message,changeset id
141
142     def startchangeset(usertoken, cstags, closeid, closecomment, opennew)
143       amf_handle_error("'startchangeset'", nil, nil) do
144         user = getuser(usertoken)
145         return -1, "You are not logged in, so Potlatch can't write any changes to the database." unless user
146         return -1, t("application.setup_user_auth.blocked") if user.blocks.active.exists?
147         return -1, "You must accept the contributor terms before you can edit." if user.terms_agreed.nil?
148
149         if cstags
150           return -1, "One of the tags is invalid. Linux users may need to upgrade to Flash Player 10.1." unless tags_ok(cstags)
151
152           cstags = strip_non_xml_chars cstags
153         end
154
155         # close previous changeset and add comment
156         if closeid
157           cs = Changeset.find(closeid.to_i)
158           cs.set_closed_time_now
159           if cs.user_id != user.id
160             raise OSM::APIUserChangesetMismatchError
161           elsif closecomment.empty?
162             cs.save!
163           else
164             cs.tags["comment"] = closecomment
165             # in case closecomment has chars not allowed in xml
166             cs.tags = strip_non_xml_chars cs.tags
167             cs.save_with_tags!
168           end
169         end
170
171         # open a new changeset
172         if opennew.nonzero?
173           cs = Changeset.new
174           cs.tags = cstags
175           cs.user_id = user.id
176           unless closecomment.empty?
177             cs.tags["comment"] = closecomment
178             # in case closecomment has chars not allowed in xml
179             cs.tags = strip_non_xml_chars cs.tags
180           end
181           # smsm1 doesn't like the next two lines and thinks they need to be abstracted to the model more/better
182           cs.created_at = Time.now.getutc
183           cs.closed_at = cs.created_at + Changeset::IDLE_TIMEOUT
184           cs.save_with_tags!
185           return [0, "", cs.id]
186         else
187           return [0, "", nil]
188         end
189       end
190     end
191
192     # Return presets (default tags, localisation etc.):
193     # uses POTLATCH_PRESETS global, set up in OSM::Potlatch.
194
195     def getpresets(usertoken, _lang)
196       user = getuser(usertoken)
197
198       langs = if user && !user.languages.empty?
199                 Locale.list(user.languages)
200               else
201                 Locale.list(http_accept_language.user_preferred_languages)
202               end
203
204       lang = getlocales.preferred(langs)
205       (real_lang, localised) = getlocalized(lang.to_s)
206
207       # Tell Potlatch what language it's using
208       localised["__potlatch_locale"] = real_lang
209
210       # Get help from i18n but delete it so we won't pass it around
211       # twice for nothing
212       help = localised["help_html"]
213       localised.delete("help_html")
214
215       # Populate icon names
216       POTLATCH_PRESETS[10].each do |id|
217         POTLATCH_PRESETS[11][id] = localised["preset_icon_#{id}"]
218         localised.delete("preset_icon_#{id}")
219       end
220
221       POTLATCH_PRESETS + [localised, help]
222     end
223
224     def getlocalized(lang)
225       # What we end up actually using. Reported in Potlatch's created_by=* string
226       loaded_lang = "en"
227
228       # Load English defaults
229       en = YAML.safe_load(File.open(Rails.root.join("config/potlatch/locales/en.yml")))["en"]
230
231       if lang == "en"
232         [loaded_lang, en]
233       else
234         # Use English as a fallback
235         begin
236           other = YAML.safe_load(File.open(Rails.root.join("config/potlatch/locales/#{lang}.yml")))[lang]
237           loaded_lang = lang
238         rescue StandardError
239           other = en
240         end
241
242         # We have to return a flat list and some of the keys won't be
243         # translated (probably)
244         [loaded_lang, en.merge(other)]
245       end
246     end
247
248     ##
249     # Find all the ways, POI nodes (i.e. not part of ways), and relations
250     # in a given bounding box. Nodes are returned in full; ways and relations
251     # are IDs only.
252     #
253     # return is of the form:
254     # [success_code, success_message,
255     #  [[way_id, way_version], ...],
256     #  [[node_id, lat, lon, [tags, ...], node_version], ...],
257     #  [[rel_id, rel_version], ...]]
258     # where the ways are any visible ways which refer to any visible
259     # nodes in the bbox, nodes are any visible nodes in the bbox but not
260     # used in any way, rel is any relation which refers to either a way
261     # or node that we're returning.
262     def whichways(xmin, ymin, xmax, ymax)
263       amf_handle_error_with_timeout("'whichways'", nil, nil) do
264         enlarge = [(xmax - xmin) / 8, 0.01].min
265         xmin -= enlarge
266         ymin -= enlarge
267         xmax += enlarge
268         ymax += enlarge
269
270         # check boundary is sane and area within defined
271         # see /config/application.yml
272         bbox = BoundingBox.new(xmin, ymin, xmax, ymax)
273         bbox.check_boundaries
274         bbox.check_size
275
276         if POTLATCH_USE_SQL
277           ways = sql_find_ways_in_area(bbox)
278           points = sql_find_pois_in_area(bbox)
279           relations = sql_find_relations_in_area_and_ways(bbox, ways.collect { |x| x[0] })
280         else
281           # find the way ids in an area
282           nodes_in_area = Node.bbox(bbox).visible.includes(:ways)
283           ways = nodes_in_area.inject([]) do |sum, node|
284             visible_ways = node.ways.select(&:visible?)
285             sum + visible_ways.collect { |w| [w.id, w.version] }
286           end.uniq
287           ways.delete([])
288
289           # find the node ids in an area that aren't part of ways
290           nodes_not_used_in_area = nodes_in_area.select { |node| node.ways.empty? }
291           points = nodes_not_used_in_area.collect { |n| [n.id, n.lon, n.lat, n.tags, n.version] }.uniq
292
293           # find the relations used by those nodes and ways
294           relations = Relation.nodes(nodes_in_area.collect(&:id)).visible +
295                       Relation.ways(ways.collect { |w| w[0] }).visible
296           relations = relations.collect { |relation| [relation.id, relation.version] }.uniq
297         end
298
299         [0, "", ways, points, relations]
300       end
301     end
302
303     # Find deleted ways in current bounding box (similar to whichways, but ways
304     # with a deleted node only - not POIs or relations).
305
306     def whichways_deleted(xmin, ymin, xmax, ymax)
307       amf_handle_error_with_timeout("'whichways_deleted'", nil, nil) do
308         enlarge = [(xmax - xmin) / 8, 0.01].min
309         xmin -= enlarge
310         ymin -= enlarge
311         xmax += enlarge
312         ymax += enlarge
313
314         # check boundary is sane and area within defined
315         # see /config/application.yml
316         bbox = BoundingBox.new(xmin, ymin, xmax, ymax)
317         bbox.check_boundaries
318         bbox.check_size
319
320         nodes_in_area = Node.bbox(bbox).joins(:ways_via_history).where(:current_ways => { :visible => false })
321         way_ids = nodes_in_area.collect { |node| node.ways_via_history.invisible.collect(&:id) }.flatten.uniq
322
323         [0, "", way_ids]
324       end
325     end
326
327     # Get a way including nodes and tags.
328     # Returns the way id, a Potlatch-style array of points, a hash of tags, the version number, and the user ID.
329
330     def getway(wayid)
331       amf_handle_error_with_timeout("'getway' #{wayid}", "way", wayid) do
332         if POTLATCH_USE_SQL
333           points = sql_get_nodes_in_way(wayid)
334           tags = sql_get_tags_in_way(wayid)
335           version = sql_get_way_version(wayid)
336           uid = sql_get_way_user(wayid)
337         else
338           # Ideally we would do ":include => :nodes" here but if we do that
339           # then rails only seems to return the first copy of a node when a
340           # way includes a node more than once
341           way = Way.where(:id => wayid).first
342
343           # check case where way has been deleted or doesn't exist
344           return [-4, "way", wayid] if way.nil? || !way.visible
345
346           points = way.nodes.preload(:node_tags).collect do |node|
347             nodetags = node.tags
348             nodetags.delete("created_by")
349             [node.lon, node.lat, node.id, nodetags, node.version]
350           end
351           tags = way.tags
352           version = way.version
353           uid = way.changeset.user.id
354         end
355
356         [0, "", wayid, points, tags, version, uid]
357       end
358     end
359
360     # Get an old version of a way, and all constituent nodes.
361     #
362     # For undelete (version<0), always uses the most recent version of each node,
363     # even if it's moved.  For revert (version >= 0), uses the node in existence
364     # at the time, generating a new id if it's still visible and has been moved/
365     # retagged.
366     #
367     # Returns:
368     # 0. success code,
369     # 1. id,
370     # 2. array of points,
371     # 3. hash of tags,
372     # 4. version,
373     # 5. is this the current, visible version? (boolean)
374
375     def getway_old(id, timestamp)
376       amf_handle_error_with_timeout("'getway_old' #{id}, #{timestamp}", "way", id) do
377         if timestamp == ""
378           # undelete
379           old_way = OldWay.where(:visible => true, :way_id => id).unredacted.order("version DESC").first
380           points = old_way.get_nodes_undelete unless old_way.nil?
381         else
382           begin
383             # revert
384             timestamp = Time.zone.strptime(timestamp.to_s, "%d %b %Y, %H:%M:%S")
385             old_way = OldWay.where("way_id = ? AND timestamp <= ?", id, timestamp).unredacted.order("timestamp DESC").first
386             unless old_way.nil?
387               if old_way.visible
388                 points = old_way.get_nodes_revert(timestamp)
389               else
390                 return [-1, "Sorry, the way was deleted at that time - please revert to a previous version.", id]
391               end
392             end
393           rescue ArgumentError
394             # thrown by date parsing method. leave old_way as nil for
395             # the error handler below.
396             old_way = nil
397           end
398         end
399
400         if old_way.nil?
401           return [-1, "Sorry, the server could not find a way at that time.", id]
402         else
403           curway = Way.find(id)
404           old_way.tags["history"] = "Retrieved from v#{old_way.version}"
405           return [0, "", id, points, old_way.tags, curway.version, (curway.version == old_way.version && curway.visible)]
406         end
407       end
408     end
409
410     # Find history of a way.
411     # Returns 'way', id, and an array of previous versions:
412     # - formerly [old_way.version, old_way.timestamp.strftime("%d %b %Y, %H:%M"), old_way.visible ? 1 : 0, user, uid]
413     # - now [timestamp,user,uid]
414     #
415     # Heuristic: Find all nodes that have ever been part of the way;
416     # get a list of their revision dates; add revision dates of the way;
417     # sort and collapse list (to within 2 seconds); trim all dates before the
418     # start date of the way.
419
420     def getway_history(wayid)
421       revdates = []
422       revusers = {}
423       Way.find(wayid).old_ways.unredacted.collect do |a|
424         revdates.push(a.timestamp)
425         revusers[a.timestamp.to_i] = change_user(a) unless revusers.key?(a.timestamp.to_i)
426         a.nds.each do |n|
427           Node.find(n).old_nodes.unredacted.collect do |o|
428             revdates.push(o.timestamp)
429             revusers[o.timestamp.to_i] = change_user(o) unless revusers.key?(o.timestamp.to_i)
430           end
431         end
432       end
433       waycreated = revdates[0]
434       revdates.uniq!
435       revdates.sort!
436       revdates.reverse!
437
438       # Remove any dates (from nodes) before first revision date of way
439       revdates.delete_if { |d| d < waycreated }
440       # Remove any elements where 2 seconds doesn't elapse before next one
441       revdates.delete_if { |d| revdates.include?(d + 1) || revdates.include?(d + 2) }
442       # Collect all in one nested array
443       revdates.collect! { |d| [(d + 1).strftime("%d %b %Y, %H:%M:%S")] + revusers[d.to_i] }
444       revdates.uniq!
445
446       ["way", wayid, revdates]
447     rescue ActiveRecord::RecordNotFound
448       ["way", wayid, []]
449     end
450
451     # Find history of a node. Returns 'node', id, and an array of previous versions as above.
452
453     def getnode_history(nodeid)
454       history = Node.find(nodeid).old_nodes.unredacted.reverse.collect do |old_node|
455         [(old_node.timestamp + 1).strftime("%d %b %Y, %H:%M:%S")] + change_user(old_node)
456       end
457       ["node", nodeid, history]
458     rescue ActiveRecord::RecordNotFound
459       ["node", nodeid, []]
460     end
461
462     def change_user(obj)
463       user_object = obj.changeset.user
464       user = user_object.data_public? ? user_object.display_name : "anonymous"
465       uid  = user_object.data_public? ? user_object.id : 0
466       [user, uid]
467     end
468
469     # Find GPS traces with specified name/id.
470     # Returns array listing GPXs, each one comprising id, name and description.
471
472     def findgpx(searchterm, usertoken)
473       amf_handle_error_with_timeout("'findgpx'", nil, nil) do
474         user = getuser(usertoken)
475
476         return -1, "You must be logged in to search for GPX traces." unless user
477         return -1, t("application.setup_user_auth.blocked") if user.blocks.active.exists?
478
479         query = Trace.visible_to(user)
480         query = if searchterm.to_i.positive?
481                   query.where(:id => searchterm.to_i)
482                 else
483                   query.where("MATCH(name) AGAINST (?)", searchterm).limit(21)
484                 end
485         gpxs = query.collect do |gpx|
486           [gpx.id, gpx.name, gpx.description]
487         end
488         [0, "", gpxs]
489       end
490     end
491
492     # Get a relation with all tags and members.
493     # Returns:
494     # 0. success code?
495     # 1. object type?
496     # 2. relation id,
497     # 3. hash of tags,
498     # 4. list of members,
499     # 5. version.
500
501     def getrelation(relid)
502       amf_handle_error("'getrelation' #{relid}", "relation", relid) do
503         rel = Relation.where(:id => relid).first
504
505         return [-4, "relation", relid] if rel.nil? || !rel.visible
506
507         [0, "", relid, rel.tags, rel.members, rel.version]
508       end
509     end
510
511     # Find relations with specified name/id.
512     # Returns array of relations, each in same form as getrelation.
513
514     def findrelations(searchterm)
515       rels = []
516       if searchterm.to_i.positive?
517         rel = Relation.where(:id => searchterm.to_i).first
518         rels.push([rel.id, rel.tags, rel.members, rel.version]) if rel&.visible
519       else
520         RelationTag.where("v like ?", "%#{searchterm}%").limit(11).each do |t|
521           rels.push([t.relation.id, t.relation.tags, t.relation.members, t.relation.version]) if t.relation.visible
522         end
523       end
524       rels
525     end
526
527     # Save a relation.
528     # Returns
529     # 0. 0 (success),
530     # 1. original relation id (unchanged),
531     # 2. new relation id,
532     # 3. version.
533
534     def putrelation(renumberednodes, renumberedways, usertoken, changeset_id, version, relid, tags, members, visible)
535       amf_handle_error("'putrelation' #{relid}", "relation", relid) do
536         user = getuser(usertoken)
537
538         return -1, "You are not logged in, so the relation could not be saved." unless user
539         return -1, t("application.setup_user_auth.blocked") if user.blocks.active.exists?
540         return -1, "You must accept the contributor terms before you can edit." if user.terms_agreed.nil?
541
542         return -1, "One of the tags is invalid. Linux users may need to upgrade to Flash Player 10.1." unless tags_ok(tags)
543
544         tags = strip_non_xml_chars tags
545
546         relid = relid.to_i
547         visible = visible.to_i.nonzero?
548
549         new_relation = nil
550         relation = nil
551         Relation.transaction do
552           # create a new relation, or find the existing one
553           relation = Relation.find(relid) if relid.positive?
554           # We always need a new node, based on the data that has been sent to us
555           new_relation = Relation.new
556
557           # check the members are all positive, and correctly type
558           typedmembers = []
559           members.each do |m|
560             mid = m[1].to_i
561             if mid.negative?
562               mid = renumberednodes[mid] if m[0] == "Node"
563               mid = renumberedways[mid] if m[0] == "Way"
564             end
565             typedmembers << [m[0], mid, m[2].delete("\000-\037\ufffe\uffff", "^\011\012\015")] if mid
566           end
567
568           # assign new contents
569           new_relation.members = typedmembers
570           new_relation.tags = tags
571           new_relation.visible = visible
572           new_relation.changeset_id = changeset_id.to_i
573           new_relation.version = version
574
575           if relid <= 0
576             # We're creating the relation
577             new_relation.create_with_history(user)
578           elsif visible
579             # We're updating the relation
580             new_relation.id = relid
581             relation.update_from(new_relation, user)
582           else
583             # We're deleting the relation
584             new_relation.id = relid
585             relation.delete_with_history!(new_relation, user)
586           end
587         end
588
589         if relid <= 0
590           return [0, "", relid, new_relation.id, new_relation.version]
591         else
592           return [0, "", relid, relid, relation.version]
593         end
594       end
595     end
596
597     # Save a way to the database, including all nodes. Any nodes in the previous
598     # version and no longer used are deleted.
599     #
600     # Parameters:
601     # 0. hash of renumbered nodes (added by amf_controller)
602     # 1. current user token (for authentication)
603     # 2. current changeset
604     # 3. new way version
605     # 4. way ID
606     # 5. list of nodes in way
607     # 6. hash of way tags
608     # 7. array of nodes to change (each one is [lon,lat,id,version,tags]),
609     # 8. hash of nodes to delete (id->version).
610     #
611     # Returns:
612     # 0. '0' (code for success),
613     # 1. message,
614     # 2. original way id (unchanged),
615     # 3. new way id,
616     # 4. hash of renumbered nodes (old id=>new id),
617     # 5. way version,
618     # 6. hash of changed node versions (node=>version)
619     # 7. hash of deleted node versions (node=>version)
620
621     def putway(renumberednodes, usertoken, changeset_id, wayversion, originalway, pointlist, attributes, nodes, deletednodes)
622       amf_handle_error("'putway' #{originalway}", "way", originalway) do
623         # -- Initialise
624
625         user = getuser(usertoken)
626         return -1, "You are not logged in, so the way could not be saved." unless user
627         return -1, t("application.setup_user_auth.blocked") if user.blocks.active.exists?
628         return -1, "You must accept the contributor terms before you can edit." if user.terms_agreed.nil?
629
630         return -2, "Server error - way is only #{pointlist.length} points long." if pointlist.length < 2
631
632         return -1, "One of the tags is invalid. Linux users may need to upgrade to Flash Player 10.1." unless tags_ok(attributes)
633
634         attributes = strip_non_xml_chars attributes
635
636         originalway = originalway.to_i
637         pointlist.collect!(&:to_i)
638
639         way = nil # this is returned, so scope it outside the transaction
640         nodeversions = {}
641         Way.transaction do
642           # -- Update each changed node
643
644           nodes.each do |a|
645             lon = a[0].to_f
646             lat = a[1].to_f
647             id = a[2].to_i
648             version = a[3].to_i
649
650             return -2, "Server error - node with id 0 found in way #{originalway}." if id.zero?
651             return -2, "Server error - node with latitude -90 found in way #{originalway}." if lat == 90
652
653             id = renumberednodes[id] if renumberednodes[id]
654
655             node = Node.new
656             node.changeset_id = changeset_id.to_i
657             node.lat = lat
658             node.lon = lon
659             node.tags = a[4]
660
661             # fixup node tags in a way as well
662             return -1, "One of the tags is invalid. Linux users may need to upgrade to Flash Player 10.1." unless tags_ok(node.tags)
663
664             node.tags = strip_non_xml_chars node.tags
665
666             node.tags.delete("created_by")
667             node.version = version
668             if id <= 0
669               # We're creating the node
670               node.create_with_history(user)
671               renumberednodes[id] = node.id
672               nodeversions[node.id] = node.version
673             else
674               # We're updating an existing node
675               previous = Node.find(id)
676               node.id = id
677               previous.update_from(node, user)
678               nodeversions[previous.id] = previous.version
679             end
680           end
681
682           # -- Save revised way
683
684           pointlist.collect! do |a|
685             renumberednodes[a] || a
686           end
687           new_way = Way.new
688           new_way.tags = attributes
689           new_way.nds = pointlist
690           new_way.changeset_id = changeset_id.to_i
691           new_way.version = wayversion
692           if originalway <= 0
693             new_way.create_with_history(user)
694             way = new_way # so we can get way.id and way.version
695           else
696             way = Way.find(originalway)
697             if way.tags != attributes || way.nds != pointlist || !way.visible?
698               new_way.id = originalway
699               way.update_from(new_way, user)
700             end
701           end
702
703           # -- Delete unwanted nodes
704
705           deletednodes.each do |id, v|
706             node = Node.find(id.to_i)
707             new_node = Node.new
708             new_node.changeset_id = changeset_id.to_i
709             new_node.version = v.to_i
710             new_node.id = id.to_i
711             begin
712               node.delete_with_history!(new_node, user)
713             rescue OSM::APIPreconditionFailedError
714               # We don't do anything here as the node is being used elsewhere
715               # and we don't want to delete it
716             end
717           end
718         end
719
720         [0, "", originalway, way.id, renumberednodes, way.version, nodeversions, deletednodes]
721       end
722     end
723
724     # Save POI to the database.
725     # Refuses save if the node has since become part of a way.
726     # Returns array with:
727     # 0. 0 (success),
728     # 1. success message,
729     # 2. original node id (unchanged),
730     # 3. new node id,
731     # 4. version.
732
733     def putpoi(usertoken, changeset_id, version, id, lon, lat, tags, visible)
734       amf_handle_error("'putpoi' #{id}", "node", id) do
735         user = getuser(usertoken)
736         return -1, "You are not logged in, so the point could not be saved." unless user
737         return -1, t("application.setup_user_auth.blocked") if user.blocks.active.exists?
738         return -1, "You must accept the contributor terms before you can edit." if user.terms_agreed.nil?
739
740         return -1, "One of the tags is invalid. Linux users may need to upgrade to Flash Player 10.1." unless tags_ok(tags)
741
742         tags = strip_non_xml_chars tags
743
744         id = id.to_i
745         visible = (visible.to_i == 1)
746         node = nil
747         new_node = nil
748         Node.transaction do
749           if id.positive?
750             begin
751               node = Node.find(id)
752             rescue ActiveRecord::RecordNotFound
753               return [-4, "node", id]
754             end
755
756             return -1, "Point #{id} has since become part of a way, so you cannot save it as a POI.", id, id, version unless visible || node.ways.empty?
757           end
758           # We always need a new node, based on the data that has been sent to us
759           new_node = Node.new
760
761           new_node.changeset_id = changeset_id.to_i
762           new_node.version = version
763           new_node.lat = lat
764           new_node.lon = lon
765           new_node.tags = tags
766           if id <= 0
767             # We're creating the node
768             new_node.create_with_history(user)
769           elsif visible
770             # We're updating the node
771             new_node.id = id
772             node.update_from(new_node, user)
773           else
774             # We're deleting the node
775             new_node.id = id
776             node.delete_with_history!(new_node, user)
777           end
778         end
779
780         if id <= 0
781           return [0, "", id, new_node.id, new_node.version]
782         else
783           return [0, "", id, node.id, node.version]
784         end
785       end
786     end
787
788     # Read POI from database
789     # (only called on revert: POIs are usually read by whichways).
790     #
791     # Returns array of id, long, lat, hash of tags, (current) version.
792
793     def getpoi(id, timestamp)
794       amf_handle_error("'getpoi' #{id}", "node", id) do
795         id = id.to_i
796         n = Node.where(:id => id).first
797         if n
798           v = n.version
799           n = OldNode.where("node_id = ? AND timestamp <= ?", id, timestamp).unredacted.order("timestamp DESC").first unless timestamp == ""
800         end
801
802         if n
803           return [0, "", id, n.lon, n.lat, n.tags, v]
804         else
805           return [-4, "node", id]
806         end
807       end
808     end
809
810     # Delete way and all constituent nodes.
811     # Params:
812     # * The user token
813     # * the changeset id
814     # * the id of the way to change
815     # * the version of the way that was downloaded
816     # * a hash of the id and versions of all the nodes that are in the way, if any
817     # of the nodes have been changed by someone else then, there is a problem!
818     # Returns 0 (success), unchanged way id, new way version, new node versions.
819
820     def deleteway(usertoken, changeset_id, way_id, way_version, deletednodes)
821       amf_handle_error("'deleteway' #{way_id}", "way", way_id) do
822         user = getuser(usertoken)
823         return -1, "You are not logged in, so the way could not be deleted." unless user
824         return -1, t("application.setup_user_auth.blocked") if user.blocks.active.exists?
825         return -1, "You must accept the contributor terms before you can edit." if user.terms_agreed.nil?
826
827         way_id = way_id.to_i
828         nodeversions = {}
829         old_way = nil # returned, so scope it outside the transaction
830         # Need a transaction so that if one item fails to delete, the whole delete fails.
831         Way.transaction do
832           # -- Delete the way
833
834           old_way = Way.find(way_id)
835           delete_way = Way.new
836           delete_way.version = way_version
837           delete_way.changeset_id = changeset_id.to_i
838           delete_way.id = way_id
839           old_way.delete_with_history!(delete_way, user)
840
841           # -- Delete unwanted nodes
842
843           deletednodes.each do |id, v|
844             node = Node.find(id.to_i)
845             new_node = Node.new
846             new_node.changeset_id = changeset_id.to_i
847             new_node.version = v.to_i
848             new_node.id = id.to_i
849             begin
850               node.delete_with_history!(new_node, user)
851               nodeversions[node.id] = node.version
852             rescue OSM::APIPreconditionFailedError
853               # We don't do anything with the exception as the node is in use
854               # elsewhere and we don't want to delete it
855             end
856           end
857         end
858         [0, "", way_id, old_way.version, nodeversions]
859       end
860     end
861
862     # ====================================================================
863     # Support functions
864
865     # Authenticate token
866     # (can also be of form user:pass)
867     # When we are writing to the api, we need the actual user model,
868     # not just the id, hence this abstraction
869
870     def getuser(token)
871       if token =~ /^(.+):(.+)$/
872         User.authenticate(:username => Regexp.last_match(1), :password => Regexp.last_match(2))
873       else
874         User.authenticate(:token => token)
875       end
876     end
877
878     def getlocales
879       @getlocales ||= Locale.list(Dir.glob(Rails.root.join("config/potlatch/locales/*")).collect { |f| File.basename(f, ".yml") })
880     end
881
882     ##
883     # check that all key-value pairs are valid UTF-8.
884     def tags_ok(tags)
885       tags.each do |k, v|
886         return false unless UTF8.valid? k
887         return false unless UTF8.valid? v
888       end
889       true
890     end
891
892     ##
893     # strip characters which are invalid in XML documents from the strings
894     # in the +tags+ hash.
895     def strip_non_xml_chars(tags)
896       new_tags = {}
897       tags&.each do |k, v|
898         new_k = k.delete "\000-\037\ufffe\uffff", "^\011\012\015"
899         new_v = v.delete "\000-\037\ufffe\uffff", "^\011\012\015"
900         new_tags[new_k] = new_v
901       end
902       new_tags
903     end
904
905     # ====================================================================
906     # Alternative SQL queries for getway/whichways
907
908     def sql_find_ways_in_area(bbox)
909       sql = <<~SQL.squish
910         SELECT DISTINCT current_ways.id AS wayid,current_ways.version AS version
911           FROM current_way_nodes
912         INNER JOIN current_nodes ON current_nodes.id=current_way_nodes.node_id
913         INNER JOIN current_ways  ON current_ways.id =current_way_nodes.id
914            WHERE current_nodes.visible=TRUE
915            AND current_ways.visible=TRUE
916            AND #{OSM.sql_for_area(bbox, 'current_nodes.')}
917       SQL
918       ActiveRecord::Base.connection.select_all(sql).collect { |a| [a["wayid"].to_i, a["version"].to_i] }
919     end
920
921     def sql_find_pois_in_area(bbox)
922       pois = []
923       sql = <<~SQL.squish
924         SELECT current_nodes.id,current_nodes.latitude*0.0000001 AS lat,current_nodes.longitude*0.0000001 AS lon,current_nodes.version
925         FROM current_nodes
926          LEFT OUTER JOIN current_way_nodes cwn ON cwn.node_id=current_nodes.id
927          WHERE current_nodes.visible=TRUE
928          AND cwn.id IS NULL
929          AND #{OSM.sql_for_area(bbox, 'current_nodes.')}
930       SQL
931       ActiveRecord::Base.connection.select_all(sql).each do |row|
932         poitags = {}
933         ActiveRecord::Base.connection.select_all("SELECT k,v FROM current_node_tags WHERE id=#{row['id']}").each do |n|
934           poitags[n["k"]] = n["v"]
935         end
936         pois << [row["id"].to_i, row["lon"].to_f, row["lat"].to_f, poitags, row["version"].to_i]
937       end
938       pois
939     end
940
941     def sql_find_relations_in_area_and_ways(bbox, way_ids)
942       # ** It would be more Potlatchy to get relations for nodes within ways
943       #    during 'getway', not here
944       sql = <<~SQL.squish
945         SELECT DISTINCT cr.id AS relid,cr.version AS version
946         FROM current_relations cr
947         INNER JOIN current_relation_members crm ON crm.id=cr.id
948         INNER JOIN current_nodes cn ON crm.member_id=cn.id AND crm.member_type='Node'
949          WHERE #{OSM.sql_for_area(bbox, 'cn.')}
950       SQL
951       unless way_ids.empty?
952         sql += <<~SQL.squish
953           UNION
954            SELECT DISTINCT cr.id AS relid,cr.version AS version
955            FROM current_relations cr
956            INNER JOIN current_relation_members crm ON crm.id=cr.id
957             WHERE crm.member_type='Way'
958             AND crm.member_id IN (#{way_ids.join(',')})
959         SQL
960       end
961       ActiveRecord::Base.connection.select_all(sql).collect { |a| [a["relid"].to_i, a["version"].to_i] }
962     end
963
964     def sql_get_nodes_in_way(wayid)
965       points = []
966       sql = <<~SQL.squish
967         SELECT latitude*0.0000001 AS lat,longitude*0.0000001 AS lon,current_nodes.id,current_nodes.version
968         FROM current_way_nodes,current_nodes
969          WHERE current_way_nodes.id=#{wayid.to_i}
970          AND current_way_nodes.node_id=current_nodes.id
971          AND current_nodes.visible=TRUE
972         ORDER BY sequence_id
973       SQL
974       ActiveRecord::Base.connection.select_all(sql).each do |row|
975         nodetags = {}
976         ActiveRecord::Base.connection.select_all("SELECT k,v FROM current_node_tags WHERE id=#{row['id']}").each do |n|
977           nodetags[n["k"]] = n["v"]
978         end
979         nodetags.delete("created_by")
980         points << [row["lon"].to_f, row["lat"].to_f, row["id"].to_i, nodetags, row["version"].to_i]
981       end
982       points
983     end
984
985     def sql_get_tags_in_way(wayid)
986       tags = {}
987       ActiveRecord::Base.connection.select_all("SELECT k,v FROM current_way_tags WHERE id=#{wayid.to_i}").each do |row|
988         tags[row["k"]] = row["v"]
989       end
990       tags
991     end
992
993     def sql_get_way_version(wayid)
994       ActiveRecord::Base.connection.select_one("SELECT version FROM current_ways WHERE id=#{wayid.to_i}")["version"]
995     end
996
997     def sql_get_way_user(wayid)
998       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"]
999     end
1000   end
1001 end