jro_apps/redmine Commit - r11175:7799788b3de6

Fixed that updating the issue form was broken by r4011 when user is not allowed to add issues (#13188)....

Jean-Philippe Lang -

r11175:7799788b3de6

parent child

Context file:

r11175:7799788b3de6

Collapse all files

The requested changes are too big and content was truncated. Show full diff

app/controllers/issues_controller.rb +7 -3

             # Redmine - project management software
             # Copyright (C) 2006-2013  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class IssuesController < ApplicationController
               menu_item :new_issue, :only => [:new, :create]
               default_search_scope :issues
               before_filter :find_issue, :only => [:show, :edit, :update]
               before_filter :find_issues, :only => [:bulk_edit, :bulk_update, :destroy]
-              before_filter :find_project, :only => [:new, :create]
+              before_filter :find_project, :only => [:new, :create, :update_form]
               before_filter :authorize, :except => [:index]
               before_filter :find_optional_project, :only => [:index]
               before_filter :check_for_default_issue_status, :only => [:new, :create]
-              before_filter :build_new_issue_from_params, :only => [:new, :create]
+              before_filter :build_new_issue_from_params, :only => [:new, :create, :update_form]
               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
               include ProjectsHelper
               helper :custom_fields
               include CustomFieldsHelper
               helper :issue_relations
               include IssueRelationsHelper
               helper :watchers
               include WatchersHelper
               helper :attachments
               include AttachmentsHelper
               helper :queries
               include QueriesHelper
               helper :repositories
               include RepositoriesHelper
               helper :sort
               include SortHelper
               include IssuesHelper
               helper :timelog
               include Redmine::Export::PDF
               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
                   when 'atom'
                     @limit = Setting.feeds_limit.to_i
                   when 'xml', 'json'
                     @offset, @limit = api_offset_and_limit
                   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(issues_to_csv(@issues, @project, @query, params), :type => 'text/csv; header=present', :filename => 'export.csv') }
                     format.pdf  { send_data(issues_to_pdf(@issues, @project, @query), :type => 'application/pdf', :filename => 'export.pdf') }
                   end
                 else
                   respond_to do |format|
                     format.html { render(:template => 'issues/index', :layout => !request.xhr?) }
                     format.any(:atom, :csv, :pdf) { render(:nothing => true) }
                     format.api { render_validation_errors(@query) }
                   end
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def show
                 @journals = @issue.journals.includes(:user, :details).reorder("#{Journal.table_name}.id ASC").all
                 @journals.each_with_index {|j,i| j.indice = i+1}
                 @journals.reject!(&:private_notes?) unless User.current.allowed_to?(:view_private_notes, @issue.project)
                 @journals.reverse! if User.current.wants_comments_in_reverse_order?
                 @changesets = @issue.changesets.visible.all
                 @changesets.reverse! if User.current.wants_comments_in_reverse_order?
                 @relations = @issue.relations.select {|r| r.other_issue(@issue) && r.other_issue(@issue).visible? }
                 @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                 @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
                 @priorities = IssuePriority.active
                 @time_entry = TimeEntry.new(:issue => @issue, :project => @issue.project)
                 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  {
                     pdf = issue_to_pdf(@issue, :journals => @journals)
                     send_data(pdf, :type => 'application/pdf', :filename => "#{@project.identifier}-#{@issue.id}.pdf")
                   }
                 end
               end
               # Add a new issue
               # The new issue will be created from an existing one if copy_from parameter is given
               def new
                 respond_to do |format|
                   format.html { render :action => 'new', :layout => !request.xhr? }
-                  format.js { render :partial => 'update_form' }
                 end
               end
               def create
                 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))
                       if params[:continue]
                         attrs = {:tracker_id => @issue.tracker, :parent_issue_id => @issue.parent_issue_id}.reject {|k,v| v.nil?}
                         redirect_to new_project_issue_path(@issue.project, :issue => attrs)
                       else
                         redirect_to issue_path(@issue)
                       end
                     }
                     format.api  { render :action => 'show', :status => :created, :location => issue_url(@issue) }
                   end
                   return
                 else
                   respond_to do |format|
                     format.html { render :action => 'new' }
                     format.api  { render_validation_errors(@issue) }
                   end
                 end
               end
               def edit
                 return unless update_issue_from_params
                 respond_to do |format|
                   format.html { }
                   format.xml  { }
                 end
               end
               def update
                 return unless update_issue_from_params
                 @issue.save_attachments(params[:attachments] || (params[:issue] && params[:issue][:uploads]))
                 saved = false
                 begin
                   saved = @issue.save_issue_with_child_records(params, @time_entry)
                 rescue ActiveRecord::StaleObjectError
                   @conflict = true
                   if params[:last_journal_id]
                     @conflict_journals = @issue.journals_after(params[:last_journal_id]).all
                     @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) }
                     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
+              # Updates the issue form when changing the project, status or tracker
+              # on issue creation/update
+              def update_form
+              end
               # Bulk edit/copy a set of issues
               def bulk_edit
                 @issues.sort!
                 @copy = params[:copy].present?
                 @notes = params[:notes]
                 if User.current.allowed_to?(:move_issues, @projects)
                   @allowed_projects = Issue.allowed_target_projects_on_move
                   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
                 end
                 target_projects ||= @projects
                 if @copy
                   @available_statuses = [IssueStatus.default]
                 else
                   @available_statuses = @issues.map(&:new_statuses_allowed_to).reduce(:&)
                 end
                 @custom_fields = target_projects.map{|p|p.all_issue_custom_fields}.reduce(:&)
                 @assignables = target_projects.map(&:assignable_users).reduce(:&)
                 @trackers = target_projects.map(&:trackers).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(:&)
                 render :layout => false if request.xhr?
               end
               def bulk_update
                 @issues.sort!
                 @copy = params[:copy].present?
                 attributes = parse_params_for_bulk_issue_attributes(params)
                 unsaved_issue_ids = []
                 moved_issues = []
                 if @copy && params[:copy_subtasks].present?
                   # 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 |issue|
                   issue.reload
                   if @copy
                     issue = issue.copy({},
                       :attachments => params[:copy_attachments].present?,
                       :subtasks => params[:copy_subtasks].present?
                     )
                   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
                     moved_issues << issue
                   else
                     # Keep unsaved issue ids to display them in flash error
                     unsaved_issue_ids << issue.id
                   end
                 end
                 set_flash_from_bulk_issue_save(@issues, unsaved_issue_ids)
                 if params[:follow]
                   if @issues.size == 1 && moved_issues.size == 1
                     redirect_to issue_path(moved_issues.first)
                   elsif moved_issues.map(&:project).uniq.size == 1
                     redirect_to project_issues_path(moved_issues.map(&:project).first)
                   end
                 else
                   redirect_back_or_default _project_issues_path(@project)
                 end
               end
               def destroy
                 @hours = TimeEntry.sum(:hours, :conditions => ['issue_id IN (?)', @issues]).to_f
                 if @hours > 0
                   case params[:todo]
                   when 'destroy'
                     # nothing to do
                   when 'nullify'
                     TimeEntry.update_all('issue_id = NULL', ['issue_id IN (?)', @issues])
                   when 'reassign'
                     reassign_to = @project.issues.find_by_id(params[:reassign_to_id])
                     if reassign_to.nil?
                       flash.now[:error] = l(:error_issue_not_found_in_project)
                       return
                     else
                       TimeEntry.update_all("issue_id = #{reassign_to.id}", ['issue_id IN (?)', @issues])
                     end
                   else
                     # display the destroy form if it's a user request
                     return unless api_request?
                   end
                 end
                 @issues.each 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
               private
               def find_project
                 project_id = params[:project_id] || (params[:issue] && params[:issue][:project_id])
                 @project = Project.find(project_id)
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def retrieve_previous_and_next_issue_ids
                 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
               # Used by #edit and #update to set some common instance variables
               # from the params
               # TODO: Refactor, not everything in here is needed by #edit
               def update_issue_from_params
                 @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
                 @time_entry = TimeEntry.new(:issue => @issue, :project => @issue.project)
                 @time_entry.attributes = params[:time_entry]
                 @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)
                   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
               # TODO: Refactor, lots of extra code in here
               # TODO: Changing tracker on an existing issue should not trigger this
               def build_new_issue_from_params
                 if params[:id].blank?
                   @issue = Issue.new
                   if params[:copy_from]
                     begin
                       @copy_from = Issue.visible.find(params[:copy_from])
                       @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)
                     rescue ActiveRecord::RecordNotFound
                       render_404
                       return
                     end
                   end
                   @issue.project = @project
                 else
                   @issue = @project.issues.visible.find(params[:id])
                 end
                 @issue.project = @project
                 @issue.author ||= User.current
                 # Tracker must be set before custom field values
                 @issue.tracker ||= @project.trackers.find((params[:issue] && params[:issue][:tracker_id]) || params[:tracker_id] || :first)
                 if @issue.tracker.nil?
                   render_error l(:error_no_tracker_in_project)
                   return false
                 end
                 @issue.start_date ||= Date.today if Setting.default_issue_start_date_to_creation_date?
                 @issue.safe_attributes = params[:issue]
                 @priorities = IssuePriority.active
                 @allowed_statuses = @issue.new_statuses_allowed_to(User.current, true)
                 @available_watchers = (@issue.project.users.sort + @issue.watcher_users).uniq
               end
               def check_for_default_issue_status
                 if IssueStatus.default.nil?
                   render_error l(:error_no_default_issue_status)
                   return false
                 end
               end
               def parse_params_for_bulk_issue_attributes(params)
                 attributes = (params[:issue] || {}).reject {|k,v| v.blank?}
                 attributes.keys.each {|k| attributes[k] = '' if attributes[k] == 'none'}
                 if custom = attributes[:custom_field_values]
                   custom.reject! {|k,v| v.blank?}
                   custom.keys.each do |k|
                     if custom[k].is_a?(Array)
                       custom[k] << '' if custom[k].delete('__none__')
                     else
                       custom[k] = '' if custom[k] == '__none__'
                     end
                   end
                 end
                 attributes
               end
             end

app/views/issues/update_form.js.erb ~~app/views/issues/_update_form.js.erb~~ renamed 0 0

NO CONTENT: file renamed from app/views/issues/_update_form.js.erb to app/views/issues/update_form.js.erb

config/routes.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2013  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.
             RedmineApp::Application.routes.draw do
               root :to => 'welcome#index', :as => 'home'
               match 'login', :to => 'account#login', :as => 'signin', :via => [:get, :post]
               match 'logout', :to => 'account#logout', :as => 'signout', :via => [:get, :post]
               match 'account/register', :to => 'account#register', :via => [:get, :post], :as => 'register'
               match 'account/lost_password', :to => 'account#lost_password', :via => [:get, :post], :as => 'lost_password'
               match 'account/activate', :to => 'account#activate', :via => :get
               match '/news/preview', :controller => 'previews', :action => 'news', :as => 'preview_news', :via => [:get, :post, :put]
               match '/issues/preview/new/:project_id', :to => 'previews#issue', :as => 'preview_new_issue', :via => [:get, :post, :put]
               match '/issues/preview/edit/:id', :to => 'previews#issue', :as => 'preview_edit_issue', :via => [:get, :post, :put]
               match '/issues/preview', :to => 'previews#issue', :as => 'preview_issue', :via => [:get, :post, :put]
               match 'projects/:id/wiki', :to => 'wikis#edit', :via => :post
               match 'projects/:id/wiki/destroy', :to => 'wikis#destroy', :via => [:get, :post]
               match 'boards/:board_id/topics/new', :to => 'messages#new', :via => [:get, :post], :as => 'new_board_message'
               get 'boards/:board_id/topics/:id', :to => 'messages#show', :as => 'board_message'
               match 'boards/:board_id/topics/quote/:id', :to => 'messages#quote', :via => [:get, :post]
               get 'boards/:board_id/topics/:id/edit', :to => 'messages#edit'
               post 'boards/:board_id/topics/preview', :to => 'messages#preview', :as => 'preview_board_message'
               post 'boards/:board_id/topics/:id/replies', :to => 'messages#reply'
               post 'boards/:board_id/topics/:id/edit', :to => 'messages#edit'
               post 'boards/:board_id/topics/:id/destroy', :to => 'messages#destroy'
               # Misc issue routes. TODO: move into resources
               match '/issues/auto_complete', :to => 'auto_completes#issues', :via => :get, :as => 'auto_complete_issues'
               match '/issues/context_menu', :to => 'context_menus#issues', :as => 'issues_context_menu', :via => [:get, :post]
               match '/issues/changes', :to => 'journals#index', :as => 'issue_changes', :via => :get
               match '/issues/:id/quoted', :to => 'journals#new', :id => /\d+/, :via => :post, :as => 'quoted_issue'
               match '/journals/diff/:id', :to => 'journals#diff', :id => /\d+/, :via => :get
               match '/journals/edit/:id', :to => 'journals#edit', :id => /\d+/, :via => [:get, :post]
               get '/projects/:project_id/issues/gantt', :to => 'gantts#show', :as => 'project_gantt'
               get '/issues/gantt', :to => 'gantts#show'
               get '/projects/:project_id/issues/calendar', :to => 'calendars#show', :as => 'project_calendar'
               get '/issues/calendar', :to => 'calendars#show'
               get 'projects/:id/issues/report', :to => 'reports#issue_report', :as => 'project_issues_report'
               get 'projects/:id/issues/report/:detail', :to => 'reports#issue_report_details', :as => 'project_issues_report_details'
               match 'my/account', :controller => 'my', :action => 'account', :via => [:get, :post]
               match 'my/account/destroy', :controller => 'my', :action => 'destroy', :via => [:get, :post]
               match 'my/page', :controller => 'my', :action => 'page', :via => :get
               match 'my', :controller => 'my', :action => 'index', :via => :get # Redirects to my/page
               match 'my/reset_rss_key', :controller => 'my', :action => 'reset_rss_key', :via => :post
               match 'my/reset_api_key', :controller => 'my', :action => 'reset_api_key', :via => :post
               match 'my/password', :controller => 'my', :action => 'password', :via => [:get, :post]
               match 'my/page_layout', :controller => 'my', :action => 'page_layout', :via => :get
               match 'my/add_block', :controller => 'my', :action => 'add_block', :via => :post
               match 'my/remove_block', :controller => 'my', :action => 'remove_block', :via => :post
               match 'my/order_blocks', :controller => 'my', :action => 'order_blocks', :via => :post
               resources :users
               match 'users/:id/memberships/:membership_id', :to => 'users#edit_membership', :via => :put, :as => 'user_membership'
               match 'users/:id/memberships/:membership_id', :to => 'users#destroy_membership', :via => :delete
               match 'users/:id/memberships', :to => 'users#edit_membership', :via => :post, :as => 'user_memberships'
               post 'watchers/watch', :to => 'watchers#watch', :as => 'watch'
               delete 'watchers/watch', :to => 'watchers#unwatch'
               get 'watchers/new', :to => 'watchers#new'
               post 'watchers', :to => 'watchers#create'
               post 'watchers/append', :to => 'watchers#append'
               post 'watchers/destroy', :to => 'watchers#destroy'
               get 'watchers/autocomplete_for_user', :to => 'watchers#autocomplete_for_user'
               # Specific routes for issue watchers API
               post 'issues/:object_id/watchers', :to => 'watchers#create', :object_type => 'issue'
               delete 'issues/:object_id/watchers/:user_id' => 'watchers#destroy', :object_type => 'issue'
               resources :projects do
                 member do
                   get 'settings(/:tab)', :action => 'settings', :as => 'settings'
                   post 'modules'
                   post 'archive'
                   post 'unarchive'
                   post 'close'
                   post 'reopen'
                   match 'copy', :via => [:get, :post]
                 end
                 resources :memberships, :shallow => true, :controller => 'members', :only => [:index, :show, :new, :create, :update, :destroy] do
                   collection do
                     get 'autocomplete'
                   end
                 end
                 resource :enumerations, :controller => 'project_enumerations', :only => [:update, :destroy]
                 get 'issues/:copy_from/copy', :to => 'issues#new', :as => 'copy_issue'
                 resources :issues, :only => [:index, :new, :create] do
                   resources :time_entries, :controller => 'timelog' do
                     collection do
                       get 'report'
                     end
                   end
                 end
                 # issue form update
-                match 'issues/new', :controller => 'issues', :action => 'new', :via => [:put, :post], :as => 'issue_form'
+                match 'issues/update_form', :controller => 'issues', :action => 'update_form', :via => [:put, :post], :as => 'issue_form'
                 resources :files, :only => [:index, :new, :create]
                 resources :versions, :except => [:index, :show, :edit, :update, :destroy] do
                   collection do
                     put 'close_completed'
                   end
                 end
                 get 'versions.:format', :to => 'versions#index'
                 get 'roadmap', :to => 'versions#index', :format => false
                 get 'versions', :to => 'versions#index'
                 resources :news, :except => [:show, :edit, :update, :destroy]
                 resources :time_entries, :controller => 'timelog' do
                   get 'report', :on => :collection
                 end
                 resources :queries, :only => [:new, :create]
                 resources :issue_categories, :shallow => true
                 resources :documents, :except => [:show, :edit, :update, :destroy]
                 resources :boards
                 resources :repositories, :shallow => true, :except => [:index, :show] do
                   member do
                     match 'committers', :via => [:get, :post]
                   end
                 end
                 match 'wiki/index', :controller => 'wiki', :action => 'index', :via => :get
                 resources :wiki, :except => [:index, :new, :create], :as => 'wiki_page' do
                   member do
                     get 'rename'
                     post 'rename'
                     get 'history'
                     get 'diff'
                     match 'preview', :via => [:post, :put]
                     post 'protect'
                     post 'add_attachment'
                   end
                   collection do
                     get 'export'
                     get 'date_index'
                   end
                 end
                 match 'wiki', :controller => 'wiki', :action => 'show', :via => :get
                 get 'wiki/:id/:version', :to => 'wiki#show', :constraints => {:version => /\d+/}
                 delete 'wiki/:id/:version', :to => 'wiki#destroy_version'
                 get 'wiki/:id/:version/annotate', :to => 'wiki#annotate'
                 get 'wiki/:id/:version/diff', :to => 'wiki#diff'
               end
               resources :issues do
                 collection do
                   match 'bulk_edit', :via => [:get, :post]
                   post 'bulk_update'
                 end
                 resources :time_entries, :controller => 'timelog' do
                   collection do
                     get 'report'
                   end
                 end
                 resources :relations, :shallow => true, :controller => 'issue_relations', :only => [:index, :show, :create, :destroy]
               end
               match '/issues', :controller => 'issues', :action => 'destroy', :via => :delete
               resources :queries, :except => [:show]
               resources :news, :only => [:index, :show, :edit, :update, :destroy]
               match '/news/:id/comments', :to => 'comments#create', :via => :post
               match '/news/:id/comments/:comment_id', :to => 'comments#destroy', :via => :delete
               resources :versions, :only => [:show, :edit, :update, :destroy] do
                 post 'status_by', :on => :member
               end
               resources :documents, :only => [:show, :edit, :update, :destroy] do
                 post 'add_attachment', :on => :member
               end
               match '/time_entries/context_menu', :to => 'context_menus#time_entries', :as => :time_entries_context_menu, :via => [:get, :post]
               resources :time_entries, :controller => 'timelog', :except => :destroy do
                 collection do
                   get 'report'
                   get 'bulk_edit'
                   post 'bulk_update'
                 end
               end
               match '/time_entries/:id', :to => 'timelog#destroy', :via => :delete, :id => /\d+/
               # TODO: delete /time_entries for bulk deletion
               match '/time_entries/destroy', :to => 'timelog#destroy', :via => :delete
               get 'projects/:id/activity', :to => 'activities#index'
               get 'projects/:id/activity.:format', :to => 'activities#index'
               get 'activity', :to => 'activities#index'
               # repositories routes
               get 'projects/:id/repository/:repository_id/statistics', :to => 'repositories#stats'
               get 'projects/:id/repository/:repository_id/graph', :to => 'repositories#graph'
               get 'projects/:id/repository/:repository_id/changes(/*path(.:ext))',
                   :to => 'repositories#changes'
               get 'projects/:id/repository/:repository_id/revisions/:rev', :to => 'repositories#revision'
               get 'projects/:id/repository/:repository_id/revision', :to => 'repositories#revision'
               post   'projects/:id/repository/:repository_id/revisions/:rev/issues', :to => 'repositories#add_related_issue'
               delete 'projects/:id/repository/:repository_id/revisions/:rev/issues/:issue_id', :to => 'repositories#remove_related_issue'
               get 'projects/:id/repository/:repository_id/revisions', :to => 'repositories#revisions'
               get 'projects/:id/repository/:repository_id/revisions/:rev/:action(/*path(.:ext))',
                   :controller => 'repositories',
                   :format => false,
                   :constraints => {
                         :action => /(browse|show|entry|raw|annotate|diff)/,
                         :rev    => /[a-z0-9\.\-_]+/
                       }
               get 'projects/:id/repository/statistics', :to => 'repositories#stats'
               get 'projects/:id/repository/graph', :to => 'repositories#graph'
               get 'projects/:id/repository/changes(/*path(.:ext))',
                   :to => 'repositories#changes'
               get 'projects/:id/repository/revisions', :to => 'repositories#revisions'
               get 'projects/:id/repository/revisions/:rev', :to => 'repositories#revision'
               get 'projects/:id/repository/revision', :to => 'repositories#revision'
               post   'projects/:id/repository/revisions/:rev/issues', :to => 'repositories#add_related_issue'
               delete 'projects/:id/repository/revisions/:rev/issues/:issue_id', :to => 'repositories#remove_related_issue'
               get 'projects/:id/repository/revisions/:rev/:action(/*path(.:ext))',
                   :controller => 'repositories',
                   :format => false,
                   :constraints => {
                         :action => /(browse|show|entry|raw|annotate|diff)/,
                         :rev    => /[a-z0-9\.\-_]+/
                       }
               get 'projects/:id/repository/:repository_id/:action(/*path(.:ext))',
                   :controller => 'repositories',
                   :action => /(browse|show|entry|raw|changes|annotate|diff)/
               get 'projects/:id/repository/:action(/*path(.:ext))',
                   :controller => 'repositories',
                   :action => /(browse|show|entry|raw|changes|annotate|diff)/
               get 'projects/:id/repository/:repository_id', :to => 'repositories#show', :path => nil
               get 'projects/:id/repository', :to => 'repositories#show', :path => nil
               # additional routes for having the file name at the end of url
               get 'attachments/:id/:filename', :to => 'attachments#show', :id => /\d+/, :filename => /.*/, :as => 'named_attachment'
               get 'attachments/download/:id/:filename', :to => 'attachments#download', :id => /\d+/, :filename => /.*/, :as => 'download_named_attachment'
               get 'attachments/download/:id', :to => 'attachments#download', :id => /\d+/
               get 'attachments/thumbnail/:id(/:size)', :to => 'attachments#thumbnail', :id => /\d+/, :size => /\d+/, :as => 'thumbnail'
               resources :attachments, :only => [:show, :destroy]
               resources :groups do
                 member do
                   get 'autocomplete_for_user'
                 end
               end
               match 'groups/:id/users', :controller => 'groups', :action => 'add_users', :id => /\d+/, :via => :post, :as => 'group_users'
               match 'groups/:id/users/:user_id', :controller => 'groups', :action => 'remove_user', :id => /\d+/, :via => :delete, :as => 'group_user'
               match 'groups/destroy_membership/:id', :controller => 'groups', :action => 'destroy_membership', :id => /\d+/, :via => :post
               match 'groups/edit_membership/:id', :controller => 'groups', :action => 'edit_membership', :id => /\d+/, :via => :post
               resources :trackers, :except => :show do
                 collection do
                   match 'fields', :via => [:get, :post]
                 end
               end
               resources :issue_statuses, :except => :show do
                 collection do
                   post 'update_issue_done_ratio'
                 end
               end
               resources :custom_fields, :except => :show
               resources :roles do
                 collection do
                   match 'permissions', :via => [:get, :post]
                 end
               end
               resources :enumerations, :except => :show
               match 'enumerations/:type', :to => 'enumerations#index', :via => :get
               get 'projects/:id/search', :controller => 'search', :action => 'index'
               get 'search', :controller => 'search', :action => 'index'
               match 'mail_handler', :controller => 'mail_handler', :action => 'index', :via => :post
               match 'admin', :controller => 'admin', :action => 'index', :via => :get
               match 'admin/projects', :controller => 'admin', :action => 'projects', :via => :get
               match 'admin/plugins', :controller => 'admin', :action => 'plugins', :via => :get
               match 'admin/info', :controller => 'admin', :action => 'info', :via => :get
               match 'admin/test_email', :controller => 'admin', :action => 'test_email', :via => :get
               match 'admin/default_configuration', :controller => 'admin', :action => 'default_configuration', :via => :post
               resources :auth_sources do
                 member do
                   get 'test_connection', :as => 'try_connection'
                 end
                 collection do
                   get 'autocomplete_for_new_user'
                 end
               end
               match 'workflows', :controller => 'workflows', :action => 'index', :via => :get
               match 'workflows/edit', :controller => 'workflows', :action => 'edit', :via => [:get, :post]
               match 'workflows/permissions', :controller => 'workflows', :action => 'permissions', :via => [:get, :post]
               match 'workflows/copy', :controller => 'workflows', :action => 'copy', :via => [:get, :post]
               match 'settings', :controller => 'settings', :action => 'index', :via => :get
               match 'settings/edit', :controller => 'settings', :action => 'edit', :via => [:get, :post]
               match 'settings/plugin/:id', :controller => 'settings', :action => 'plugin', :via => [:get, :post], :as => 'plugin_settings'
               match 'sys/projects', :to => 'sys#projects', :via => :get
               match 'sys/projects/:id/repository', :to => 'sys#create_project_repository', :via => :post
               match 'sys/fetch_changesets', :to => 'sys#fetch_changesets', :via => :get
               match 'uploads', :to => 'attachments#upload', :via => :post
               get 'robots.txt', :to => 'welcome#robots'
               Dir.glob File.expand_path("plugins/*", Rails.root) do |plugin_dir|
                 file = File.join(plugin_dir, "config/routes.rb")
                 if File.exists?(file)
                   begin
                     instance_eval File.read(file)
                   rescue Exception => e
                     puts "An error occurred while loading the routes definition of #{File.basename(plugin_dir)} plugin (#{file}): #{e.message}."
                     exit 1
                   end
                 end
               end
             end

