jro_apps/redmine Commit - r4375:00d50157d3d6

Restores object count and adds offset/limit attributes to API responses for paginated collections (#6140)....

Jean-Philippe Lang -

r4375:00d50157d3d6

parent child

Context file:

r4375:00d50157d3d6

Collapse all files

app/controllers/application_controller.rb +17 0

              # redMine - project management software
              # Copyright (C) 2006-2007  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require 'uri'
              require 'cgi'
              class ApplicationController < ActionController::Base
                include Redmine::I18n
                layout 'base'
                exempt_from_layout 'builder', 'rsb'
                # Remove broken cookie after upgrade from 0.8.x (#4292)
                # See https://rails.lighthouseapp.com/projects/8994/tickets/3360
                # TODO: remove it when Rails is fixed
                before_filter :delete_broken_cookies
                def delete_broken_cookies
                  if cookies['_redmine_session'] && cookies['_redmine_session'] !~ /--/
                    cookies.delete '_redmine_session'
                    redirect_to home_path
                    return false
                  end
                end
                before_filter :user_setup, :check_if_login_required, :set_localization
                filter_parameter_logging :password
                protect_from_forgery
                rescue_from ActionController::InvalidAuthenticityToken, :with => :invalid_authenticity_token
                include Redmine::Search::Controller
                include Redmine::MenuManager::MenuController
                helper Redmine::MenuManager::MenuHelper
                Redmine::Scm::Base.all.each do |scm|
                  require_dependency "repository/#{scm.underscore}"
                end
                def user_setup
                  # Check the settings cache for each request
                  Setting.check_cache
                  # Find the current user
                  User.current = find_current_user
                end
                # Returns the current user or nil if no user is logged in
                # and starts a session if needed
                def find_current_user
                  if session[:user_id]
                    # existing session
                    (User.active.find(session[:user_id]) rescue nil)
                  elsif cookies[:autologin] && Setting.autologin?
                    # auto-login feature starts a new session
                    user = User.try_to_autologin(cookies[:autologin])
                    session[:user_id] = user.id if user
                    user
                  elsif params[:format] == 'atom' && params[:key] && accept_key_auth_actions.include?(params[:action])
                    # RSS key authentication does not start a session
                    User.find_by_rss_key(params[:key])
                  elsif Setting.rest_api_enabled? && ['xml', 'json'].include?(params[:format])
                    if params[:key].present? && accept_key_auth_actions.include?(params[:action])
                      # Use API key
                      User.find_by_api_key(params[:key])
                    else
                      # HTTP Basic, either username/password or API key/random
                      authenticate_with_http_basic do |username, password|
                        User.try_to_login(username, password) || User.find_by_api_key(username)
                      end
                    end
                  end
                end
                # Sets the logged in user
                def logged_user=(user)
                  reset_session
                  if user && user.is_a?(User)
                    User.current = user
                    session[:user_id] = user.id
                  else
                    User.current = User.anonymous
                  end
                end
                # check if login is globally required to access the application
                def check_if_login_required
                  # no check needed if user is already logged in
                  return true if User.current.logged?
                  require_login if Setting.login_required?
                end
                def set_localization
                  lang = nil
                  if User.current.logged?
                    lang = find_language(User.current.language)
                  end
                  if lang.nil? && request.env['HTTP_ACCEPT_LANGUAGE']
                    accept_lang = parse_qvalues(request.env['HTTP_ACCEPT_LANGUAGE']).first
                    if !accept_lang.blank?
                      accept_lang = accept_lang.downcase
                      lang = find_language(accept_lang) || find_language(accept_lang.split('-').first)
                    end
                  end
                  lang ||= Setting.default_language
                  set_language_if_valid(lang)
                end
                def require_login
                  if !User.current.logged?
                    # Extract only the basic url parameters on non-GET requests
                    if request.get?
                      url = url_for(params)
                    else
                      url = url_for(:controller => params[:controller], :action => params[:action], :id => params[:id], :project_id => params[:project_id])
                    end
                    respond_to do |format|
                      format.html { redirect_to :controller => "account", :action => "login", :back_url => url }
                      format.atom { redirect_to :controller => "account", :action => "login", :back_url => url }
                      format.xml  { head :unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"' }
                      format.js   { head :unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"' }
                      format.json { head :unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"' }
                    end
                    return false
                  end
                  true
                end
                def require_admin
                  return unless require_login
                  if !User.current.admin?
                    render_403
                    return false
                  end
                  true
                end
                def deny_access
                  User.current.logged? ? render_403 : require_login
                end
                # Authorize the user for the requested action
                def authorize(ctrl = params[:controller], action = params[:action], global = false)
                  allowed = User.current.allowed_to?({:controller => ctrl, :action => action}, @project || @projects, :global => global)
                  if allowed
                    true
                  else
                    if @project && @project.archived?
                      render_403 :message => :notice_not_authorized_archived_project
                    else
                      deny_access
                    end
                  end
                end
                # Authorize the user for the requested action outside a project
                def authorize_global(ctrl = params[:controller], action = params[:action], global = true)
                  authorize(ctrl, action, global)
                end
                # Find project of id params[:id]
                def find_project
                  @project = Project.find(params[:id])
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                # Find project of id params[:project_id]
                def find_project_by_project_id
                  @project = Project.find(params[:project_id])
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                # Find a project based on params[:project_id]
                # TODO: some subclasses override this, see about merging their logic
                def find_optional_project
                  @project = Project.find(params[:project_id]) unless params[:project_id].blank?
                  allowed = User.current.allowed_to?({:controller => params[:controller], :action => params[:action]}, @project, :global => true)
                  allowed ? true : deny_access
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                # Finds and sets @project based on @object.project
                def find_project_from_association
                  render_404 unless @object.present?
                  @project = @object.project
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def find_model_object
                  model = self.class.read_inheritable_attribute('model_object')
                  if model
                    @object = model.find(params[:id])
                    self.instance_variable_set('@' + controller_name.singularize, @object) if @object
                  end
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def self.model_object(model)
                  write_inheritable_attribute('model_object', model)
                end
                # Filter for bulk issue operations
                def find_issues
                  @issues = Issue.find_all_by_id(params[:id] || params[:ids])
                  raise ActiveRecord::RecordNotFound if @issues.empty?
                  @projects = @issues.collect(&:project).compact.uniq
                  @project = @projects.first if @projects.size == 1
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                # Check if project is unique before bulk operations
                def check_project_uniqueness
                  unless @project
                    # TODO: let users bulk edit/move/destroy issues from different projects
                    render_error 'Can not bulk edit/move/destroy issues from different projects'
                    return false
                  end
                end
                # make sure that the user is a member of the project (or admin) if project is private
                # used as a before_filter for actions that do not require any particular permission on the project
                def check_project_privacy
                  if @project && @project.active?
                    if @project.is_public? || User.current.member_of?(@project) || User.current.admin?
                      true
                    else
                      User.current.logged? ? render_403 : require_login
                    end
                  else
                    @project = nil
                    render_404
                    false
                  end
                end
                def back_url
                  params[:back_url] || request.env['HTTP_REFERER']
                end
                def redirect_back_or_default(default)
                  back_url = CGI.unescape(params[:back_url].to_s)
                  if !back_url.blank?
                    begin
                      uri = URI.parse(back_url)
                      # do not redirect user to another host or to the login or register page
                      if (uri.relative? || (uri.host == request.host)) && !uri.path.match(%r{/(login|account/register)})
                        redirect_to(back_url)
                        return
                      end
                    rescue URI::InvalidURIError
                      # redirect to default
                    end
                  end
                  redirect_to default
                end
                def render_403(options={})
                  @project = nil
                  render_error({:message => :notice_not_authorized, :status => 403}.merge(options))
                  return false
                end
                def render_404(options={})
                  render_error({:message => :notice_file_not_found, :status => 404}.merge(options))
                  return false
                end
                # Renders an error response
                def render_error(arg)
                  arg = {:message => arg} unless arg.is_a?(Hash)
                  @message = arg[:message]
                  @message = l(@message) if @message.is_a?(Symbol)
                  @status = arg[:status] || 500
                  respond_to do |format|
                    format.html {
                      render :template => 'common/error', :layout => use_layout, :status => @status
                    }
                    format.atom { head @status }
                    format.xml { head @status }
                    format.js { head @status }
                    format.json { head @status }
                  end
                end
                # Picks which layout to use based on the request
                #
                # @return [boolean, string] name of the layout to use or false for no layout
                def use_layout
                  request.xhr? ? false : 'base'
                end
                def invalid_authenticity_token
                  if api_request?
                    logger.error "Form authenticity token is missing or is invalid. API calls must include a proper Content-type header (text/xml or text/json)."
                  end
                  render_error "Invalid form authenticity token."
                end
                def render_feed(items, options={})
                  @items = items || []
                  @items.sort! {|x,y| y.event_datetime <=> x.event_datetime }
                  @items = @items.slice(0, Setting.feeds_limit.to_i)
                  @title = options[:title] || Setting.app_title
                  render :template => "common/feed.atom.rxml", :layout => false, :content_type => 'application/atom+xml'
                end
                def self.accept_key_auth(*actions)
                  actions = actions.flatten.map(&:to_s)
                  write_inheritable_attribute('accept_key_auth_actions', actions)
                end
                def accept_key_auth_actions
                  self.class.read_inheritable_attribute('accept_key_auth_actions') || []
                end
                # Returns the number of objects that should be displayed
                # on the paginated list
                def per_page_option
                  per_page = nil
                  if params[:per_page] && Setting.per_page_options_array.include?(params[:per_page].to_s.to_i)
                    per_page = params[:per_page].to_s.to_i
                    session[:per_page] = per_page
                  elsif session[:per_page]
                    per_page = session[:per_page]
                  else
                    per_page = Setting.per_page_options_array.first || 25
                  end
                  per_page
                end
+               def api_offset_and_limit
+                 offset = nil
+                 if params[:offset].present?
+                   offset = params[:offset].to_i
+                   if offset < 0
+                     offset = 0
+                   end
+                 end
+                 limit = params[:limit].to_i
+                 if limit < 1
+                   limit = 25
+                 elsif limit > 100
+                   limit = 100
+                 end
+                 [offset, limit]
+               end
                # qvalues http header parser
                # code taken from webrick
                def parse_qvalues(value)
                  tmp = []
                  if value
                    parts = value.split(/,\s*/)
                    parts.each {|part|
                      if m = %r{^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$}.match(part)
                        val = m[1]
                        q = (m[2] or 1).to_f
                        tmp.push([val, q])
                      end
                    }
                    tmp = tmp.sort_by{|val, q| -q}
                    tmp.collect!{|val, q| val}
                  end
                  return tmp
                rescue
                  nil
                end
                # Returns a string that can be used as filename value in Content-Disposition header
                def filename_for_content_disposition(name)
                  request.env['HTTP_USER_AGENT'] =~ %r{MSIE} ? ERB::Util.url_encode(name) : name
                end
                def api_request?
                  %w(xml json).include? params[:format]
                end
                # Renders a warning flash if obj has unsaved attachments
                def render_attachment_warning_if_needed(obj)
                  flash[:warning] = l(:warning_attachments_not_saved, obj.unsaved_attachments.size) if obj.unsaved_attachments.present?
                end
                # Sets the `flash` notice or error based the number of issues that did not save
                #
                # @param [Array, Issue] issues all of the saved and unsaved Issues
                # @param [Array, Integer] unsaved_issue_ids the issue ids that were not saved
                def set_flash_from_bulk_issue_save(issues, unsaved_issue_ids)
                  if unsaved_issue_ids.empty?
                    flash[:notice] = l(:notice_successful_update) unless issues.empty?
                  else
                    flash[:error] = l(:notice_failed_to_save_issues,
                                      :count => unsaved_issue_ids.size,
                                      :total => issues.size,
                                      :ids => '#' + unsaved_issue_ids.join(', #'))
                  end
                end
                # Rescues an invalid query statement. Just in case...
                def query_statement_invalid(exception)
                  logger.error "Query::StatementInvalid: #{exception.message}" if logger
                  session.delete(:query)
                  sort_clear if respond_to?(:sort_clear)
                  render_error "An error occurred while executing the query and has been logged. Please report this error to your Redmine administrator."
                end
                # Converts the errors on an ActiveRecord object into a common JSON format
                def object_errors_to_json(object)
                  object.errors.collect do |attribute, error|
                    { attribute => error }
                  end.to_json
                end
                # Renders API response on validation failure
                def render_validation_errors(object)
                  options = { :status => :unprocessable_entity, :layout => false }
                  options.merge!(case params[:format]
                    when 'xml';  { :xml =>  object.errors }
                    when 'json'; { :json => {'errors' => object.errors} } # ActiveResource client compliance
                    else
                      raise "Unknown format #{params[:format]} in #render_validation_errors"
                    end
                  )
                  render options
                end
                # Overrides #default_template so that the api template
                # is used automatically if it exists
                def default_template(action_name = self.action_name)
                  if api_request?
                    begin
                      return self.view_paths.find_template(default_template_name(action_name), 'api')
                    rescue ::ActionView::MissingTemplate
                      # the api template was not found
                      # fallback to the default behaviour
                    end
                  end
                  super
                end
                # Overrides #pick_layout so that #render with no arguments
                # doesn't use the layout for api requests
                def pick_layout(*args)
                  api_request? ? nil : super
                end
              end

app/controllers/issues_controller.rb +10 -7

              # Redmine - project management software
              # Copyright (C) 2006-2008  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              class IssuesController < ApplicationController
                menu_item :new_issue, :only => [:new, :create]
                default_search_scope :issues
                before_filter :find_issue, :only => [:show, :edit, :update]
                before_filter :find_issues, :only => [:bulk_edit, :bulk_update, :move, :perform_move, :destroy]
                before_filter :check_project_uniqueness, :only => [:move, :perform_move]
                before_filter :find_project, :only => [:new, :create]
                before_filter :authorize, :except => [:index]
                before_filter :find_optional_project, :only => [:index]
                before_filter :check_for_default_issue_status, :only => [:new, :create]
                before_filter :build_new_issue_from_params, :only => [:new, :create]
                accept_key_auth :index, :show, :create, :update, :destroy
                rescue_from Query::StatementInvalid, :with => :query_statement_invalid
                helper :journals
                helper :projects
                include ProjectsHelper
                helper :custom_fields
                include CustomFieldsHelper
                helper :issue_relations
                include IssueRelationsHelper
                helper :watchers
                include WatchersHelper
                helper :attachments
                include AttachmentsHelper
                helper :queries
                include QueriesHelper
                helper :sort
                include SortHelper
                include IssuesHelper
                helper :timelog
                helper :gantt
                include Redmine::Export::PDF
                verify :method => [:post, :delete],
                       :only => :destroy,
                       :render => { :nothing => true, :status => :method_not_allowed }
                verify :method => :post, :only => :create, :render => {:nothing => true, :status => :method_not_allowed }
                verify :method => :post, :only => :bulk_update, :render => {:nothing => true, :status => :method_not_allowed }
                verify :method => :put, :only => :update, :render => {:nothing => true, :status => :method_not_allowed }
                def index
                  retrieve_query
                  sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
                  sort_update(@query.sortable_columns)
                  if @query.valid?
-                   limit = case params[:format]
+                   case params[:format]
                    when 'csv', 'pdf'
-                     Setting.issues_export_limit.to_i
+                     @limit = Setting.issues_export_limit.to_i
                    when 'atom'
-                     Setting.feeds_limit.to_i
+                     @limit = Setting.feeds_limit.to_i
+                   when 'xml', 'json'
+                     @offset, @limit = api_offset_and_limit
                    else
-                     per_page_option
+                     @limit = per_page_option
                    end
                    @issue_count = @query.issue_count
-                   @issue_pages = Paginator.new self, @issue_count, limit, params['page']
+                   @issue_pages = Paginator.new self, @issue_count, @limit, params['page']
+                   @offset ||= @issue_pages.current.offset
                    @issues = @query.issues(:include => [:assigned_to, :tracker, :priority, :category, :fixed_version],
                                            :order => sort_clause,
-                                           :offset => @issue_pages.current.offset,
-                                           :limit => limit)
+                                           :offset => @offset,
+                                           :limit => @limit)
                    @issue_count_by_group = @query.issue_count_by_group
                    respond_to do |format|
                      format.html { render :template => 'issues/index.rhtml', :layout => !request.xhr? }
                      format.api
                      format.atom { render_feed(@issues, :title => "#{@project || Setting.app_title}: #{l(:label_issue_plural)}") }
                      format.csv  { send_data(issues_to_csv(@issues, @project), :type => 'text/csv; header=present', :filename => 'export.csv') }
                      format.pdf  { send_data(issues_to_pdf(@issues, @project, @query), :type => 'application/pdf', :filename => 'export.pdf') }
                    end
                  else
                    # Send html if the query is not valid
                    render(:template => 'issues/index.rhtml', :layout => !request.xhr?)
                  end
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def show
                  @journals = @issue.journals.find(:all, :include => [:user, :details], :order => "#{Journal.table_name}.created_on ASC")
                  @journals.each_with_index {|j,i| j.indice = i+1}
                  @journals.reverse! if User.current.wants_comments_in_reverse_order?
                  @changesets = @issue.changesets.visible.all
                  @changesets.reverse! if User.current.wants_comments_in_reverse_order?
                  @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                  @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
                  @priorities = IssuePriority.all
                  @time_entry = TimeEntry.new
                  respond_to do |format|
                    format.html { render :template => 'issues/show.rhtml' }
                    format.api
                    format.atom { render :template => 'journals/index', :layout => false, :content_type => 'application/atom+xml' }
                    format.pdf  { send_data(issue_to_pdf(@issue), :type => 'application/pdf', :filename => "#{@project.identifier}-#{@issue.id}.pdf") }
                  end
                end
                # Add a new issue
                # The new issue will be created from an existing one if copy_from parameter is given
                def new
                  respond_to do |format|
                    format.html { render :action => 'new', :layout => !request.xhr? }
                    format.js { render :partial => 'attributes' }
                  end
                end
                def create
                  call_hook(:controller_issues_new_before_save, { :params => params, :issue => @issue })
                  if @issue.save
                    attachments = Attachment.attach_files(@issue, params[:attachments])
                    render_attachment_warning_if_needed(@issue)
                    flash[:notice] = l(:notice_successful_create)
                    call_hook(:controller_issues_new_after_save, { :params => params, :issue => @issue})
                    respond_to do |format|
                      format.html {
                        redirect_to(params[:continue] ?  { :action => 'new', :project_id => @project, :issue => {:tracker_id => @issue.tracker, :parent_issue_id => @issue.parent_issue_id}.reject {|k,v| v.nil?} } :
                                    { :action => 'show', :id => @issue })
                      }
                      format.api  { render :action => 'show', :status => :created, :location => issue_url(@issue) }
                    end
                    return
                  else
                    respond_to do |format|
                      format.html { render :action => 'new' }
                      format.api  { render_validation_errors(@issue) }
                    end
                  end
                end
                def edit
                  update_issue_from_params
                  @journal = @issue.current_journal
                  respond_to do |format|
                    format.html { }
                    format.xml  { }
                  end
                end
                def update
                  update_issue_from_params
                  if @issue.save_issue_with_child_records(params, @time_entry)
                    render_attachment_warning_if_needed(@issue)
                    flash[:notice] = l(:notice_successful_update) unless @issue.current_journal.new_record?
                    respond_to do |format|
                      format.html { redirect_back_or_default({:action => 'show', :id => @issue}) }
                      format.api  { head :ok }
                    end
                  else
                    render_attachment_warning_if_needed(@issue)
                    flash[:notice] = l(:notice_successful_update) unless @issue.current_journal.new_record?
                    @journal = @issue.current_journal
                    respond_to do |format|
                      format.html { render :action => 'edit' }
                      format.api  { render_validation_errors(@issue) }
                    end
                  end
                end
                # Bulk edit a set of issues
                def bulk_edit
                  @issues.sort!
                  @available_statuses = @projects.map{|p|Workflow.available_statuses(p)}.inject{|memo,w|memo & w}
                  @custom_fields = @projects.map{|p|p.all_issue_custom_fields}.inject{|memo,c|memo & c}
                  @assignables = @projects.map(&:assignable_users).inject{|memo,a| memo & a}
                  @trackers = @projects.map(&:trackers).inject{|memo,t| memo & t}
                end
                def bulk_update
                  @issues.sort!
                  attributes = parse_params_for_bulk_issue_attributes(params)
                  unsaved_issue_ids = []
                  @issues.each do |issue|
                    issue.reload
                    journal = issue.init_journal(User.current, params[:notes])
                    issue.safe_attributes = attributes
                    call_hook(:controller_issues_bulk_edit_before_save, { :params => params, :issue => issue })
                    unless issue.save
                      # Keep unsaved issue ids to display them in flash error
                      unsaved_issue_ids << issue.id
                    end
                  end
                  set_flash_from_bulk_issue_save(@issues, unsaved_issue_ids)
                  redirect_back_or_default({:controller => 'issues', :action => 'index', :project_id => @project})
                end
                def destroy
                  @hours = TimeEntry.sum(:hours, :conditions => ['issue_id IN (?)', @issues]).to_f
                  if @hours > 0
                    case params[:todo]
                    when 'destroy'
                      # nothing to do
                    when 'nullify'
                      TimeEntry.update_all('issue_id = NULL', ['issue_id IN (?)', @issues])
                    when 'reassign'
                      reassign_to = @project.issues.find_by_id(params[:reassign_to_id])
                      if reassign_to.nil?
                        flash.now[:error] = l(:error_issue_not_found_in_project)
                        return
                      else
                        TimeEntry.update_all("issue_id = #{reassign_to.id}", ['issue_id IN (?)', @issues])
                      end
                    else
                      # display the destroy form if it's a user request
                      return unless api_request?
                    end
                  end
                  @issues.each(&:destroy)
                  respond_to do |format|
                    format.html { redirect_back_or_default(:action => 'index', :project_id => @project) }
                    format.api  { head :ok }
                  end
                end
              private
                def find_issue
                  @issue = Issue.find(params[:id], :include => [:project, :tracker, :status, :author, :priority, :category])
                  @project = @issue.project
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def find_project
                  project_id = (params[:issue] && params[:issue][:project_id]) || params[:project_id]
                  @project = Project.find(project_id)
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                # Used by #edit and #update to set some common instance variables
                # from the params
                # TODO: Refactor, not everything in here is needed by #edit
                def update_issue_from_params
                  @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                  @priorities = IssuePriority.all
                  @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
                  @time_entry = TimeEntry.new
                  @time_entry.attributes = params[:time_entry]
                  @notes = params[:notes] || (params[:issue].present? ? params[:issue][:notes] : nil)
                  @issue.init_journal(User.current, @notes)
                  @issue.safe_attributes = params[:issue]
                end
                # TODO: Refactor, lots of extra code in here
                # TODO: Changing tracker on an existing issue should not trigger this
                def build_new_issue_from_params
                  if params[:id].blank?
                    @issue = Issue.new
                    @issue.copy_from(params[:copy_from]) if params[:copy_from]
                    @issue.project = @project
                  else
                    @issue = @project.issues.visible.find(params[:id])
                  end
                  @issue.project = @project
                  # Tracker must be set before custom field values
                  @issue.tracker ||= @project.trackers.find((params[:issue] && params[:issue][:tracker_id]) || params[:tracker_id] || :first)
                  if @issue.tracker.nil?
                    render_error l(:error_no_tracker_in_project)
                    return false
                  end
                  @issue.start_date ||= Date.today
                  if params[:issue].is_a?(Hash)
                    @issue.safe_attributes = params[:issue]
                    if User.current.allowed_to?(:add_issue_watchers, @project) && @issue.new_record?
                      @issue.watcher_user_ids = params[:issue]['watcher_user_ids']
                    end
                  end
                  @issue.author = User.current
                  @priorities = IssuePriority.all
                  @allowed_statuses = @issue.new_statuses_allowed_to(User.current, true)
                end
                def check_for_default_issue_status
                  if IssueStatus.default.nil?
                    render_error l(:error_no_default_issue_status)
                    return false
                  end
                end
                def parse_params_for_bulk_issue_attributes(params)
                  attributes = (params[:issue] || {}).reject {|k,v| v.blank?}
                  attributes.keys.each {|k| attributes[k] = '' if attributes[k] == 'none'}
                  attributes[:custom_field_values].reject! {|k,v| v.blank?} if attributes[:custom_field_values]
                  attributes
                end
              end

app/controllers/users_controller.rb +13 -6

              # Redmine - project management software
              # Copyright (C) 2006-2010  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              class UsersController < ApplicationController
                layout 'admin'
                before_filter :require_admin, :except => :show
                accept_key_auth :index, :show, :create, :update
                helper :sort
                include SortHelper
                helper :custom_fields
                include CustomFieldsHelper
                def index
                  sort_init 'login', 'asc'
                  sort_update %w(login firstname lastname mail admin created_on last_login_on)
+                 case params[:format]
+                 when 'xml', 'json'
+                   @offset, @limit = api_offset_and_limit
+                 else
+                   @limit = per_page_option
+                 end
                  @status = params[:status] ? params[:status].to_i : 1
                  c = ARCondition.new(@status == 0 ? "status <> 0" : ["status = ?", @status])
                  unless params[:name].blank?
                    name = "%#{params[:name].strip.downcase}%"
                    c << ["LOWER(login) LIKE ? OR LOWER(firstname) LIKE ? OR LOWER(lastname) LIKE ? OR LOWER(mail) LIKE ?", name, name, name, name]
                  end
                  @user_count = User.count(:conditions => c.conditions)
-                 @user_pages = Paginator.new self, @user_count,
-             								per_page_option,
-             								params['page']
-                 @users =  User.find :all,:order => sort_clause,
+                 @user_pages = Paginator.new self, @user_count, @limit, params['page']
+                 @offset ||= @user_pages.current.offset
+                 @users =  User.find :all,
+                                     :order => sort_clause,
                                      :conditions => c.conditions,
-             						:limit  =>  @user_pages.items_per_page,
-             						:offset =>  @user_pages.current.offset
+                                     :limit  =>  @limit,
+                                     :offset =>  @offset
              		respond_to do |format|
              		  format.html { render :layout => !request.xhr? }
                    format.api
              		end
                end
                def show
                  @user = User.find(params[:id])
                  # show projects based on current user visibility
                  @memberships = @user.memberships.all(:conditions => Project.visible_by(User.current))
                  events = Redmine::Activity::Fetcher.new(User.current, :author => @user).events(nil, nil, :limit => 10)
                  @events_by_day = events.group_by(&:event_date)
                  unless User.current.admin?
                    if !@user.active? || (@user != User.current  && @memberships.empty? && events.empty?)
                      render_404
                      return
                    end
                  end
                  respond_to do |format|
                    format.html { render :layout => 'base' }
                    format.api
                  end
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def new
                  @notification_options = User::MAIL_NOTIFICATION_OPTIONS
                  @notification_option = Setting.default_notification_option
                  @user = User.new(:language => Setting.default_language)
                  @auth_sources = AuthSource.find(:all)
                end
                verify :method => :post, :only => :create, :render => {:nothing => true, :status => :method_not_allowed }
                def create
                  @notification_options = User::MAIL_NOTIFICATION_OPTIONS
                  @notification_option = Setting.default_notification_option
                  @user = User.new(params[:user])
                  @user.admin = params[:user][:admin] || false
                  @user.login = params[:user][:login]
                  @user.password, @user.password_confirmation = params[:password], params[:password_confirmation] unless @user.auth_source_id
                  # TODO: Similar to My#account
                  @user.mail_notification = params[:notification_option] || 'only_my_events'
                  @user.pref.attributes = params[:pref]
                  @user.pref[:no_self_notified] = (params[:no_self_notified] == '1')
                  if @user.save
                    @user.pref.save
                    @user.notified_project_ids = (params[:notification_option] == 'selected' ? params[:notified_project_ids] : [])
                    Mailer.deliver_account_information(@user, params[:password]) if params[:send_information]
                    respond_to do |format|
                      format.html {
                        flash[:notice] = l(:notice_successful_create)
                        redirect_to(params[:continue] ?
                          {:controller => 'users', :action => 'new'} :
                          {:controller => 'users', :action => 'edit', :id => @user}
                        )
                      }
                      format.api  { render :action => 'show', :status => :created, :location => user_url(@user) }
                    end
                  else
                    @auth_sources = AuthSource.find(:all)
                    @notification_option = @user.mail_notification
                    respond_to do |format|
                      format.html { render :action => 'new' }
                      format.api  { render_validation_errors(@user) }
                    end
                  end
                end
                def edit
                  @user = User.find(params[:id])
                  @notification_options = @user.valid_notification_options
                  @notification_option = @user.mail_notification
                  @auth_sources = AuthSource.find(:all)
                  @membership ||= Member.new
                end
                verify :method => :put, :only => :update, :render => {:nothing => true, :status => :method_not_allowed }
                def update
                  @user = User.find(params[:id])
                  @notification_options = @user.valid_notification_options
                  @notification_option = @user.mail_notification
                  @user.admin = params[:user][:admin] if params[:user][:admin]
                  @user.login = params[:user][:login] if params[:user][:login]
                  if params[:password].present? && (@user.auth_source_id.nil? || params[:user][:auth_source_id].blank?)
                    @user.password, @user.password_confirmation = params[:password], params[:password_confirmation]
                  end
                  @user.group_ids = params[:user][:group_ids] if params[:user][:group_ids]
                  @user.attributes = params[:user]
                  # Was the account actived ? (do it before User#save clears the change)
                  was_activated = (@user.status_change == [User::STATUS_REGISTERED, User::STATUS_ACTIVE])
                  # TODO: Similar to My#account
                  @user.mail_notification = params[:notification_option] || 'only_my_events'
                  @user.pref.attributes = params[:pref]
                  @user.pref[:no_self_notified] = (params[:no_self_notified] == '1')
                  if @user.save
                    @user.pref.save
                    @user.notified_project_ids = (params[:notification_option] == 'selected' ? params[:notified_project_ids] : [])
                    if was_activated
                      Mailer.deliver_account_activated(@user)
                    elsif @user.active? && params[:send_information] && !params[:password].blank? && @user.auth_source_id.nil?
                      Mailer.deliver_account_information(@user, params[:password])
                    end
                    respond_to do |format|
                      format.html {
                        flash[:notice] = l(:notice_successful_update)
                        redirect_to :back
                      }
                      format.api  { head :ok }
                    end
                  else
                    @auth_sources = AuthSource.find(:all)
                    @membership ||= Member.new
                    respond_to do |format|
                      format.html { render :action => :edit }
                      format.api  { render_validation_errors(@user) }
                    end
                  end
                rescue ::ActionController::RedirectBackError
                  redirect_to :controller => 'users', :action => 'edit', :id => @user
                end
                def edit_membership
                  @user = User.find(params[:id])
                  @membership = Member.edit_membership(params[:membership_id], params[:membership], @user)
                  @membership.save if request.post?
                  respond_to do |format|
                    if @membership.valid?
                      format.html { redirect_to :controller => 'users', :action => 'edit', :id => @user, :tab => 'memberships' }
                      format.js {
                        render(:update) {|page|
                          page.replace_html "tab-content-memberships", :partial => 'users/memberships'
                          page.visual_effect(:highlight, "member-#{@membership.id}")
                        }
                      }
                    else
                      format.js {
                        render(:update) {|page|
                          page.alert(l(:notice_failed_to_save_members, :errors => @membership.errors.full_messages.join(', ')))
                        }
                      }
                    end
                  end
                end
                def destroy_membership
                  @user = User.find(params[:id])
                  @membership = Member.find(params[:membership_id])
                  if request.post? && @membership.deletable?
                    @membership.destroy
                  end
                  respond_to do |format|
                    format.html { redirect_to :controller => 'users', :action => 'edit', :id => @user, :tab => 'memberships' }
                    format.js { render(:update) {|page| page.replace_html "tab-content-memberships", :partial => 'users/memberships'} }
                  end
                end
              end

app/helpers/application_helper.rb +12 0

              # Redmine - project management software
              # Copyright (C) 2006-2010  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require 'forwardable'
              require 'cgi'
              module ApplicationHelper
                include Redmine::WikiFormatting::Macros::Definitions
                include Redmine::I18n
                include GravatarHelper::PublicMethods
                extend Forwardable
                def_delegators :wiki_helper, :wikitoolbar_for, :heads_for_wiki_formatter
                # Return true if user is authorized for controller/action, otherwise false
                def authorize_for(controller, action)
                  User.current.allowed_to?({:controller => controller, :action => action}, @project)
                end
                # Display a link if user is authorized
                #
                # @param [String] name Anchor text (passed to link_to)
                # @param [Hash] options Hash params. This will checked by authorize_for to see if the user is authorized
                # @param [optional, Hash] html_options Options passed to link_to
                # @param [optional, Hash] parameters_for_method_reference Extra parameters for link_to
                def link_to_if_authorized(name, options = {}, html_options = nil, *parameters_for_method_reference)
                  link_to(name, options, html_options, *parameters_for_method_reference) if authorize_for(options[:controller] || params[:controller], options[:action])
                end
                # Display a link to remote if user is authorized
                def link_to_remote_if_authorized(name, options = {}, html_options = nil)
                  url = options[:url] || {}
                  link_to_remote(name, options, html_options) if authorize_for(url[:controller] || params[:controller], url[:action])
                end
                # Displays a link to user's account page if active
                def link_to_user(user, options={})
                  if user.is_a?(User)
                    name = h(user.name(options[:format]))
                    if user.active?
                      link_to name, :controller => 'users', :action => 'show', :id => user
                    else
                      name
                    end
                  else
                    h(user.to_s)
                  end
                end
                # Displays a link to +issue+ with its subject.
                # Examples:
                #
                #   link_to_issue(issue)                        # => Defect #6: This is the subject
                #   link_to_issue(issue, :truncate => 6)        # => Defect #6: This i...
                #   link_to_issue(issue, :subject => false)     # => Defect #6
                #   link_to_issue(issue, :project => true)      # => Foo - Defect #6
                #
                def link_to_issue(issue, options={})
                  title = nil
                  subject = nil
                  if options[:subject] == false
                    title = truncate(issue.subject, :length => 60)
                  else
                    subject = issue.subject
                    if options[:truncate]
                      subject = truncate(subject, :length => options[:truncate])
                    end
                  end
                  s = link_to "#{issue.tracker} ##{issue.id}", {:controller => "issues", :action => "show", :id => issue},
                                                               :class => issue.css_classes,
                                                               :title => title
                  s << ": #{h subject}" if subject
                  s = "#{h issue.project} - " + s if options[:project]
                  s
                end
                # Generates a link to an attachment.
                # Options:
                # * :text - Link text (default to attachment filename)
                # * :download - Force download (default: false)
                def link_to_attachment(attachment, options={})
                  text = options.delete(:text) || attachment.filename
                  action = options.delete(:download) ? 'download' : 'show'
                  link_to(h(text), {:controller => 'attachments', :action => action, :id => attachment, :filename => attachment.filename }, options)
                end
                # Generates a link to a SCM revision
                # Options:
                # * :text - Link text (default to the formatted revision)
                def link_to_revision(revision, project, options={})
                  text = options.delete(:text) || format_revision(revision)
                  link_to(text, {:controller => 'repositories', :action => 'revision', :id => project, :rev => revision}, :title => l(:label_revision_id, revision))
                end
                # Generates a link to a project if active
                # Examples:
                #
                #   link_to_project(project)                          # => link to the specified project overview
                #   link_to_project(project, :action=>'settings')     # => link to project settings
                #   link_to_project(project, {:only_path => false}, :class => "project") # => 3rd arg adds html options
                #   link_to_project(project, {}, :class => "project") # => html options with default url (project overview)
                #
                def link_to_project(project, options={}, html_options = nil)
                  if project.active?
                    url = {:controller => 'projects', :action => 'show', :id => project}.merge(options)
                    link_to(h(project), url, html_options)
                  else
                    h(project)
                  end
                end
                def toggle_link(name, id, options={})
                  onclick = "Element.toggle('#{id}'); "
                  onclick << (options[:focus] ? "Form.Element.focus('#{options[:focus]}'); " : "this.blur(); ")
                  onclick << "return false;"
                  link_to(name, "#", :onclick => onclick)
                end
                def image_to_function(name, function, html_options = {})
                  html_options.symbolize_keys!
                  tag(:input, html_options.merge({
                      :type => "image", :src => image_path(name),
                      :onclick => (html_options[:onclick] ? "#{html_options[:onclick]}; " : "") + "#{function};"
                      }))
                end
                def prompt_to_remote(name, text, param, url, html_options = {})
                  html_options[:onclick] = "promptToRemote('#{text}', '#{param}', '#{url_for(url)}'); return false;"
                  link_to name, {}, html_options
                end
                def format_activity_title(text)
                  h(truncate_single_line(text, :length => 100))
                end
                def format_activity_day(date)
                  date == Date.today ? l(:label_today).titleize : format_date(date)
                end
                def format_activity_description(text)
                  h(truncate(text.to_s, :length => 120).gsub(%r{[\r\n]*<(pre|code)>.*$}m, '...')).gsub(/[\r\n]+/, "<br />")
                end
                def format_version_name(version)
                  if version.project == @project
                  	h(version)
                  else
                    h("#{version.project} - #{version}")
                  end
                end
                def due_date_distance_in_words(date)
                  if date
                    l((date < Date.today ? :label_roadmap_overdue : :label_roadmap_due_in), distance_of_date_in_words(Date.today, date))
                  end
                end
                def render_page_hierarchy(pages, node=nil)
                  content = ''
                  if pages[node]
                    content << "<ul class=\"pages-hierarchy\">\n"
                    pages[node].each do |page|
                      content << "<li>"
                      content << link_to(h(page.pretty_title), {:controller => 'wiki', :action => 'show', :project_id => page.project, :id => page.title},
                                         :title => (page.respond_to?(:updated_on) ? l(:label_updated_time, distance_of_time_in_words(Time.now, page.updated_on)) : nil))
                      content << "\n" + render_page_hierarchy(pages, page.id) if pages[page.id]
                      content << "</li>\n"
                    end
                    content << "</ul>\n"
                  end
                  content
                end
                # Renders flash messages
                def render_flash_messages
                  s = ''
                  flash.each do |k,v|
                    s << content_tag('div', v, :class => "flash #{k}")
                  end
                  s
                end
                # Renders tabs and their content
                def render_tabs(tabs)
                  if tabs.any?
                    render :partial => 'common/tabs', :locals => {:tabs => tabs}
                  else
                    content_tag 'p', l(:label_no_data), :class => "nodata"
                  end
                end
                # Renders the project quick-jump box
                def render_project_jump_box
                  # Retrieve them now to avoid a COUNT query
                  projects = User.current.projects.all
                  if projects.any?
                    s = '<select onchange="if (this.value != \'\') { window.location = this.value; }">' +
                          "<option value=''>#{ l(:label_jump_to_a_project) }</option>" +
                          '<option value="" disabled="disabled">---</option>'
                    s << project_tree_options_for_select(projects, :selected => @project) do |p|
                      { :value => url_for(:controller => 'projects', :action => 'show', :id => p, :jump => current_menu_item) }
                    end
                    s << '</select>'
                    s
                  end
                end
                def project_tree_options_for_select(projects, options = {})
                  s = ''
                  project_tree(projects) do |project, level|
                    name_prefix = (level > 0 ? ('&nbsp;' * 2 * level + '&#187; ') : '')
                    tag_options = {:value => project.id}
                    if project == options[:selected] || (options[:selected].respond_to?(:include?) && options[:selected].include?(project))
                      tag_options[:selected] = 'selected'
                    else
                      tag_options[:selected] = nil
                    end
                    tag_options.merge!(yield(project)) if block_given?
                    s << content_tag('option', name_prefix + h(project), tag_options)
                  end
                  s
                end
                # Yields the given block for each project with its level in the tree
                #
                # Wrapper for Project#project_tree
                def project_tree(projects, &block)
                  Project.project_tree(projects, &block)
                end
                def project_nested_ul(projects, &block)
                  s = ''
                  if projects.any?
                    ancestors = []
                    projects.sort_by(&:lft).each do |project|
                      if (ancestors.empty? || project.is_descendant_of?(ancestors.last))
                        s << "<ul>\n"
                      else
                        ancestors.pop
                        s << "</li>"
                        while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
                          ancestors.pop
                          s << "</ul></li>\n"
                        end
                      end
                      s << "<li>"
                      s << yield(project).to_s
                      ancestors << project
                    end
                    s << ("</li></ul>\n" * ancestors.size)
                  end
                  s
                end
                def principals_check_box_tags(name, principals)
                  s = ''
                  principals.sort.each do |principal|
                    s << "<label>#{ check_box_tag name, principal.id, false } #{h principal}</label>\n"
                  end
                  s
                end
                # Truncates and returns the string as a single line
                def truncate_single_line(string, *args)
                  truncate(string.to_s, *args).gsub(%r{[\r\n]+}m, ' ')
                end
                # Truncates at line break after 250 characters or options[:length]
                def truncate_lines(string, options={})
                  length = options[:length] || 250
                  if string.to_s =~ /\A(.{#{length}}.*?)$/m
                    "#{$1}..."
                  else
                    string
                  end
                end
                def html_hours(text)
                  text.gsub(%r{(\d+)\.(\d+)}, '<span class="hours hours-int">\1</span><span class="hours hours-dec">.\2</span>')
                end
                def authoring(created, author, options={})
                  l(options[:label] || :label_added_time_by, :author => link_to_user(author), :age => time_tag(created))
                end
                def time_tag(time)
                  text = distance_of_time_in_words(Time.now, time)
                  if @project
                    link_to(text, {:controller => 'activities', :action => 'index', :id => @project, :from => time.to_date}, :title => format_time(time))
                  else
                    content_tag('acronym', text, :title => format_time(time))
                  end
                end
                def syntax_highlight(name, content)
                  Redmine::SyntaxHighlighting.highlight_by_filename(content, name)
                end
                def to_path_param(path)
                  path.to_s.split(%r{[/\\]}).select {|p| !p.blank?}
                end
                def pagination_links_full(paginator, count=nil, options={})
                  page_param = options.delete(:page_param) || :page
                  per_page_links = options.delete(:per_page_links)
                  url_param = params.dup
                  # don't reuse query params if filters are present
                  url_param.merge!(:fields => nil, :values => nil, :operators => nil) if url_param.delete(:set_filter)
                  html = ''
                  if paginator.current.previous
                    html << link_to_remote_content_update('&#171; ' + l(:label_previous), url_param.merge(page_param => paginator.current.previous)) + ' '
                  end
                  html << (pagination_links_each(paginator, options) do |n|
                    link_to_remote_content_update(n.to_s, url_param.merge(page_param => n))
                  end || '')
                  if paginator.current.next
                    html << ' ' + link_to_remote_content_update((l(:label_next) + ' &#187;'), url_param.merge(page_param => paginator.current.next))
                  end
                  unless count.nil?
                    html << " (#{paginator.current.first_item}-#{paginator.current.last_item}/#{count})"
                    if per_page_links != false && links = per_page_links(paginator.items_per_page)
              	      html << " | #{links}"
                    end
                  end
                  html
                end
                def per_page_links(selected=nil)
                  url_param = params.dup
                  url_param.clear if url_param.has_key?(:set_filter)
                  links = Setting.per_page_options_array.collect do |n|
                    n == selected ? n : link_to_remote(n, {:update => "content",
                                                           :url => params.dup.merge(:per_page => n),
                                                           :method => :get},
                                                          {:href => url_for(url_param.merge(:per_page => n))})
                  end
                  links.size > 1 ? l(:label_display_per_page, links.join(', ')) : nil
                end
                def reorder_links(name, url)
                  link_to(image_tag('2uparrow.png',   :alt => l(:label_sort_highest)), url.merge({"#{name}[move_to]" => 'highest'}), :method => :post, :title => l(:label_sort_highest)) +
                  link_to(image_tag('1uparrow.png',   :alt => l(:label_sort_higher)),  url.merge({"#{name}[move_to]" => 'higher'}),  :method => :post, :title => l(:label_sort_higher)) +
                  link_to(image_tag('1downarrow.png', :alt => l(:label_sort_lower)),   url.merge({"#{name}[move_to]" => 'lower'}),   :method => :post, :title => l(:label_sort_lower)) +
                  link_to(image_tag('2downarrow.png', :alt => l(:label_sort_lowest)),  url.merge({"#{name}[move_to]" => 'lowest'}),  :method => :post, :title => l(:label_sort_lowest))
                end
                def breadcrumb(*args)
                  elements = args.flatten
                  elements.any? ? content_tag('p', args.join(' &#187; ') + ' &#187; ', :class => 'breadcrumb') : nil
                end
                def other_formats_links(&block)
                  concat('<p class="other-formats">' + l(:label_export_to))
                  yield Redmine::Views::OtherFormatsBuilder.new(self)
                  concat('</p>')
                end
                def page_header_title
                  if @project.nil? || @project.new_record?
                    h(Setting.app_title)
                  else
                    b = []
                    ancestors = (@project.root? ? [] : @project.ancestors.visible)
                    if ancestors.any?
                      root = ancestors.shift
                      b << link_to_project(root, {:jump => current_menu_item}, :class => 'root')
                      if ancestors.size > 2
                        b << '&#8230;'
                        ancestors = ancestors[-2, 2]
                      end
                      b += ancestors.collect {|p| link_to_project(p, {:jump => current_menu_item}, :class => 'ancestor') }
                    end
                    b << h(@project)
                    b.join(' &#187; ')
                  end
                end
                def html_title(*args)
                  if args.empty?
                    title = []
                    title << @project.name if @project
                    title += @html_title if @html_title
                    title << Setting.app_title
                    title.select {|t| !t.blank? }.join(' - ')
                  else
                    @html_title ||= []
                    @html_title += args
                  end
                end
                # Returns the theme, controller name, and action as css classes for the
                # HTML body.
                def body_css_classes
                  css = []
                  if theme = Redmine::Themes.theme(Setting.ui_theme)
                    css << 'theme-' + theme.name
                  end
                  css << 'controller-' + params[:controller]
                  css << 'action-' + params[:action]
                  css.join(' ')
                end
                def accesskey(s)
                  Redmine::AccessKeys.key_for s
                end
                # Formats text according to system settings.
                # 2 ways to call this method:
                # * with a String: textilizable(text, options)
                # * with an object and one of its attribute: textilizable(issue, :description, options)
                def textilizable(*args)
                  options = args.last.is_a?(Hash) ? args.pop : {}
                  case args.size
                  when 1
                    obj = options[:object]
                    text = args.shift
                  when 2
                    obj = args.shift
                    attr = args.shift
                    text = obj.send(attr).to_s
                  else
                    raise ArgumentError, 'invalid arguments to textilizable'
                  end
                  return '' if text.blank?
                  project = options[:project] || @project || (obj && obj.respond_to?(:project) ? obj.project : nil)
                  only_path = options.delete(:only_path) == false ? false : true
                  text = Redmine::WikiFormatting.to_html(Setting.text_formatting, text, :object => obj, :attribute => attr) { |macro, args| exec_macro(macro, obj, args) }
                  parse_non_pre_blocks(text) do |text|
                    [:parse_inline_attachments, :parse_wiki_links, :parse_redmine_links, :parse_headings].each do |method_name|
                      send method_name, text, project, obj, attr, only_path, options
                    end
                  end
                end
                def parse_non_pre_blocks(text)
                  s = StringScanner.new(text)
                  tags = []
                  parsed = ''
                  while !s.eos?
                    s.scan(/(.*?)(<(\/)?(pre|code)(.*?)>|\z)/im)
                    text, full_tag, closing, tag = s[1], s[2], s[3], s[4]
                    if tags.empty?
                      yield text
                    end
                    parsed << text
                    if tag
                      if closing
                        if tags.last == tag.downcase
                          tags.pop
                        end
                      else
                        tags << tag.downcase
                      end
                      parsed << full_tag
                    end
                  end
                  # Close any non closing tags
                  while tag = tags.pop
                    parsed << "</#{tag}>"
                  end
                  parsed
                end
                def parse_inline_attachments(text, project, obj, attr, only_path, options)
                  # when using an image link, try to use an attachment, if possible
                  if options[:attachments] || (obj && obj.respond_to?(:attachments))
                    attachments = nil
                    text.gsub!(/src="([^\/"]+\.(bmp|gif|jpg|jpeg|png))"(\s+alt="([^"]*)")?/i) do |m|
                      filename, ext, alt, alttext = $1.downcase, $2, $3, $4
                      attachments ||= (options[:attachments] || obj.attachments).sort_by(&:created_on).reverse
                      # search for the picture in attachments
                      if found = attachments.detect { |att| att.filename.downcase == filename }
                        image_url = url_for :only_path => only_path, :controller => 'attachments', :action => 'download', :id => found
                        desc = found.description.to_s.gsub('"', '')
                        if !desc.blank? && alttext.blank?
                          alt = " title=\"#{desc}\" alt=\"#{desc}\""
                        end
                        "src=\"#{image_url}\"#{alt}"
                      else
                        m
                      end
                    end
                  end
                end
                # Wiki links
                #
                # Examples:
                #   [[mypage]]
                #   [[mypage|mytext]]
                # wiki links can refer other project wikis, using project name or identifier:
                #   [[project:]] -> wiki starting page
                #   [[project:|mytext]]
                #   [[project:mypage]]
                #   [[project:mypage|mytext]]
                def parse_wiki_links(text, project, obj, attr, only_path, options)
                  text.gsub!(/(!)?(\[\[([^\]\n\|]+)(\|([^\]\n\|]+))?\]\])/) do |m|
                    link_project = project
                    esc, all, page, title = $1, $2, $3, $5
                    if esc.nil?
                      if page =~ /^([^\:]+)\:(.*)$/
                        link_project = Project.find_by_identifier($1) || Project.find_by_name($1)
                        page = $2
                        title ||= $1 if page.blank?
                      end
                      if link_project && link_project.wiki
                        # extract anchor
                        anchor = nil
                        if page =~ /^(.+?)\#(.+)$/
                          page, anchor = $1, $2
                        end
                        # check if page exists
                        wiki_page = link_project.wiki.find_page(page)
                        url = case options[:wiki_links]
                          when :local; "#{title}.html"
                          when :anchor; "##{title}"   # used for single-file wiki export
                          else
                            wiki_page_id = page.present? ? Wiki.titleize(page) : nil
                            url_for(:only_path => only_path, :controller => 'wiki', :action => 'show', :project_id => link_project, :id => wiki_page_id, :anchor => anchor)
                          end
                        link_to((title || page), url, :class => ('wiki-page' + (wiki_page ? '' : ' new')))
                      else
                        # project or wiki doesn't exist
                        all
                      end
                    else
                      all
                    end
                  end
                end
                # Redmine links
                #
                # Examples:
                #   Issues:
                #     #52 -> Link to issue #52
                #   Changesets:
                #     r52 -> Link to revision 52
                #     commit:a85130f -> Link to scmid starting with a85130f
                #   Documents:
                #     document#17 -> Link to document with id 17
                #     document:Greetings -> Link to the document with title "Greetings"
                #     document:"Some document" -> Link to the document with title "Some document"
                #   Versions:
                #     version#3 -> Link to version with id 3
                #     version:1.0.0 -> Link to version named "1.0.0"
                #     version:"1.0 beta 2" -> Link to version named "1.0 beta 2"
                #   Attachments:
                #     attachment:file.zip -> Link to the attachment of the current object named file.zip
                #   Source files:
                #     source:some/file -> Link to the file located at /some/file in the project's repository
                #     source:some/file@52 -> Link to the file's revision 52
                #     source:some/file#L120 -> Link to line 120 of the file
                #     source:some/file@52#L120 -> Link to line 120 of the file's revision 52
                #     export:some/file -> Force the download of the file
                #  Forum messages:
                #     message#1218 -> Link to message with id 1218
                def parse_redmine_links(text, project, obj, attr, only_path, options)
                  text.gsub!(%r{([\s\(,\-\[\>]|^)(!)?(attachment|document|version|commit|source|export|message|project)?((#|r)(\d+)|(:)([^"\s<>][^\s<>]*?|"[^"]+?"))(?=(?=[[:punct:]]\W)|,|\s|\]|<|$)}) do |m|
                    leading, esc, prefix, sep, identifier = $1, $2, $3, $5 || $7, $6 || $8
                    link = nil
                    if esc.nil?
                      if prefix.nil? && sep == 'r'
                        if project && (changeset = project.changesets.find_by_revision(identifier))
                          link = link_to("r#{identifier}", {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :rev => changeset.revision},
                                                    :class => 'changeset',
                                                    :title => truncate_single_line(changeset.comments, :length => 100))
                        end
                      elsif sep == '#'
                        oid = identifier.to_i
                        case prefix
                        when nil
                          if issue = Issue.visible.find_by_id(oid, :include => :status)
                            link = link_to("##{oid}", {:only_path => only_path, :controller => 'issues', :action => 'show', :id => oid},
                                                      :class => issue.css_classes,
                                                      :title => "#{truncate(issue.subject, :length => 100)} (#{issue.status.name})")
                          end
                        when 'document'
                          if document = Document.find_by_id(oid, :include => [:project], :conditions => Project.visible_by(User.current))
                            link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                                              :class => 'document'
                          end
                        when 'version'
                          if version = Version.find_by_id(oid, :include => [:project], :conditions => Project.visible_by(User.current))
                            link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                            :class => 'version'
                          end
                        when 'message'
                          if message = Message.find_by_id(oid, :include => [:parent, {:board => :project}], :conditions => Project.visible_by(User.current))
                            link = link_to h(truncate(message.subject, :length => 60)), {:only_path => only_path,
                                                                              :controller => 'messages',
                                                                              :action => 'show',
                                                                              :board_id => message.board,
                                                                              :id => message.root,
                                                                              :anchor => (message.parent ? "message-#{message.id}" : nil)},
                                                               :class => 'message'
                          end
                        when 'project'
                          if p = Project.visible.find_by_id(oid)
                            link = link_to_project(p, {:only_path => only_path}, :class => 'project')
                          end
                        end
                      elsif sep == ':'
                        # removes the double quotes if any
                        name = identifier.gsub(%r{^"(.*)"$}, "\\1")
                        case prefix
                        when 'document'
                          if project && document = project.documents.find_by_title(name)
                            link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                                              :class => 'document'
                          end
                        when 'version'
                          if project && version = project.versions.find_by_name(name)
                            link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                            :class => 'version'
                          end
                        when 'commit'
                          if project && (changeset = project.changesets.find(:first, :conditions => ["scmid LIKE ?", "#{name}%"]))
                            link = link_to h("#{name}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :rev => changeset.revision},
                                                         :class => 'changeset',
                                                         :title => truncate_single_line(changeset.comments, :length => 100)
                          end
                        when 'source', 'export'
                          if project && project.repository
                            name =~ %r{^[/\\]*(.*?)(@([0-9a-f]+))?(#(L\d+))?$}
                            path, rev, anchor = $1, $3, $5
                            link = link_to h("#{prefix}:#{name}"), {:controller => 'repositories', :action => 'entry', :id => project,
                                                                    :path => to_path_param(path),
                                                                    :rev => rev,
                                                                    :anchor => anchor,
                                                                    :format => (prefix == 'export' ? 'raw' : nil)},
                                                                   :class => (prefix == 'export' ? 'source download' : 'source')
                          end
                        when 'attachment'
                          attachments = options[:attachments] || (obj && obj.respond_to?(:attachments) ? obj.attachments : nil)
                          if attachments && attachment = attachments.detect {|a| a.filename == name }
                            link = link_to h(attachment.filename), {:only_path => only_path, :controller => 'attachments', :action => 'download', :id => attachment},
                                                                   :class => 'attachment'
                          end
                        when 'project'
                          if p = Project.visible.find(:first, :conditions => ["identifier = :s OR LOWER(name) = :s", {:s => name.downcase}])
                            link = link_to_project(p, {:only_path => only_path}, :class => 'project')
                          end
                        end
                      end
                    end
                    leading + (link || "#{prefix}#{sep}#{identifier}")
                  end
                end
                TOC_RE = /<p>\{\{([<>]?)toc\}\}<\/p>/i unless const_defined?(:TOC_RE)
                HEADING_RE = /<h(1|2|3|4)( [^>]+)?>(.+?)<\/h(1|2|3|4)>/i unless const_defined?(:HEADING_RE)
                # Headings and TOC
                # Adds ids and links to headings and renders the TOC if needed unless options[:headings] is set to false
                def parse_headings(text, project, obj, attr, only_path, options)
                  headings = []
                  text.gsub!(HEADING_RE) do
                    level, attrs, content = $1.to_i, $2, $3
                    item = strip_tags(content).strip
                    anchor = item.gsub(%r{[^\w\s\-]}, '').gsub(%r{\s+(\-+\s*)?}, '-')
                    headings << [level, anchor, item]
                    "<h#{level} #{attrs} id=\"#{anchor}\">#{content}<a href=\"##{anchor}\" class=\"wiki-anchor\">&para;</a></h#{level}>"
                  end unless options[:headings] == false
                  text.gsub!(TOC_RE) do
                    if headings.empty?
                      ''
                    else
                      div_class = 'toc'
                      div_class << ' right' if $1 == '>'
                      div_class << ' left' if $1 == '<'
                      out = "<ul class=\"#{div_class}\"><li>"
                      root = headings.map(&:first).min
                      current = root
                      started = false
                      headings.each do |level, anchor, item|
                        if level > current
                          out << '<ul><li>' * (level - current)
                        elsif level < current
                          out << "</li></ul>\n" * (current - level) + "</li><li>"
                        elsif started
                          out << '</li><li>'
                        end
                        out << "<a href=\"##{anchor}\">#{item}</a>"
                        current = level
                        started = true
                      end
                      out << '</li></ul>' * (current - root)
                      out << '</li></ul>'
                    end
                  end
                end
                # Same as Rails' simple_format helper without using paragraphs
                def simple_format_without_paragraph(text)
                  text.to_s.
                    gsub(/\r\n?/, "\n").                    # \r\n and \r -> \n
                    gsub(/\n\n+/, "<br /><br />").          # 2+ newline  -> 2 br
                    gsub(/([^\n]\n)(?=[^\n])/, '\1<br />')  # 1 newline   -> br
                end
                def lang_options_for_select(blank=true)
                  (blank ? [["(auto)", ""]] : []) +
                    valid_languages.collect{|lang| [ ll(lang.to_s, :general_lang_name), lang.to_s]}.sort{|x,y| x.last <=> y.last }
                end
                def label_tag_for(name, option_tags = nil, options = {})
                  label_text = l(("field_"+field.to_s.gsub(/\_id$/, "")).to_sym) + (options.delete(:required) ? @template.content_tag("span", " *", :class => "required"): "")
                  content_tag("label", label_text)
                end
                def labelled_tabular_form_for(name, object, options, &proc)
                  options[:html] ||= {}
                  options[:html][:class] = 'tabular' unless options[:html].has_key?(:class)
                  form_for(name, object, options.merge({ :builder => TabularFormBuilder, :lang => current_language}), &proc)
                end
                def back_url_hidden_field_tag
                  back_url = params[:back_url] || request.env['HTTP_REFERER']
                  back_url = CGI.unescape(back_url.to_s)
                  hidden_field_tag('back_url', CGI.escape(back_url)) unless back_url.blank?
                end
                def check_all_links(form_name)
                  link_to_function(l(:button_check_all), "checkAll('#{form_name}', true)") +
                  " | " +
                  link_to_function(l(:button_uncheck_all), "checkAll('#{form_name}', false)")
                end
                def progress_bar(pcts, options={})
                  pcts = [pcts, pcts] unless pcts.is_a?(Array)
                  pcts = pcts.collect(&:round)
                  pcts[1] = pcts[1] - pcts[0]
                  pcts << (100 - pcts[1] - pcts[0])
                  width = options[:width] || '100px;'
                  legend = options[:legend] || ''
                  content_tag('table',
                    content_tag('tr',
                      (pcts[0] > 0 ? content_tag('td', '', :style => "width: #{pcts[0]}%;", :class => 'closed') : '') +
                      (pcts[1] > 0 ? content_tag('td', '', :style => "width: #{pcts[1]}%;", :class => 'done') : '') +
                      (pcts[2] > 0 ? content_tag('td', '', :style => "width: #{pcts[2]}%;", :class => 'todo') : '')
                    ), :class => 'progress', :style => "width: #{width};") +
                    content_tag('p', legend, :class => 'pourcent')
                end
                def checked_image(checked=true)
                  if checked
                    image_tag 'toggle_check.png'
                  end
                end
                def context_menu(url)
                  unless @context_menu_included
                    content_for :header_tags do
                      javascript_include_tag('context_menu') +
                        stylesheet_link_tag('context_menu')
                    end
                    if l(:direction) == 'rtl'
                      content_for :header_tags do
                        stylesheet_link_tag('context_menu_rtl')
                      end
                    end
                    @context_menu_included = true
                  end
                  javascript_tag "new ContextMenu('#{ url_for(url) }')"
                end
                def context_menu_link(name, url, options={})
                  options[:class] ||= ''
                  if options.delete(:selected)
                    options[:class] << ' icon-checked disabled'
                    options[:disabled] = true
                  end
                  if options.delete(:disabled)
                    options.delete(:method)
                    options.delete(:confirm)
                    options.delete(:onclick)
                    options[:class] << ' disabled'
                    url = '#'
                  end
                  link_to name, url, options
                end
                def calendar_for(field_id)
                  include_calendar_headers_tags
                  image_tag("calendar.png", {:id => "#{field_id}_trigger",:class => "calendar-trigger"}) +
                  javascript_tag("Calendar.setup({inputField : '#{field_id}', ifFormat : '%Y-%m-%d', button : '#{field_id}_trigger' });")
                end
                def include_calendar_headers_tags
                  unless @calendar_headers_tags_included
                    @calendar_headers_tags_included = true
                    content_for :header_tags do
                      start_of_week = case Setting.start_of_week.to_i
                      when 1
                        'Calendar._FD = 1;' # Monday
                      when 7
                        'Calendar._FD = 0;' # Sunday
                      else
                        '' # use language
                      end
                      javascript_include_tag('calendar/calendar') +
                      javascript_include_tag("calendar/lang/calendar-#{current_language.to_s.downcase}.js") +
                      javascript_tag(start_of_week) +
                      javascript_include_tag('calendar/calendar-setup') +
                      stylesheet_link_tag('calendar')
                    end
                  end
                end
                def content_for(name, content = nil, &block)
                  @has_content ||= {}
                  @has_content[name] = true
                  super(name, content, &block)
                end
                def has_content?(name)
                  (@has_content && @has_content[name]) || false
                end
                # Returns the avatar image tag for the given +user+ if avatars are enabled
                # +user+ can be a User or a string that will be scanned for an email address (eg. 'joe <joe@foo.bar>')
                def avatar(user, options = { })
                  if Setting.gravatar_enabled?
                    options.merge!({:ssl => (defined?(request) && request.ssl?), :default => Setting.gravatar_default})
                    email = nil
                    if user.respond_to?(:mail)
                      email = user.mail
                    elsif user.to_s =~ %r{<(.+?)>}
                      email = $1
                    end
                    return gravatar(email.to_s.downcase, options) unless email.blank? rescue nil
                  else
                    ''
                  end
                end
                def favicon
                  "<link rel='shortcut icon' href='#{image_path('/favicon.ico')}' />"
                end
                # Returns true if arg is expected in the API response
                def include_in_api_response?(arg)
                  unless @included_in_api_response
                    param = params[:include]
                    @included_in_api_response = param.is_a?(Array) ? param.collect(&:to_s) : param.to_s.split(',')
                    @included_in_api_response.collect!(&:strip)
                  end
                  @included_in_api_response.include?(arg.to_s)
                end
+               # Returns options or nil if nometa param or X-Redmine-Nometa header
+               # was set in the request
+               def api_meta(options)
+                 if params[:nometa].present? || request.headers['X-Redmine-Nometa']
+                   # compatibility mode for activeresource clients that raise
+                   # an error when unserializing an array with attributes
+                   nil
+                 else
+                   options
+                 end
+               end
                private
                def wiki_helper
                  helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)
                  extend helper
                  return self
                end
                def link_to_remote_content_update(text, url_params)
                  link_to_remote(text,
                    {:url => url_params, :method => :get, :update => 'content', :complete => 'window.scrollTo(0,0)'},
                    {:href => url_for(:params => url_params)}
                  )
                end
              end

app/views/issues/index.api.rsb +1 -1

-             api.array :issues do
+             api.array :issues, api_meta(:total_count => @issue_count, :offset => @offset, :limit => @limit) do
                @issues.each do |issue|
                  api.issue do
                    api.id issue.id
                    api.project(:id => issue.project_id, :name => issue.project.name) unless issue.project.nil?
                    api.tracker(:id => issue.tracker_id, :name => issue.tracker.name) unless issue.tracker.nil?
                    api.status(:id => issue.status_id, :name => issue.status.name) unless issue.status.nil?
                    api.priority(:id => issue.priority_id, :name => issue.priority.name) unless issue.priority.nil?
                    api.author(:id => issue.author_id, :name => issue.author.name) unless issue.author.nil?
                    api.assigned_to(:id => issue.assigned_to_id, :name => issue.assigned_to.name) unless issue.assigned_to.nil?
                    api.category(:id => issue.category_id, :name => issue.category.name) unless issue.category.nil?
                    api.fixed_version(:id => issue.fixed_version_id, :name => issue.fixed_version.name) unless issue.fixed_version.nil?
                    api.parent(:id => issue.parent_id) unless issue.parent.nil?
                    api.subject 		issue.subject
                    api.description issue.description
                    api.start_date 	issue.start_date
                    api.due_date 		issue.due_date
                    api.done_ratio 	issue.done_ratio
                    api.estimated_hours issue.estimated_hours
                    render_api_custom_values issue.custom_field_values, api
                    api.created_on issue.created_on
                    api.updated_on issue.updated_on
                  end
                end
              end

app/views/users/index.api.rsb +1 -1

-             api.array :users do
+             api.array :users, api_meta(:total_count => @user_count, :offset => @offset, :limit => @limit) do
                @users.each do |user|
                  api.user do
                    api.id         user.id
                    api.login      user.login
                    api.firstname  user.firstname
                    api.lastname   user.lastname
                    api.mail       user.mail
                    api.created_on user.created_on
                    api.last_login_on user.last_login_on
                    render_api_custom_values user.visible_custom_field_values, api
                  end
                end
              end

lib/redmine/views/builders/structure.rb +2 -1

              # Redmine - project management software
              # Copyright (C) 2006-2010  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require 'blankslate'
              module Redmine
                module Views
                  module Builders
                    class Structure < BlankSlate
                      def initialize
                        @struct = [{}]
                      end
-                     def array(tag, &block)
+                     def array(tag, options={}, &block)
                        @struct << []
                        block.call(self)
                        ret = @struct.pop
                        @struct.last[tag] = ret
+                       @struct.last.merge!(options) if options
                      end
                      def method_missing(sym, *args, &block)
                        if args.any?
                          if args.first.is_a?(Hash)
                            if @struct.last.is_a?(Array)
                              @struct.last << args.first unless block
                            else
                              @struct.last[sym] = args.first
                            end
                          else
                            if @struct.last.is_a?(Array)
                              @struct.last << (args.last || {}).merge(:value => args.first)
                            else
                              @struct.last[sym] = args.first
                            end
                          end
                        end
                        if block
                          @struct << (args.first.is_a?(Hash) ? args.first : {})
                          block.call(self)
                          ret = @struct.pop
                          if @struct.last.is_a?(Array)
                            @struct.last << ret
                          else
                            if @struct.last.has_key?(sym) && @struct.last[sym].is_a?(Hash)
                              @struct.last[sym].merge! ret
                            else
                              @struct.last[sym] = ret
                            end
                          end
                        end
                      end
                      def output
                        raise "Need to implement #{self.class.name}#output"
                      end
                    end
                  end
                end
              end

lib/redmine/views/builders/xml.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2010  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              module Redmine
                module Views
                  module Builders
                    class Xml < ::Builder::XmlMarkup
                      def initialize
                        super
                        instruct!
                      end
                      def output
                        target!
                      end
                      def method_missing(sym, *args, &block)
                        if args.size == 1 && args.first.is_a?(Time)
                          __send__ sym, args.first.xmlschema, &block
                        else
                          super
                        end
                      end
                      def array(name, options={}, &block)
-                       __send__ name, options.merge(:type => 'array'), &block
+                       __send__ name, (options || {}).merge(:type => 'array'), &block
                      end
                    end
                  end
                end
              end

test/integration/api_test/issues_test.rb +51 -1

              # Redmine - project management software
              # Copyright (C) 2006-2010  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require "#{File.dirname(__FILE__)}/../../test_helper"
              class ApiTest::IssuesTest < ActionController::IntegrationTest
                fixtures :projects,
                  :users,
                  :roles,
                  :members,
                  :member_roles,
                  :issues,
                  :issue_statuses,
                  :versions,
                  :trackers,
                  :projects_trackers,
                  :issue_categories,
                  :enabled_modules,
                  :enumerations,
                  :attachments,
                  :workflows,
                  :custom_fields,
                  :custom_values,
                  :custom_fields_projects,
                  :custom_fields_trackers,
                  :time_entries,
                  :journals,
                  :journal_details,
                  :queries
                def setup
                  Setting.rest_api_enabled = '1'
                end
+               context "/index.xml" do
                # Use a private project to make sure auth is really working and not just
                # only showing public issues.
-               context "/index.xml" do
                  should_allow_api_authentication(:get, "/projects/private-child/issues.xml")
+                 should "contain metadata" do
+                   get '/issues.xml'
+                   assert_tag :tag => 'issues',
+                     :attributes => {
+                       :type => 'array',
+                       :total_count => assigns(:issue_count),
+                       :limit => 25,
+                       :offset => 0
+                     }
+                 end
+                 context "with offset and limit" do
+                   should "use the params" do
+                     get '/issues.xml?offset=2&limit=3'
+                     assert_equal 3, assigns(:limit)
+                     assert_equal 2, assigns(:offset)
+                     assert_tag :tag => 'issues', :children => {:count => 3, :only => {:tag => 'issue'}}
+                   end
+                 end
+                 context "with nometa param" do
+                   should "not contain metadata" do
+                     get '/issues.xml?nometa=1'
+                     assert_tag :tag => 'issues',
+                       :attributes => {
+                         :type => 'array',
+                         :total_count => nil,
+                         :limit => nil,
+                         :offset => nil
+                       }
+                   end
+                 end
+                 context "with nometa header" do
+                   should "not contain metadata" do
+                     get '/issues.xml', {}, {'X-Redmine-Nometa' => '1'}
+                     assert_tag :tag => 'issues',
+                       :attributes => {
+                         :type => 'array',
+                         :total_count => nil,
+                         :limit => nil,
+                         :offset => nil
+                       }
+                   end
+                 end
                end
                context "/index.json" do
                  should_allow_api_authentication(:get, "/projects/private-child/issues.json")
                end
                context "/index.xml with filter" do
                  should_allow_api_authentication(:get, "/projects/private-child/issues.xml?status_id=5")
                  should "show only issues with the status_id" do
                    get '/issues.xml?status_id=5'
                    assert_tag :tag => 'issues',
                               :children => { :count => Issue.visible.count(:conditions => {:status_id => 5}),
                                              :only => { :tag => 'issue' } }
                  end
                end
                context "/index.json with filter" do
                  should_allow_api_authentication(:get, "/projects/private-child/issues.json?status_id=5")
                  should "show only issues with the status_id" do
                    get '/issues.json?status_id=5'
                    json = ActiveSupport::JSON.decode(response.body)
                    status_ids_used = json['issues'].collect {|j| j['status']['id'] }
                    assert_equal 3, status_ids_used.length
                    assert status_ids_used.all? {|id| id == 5 }
                  end
                end
                # Issue 6 is on a private project
                context "/issues/6.xml" do
                  should_allow_api_authentication(:get, "/issues/6.xml")
                end
                context "/issues/6.json" do
                  should_allow_api_authentication(:get, "/issues/6.json")
                end
                context "GET /issues/:id" do
                  context "with journals" do
                    context ".xml" do
                      should "display journals" do
                        get '/issues/1.xml?include=journals'
                        assert_tag :tag => 'issue',
                          :child => {
                            :tag => 'journals',
                            :attributes => { :type => 'array' },
                            :child => {
                              :tag => 'journal',
                              :attributes => { :id => '1'},
                              :child => {
                                :tag => 'details',
                                :attributes => { :type => 'array' },
                                :child => {
                                  :tag => 'detail',
                                  :attributes => { :name => 'status_id' },
                                  :child => {
                                    :tag => 'old_value',
                                    :content => '1',
                                    :sibling => {
                                      :tag => 'new_value',
                                      :content => '2'
                                    }
                                  }
                                }
                              }
                            }
                          }
                      end
                    end
                  end
                  context "with custom fields" do
                    context ".xml" do
                      should "display custom fields" do
                        get '/issues/3.xml'
                        assert_tag :tag => 'issue',
                          :child => {
                            :tag => 'custom_fields',
                            :attributes => { :type => 'array' },
                            :child => {
                              :tag => 'custom_field',
                              :attributes => { :id => '1'},
                              :child => {
                                :tag => 'value',
                                :content => 'MySQL'
                              }
                            }
                          }
                        assert_nothing_raised do
                          Hash.from_xml(response.body).to_xml
                        end
                      end
                    end
                  end
                  context "with subtasks" do
                    setup do
                      @c1 = Issue.generate!(:status_id => 1, :subject => "child c1", :tracker_id => 1, :project_id => 1, :parent_issue_id => 1)
                      @c2 = Issue.generate!(:status_id => 1, :subject => "child c2", :tracker_id => 1, :project_id => 1, :parent_issue_id => 1)
                      @c3 = Issue.generate!(:status_id => 1, :subject => "child c3", :tracker_id => 1, :project_id => 1, :parent_issue_id => @c1.id)
                    end
                    context ".xml" do
                      should "display children" do
                        get '/issues/1.xml?include=children'
                        assert_tag :tag => 'issue',
                          :child => {
                            :tag => 'children',
                            :children => {:count => 2},
                            :child => {
                              :tag => 'issue',
                              :attributes => {:id => @c1.id.to_s},
                              :child => {
                                :tag => 'subject',
                                :content => 'child c1',
                                :sibling => {
                                  :tag => 'children',
                                  :children => {:count => 1},
                                  :child => {
                                    :tag => 'issue',
                                    :attributes => {:id => @c3.id.to_s}
                                  }
                                }
                              }
                            }
                          }
                      end
                      context ".json" do
                        should "display children" do
                          get '/issues/1.json?include=children'
                          json = ActiveSupport::JSON.decode(response.body)
                          assert_equal([
                            {
                              'id' => @c1.id, 'subject' => 'child c1', 'tracker' => {'id' => 1, 'name' => 'Bug'},
                              'children' => [{ 'id' => @c3.id, 'subject' => 'child c3', 'tracker' => {'id' => 1, 'name' => 'Bug'} }]
                            },
                            { 'id' => @c2.id, 'subject' => 'child c2', 'tracker' => {'id' => 1, 'name' => 'Bug'} }
                            ],
                            json['issue']['children'])
                        end
                      end
                    end
                  end
                end
                context "POST /issues.xml" do
                  should_allow_api_authentication(:post,
                                                  '/issues.xml',
                                                  {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}},
                                                  {:success_code => :created})
                  should "create an issue with the attributes" do
                    assert_difference('Issue.count') do
                      post '/issues.xml', {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}}, :authorization => credentials('jsmith')
                    end
                    issue = Issue.first(:order => 'id DESC')
                    assert_equal 1, issue.project_id
                    assert_equal 2, issue.tracker_id
                    assert_equal 3, issue.status_id
                    assert_equal 'API test', issue.subject
                    assert_response :created
                    assert_equal 'application/xml', @response.content_type
                    assert_tag 'issue', :child => {:tag => 'id', :content => issue.id.to_s}
                  end
                end
                context "POST /issues.xml with failure" do
                  should_allow_api_authentication(:post,
                                                  '/issues.xml',
                                                  {:issue => {:project_id => 1}},
                                                  {:success_code => :unprocessable_entity})
                  should "have an errors tag" do
                    assert_no_difference('Issue.count') do
                      post '/issues.xml', {:issue => {:project_id => 1}}, :authorization => credentials('jsmith')
                    end
                    assert_tag :errors, :child => {:tag => 'error', :content => "Subject can't be blank"}
                  end
                end
                context "POST /issues.json" do
                  should_allow_api_authentication(:post,
                                                  '/issues.json',
                                                  {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}},
                                                  {:success_code => :created})
                  should "create an issue with the attributes" do
                    assert_difference('Issue.count') do
                      post '/issues.json', {:issue => {:project_id => 1, :subject => 'API test', :tracker_id => 2, :status_id => 3}}, :authorization => credentials('jsmith')
                    end
                    issue = Issue.first(:order => 'id DESC')
                    assert_equal 1, issue.project_id
                    assert_equal 2, issue.tracker_id
                    assert_equal 3, issue.status_id
                    assert_equal 'API test', issue.subject
                  end
                end
                context "POST /issues.json with failure" do
                  should_allow_api_authentication(:post,
                                                  '/issues.json',
                                                  {:issue => {:project_id => 1}},
                                                  {:success_code => :unprocessable_entity})
                  should "have an errors element" do
                    assert_no_difference('Issue.count') do
                      post '/issues.json', {:issue => {:project_id => 1}}, :authorization => credentials('jsmith')
                    end
                    json = ActiveSupport::JSON.decode(response.body)
                    assert json['errors'].include?(['subject', "can't be blank"])
                  end
                end
                # Issue 6 is on a private project
                context "PUT /issues/6.xml" do
                  setup do
                    @parameters = {:issue => {:subject => 'API update', :notes => 'A new note'}}
                    @headers = { :authorization => credentials('jsmith') }
                  end
                  should_allow_api_authentication(:put,
                                                  '/issues/6.xml',
                                                  {:issue => {:subject => 'API update', :notes => 'A new note'}},
                                                  {:success_code => :ok})
                  should "not create a new issue" do
                    assert_no_difference('Issue.count') do
                      put '/issues/6.xml', @parameters, @headers
                    end
                  end
                  should "create a new journal" do
                    assert_difference('Journal.count') do
                      put '/issues/6.xml', @parameters, @headers
                    end
                  end
                  should "add the note to the journal" do
                    put '/issues/6.xml', @parameters, @headers
                    journal = Journal.last
                    assert_equal "A new note", journal.notes
                  end
                  should "update the issue" do
                    put '/issues/6.xml', @parameters, @headers
                    issue = Issue.find(6)
                    assert_equal "API update", issue.subject
                  end
                end
                context "PUT /issues/3.xml with custom fields" do
                  setup do
                    @parameters = {:issue => {:custom_fields => [{'id' => '1', 'value' => 'PostgreSQL' }, {'id' => '2', 'value' => '150'}]}}
                    @headers = { :authorization => credentials('jsmith') }
                  end
                  should "update custom fields" do
                    assert_no_difference('Issue.count') do
                      put '/issues/3.xml', @parameters, @headers
                    end
                    issue = Issue.find(3)
                    assert_equal '150', issue.custom_value_for(2).value
                    assert_equal 'PostgreSQL', issue.custom_value_for(1).value
                  end
                end
                context "PUT /issues/6.xml with failed update" do
                  setup do
                    @parameters = {:issue => {:subject => ''}}
                    @headers = { :authorization => credentials('jsmith') }
                  end
                  should_allow_api_authentication(:put,
                                                  '/issues/6.xml',
                                                  {:issue => {:subject => ''}}, # Missing subject should fail
                                                  {:success_code => :unprocessable_entity})
                  should "not create a new issue" do
                    assert_no_difference('Issue.count') do
                      put '/issues/6.xml', @parameters, @headers
                    end
                  end
                  should "not create a new journal" do
                    assert_no_difference('Journal.count') do
                      put '/issues/6.xml', @parameters, @headers
                    end
                  end
                  should "have an errors tag" do
                    put '/issues/6.xml', @parameters, @headers
                    assert_tag :errors, :child => {:tag => 'error', :content => "Subject can't be blank"}
                  end
                end
                context "PUT /issues/6.json" do
                  setup do
                    @parameters = {:issue => {:subject => 'API update', :notes => 'A new note'}}
                    @headers = { :authorization => credentials('jsmith') }
                  end
                  should_allow_api_authentication(:put,
                                                  '/issues/6.json',
                                                  {:issue => {:subject => 'API update', :notes => 'A new note'}},
                                                  {:success_code => :ok})
                  should "not create a new issue" do
                    assert_no_difference('Issue.count') do
                      put '/issues/6.json', @parameters, @headers
                    end
                  end
                  should "create a new journal" do
                    assert_difference('Journal.count') do
                      put '/issues/6.json', @parameters, @headers
                    end
                  end
                  should "add the note to the journal" do
                    put '/issues/6.json', @parameters, @headers
                    journal = Journal.last
                    assert_equal "A new note", journal.notes
                  end
                  should "update the issue" do
                    put '/issues/6.json', @parameters, @headers
                    issue = Issue.find(6)
                    assert_equal "API update", issue.subject
                  end
                end
                context "PUT /issues/6.json with failed update" do
                  setup do
                    @parameters = {:issue => {:subject => ''}}
                    @headers = { :authorization => credentials('jsmith') }
                  end
                  should_allow_api_authentication(:put,
                                                  '/issues/6.json',
                                                  {:issue => {:subject => ''}}, # Missing subject should fail
                                                  {:success_code => :unprocessable_entity})
                  should "not create a new issue" do
                    assert_no_difference('Issue.count') do
                      put '/issues/6.json', @parameters, @headers
                    end
                  end
                  should "not create a new journal" do
                    assert_no_difference('Journal.count') do
                      put '/issues/6.json', @parameters, @headers
                    end
                  end
                  should "have an errors attribute" do
                    put '/issues/6.json', @parameters, @headers
                    json = ActiveSupport::JSON.decode(response.body)
                    assert json['errors'].include?(['subject', "can't be blank"])
                  end
                end
                context "DELETE /issues/1.xml" do
                  should_allow_api_authentication(:delete,
                                                  '/issues/6.xml',
                                                  {},
                                                  {:success_code => :ok})
                  should "delete the issue" do
                    assert_difference('Issue.count',-1) do
                      delete '/issues/6.xml', {}, :authorization => credentials('jsmith')
                    end
                    assert_nil Issue.find_by_id(6)
                  end
                end
                context "DELETE /issues/1.json" do
                  should_allow_api_authentication(:delete,
                                                  '/issues/6.json',
                                                  {},
                                                  {:success_code => :ok})
                  should "delete the issue" do
                    assert_difference('Issue.count',-1) do
                      delete '/issues/6.json', {}, :authorization => credentials('jsmith')
                    end
                    assert_nil Issue.find_by_id(6)
                  end
                end
                def credentials(user, password=nil)
                  ActionController::HttpAuthentication::Basic.encode_credentials(user, password || user)
                end
              end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages