app/controllers/note_controller.rb

   1 class NoteController < ApplicationController
   2
   3   layout 'site', :only => [:mine]
   4
   5   before_filter :check_api_readable
   6   before_filter :authorize_web, :only => [:create, :close, :update, :delete, :mine]
   7   before_filter :check_api_writable, :only => [:create, :close, :update, :delete]
   8   before_filter :set_locale, :only => [:mine]
   9   after_filter :compress_output
  10   around_filter :api_call_handle_error, :api_call_timeout
  11
  12   ##
  13   # Return a list of notes in a given area
  14   def list
  15     # Figure out the bbox - we prefer a bbox argument but also
  16     # support the old, deprecated, method with four arguments
  17     if params[:bbox]
  18       bbox = BoundingBox.from_bbox_params(params)
  19     else
  20       raise OSM::APIBadUserInput.new("No l was given") unless params[:l]
  21       raise OSM::APIBadUserInput.new("No r was given") unless params[:r]
  22       raise OSM::APIBadUserInput.new("No b was given") unless params[:b]
  23       raise OSM::APIBadUserInput.new("No t was given") unless params[:t]
  24
  25       bbox = BoundingBox.from_lrbt_params(params)
  26     end
  27
  28     # Get the sanitised boundaries
  29     @min_lon, @min_lat, @max_lon, @max_lat = sanitise_boundaries(bbox)
  30
  31     # Get any conditions that need to be applied
  32     notes = closed_condition(Note.scoped)
  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(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 arguments are sane
  56     raise OSM::APIBadUserInput.new("No lat was given") unless params[:lat]
  57     raise OSM::APIBadUserInput.new("No lon was given") unless params[:lon]
  58     raise OSM::APIBadUserInput.new("No text was given") unless params[:text]
  59
  60     # Extract the arguments
  61     lon = params[:lon].to_f
  62     lat = params[:lat].to_f
  63     comment = params[:text]
  64     name = params[:name]
  65
  66     # Include in a transaction to ensure that there is always a note_comment for every note
  67     Note.transaction do
  68       # Create the note
  69       @note = Note.create(:lat => lat, :lon => lon)
  70       raise OSM::APIBadUserInput.new("The note is outside this world") unless @note.in_world?
  71
  72       #TODO: move this into a helper function
  73       begin
  74         url = "http://nominatim.openstreetmap.org/reverse?lat=" + lat.to_s + "&lon=" + lon.to_s + "&zoom=16"
  75         response = REXML::Document.new(Net::HTTP.get(URI.parse(url)))
  76
  77         if result = response.get_text("reversegeocode/result")
  78           @note.nearby_place = result.to_s
  79         else
  80           @note.nearby_place = "unknown"
  81         end
  82       rescue Exception => err
  83         @note.nearby_place = "unknown"
  84       end
  85
  86       # Save the note
  87       @note.save
  88
  89       # Add a comment to the note
  90       add_comment(@note, comment, name, "opened")
  91     end
  92
  93     # Send an OK response
  94     render_ok
  95   end
  96
  97   ##
  98   # Add a comment to an existing note
  99   def update
 100     # Check the arguments are sane
 101     raise OSM::APIBadUserInput.new("No id was given") unless params[:id]
 102     raise OSM::APIBadUserInput.new("No text was given") unless params[:text]
 103
 104     # Extract the arguments
 105     id = params[:id].to_i
 106     comment = params[:text]
 107     name = params[:name] or "NoName"
 108
 109     # Find the note and check it is valid
 110     note = Note.find(id)
 111     raise OSM::APINotFoundError unless note
 112     raise OSM::APIAlreadyDeletedError unless note.visible?
 113
 114     # Add a comment to the note
 115     Note.transaction do
 116       add_comment(note, comment, name, "commented")
 117     end
 118
 119     # Send an OK response
 120     render_ok
 121   end
 122
 123   ##
 124   # Close a note
 125   def close
 126     # Check the arguments are sane
 127     raise OSM::APIBadUserInput.new("No id was given") unless params[:id]
 128
 129     # Extract the arguments
 130     id = params[:id].to_i
 131     name = params[:name]
 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 unless note.visible?
 137
 138     # Close the note and add a comment
 139     Note.transaction do
 140       note.close
 141
 142       add_comment(note, nil, name, "closed")
 143     end
 144
 145     # Send an OK response
 146     render_ok
 147   end
 148
 149   ##
 150   # Get a feed of recent notes and comments
 151   def rss
 152     # Get any conditions that need to be applied
 153     notes = closed_condition(Note.scoped)
 154
 155     # Process any bbox
 156     if params[:bbox]
 157       bbox = BoundingBox.from_bbox_params(params)
 158
 159       bbox.check_boundaries
 160       bbox.check_size(MAX_NOTE_REQUEST_AREA)
 161
 162       notes = notes.bbox(bbox)
 163     end
 164
 165     # Find the comments we want to return
 166     @comments = NoteComment.where(:note => notes).order("created_at DESC").limit(result_limit).include(:note)
 167
 168     # Render the result
 169     respond_to do |format|
 170       format.rss
 171     end
 172   end
 173
 174   ##
 175   # Read a note
 176   def read
 177     # Check the arguments are sane
 178     raise OSM::APIBadUserInput.new("No id was given") unless params[:id]
 179
 180     # Find the note and check it is valid
 181     @note = Note.find(params[:id])
 182     raise OSM::APINotFoundError unless @note
 183     raise OSM::APIAlreadyDeletedError unless @note.visible?
 184
 185     # Render the result
 186     respond_to do |format|
 187       format.xml
 188       format.rss
 189       format.json
 190       format.gpx
 191     end
 192   end
 193
 194   ##
 195   # Delete (hide) a note
 196   def delete
 197     # Check the arguments are sane
 198     raise OSM::APIBadUserInput.new("No id was given") unless params[:id]
 199
 200     # Extract the arguments
 201     id = params[:id].to_i
 202     name = params[:name]
 203
 204     # Find the note and check it is valid
 205     note = Note.find(id)
 206     raise OSM::APINotFoundError unless note
 207     raise OSM::APIAlreadyDeletedError unless note.visible?
 208
 209     # Mark the note as hidden
 210     Note.transaction do
 211       note.status = "hidden"
 212       note.save
 213
 214       add_comment(note, nil, name, "hidden")
 215     end
 216
 217     # Render the result
 218     render :text => "ok\n", :content_type => "text/html"
 219   end
 220
 221   ##
 222   # Return a list of notes matching a given string
 223   def search
 224     # Check the arguments are sane
 225     raise OSM::APIBadUserInput.new("No query string was given") unless params[:q]
 226
 227     # Get any conditions that need to be applied
 228     conditions = closed_condition
 229     conditions = cond_merge conditions, ['note_comments.body ~ ?', params[:q]]
 230
 231     # Find the notes we want to return
 232     @notes = Note.find(:all,
 233                        :conditions => conditions,
 234                        :order => "updated_at DESC",
 235                        :limit => result_limit,
 236                        :joins => :comments,
 237                        :include => :comments)
 238
 239     # Render the result
 240     respond_to do |format|
 241       format.html { render :action => :list, :format => :rjs, :content_type => "text/javascript"}
 242       format.rss { render :action => :list }
 243       format.js
 244       format.xml { render :action => :list }
 245       format.json { render :action => :list }
 246       format.gpx { render :action => :list }
 247     end
 248   end
 249
 250   def mine
 251     if params[:display_name]
 252       @user2 = User.find_by_display_name(params[:display_name], :conditions => { :status => ["active", "confirmed"] })
 253
 254       if @user2
 255         if @user2.data_public? or @user2 == @user
 256           conditions = ['note_comments.author_id = ?', @user2.id]
 257         else
 258           conditions = ['false']
 259         end
 260       else #if request.format == :html
 261         @title = t 'user.no_such_user.title'
 262         @not_found_user = params[:display_name]
 263         render :template => 'user/no_such_user', :status => :not_found
 264         return
 265       end
 266     end
 267
 268     if @user2
 269       user_link = render_to_string :partial => "user", :object => @user2
 270     end
 271
 272     @title =  t 'note.mine.title', :user => @user2.display_name
 273     @heading =  t 'note.mine.heading', :user => @user2.display_name
 274     @description = t 'note.mine.description', :user => user_link
 275
 276     @page = (params[:page] || 1).to_i
 277     @page_size = 10
 278
 279     @notes = Note.find(:all,
 280                        :include => [:comments, {:comments => :author}],
 281                        :joins => :comments,
 282                        :order => "updated_at DESC",
 283                        :conditions => conditions,
 284                        :offset => (@page - 1) * @page_size,
 285                        :limit => @page_size).uniq
 286   end
 287
 288 private
 289   #------------------------------------------------------------
 290   # utility functions below.
 291   #------------------------------------------------------------
 292
 293   ##
 294   # Render an OK response
 295   def render_ok
 296     if params[:format] == "js"
 297       render :text => "osbResponse();", :content_type => "text/javascript"
 298     else
 299       render :text => "ok " + @note.id.to_s + "\n", :content_type => "text/plain" if @note
 300       render :text => "ok\n", :content_type => "text/plain" unless @note
 301     end
 302   end
 303
 304   ##
 305   # Get the maximum number of results to return
 306   def result_limit
 307     if params[:limit] and params[:limit].to_i > 0 and params[:limit].to_i < 10000
 308       params[:limit].to_i
 309     else
 310       100
 311     end
 312   end
 313
 314   ##
 315   # Generate a condition to choose which bugs we want based
 316   # on their status and the user's request parameters
 317   def closed_condition(notes)
 318     if params[:closed]
 319       closed_since = params[:closed].to_i
 320     else
 321       closed_since = 7
 322     end
 323
 324     if closed_since < 0
 325       notes = notes.where("status != 'hidden'")
 326     elsif closed_since > 0
 327       notes = notes.where("(status = 'open' OR (status = 'closed' AND closed_at > '#{Time.now - closed_since.days}'))")
 328     else
 329       notes = notes.where("status = 'open'")
 330     end
 331
 332     return notes
 333   end
 334
 335   ##
 336   # Add a comment to a note
 337   def add_comment(note, text, name, event)
 338     name = "NoName" if name.nil?
 339
 340     attributes = { :visible => true, :event => event, :body => text }
 341
 342     if @user
 343       attributes[:author_id] = @user.id
 344       attributes[:author_name] = @user.display_name
 345     else
 346       attributes[:author_ip] = request.remote_ip
 347       attributes[:author_name] = name + " (a)"
 348     end
 349
 350     note.comments.create(attributes)
 351
 352     note.comments.map { |c| c.author }.uniq.each do |user|
 353       if user and user != @user
 354         Notifier.deliver_note_comment_notification(comment, user)
 355       end
 356     end
 357   end
 358 end