Move the notes api methods into a controller in the api namespace

app/controllers/api/notes_controller.rb

@@ -0,0 +1,373 @@
+module Api
+  class NotesController < ApplicationController
+    layout "site", :only => [:mine]
+
+    skip_before_action :verify_authenticity_token
+    before_action :check_api_readable
+    before_action :setup_user_auth, :only => [:create, :comment, :show]
+    before_action :authorize, :only => [:close, :reopen, :destroy]
+    before_action :api_deny_access_handler
+
+    authorize_resource
+
+    before_action :check_api_writable, :only => [:create, :comment, :close, :reopen, :destroy]
+    before_action :set_locale
+    around_action :api_call_handle_error, :api_call_timeout
+
+    ##
+    # Return a list of notes in a given area
+    def index
+      # Figure out the bbox - we prefer a bbox argument but also
+      # support the old, deprecated, method with four arguments
+      if params[:bbox]
+        bbox = BoundingBox.from_bbox_params(params)
+      else
+        raise OSM::APIBadUserInput, "No l was given" unless params[:l]
+        raise OSM::APIBadUserInput, "No r was given" unless params[:r]
+        raise OSM::APIBadUserInput, "No b was given" unless params[:b]
+        raise OSM::APIBadUserInput, "No t was given" unless params[:t]
+
+        bbox = BoundingBox.from_lrbt_params(params)
+      end
+
+      # Get any conditions that need to be applied
+      notes = closed_condition(Note.all)
+
+      # Check that the boundaries are valid
+      bbox.check_boundaries
+
+      # Check the the bounding box is not too big
+      bbox.check_size(MAX_NOTE_REQUEST_AREA)
+
+      # Find the notes we want to return
+      @notes = notes.bbox(bbox).order("updated_at DESC").limit(result_limit).preload(:comments)
+
+      # Render the result
+      respond_to do |format|
+        format.rss
+        format.xml
+        format.json
+        format.gpx
+      end
+    end
+
+    ##
+    # Create a new note
+    def create
+      # Check the ACLs
+      raise OSM::APIAccessDenied if current_user.nil? && Acl.no_note_comment(request.remote_ip)
+
+      # Check the arguments are sane
+      raise OSM::APIBadUserInput, "No lat was given" unless params[:lat]
+      raise OSM::APIBadUserInput, "No lon was given" unless params[:lon]
+      raise OSM::APIBadUserInput, "No text was given" if params[:text].blank?
+
+      # Extract the arguments
+      lon = OSM.parse_float(params[:lon], OSM::APIBadUserInput, "lon was not a number")
+      lat = OSM.parse_float(params[:lat], OSM::APIBadUserInput, "lat was not a number")
+      comment = params[:text]
+
+      # Include in a transaction to ensure that there is always a note_comment for every note
+      Note.transaction do
+        # Create the note
+        @note = Note.create(:lat => lat, :lon => lon)
+        raise OSM::APIBadUserInput, "The note is outside this world" unless @note.in_world?
+
+        # Save the note
+        @note.save!
+
+        # Add a comment to the note
+        add_comment(@note, comment, "opened")
+      end
+
+      # Return a copy of the new note
+      respond_to do |format|
+        format.xml { render :action => :show }
+        format.json { render :action => :show }
+      end
+    end
+
+    ##
+    # Add a comment to an existing note
+    def comment
+      # Check the ACLs
+      raise OSM::APIAccessDenied if current_user.nil? && Acl.no_note_comment(request.remote_ip)
+
+      # Check the arguments are sane
+      raise OSM::APIBadUserInput, "No id was given" unless params[:id]
+      raise OSM::APIBadUserInput, "No text was given" if params[:text].blank?
+
+      # Extract the arguments
+      id = params[:id].to_i
+      comment = params[:text]
+
+      # Find the note and check it is valid
+      @note = Note.find(id)
+      raise OSM::APINotFoundError unless @note
+      raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible?
+      raise OSM::APINoteAlreadyClosedError, @note if @note.closed?
+
+      # Add a comment to the note
+      Note.transaction do
+        add_comment(@note, comment, "commented")
+      end
+
+      # Return a copy of the updated note
+      respond_to do |format|
+        format.xml { render :action => :show }
+        format.json { render :action => :show }
+      end
+    end
+
+    ##
+    # Close a note
+    def close
+      # Check the arguments are sane
+      raise OSM::APIBadUserInput, "No id was given" unless params[:id]
+
+      # Extract the arguments
+      id = params[:id].to_i
+      comment = params[:text]
+
+      # Find the note and check it is valid
+      @note = Note.find_by(:id => id)
+      raise OSM::APINotFoundError unless @note
+      raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible?
+      raise OSM::APINoteAlreadyClosedError, @note if @note.closed?
+
+      # Close the note and add a comment
+      Note.transaction do
+        @note.close
+
+        add_comment(@note, comment, "closed")
+      end
+
+      # Return a copy of the updated note
+      respond_to do |format|
+        format.xml { render :action => :show }
+        format.json { render :action => :show }
+      end
+    end
+
+    ##
+    # Reopen a note
+    def reopen
+      # Check the arguments are sane
+      raise OSM::APIBadUserInput, "No id was given" unless params[:id]
+
+      # Extract the arguments
+      id = params[:id].to_i
+      comment = params[:text]
+
+      # Find the note and check it is valid
+      @note = Note.find_by(:id => id)
+      raise OSM::APINotFoundError unless @note
+      raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible? || current_user.moderator?
+      raise OSM::APINoteAlreadyOpenError, @note unless @note.closed? || !@note.visible?
+
+      # Reopen the note and add a comment
+      Note.transaction do
+        @note.reopen
+
+        add_comment(@note, comment, "reopened")
+      end
+
+      # Return a copy of the updated note
+      respond_to do |format|
+        format.xml { render :action => :show }
+        format.json { render :action => :show }
+      end
+    end
+
+    ##
+    # Get a feed of recent notes and comments
+    def feed
+      # Get any conditions that need to be applied
+      notes = closed_condition(Note.all)
+
+      # Process any bbox
+      if params[:bbox]
+        bbox = BoundingBox.from_bbox_params(params)
+
+        bbox.check_boundaries
+        bbox.check_size(MAX_NOTE_REQUEST_AREA)
+
+        notes = notes.bbox(bbox)
+      end
+
+      # Find the comments we want to return
+      @comments = NoteComment.where(:note_id => notes).order("created_at DESC").limit(result_limit).preload(:note)
+
+      # Render the result
+      respond_to do |format|
+        format.rss
+      end
+    end
+
+    ##
+    # Read a note
+    def show
+      # Check the arguments are sane
+      raise OSM::APIBadUserInput, "No id was given" unless params[:id]
+
+      # Find the note and check it is valid
+      @note = Note.find(params[:id])
+      raise OSM::APINotFoundError unless @note
+      raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible? || current_user&.moderator?
+
+      # Render the result
+      respond_to do |format|
+        format.xml
+        format.rss
+        format.json
+        format.gpx
+      end
+    end
+
+    ##
+    # Delete (hide) a note
+    def destroy
+      # Check the arguments are sane
+      raise OSM::APIBadUserInput, "No id was given" unless params[:id]
+
+      # Extract the arguments
+      id = params[:id].to_i
+      comment = params[:text]
+
+      # Find the note and check it is valid
+      @note = Note.find(id)
+      raise OSM::APINotFoundError unless @note
+      raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible?
+
+      # Mark the note as hidden
+      Note.transaction do
+        @note.status = "hidden"
+        @note.save
+
+        add_comment(@note, comment, "hidden", false)
+      end
+
+      # Return a copy of the updated note
+      respond_to do |format|
+        format.xml { render :action => :show }
+        format.json { render :action => :show }
+      end
+    end
+
+    ##
+    # Return a list of notes matching a given string
+    def search
+      # Get the initial set of notes
+      @notes = closed_condition(Note.all)
+
+      # Add any user filter
+      if params[:display_name] || params[:user]
+        if params[:display_name]
+          @user = User.find_by(:display_name => params[:display_name])
+
+          raise OSM::APIBadUserInput, "User #{params[:display_name]} not known" unless @user
+        else
+          @user = User.find_by(:id => params[:user])
+
+          raise OSM::APIBadUserInput, "User #{params[:user]} not known" unless @user
+        end
+
+        @notes = @notes.joins(:comments).where(:note_comments => { :author_id => @user })
+      end
+
+      # Add any text filter
+      @notes = @notes.joins(:comments).where("to_tsvector('english', note_comments.body) @@ plainto_tsquery('english', ?)", params[:q]) if params[:q]
+
+      # Add any date filter
+      if params[:from]
+        begin
+          from = Time.parse(params[:from])
+        rescue ArgumentError
+          raise OSM::APIBadUserInput, "Date #{params[:from]} is in a wrong format"
+        end
+
+        begin
+          to = if params[:to]
+                 Time.parse(params[:to])
+               else
+                 Time.now
+               end
+        rescue ArgumentError
+          raise OSM::APIBadUserInput, "Date #{params[:to]} is in a wrong format"
+        end
+
+        @notes = @notes.where(:created_at => from..to)
+      end
+
+      # Find the notes we want to return
+      @notes = @notes.order("updated_at DESC").limit(result_limit).preload(:comments)
+
+      # Render the result
+      respond_to do |format|
+        format.rss { render :action => :index }
+        format.xml { render :action => :index }
+        format.json { render :action => :index }
+        format.gpx { render :action => :index }
+      end
+    end
+
+    private
+
+    #------------------------------------------------------------
+    # utility functions below.
+    #------------------------------------------------------------
+
+    ##
+    # Get the maximum number of results to return
+    def result_limit
+      if params[:limit]
+        if params[:limit].to_i.positive? && params[:limit].to_i <= 10000
+          params[:limit].to_i
+        else
+          raise OSM::APIBadUserInput, "Note limit must be between 1 and 10000"
+        end
+      else
+        100
+      end
+    end
+
+    ##
+    # Generate a condition to choose which notes we want based
+    # on their status and the user's request parameters
+    def closed_condition(notes)
+      closed_since = if params[:closed]
+                       params[:closed].to_i
+                     else
+                       7
+                     end
+
+      if closed_since.negative?
+        notes.where.not(:status => "hidden")
+      elsif closed_since.positive?
+        notes.where(:status => "open")
+             .or(notes.where(:status => "closed")
+                      .where(notes.arel_table[:closed_at].gt(Time.now - closed_since.days)))
+      else
+        notes.where(:status => "open")
+      end
+    end
+
+    ##
+    # Add a comment to a note
+    def add_comment(note, text, event, notify = true)
+      attributes = { :visible => true, :event => event, :body => text }
+
+      if current_user
+        attributes[:author_id] = current_user.id
+      else
+        attributes[:author_ip] = request.remote_ip
+      end
+
+      comment = note.comments.create!(attributes)
+
+      note.comments.map(&:author).uniq.each do |user|
+        Notifier.note_comment_notification(comment, user).deliver_later if notify && user && user != current_user && user.visible?
+      end
+    end
+  end
+end