lib/redmine.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 'redmine/core_ext'
             begin
               require 'RMagick' unless Object.const_defined?(:Magick)
             rescue LoadError
               # RMagick is not available
             end
             require 'redmine/scm/base'
             require 'redmine/access_control'
             require 'redmine/access_keys'
             require 'redmine/activity'
             require 'redmine/activity/fetcher'
             require 'redmine/ciphering'
             require 'redmine/codeset_util'
             require 'redmine/custom_field_format'
             require 'redmine/i18n'
             require 'redmine/menu_manager'
             require 'redmine/notifiable'
             require 'redmine/platform'
             require 'redmine/mime_type'
             require 'redmine/notifiable'
             require 'redmine/search'
             require 'redmine/syntax_highlighting'
             require 'redmine/thumbnail'
             require 'redmine/unified_diff'
             require 'redmine/utils'
             require 'redmine/version'
             require 'redmine/wiki_formatting'
             require 'redmine/default_data/loader'
             require 'redmine/helpers/calendar'
             require 'redmine/helpers/diff'
             require 'redmine/helpers/gantt'
             require 'redmine/helpers/time_report'
             require 'redmine/views/other_formats_builder'
             require 'redmine/views/labelled_form_builder'
             require 'redmine/views/builders'
             require 'redmine/themes'
             require 'redmine/hook'
             require 'redmine/plugin'
             if RUBY_VERSION < '1.9'
               require 'fastercsv'
             else
               require 'csv'
               FCSV = CSV
             end
             Redmine::Scm::Base.add "Subversion"
             Redmine::Scm::Base.add "Darcs"
             Redmine::Scm::Base.add "Mercurial"
             Redmine::Scm::Base.add "Cvs"
             Redmine::Scm::Base.add "Bazaar"
             Redmine::Scm::Base.add "Git"
             Redmine::Scm::Base.add "Filesystem"
             Redmine::CustomFieldFormat.map do |fields|
               fields.register 'string'
               fields.register 'text'
               fields.register 'int', :label => :label_integer
               fields.register 'float'
               fields.register 'list'
               fields.register 'date'
               fields.register 'bool', :label => :label_boolean
               fields.register 'user', :only => %w(Issue TimeEntry Version Project), :edit_as => 'list'
               fields.register 'version', :only => %w(Issue TimeEntry Version Project), :edit_as => 'list'
             end
             # Permissions
             Redmine::AccessControl.map do |map|
               map.permission :view_project, {:projects => [:show], :activities => [:index]}, :public => true, :read => true
               map.permission :search_project, {:search => :index}, :public => true, :read => true
               map.permission :add_project, {:projects => [:new, :create]}, :require => :loggedin
               map.permission :edit_project, {:projects => [:settings, :edit, :update]}, :require => :member
               map.permission :close_project, {:projects => [:close, :reopen]}, :require => :member, :read => true
               map.permission :select_project_modules, {:projects => :modules}, :require => :member
               map.permission :manage_members, {:projects => :settings, :members => [:index, :show, :create, :update, :destroy, :autocomplete]}, :require => :member
               map.permission :manage_versions, {:projects => :settings, :versions => [:new, :create, :edit, :update, :close_completed, :destroy]}, :require => :member
               map.permission :add_subprojects, {:projects => [:new, :create]}, :require => :member
               map.project_module :issue_tracking do |map|
                 # Issue categories
                 map.permission :manage_categories, {:projects => :settings, :issue_categories => [:index, :show, :new, :create, :edit, :update, :destroy]}, :require => :member
                 # Issues
                 map.permission :view_issues, {:issues => [:index, :show],
                                               :auto_complete => [:issues],
                                               :context_menus => [:issues],
                                               :versions => [:index, :show, :status_by],
                                               :journals => [:index, :diff],
                                               :queries => :index,
                                               :reports => [:issue_report, :issue_report_details]},
                                               :read => true
                 map.permission :add_issues, {:issues => [:new, :create, :update_form], :attachments => :upload}
                 map.permission :edit_issues, {:issues => [:edit, :update, :bulk_edit, :bulk_update, :update_form], :journals => [:new], :attachments => :upload}
                 map.permission :manage_issue_relations, {:issue_relations => [:index, :show, :create, :destroy]}
                 map.permission :manage_subtasks, {}
                 map.permission :set_issues_private, {}
                 map.permission :set_own_issues_private, {}, :require => :loggedin
