app/controllers/api/notes_controller.rb

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