app/controllers/notes_controller.rb

@@ -1,316 +1,14 @@
 class NotesController < ApplicationController
   layout "site", :only => [:mine]
 
-  skip_before_action :verify_authenticity_token, :except => [:mine]
   before_action :check_api_readable
-  before_action :authorize_web, :only => [:mine]
+  before_action :authorize_web
-  before_action :setup_user_auth, :only => [:create, :comment, :show]
-  before_action :authorize, :only => [:close, :reopen, :destroy]
-  before_action :api_deny_access_handler, :except => [:mine]
 
   authorize_resource
 
-  before_action :check_api_writable, :only => [:create, :comment, :close, :reopen, :destroy]
   before_action :set_locale
   around_action :api_call_handle_error, :api_call_timeout
 
-  ##
-  # Return a list of notes in a given area
-  def index
-    # Figure out the bbox - we prefer a bbox argument but also
-    # support the old, deprecated, method with four arguments
-    if params[:bbox]
-      bbox = BoundingBox.from_bbox_params(params)
-    else
-      raise OSM::APIBadUserInput, "No l was given" unless params[:l]
-      raise OSM::APIBadUserInput, "No r was given" unless params[:r]
-      raise OSM::APIBadUserInput, "No b was given" unless params[:b]
-      raise OSM::APIBadUserInput, "No t was given" unless params[:t]
-
-      bbox = BoundingBox.from_lrbt_params(params)
-    end
-
-    # Get any conditions that need to be applied
-    notes = closed_condition(Note.all)
-
-    # Check that the boundaries are valid
-    bbox.check_boundaries
-
-    # Check the the bounding box is not too big
-    bbox.check_size(MAX_NOTE_REQUEST_AREA)
-
-    # Find the notes we want to return
-    @notes = notes.bbox(bbox).order("updated_at DESC").limit(result_limit).preload(:comments)
-
-    # Render the result
-    respond_to do |format|
-      format.rss
-      format.xml
-      format.json
-      format.gpx
-    end
-  end
-
-  ##
-  # Create a new note
-  def create
-    # Check the ACLs
-    raise OSM::APIAccessDenied if current_user.nil? && Acl.no_note_comment(request.remote_ip)
-
-    # Check the arguments are sane
-    raise OSM::APIBadUserInput, "No lat was given" unless params[:lat]
-    raise OSM::APIBadUserInput, "No lon was given" unless params[:lon]
-    raise OSM::APIBadUserInput, "No text was given" if params[:text].blank?
-
-    # Extract the arguments
-    lon = OSM.parse_float(params[:lon], OSM::APIBadUserInput, "lon was not a number")
-    lat = OSM.parse_float(params[:lat], OSM::APIBadUserInput, "lat was not a number")
-    comment = params[:text]
-
-    # Include in a transaction to ensure that there is always a note_comment for every note
-    Note.transaction do
-      # Create the note
-      @note = Note.create(:lat => lat, :lon => lon)
-      raise OSM::APIBadUserInput, "The note is outside this world" unless @note.in_world?
-
-      # Save the note
-      @note.save!
-
-      # Add a comment to the note
-      add_comment(@note, comment, "opened")
-    end
-
-    # Return a copy of the new note
-    respond_to do |format|
-      format.xml { render :action => :show }
-      format.json { render :action => :show }
-    end
-  end
-
-  ##
-  # Add a comment to an existing note
-  def comment
-    # Check the ACLs
-    raise OSM::APIAccessDenied if current_user.nil? && Acl.no_note_comment(request.remote_ip)
-
-    # Check the arguments are sane
-    raise OSM::APIBadUserInput, "No id was given" unless params[:id]
-    raise OSM::APIBadUserInput, "No text was given" if params[:text].blank?
-
-    # Extract the arguments
-    id = params[:id].to_i
-    comment = params[:text]
-
-    # Find the note and check it is valid
-    @note = Note.find(id)
-    raise OSM::APINotFoundError unless @note
-    raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible?
-    raise OSM::APINoteAlreadyClosedError, @note if @note.closed?
-
-    # Add a comment to the note
-    Note.transaction do
-      add_comment(@note, comment, "commented")
-    end
-
-    # Return a copy of the updated note
-    respond_to do |format|
-      format.xml { render :action => :show }
-      format.json { render :action => :show }
-    end
-  end
-
-  ##
-  # Close a note
-  def close
-    # Check the arguments are sane
-    raise OSM::APIBadUserInput, "No id was given" unless params[:id]
-
-    # Extract the arguments
-    id = params[:id].to_i
-    comment = params[:text]
-
-    # Find the note and check it is valid
-    @note = Note.find_by(:id => id)
-    raise OSM::APINotFoundError unless @note
-    raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible?
-    raise OSM::APINoteAlreadyClosedError, @note if @note.closed?
-
-    # Close the note and add a comment
-    Note.transaction do
-      @note.close
-
-      add_comment(@note, comment, "closed")
-    end
-
-    # Return a copy of the updated note
-    respond_to do |format|
-      format.xml { render :action => :show }
-      format.json { render :action => :show }
-    end
-  end
-
-  ##
-  # Reopen a note
-  def reopen
-    # Check the arguments are sane
-    raise OSM::APIBadUserInput, "No id was given" unless params[:id]
-
-    # Extract the arguments
-    id = params[:id].to_i
-    comment = params[:text]
-
-    # Find the note and check it is valid
-    @note = Note.find_by(:id => id)
-    raise OSM::APINotFoundError unless @note
-    raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible? || current_user.moderator?
-    raise OSM::APINoteAlreadyOpenError, @note unless @note.closed? || !@note.visible?
-
-    # Reopen the note and add a comment
-    Note.transaction do
-      @note.reopen
-
-      add_comment(@note, comment, "reopened")
-    end
-
-    # Return a copy of the updated note
-    respond_to do |format|
-      format.xml { render :action => :show }
-      format.json { render :action => :show }
-    end
-  end
-
-  ##
-  # Get a feed of recent notes and comments
-  def feed
-    # Get any conditions that need to be applied
-    notes = closed_condition(Note.all)
-
-    # Process any bbox
-    if params[:bbox]
-      bbox = BoundingBox.from_bbox_params(params)
-
-      bbox.check_boundaries
-      bbox.check_size(MAX_NOTE_REQUEST_AREA)
-
-      notes = notes.bbox(bbox)
-    end
-
-    # Find the comments we want to return
-    @comments = NoteComment.where(:note_id => notes).order("created_at DESC").limit(result_limit).preload(:note)
-
-    # Render the result
-    respond_to do |format|
-      format.rss
-    end
-  end
-
-  ##
-  # Read a note
-  def show
-    # Check the arguments are sane
-    raise OSM::APIBadUserInput, "No id was given" unless params[:id]
-
-    # Find the note and check it is valid
-    @note = Note.find(params[:id])
-    raise OSM::APINotFoundError unless @note
-    raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible? || current_user&.moderator?
-
-    # Render the result
-    respond_to do |format|
-      format.xml
-      format.rss
-      format.json
-      format.gpx
-    end
-  end
-
-  ##
-  # Delete (hide) a note
-  def destroy
-    # Check the arguments are sane
-    raise OSM::APIBadUserInput, "No id was given" unless params[:id]
-
-    # Extract the arguments
-    id = params[:id].to_i
-    comment = params[:text]
-
-    # Find the note and check it is valid
-    @note = Note.find(id)
-    raise OSM::APINotFoundError unless @note
-    raise OSM::APIAlreadyDeletedError.new("note", @note.id) unless @note.visible?
-
-    # Mark the note as hidden
-    Note.transaction do
-      @note.status = "hidden"
-      @note.save
-
-      add_comment(@note, comment, "hidden", false)
-    end
-
-    # Return a copy of the updated note
-    respond_to do |format|
-      format.xml { render :action => :show }
-      format.json { render :action => :show }
-    end
-  end
-
-  ##
-  # Return a list of notes matching a given string
-  def search
-    # Get the initial set of notes
-    @notes = closed_condition(Note.all)
-
-    # Add any user filter
-    if params[:display_name] || params[:user]
-      if params[:display_name]
-        @user = User.find_by(:display_name => params[:display_name])
-
-        raise OSM::APIBadUserInput, "User #{params[:display_name]} not known" unless @user
-      else
-        @user = User.find_by(:id => params[:user])
-
-        raise OSM::APIBadUserInput, "User #{params[:user]} not known" unless @user
-      end
-
-      @notes = @notes.joins(:comments).where(:note_comments => { :author_id => @user })
-    end
-
-    # Add any text filter
-    @notes = @notes.joins(:comments).where("to_tsvector('english', note_comments.body) @@ plainto_tsquery('english', ?)", params[:q]) if params[:q]
-
-    # Add any date filter
-    if params[:from]
-      begin
-        from = Time.parse(params[:from])
-      rescue ArgumentError
-        raise OSM::APIBadUserInput, "Date #{params[:from]} is in a wrong format"
-      end
-
-      begin
-        to = if params[:to]
-               Time.parse(params[:to])
-             else
-               Time.now
-             end
-      rescue ArgumentError
-        raise OSM::APIBadUserInput, "Date #{params[:to]} is in a wrong format"
-      end
-
-      @notes = @notes.where(:created_at => from..to)
-    end
-
-    # Find the notes we want to return
-    @notes = @notes.order("updated_at DESC").limit(result_limit).preload(:comments)
-
-    # Render the result
-    respond_to do |format|
-      format.rss { render :action => :index }
-      format.xml { render :action => :index }
-      format.json { render :action => :index }
-      format.gpx { render :action => :index }
-    end
-  end
-
   ##
   # Display a list of notes by a specified user
   def mine