-                map.permission :add_issue_notes, {:issues => [:edit, :update], :journals => [:new], :attachments => :upload}
+                map.permission :add_issue_notes, {:issues => [:edit, :update, :update_form], :journals => [:new], :attachments => :upload}
                 map.permission :edit_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :edit_own_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :view_private_notes, {}, :read => true, :require => :member
                 map.permission :set_notes_private, {}, :require => :member
                 map.permission :move_issues, {:issues => [:bulk_edit, :bulk_update]}, :require => :loggedin
                 map.permission :delete_issues, {:issues => :destroy}, :require => :member
                 # Queries
                 map.permission :manage_public_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :member
                 map.permission :save_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :loggedin
                 # Watchers
                 map.permission :view_issue_watchers, {}, :read => true
                 map.permission :add_issue_watchers, {:watchers => [:new, :create, :append, :autocomplete_for_user]}
                 map.permission :delete_issue_watchers, {:watchers => :destroy}
               end
               map.project_module :time_tracking do |map|
                 map.permission :log_time, {:timelog => [:new, :create]}, :require => :loggedin
                 map.permission :view_time_entries, {:timelog => [:index, :report, :show]}, :read => true
                 map.permission :edit_time_entries, {:timelog => [:edit, :update, :destroy, :bulk_edit, :bulk_update]}, :require => :member
                 map.permission :edit_own_time_entries, {:timelog => [:edit, :update, :destroy,:bulk_edit, :bulk_update]}, :require => :loggedin
                 map.permission :manage_project_activities, {:project_enumerations => [:update, :destroy]}, :require => :member
               end
               map.project_module :news do |map|
                 map.permission :manage_news, {:news => [:new, :create, :edit, :update, :destroy], :comments => [:destroy]}, :require => :member
                 map.permission :view_news, {:news => [:index, :show]}, :public => true, :read => true
                 map.permission :comment_news, {:comments => :create}
               end
               map.project_module :documents do |map|
                 map.permission :add_documents, {:documents => [:new, :create, :add_attachment]}, :require => :loggedin
                 map.permission :edit_documents, {:documents => [:edit, :update, :add_attachment]}, :require => :loggedin
                 map.permission :delete_documents, {:documents => [:destroy]}, :require => :loggedin
                 map.permission :view_documents, {:documents => [:index, :show, :download]}, :read => true
               end
               map.project_module :files do |map|
                 map.permission :manage_files, {:files => [:new, :create]}, :require => :loggedin
                 map.permission :view_files, {:files => :index, :versions => :download}, :read => true
               end
               map.project_module :wiki do |map|
                 map.permission :manage_wiki, {:wikis => [:edit, :destroy]}, :require => :member
                 map.permission :rename_wiki_pages, {:wiki => :rename}, :require => :member
                 map.permission :delete_wiki_pages, {:wiki => [:destroy, :destroy_version]}, :require => :member
                 map.permission :view_wiki_pages, {:wiki => [:index, :show, :special, :date_index]}, :read => true
                 map.permission :export_wiki_pages, {:wiki => [:export]}, :read => true
                 map.permission :view_wiki_edits, {:wiki => [:history, :diff, :annotate]}, :read => true
                 map.permission :edit_wiki_pages, :wiki => [:edit, :update, :preview, :add_attachment]
                 map.permission :delete_wiki_pages_attachments, {}
                 map.permission :protect_wiki_pages, {:wiki => :protect}, :require => :member
               end
               map.project_module :repository do |map|
                 map.permission :manage_repository, {:repositories => [:new, :create, :edit, :update, :committers, :destroy]}, :require => :member
                 map.permission :browse_repository, {:repositories => [:show, :browse, :entry, :raw, :annotate, :changes, :diff, :stats, :graph]}, :read => true
                 map.permission :view_changesets, {:repositories => [:show, :revisions, :revision]}, :read => true
                 map.permission :commit_access, {}
                 map.permission :manage_related_issues, {:repositories => [:add_related_issue, :remove_related_issue]}
               end
               map.project_module :boards do |map|
                 map.permission :manage_boards, {:boards => [:new, :create, :edit, :update, :destroy]}, :require => :member
                 map.permission :view_messages, {:boards => [:index, :show], :messages => [:show]}, :public => true, :read => true
                 map.permission :add_messages, {:messages => [:new, :reply, :quote]}
                 map.permission :edit_messages, {:messages => :edit}, :require => :member
                 map.permission :edit_own_messages, {:messages => :edit}, :require => :loggedin
                 map.permission :delete_messages, {:messages => :destroy}, :require => :member
                 map.permission :delete_own_messages, {:messages => :destroy}, :require => :loggedin
               end
               map.project_module :calendar do |map|
                 map.permission :view_calendar, {:calendars => [:show, :update]}, :read => true
               end
               map.project_module :gantt do |map|
                 map.permission :view_gantt, {:gantts => [:show, :update]}, :read => true
               end
             end
             Redmine::MenuManager.map :top_menu do |menu|
               menu.push :home, :home_path
               menu.push :my_page, { :controller => 'my', :action => 'page' }, :if => Proc.new { User.current.logged? }
               menu.push :projects, { :controller => 'projects', :action => 'index' }, :caption => :label_project_plural
               menu.push :administration, { :controller => 'admin', :action => 'index' }, :if => Proc.new { User.current.admin? }, :last => true
               menu.push :help, Redmine::Info.help_url, :last => true
             end
             Redmine::MenuManager.map :account_menu do |menu|
               menu.push :login, :signin_path, :if => Proc.new { !User.current.logged? }
               menu.push :register, :register_path, :if => Proc.new { !User.current.logged? && Setting.self_registration? }
               menu.push :my_account, { :controller => 'my', :action => 'account' }, :if => Proc.new { User.current.logged? }
               menu.push :logout, :signout_path, :html => {:method => 'post'}, :if => Proc.new { User.current.logged? }
             end
             Redmine::MenuManager.map :application_menu do |menu|
               # Empty
             end
             Redmine::MenuManager.map :admin_menu do |menu|
               menu.push :projects, {:controller => 'admin', :action => 'projects'}, :caption => :label_project_plural
               menu.push :users, {:controller => 'users'}, :caption => :label_user_plural
               menu.push :groups, {:controller => 'groups'}, :caption => :label_group_plural
               menu.push :roles, {:controller => 'roles'}, :caption => :label_role_and_permissions
               menu.push :trackers, {:controller => 'trackers'}, :caption => :label_tracker_plural
               menu.push :issue_statuses, {:controller => 'issue_statuses'}, :caption => :label_issue_status_plural,
                         :html => {:class => 'issue_statuses'}
               menu.push :workflows, {:controller => 'workflows', :action => 'edit'}, :caption => :label_workflow
               menu.push :custom_fields, {:controller => 'custom_fields'},  :caption => :label_custom_field_plural,
                         :html => {:class => 'custom_fields'}
               menu.push :enumerations, {:controller => 'enumerations'}
               menu.push :settings, {:controller => 'settings'}
               menu.push :ldap_authentication, {:controller => 'auth_sources', :action => 'index'},
                         :html => {:class => 'server_authentication'}
               menu.push :plugins, {:controller => 'admin', :action => 'plugins'}, :last => true
               menu.push :info, {:controller => 'admin', :action => 'info'}, :caption => :label_information_plural, :last => true
             end
             Redmine::MenuManager.map :project_menu do |menu|
               menu.push :overview, { :controller => 'projects', :action => 'show' }
               menu.push :activity, { :controller => 'activities', :action => 'index' }
               menu.push :roadmap, { :controller => 'versions', :action => 'index' }, :param => :project_id,
                           :if => Proc.new { |p| p.shared_versions.any? }
               menu.push :issues, { :controller => 'issues', :action => 'index' }, :param => :project_id, :caption => :label_issue_plural
               menu.push :new_issue, { :controller => 'issues', :action => 'new', :copy_from => nil }, :param => :project_id, :caption => :label_issue_new,
                           :html => { :accesskey => Redmine::AccessKeys.key_for(:new_issue) }
               menu.push :gantt, { :controller => 'gantts', :action => 'show' }, :param => :project_id, :caption => :label_gantt
               menu.push :calendar, { :controller => 'calendars', :action => 'show' }, :param => :project_id, :caption => :label_calendar
               menu.push :news, { :controller => 'news', :action => 'index' }, :param => :project_id, :caption => :label_news_plural
               menu.push :documents, { :controller => 'documents', :action => 'index' }, :param => :project_id, :caption => :label_document_plural
               menu.push :wiki, { :controller => 'wiki', :action => 'show', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.wiki && !p.wiki.new_record? }
               menu.push :boards, { :controller => 'boards', :action => 'index', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.boards.any? }, :caption => :label_board_plural
               menu.push :files, { :controller => 'files', :action => 'index' }, :caption => :label_file_plural, :param => :project_id
               menu.push :repository, { :controller => 'repositories', :action => 'show', :repository_id => nil, :path => nil, :rev => nil },
                           :if => Proc.new { |p| p.repository && !p.repository.new_record? }
               menu.push :settings, { :controller => 'projects', :action => 'settings' }, :last => true
             end
             Redmine::Activity.map do |activity|
               activity.register :issues, :class_name => %w(Issue Journal)
               activity.register :changesets
               activity.register :news
               activity.register :documents, :class_name => %w(Document Attachment)
               activity.register :files, :class_name => 'Attachment'
               activity.register :wiki_edits, :class_name => 'WikiContent::Version', :default => false
               activity.register :messages, :default => false
               activity.register :time_entries, :default => false
             end
             Redmine::Search.map do |search|
               search.register :issues
               search.register :news
               search.register :documents
               search.register :changesets
               search.register :wiki_pages
               search.register :messages
               search.register :projects
             end
             Redmine::WikiFormatting.map do |format|
               format.register :textile, Redmine::WikiFormatting::Textile::Formatter, Redmine::WikiFormatting::Textile::Helper
             end
             ActionView::Template.register_template_handler :rsb, Redmine::Views::ApiTemplateHandler

