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