@@ -333,63 +31,4 @@ class NotesController < ApplicationController
       end
     end
   end
-
-  private
-
-  #------------------------------------------------------------
-  # utility functions below.
-  #------------------------------------------------------------
-
-  ##
-  # Get the maximum number of results to return
-  def result_limit
-    if params[:limit]
-      if params[:limit].to_i.positive? && params[:limit].to_i <= 10000
-        params[:limit].to_i
-      else
-        raise OSM::APIBadUserInput, "Note limit must be between 1 and 10000"
-      end
-    else
-      100
-    end
-  end
-
-  ##
-  # Generate a condition to choose which notes we want based
-  # on their status and the user's request parameters
-  def closed_condition(notes)
-    closed_since = if params[:closed]
-                     params[:closed].to_i
-                   else
-                     7
-                   end
-
-    if closed_since.negative?
-      notes.where.not(:status => "hidden")
-    elsif closed_since.positive?
-      notes.where(:status => "open")
-           .or(notes.where(:status => "closed")
-                    .where(notes.arel_table[:closed_at].gt(Time.now - closed_since.days)))
-    else
-      notes.where(:status => "open")
-    end
-  end
-
-  ##
-  # Add a comment to a note
-  def add_comment(note, text, event, notify = true)
-    attributes = { :visible => true, :event => event, :body => text }
-
-    if current_user
-      attributes[:author_id] = current_user.id
-    else
-      attributes[:author_ip] = request.remote_ip
-    end
-
-    comment = note.comments.create!(attributes)
-
-    note.comments.map(&:author).uniq.each do |user|
-      Notifier.note_comment_notification(comment, user).deliver_later if notify && user && user != current_user && user.visible?
-    end
-  end
 end