test/fixtures/users.yml +5 -2

             ---
             users_004:
               created_on: 2006-07-19 19:34:07 +02:00
               status: 1
               last_login_on:
               language: en
               # password = foo
               salt: 3126f764c3c5ac61cbfc103f25f934cf
               hashed_password: 9e4dd7eeb172c12a0691a6d9d3a269f7e9fe671b
               updated_on: 2006-07-19 19:34:07 +02:00
               admin: false
               mail: rhill@somenet.foo
               lastname: Hill
               firstname: Robert
               id: 4
               auth_source_id:
               mail_notification: all
               login: rhill
               type: User
             users_001:
               created_on: 2006-07-19 19:12:21 +02:00
               status: 1
               last_login_on: 2006-07-19 22:57:52 +02:00
               language: en
               # password = admin
               salt: 82090c953c4a0000a7db253b0691a6b4
               hashed_password: b5b6ff9543bf1387374cdfa27a54c96d236a7150
               updated_on: 2006-07-19 22:57:52 +02:00
               admin: true
               mail: admin@somenet.foo
               lastname: Admin
               firstname: Redmine
               id: 1
               auth_source_id:
               mail_notification: all
               login: admin
               type: User
             users_002:
               created_on: 2006-07-19 19:32:09 +02:00
               status: 1
               last_login_on: 2006-07-19 22:42:15 +02:00
               language: en
               # password = jsmith
               salt: 67eb4732624d5a7753dcea7ce0bb7d7d
               hashed_password: bfbe06043353a677d0215b26a5800d128d5413bc
               updated_on: 2006-07-19 22:42:15 +02:00
               admin: false
               mail: jsmith@somenet.foo
               lastname: Smith
               firstname: John
               id: 2
               auth_source_id:
               mail_notification: all
               login: jsmith
               type: User
             users_003:
               created_on: 2006-07-19 19:33:19 +02:00
               status: 1
               last_login_on:
               language: en
               # password = foo
               salt: 7599f9963ec07b5a3b55b354407120c0
               hashed_password: 8f659c8d7c072f189374edacfa90d6abbc26d8ed
               updated_on: 2006-07-19 19:33:19 +02:00
               admin: false
               mail: dlopper@somenet.foo
               lastname: Lopper
               firstname: Dave
               id: 3
               auth_source_id:
               mail_notification: all
               login: dlopper
               type: User
             users_005:
               id: 5
               created_on: 2006-07-19 19:33:19 +02:00
               # Locked
               status: 3
               last_login_on:
               language: en
               hashed_password: 1
               updated_on: 2006-07-19 19:33:19 +02:00
               admin: false
               mail: dlopper2@somenet.foo
               lastname: Lopper2
               firstname: Dave2
               auth_source_id:
               mail_notification: all
               login: dlopper2
               type: User
             users_006:
               id: 6
               created_on: 2006-07-19 19:33:19 +02:00
               status: 0
               last_login_on:
               language: ''
               hashed_password: 1
               updated_on: 2006-07-19 19:33:19 +02:00
               admin: false
               mail: ''
               lastname: Anonymous
               firstname: ''
               auth_source_id:
               mail_notification: only_my_events
               login: ''
               type: AnonymousUser
             users_007:
+              # A user who does not belong to any project
               id: 7
               created_on: 2006-07-19 19:33:19 +02:00
               status: 1
               last_login_on:
-              language: ''
+              language: 'en'
-              hashed_password: 1
+              # password = foo
+              salt: 7599f9963ec07b5a3b55b354407120c0
+              hashed_password: 8f659c8d7c072f189374edacfa90d6abbc26d8ed
               updated_on: 2006-07-19 19:33:19 +02:00
               admin: false
               mail: someone@foo.bar
               lastname: One
               firstname: Some
               auth_source_id:
               mail_notification: only_my_events
               login: someone
               type: User
             users_008:
               id: 8
               created_on: 2006-07-19 19:33:19 +02:00
               status: 1
               last_login_on:
               language: 'it'
               # password = foo
               salt: 7599f9963ec07b5a3b55b354407120c0
               hashed_password: 8f659c8d7c072f189374edacfa90d6abbc26d8ed
               updated_on: 2006-07-19 19:33:19 +02:00
               admin: false
               mail: miscuser8@foo.bar
               lastname: Misc
               firstname: User
               auth_source_id:
               mail_notification: only_my_events
               login: miscuser8
               type: User
             users_009:
               id: 9
               created_on: 2006-07-19 19:33:19 +02:00
               status: 1
               last_login_on:
               language: 'it'
               hashed_password: 1
               updated_on: 2006-07-19 19:33:19 +02:00
               admin: false
               mail: miscuser9@foo.bar
               lastname: Misc
               firstname: User
               auth_source_id:
               mail_notification: only_my_events
               login: miscuser9
               type: User
             groups_010:
               id: 10
               lastname: A Team
               type: Group
             groups_011:
               id: 11
               lastname: B Team
               type: Group

test/functional/issues_controller_test.rb 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

test/integration/issues_test.rb 0 -9

             # Redmine - project management software
             # Copyright (C) 2006-2013  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class IssuesTest < ActionController::IntegrationTest
               fixtures :projects,
                        :users,
                        :roles,
                        :members,
                        :member_roles,
                        :trackers,
                        :projects_trackers,
                        :enabled_modules,
                        :issue_statuses,
                        :issues,
                        :enumerations,
                        :custom_fields,
                        :custom_values,
                        :custom_fields_trackers
               # create an issue
               def test_add_issue
                 log_user('jsmith', 'jsmith')
                 get 'projects/1/issues/new', :tracker_id => '1'
                 assert_response :success
                 assert_template 'issues/new'
                 post 'projects/1/issues', :tracker_id => "1",
                                              :issue => { :start_date => "2006-12-26",
                                                          :priority_id => "4",
                                                          :subject => "new test issue",
                                                          :category_id => "",
                                                          :description => "new issue",
                                                          :done_ratio => "0",
                                                          :due_date => "",
                                                          :assigned_to_id => "" },
                                              :custom_fields => {'2' => 'Value for field 2'}
                 # find created issue
                 issue = Issue.find_by_subject("new test issue")
                 assert_kind_of Issue, issue
                 # check redirection
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => issue
                 follow_redirect!
                 assert_equal issue, assigns(:issue)
                 # check issue attributes
                 assert_equal 'jsmith', issue.author.login
                 assert_equal 1, issue.project.id
                 assert_equal 1, issue.status.id
               end
