app/controllers/api/notes_controller.rb

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