app/helpers/note_helper.rb

@@ -18,7 +18,7 @@ module NoteHelper
     elsif author.status == "deleted"
       t("users.no_such_user.deleted")
     else
-      link_to h(author.display_name), link_options.merge(:controller => "users", :action => "show", :display_name => author.display_name)
+      link_to h(author.display_name), link_options.merge(:controller => "/users", :action => "show", :display_name => author.display_name)
     end
   end
 end

app/views/api/notes/_note.rss.builder

@@ -2,11 +2,11 @@ xml.item do
   location = describe_location(note.lat, note.lon, 14, locale)
 
   if note.closed?
-    xml.title t("notes.rss.closed", :place => location)
+    xml.title t("api.notes.rss.closed", :place => location)
   elsif note.comments.length > 1
-    xml.title t("notes.rss.commented", :place => location)
+    xml.title t("api.notes.rss.commented", :place => location)
   else
-    xml.title t("notes.rss.opened", :place => location)
+    xml.title t("api.notes.rss.opened", :place => location)
   end
 
   xml.link browse_note_url(note)

app/views/api/notes/feed.rss.builder

@@ -5,18 +5,18 @@ xml.rss("version" => "2.0",
         "xmlns:geo" => "http://www.w3.org/2003/01/geo/wgs84_pos#",
         "xmlns:georss" => "http://www.georss.org/georss") do
   xml.channel do
