jro_apps/redmine Commit - r15305:cad0036297bd

Use head instead of render :nothing => true....

Jean-Philippe Lang -

r15305:cad0036297bd

parent child

Context file:

r15305:cad0036297bd

Collapse all files

app/controllers/attachments_controller.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 AttachmentsController < ApplicationController
                before_action :find_attachment, :only => [:show, :download, :thumbnail, :destroy]
                before_action :find_editable_attachments, :only => [:edit, :update]
                before_action :file_readable, :read_authorize, :only => [:show, :download, :thumbnail]
                before_action :delete_authorize, :only => :destroy
                before_action :authorize_global, :only => :upload
                accept_api_auth :show, :download, :thumbnail, :upload, :destroy
                def show
                  respond_to do |format|
                    format.html {
                      if @attachment.is_diff?
                        @diff = File.read(@attachment.diskfile, :mode => "rb")
                        @diff_type = params[:type] || User.current.pref[:diff_type] || 'inline'
                        @diff_type = 'inline' unless %w(inline sbs).include?(@diff_type)
                        # Save diff type as user preference
                        if User.current.logged? && @diff_type != User.current.pref[:diff_type]
                          User.current.pref[:diff_type] = @diff_type
                          User.current.preference.save
                        end
                        render :action => 'diff'
                      elsif @attachment.is_text? && @attachment.filesize <= Setting.file_max_size_displayed.to_i.kilobyte
                        @content = File.read(@attachment.diskfile, :mode => "rb")
                        render :action => 'file'
                      elsif @attachment.is_image?
                        render :action => 'image'
                      else
                        render :action => 'other'
                      end
                    }
                    format.api
                  end
                end
                def download
                  if @attachment.container.is_a?(Version) || @attachment.container.is_a?(Project)
                    @attachment.increment_download
                  end
                  if stale?(:etag => @attachment.digest)
                    # images are sent inline
                    send_file @attachment.diskfile, :filename => filename_for_content_disposition(@attachment.filename),
                                                    :type => detect_content_type(@attachment),
                                                    :disposition => disposition(@attachment)
                  end
                end
                def thumbnail
                  if @attachment.thumbnailable? && tbnail = @attachment.thumbnail(:size => params[:size])
                    if stale?(:etag => tbnail)
                      send_file tbnail,
                        :filename => filename_for_content_disposition(@attachment.filename),
                        :type => detect_content_type(@attachment),
                        :disposition => 'inline'
                    end
                  else
                    # No thumbnail for the attachment or thumbnail could not be created
-                   render :nothing => true, :status => 404
+                   head 404
                  end
                end
                def upload
                  # Make sure that API users get used to set this content type
                  # as it won't trigger Rails' automatic parsing of the request body for parameters
                  unless request.content_type == 'application/octet-stream'
-                   render :nothing => true, :status => 406
+                   head 406
                    return
                  end
                  @attachment = Attachment.new(:file => request.raw_post)
                  @attachment.author = User.current
                  @attachment.filename = params[:filename].presence || Redmine::Utils.random_hex(16)
                  @attachment.content_type = params[:content_type].presence
                  saved = @attachment.save
                  respond_to do |format|
                    format.js
                    format.api {
                      if saved
                        render :action => 'upload', :status => :created
                      else
                        render_validation_errors(@attachment)
                      end
                    }
                  end
                end
                def edit
                end
                def update
                  if params[:attachments].is_a?(Hash)
                    if Attachment.update_attachments(@attachments, params[:attachments])
                      redirect_back_or_default home_path
                      return
                    end
                  end
                  render :action => 'edit'
                end
                def destroy
                  if @attachment.container.respond_to?(:init_journal)
                    @attachment.container.init_journal(User.current)
                  end
                  if @attachment.container
                    # Make sure association callbacks are called
                    @attachment.container.attachments.delete(@attachment)
                  else
                    @attachment.destroy
                  end
                  respond_to do |format|
                    format.html { redirect_to_referer_or project_path(@project) }
                    format.js
                    format.api { render_api_ok }
                  end
                end
                private
                def find_attachment
                  @attachment = Attachment.find(params[:id])
                  # Show 404 if the filename in the url is wrong
                  raise ActiveRecord::RecordNotFound if params[:filename] && params[:filename] != @attachment.filename
                  @project = @attachment.project
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def find_editable_attachments
                  klass = params[:object_type].to_s.singularize.classify.constantize rescue nil
                  unless klass && klass.reflect_on_association(:attachments)
                    render_404
                    return
                  end
                  @container = klass.find(params[:object_id])
                  if @container.respond_to?(:visible?) && !@container.visible?
                    render_403
                    return
                  end
                  @attachments = @container.attachments.select(&:editable?)
                  if @container.respond_to?(:project)
                    @project = @container.project
                  end
                  render_404 if @attachments.empty?
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                # Checks that the file exists and is readable
                def file_readable
                  if @attachment.readable?
                    true
                  else
                    logger.error "Cannot send attachment, #{@attachment.diskfile} does not exist or is unreadable."
                    render_404
                  end
                end
                def read_authorize
                  @attachment.visible? ? true : deny_access
                end
                def delete_authorize
                  @attachment.deletable? ? true : deny_access
                end
                def detect_content_type(attachment)
                  content_type = attachment.content_type
                  if content_type.blank? || content_type == "application/octet-stream"
                    content_type = Redmine::MimeType.of(attachment.filename)
                  end
                  content_type.to_s
                end
                def disposition(attachment)
                  if attachment.is_image? || attachment.is_pdf?
                    'inline'
                  else
                    'attachment'
                  end
                end
              end

app/controllers/boards_controller.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 BoardsController < ApplicationController
                default_search_scope :messages
                before_action :find_project_by_project_id, :find_board_if_available, :authorize
                accept_rss_auth :index, :show
                helper :sort
                include SortHelper
                helper :watchers
                def index
                  @boards = @project.boards.preload(:project, :last_message => :author).to_a
                  # show the board if there is only one
                  if @boards.size == 1
                    @board = @boards.first
                    show
                  end
                end
                def show
                  respond_to do |format|
                    format.html {
                      sort_init 'updated_on', 'desc'
                      sort_update 'created_on' => "#{Message.table_name}.id",
                                  'replies' => "#{Message.table_name}.replies_count",
                                  'updated_on' => "COALESCE(#{Message.table_name}.last_reply_id, #{Message.table_name}.id)"
                      @topic_count = @board.topics.count
                      @topic_pages = Paginator.new @topic_count, per_page_option, params['page']
                      @topics =  @board.topics.
                        reorder(:sticky => :desc).
                        limit(@topic_pages.per_page).
                        offset(@topic_pages.offset).
                        order(sort_clause).
                        preload(:author, {:last_reply => :author}).
                        to_a
                      @message = Message.new(:board => @board)
                      render :action => 'show', :layout => !request.xhr?
                    }
                    format.atom {
                      @messages = @board.messages.
                        reorder(:id => :desc).
                        includes(:author, :board).
                        limit(Setting.feeds_limit.to_i).
                        to_a
                      render_feed(@messages, :title => "#{@project}: #{@board}")
                    }
                  end
                end
                def new
                  @board = @project.boards.build
                  @board.safe_attributes = params[:board]
                end
                def create
                  @board = @project.boards.build
                  @board.safe_attributes = params[:board]
                  if @board.save
                    flash[:notice] = l(:notice_successful_create)
                    redirect_to_settings_in_projects
                  else
                    render :action => 'new'
                  end
                end
                def edit
                end
                def update
                  @board.safe_attributes = params[:board]
                  if @board.save
                    respond_to do |format|
                      format.html {
                        flash[:notice] = l(:notice_successful_update)
                        redirect_to_settings_in_projects
                      }
-                     format.js { render :nothing => true }
+                     format.js { head 200 }
                    end
                  else
                    respond_to do |format|
                      format.html { render :action => 'edit' }
-                     format.js { render :nothing => true, :status => 422 }
+                     format.js { head 422 }
                    end
                  end
                end
                def destroy
                  @board.destroy
                  redirect_to_settings_in_projects
                end
              private
                def redirect_to_settings_in_projects
                  redirect_to settings_project_path(@project, :tab => 'boards')
                end
                def find_board_if_available
                  @board = @project.boards.find(params[:id]) if params[:id]
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
              end

app/controllers/custom_fields_controller.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 CustomFieldsController < ApplicationController
                layout 'admin'
                before_action :require_admin
                before_action :build_new_custom_field, :only => [:new, :create]
                before_action :find_custom_field, :only => [:edit, :update, :destroy]
                accept_api_auth :index
                def index
                  respond_to do |format|
                    format.html {
                      @custom_fields_by_type = CustomField.all.group_by {|f| f.class.name }
                    }
                    format.api {
                      @custom_fields = CustomField.all
                    }
                  end
                end
                def new
                  @custom_field.field_format = 'string' if @custom_field.field_format.blank?
                  @custom_field.default_value = nil
                end
                def create
                  if @custom_field.save
                    flash[:notice] = l(:notice_successful_create)
                    call_hook(:controller_custom_fields_new_after_save, :params => params, :custom_field => @custom_field)
                    redirect_to edit_custom_field_path(@custom_field)
                  else
                    render :action => 'new'
                  end
                end
                def edit
                end
                def update
                  if @custom_field.update_attributes(params[:custom_field])
                    call_hook(:controller_custom_fields_edit_after_save, :params => params, :custom_field => @custom_field)
                    respond_to do |format|
                      format.html {
                        flash[:notice] = l(:notice_successful_update)
                        redirect_back_or_default edit_custom_field_path(@custom_field)
                      }
