Merge remote-tracking branch 'upstream/pull/2204'
[rails.git] / app / controllers / api / notes_controller.rb
1 module Api
2   class NotesController < ApiController
3     layout "site", :only => [:mine]
4
5     before_action :check_api_readable
6     before_action :setup_user_auth, :only => [:create, :comment, :show]
7     before_action :authorize, :only => [:close, :reopen, :destroy]
8
9     authorize_resource
10
11     before_action :check_api_writable, :only => [:create, :comment, :close, :reopen, :destroy]
12     before_action :set_locale
13     around_action :api_call_handle_error, :api_call_timeout
14
15     ##
16     # Return a list of notes in a given area
17     def index
18       # Figure out the bbox - we prefer a bbox argument but also
19       # support the old, deprecated, method with four arguments
20       if params[:bbox]
21         bbox = BoundingBox.from_bbox_params(params)
22       else
23         raise OSM::APIBadUserInput, "No l was given" unless params[:l]
24         raise OSM::APIBadUserInput, "No r was given" unless params[:r]
25         raise OSM::APIBadUserInput, "No b was given" unless params[:b]
26         raise OSM::APIBadUserInput, "No t was given" unless params[:t]
27
28         bbox = BoundingBox.from_lrbt_params(params)
29       end
30
31       # Get any conditions that need to be applied
32       notes = closed_condition(Note.all)
33
34       # Check that the boundaries are valid
35       bbox.check_boundaries
36
37       # Check the the bounding box is not too big
38       bbox.check_size(Settings.max_note_request_area)
39
40       # Find the notes we want to return
41       @notes = notes.bbox(bbox).order("updated_at DESC").limit(result_limit).preload(:comments)
42
43       # Render the result
44       respond_to do |format|
45         format.rss
46         format.xml
47         format.json
48         format.gpx
49       end
50     end
51
52     ##
53     # Create a new note
54     def create
55       # Check the ACLs
56       raise OSM::APIAccessDenied if current_user.nil? && Acl.no_note_comment(request.remote_ip)
57
58       # Check the arguments are sane
59       raise OSM::APIBadUserInput, "No lat was given" unless params[:lat]
60       raise OSM::APIBadUserInput, "No lon was given" unless params[:lon]
61       raise OSM::APIBadUserInput, "No text was given" if params[:text].blank?
62
63       # Extract the arguments
64       lon = OSM.parse_float(params[:lon], OSM::APIBadUserInput, "lon was not a number")
65       lat = OSM.parse_float(params[:lat], OSM::APIBadUserInput, "lat was not a number")
66       comment = params[:text]
67
68       # Include in a transaction to ensure that there is always a note_comment for every note
69       Note.transaction do
70         # Create the note
71         @note = Note.create(:lat => lat, :lon => lon)
72         raise OSM::APIBadUserInput, "The note is outside this world" unless @note.in_world?
73
74         # Save the note
75         @note.save!
76
77         # Add a comment to the note
78         add_comment(@note, comment, "opened")
79       end
80
81       # Return a copy of the new note
82       respond_to do |format|
83         format.xml { render :action => :show }
84         format.json { render :action => :show }
85       end
86     end
87
88     ##
89     # Add a comment to an existing note
90     def comment
91       # Check the ACLs
92       raise OSM::APIAccessDenied if current_user.nil? && Acl.no_note_comment(request.remote_ip)
93
94       # Check the arguments are sane
95       raise OSM::APIBadUserInput, "No id was given" unless params[:id]
96       raise OSM::APIBadUserInput, "No text was given" if params[:text].blank?
97
98       # Extract the arguments
99       id = params[:id].to_i
100       comment = params[:text]
101
102       # Find the note and check it is valid
103       @note = Note.find(id)
104       raise OSM::APINotFoundError unless @note
105       raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible?
106       raise OSM::APINoteAlreadyClosedError, @note if @note.closed?
107
108       # Add a comment to the note
109       Note.transaction do
110         add_comment(@note, comment, "commented")
111       end
112
113       # Return a copy of the updated note
114       respond_to do |format|
115         format.xml { render :action => :show }
116         format.json { render :action => :show }
117       end
118     end
119
120     ##
121     # Close a note
122     def close
123       # Check the arguments are sane
124       raise OSM::APIBadUserInput, "No id was given" unless params[:id]
125
126       # Extract the arguments
127       id = params[:id].to_i
128       comment = params[:text]
129
130       # Find the note and check it is valid
131       @note = Note.find_by(:id => id)
132       raise OSM::APINotFoundError unless @note
133       raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible?
134       raise OSM::APINoteAlreadyClosedError, @note if @note.closed?
135
136       # Close the note and add a comment
137       Note.transaction do
138         @note.close
139
140         add_comment(@note, comment, "closed")
141       end
142
143       # Return a copy of the updated note
144       respond_to do |format|
145         format.xml { render :action => :show }
146         format.json { render :action => :show }
147       end
148     end
149
150     ##
151     # Reopen a note
152     def reopen
153       # Check the arguments are sane
154       raise OSM::APIBadUserInput, "No id was given" unless params[:id]
155
156       # Extract the arguments
157       id = params[:id].to_i
158       comment = params[:text]
159
160       # Find the note and check it is valid
161       @note = Note.find_by(:id => id)
162       raise OSM::APINotFoundError unless @note
163       raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible? || current_user.moderator?
164       raise OSM::APINoteAlreadyOpenError, @note unless @note.closed? || !@note.visible?
165
166       # Reopen the note and add a comment
167       Note.transaction do
168         @note.reopen
169
170         add_comment(@note, comment, "reopened")
171       end
172
173       # Return a copy of the updated note
174       respond_to do |format|
175         format.xml { render :action => :show }
176         format.json { render :action => :show }
177       end
178     end
179
180     ##
181     # Get a feed of recent notes and comments
182     def feed
183       # Get any conditions that need to be applied
184       notes = closed_condition(Note.all)
185
186       # Process any bbox
187       if params[:bbox]
188         bbox = BoundingBox.from_bbox_params(params)
189
190         bbox.check_boundaries
191         bbox.check_size(Settings.max_note_request_area)
192
193         notes = notes.bbox(bbox)
194       end
195
196       # Find the comments we want to return
197       @comments = NoteComment.where(:note_id => notes).order("created_at DESC").limit(result_limit).preload(:note)
198
199       # Render the result
200       respond_to do |format|
201         format.rss
202       end
203     end
204
205     ##
206     # Read a note
207     def show
208       # Check the arguments are sane
209       raise OSM::APIBadUserInput, "No id was given" unless params[:id]
210
211       # Find the note and check it is valid
212       @note = Note.find(params[:id])
213       raise OSM::APINotFoundError unless @note
214       raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible? || current_user&.moderator?
215
216       # Render the result
217       respond_to do |format|
218         format.xml
219         format.rss
220         format.json
221         format.gpx
222       end
223     end
224
225     ##
226     # Delete (hide) a note
227     def destroy
228       # Check the arguments are sane
229       raise OSM::APIBadUserInput, "No id was given" unless params[:id]
230
231       # Extract the arguments
232       id = params[:id].to_i
233       comment = params[:text]
234
235       # Find the note and check it is valid
236       @note = Note.find(id)
237       raise OSM::APINotFoundError unless @note
238       raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible?
239
240       # Mark the note as hidden
241       Note.transaction do
242         @note.status = "hidden"
243         @note.save
244
245         add_comment(@note, comment, "hidden", false)
246       end
247
248       # Return a copy of the updated note
249       respond_to do |format|
250         format.xml { render :action => :show }
251         format.json { render :action => :show }
252       end
253     end
254
255     ##
256     # Return a list of notes matching a given string
257     def search
258       # Get the initial set of notes
259       @notes = closed_condition(Note.all)
260
261       # Add any user filter
262       if params[:display_name] || params[:user]
263         if params[:display_name]
264           @user = User.find_by(:display_name => params[:display_name])
265
266           raise OSM::APIBadUserInput, "User #{params[:display_name]} not known" unless @user
267         else
268           @user = User.find_by(:id => params[:user])
269
270           raise OSM::APIBadUserInput, "User #{params[:user]} not known" unless @user
271         end
272
273         @notes = @notes.joins(:comments).where(:note_comments => { :author_id => @user })
274       end
275
276       # Add any text filter
277       @notes = @notes.joins(:comments).where("to_tsvector('english', note_comments.body) @@ plainto_tsquery('english', ?)", params[:q]) if params[:q]
278
279       # Add any date filter
280       if params[:from]
281         begin
282           from = Time.parse(params[:from])
283         rescue ArgumentError
284           raise OSM::APIBadUserInput, "Date #{params[:from]} is in a wrong format"
285         end
286
287         begin
288           to = if params[:to]
289                  Time.parse(params[:to])
290                else
291                  Time.now
292                end
293         rescue ArgumentError
294           raise OSM::APIBadUserInput, "Date #{params[:to]} is in a wrong format"
295         end
296
297         @notes = @notes.where(:created_at => from..to)
298       end
299
300       # Find the notes we want to return
301       @notes = @notes.order("updated_at DESC").limit(result_limit).preload(:comments)
302
303       # Render the result
304       respond_to do |format|
305         format.rss { render :action => :index }
306         format.xml { render :action => :index }
307         format.json { render :action => :index }
308         format.gpx { render :action => :index }
309       end
310     end
311
312     private
313
314     #------------------------------------------------------------
315     # utility functions below.
316     #------------------------------------------------------------
317
318     ##
319     # Get the maximum number of results to return
320     def result_limit
321       if params[:limit]
322         if params[:limit].to_i.positive? && params[:limit].to_i <= 10000
323           params[:limit].to_i
324         else
325           raise OSM::APIBadUserInput, "Note limit must be between 1 and 10000"
326         end
327       else
328         100
329       end
330     end
331
332     ##
333     # Generate a condition to choose which notes we want based
334     # on their status and the user's request parameters
335     def closed_condition(notes)
336       closed_since = if params[:closed]
337                        params[:closed].to_i
338                      else
339                        7
340                      end
341
342       if closed_since.negative?
343         notes.where.not(:status => "hidden")
344       elsif closed_since.positive?
345         notes.where(:status => "open")
346              .or(notes.where(:status => "closed")
347                       .where(notes.arel_table[:closed_at].gt(Time.now - closed_since.days)))
348       else
349         notes.where(:status => "open")
350       end
351     end
352
353     ##
354     # Add a comment to a note
355     def add_comment(note, text, event, notify = true)
356       attributes = { :visible => true, :event => event, :body => text }
357
358       if current_user
359         attributes[:author_id] = current_user.id
360       else
361         attributes[:author_ip] = request.remote_ip
362       end
363
364       comment = note.comments.create!(attributes)
365
366       note.comments.map(&:author).uniq.each do |user|
367         Notifier.note_comment_notification(comment, user).deliver_later if notify && user && user != current_user && user.visible?
368       end
369     end
370   end
371 end