-    xml.title t("notes.rss.title")
+    xml.title t("api.notes.rss.title")
-    xml.description t("notes.rss.description_area", :min_lat => @min_lat, :min_lon => @min_lon, :max_lat => @max_lat, :max_lon => @max_lon)
+    xml.description t("api.notes.rss.description_area", :min_lat => @min_lat, :min_lon => @min_lon, :max_lat => @max_lat, :max_lon => @max_lon)
-    xml.link url_for(:controller => "site", :action => "index", :only_path => false)
+    xml.link url_for(:controller => "/site", :action => "index", :only_path => false)
 
     @comments.each do |comment|
       location = describe_location(comment.note.lat, comment.note.lon, 14, locale)
 
       xml.item do
-        xml.title t("notes.rss.#{comment.event}", :place => location)
+        xml.title t("api.notes.rss.#{comment.event}", :place => location)
 
-        xml.link url_for(:controller => "browse", :action => "note", :id => comment.note.id, :anchor => "c#{comment.id}", :only_path => false)
+        xml.link url_for(:controller => "/browse", :action => "note", :id => comment.note.id, :anchor => "c#{comment.id}", :only_path => false)
-        xml.guid url_for(:controller => "browse", :action => "note", :id => comment.note.id, :anchor => "c#{comment.id}", :only_path => false)
+        xml.guid url_for(:controller => "/browse", :action => "note", :id => comment.note.id, :anchor => "c#{comment.id}", :only_path => false)
 
         xml.description do
           xml.cdata! render(:partial => "entry", :object => comment, :formats => [:html])