-                     format.js { render :nothing => true }
+                     format.js { head 200 }
                    end
                  else
                    respond_to do |format|
                      format.html { render :action => 'edit' }
-                     format.js { render :nothing => true, :status => 422 }
+                     format.js { head 422 }
                    end
                  end
                end
                def destroy
                  begin
                    @custom_field.destroy
                  rescue
                    flash[:error] = l(:error_can_not_delete_custom_field)
                  end
                  redirect_to custom_fields_path(:tab => @custom_field.class.name)
                end
                private
                def build_new_custom_field
                  @custom_field = CustomField.new_subclass_instance(params[:type], params[:custom_field])
                  if @custom_field.nil?
                    render :action => 'select_type'
                  end
                end
                def find_custom_field
                  @custom_field = CustomField.find(params[:id])
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
              end

app/controllers/enumerations_controller.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 EnumerationsController < ApplicationController
                layout 'admin'
                before_action :require_admin, :except => :index
                before_action :require_admin_or_api_request, :only => :index
                before_action :build_new_enumeration, :only => [:new, :create]
                before_action :find_enumeration, :only => [:edit, :update, :destroy]
                accept_api_auth :index
                helper :custom_fields
                def index
                  respond_to do |format|
                    format.html
                    format.api {
                      @klass = Enumeration.get_subclass(params[:type])
                      if @klass
                        @enumerations = @klass.shared.sorted.to_a
                      else
                        render_404
                      end
                    }
                  end
                end
                def new
                end
                def create
                  if request.post? && @enumeration.save
                    flash[:notice] = l(:notice_successful_create)
                    redirect_to enumerations_path
                  else
                    render :action => 'new'
                  end
                end
                def edit
                end
                def update
                  if @enumeration.update_attributes(params[:enumeration])
                    respond_to do |format|
                      format.html {
                        flash[:notice] = l(:notice_successful_update)
                        redirect_to enumerations_path
                      }
-                     format.js { render :nothing => true }
+                     format.js { head 200 }
                    end
                  else
                    respond_to do |format|
                      format.html { render :action => 'edit' }
-                     format.js { render :nothing => true, :status => 422 }
+                     format.js { head 422 }
                    end
                  end
                end
                def destroy
                  if !@enumeration.in_use?
                    # No associated objects
                    @enumeration.destroy
                    redirect_to enumerations_path
                    return
                  elsif params[:reassign_to_id].present? && (reassign_to = @enumeration.class.find_by_id(params[:reassign_to_id].to_i))
                    @enumeration.destroy(reassign_to)
                    redirect_to enumerations_path
                    return
                  end
                  @enumerations = @enumeration.class.system.to_a - [@enumeration]
                end
                private
                def build_new_enumeration
                  class_name = params[:enumeration] && params[:enumeration][:type] || params[:type]
                  @enumeration = Enumeration.new_subclass_instance(class_name, params[:enumeration])
                  if @enumeration.nil?
                    render_404
                  end
                end
                def find_enumeration
                  @enumeration = Enumeration.find(params[:id])
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
              end

app/controllers/issue_relations_controller.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 IssueRelationsController < ApplicationController
                before_action :find_issue, :authorize, :only => [:index, :create]
                before_action :find_relation, :only => [:show, :destroy]
                accept_api_auth :index, :show, :create, :destroy
                def index
                  @relations = @issue.relations
                  respond_to do |format|
-                   format.html { render :nothing => true }
+                   format.html { head 200 }
                    format.api
                  end
                end
                def show
                  raise Unauthorized unless @relation.visible?
                  respond_to do |format|
-                   format.html { render :nothing => true }
+                   format.html { head 200 }
                    format.api
                  end
                end
                def create
                  @relation = IssueRelation.new
                  @relation.issue_from = @issue
                  @relation.safe_attributes = params[:relation]
                  @relation.init_journals(User.current)
                  saved = @relation.save
                  respond_to do |format|
                    format.html { redirect_to issue_path(@issue) }
                    format.js {
                      @relations = @issue.reload.relations.select {|r| r.other_issue(@issue) && r.other_issue(@issue).visible? }
                    }
                    format.api {
                      if saved
                        render :action => 'show', :status => :created, :location => relation_url(@relation)
                      else
                        render_validation_errors(@relation)
                      end
                    }
                  end
                end
                def destroy
                  raise Unauthorized unless @relation.deletable?
                  @relation.init_journals(User.current)
                  @relation.destroy
                  respond_to do |format|
                    format.html { redirect_to issue_path(@relation.issue_from) }
                    format.js
                    format.api  { render_api_ok }
                  end
                end
                private
                def find_issue
                  @issue = Issue.find(params[:issue_id])
                  @project = @issue.project
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def find_relation
                  @relation = IssueRelation.find(params[:id])
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
              end

app/controllers/issue_statuses_controller.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 IssueStatusesController < ApplicationController
                layout 'admin'
                before_action :require_admin, :except => :index
                before_action :require_admin_or_api_request, :only => :index
                accept_api_auth :index
                def index
                  @issue_statuses = IssueStatus.sorted.to_a
                  respond_to do |format|
                    format.html { render :layout => false if request.xhr? }
                    format.api
                  end
                end
                def new
                  @issue_status = IssueStatus.new
                end
                def create
                  @issue_status = IssueStatus.new(params[:issue_status])
                  if @issue_status.save
                    flash[:notice] = l(:notice_successful_create)
                    redirect_to issue_statuses_path
                  else
                    render :action => 'new'
                  end
                end
                def edit
                  @issue_status = IssueStatus.find(params[:id])
                end
                def update
                  @issue_status = IssueStatus.find(params[:id])
                  if @issue_status.update_attributes(params[:issue_status])
                    respond_to do |format|
                      format.html {
                        flash[:notice] = l(:notice_successful_update)
                        redirect_to issue_statuses_path(:page => params[:page])
                      }
-                     format.js { render :nothing => true }
+                     format.js { head 200 }
                    end
                  else
                    respond_to do |format|
                      format.html { render :action => 'edit' }
-                     format.js { render :nothing => true, :status => 422 }
+                     format.js { head 422 }
                    end
                  end
                end
                def destroy
                  IssueStatus.find(params[:id]).destroy
                  redirect_to issue_statuses_path
                rescue
                  flash[:error] = l(:error_unable_delete_issue_status)
                  redirect_to issue_statuses_path
                end
                def update_issue_done_ratio
                  if request.post? && IssueStatus.update_issue_done_ratios
                    flash[:notice] = l(:notice_issue_done_ratios_updated)
                  else
                    flash[:error] =  l(:error_issue_done_ratios_not_updated)
                  end
                  redirect_to issue_statuses_path
                end
              end

app/controllers/issues_controller.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  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
                default_search_scope :issues
                before_action :find_issue, :only => [:show, :edit, :update]
                before_action :find_issues, :only => [:bulk_edit, :bulk_update, :destroy]
                before_action :authorize, :except => [:index, :new, :create]
                before_action :find_optional_project, :only => [:index, :new, :create]
                before_action :build_new_issue_from_params, :only => [:new, :create]
                accept_rss_auth :index, :show
                accept_api_auth :index, :show, :create, :update, :destroy
                rescue_from Query::StatementInvalid, :with => :query_statement_invalid
                helper :journals
                helper :projects
                helper :custom_fields
                helper :issue_relations
                helper :watchers
                helper :attachments
                helper :queries
                include QueriesHelper
                helper :repositories
                helper :sort
                include SortHelper
                helper :timelog
                def index
                  retrieve_query
                  sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
                  sort_update(@query.sortable_columns)
                  @query.sort_criteria = sort_criteria.to_a
                  if @query.valid?
                    case params[:format]
                    when 'csv', 'pdf'
                      @limit = Setting.issues_export_limit.to_i
                      if params[:columns] == 'all'
                        @query.column_names = @query.available_inline_columns.map(&:name)
                      end
                    when 'atom'
                      @limit = Setting.feeds_limit.to_i
                    when 'xml', 'json'
                      @offset, @limit = api_offset_and_limit
                      @query.column_names = %w(author)
                    else
                      @limit = per_page_option
                    end
                    @issue_count = @query.issue_count
                    @issue_pages = Paginator.new @issue_count, @limit, params['page']
                    @offset ||= @issue_pages.offset
                    @issues = @query.issues(:include => [:assigned_to, :tracker, :priority, :category, :fixed_version],
                                            :order => sort_clause,
                                            :offset => @offset,
                                            :limit => @limit)
                    @issue_count_by_group = @query.issue_count_by_group
                    respond_to do |format|
                      format.html { render :template => 'issues/index', :layout => !request.xhr? }
                      format.api  {
                        Issue.load_visible_relations(@issues) if include_in_api_response?('relations')
                      }
                      format.atom { render_feed(@issues, :title => "#{@project || Setting.app_title}: #{l(:label_issue_plural)}") }
                      format.csv  { send_data(query_to_csv(@issues, @query, params[:csv]), :type => 'text/csv; header=present', :filename => 'issues.csv') }
                      format.pdf  { send_file_headers! :type => 'application/pdf', :filename => 'issues.pdf' }
                    end
                  else
                    respond_to do |format|
                      format.html { render(:template => 'issues/index', :layout => !request.xhr?) }