-              def test_update_issue_form
-                log_user('jsmith', 'jsmith')
-                post 'projects/ecookbook/issues/new', :issue => { :tracker_id => "2"}
-                assert_response :success
-                assert_tag 'select',
-                  :attributes => {:name => 'issue[tracker_id]'},
-                  :child => {:tag => 'option', :attributes => {:value => '2', :selected => 'selected'}}
-              end
               # add then remove 2 attachments to an issue
               def test_issue_attachments
                 log_user('jsmith', 'jsmith')
                 set_tmp_attachments_directory
                 put 'issues/1',
                      :notes => 'Some notes',
                      :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'This is an attachment'}}
                 assert_redirected_to "/issues/1"
                 # make sure attachment was saved
                 attachment = Issue.find(1).attachments.find_by_filename("testfile.txt")
                 assert_kind_of Attachment, attachment
                 assert_equal Issue.find(1), attachment.container
                 assert_equal 'This is an attachment', attachment.description
                 # verify the size of the attachment stored in db
                 #assert_equal file_data_1.length, attachment.filesize
                 # verify that the attachment was written to disk
                 assert File.exist?(attachment.diskfile)
                 # remove the attachments
                 Issue.find(1).attachments.each(&:destroy)
                 assert_equal 0, Issue.find(1).attachments.length
               end
               def test_other_formats_links_on_index
                 get '/projects/ecookbook/issues'
                 %w(Atom PDF CSV).each do |format|
                   assert_tag :a, :content => format,
                                  :attributes => { :href => "/projects/ecookbook/issues.#{format.downcase}",
                                                   :rel => 'nofollow' }
                 end
               end
               def test_other_formats_links_on_index_without_project_id_in_url
                 get '/issues', :project_id => 'ecookbook'
                 %w(Atom PDF CSV).each do |format|
                   assert_tag :a, :content => format,
                                  :attributes => { :href => "/projects/ecookbook/issues.#{format.downcase}",
                                                   :rel => 'nofollow' }
                 end
               end
               def test_pagination_links_on_index
                 Setting.per_page_options = '2'
                 get '/projects/ecookbook/issues'
                 assert_tag :a, :content => '2',
                                :attributes => { :href => '/projects/ecookbook/issues?page=2' }
               end
               def test_pagination_links_on_index_without_project_id_in_url
                 Setting.per_page_options = '2'
                 get '/issues', :project_id => 'ecookbook'
                 assert_tag :a, :content => '2',
                                :attributes => { :href => '/projects/ecookbook/issues?page=2' }
               end
               def test_issue_with_user_custom_field
                 @field = IssueCustomField.create!(:name => 'Tester', :field_format => 'user', :is_for_all => true, :trackers => Tracker.all)
                 Role.anonymous.add_permission! :add_issues, :edit_issues
                 users = Project.find(1).users
                 tester = users.first
                 # Issue form
                 get '/projects/ecookbook/issues/new'
                 assert_response :success
                 assert_tag :select,
                   :attributes => {:name => "issue[custom_field_values][#{@field.id}]"},
                   :children => {:count => (users.size + 1)}, # +1 for blank value
                   :child => {
                     :tag => 'option',
                     :attributes => {:value => tester.id.to_s},
                     :content => tester.name
                   }
                 # Create issue
                 assert_difference 'Issue.count' do
                   post '/projects/ecookbook/issues',
                     :issue => {
                       :tracker_id => '1',
                       :priority_id => '4',
                       :subject => 'Issue with user custom field',
                       :custom_field_values => {@field.id.to_s => users.first.id.to_s}
                     }
                 end
                 issue = Issue.first(:order => 'id DESC')
                 assert_response 302
                 # Issue view
                 follow_redirect!
                 assert_tag :th,
                   :content => /Tester/,
                   :sibling => {
                     :tag => 'td',
                     :content => tester.name
                   }
                 assert_tag :select,
                   :attributes => {:name => "issue[custom_field_values][#{@field.id}]"},
                   :children => {:count => (users.size + 1)}, # +1 for blank value
                   :child => {
                     :tag => 'option',
                     :attributes => {:value => tester.id.to_s, :selected => 'selected'},
                     :content => tester.name
                   }
                 # Update issue
                 new_tester = users[1]
                 assert_difference 'Journal.count' do
                   put "/issues/#{issue.id}",
                     :notes => 'Updating custom field',
                     :issue => {
                       :custom_field_values => {@field.id.to_s => new_tester.id.to_s}
                     }
                 end
                 assert_response 302
                 # Issue view
                 follow_redirect!
                 assert_tag :content => 'Tester',
                   :ancestor => {:tag => 'ul', :attributes => {:class => /details/}},
                   :sibling => {
                     :content => tester.name,
                     :sibling => {
                       :content => new_tester.name
                     }
                   }
               end
               def test_update_using_invalid_http_verbs
                 subject = 'Updated by an invalid http verb'
                 get '/issues/update/1', {:issue => {:subject => subject}}, credentials('jsmith')
                 assert_response 404
                 assert_not_equal subject, Issue.find(1).subject
                 post '/issues/1', {:issue => {:subject => subject}}, credentials('jsmith')
                 assert_response 404
                 assert_not_equal subject, Issue.find(1).subject
               end
               def test_get_watch_should_be_invalid
                 assert_no_difference 'Watcher.count' do
                   get '/watchers/watch?object_type=issue&object_id=1', {}, credentials('jsmith')
                   assert_response 404
                 end
               end
             end