app/views/api/notes/index.rss.builder

@@ -5,9 +5,9 @@ xml.rss("version" => "2.0",
         "xmlns:geo" => "http://www.w3.org/2003/01/geo/wgs84_pos#",
         "xmlns:georss" => "http://www.georss.org/georss") do
   xml.channel do
-    xml.title t("notes.rss.title")
+    xml.title t("api.notes.rss.title")
-    xml.description t("notes.rss.description_area", :min_lat => @min_lat, :min_lon => @min_lon, :max_lat => @max_lat, :max_lon => @max_lon)
+    xml.description t("api.notes.rss.description_area", :min_lat => @min_lat, :min_lon => @min_lon, :max_lat => @max_lat, :max_lon => @max_lon)
-    xml.link url_for(:controller => "site", :action => "index", :only_path => false)
+    xml.link url_for(:controller => "/site", :action => "index", :only_path => false)
 
     xml << (render(:partial => "note", :collection => @notes) || "")
   end

app/views/api/notes/show.rss.builder

@@ -4,9 +4,9 @@ xml.rss("version" => "2.0",
         "xmlns:geo" => "http://www.w3.org/2003/01/geo/wgs84_pos#",
         "xmlns:georss" => "http://www.georss.org/georss") do
   xml.channel do
-    xml.title t("notes.rss.title")
+    xml.title t("api.notes.rss.title")
-    xml.description t("notes.rss.description_item", :id => @note.id)
+    xml.description t("api.notes.rss.description_item", :id => @note.id)
-    xml.link url_for(:controller => "site", :action => "index", :only_path => false)
+    xml.link url_for(:controller => "/site", :action => "index", :only_path => false)
 
     xml << render(:partial => "note", :object => @note)
   end