-                     format.any(:atom, :csv, :pdf) { render(:nothing => true) }
+                     format.any(:atom, :csv, :pdf) { head 422 }
                      format.api { render_validation_errors(@query) }
                    end
                  end
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def show
                  @journals = @issue.journals.
                                preload(:details).
                                preload(:user => :email_address).
                                reorder(:created_on, :id).to_a
                  @journals.each_with_index {|j,i| j.indice = i+1}
                  @journals.reject!(&:private_notes?) unless User.current.allowed_to?(:view_private_notes, @issue.project)
                  Journal.preload_journals_details_custom_fields(@journals)
                  @journals.select! {|journal| journal.notes? || journal.visible_details.any?}
                  @journals.reverse! if User.current.wants_comments_in_reverse_order?
                  @changesets = @issue.changesets.visible.preload(:repository, :user).to_a
                  @changesets.reverse! if User.current.wants_comments_in_reverse_order?
                  @relations = @issue.relations.select {|r| r.other_issue(@issue) && r.other_issue(@issue).visible? }
                  @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                  @priorities = IssuePriority.active
                  @time_entry = TimeEntry.new(:issue => @issue, :project => @issue.project)
                  @relation = IssueRelation.new
                  respond_to do |format|
                    format.html {
                      retrieve_previous_and_next_issue_ids
                      render :template => 'issues/show'
                    }
                    format.api
                    format.atom { render :template => 'journals/index', :layout => false, :content_type => 'application/atom+xml' }
                    format.pdf  {
                      send_file_headers! :type => 'application/pdf', :filename => "#{@project.identifier}-#{@issue.id}.pdf"
                    }
                  end
                end
                def new
                  respond_to do |format|
                    format.html { render :action => 'new', :layout => !request.xhr? }
                    format.js
                  end
                end
                def create
                  unless User.current.allowed_to?(:add_issues, @issue.project, :global => true)
                    raise ::Unauthorized
                  end
                  call_hook(:controller_issues_new_before_save, { :params => params, :issue => @issue })
                  @issue.save_attachments(params[:attachments] || (params[:issue] && params[:issue][:uploads]))
                  if @issue.save
                    call_hook(:controller_issues_new_after_save, { :params => params, :issue => @issue})
                    respond_to do |format|
                      format.html {
                        render_attachment_warning_if_needed(@issue)
                        flash[:notice] = l(:notice_issue_successful_create, :id => view_context.link_to("##{@issue.id}", issue_path(@issue), :title => @issue.subject))
                        redirect_after_create
                      }
                      format.api  { render :action => 'show', :status => :created, :location => issue_url(@issue) }
                    end
                    return
                  else
                    respond_to do |format|
                      format.html {
                        if @issue.project.nil?
                          render_error :status => 422
                        else
                          render :action => 'new'
                        end
                      }
                      format.api  { render_validation_errors(@issue) }
                    end
                  end
                end
                def edit
                  return unless update_issue_from_params
                  respond_to do |format|
                    format.html { }
                    format.js
                  end
                end
                def update
                  return unless update_issue_from_params
                  @issue.save_attachments(params[:attachments] || (params[:issue] && params[:issue][:uploads]))
                  saved = false
                  begin
                    saved = save_issue_with_child_records
                  rescue ActiveRecord::StaleObjectError
                    @conflict = true
                    if params[:last_journal_id]
                      @conflict_journals = @issue.journals_after(params[:last_journal_id]).to_a
                      @conflict_journals.reject!(&:private_notes?) unless User.current.allowed_to?(:view_private_notes, @issue.project)
                    end
                  end
                  if saved
                    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 issue_path(@issue, previous_and_next_issue_ids_params) }
                      format.api  { render_api_ok }
                    end
                  else
                    respond_to do |format|
                      format.html { render :action => 'edit' }
                      format.api  { render_validation_errors(@issue) }
                    end
                  end
                end
                # Bulk edit/copy a set of issues
                def bulk_edit
                  @issues.sort!
                  @copy = params[:copy].present?
                  @notes = params[:notes]
                  if @copy
                    unless User.current.allowed_to?(:copy_issues, @projects)
                      raise ::Unauthorized
                    end
                  else
                    unless @issues.all?(&:attributes_editable?)
                      raise ::Unauthorized
                    end
                  end
                  @allowed_projects = Issue.allowed_target_projects
                  if params[:issue]
                    @target_project = @allowed_projects.detect {|p| p.id.to_s == params[:issue][:project_id].to_s}
                    if @target_project
                      target_projects = [@target_project]
                    end
                  end
                  target_projects ||= @projects
                  if @copy
                    # Copied issues will get their default statuses
                    @available_statuses = []
                  else
                    @available_statuses = @issues.map(&:new_statuses_allowed_to).reduce(:&)
                  end
                  @custom_fields = @issues.map{|i|i.editable_custom_fields}.reduce(:&)
                  @assignables = target_projects.map(&:assignable_users).reduce(:&)
                  @trackers = target_projects.map {|p| Issue.allowed_target_trackers(p) }.reduce(:&)
                  @versions = target_projects.map {|p| p.shared_versions.open}.reduce(:&)
                  @categories = target_projects.map {|p| p.issue_categories}.reduce(:&)
                  if @copy
                    @attachments_present = @issues.detect {|i| i.attachments.any?}.present?
                    @subtasks_present = @issues.detect {|i| !i.leaf?}.present?
                  end
                  @safe_attributes = @issues.map(&:safe_attribute_names).reduce(:&)
                  @issue_params = params[:issue] || {}
                  @issue_params[:custom_field_values] ||= {}
                end
                def bulk_update
                  @issues.sort!
                  @copy = params[:copy].present?
                  attributes = parse_params_for_bulk_update(params[:issue])
                  copy_subtasks = (params[:copy_subtasks] == '1')
                  copy_attachments = (params[:copy_attachments] == '1')
                  if @copy
                    unless User.current.allowed_to?(:copy_issues, @projects)
                      raise ::Unauthorized
                    end
                    target_projects = @projects
                    if attributes['project_id'].present?
                      target_projects = Project.where(:id => attributes['project_id']).to_a
                    end
                    unless User.current.allowed_to?(:add_issues, target_projects)
                      raise ::Unauthorized
                    end
                  else
                    unless @issues.all?(&:attributes_editable?)
                      raise ::Unauthorized
                    end
                  end
                  unsaved_issues = []
                  saved_issues = []
                  if @copy && copy_subtasks
                    # Descendant issues will be copied with the parent task
                    # Don't copy them twice
                    @issues.reject! {|issue| @issues.detect {|other| issue.is_descendant_of?(other)}}
                  end
                  @issues.each do |orig_issue|
                    orig_issue.reload
                    if @copy
                      issue = orig_issue.copy({},
                        :attachments => copy_attachments,
                        :subtasks => copy_subtasks,
                        :link => link_copy?(params[:link_copy])
                      )
                    else
                      issue = orig_issue
                    end
                    journal = issue.init_journal(User.current, params[:notes])
                    issue.safe_attributes = attributes
                    call_hook(:controller_issues_bulk_edit_before_save, { :params => params, :issue => issue })
                    if issue.save
                      saved_issues << issue
                    else
                      unsaved_issues << orig_issue
                    end
                  end
                  if unsaved_issues.empty?
                    flash[:notice] = l(:notice_successful_update) unless saved_issues.empty?
                    if params[:follow]
                      if @issues.size == 1 && saved_issues.size == 1
                        redirect_to issue_path(saved_issues.first)
                      elsif saved_issues.map(&:project).uniq.size == 1
                        redirect_to project_issues_path(saved_issues.map(&:project).first)
                      end
                    else
                      redirect_back_or_default _project_issues_path(@project)
                    end
                  else
                    @saved_issues = @issues
                    @unsaved_issues = unsaved_issues
                    @issues = Issue.visible.where(:id => @unsaved_issues.map(&:id)).to_a
                    bulk_edit
                    render :action => 'bulk_edit'
                  end
                end
                def destroy
                  raise Unauthorized unless @issues.all?(&:deletable?)
                  @hours = TimeEntry.where(:issue_id => @issues.map(&:id)).sum(:hours).to_f
                  if @hours > 0
                    case params[:todo]
                    when 'destroy'
                      # nothing to do
                    when 'nullify'
                      TimeEntry.where(['issue_id IN (?)', @issues]).update_all('issue_id = NULL')
                    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.where(['issue_id IN (?)', @issues]).
                          update_all("issue_id = #{reassign_to.id}")
                      end
                    else
                      # display the destroy form if it's a user request
                      return unless api_request?
                    end
                  end
                  @issues.each do |issue|
                    begin
                      issue.reload.destroy
                    rescue ::ActiveRecord::RecordNotFound # raised by #reload if issue no longer exists
                      # nothing to do, issue was already deleted (eg. by a parent)
                    end
                  end
                  respond_to do |format|
                    format.html { redirect_back_or_default _project_issues_path(@project) }
                    format.api  { render_api_ok }
                  end
                end
                # Overrides Redmine::MenuManager::MenuController::ClassMethods for
                # when the "New issue" tab is enabled
                def current_menu_item
                  if Setting.new_item_menu_tab == '1' && [:new, :create].include?(action_name.to_sym)
                    :new_issue
                  else
                    super
                  end
                end
                private
                def retrieve_previous_and_next_issue_ids
                  if params[:prev_issue_id].present? || params[:next_issue_id].present?
                    @prev_issue_id = params[:prev_issue_id].presence.try(:to_i)
                    @next_issue_id = params[:next_issue_id].presence.try(:to_i)
                    @issue_position = params[:issue_position].presence.try(:to_i)
                    @issue_count = params[:issue_count].presence.try(:to_i)
                  else
                    retrieve_query_from_session
                    if @query
                      sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
                      sort_update(@query.sortable_columns, 'issues_index_sort')
                      limit = 500
                      issue_ids = @query.issue_ids(:order => sort_clause, :limit => (limit + 1), :include => [:assigned_to, :tracker, :priority, :category, :fixed_version])
                      if (idx = issue_ids.index(@issue.id)) && idx < limit
                        if issue_ids.size < 500
                          @issue_position = idx + 1
                          @issue_count = issue_ids.size
                        end
                        @prev_issue_id = issue_ids[idx - 1] if idx > 0
                        @next_issue_id = issue_ids[idx + 1] if idx < (issue_ids.size - 1)
                      end
                    end
                  end
                end
                def previous_and_next_issue_ids_params
                  {
                    :prev_issue_id => params[:prev_issue_id],
                    :next_issue_id => params[:next_issue_id],
                    :issue_position => params[:issue_position],
                    :issue_count => params[:issue_count]
                  }.reject {|k,v| k.blank?}
                end
                # Used by #edit and #update to set some common instance variables
                # from the params
                def update_issue_from_params
                  @time_entry = TimeEntry.new(:issue => @issue, :project => @issue.project)
                  if params[:time_entry]
                    @time_entry.safe_attributes = params[:time_entry]
                  end
                  @issue.init_journal(User.current)
                  issue_attributes = params[:issue]
                  if issue_attributes && params[:conflict_resolution]
                    case params[:conflict_resolution]
                    when 'overwrite'
                      issue_attributes = issue_attributes.dup
                      issue_attributes.delete(:lock_version)
                    when 'add_notes'
                      issue_attributes = issue_attributes.slice(:notes, :private_notes)
                    when 'cancel'
                      redirect_to issue_path(@issue)
                      return false
                    end
                  end
                  @issue.safe_attributes = issue_attributes
                  @priorities = IssuePriority.active
                  @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                  true
                end
                # Used by #new and #create to build a new issue from the params
                # The new issue will be copied from an existing one if copy_from parameter is given
                def build_new_issue_from_params
                  @issue = Issue.new
                  if params[:copy_from]
                    begin
                      @issue.init_journal(User.current)
                      @copy_from = Issue.visible.find(params[:copy_from])
                      unless User.current.allowed_to?(:copy_issues, @copy_from.project)
                        raise ::Unauthorized
                      end
                      @link_copy = link_copy?(params[:link_copy]) || request.get?
                      @copy_attachments = params[:copy_attachments].present? || request.get?
                      @copy_subtasks = params[:copy_subtasks].present? || request.get?
                      @issue.copy_from(@copy_from, :attachments => @copy_attachments, :subtasks => @copy_subtasks, :link => @link_copy)
                      @issue.parent_issue_id = @copy_from.parent_id
                    rescue ActiveRecord::RecordNotFound
                      render_404
                      return
                    end
                  end
                  @issue.project = @project
                  if request.get?
                    @issue.project ||= @issue.allowed_target_projects.first
                  end
                  @issue.author ||= User.current
                  @issue.start_date ||= User.current.today if Setting.default_issue_start_date_to_creation_date?
                  attrs = (params[:issue] || {}).deep_dup
                  if action_name == 'new' && params[:was_default_status] == attrs[:status_id]
                    attrs.delete(:status_id)
                  end
                  if action_name == 'new' && params[:form_update_triggered_by] == 'issue_project_id'
                    # Discard submitted version when changing the project on the issue form
                    # so we can use the default version for the new project
                    attrs.delete(:fixed_version_id)
                  end
                  @issue.safe_attributes = attrs
                  if @issue.project
                    @issue.tracker ||= @issue.allowed_target_trackers.first
                    if @issue.tracker.nil?
                      if @issue.project.trackers.any?
                        # None of the project trackers is allowed to the user
                        render_error :message => l(:error_no_tracker_allowed_for_new_issue_in_project), :status => 403
                      else
                        # Project has no trackers
                        render_error l(:error_no_tracker_in_project)
                      end
                      return false
                    end
                    if @issue.status.nil?
                      render_error l(:error_no_default_issue_status)
                      return false
                    end
                  end
                  @priorities = IssuePriority.active
                  @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                end
                # Saves @issue and a time_entry from the parameters
                def save_issue_with_child_records
                  Issue.transaction do
                    if params[:time_entry] && (params[:time_entry][:hours].present? || params[:time_entry][:comments].present?) && User.current.allowed_to?(:log_time, @issue.project)
                      time_entry = @time_entry || TimeEntry.new
                      time_entry.project = @issue.project
                      time_entry.issue = @issue
                      time_entry.user = User.current
                      time_entry.spent_on = User.current.today
                      time_entry.attributes = params[:time_entry]
                      @issue.time_entries << time_entry
                    end
                    call_hook(:controller_issues_edit_before_save, { :params => params, :issue => @issue, :time_entry => time_entry, :journal => @issue.current_journal})
                    if @issue.save
                      call_hook(:controller_issues_edit_after_save, { :params => params, :issue => @issue, :time_entry => time_entry, :journal => @issue.current_journal})
                    else
                      raise ActiveRecord::Rollback
                    end
                  end
                end
                # Returns true if the issue copy should be linked
                # to the original issue
                def link_copy?(param)
                  case Setting.link_copied_issue
                  when 'yes'
                    true
                  when 'no'
                    false
                  when 'ask'
                    param == '1'
                  end
                end
                # Redirects user after a successful issue creation
                def redirect_after_create
                  if params[:continue]
                    attrs = {:tracker_id => @issue.tracker, :parent_issue_id => @issue.parent_issue_id}.reject {|k,v| v.nil?}
                    if params[:project_id]
                      redirect_to new_project_issue_path(@issue.project, :issue => attrs)
                    else
                      attrs.merge! :project_id => @issue.project_id
                      redirect_to new_issue_path(:issue => attrs)
                    end
                  else
                    redirect_to issue_path(@issue)
                  end
                end
              end