test/integration/routing/issues_test.rb +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2013  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../test_helper', __FILE__)
             class RoutingIssuesTest < ActionController::IntegrationTest
               def test_issues_rest_actions
                 assert_routing(
                     { :method => 'get', :path => "/issues" },
                     { :controller => 'issues', :action => 'index' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/issues.pdf" },
                     { :controller => 'issues', :action => 'index', :format => 'pdf' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/issues.atom" },
                     { :controller => 'issues', :action => 'index', :format => 'atom' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/issues.xml" },
                     { :controller => 'issues', :action => 'index', :format => 'xml' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/issues/64" },
                     { :controller => 'issues', :action => 'show', :id => '64' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/issues/64.pdf" },
                     { :controller => 'issues', :action => 'show', :id => '64',
                       :format => 'pdf' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/issues/64.atom" },
                     { :controller => 'issues', :action => 'show', :id => '64',
                       :format => 'atom' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/issues/64.xml" },
                     { :controller => 'issues', :action => 'show', :id => '64',
                       :format => 'xml' }
                   )
                 assert_routing(
                     { :method => 'post', :path => "/issues.xml" },
                     { :controller => 'issues', :action => 'create', :format => 'xml' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/issues/64/edit" },
                     { :controller => 'issues', :action => 'edit', :id => '64' }
                   )
                 assert_routing(
                     { :method => 'put', :path => "/issues/1.xml" },
                     { :controller => 'issues', :action => 'update', :id => '1',
                       :format => 'xml' }
                   )
                 assert_routing(
                     { :method => 'delete', :path => "/issues/1.xml" },
                     { :controller => 'issues', :action => 'destroy', :id => '1',
                       :format => 'xml' }
                   )
               end
               def test_issues_rest_actions_scoped_under_project
                 assert_routing(
                     { :method => 'get', :path => "/projects/23/issues" },
                     { :controller => 'issues', :action => 'index', :project_id => '23' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/projects/23/issues.pdf" },
                     { :controller => 'issues', :action => 'index', :project_id => '23',
                       :format => 'pdf' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/projects/23/issues.atom" },
                     { :controller => 'issues', :action => 'index', :project_id => '23',
                       :format => 'atom' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/projects/23/issues.xml" },
                     { :controller => 'issues', :action => 'index', :project_id => '23',
                       :format => 'xml' }
                   )
                 assert_routing(
                     { :method => 'post', :path => "/projects/23/issues" },
                     { :controller => 'issues', :action => 'create', :project_id => '23' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/projects/23/issues/new" },
                     { :controller => 'issues', :action => 'new', :project_id => '23' }
                   )
               end
               def test_issues_form_update
                 ["post", "put"].each do |method|
                   assert_routing(
-                      { :method => method, :path => "/projects/23/issues/new" },
+                      { :method => method, :path => "/projects/23/issues/update_form" },
-                      { :controller => 'issues', :action => 'new', :project_id => '23' }
+                      { :controller => 'issues', :action => 'update_form', :project_id => '23' }
                     )
                 end
               end
               def test_issues_extra_actions
                 assert_routing(
                     { :method => 'get', :path => "/projects/23/issues/64/copy" },
                     { :controller => 'issues', :action => 'new', :project_id => '23',
                       :copy_from => '64' }
                   )
                 # For updating the bulk edit form
                 ["get", "post"].each do |method|
                   assert_routing(
                       { :method => method, :path => "/issues/bulk_edit" },
                       { :controller => 'issues', :action => 'bulk_edit' }
                     )
                 end
                 assert_routing(
                     { :method => 'post', :path => "/issues/bulk_update" },
                     { :controller => 'issues', :action => 'bulk_update' }
                   )
               end
             end

test/ui/issues_test.rb +58 0

             # Redmine - project management software
             # Copyright (C) 2006-2013  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../base', __FILE__)
             class Redmine::UiTest::IssuesTest < Redmine::UiTest::Base
               fixtures :projects, :users, :roles, :members, :member_roles,
                        :trackers, :projects_trackers, :enabled_modules, :issue_statuses, :issues,
                        :enumerations, :custom_fields, :custom_values, :custom_fields_trackers,
                        :watchers
               def test_create_issue
                 log_user('jsmith', 'jsmith')
                 visit '/projects/ecookbook/issues/new'
                 within('form#issue-form') do
                   select 'Bug', :from => 'Tracker'
                   select 'Low', :from => 'Priority'
                   fill_in 'Subject', :with => 'new test issue'
                   fill_in 'Description', :with => 'new issue'
                   select '0 %', :from => 'Done'
                   fill_in 'Due date', :with => ''
                   select '', :from => 'Assignee'
                   fill_in 'Searchable field', :with => 'Value for field 2'
                   # click_button 'Create' would match both 'Create' and 'Create and continue' buttons
                   find('input[name=commit]').click
                 end
                 # find created issue
                 issue = Issue.find_by_subject("new test issue")
                 assert_kind_of Issue, issue
                 # check redirection
                 find 'div#flash_notice', :visible => true, :text => "Issue \##{issue.id} created."
                 assert_equal issue_path(:id => issue), current_path
                 # check issue attributes
                 assert_equal 'jsmith', issue.author.login
                 assert_equal 1, issue.project.id
                 assert_equal IssueStatus.find_by_name('New'), issue.status
                 assert_equal Tracker.find_by_name('Bug'), issue.tracker
                 assert_equal IssuePriority.find_by_name('Low'), issue.priority
                 assert_equal 'Value for field 2', issue.custom_field_value(CustomField.find_by_name('Searchable field'))
               end
+              def test_create_issue_with_form_update
+                field = IssueCustomField.create!(
+                  :field_format => 'string',
+                  :name => 'Form update CF',
+                  :is_for_all => true,
+                  :trackers => Tracker.find_all_by_name('Feature request')
+                )
+                Role.non_member.add_permission! :add_issues
+                Role.non_member.remove_permission! :edit_issues, :add_issue_notes
+                log_user('someone', 'foo')
+                visit '/projects/ecookbook/issues/new'
+                assert page.has_no_content?('Form update CF')
+                fill_in 'Subject', :with => 'new test issue'
+                # the custom field should show up when changing tracker
+                select 'Feature request', :from => 'Tracker'
+                assert page.has_content?('Form update CF')
+                fill_in 'Form update', :with => 'CF value'
+                assert_difference 'Issue.count' do
+                  find('input[name=commit]').click
+                end
+                issue = Issue.order('id desc').first
+                assert_equal 'CF value', issue.custom_field_value(field)
+              end
               def test_create_issue_with_watchers
                 User.generate!(:firstname => 'Some', :lastname => 'Watcher')
                 log_user('jsmith', 'jsmith')
                 visit '/projects/ecookbook/issues/new'
                 fill_in 'Subject', :with => 'Issue with watchers'
                 # Add a project member as watcher
                 check 'Dave Lopper'
                 # Search for another user
                 click_link 'Search for watchers to add'
                 within('form#new-watcher-form') do
                   assert page.has_content?('Some One')
                   fill_in 'user_search', :with => 'watch'
                   assert page.has_no_content?('Some One')
                   check 'Some Watcher'
                   click_button 'Add'
                 end
                 assert_difference 'Issue.count' do
                   find('input[name=commit]').click
                 end
                 issue = Issue.order('id desc').first
                 assert_equal ['Dave Lopper', 'Some Watcher'], issue.watcher_users.map(&:name).sort
               end
               def test_preview_issue_description
                 log_user('jsmith', 'jsmith')
                 visit '/projects/ecookbook/issues/new'
                 within('form#issue-form') do
                   fill_in 'Subject', :with => 'new issue subject'
                   fill_in 'Description', :with => 'new issue description'
                   click_link 'Preview'
                 end
                 find 'div#preview fieldset', :visible => true, :text => 'new issue description'
                 assert_difference 'Issue.count' do
                   find('input[name=commit]').click
                 end
                 issue = Issue.order('id desc').first
                 assert_equal 'new issue description', issue.description
               end
+              def test_update_issue_with_form_update
+                field = IssueCustomField.create!(
+                  :field_format => 'string',
+                  :name => 'Form update CF',
+                  :is_for_all => true,
+                  :trackers => Tracker.find_all_by_name('Feature request')
+                )
+                Role.non_member.add_permission! :edit_issues
+                Role.non_member.remove_permission! :add_issues, :add_issue_notes
+                log_user('someone', 'foo')
+                visit '/issues/1'
+                assert page.has_no_content?('Form update CF')
+                page.first(:link, 'Update').click
+                # the custom field should show up when changing tracker
+                select 'Feature request', :from => 'Tracker'
+                assert page.has_content?('Form update CF')
+                fill_in 'Form update', :with => 'CF value'
+                assert_no_difference 'Issue.count' do
+                  page.first(:button, 'Submit').click
+                end
+                issue = Issue.find(1)
+                assert_equal 'CF value', issue.custom_field_value(field)
+              end
               def test_watch_issue_via_context_menu
                 log_user('jsmith', 'jsmith')
                 visit '/issues'
                 find('tr#issue-1 td.updated_on').click
                 page.execute_script "$('tr#issue-1 td.updated_on').trigger('contextmenu');"
                 assert_difference 'Watcher.count' do
                   within('#context-menu') do
                     click_link 'Watch'
                   end
                 end
                 assert Issue.find(1).watched_by?(User.find_by_login('jsmith'))
               end
               def test_bulk_watch_issues_via_context_menu
                 log_user('jsmith', 'jsmith')
                 visit '/issues'
                 find('tr#issue-1 input[type=checkbox]').click
                 find('tr#issue-4 input[type=checkbox]').click
                 page.execute_script "$('tr#issue-1 td.updated_on').trigger('contextmenu');"
                 assert_difference 'Watcher.count', 2 do
                   within('#context-menu') do
                     click_link 'Watch'
                   end
                 end
                 assert Issue.find(1).watched_by?(User.find_by_login('jsmith'))
                 assert Issue.find(4).watched_by?(User.find_by_login('jsmith'))
               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