config/locales/en.yml

@@ -98,6 +98,28 @@ en:
     remote:
       name: "Remote Control"
       description: "Remote Control (JOSM or Merkaartor)"
+  api:
+    notes:
+      comment:
+        opened_at_html: "Created %{when} ago"
+        opened_at_by_html: "Created %{when} ago by %{user}"
+        commented_at_html: "Updated %{when} ago"
+        commented_at_by_html: "Updated %{when} ago by %{user}"
+        closed_at_html: "Resolved %{when} ago"
+        closed_at_by_html: "Resolved %{when} ago by %{user}"
+        reopened_at_html: "Reactivated %{when} ago"
+        reopened_at_by_html: "Reactivated %{when} ago by %{user}"
+      rss:
+        title: "OpenStreetMap Notes"
+        description_area: "A list of notes, reported, commented on or closed in your area [(%{min_lat}|%{min_lon}) -- (%{max_lat}|%{max_lon})]"
+        description_item: "An rss feed for note %{id}"
+        opened: "new note (near %{place})"
+        commented: "new comment (near %{place})"
+        closed: "closed note (near %{place})"
+        reopened: "reactivated note (near %{place})"
+      entry:
+        comment: Comment
+        full: Full note
   browse:
     created: "Created"
     closed: "Closed"