app/controllers/mail_handler_controller.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 MailHandlerController < ActionController::Base
                before_action :check_credential
                # Displays the email submission form
                def new
                end
                # Submits an incoming email to MailHandler
                def index
                  options = params.dup
                  email = options.delete(:email)
                  if MailHandler.receive(email, options)
-                   render :nothing => true, :status => :created
+                   head :created
                  else
-                   render :nothing => true, :status => :unprocessable_entity
+                   head :unprocessable_entity
                  end
                end
                private
                def check_credential
                  User.current = nil
                  unless Setting.mail_handler_api_enabled? && params[:key].to_s == Setting.mail_handler_api_key
                    render :text => 'Access denied. Incoming emails WS is disabled or key is invalid.', :status => 403
                  end
                end
              end

app/controllers/my_controller.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 MyController < ApplicationController
                before_action :require_login
                # let user change user's password when user has to
                skip_before_action :check_password_change, :only => :password
                require_sudo_mode :account, only: :post
                require_sudo_mode :reset_rss_key, :reset_api_key, :show_api_key, :destroy
                helper :issues
                helper :users
                helper :custom_fields
                BLOCKS = { 'issuesassignedtome' => :label_assigned_to_me_issues,
                           'issuesreportedbyme' => :label_reported_issues,
                           'issueswatched' => :label_watched_issues,
                           'news' => :label_news_latest,
                           'calendar' => :label_calendar,
                           'documents' => :label_document_plural,
                           'timelog' => :label_spent_time
                         }.merge(Redmine::Views::MyPage::Block.additional_blocks).freeze
                DEFAULT_LAYOUT = {  'left' => ['issuesassignedtome'],
                                    'right' => ['issuesreportedbyme']
                                 }.freeze
                def index
                  page
                  render :action => 'page'
                end
                # Show user's page
                def page
                  @user = User.current
                  @blocks = @user.pref[:my_page_layout] || DEFAULT_LAYOUT
                end
                # Edit user's account
                def account
                  @user = User.current
                  @pref = @user.pref
                  if request.post?
                    @user.safe_attributes = params[:user] if params[:user]
                    @user.pref.attributes = params[:pref] if params[:pref]
                    if @user.save
                      @user.pref.save
                      set_language_if_valid @user.language
                      flash[:notice] = l(:notice_account_updated)
                      redirect_to my_account_path
                      return
                    end
                  end
                end
                # Destroys user's account
                def destroy
                  @user = User.current
                  unless @user.own_account_deletable?
                    redirect_to my_account_path
                    return
                  end
                  if request.post? && params[:confirm]
                    @user.destroy
                    if @user.destroyed?
                      logout_user
                      flash[:notice] = l(:notice_account_deleted)
                    end
                    redirect_to home_path
                  end
                end
                # Manage user's password
                def password
                  @user = User.current
                  unless @user.change_password_allowed?
                    flash[:error] = l(:notice_can_t_change_password)
                    redirect_to my_account_path
                    return
                  end
                  if request.post?
                    if !@user.check_password?(params[:password])
                      flash.now[:error] = l(:notice_account_wrong_password)
                    elsif params[:password] == params[:new_password]
                      flash.now[:error] = l(:notice_new_password_must_be_different)
                    else
                      @user.password, @user.password_confirmation = params[:new_password], params[:new_password_confirmation]
                      @user.must_change_passwd = false
                      if @user.save
                        # The session token was destroyed by the password change, generate a new one
                        session[:tk] = @user.generate_session_token
                        Mailer.password_updated(@user)
                        flash[:notice] = l(:notice_account_password_updated)
                        redirect_to my_account_path
                      end
                    end
                  end
                end
                # Create a new feeds key
                def reset_rss_key
                  if request.post?
                    if User.current.rss_token
                      User.current.rss_token.destroy
                      User.current.reload
                    end
                    User.current.rss_key
                    flash[:notice] = l(:notice_feeds_access_key_reseted)
                  end
                  redirect_to my_account_path
                end
                def show_api_key
                  @user = User.current
                end
                # Create a new API key
                def reset_api_key
                  if request.post?
                    if User.current.api_token
                      User.current.api_token.destroy
                      User.current.reload
                    end
                    User.current.api_key
                    flash[:notice] = l(:notice_api_access_key_reseted)
                  end
                  redirect_to my_account_path
                end
                # User's page layout configuration
                def page_layout
                  @user = User.current
                  @blocks = @user.pref[:my_page_layout] || DEFAULT_LAYOUT.dup
                  @block_options = []
                  BLOCKS.each do |k, v|
                    unless @blocks.values.flatten.include?(k)
                      @block_options << [l("my.blocks.#{v}", :default => [v, v.to_s.humanize]), k.dasherize]
                    end
                  end
                end
                # Add a block to user's page
                # The block is added on top of the page
                # params[:block] : id of the block to add
                def add_block
                  block = params[:block].to_s.underscore
                  if block.present? && BLOCKS.key?(block)
                    @user = User.current
                    layout = @user.pref[:my_page_layout] || {}
                    # remove if already present in a group
                    %w(top left right).each {|f| (layout[f] ||= []).delete block }
                    # add it on top
                    layout['top'].unshift block
                    @user.pref[:my_page_layout] = layout
                    @user.pref.save
                  end
                  redirect_to my_page_layout_path
                end
                # Remove a block to user's page
                # params[:block] : id of the block to remove
                def remove_block
                  block = params[:block].to_s.underscore
                  @user = User.current
                  # remove block in all groups
                  layout = @user.pref[:my_page_layout] || {}
                  %w(top left right).each {|f| (layout[f] ||= []).delete block }
                  @user.pref[:my_page_layout] = layout
                  @user.pref.save
                  redirect_to my_page_layout_path
                end
                # Change blocks order on user's page
                # params[:group] : group to order (top, left or right)
                # params[:list-(top|left|right)] : array of block ids of the group
                def order_blocks
                  group = params[:group]
                  @user = User.current
                  if group.is_a?(String)
                    group_items = (params["blocks"] || []).collect(&:underscore)
                    group_items.each {|s| s.sub!(/^block_/, '')}
                    if group_items and group_items.is_a? Array
                      layout = @user.pref[:my_page_layout] || {}
                      # remove group blocks if they are presents in other groups
                      %w(top left right).each {|f|
                        layout[f] = (layout[f] || []) - group_items
                      }
                      layout[group] = group_items
                      @user.pref[:my_page_layout] = layout
                      @user.pref.save
                    end
                  end
-                 render :nothing => true
+                 head 200
                end
              end

app/controllers/repositories_controller.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 'SVG/Graph/Bar'
              require 'SVG/Graph/BarHorizontal'
              require 'digest/sha1'
              require 'redmine/scm/adapters'
              class ChangesetNotFound < Exception; end
              class InvalidRevisionParam < Exception; end
              class RepositoriesController < ApplicationController
                menu_item :repository
                menu_item :settings, :only => [:new, :create, :edit, :update, :destroy, :committers]
                default_search_scope :changesets
                before_action :find_project_by_project_id, :only => [:new, :create]
                before_action :find_repository, :only => [:edit, :update, :destroy, :committers]
                before_action :find_project_repository, :except => [:new, :create, :edit, :update, :destroy, :committers]
                before_action :find_changeset, :only => [:revision, :add_related_issue, :remove_related_issue]
                before_action :authorize
                accept_rss_auth :revisions
                rescue_from Redmine::Scm::Adapters::CommandFailed, :with => :show_error_command_failed
                def new
                  scm = params[:repository_scm] || (Redmine::Scm::Base.all & Setting.enabled_scm).first
                  @repository = Repository.factory(scm)
                  @repository.is_default = @project.repository.nil?
                  @repository.project = @project
                end
                def create
                  attrs = pickup_extra_info
                  @repository = Repository.factory(params[:repository_scm])
                  @repository.safe_attributes = params[:repository]
                  if attrs[:attrs_extra].keys.any?
                    @repository.merge_extra_info(attrs[:attrs_extra])
                  end
                  @repository.project = @project
                  if request.post? && @repository.save
                    redirect_to settings_project_path(@project, :tab => 'repositories')
                  else
                    render :action => 'new'
                  end
                end
                def edit
                end
                def update
                  attrs = pickup_extra_info
                  @repository.safe_attributes = attrs[:attrs]
                  if attrs[:attrs_extra].keys.any?
                    @repository.merge_extra_info(attrs[:attrs_extra])
                  end
                  @repository.project = @project
                  if @repository.save
                    redirect_to settings_project_path(@project, :tab => 'repositories')
                  else
                    render :action => 'edit'
                  end
                end
                def pickup_extra_info
                  p       = {}
                  p_extra = {}
                  params[:repository].each do |k, v|
                    if k =~ /^extra_/
                      p_extra[k] = v
                    else
                      p[k] = v
                    end
                  end
                  {:attrs => p, :attrs_extra => p_extra}
                end
                private :pickup_extra_info
                def committers
                  @committers = @repository.committers
                  @users = @project.users.to_a
                  additional_user_ids = @committers.collect(&:last).collect(&:to_i) - @users.collect(&:id)
                  @users += User.where(:id => additional_user_ids).to_a unless additional_user_ids.empty?
                  @users.compact!
                  @users.sort!
                  if request.post? && params[:committers].is_a?(Hash)
                    # Build a hash with repository usernames as keys and corresponding user ids as values
                    @repository.committer_ids = params[:committers].values.inject({}) {|h, c| h[c.first] = c.last; h}
                    flash[:notice] = l(:notice_successful_update)
                    redirect_to settings_project_path(@project, :tab => 'repositories')
                  end
                end
                def destroy
                  @repository.destroy if request.delete?
                  redirect_to settings_project_path(@project, :tab => 'repositories')
                end
                def show
                  @repository.fetch_changesets if @project.active? && Setting.autofetch_changesets? && @path.empty?
                  @entries = @repository.entries(@path, @rev)
                  @changeset = @repository.find_changeset_by_name(@rev)
                  if request.xhr?