@@ -2331,26 +2353,6 @@ en:
       next: "Next »"
       previous: "« Previous"
   notes:
-    comment:
-      opened_at_html: "Created %{when} ago"
-      opened_at_by_html: "Created %{when} ago by %{user}"
-      commented_at_html: "Updated %{when} ago"
-      commented_at_by_html: "Updated %{when} ago by %{user}"
-      closed_at_html: "Resolved %{when} ago"
-      closed_at_by_html: "Resolved %{when} ago by %{user}"
-      reopened_at_html: "Reactivated %{when} ago"
-      reopened_at_by_html: "Reactivated %{when} ago by %{user}"
-    rss:
-      title: "OpenStreetMap Notes"
-      description_area: "A list of notes, reported, commented on or closed in your area [(%{min_lat}|%{min_lon}) -- (%{max_lat}|%{max_lon})]"
-      description_item: "An rss feed for note %{id}"
-      opened: "new note (near %{place})"
-      commented: "new comment (near %{place})"
-      closed: "closed note (near %{place})"
-      reopened: "reactivated note (near %{place})"
-    entry:
-      comment: Comment
-      full: Full note
     mine:
       title: "Notes submitted or commented on by %{user}"
       heading: "%{user}'s notes"

config/routes.rb

@@ -90,7 +90,7 @@ OpenStreetMap::Application.routes.draw do
     get "swf/trackpoints" => "swf#trackpoints"
 
     # Map notes API
-    resources :notes, :except => [:new, :edit, :update], :constraints => { :id => /\d+/ }, :defaults => { :format => "xml" } do
+    resources :notes, :except => [:new, :edit, :update], :constraints => { :id => /\d+/ }, :defaults => { :format => "xml" }, :controller => "api/notes" do
       collection do
         get "search"
         get "feed", :defaults => { :format => "rss" }
@@ -103,11 +103,11 @@ OpenStreetMap::Application.routes.draw do
       end
     end
 
-    post "notes/addPOIexec" => "notes#create"
+    post "notes/addPOIexec" => "api/notes#create"
-    post "notes/closePOIexec" => "notes#close"
+    post "notes/closePOIexec" => "api/notes#close"
-    post "notes/editPOIexec" => "notes#comment"
+    post "notes/editPOIexec" => "api/notes#comment"
-    get "notes/getGPX" => "notes#index", :format => "gpx"
+    get "notes/getGPX" => "api/notes#index", :format => "gpx"
-    get "notes/getRSSfeed" => "notes#feed", :format => "rss"
+    get "notes/getRSSfeed" => "api/notes#feed", :format => "rss"
   end
 
   # Data browsing