-                   @entries ? render(:partial => 'dir_list_content') : render(:nothing => true)
+                   @entries ? render(:partial => 'dir_list_content') : head(200)
                  else
                    (show_error_not_found; return) unless @entries
                    @changesets = @repository.latest_changesets(@path, @rev)
                    @properties = @repository.properties(@path, @rev)
                    @repositories = @project.repositories
                    render :action => 'show'
                  end
                end
                alias_method :browse, :show
                def changes
                  @entry = @repository.entry(@path, @rev)
                  (show_error_not_found; return) unless @entry
                  @changesets = @repository.latest_changesets(@path, @rev, Setting.repository_log_display_limit.to_i)
                  @properties = @repository.properties(@path, @rev)
                  @changeset = @repository.find_changeset_by_name(@rev)
                end
                def revisions
                  @changeset_count = @repository.changesets.count
                  @changeset_pages = Paginator.new @changeset_count,
                                                   per_page_option,
                                                   params['page']
                  @changesets = @repository.changesets.
                    limit(@changeset_pages.per_page).
                    offset(@changeset_pages.offset).
                    includes(:user, :repository, :parents).
                    to_a
                  respond_to do |format|
                    format.html { render :layout => false if request.xhr? }
                    format.atom { render_feed(@changesets, :title => "#{@project.name}: #{l(:label_revision_plural)}") }
                  end
                end
                def raw
                  entry_and_raw(true)
                end
                def entry
                  entry_and_raw(false)
                end
                def entry_and_raw(is_raw)
                  @entry = @repository.entry(@path, @rev)
                  (show_error_not_found; return) unless @entry
                  # If the entry is a dir, show the browser
                  (show; return) if @entry.is_dir?
                  if is_raw
                    # Force the download
                    send_opt = { :filename => filename_for_content_disposition(@path.split('/').last) }
                    send_type = Redmine::MimeType.of(@path)
                    send_opt[:type] = send_type.to_s if send_type
                    send_opt[:disposition] = disposition(@path)
                    send_data @repository.cat(@path, @rev), send_opt
                  else
                    if !@entry.size || @entry.size <= Setting.file_max_size_displayed.to_i.kilobyte
                      content = @repository.cat(@path, @rev)
                      (show_error_not_found; return) unless content
                      if content.size <= Setting.file_max_size_displayed.to_i.kilobyte &&
                         is_entry_text_data?(content, @path)
                        # TODO: UTF-16
                        # Prevent empty lines when displaying a file with Windows style eol
                        # Is this needed? AttachmentsController simply reads file.
                        @content = content.gsub("\r\n", "\n")
                      end
                    end
                    @changeset = @repository.find_changeset_by_name(@rev)
                  end
                end
                private :entry_and_raw
                def is_entry_text_data?(ent, path)
                  # UTF-16 contains "\x00".
                  # It is very strict that file contains less than 30% of ascii symbols
                  # in non Western Europe.
                  return true if Redmine::MimeType.is_type?('text', path)
                  # Ruby 1.8.6 has a bug of integer divisions.
                  # http://apidock.com/ruby/v1_8_6_287/String/is_binary_data%3F
                  return false if ent.is_binary_data?
                  true
                end
                private :is_entry_text_data?
                def annotate
                  @entry = @repository.entry(@path, @rev)
                  (show_error_not_found; return) unless @entry
                  @annotate = @repository.scm.annotate(@path, @rev)
                  if @annotate.nil? || @annotate.empty?
                    (render_error l(:error_scm_annotate); return)
                  end
                  ann_buf_size = 0
                  @annotate.lines.each do |buf|
                    ann_buf_size += buf.size
                  end
                  if ann_buf_size > Setting.file_max_size_displayed.to_i.kilobyte
                    (render_error l(:error_scm_annotate_big_text_file); return)
                  end
                  @changeset = @repository.find_changeset_by_name(@rev)
                end
                def revision
                  respond_to do |format|
                    format.html
                    format.js {render :layout => false}
                  end
                end
                # Adds a related issue to a changeset
                # POST /projects/:project_id/repository/(:repository_id/)revisions/:rev/issues
                def add_related_issue
                  issue_id = params[:issue_id].to_s.sub(/^#/,'')
                  @issue = @changeset.find_referenced_issue_by_id(issue_id)
                  if @issue && (!@issue.visible? || @changeset.issues.include?(@issue))
                    @issue = nil
                  end
                  if @issue
                    @changeset.issues << @issue
                  end
                end
                # Removes a related issue from a changeset
                # DELETE /projects/:project_id/repository/(:repository_id/)revisions/:rev/issues/:issue_id
                def remove_related_issue
                  @issue = Issue.visible.find_by_id(params[:issue_id])
                  if @issue
                    @changeset.issues.delete(@issue)
                  end
                end
                def diff
                  if params[:format] == 'diff'
                    @diff = @repository.diff(@path, @rev, @rev_to)
                    (show_error_not_found; return) unless @diff
                    filename = "changeset_r#{@rev}"
                    filename << "_r#{@rev_to}" if @rev_to
                    send_data @diff.join, :filename => "#{filename}.diff",
                                          :type => 'text/x-patch',
                                          :disposition => 'attachment'
                  else
                    @diff_type = params[:type] || User.current.pref[:diff_type] || 'inline'
                    @diff_type = 'inline' unless %w(inline sbs).include?(@diff_type)
                    # Save diff type as user preference
                    if User.current.logged? && @diff_type != User.current.pref[:diff_type]
                      User.current.pref[:diff_type] = @diff_type
                      User.current.preference.save
                    end
                    @cache_key = "repositories/diff/#{@repository.id}/" +
                                    Digest::MD5.hexdigest("#{@path}-#{@rev}-#{@rev_to}-#{@diff_type}-#{current_language}")
                    unless read_fragment(@cache_key)
                      @diff = @repository.diff(@path, @rev, @rev_to)
                      show_error_not_found unless @diff
                    end
                    @changeset = @repository.find_changeset_by_name(@rev)
                    @changeset_to = @rev_to ? @repository.find_changeset_by_name(@rev_to) : nil
                    @diff_format_revisions = @repository.diff_format_revisions(@changeset, @changeset_to)
                  end
                end
                def stats
                end
                def graph
                  data = nil
                  case params[:graph]
                  when "commits_per_month"
                    data = graph_commits_per_month(@repository)
                  when "commits_per_author"
                    data = graph_commits_per_author(@repository)
                  end
                  if data
                    headers["Content-Type"] = "image/svg+xml"
                    send_data(data, :type => "image/svg+xml", :disposition => "inline")
                  else
                    render_404
                  end
                end
                private
                def find_repository
                  @repository = Repository.find(params[:id])
                  @project = @repository.project
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                REV_PARAM_RE = %r{\A[a-f0-9]*\Z}i
                def find_project_repository
                  @project = Project.find(params[:id])
                  if params[:repository_id].present?
                    @repository = @project.repositories.find_by_identifier_param(params[:repository_id])
                  else
                    @repository = @project.repository
                  end
                  (render_404; return false) unless @repository
                  @path = params[:path].is_a?(Array) ? params[:path].join('/') : params[:path].to_s
                  @rev = params[:rev].blank? ? @repository.default_branch : params[:rev].to_s.strip
                  @rev_to = params[:rev_to]
                  unless @rev.to_s.match(REV_PARAM_RE) && @rev_to.to_s.match(REV_PARAM_RE)
                    if @repository.branches.blank?
                      raise InvalidRevisionParam
                    end
                  end
                rescue ActiveRecord::RecordNotFound
                  render_404
                rescue InvalidRevisionParam
                  show_error_not_found
                end
                def find_changeset
                  if @rev.present?
                    @changeset = @repository.find_changeset_by_name(@rev)
                  end
                  show_error_not_found unless @changeset
                end
                def show_error_not_found
                  render_error :message => l(:error_scm_not_found), :status => 404
                end
                # Handler for Redmine::Scm::Adapters::CommandFailed exception
                def show_error_command_failed(exception)
                  render_error l(:error_scm_command_failed, exception.message)
                end
                def graph_commits_per_month(repository)
                  @date_to = User.current.today
                  @date_from = @date_to << 11
                  @date_from = Date.civil(@date_from.year, @date_from.month, 1)
                  commits_by_day = Changeset.
                    where("repository_id = ? AND commit_date BETWEEN ? AND ?", repository.id, @date_from, @date_to).
                    group(:commit_date).
                    count
                  commits_by_month = [0] * 12
                  commits_by_day.each {|c| commits_by_month[(@date_to.month - c.first.to_date.month) % 12] += c.last }
                  changes_by_day = Change.
                    joins(:changeset).
                    where("#{Changeset.table_name}.repository_id = ? AND #{Changeset.table_name}.commit_date BETWEEN ? AND ?", repository.id, @date_from, @date_to).
                    group(:commit_date).
                    count
                  changes_by_month = [0] * 12
                  changes_by_day.each {|c| changes_by_month[(@date_to.month - c.first.to_date.month) % 12] += c.last }
                  fields = []
                  today = User.current.today
 .times {|m| fields << month_name(((today.month - 1 - m) % 12) + 1)}
                  graph = SVG::Graph::Bar.new(
                    :height => 300,
                    :width => 800,
                    :fields => fields.reverse,
                    :stack => :side,
                    :scale_integers => true,
                    :step_x_labels => 2,
                    :show_data_values => false,
                    :graph_title => l(:label_commits_per_month),
                    :show_graph_title => true
                  )
                  graph.add_data(
                    :data => commits_by_month[0..11].reverse,
                    :title => l(:label_revision_plural)
                  )
                  graph.add_data(
                    :data => changes_by_month[0..11].reverse,
                    :title => l(:label_change_plural)
                  )
                  graph.burn
                end
                def graph_commits_per_author(repository)
                  #data
                  stats = repository.stats_by_author
                  fields, commits_data, changes_data = [], [], []
                  stats.each do |name, hsh|
                    fields << name
                    commits_data << hsh[:commits_count]
                    changes_data << hsh[:changes_count]
                  end
                  #expand to 10 values if needed
                  fields = fields + [""]*(10 - fields.length) if fields.length<10
                  commits_data = commits_data + [0]*(10 - commits_data.length) if commits_data.length<10
                  changes_data = changes_data + [0]*(10 - changes_data.length) if changes_data.length<10
                  # Remove email address in usernames
                  fields = fields.collect {|c| c.gsub(%r{<.+@.+>}, '') }
                  #prepare graph
                  graph = SVG::Graph::BarHorizontal.new(
                    :height => 30 * commits_data.length,
                    :width => 800,
                    :fields => fields,
                    :stack => :side,
                    :scale_integers => true,
                    :show_data_values => false,
                    :rotate_y_labels => false,
                    :graph_title => l(:label_commits_per_author),
                    :show_graph_title => true
                  )
                  graph.add_data(
                    :data => commits_data,
                    :title => l(:label_revision_plural)
                  )
                  graph.add_data(
                    :data => changes_data,
                    :title => l(:label_change_plural)
                  )
                  graph.burn
                end
                def disposition(path)
                  if Redmine::MimeType.is_type?('image', @path) || Redmine::MimeType.of(@path) == "application/pdf"
                    'inline'
                  else
                    'attachment'
                  end
                end
              end

app/controllers/roles_controller.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 RolesController < ApplicationController
                layout 'admin'
                before_action :require_admin, :except => [:index, :show]
                before_action :require_admin_or_api_request, :only => [:index, :show]
                before_action :find_role, :only => [:show, :edit, :update, :destroy]
                accept_api_auth :index, :show
                require_sudo_mode :create, :update, :destroy
                def index
                  respond_to do |format|
                    format.html {
                      @roles = Role.sorted.to_a
                      render :layout => false if request.xhr?
                    }
                    format.api {
                      @roles = Role.givable.to_a
                    }
                  end
                end
                def show
                  respond_to do |format|
                    format.api
                  end
                end
                def new
                  # Prefills the form with 'Non member' role permissions by default
                  @role = Role.new
                  @role.safe_attributes = params[:role] || {:permissions => Role.non_member.permissions}
                  if params[:copy].present? && @copy_from = Role.find_by_id(params[:copy])
                    @role.copy_from(@copy_from)
                  end
                  @roles = Role.sorted.to_a
                end
                def create
                  @role = Role.new
                  @role.safe_attributes = params[:role]
                  if request.post? && @role.save
                    # workflow copy
                    if !params[:copy_workflow_from].blank? && (copy_from = Role.find_by_id(params[:copy_workflow_from]))
                      @role.workflow_rules.copy(copy_from)
                    end
                    flash[:notice] = l(:notice_successful_create)
                    redirect_to roles_path
                  else
                    @roles = Role.sorted.to_a
                    render :action => 'new'
                  end
                end
                def edit
                end
                def update
                  @role.safe_attributes = params[:role]
                  if @role.save
                    respond_to do |format|
                      format.html {
                        flash[:notice] = l(:notice_successful_update)
                        redirect_to roles_path(:page => params[:page])
                      }
-                     format.js { render :nothing => true }
+                     format.js { head 200 }
                    end
                  else
                    respond_to do |format|
                      format.html { render :action => 'edit' }
-                     format.js { render :nothing => true, :status => 422 }
+                     format.js { head 422 }
                    end
                  end
                end
                def destroy
                  @role.destroy
                  redirect_to roles_path
                rescue
                  flash[:error] =  l(:error_can_not_remove_role)
                  redirect_to roles_path
                end
                def permissions
                  @roles = Role.sorted.to_a
                  @permissions = Redmine::AccessControl.permissions.select { |p| !p.public? }
                  if request.post?
                    @roles.each do |role|
                      role.permissions = params[:permissions][role.id.to_s]
                      role.save
                    end
                    flash[:notice] = l(:notice_successful_update)
                    redirect_to roles_path
                  end
                end
                private
                def find_role
                  @role = Role.find(params[:id])
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
              end

app/controllers/sys_controller.rb +4 -4

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 SysController < ActionController::Base
                before_action :check_enabled
                def projects
                  p = Project.active.has_module(:repository).
                        order("#{Project.table_name}.identifier").preload(:repository).to_a
                  # extra_info attribute from repository breaks activeresource client
                  render :xml => p.to_xml(
                                     :only => [:id, :identifier, :name, :is_public, :status],
                                     :include => {:repository => {:only => [:id, :url]}}
                                   )
                end
                def create_project_repository
                  project = Project.find(params[:id])
                  if project.repository
-                   render :nothing => true, :status => 409
+                   head 409
                  else
                    logger.info "Repository for #{project.name} was reported to be created by #{request.remote_ip}."
                    repository = Repository.factory(params[:vendor], params[:repository])
                    repository.project = project
                    if repository.save
                      render :xml => {repository.class.name.underscore.gsub('/', '-') => {:id => repository.id, :url => repository.url}}, :status => 201
                    else
-                     render :nothing => true, :status => 422
+                     head 422
                    end
                  end
                end
                def fetch_changesets
                  projects = []
                  scope = Project.active.has_module(:repository)
                  if params[:id]
                    project = nil
                    if params[:id].to_s =~ /^\d*$/
                      project = scope.find(params[:id])
                    else
                      project = scope.find_by_identifier(params[:id])
                    end
                    raise ActiveRecord::RecordNotFound unless project
                    projects << project
                  else
                    projects = scope.to_a
                  end
                  projects.each do |project|
                    project.repositories.each do |repository|
                      repository.fetch_changesets
                    end
                  end
-                 render :nothing => true, :status => 200
+                 head 200
                rescue ActiveRecord::RecordNotFound
-                 render :nothing => true, :status => 404
+                 head 404
                end
                protected
                def check_enabled
                  User.current = nil
                  unless Setting.sys_api_enabled? && params[:key].to_s == Setting.sys_api_key
                    render :text => 'Access denied. Repository management WS is disabled or key is invalid.', :status => 403
                    return false
                  end
                end
              end

app/controllers/timelog_controller.rb +1 -1

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 TimelogController < ApplicationController
                menu_item :issues
                before_action :find_time_entry, :only => [:show, :edit, :update]
                before_action :find_time_entries, :only => [:bulk_edit, :bulk_update, :destroy]
                before_action :authorize, :only => [:show, :edit, :update, :bulk_edit, :bulk_update, :destroy]
                before_action :find_optional_issue, :only => [:new, :create]
                before_action :find_optional_project, :only => [:index, :report]
                before_action :authorize_global, :only => [:new, :create, :index, :report]
                accept_rss_auth :index
                accept_api_auth :index, :show, :create, :update, :destroy
                rescue_from Query::StatementInvalid, :with => :query_statement_invalid
                helper :sort
                include SortHelper
                helper :issues
                include TimelogHelper
                helper :custom_fields
                include CustomFieldsHelper
                helper :queries
                include QueriesHelper
                def index
                  retrieve_time_entry_query
                  sort_init(@query.sort_criteria.empty? ? [['spent_on', 'desc']] : @query.sort_criteria)
                  sort_update(@query.sortable_columns)
                  scope = time_entry_scope(:order => sort_clause).
                    includes(:project, :user, :issue).
                    preload(:issue => [:project, :tracker, :status, :assigned_to, :priority])
                  respond_to do |format|
                    format.html {
                      @entry_count = scope.count
                      @entry_pages = Paginator.new @entry_count, per_page_option, params['page']
                      @entries = scope.offset(@entry_pages.offset).limit(@entry_pages.per_page).to_a
                      render :layout => !request.xhr?
                    }
                    format.api  {
                      @entry_count = scope.count
                      @offset, @limit = api_offset_and_limit
                      @entries = scope.offset(@offset).limit(@limit).preload(:custom_values => :custom_field).to_a
                    }
                    format.atom {
                      entries = scope.limit(Setting.feeds_limit.to_i).reorder("#{TimeEntry.table_name}.created_on DESC").to_a
                      render_feed(entries, :title => l(:label_spent_time))
                    }
                    format.csv {
                      # Export all entries
                      @entries = scope.to_a
                      send_data(query_to_csv(@entries, @query, params), :type => 'text/csv; header=present', :filename => 'timelog.csv')
                    }
                  end
                end
                def report
                  retrieve_time_entry_query
                  scope = time_entry_scope
                  @report = Redmine::Helpers::TimeReport.new(@project, @issue, params[:criteria], params[:columns], scope)
                  respond_to do |format|
                    format.html { render :layout => !request.xhr? }
                    format.csv  { send_data(report_to_csv(@report), :type => 'text/csv; header=present', :filename => 'timelog.csv') }
                  end
                end
                def show
                  respond_to do |format|
                    # TODO: Implement html response
-                   format.html { render :nothing => true, :status => 406 }
+                   format.html { head 406 }
                    format.api
                  end
                end
                def new
                  @time_entry ||= TimeEntry.new(:project => @project, :issue => @issue, :user => User.current, :spent_on => User.current.today)
                  @time_entry.safe_attributes = params[:time_entry]
                end
                def create
                  @time_entry ||= TimeEntry.new(:project => @project, :issue => @issue, :user => User.current, :spent_on => User.current.today)
                  @time_entry.safe_attributes = params[:time_entry]
                  if @time_entry.project && !User.current.allowed_to?(:log_time, @time_entry.project)
                    render_403
                    return
                  end
                  call_hook(:controller_timelog_edit_before_save, { :params => params, :time_entry => @time_entry })
                  if @time_entry.save
                    respond_to do |format|
                      format.html {
                        flash[:notice] = l(:notice_successful_create)
                        if params[:continue]
                          options = {
                            :time_entry => {
                              :project_id => params[:time_entry][:project_id],
                              :issue_id => @time_entry.issue_id,
                              :activity_id => @time_entry.activity_id
                            },
                            :back_url => params[:back_url]
                          }
                          if params[:project_id] && @time_entry.project
                            redirect_to new_project_time_entry_path(@time_entry.project, options)
                          elsif params[:issue_id] && @time_entry.issue
                            redirect_to new_issue_time_entry_path(@time_entry.issue, options)
                          else
                            redirect_to new_time_entry_path(options)
                          end
                        else
                          redirect_back_or_default project_time_entries_path(@time_entry.project)
                        end
                      }
                      format.api  { render :action => 'show', :status => :created, :location => time_entry_url(@time_entry) }
                    end
                  else
                    respond_to do |format|
                      format.html { render :action => 'new' }
                      format.api  { render_validation_errors(@time_entry) }
                    end
                  end
                end
                def edit
                  @time_entry.safe_attributes = params[:time_entry]
                end
                def update
                  @time_entry.safe_attributes = params[:time_entry]
                  call_hook(:controller_timelog_edit_before_save, { :params => params, :time_entry => @time_entry })
                  if @time_entry.save
                    respond_to do |format|
                      format.html {
                        flash[:notice] = l(:notice_successful_update)
                        redirect_back_or_default project_time_entries_path(@time_entry.project)
                      }
                      format.api  { render_api_ok }
                    end
                  else
                    respond_to do |format|
                      format.html { render :action => 'edit' }
                      format.api  { render_validation_errors(@time_entry) }
                    end
                  end
                end
                def bulk_edit
                  @available_activities = TimeEntryActivity.shared.active
                  @custom_fields = TimeEntry.first.available_custom_fields
                end
                def bulk_update
                  attributes = parse_params_for_bulk_update(params[:time_entry])
                  unsaved_time_entry_ids = []
                  @time_entries.each do |time_entry|
                    time_entry.reload
                    time_entry.safe_attributes = attributes
                    call_hook(:controller_time_entries_bulk_edit_before_save, { :params => params, :time_entry => time_entry })
                    unless time_entry.save
                      logger.info "time entry could not be updated: #{time_entry.errors.full_messages}" if logger && logger.info?
                      # Keep unsaved time_entry ids to display them in flash error
                      unsaved_time_entry_ids << time_entry.id
                    end
                  end
                  set_flash_from_bulk_time_entry_save(@time_entries, unsaved_time_entry_ids)
                  redirect_back_or_default project_time_entries_path(@projects.first)
                end
                def destroy
                  destroyed = TimeEntry.transaction do
                    @time_entries.each do |t|
                      unless t.destroy && t.destroyed?
                        raise ActiveRecord::Rollback
                      end
                    end
                  end
                  respond_to do |format|
                    format.html {
                      if destroyed
                        flash[:notice] = l(:notice_successful_delete)
                      else
                        flash[:error] = l(:notice_unable_delete_time_entry)
                      end
                      redirect_back_or_default project_time_entries_path(@projects.first)
                    }
                    format.api  {
                      if destroyed
                        render_api_ok
                      else
                        render_validation_errors(@time_entries)
                      end
                    }
                  end
                end
              private
                def find_time_entry
                  @time_entry = TimeEntry.find(params[:id])
                  unless @time_entry.editable_by?(User.current)
                    render_403
                    return false
                  end
                  @project = @time_entry.project
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def find_time_entries
                  @time_entries = TimeEntry.where(:id => params[:id] || params[:ids]).to_a
                  raise ActiveRecord::RecordNotFound if @time_entries.empty?
                  raise Unauthorized unless @time_entries.all? {|t| t.editable_by?(User.current)}
                  @projects = @time_entries.collect(&:project).compact.uniq
                  @project = @projects.first if @projects.size == 1
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def set_flash_from_bulk_time_entry_save(time_entries, unsaved_time_entry_ids)
                  if unsaved_time_entry_ids.empty?
                    flash[:notice] = l(:notice_successful_update) unless time_entries.empty?
                  else
                    flash[:error] = l(:notice_failed_to_save_time_entries,
                                      :count => unsaved_time_entry_ids.size,
                                      :total => time_entries.size,
                                      :ids => '#' + unsaved_time_entry_ids.join(', #'))
                  end
                end
                def find_optional_issue
                  if params[:issue_id].present?
                    @issue = Issue.find(params[:issue_id])
                    @project = @issue.project
                  else
                    find_optional_project
                  end
                end
                def find_optional_project
                  if params[:project_id].present?
                    @project = Project.find(params[:project_id])
                  end
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                # Returns the TimeEntry scope for index and report actions
                def time_entry_scope(options={})
                  @query.results_scope(options)
                end
                def retrieve_time_entry_query
                  retrieve_query(TimeEntryQuery, false)
                end
              end

app/controllers/trackers_controller.rb +2 -2

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 TrackersController < ApplicationController
                layout 'admin'
                before_action :require_admin, :except => :index
                before_action :require_admin_or_api_request, :only => :index
                accept_api_auth :index
                def index
                  @trackers = Tracker.sorted.to_a
                  respond_to do |format|
                    format.html { render :layout => false if request.xhr? }
                    format.api
                  end
                end
                def new
                  @tracker ||= Tracker.new
                  @tracker.safe_attributes = params[:tracker]
                  @trackers = Tracker.sorted.to_a
                  @projects = Project.all
                end
                def create
                  @tracker = Tracker.new
                  @tracker.safe_attributes = params[:tracker]
                  if @tracker.save
                    # workflow copy
                    if !params[:copy_workflow_from].blank? && (copy_from = Tracker.find_by_id(params[:copy_workflow_from]))
                      @tracker.workflow_rules.copy(copy_from)
                    end
                    flash[:notice] = l(:notice_successful_create)
                    redirect_to trackers_path
                    return
                  end
                  new
                  render :action => 'new'
                end
                def edit
                  @tracker ||= Tracker.find(params[:id])
                  @projects = Project.all
                end
                def update
                  @tracker = Tracker.find(params[:id])
                  @tracker.safe_attributes = params[:tracker]
                  if @tracker.save
                    respond_to do |format|
                      format.html {
                        flash[:notice] = l(:notice_successful_update)
                        redirect_to trackers_path(:page => params[:page])
                      }
-                     format.js { render :nothing => true }
+                     format.js { head 200 }
                    end
                  else
                    respond_to do |format|
                      format.html {
                        edit
                        render :action => 'edit'
                      }
-                     format.js { render :nothing => true, :status => 422 }
+                     format.js { head 422 }
                    end
                  end
                end
                def destroy
                  @tracker = Tracker.find(params[:id])
                  unless @tracker.issues.empty?
                    flash[:error] = l(:error_can_not_delete_tracker)
                  else
                    @tracker.destroy
                  end
                  redirect_to trackers_path
                end
                def fields
                  if request.post? && params[:trackers]
                    params[:trackers].each do |tracker_id, tracker_params|
                      tracker = Tracker.find_by_id(tracker_id)
                      if tracker
                        tracker.core_fields = tracker_params[:core_fields]
                        tracker.custom_field_ids = tracker_params[:custom_field_ids]
                        tracker.save
                      end
                    end
                    flash[:notice] = l(:notice_successful_update)
                    redirect_to fields_trackers_path
                    return
                  end
                  @trackers = Tracker.sorted.to_a
                  @custom_fields = IssueCustomField.all.sort
                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