jro_apps/redmine Commit - r9134:fae5250e5250

Ability to add non-member watchers on issue creation (#5159)....

Jean-Philippe Lang -

r9134:fae5250e5250

parent child

Context file:

r9134:fae5250e5250

Collapse all files

app/controllers/issues_controller.rb +1 0

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 :authorize, :except => [:index]
               before_filter :find_optional_project, :only => [:index]
               before_filter :check_for_default_issue_status, :only => [:new, :create]
               before_filter :build_new_issue_from_params, :only => [:new, :create]
               accept_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
               helper :gantt
               include Redmine::Export::PDF
               def index
                 retrieve_query
                 sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
                 sort_update(@query.sortable_columns)
                 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 self, @issue_count, @limit, params['page']
                   @offset ||= @issue_pages.current.offset
                   @issues = @query.issues(:include => [:assigned_to, :tracker, :priority, :category, :fixed_version],
                                           :order => sort_clause,
                                           :offset => @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_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.find(:all, :include => [:user, :details], :order => "#{Journal.table_name}.created_on ASC")
                 @journals.each_with_index {|j,i| j.indice = i+1}
                 @journals.reverse! if User.current.wants_comments_in_reverse_order?
                 @changesets = @issue.changesets.visible.all
                 @changesets.reverse! if User.current.wants_comments_in_reverse_order?
                 @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  { send_data(issue_to_pdf(@issue), :type => 'application/pdf', :filename => "#{@project.identifier}-#{@issue.id}.pdf") }
                 end
               end
               # Add a new issue
               # The new issue will be created from an existing one if copy_from parameter is given
               def new
                 respond_to do |format|
                   format.html { render :action => 'new', :layout => !request.xhr? }
                   format.js {
                     render(:update) { |page|
                       if params[:project_change]
                         page.replace_html 'all_attributes', :partial => 'form'
                       else
                         page.replace_html 'attributes', :partial => 'attributes'
                       end
                       m = User.current.allowed_to?(:log_time, @issue.project) ? 'show' : 'hide'
                       page << "if ($('log_time')) {Element.#{m}('log_time');}"
                     }
                   }
                 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 => "<a href='#{issue_path(@issue)}'>##{@issue.id}</a>")
                       redirect_to(params[:continue] ?  { :action => 'new', :project_id => @issue.project, :issue => {:tracker_id => @issue.tracker, :parent_issue_id => @issue.parent_issue_id}.reject {|k,v| v.nil?} } :
                                   { :action => 'show', :id => @issue })
                     }
                     format.api  { render :action => 'show', :status => :created, :location => issue_url(@issue) }
                   end
                   return
                 else
                   respond_to do |format|
                     format.html { render :action => 'new' }
                     format.api  { render_validation_errors(@issue) }
                   end
                 end
               end
               def edit
                 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]
                     if params[:last_journal_id].present?
                       last_journal_id = params[:last_journal_id].to_i
                       @conflict_journals = @issue.journals.all(:conditions => ["#{Journal.table_name}.id > ?", last_journal_id])
                     else
                       @conflict_journals = @issue.journals.all
                     end
                   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({:action => 'show', :id => @issue}) }
                     format.api  { head :ok }
                   end
                 else
                   respond_to do |format|
                     format.html { render :action => 'edit' }
                     format.api  { render_validation_errors(@issue) }
                   end
                 end
               end
               # Bulk edit/copy a set of issues
               def bulk_edit
                 @issues.sort!
                 @copy = params[:copy].present?
                 @notes = params[:notes]
                 if 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
                 @available_statuses = @issues.map(&:new_statuses_allowed_to).reduce(:&)
                 @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(:&)
                 @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 = []
                 @issues.each do |issue|
                   issue.reload
                   if @copy
                     issue = issue.copy
                   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 :controller => 'issues', :action => 'show', :id => moved_issues.first
                   elsif moved_issues.map(&:project).uniq.size == 1
                     redirect_to :controller => 'issues', :action => 'index', :project_id => moved_issues.map(&:project).first
                   end
                 else
                   redirect_back_or_default({:controller => 'issues', :action => 'index', :project_id => @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(:action => 'index', :project_id => @project) }
                   format.api  { head :ok }
                 end
               end
             private
               def find_issue
                 # Issue.visible.find(...) can not be used to redirect user to the login form
                 # if the issue actually exists but requires authentication
                 @issue = Issue.find(params[:id], :include => [:project, :tracker, :status, :author, :priority, :category])
                 unless @issue.visible?
                   deny_access
                   return
                 end
                 @project = @issue.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               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
                 @allowed_statuses = @issue.new_statuses_allowed_to(User.current)
                 @priorities = IssuePriority.active
                 @edit_allowed = User.current.allowed_to?(:edit_issues, @project)
                 @time_entry = TimeEntry.new(:issue => @issue, :project => @issue.project)
                 @time_entry.attributes = params[:time_entry]
                 @notes = params[:notes] || (params[:issue].present? ? params[:issue][:notes] : nil)
                 @issue.init_journal(User.current, @notes)
                 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 = {}
                   when 'cancel'
                     redirect_to issue_path(@issue)
                     return false
                   end
                 end
                 @issue.safe_attributes = issue_attributes
                 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?
                       @issue.copy_from(@copy_from, :attachments => @copy_attachments)
                     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'}
                 attributes[:custom_field_values].reject! {|k,v| v.blank?} if attributes[:custom_field_values]
                 attributes
               end
             end

app/controllers/watchers_controller.rb +25 -1

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 WatchersController < ApplicationController
               before_filter :find_project
               before_filter :require_login, :check_project_privacy, :only => [:watch, :unwatch]
               before_filter :authorize, :only => [:new, :destroy]
               def watch
                 if @watched.respond_to?(:visible?) && !@watched.visible?(User.current)
                   render_403
                 else
                   set_watcher(User.current, true)
                 end
               end
               def unwatch
                 set_watcher(User.current, false)
               end
               def new
                 respond_to do |format|
                   format.js do
                     render :update do |page|
                       page.replace_html 'ajax-modal', :partial => 'watchers/new', :locals => {:watched => @watched}
                       page << "showModal('ajax-modal', '400px');"
                       page << "$('ajax-modal').addClassName('new-watcher');"
                     end
                   end
                 end
               end
               def create
                 if params[:watcher].is_a?(Hash) && request.post?
                   user_ids = params[:watcher][:user_ids] || [params[:watcher][:user_id]]
                   user_ids.each do |user_id|
                     Watcher.create(:watchable => @watched, :user_id => user_id)
                   end
                 end
                 respond_to do |format|
                   format.html { redirect_to :back }
                   format.js do
                     render :update do |page|
                       page.replace_html 'ajax-modal', :partial => 'watchers/new', :locals => {:watched => @watched}
                       page.replace_html 'watchers', :partial => 'watchers/watchers', :locals => {:watched => @watched}
                     end
                   end
                 end
               rescue ::ActionController::RedirectBackError
                 render :text => 'Watcher added.', :layout => true
               end
+              def append
+                if params[:watcher].is_a?(Hash)
+                  user_ids = params[:watcher][:user_ids] || [params[:watcher][:user_id]]
+                  users = User.active.find_all_by_id(user_ids)
+                  respond_to do |format|
+                    format.js do
+                      render :update do |page|
+                        users.each do |user|
+                          page.select("#issue_watcher_user_ids_#{user.id}").each(&:hide)
+                        end
+                        page.insert_html :bottom, 'watchers_inputs', :text => watchers_checkboxes(nil, users, true)
+                      end
+                    end
+                  end
+                end
+              end
               def destroy
                 @watched.set_watcher(User.find(params[:user_id]), false) if request.post?
                 respond_to do |format|
                   format.html { redirect_to :back }
                   format.js do
                     render :update do |page|
                       page.replace_html 'watchers', :partial => 'watchers/watchers', :locals => {:watched => @watched}
                     end
                   end
                 end
               end
               def autocomplete_for_user
-                @users = User.active.like(params[:q]).find(:all, :limit => 100) - @watched.watcher_users
+                @users = User.active.like(params[:q]).find(:all, :limit => 100)
+                if @watched
+                  @user -= @watched.watcher_users
+                end
                 render :layout => false
               end
             private
               def find_project
+                if params[:object_type] && params[:object_id]
                   klass = Object.const_get(params[:object_type].camelcase)
                   return false unless klass.respond_to?('watched_by')
                   @watched = klass.find(params[:object_id])
                   @project = @watched.project
+                elsif params[:project_id]
+                  @project = Project.visible.find(params[:project_id])
+                end
               rescue
                 render_404
               end
               def set_watcher(user, watching)
                 @watched.set_watcher(user, watching)
                 respond_to do |format|
                   format.html { redirect_to :back }
                   format.js do
                     render(:update) do |page|
                       c = watcher_css(@watched)
                       page.select(".#{c}").each do |item|
                         page.replace_html item, watcher_link(@watched, user)
                       end
                     end
                   end
                 end
               rescue ::ActionController::RedirectBackError
                 render :text => (watching ? 'Watcher added.' : 'Watcher removed.'), :layout => true
               end
             end

app/helpers/watchers_helper.rb +8 0

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2011  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module WatchersHelper
               def watcher_tag(object, user, options={})
                 content_tag("span", watcher_link(object, user), :class => watcher_css(object))
               end
               def watcher_link(object, user)
                 return '' unless user && user.logged? && object.respond_to?('watched_by?')
                 watched = object.watched_by?(user)
                 url = {:controller => 'watchers',
                        :action => (watched ? 'unwatch' : 'watch'),
                        :object_type => object.class.to_s.underscore,
                        :object_id => object.id}
                 link_to_remote((watched ? l(:button_unwatch) : l(:button_watch)),
                                {:url => url},
                                :href => url_for(url),
                                :class => (watched ? 'icon icon-fav' : 'icon icon-fav-off'))
               end
               # Returns the css class used to identify watch links for a given +object+
               def watcher_css(object)
                 "#{object.class.to_s.underscore}-#{object.id}-watcher"
               end
               # Returns a comma separated list of users watching the given object
               def watchers_list(object)
                 remove_allowed = User.current.allowed_to?("delete_#{object.class.name.underscore}_watchers".to_sym, object.project)
                 lis = object.watcher_users.collect do |user|
                   s = avatar(user, :size => "16").to_s + link_to_user(user, :class => 'user').to_s
                   if remove_allowed
                     url = {:controller => 'watchers',
                            :action => 'destroy',
                            :object_type => object.class.to_s.underscore,
                            :object_id => object.id,
                            :user_id => user}
                     s += ' ' + link_to_remote(image_tag('delete.png'),
                                               {:url => url},
                                               :href => url_for(url),
                                               :style => "vertical-align: middle",
                                               :class => "delete")
                   end
                   content_tag :li, s.html_safe
                 end
                 (lis.empty? ? "" : "<ul>#{ lis.join("\n") }</ul>").html_safe
               end
+              def watchers_checkboxes(object, users, checked=nil)
+                users.map do |user|
+                  c = checked.nil? ? object.watched_by?(user) : checked
+                  tag = check_box_tag 'issue[watcher_user_ids][]', user.id, c, :id => nil
+                  content_tag 'label', "#{tag} #{h(user)}", :id => "issue_watcher_user_ids_#{user.id}", :class => "floating"
+                end.join
+              end
             end

app/views/attachments/_form.html.erb +2 -3

             <% if defined?(container) && container && container.saved_attachments %>
               <% container.saved_attachments.each_with_index do |attachment, i| %>
                 <span class="icon icon-attachment" style="display:block; line-height:1.5em;">
                   <%= h(attachment.filename) %> (<%= number_to_human_size(attachment.filesize) %>)
                   <%= hidden_field_tag "attachments[p#{i}][token]", "#{attachment.id}.#{attachment.digest}" %>
                 </span>
               <% end %>
             <% end %>
             <span id="attachments_fields">
               <span>
                 <%= file_field_tag 'attachments[1][file]', :size => 30, :id => nil, :class => 'file',
                       :onchange => "checkFileSize(this, #{Setting.attachment_max_size.to_i.kilobytes}, '#{escape_javascript(l(:error_attachment_too_big, :max_size => number_to_human_size(Setting.attachment_max_size.to_i.kilobytes)))}');"  -%>
                 <%= text_field_tag 'attachments[1][description]', '', :id => nil, :class => 'description', :placeholder => l(:label_optional_description) %>
                 <%= link_to_function(image_tag('delete.png'), 'removeFileField(this)', :title => (l(:button_delete))) %>
               </span>
             </span>
-            <small><%= link_to l(:label_add_another_file), '#', :onclick => 'addFileField(); return false;' %>
+            <span class="add_attachment"><%= link_to l(:label_add_another_file), '#', :onclick => 'addFileField(); return false;', :class => 'add_attachment' %>
-            (<%= l(:label_max_size) %>: <%= number_to_human_size(Setting.attachment_max_size.to_i.kilobytes) %>)
+            (<%= l(:label_max_size) %>: <%= number_to_human_size(Setting.attachment_max_size.to_i.kilobytes) %>)</span>
-            </small>

app/views/issues/new.html.erb +8 -3

             <h2><%=l(:label_issue_new)%></h2>
             <%= call_hook(:view_issues_new_top, {:issue => @issue}) %>
             <% labelled_form_for @issue, :url => project_issues_path(@project),
                                          :html => {:id => 'issue-form', :multipart => true} do |f| %>
               <%= error_messages_for 'issue' %>
               <%= hidden_field_tag 'copy_from', params[:copy_from] if params[:copy_from] %>
               <div class="box tabular">
                 <div id="all_attributes">
                 <%= render :partial => 'issues/form', :locals => {:f => f} %>
                 </div>
                 <% if @copy_from && @copy_from.attachments.any? %>
                 <p>
                   <label for="copy_attachments"><%= l(:label_copy_attachments) %></label>
                   <%= check_box_tag 'copy_attachments', '1', @copy_attachments %>
                 </p>
                 <% end %>
                 <p id="attachments_form"><%= label_tag('attachments[1][file]', l(:label_attachment_plural))%><%= render :partial => 'attachments/form', :locals => {:container => @issue} %></p>
                 <% if @issue.safe_attribute? 'watcher_user_ids' -%>
                   <p id="watchers_form"><label><%= l(:label_issue_watchers) %></label>
-                  <% @issue.project.users.sort.each do |user| -%>
+                  <span id="watchers_inputs">
-                    <label class="floating"><%= check_box_tag 'issue[watcher_user_ids][]', user.id, @issue.watched_by?(user), :id => nil %> <%=h user %></label>
+                    <%= watchers_checkboxes(@issue, @available_watchers) %>
-                  <% end -%>
+            			</span>
+            			<span class="search_for_watchers">
+                  <%= link_to_remote l(:label_search_for_watchers),
+                               :url => {:controller => 'watchers', :action => 'new', :project_id => @issue.project},
+                               :method => 'get' %>
+            			</span>
             			</p>
                 <% end %>
               </div>
                 <%= submit_tag l(:button_create) %>
                 <%= submit_tag l(:button_create_and_continue), :name => 'continue' %>
                 <%= link_to_remote l(:label_preview),
                                    { :url => preview_new_issue_path(:project_id => @project),
                                      :method => 'post',
                                      :update => 'preview',
                                      :with => "Form.serialize('issue-form')",
                                      :complete => "Element.scrollTo('preview')"
                                    }, :accesskey => accesskey(:preview) %>
                 <%= javascript_tag "Form.Element.focus('issue_subject');" %>
             <% end %>
             <div id="preview" class="wiki"></div>
             <% content_for :header_tags do %>
                 <%= stylesheet_link_tag 'scm' %>
                 <%= robot_exclusion_tag %>
             <% end %>

app/views/watchers/_new.html.erb +2 -2

             <h3 class="title"><%= l(:permission_add_issue_watchers) %></h3>
             <% form_remote_tag :url => {:controller => 'watchers',
-                                        :action => 'create',
+                                        :action => (watched ? 'create' : 'append'),
                                         :object_type => watched.class.name.underscore,
                                         :object_id => watched},
                                  :method => :post,
                                  :html => {:id => 'new-watcher-form'} do %>
               <p><%= label_tag 'user_search', l(:label_user_search) %><%= text_field_tag 'user_search', nil %></p>
               <%= observe_field(:user_search,
                            :frequency => 0.5,
                            :update => :users_for_watcher,
                            :method => :get,
                            :before => '$("user_search").addClassName("ajax-loading")',
                            :complete => '$("user_search").removeClassName("ajax-loading")',
                            :url => {
                              :controller => 'watchers',
                              :action => 'autocomplete_for_user',
                              :object_type => watched.class.name.underscore,
                              :object_id => watched},
                            :with => 'q') %>
               <div id="users_for_watcher">
-                <%= principals_check_box_tags 'watcher[user_ids][]', watched.addable_watcher_users %>
+                <%= principals_check_box_tags 'watcher[user_ids][]', (watched ? watched.addable_watcher_users : User.active.all(:limit => 100)) %>
               </div>
               <p class="buttons">
                 <%= submit_tag l(:button_add), :name => nil, :onclick => "hideModal(this);" %>
                 <%= submit_tag l(:button_cancel), :name => nil, :onclick => "hideModal(this);", :type => 'button' %>
               </p>
             <% end %>

config/locales/en.yml +1 0

             en:
               # Text direction: Left-to-Right (ltr) or Right-to-Left (rtl)
               direction: ltr
               date:
                 formats:
                   # Use the strftime parameters for formats.
                   # When no format has been given, it uses default.
                   # You can provide other formats here if you like!
                   default: "%m/%d/%Y"
                   short: "%b %d"
                   long: "%B %d, %Y"
                 day_names: [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]
                 abbr_day_names: [Sun, Mon, Tue, Wed, Thu, Fri, Sat]
                 # Don't forget the nil at the beginning; there's no such thing as a 0th month
                 month_names: [~, January, February, March, April, May, June, July, August, September, October, November, December]
                 abbr_month_names: [~, Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec]
                 # Used in date_select and datime_select.
                 order:
                   - :year
                   - :month
                   - :day
               time:
                 formats:
                   default: "%m/%d/%Y %I:%M %p"
                   time: "%I:%M %p"
                   short: "%d %b %H:%M"
                   long: "%B %d, %Y %H:%M"
                 am: "am"
                 pm: "pm"
               datetime:
                 distance_in_words:
                   half_a_minute: "half a minute"
                   less_than_x_seconds:
                     one:   "less than 1 second"
                     other: "less than %{count} seconds"
                   x_seconds:
                     one:   "1 second"
                     other: "%{count} seconds"
                   less_than_x_minutes:
                     one:   "less than a minute"
                     other: "less than %{count} minutes"
                   x_minutes:
                     one:   "1 minute"
                     other: "%{count} minutes"
                   about_x_hours:
                     one:   "about 1 hour"
                     other: "about %{count} hours"
                   x_days:
                     one:   "1 day"
                     other: "%{count} days"
                   about_x_months:
                     one:   "about 1 month"
                     other: "about %{count} months"
                   x_months:
                     one:   "1 month"
                     other: "%{count} months"
                   about_x_years:
                     one:   "about 1 year"
                     other: "about %{count} years"
                   over_x_years:
                     one:   "over 1 year"
                     other: "over %{count} years"
                   almost_x_years:
                     one:   "almost 1 year"
                     other: "almost %{count} years"
               number:
                 format:
                   separator: "."
                   delimiter: ""
                   precision: 3
                 human:
                   format:
                     delimiter: ""
                     precision: 1
                   storage_units:
                     format: "%n %u"
                     units:
                       byte:
                         one: "Byte"
                         other: "Bytes"
                       kb: "kB"
                       mb: "MB"
                       gb: "GB"
                       tb: "TB"
             # Used in array.to_sentence.
               support:
                 array:
                   sentence_connector: "and"
                   skip_last_comma: false
               activerecord:
                 errors:
                   template:
                     header:
                       one:    "1 error prohibited this %{model} from being saved"
                       other:  "%{count} errors prohibited this %{model} from being saved"
                   messages:
                     inclusion: "is not included in the list"
                     exclusion: "is reserved"
                     invalid: "is invalid"
                     confirmation: "doesn't match confirmation"
                     accepted: "must be accepted"
                     empty: "can't be empty"
                     blank: "can't be blank"
                     too_long: "is too long (maximum is %{count} characters)"
                     too_short: "is too short (minimum is %{count} characters)"
                     wrong_length: "is the wrong length (should be %{count} characters)"
                     taken: "has already been taken"
                     not_a_number: "is not a number"
                     not_a_date: "is not a valid date"
                     greater_than: "must be greater than %{count}"
                     greater_than_or_equal_to: "must be greater than or equal to %{count}"
                     equal_to: "must be equal to %{count}"
                     less_than: "must be less than %{count}"
                     less_than_or_equal_to: "must be less than or equal to %{count}"
                     odd: "must be odd"
                     even: "must be even"
                     greater_than_start_date: "must be greater than start date"
                     not_same_project: "doesn't belong to the same project"
                     circular_dependency: "This relation would create a circular dependency"
                     cant_link_an_issue_with_a_descendant: "An issue cannot be linked to one of its subtasks"
               actionview_instancetag_blank_option: Please select
               general_text_No: 'No'
               general_text_Yes: 'Yes'
               general_text_no: 'no'
               general_text_yes: 'yes'
               general_lang_name: 'English'
               general_csv_separator: ','
               general_csv_decimal_separator: '.'
               general_csv_encoding: ISO-8859-1
               general_pdf_encoding: UTF-8
               general_first_day_of_week: '7'
               notice_account_updated: Account was successfully updated.
               notice_account_invalid_creditentials: Invalid user or password
               notice_account_password_updated: Password was successfully updated.
               notice_account_wrong_password: Wrong password
               notice_account_register_done: Account was successfully created. To activate your account, click on the link that was emailed to you.
               notice_account_unknown_email: Unknown user.
               notice_can_t_change_password: This account uses an external authentication source. Impossible to change the password.
               notice_account_lost_email_sent: An email with instructions to choose a new password has been sent to you.
               notice_account_activated: Your account has been activated. You can now log in.
               notice_successful_create: Successful creation.
               notice_successful_update: Successful update.
               notice_successful_delete: Successful deletion.
               notice_successful_connection: Successful connection.
               notice_file_not_found: The page you were trying to access doesn't exist or has been removed.
               notice_locking_conflict: Data has been updated by another user.
               notice_not_authorized: You are not authorized to access this page.
               notice_not_authorized_archived_project: The project you're trying to access has been archived.
               notice_email_sent: "An email was sent to %{value}"
               notice_email_error: "An error occurred while sending mail (%{value})"
               notice_feeds_access_key_reseted: Your RSS access key was reset.
               notice_api_access_key_reseted: Your API access key was reset.
               notice_failed_to_save_issues: "Failed to save %{count} issue(s) on %{total} selected: %{ids}."
               notice_failed_to_save_time_entries: "Failed to save %{count} time entrie(s) on %{total} selected: %{ids}."
               notice_failed_to_save_members: "Failed to save member(s): %{errors}."
               notice_no_issue_selected: "No issue is selected! Please, check the issues you want to edit."
               notice_account_pending: "Your account was created and is now pending administrator approval."
               notice_default_data_loaded: Default configuration successfully loaded.
               notice_unable_delete_version: Unable to delete version.
               notice_unable_delete_time_entry: Unable to delete time log entry.
               notice_issue_done_ratios_updated: Issue done ratios updated.
               notice_gantt_chart_truncated: "The chart was truncated because it exceeds the maximum number of items that can be displayed (%{max})"
               notice_issue_successful_create: "Issue %{id} created."
               notice_issue_update_conflict: "The issue has been updated by an other user while you were editing it."
               error_can_t_load_default_data: "Default configuration could not be loaded: %{value}"
               error_scm_not_found: "The entry or revision was not found in the repository."
               error_scm_command_failed: "An error occurred when trying to access the repository: %{value}"
               error_scm_annotate: "The entry does not exist or cannot be annotated."
               error_scm_annotate_big_text_file: "The entry cannot be annotated, as it exceeds the maximum text file size."
               error_issue_not_found_in_project: 'The issue was not found or does not belong to this project'
               error_no_tracker_in_project: 'No tracker is associated to this project. Please check the Project settings.'
               error_no_default_issue_status: 'No default issue status is defined. Please check your configuration (Go to "Administration -> Issue statuses").'
               error_can_not_delete_custom_field: Unable to delete custom field
               error_can_not_delete_tracker: "This tracker contains issues and cannot be deleted."
               error_can_not_remove_role: "This role is in use and cannot be deleted."
               error_can_not_reopen_issue_on_closed_version: 'An issue assigned to a closed version cannot be reopened'
               error_can_not_archive_project: This project cannot be archived
               error_issue_done_ratios_not_updated: "Issue done ratios not updated."
               error_workflow_copy_source: 'Please select a source tracker or role'
               error_workflow_copy_target: 'Please select target tracker(s) and role(s)'
               error_unable_delete_issue_status: 'Unable to delete issue status'
               error_unable_to_connect: "Unable to connect (%{value})"
               error_attachment_too_big: "This file cannot be uploaded because it exceeds the maximum allowed file size (%{max_size})"
               warning_attachments_not_saved: "%{count} file(s) could not be saved."
               mail_subject_lost_password: "Your %{value} password"
               mail_body_lost_password: 'To change your password, click on the following link:'
               mail_subject_register: "Your %{value} account activation"
               mail_body_register: 'To activate your account, click on the following link:'
               mail_body_account_information_external: "You can use your %{value} account to log in."
               mail_body_account_information: Your account information
               mail_subject_account_activation_request: "%{value} account activation request"
               mail_body_account_activation_request: "A new user (%{value}) has registered. The account is pending your approval:"
               mail_subject_reminder: "%{count} issue(s) due in the next %{days} days"
               mail_body_reminder: "%{count} issue(s) that are assigned to you are due in the next %{days} days:"
               mail_subject_wiki_content_added: "'%{id}' wiki page has been added"
               mail_body_wiki_content_added: "The '%{id}' wiki page has been added by %{author}."
               mail_subject_wiki_content_updated: "'%{id}' wiki page has been updated"
               mail_body_wiki_content_updated: "The '%{id}' wiki page has been updated by %{author}."
               gui_validation_error: 1 error
               gui_validation_error_plural: "%{count} errors"
               field_name: Name
               field_description: Description
               field_summary: Summary
               field_is_required: Required
               field_firstname: First name
               field_lastname: Last name
               field_mail: Email
               field_filename: File
               field_filesize: Size
               field_downloads: Downloads
               field_author: Author
               field_created_on: Created
               field_updated_on: Updated
               field_field_format: Format
               field_is_for_all: For all projects
               field_possible_values: Possible values
               field_regexp: Regular expression
               field_min_length: Minimum length
               field_max_length: Maximum length
               field_value: Value
               field_category: Category
               field_title: Title
               field_project: Project
               field_issue: Issue
               field_status: Status
               field_notes: Notes
               field_is_closed: Issue closed
               field_is_default: Default value
               field_tracker: Tracker
               field_subject: Subject
               field_due_date: Due date
               field_assigned_to: Assignee
               field_priority: Priority
               field_fixed_version: Target version
               field_user: User
               field_principal: Principal
               field_role: Role
               field_homepage: Homepage
               field_is_public: Public
               field_parent: Subproject of
               field_is_in_roadmap: Issues displayed in roadmap
               field_login: Login
               field_mail_notification: Email notifications
               field_admin: Administrator
               field_last_login_on: Last connection
               field_language: Language
               field_effective_date: Date
               field_password: Password
               field_new_password: New password
               field_password_confirmation: Confirmation
               field_version: Version
               field_type: Type
               field_host: Host
               field_port: Port
               field_account: Account
               field_base_dn: Base DN
               field_attr_login: Login attribute
               field_attr_firstname: Firstname attribute
               field_attr_lastname: Lastname attribute
               field_attr_mail: Email attribute
               field_onthefly: On-the-fly user creation
               field_start_date: Start date
               field_done_ratio: "% Done"
               field_auth_source: Authentication mode
               field_hide_mail: Hide my email address
               field_comments: Comment
               field_url: URL
               field_start_page: Start page
               field_subproject: Subproject
               field_hours: Hours
               field_activity: Activity
               field_spent_on: Date
               field_identifier: Identifier
               field_is_filter: Used as a filter
               field_issue_to: Related issue
               field_delay: Delay
               field_assignable: Issues can be assigned to this role
               field_redirect_existing_links: Redirect existing links
               field_estimated_hours: Estimated time
               field_column_names: Columns
               field_time_entries: Log time
               field_time_zone: Time zone
               field_searchable: Searchable
               field_default_value: Default value
               field_comments_sorting: Display comments
               field_parent_title: Parent page
               field_editable: Editable
               field_watcher: Watcher
               field_identity_url: OpenID URL
               field_content: Content
               field_group_by: Group results by
               field_sharing: Sharing
               field_parent_issue: Parent task
               field_member_of_group: "Assignee's group"
               field_assigned_to_role: "Assignee's role"
               field_text: Text field
               field_visible: Visible
               field_warn_on_leaving_unsaved: "Warn me when leaving a page with unsaved text"
               field_issues_visibility: Issues visibility
               field_is_private: Private
               field_commit_logs_encoding: Commit messages encoding
               field_scm_path_encoding: Path encoding
               field_path_to_repository: Path to repository
               field_root_directory: Root directory
               field_cvsroot: CVSROOT
               field_cvs_module: Module
               field_repository_is_default: Main repository
               field_multiple: Multiple values
               field_ldap_filter: LDAP filter
               setting_app_title: Application title
               setting_app_subtitle: Application subtitle
               setting_welcome_text: Welcome text
               setting_default_language: Default language
               setting_login_required: Authentication required
               setting_self_registration: Self-registration
               setting_attachment_max_size: Maximum attachment size
               setting_issues_export_limit: Issues export limit
               setting_mail_from: Emission email address
               setting_bcc_recipients: Blind carbon copy recipients (bcc)
               setting_plain_text_mail: Plain text mail (no HTML)
               setting_host_name: Host name and path
               setting_text_formatting: Text formatting
               setting_wiki_compression: Wiki history compression
               setting_feeds_limit: Maximum number of items in Atom feeds
               setting_default_projects_public: New projects are public by default
               setting_autofetch_changesets: Fetch commits automatically
               setting_sys_api_enabled: Enable WS for repository management
               setting_commit_ref_keywords: Referencing keywords
               setting_commit_fix_keywords: Fixing keywords
               setting_autologin: Autologin
               setting_date_format: Date format
               setting_time_format: Time format
               setting_cross_project_issue_relations: Allow cross-project issue relations
               setting_issue_list_default_columns: Default columns displayed on the issue list
               setting_repositories_encodings: Attachments and repositories encodings
               setting_emails_header: Emails header
               setting_emails_footer: Emails footer
               setting_protocol: Protocol
               setting_per_page_options: Objects per page options
               setting_user_format: Users display format
               setting_activity_days_default: Days displayed on project activity
               setting_display_subprojects_issues: Display subprojects issues on main projects by default
               setting_enabled_scm: Enabled SCM
               setting_mail_handler_body_delimiters: "Truncate emails after one of these lines"
               setting_mail_handler_api_enabled: Enable WS for incoming emails
               setting_mail_handler_api_key: API key
               setting_sequential_project_identifiers: Generate sequential project identifiers
               setting_gravatar_enabled: Use Gravatar user icons
               setting_gravatar_default: Default Gravatar image
               setting_diff_max_lines_displayed: Maximum number of diff lines displayed
               setting_file_max_size_displayed: Maximum size of text files displayed inline
               setting_repository_log_display_limit: Maximum number of revisions displayed on file log
               setting_openid: Allow OpenID login and registration
               setting_password_min_length: Minimum password length
               setting_new_project_user_role_id: Role given to a non-admin user who creates a project
               setting_default_projects_modules: Default enabled modules for new projects
               setting_issue_done_ratio: Calculate the issue done ratio with
               setting_issue_done_ratio_issue_field: Use the issue field
               setting_issue_done_ratio_issue_status: Use the issue status
               setting_start_of_week: Start calendars on
               setting_rest_api_enabled: Enable REST web service
               setting_cache_formatted_text: Cache formatted text
               setting_default_notification_option: Default notification option
               setting_commit_logtime_enabled: Enable time logging
               setting_commit_logtime_activity_id: Activity for logged time
               setting_gantt_items_limit: Maximum number of items displayed on the gantt chart
               setting_issue_group_assignment: Allow issue assignment to groups
               setting_default_issue_start_date_to_creation_date: Use current date as start date for new issues
               setting_commit_cross_project_ref: Allow issues of all the other projects to be referenced and fixed
               permission_add_project: Create project
               permission_add_subprojects: Create subprojects
               permission_edit_project: Edit project
               permission_select_project_modules: Select project modules
               permission_manage_members: Manage members
               permission_manage_project_activities: Manage project activities
               permission_manage_versions: Manage versions
               permission_manage_categories: Manage issue categories
               permission_view_issues: View Issues
               permission_add_issues: Add issues
               permission_edit_issues: Edit issues
               permission_manage_issue_relations: Manage issue relations
               permission_set_issues_private: Set issues public or private
               permission_set_own_issues_private: Set own issues public or private
               permission_add_issue_notes: Add notes
               permission_edit_issue_notes: Edit notes
               permission_edit_own_issue_notes: Edit own notes
               permission_move_issues: Move issues
               permission_delete_issues: Delete issues
               permission_manage_public_queries: Manage public queries
               permission_save_queries: Save queries
               permission_view_gantt: View gantt chart
               permission_view_calendar: View calendar
               permission_view_issue_watchers: View watchers list
               permission_add_issue_watchers: Add watchers
               permission_delete_issue_watchers: Delete watchers
               permission_log_time: Log spent time
               permission_view_time_entries: View spent time
               permission_edit_time_entries: Edit time logs
               permission_edit_own_time_entries: Edit own time logs
               permission_manage_news: Manage news
               permission_comment_news: Comment news
               permission_manage_documents: Manage documents
               permission_view_documents: View documents
               permission_manage_files: Manage files
               permission_view_files: View files
               permission_manage_wiki: Manage wiki
               permission_rename_wiki_pages: Rename wiki pages
               permission_delete_wiki_pages: Delete wiki pages
               permission_view_wiki_pages: View wiki
               permission_view_wiki_edits: View wiki history
               permission_edit_wiki_pages: Edit wiki pages
               permission_delete_wiki_pages_attachments: Delete attachments
               permission_protect_wiki_pages: Protect wiki pages
               permission_manage_repository: Manage repository
               permission_browse_repository: Browse repository
               permission_view_changesets: View changesets
               permission_commit_access: Commit access
               permission_manage_boards: Manage forums
               permission_view_messages: View messages
               permission_add_messages: Post messages
               permission_edit_messages: Edit messages
               permission_edit_own_messages: Edit own messages
               permission_delete_messages: Delete messages
               permission_delete_own_messages: Delete own messages
               permission_export_wiki_pages: Export wiki pages
               permission_manage_subtasks: Manage subtasks
               permission_manage_related_issues: Manage related issues
               project_module_issue_tracking: Issue tracking
               project_module_time_tracking: Time tracking
               project_module_news: News
               project_module_documents: Documents
               project_module_files: Files
               project_module_wiki: Wiki
               project_module_repository: Repository
               project_module_boards: Forums
               project_module_calendar: Calendar
               project_module_gantt: Gantt
               label_user: User
               label_user_plural: Users
               label_user_new: New user
               label_user_anonymous: Anonymous
               label_project: Project
               label_project_new: New project
               label_project_plural: Projects
               label_x_projects:
                 zero:  no projects
                 one:   1 project
                 other: "%{count} projects"
               label_project_all: All Projects
               label_project_latest: Latest projects
               label_issue: Issue
               label_issue_new: New issue
               label_issue_plural: Issues
               label_issue_view_all: View all issues
               label_issues_by: "Issues by %{value}"
               label_issue_added: Issue added
               label_issue_updated: Issue updated
               label_issue_note_added: Note added
               label_issue_status_updated: Status updated
               label_issue_priority_updated: Priority updated
               label_document: Document
               label_document_new: New document
               label_document_plural: Documents
               label_document_added: Document added
               label_role: Role
               label_role_plural: Roles
               label_role_new: New role
               label_role_and_permissions: Roles and permissions
               label_role_anonymous: Anonymous
               label_role_non_member: Non member
               label_member: Member
               label_member_new: New member
               label_member_plural: Members
               label_tracker: Tracker
               label_tracker_plural: Trackers
               label_tracker_new: New tracker
               label_workflow: Workflow
               label_issue_status: Issue status
               label_issue_status_plural: Issue statuses
               label_issue_status_new: New status
               label_issue_category: Issue category
               label_issue_category_plural: Issue categories
               label_issue_category_new: New category
               label_custom_field: Custom field
               label_custom_field_plural: Custom fields
               label_custom_field_new: New custom field
               label_enumerations: Enumerations
               label_enumeration_new: New value
               label_information: Information
               label_information_plural: Information
               label_please_login: Please log in
               label_register: Register
               label_login_with_open_id_option: or login with OpenID
               label_password_lost: Lost password
               label_home: Home
               label_my_page: My page
               label_my_account: My account
               label_my_projects: My projects
               label_my_page_block: My page block
               label_administration: Administration
               label_login: Sign in
               label_logout: Sign out
               label_help: Help
               label_reported_issues: Reported issues
               label_assigned_to_me_issues: Issues assigned to me
               label_last_login: Last connection
               label_registered_on: Registered on
               label_activity: Activity
               label_overall_activity: Overall activity
               label_user_activity: "%{value}'s activity"
               label_new: New
               label_logged_as: Logged in as
               label_environment: Environment
               label_authentication: Authentication
               label_auth_source: Authentication mode
               label_auth_source_new: New authentication mode
               label_auth_source_plural: Authentication modes
               label_subproject_plural: Subprojects
               label_subproject_new: New subproject
               label_and_its_subprojects: "%{value} and its subprojects"
               label_min_max_length: Min - Max length
               label_list: List
               label_date: Date
               label_integer: Integer
               label_float: Float
               label_boolean: Boolean
               label_string: Text
               label_text: Long text
               label_attribute: Attribute
               label_attribute_plural: Attributes
               label_download: "%{count} Download"
               label_download_plural: "%{count} Downloads"
               label_no_data: No data to display
               label_change_status: Change status
               label_history: History
               label_attachment: File
               label_attachment_new: New file
               label_attachment_delete: Delete file
               label_attachment_plural: Files
               label_file_added: File added
               label_report: Report
               label_report_plural: Reports
               label_news: News
               label_news_new: Add news
               label_news_plural: News
               label_news_latest: Latest news
               label_news_view_all: View all news
               label_news_added: News added
               label_news_comment_added: Comment added to a news
               label_settings: Settings
               label_overview: Overview
               label_version: Version
               label_version_new: New version
               label_version_plural: Versions
               label_close_versions: Close completed versions
               label_confirmation: Confirmation
               label_export_to: 'Also available in:'
               label_read: Read...
               label_public_projects: Public projects
               label_open_issues: open
               label_open_issues_plural: open
               label_closed_issues: closed
               label_closed_issues_plural: closed
               label_x_open_issues_abbr_on_total:
                 zero:  0 open / %{total}
                 one:   1 open / %{total}
                 other: "%{count} open / %{total}"
               label_x_open_issues_abbr:
                 zero:  0 open
                 one:   1 open
                 other: "%{count} open"
               label_x_closed_issues_abbr:
                 zero:  0 closed
                 one:   1 closed
                 other: "%{count} closed"
               label_x_issues:
                 zero:  0 issues
                 one:   1 issue
                 other: "%{count} issues"
               label_total: Total
               label_permissions: Permissions
               label_current_status: Current status
               label_new_statuses_allowed: New statuses allowed
               label_all: all
               label_none: none
               label_nobody: nobody
               label_next: Next
               label_previous: Previous
               label_used_by: Used by
               label_details: Details
               label_add_note: Add a note
               label_per_page: Per page
               label_calendar: Calendar
               label_months_from: months from
               label_gantt: Gantt
               label_internal: Internal
               label_last_changes: "last %{count} changes"
               label_change_view_all: View all changes
               label_personalize_page: Personalize this page
               label_comment: Comment
               label_comment_plural: Comments
               label_x_comments:
                 zero: no comments
                 one: 1 comment
                 other: "%{count} comments"
               label_comment_add: Add a comment
               label_comment_added: Comment added
               label_comment_delete: Delete comments
               label_query: Custom query
               label_query_plural: Custom queries
               label_query_new: New query
               label_my_queries: My custom queries
               label_filter_add: Add filter
               label_filter_plural: Filters
               label_equals: is
               label_not_equals: is not
               label_in_less_than: in less than
               label_in_more_than: in more than
               label_greater_or_equal: '>='
               label_less_or_equal: '<='
               label_between: between
               label_in: in
               label_today: today
               label_all_time: all time
               label_yesterday: yesterday
               label_this_week: this week
               label_last_week: last week
               label_last_n_days: "last %{count} days"
               label_this_month: this month
               label_last_month: last month
               label_this_year: this year
               label_date_range: Date range
               label_less_than_ago: less than days ago
               label_more_than_ago: more than days ago
               label_ago: days ago
               label_contains: contains
               label_not_contains: doesn't contain
               label_day_plural: days
               label_repository: Repository
               label_repository_new: New repository
               label_repository_plural: Repositories
               label_browse: Browse
               label_modification: "%{count} change"
               label_modification_plural: "%{count} changes"
               label_branch: Branch
               label_tag: Tag
               label_revision: Revision
               label_revision_plural: Revisions
               label_revision_id: "Revision %{value}"
               label_associated_revisions: Associated revisions
               label_added: added
               label_modified: modified
               label_copied: copied
               label_renamed: renamed
               label_deleted: deleted
               label_latest_revision: Latest revision
               label_latest_revision_plural: Latest revisions
               label_view_revisions: View revisions
               label_view_all_revisions: View all revisions
               label_max_size: Maximum size
               label_sort_highest: Move to top
               label_sort_higher: Move up
               label_sort_lower: Move down
               label_sort_lowest: Move to bottom
               label_roadmap: Roadmap
               label_roadmap_due_in: "Due in %{value}"
               label_roadmap_overdue: "%{value} late"
               label_roadmap_no_issues: No issues for this version
               label_search: Search
               label_result_plural: Results
               label_all_words: All words
               label_wiki: Wiki
               label_wiki_edit: Wiki edit
               label_wiki_edit_plural: Wiki edits
               label_wiki_page: Wiki page
               label_wiki_page_plural: Wiki pages
               label_index_by_title: Index by title
               label_index_by_date: Index by date
               label_current_version: Current version
               label_preview: Preview
               label_feed_plural: Feeds
               label_changes_details: Details of all changes
               label_issue_tracking: Issue tracking
               label_spent_time: Spent time
               label_overall_spent_time: Overall spent time
               label_f_hour: "%{value} hour"
               label_f_hour_plural: "%{value} hours"
               label_time_tracking: Time tracking
               label_change_plural: Changes
               label_statistics: Statistics
               label_commits_per_month: Commits per month
               label_commits_per_author: Commits per author
               label_diff: diff
               label_view_diff: View differences
               label_diff_inline: inline
               label_diff_side_by_side: side by side
               label_options: Options
               label_copy_workflow_from: Copy workflow from
               label_permissions_report: Permissions report
               label_watched_issues: Watched issues
               label_related_issues: Related issues
               label_applied_status: Applied status
               label_loading: Loading...
               label_relation_new: New relation
               label_relation_delete: Delete relation
               label_relates_to: related to
               label_duplicates: duplicates
               label_duplicated_by: duplicated by
               label_blocks: blocks
               label_blocked_by: blocked by
               label_precedes: precedes
               label_follows: follows
               label_end_to_start: end to start
               label_end_to_end: end to end
               label_start_to_start: start to start
               label_start_to_end: start to end
               label_stay_logged_in: Stay logged in
               label_disabled: disabled
               label_show_completed_versions: Show completed versions
               label_me: me
               label_board: Forum
               label_board_new: New forum
               label_board_plural: Forums
               label_board_locked: Locked
               label_board_sticky: Sticky
               label_topic_plural: Topics
               label_message_plural: Messages
               label_message_last: Last message
               label_message_new: New message
               label_message_posted: Message added
               label_reply_plural: Replies
               label_send_information: Send account information to the user
               label_year: Year
               label_month: Month
               label_week: Week
               label_date_from: From
               label_date_to: To
               label_language_based: Based on user's language
               label_sort_by: "Sort by %{value}"
               label_send_test_email: Send a test email
               label_feeds_access_key: RSS access key
               label_missing_feeds_access_key: Missing a RSS access key
               label_feeds_access_key_created_on: "RSS access key created %{value} ago"
               label_module_plural: Modules
               label_added_time_by: "Added by %{author} %{age} ago"
               label_updated_time_by: "Updated by %{author} %{age} ago"
               label_updated_time: "Updated %{value} ago"
               label_jump_to_a_project: Jump to a project...
               label_file_plural: Files
               label_changeset_plural: Changesets
               label_default_columns: Default columns
               label_no_change_option: (No change)
               label_bulk_edit_selected_issues: Bulk edit selected issues
               label_bulk_edit_selected_time_entries: Bulk edit selected time entries
               label_theme: Theme
               label_default: Default
               label_search_titles_only: Search titles only
               label_user_mail_option_all: "For any event on all my projects"
               label_user_mail_option_selected: "For any event on the selected projects only..."
               label_user_mail_option_none: "No events"
               label_user_mail_option_only_my_events: "Only for things I watch or I'm involved in"
               label_user_mail_option_only_assigned: "Only for things I am assigned to"
               label_user_mail_option_only_owner: "Only for things I am the owner of"
               label_user_mail_no_self_notified: "I don't want to be notified of changes that I make myself"
               label_registration_activation_by_email: account activation by email
               label_registration_manual_activation: manual account activation
               label_registration_automatic_activation: automatic account activation
               label_display_per_page: "Per page: %{value}"
               label_age: Age
               label_change_properties: Change properties
               label_general: General
               label_more: More
               label_scm: SCM
               label_plugins: Plugins
               label_ldap_authentication: LDAP authentication
               label_downloads_abbr: D/L
               label_optional_description: Optional description
               label_add_another_file: Add another file
               label_preferences: Preferences
               label_chronological_order: In chronological order
               label_reverse_chronological_order: In reverse chronological order
               label_planning: Planning
               label_incoming_emails: Incoming emails
               label_generate_key: Generate a key
               label_issue_watchers: Watchers
               label_example: Example
               label_display: Display
               label_sort: Sort
               label_ascending: Ascending
               label_descending: Descending
               label_date_from_to: From %{start} to %{end}
               label_wiki_content_added: Wiki page added
               label_wiki_content_updated: Wiki page updated
               label_group: Group
               label_group_plural: Groups
               label_group_new: New group
               label_time_entry_plural: Spent time
               label_version_sharing_none: Not shared
               label_version_sharing_descendants: With subprojects
               label_version_sharing_hierarchy: With project hierarchy
               label_version_sharing_tree: With project tree
               label_version_sharing_system: With all projects
               label_update_issue_done_ratios: Update issue done ratios
               label_copy_source: Source
               label_copy_target: Target
               label_copy_same_as_target: Same as target
               label_display_used_statuses_only: Only display statuses that are used by this tracker
               label_api_access_key: API access key
               label_missing_api_access_key: Missing an API access key
               label_api_access_key_created_on: "API access key created %{value} ago"
               label_profile: Profile
               label_subtask_plural: Subtasks
               label_project_copy_notifications: Send email notifications during the project copy
               label_principal_search: "Search for user or group:"
               label_user_search: "Search for user:"
               label_additional_workflow_transitions_for_author: Additional transitions allowed when the user is the author
               label_additional_workflow_transitions_for_assignee: Additional transitions allowed when the user is the assignee
               label_issues_visibility_all: All issues
               label_issues_visibility_public: All non private issues
               label_issues_visibility_own: Issues created by or assigned to the user
               label_git_report_last_commit: Report last commit for files and directories
               label_parent_revision: Parent
               label_child_revision: Child
               label_export_options: "%{export_format} export options"
               label_copy_attachments: Copy attachments
               label_item_position: "%{position} of %{count}"
               label_completed_versions: Completed versions
+              label_search_for_watchers: Search for watchers to add
               button_login: Login
               button_submit: Submit
               button_save: Save
               button_check_all: Check all
               button_uncheck_all: Uncheck all
               button_collapse_all: Collapse all
               button_expand_all: Expand all
               button_delete: Delete
               button_create: Create
               button_create_and_continue: Create and continue
               button_test: Test
               button_edit: Edit
               button_edit_associated_wikipage: "Edit associated Wiki page: %{page_title}"
               button_add: Add
               button_change: Change
               button_apply: Apply
               button_clear: Clear
               button_lock: Lock
               button_unlock: Unlock
               button_download: Download
               button_list: List
               button_view: View
               button_move: Move
               button_move_and_follow: Move and follow
               button_back: Back
               button_cancel: Cancel
               button_activate: Activate
               button_sort: Sort
               button_log_time: Log time
               button_rollback: Rollback to this version
               button_watch: Watch
               button_unwatch: Unwatch
               button_reply: Reply
               button_archive: Archive
               button_unarchive: Unarchive
               button_reset: Reset
               button_rename: Rename
               button_change_password: Change password
               button_copy: Copy
               button_copy_and_follow: Copy and follow
               button_annotate: Annotate
               button_update: Update
               button_configure: Configure
               button_quote: Quote
               button_duplicate: Duplicate
               button_show: Show
               button_edit_section: Edit this section
               button_export: Export
               status_active: active
               status_registered: registered
               status_locked: locked
               version_status_open: open
               version_status_locked: locked
               version_status_closed: closed
               field_active: Active
               text_select_mail_notifications: Select actions for which email notifications should be sent.
               text_regexp_info: eg. ^[A-Z0-9]+$
               text_min_max_length_info: 0 means no restriction
               text_project_destroy_confirmation: Are you sure you want to delete this project and related data?
               text_subprojects_destroy_warning: "Its subproject(s): %{value} will be also deleted."
               text_workflow_edit: Select a role and a tracker to edit the workflow
               text_are_you_sure: Are you sure?
               text_are_you_sure_with_children: "Delete issue and all child issues?"
               text_journal_changed: "%{label} changed from %{old} to %{new}"
               text_journal_changed_no_detail: "%{label} updated"
               text_journal_set_to: "%{label} set to %{value}"
               text_journal_deleted: "%{label} deleted (%{old})"
               text_journal_added: "%{label} %{value} added"
               text_tip_issue_begin_day: issue beginning this day
               text_tip_issue_end_day: issue ending this day
               text_tip_issue_begin_end_day: issue beginning and ending this day
               text_project_identifier_info: 'Only lower case letters (a-z), numbers, dashes and underscores are allowed.<br />Once saved, the identifier cannot be changed.'
               text_caracters_maximum: "%{count} characters maximum."
               text_caracters_minimum: "Must be at least %{count} characters long."
               text_length_between: "Length between %{min} and %{max} characters."
               text_tracker_no_workflow: No workflow defined for this tracker
               text_unallowed_characters: Unallowed characters
               text_comma_separated: Multiple values allowed (comma separated).
               text_line_separated: Multiple values allowed (one line for each value).
               text_issues_ref_in_commit_messages: Referencing and fixing issues in commit messages
               text_issue_added: "Issue %{id} has been reported by %{author}."
               text_issue_updated: "Issue %{id} has been updated by %{author}."
               text_wiki_destroy_confirmation: Are you sure you want to delete this wiki and all its content?
               text_issue_category_destroy_question: "Some issues (%{count}) are assigned to this category. What do you want to do?"
               text_issue_category_destroy_assignments: Remove category assignments
               text_issue_category_reassign_to: Reassign issues to this category
               text_user_mail_option: "For unselected projects, you will only receive notifications about things you watch or you're involved in (eg. issues you're the author or assignee)."
               text_no_configuration_data: "Roles, trackers, issue statuses and workflow have not been configured yet.\nIt is highly recommended to load the default configuration. You will be able to modify it once loaded."
               text_load_default_configuration: Load the default configuration
               text_status_changed_by_changeset: "Applied in changeset %{value}."
               text_time_logged_by_changeset: "Applied in changeset %{value}."
               text_issues_destroy_confirmation: 'Are you sure you want to delete the selected issue(s)?'
               text_issues_destroy_descendants_confirmation: "This will also delete %{count} subtask(s)."
               text_time_entries_destroy_confirmation: 'Are you sure you want to delete the selected time entr(y/ies)?'
               text_select_project_modules: 'Select modules to enable for this project:'
               text_default_administrator_account_changed: Default administrator account changed
               text_file_repository_writable: Attachments directory writable
               text_plugin_assets_writable: Plugin assets directory writable
               text_rmagick_available: RMagick available (optional)
               text_destroy_time_entries_question: "%{hours} hours were reported on the issues you are about to delete. What do you want to do?"
               text_destroy_time_entries: Delete reported hours
               text_assign_time_entries_to_project: Assign reported hours to the project
               text_reassign_time_entries: 'Reassign reported hours to this issue:'
               text_user_wrote: "%{value} wrote:"
               text_enumeration_destroy_question: "%{count} objects are assigned to this value."
               text_enumeration_category_reassign_to: 'Reassign them to this value:'
               text_email_delivery_not_configured: "Email delivery is not configured, and notifications are disabled.\nConfigure your SMTP server in config/configuration.yml and restart the application to enable them."
               text_repository_usernames_mapping: "Select or update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."
               text_diff_truncated: '... This diff was truncated because it exceeds the maximum size that can be displayed.'
               text_custom_field_possible_values_info: 'One line for each value'
               text_wiki_page_destroy_question: "This page has %{descendants} child page(s) and descendant(s). What do you want to do?"
               text_wiki_page_nullify_children: "Keep child pages as root pages"
               text_wiki_page_destroy_children: "Delete child pages and all their descendants"
               text_wiki_page_reassign_children: "Reassign child pages to this parent page"
               text_own_membership_delete_confirmation: "You are about to remove some or all of your permissions and may no longer be able to edit this project after that.\nAre you sure you want to continue?"
               text_zoom_in: Zoom in
               text_zoom_out: Zoom out
               text_warn_on_leaving_unsaved: "The current page contains unsaved text that will be lost if you leave this page."
               text_scm_path_encoding_note: "Default: UTF-8"
               text_git_repository_note: Repository is bare and local (e.g. /gitrepo, c:\gitrepo)
               text_mercurial_repository_note: Local repository (e.g. /hgrepo, c:\hgrepo)
               text_scm_command: Command
               text_scm_command_version: Version
               text_scm_config: You can configure your scm commands in config/configuration.yml. Please restart the application after editing it.
               text_scm_command_not_available: Scm command is not available. Please check settings on the administration panel.
               text_issue_conflict_resolution_overwrite: "Apply my changes anyway (previous notes will be kept but some changes may be overwritten)"
               text_issue_conflict_resolution_add_notes: "Add my notes and discard my other changes"
               text_issue_conflict_resolution_cancel: "Discard all my changes and redisplay %{link}"
               default_role_manager: Manager
               default_role_developer: Developer
               default_role_reporter: Reporter
               default_tracker_bug: Bug
               default_tracker_feature: Feature
               default_tracker_support: Support
               default_issue_status_new: New
               default_issue_status_in_progress: In Progress
               default_issue_status_resolved: Resolved
               default_issue_status_feedback: Feedback
               default_issue_status_closed: Closed
               default_issue_status_rejected: Rejected
               default_doc_category_user: User documentation
               default_doc_category_tech: Technical documentation
               default_priority_low: Low
               default_priority_normal: Normal
               default_priority_high: High
               default_priority_urgent: Urgent
               default_priority_immediate: Immediate
               default_activity_design: Design
               default_activity_development: Development
               enumeration_issue_priorities: Issue priorities
               enumeration_doc_categories: Document categories
               enumeration_activities: Activities (time tracking)
               enumeration_system_activity: System Activity
               description_filter: Filter
               description_search: Searchfield
               description_choose_project: Projects
               description_project_scope: Search scope
               description_notes: Notes
               description_message_content: Message content
               description_query_sort_criteria_attribute: Sort attribute
               description_query_sort_criteria_direction: Sort direction
               description_user_mail_notification: Mail notification settings
               description_available_columns: Available Columns
               description_selected_columns: Selected Columns
               description_all_columns: All Columns
               description_issue_category_reassign: Choose issue category
               description_wiki_subpages_reassign: Choose new parent page
               description_date_range_list: Choose range from list
               description_date_range_interval: Choose range by selecting start and end date
               description_date_from: Enter start date
               description_date_to: Enter end date

config/routes.rb +2 0

             ActionController::Routing::Routes.draw do |map|
               # Add your own custom routes here.
               # The priority is based upon order of creation: first created -> highest priority.
               # Here's a sample route:
               # map.connect 'products/:id', :controller => 'catalog', :action => 'view'
               # Keep in mind you can assign values other than :controller and :action
               map.home '', :controller => 'welcome', :conditions => {:method => :get}
               map.signin 'login', :controller => 'account', :action => 'login',
                          :conditions => {:method => [:get, :post]}
               map.signout 'logout', :controller => 'account', :action => 'logout',
                           :conditions => {:method => :get}
               map.connect 'account/register', :controller => 'account', :action => 'register',
                           :conditions => {:method => [:get, :post]}
               map.connect 'account/lost_password', :controller => 'account', :action => 'lost_password',
                           :conditions => {:method => [:get, :post]}
               map.connect 'account/activate', :controller => 'account', :action => 'activate',
                           :conditions => {:method => :get}
               map.connect 'projects/:id/wiki', :controller => 'wikis',
                           :action => 'edit', :conditions => {:method => :post}
               map.connect 'projects/:id/wiki/destroy', :controller => 'wikis',
                           :action => 'destroy', :conditions => {:method => [:get, :post]}
               map.with_options :controller => 'messages' do |messages_routes|
                 messages_routes.with_options :conditions => {:method => :get} do |messages_views|
                   messages_views.connect 'boards/:board_id/topics/new', :action => 'new'
                   messages_views.connect 'boards/:board_id/topics/:id', :action => 'show'
                   messages_views.connect 'boards/:board_id/topics/:id/edit', :action => 'edit'
                 end
                 messages_routes.with_options :conditions => {:method => :post} do |messages_actions|
                   messages_actions.connect 'boards/:board_id/topics/new', :action => 'new'
                   messages_actions.connect 'boards/:board_id/topics/preview', :action => 'preview'
                   messages_actions.connect 'boards/:board_id/topics/quote/:id', :action => 'quote'
                   messages_actions.connect 'boards/:board_id/topics/:id/replies', :action => 'reply'
                   messages_actions.connect 'boards/:board_id/topics/:id/edit', :action => 'edit'
                   messages_actions.connect 'boards/:board_id/topics/:id/destroy', :action => 'destroy'
                 end
               end
               # Misc issue routes. TODO: move into resources
               map.auto_complete_issues '/issues/auto_complete', :controller => 'auto_completes',
                                        :action => 'issues', :conditions => { :method => :get }
               # TODO: would look nicer as /issues/:id/preview
               map.preview_new_issue '/issues/preview/new/:project_id', :controller => 'previews',
                                     :action => 'issue'
               map.preview_edit_issue '/issues/preview/edit/:id', :controller => 'previews',
                                      :action => 'issue'
               map.issues_context_menu '/issues/context_menu',
                                       :controller => 'context_menus', :action => 'issues'
               map.issue_changes '/issues/changes', :controller => 'journals', :action => 'index'
               map.quoted_issue '/issues/:id/quoted', :controller => 'journals', :action => 'new',
                                :id => /\d+/, :conditions => { :method => :post }
               map.connect '/journals/diff/:id', :controller => 'journals', :action => 'diff',
                           :id => /\d+/, :conditions => { :method => :get }
               map.connect '/journals/edit/:id', :controller => 'journals', :action => 'edit',
                           :id => /\d+/, :conditions => { :method => [:get, :post] }
               map.with_options :controller => 'gantts', :action => 'show' do |gantts_routes|
                 gantts_routes.connect '/projects/:project_id/issues/gantt'
                 gantts_routes.connect '/projects/:project_id/issues/gantt.:format'
                 gantts_routes.connect '/issues/gantt.:format'
               end
               map.with_options :controller => 'calendars', :action => 'show' do |calendars_routes|
                 calendars_routes.connect '/projects/:project_id/issues/calendar'
                 calendars_routes.connect '/issues/calendar'
               end
               map.with_options :controller => 'reports', :conditions => {:method => :get} do |reports|
                 reports.connect 'projects/:id/issues/report', :action => 'issue_report'
                 reports.connect 'projects/:id/issues/report/:detail', :action => 'issue_report_details'
               end
               map.connect 'my/account', :controller => 'my', :action => 'account',
                           :conditions => {:method => [:get, :post]}
               map.connect 'my/page', :controller => 'my', :action => 'page',
                           :conditions => {:method => :get}
               # Redirects to my/page
               map.connect 'my', :controller => 'my', :action => 'index',
                           :conditions => {:method => :get}
               map.connect 'my/reset_rss_key', :controller => 'my', :action => 'reset_rss_key',
                           :conditions => {:method => :post}
               map.connect 'my/reset_api_key', :controller => 'my', :action => 'reset_api_key',
                           :conditions => {:method => :post}
               map.connect 'my/password', :controller => 'my', :action => 'password',
                           :conditions => {:method => [:get, :post]}
               map.connect 'my/page_layout', :controller => 'my', :action => 'page_layout',
                           :conditions => {:method => :get}
               map.connect 'my/add_block', :controller => 'my', :action => 'add_block',
                           :conditions => {:method => :post}
               map.connect 'my/remove_block', :controller => 'my', :action => 'remove_block',
                           :conditions => {:method => :post}
               map.connect 'my/order_blocks', :controller => 'my', :action => 'order_blocks',
                           :conditions => {:method => :post}
               map.with_options :controller => 'users' do |users|
                 users.user_membership 'users/:id/memberships/:membership_id',
                                       :action => 'edit_membership',
                                       :conditions => {:method => :put}
                 users.connect 'users/:id/memberships/:membership_id',
                               :action => 'destroy_membership',
                               :conditions => {:method => :delete}
                 users.user_memberships 'users/:id/memberships',
                                        :action => 'edit_membership',
                                        :conditions => {:method => :post}
               end
               map.resources :users
               # For nice "roadmap" in the url for the index action
               map.connect 'projects/:project_id/roadmap', :controller => 'versions', :action => 'index'
               map.preview_news '/news/preview', :controller => 'previews', :action => 'news'
               map.connect 'news/:id/comments', :controller => 'comments',
                           :action => 'create', :conditions => {:method => :post}
               map.connect 'news/:id/comments/:comment_id', :controller => 'comments',
                           :action => 'destroy', :conditions => {:method => :delete}
               map.connect 'watchers/new', :controller=> 'watchers', :action => 'new',
                           :conditions => {:method => :get}
               map.connect 'watchers', :controller=> 'watchers', :action => 'create',
                           :conditions => {:method => :post}
+              map.connect 'watchers/append', :controller=> 'watchers', :action => 'append',
+                          :conditions => {:method => :post}
               map.connect 'watchers/destroy', :controller=> 'watchers', :action => 'destroy',
                           :conditions => {:method => :post}
               map.connect 'watchers/watch', :controller=> 'watchers', :action => 'watch',
                           :conditions => {:method => :post}
               map.connect 'watchers/unwatch', :controller=> 'watchers', :action => 'unwatch',
                           :conditions => {:method => :post}
               map.connect 'watchers/autocomplete_for_user', :controller=> 'watchers', :action => 'autocomplete_for_user',
                           :conditions => {:method => :get}
               # TODO: port to be part of the resources route(s)
               map.with_options :conditions => {:method => :get} do |project_views|
                 project_views.connect 'projects/:id/settings/:tab',
                                       :controller => 'projects', :action => 'settings'
                 project_views.connect 'projects/:project_id/issues/:copy_from/copy',
                                       :controller => 'issues', :action => 'new'
               end
               map.resources :projects, :member => {
                 :copy => [:get, :post],
                 :settings => :get,
                 :modules => :post,
                 :archive => :post,
                 :unarchive => :post
               } do |project|
                 project.resource :enumerations, :controller => 'project_enumerations',
                                  :only => [:update, :destroy]
                 # issue form update
                 project.issue_form 'issues/new', :controller => 'issues',
                                    :action => 'new', :conditions => {:method => [:post, :put]}
                 project.resources :issues, :only => [:index, :new, :create] do |issues|
                   issues.resources :time_entries, :controller => 'timelog',
                                    :collection => {:report => :get}
                 end
                 project.resources :files, :only => [:index, :new, :create]
                 project.resources :versions, :shallow => true,
                                   :collection => {:close_completed => :put},
                                   :member => {:status_by => :post}
                 project.resources :news, :shallow => true
                 project.resources :time_entries, :controller => 'timelog',
                                   :collection => {:report => :get}
                 project.resources :queries, :only => [:new, :create]
                 project.resources :issue_categories, :shallow => true
                 project.resources :documents, :shallow => true, :member => {:add_attachment => :post}
                 project.resources :boards
                 project.resources :repositories, :shallow => true, :except => [:index, :show],
                                   :member => {:committers => [:get, :post]}
                 project.resources :memberships, :shallow => true, :controller => 'members',
                                   :only => [:index, :show, :create, :update, :destroy],
                                   :collection => {:autocomplete => :get}
                 project.wiki_start_page 'wiki', :controller => 'wiki', :action => 'show', :conditions => {:method => :get}
                 project.wiki_index 'wiki/index', :controller => 'wiki', :action => 'index', :conditions => {:method => :get}
                 project.wiki_diff 'wiki/:id/diff/:version', :controller => 'wiki', :action => 'diff', :version => nil
                 project.wiki_diff 'wiki/:id/diff/:version/vs/:version_from', :controller => 'wiki', :action => 'diff'
                 project.wiki_annotate 'wiki/:id/annotate/:version', :controller => 'wiki', :action => 'annotate'
                 project.resources :wiki, :except => [:new, :create], :member => {
                   :rename => [:get, :post],
                   :history => :get,
                   :preview => :any,
                   :protect => :post,
                   :add_attachment => :post
                 }, :collection => {
                   :export => :get,
                   :date_index => :get
                 }
               end
               map.connect 'news', :controller => 'news', :action => 'index'
               map.connect 'news.:format', :controller => 'news', :action => 'index'
               map.resources :queries, :except => [:show]
               map.resources :issues,
                             :collection => {:bulk_edit => [:get, :post], :bulk_update => :post} do |issues|
                 issues.resources :time_entries, :controller => 'timelog',
                                  :collection => {:report => :get}
                 issues.resources :relations, :shallow => true,
                                  :controller => 'issue_relations',
                                  :only => [:index, :show, :create, :destroy]
               end
               # Bulk deletion
               map.connect '/issues', :controller => 'issues', :action => 'destroy',
                           :conditions => {:method => :delete}
               map.connect '/time_entries/destroy',
                           :controller => 'timelog', :action => 'destroy',
                           :conditions => { :method => :delete }
               map.time_entries_context_menu '/time_entries/context_menu',
                                :controller => 'context_menus', :action => 'time_entries'
               map.resources :time_entries, :controller => 'timelog',
                             :collection => {:report => :get, :bulk_edit => :get, :bulk_update => :post}
               map.with_options :controller => 'activities', :action => 'index',
                                :conditions => {:method => :get} do |activity|
                 activity.connect 'projects/:id/activity'
                 activity.connect 'projects/:id/activity.:format'
                 activity.connect 'activity', :id => nil
                 activity.connect 'activity.:format', :id => nil
               end
               map.with_options :controller => 'repositories' do |repositories|
                 repositories.with_options :conditions => {:method => :get} do |repository_views|
                   repository_views.connect 'projects/:id/repository',
                                            :action => 'show'
                   repository_views.connect 'projects/:id/repository/:repository_id/statistics',
                                            :action => 'stats'
                   repository_views.connect 'projects/:id/repository/:repository_id/graph',
                                            :action => 'graph'
                   repository_views.connect 'projects/:id/repository/statistics',
                                            :action => 'stats'
                   repository_views.connect 'projects/:id/repository/graph',
                                            :action => 'graph'
                   repository_views.connect 'projects/:id/repository/:repository_id/revisions',
                                            :action => 'revisions'
                   repository_views.connect 'projects/:id/repository/:repository_id/revisions.:format',
                                            :action => 'revisions'
                   repository_views.connect 'projects/:id/repository/:repository_id/revisions/:rev',
                                            :action => 'revision'
                   repository_views.connect 'projects/:id/repository/:repository_id/revisions/:rev/issues',
                                             :action => 'add_related_issue', :conditions => {:method => :post}
                   repository_views.connect 'projects/:id/repository/:repository_id/revisions/:rev/issues/:issue_id',
                                             :action => 'remove_related_issue', :conditions => {:method => :delete}
                   repository_views.connect 'projects/:id/repository/:repository_id/revisions/:rev/diff',
                                            :action => 'diff'
                   repository_views.connect 'projects/:id/repository/:repository_id/revisions/:rev/diff.:format',
                                            :action => 'diff'
                   repository_views.connect 'projects/:id/repository/:repository_id/revisions/:rev/raw/*path',
                                            :action => 'entry', :format => 'raw'
                   repository_views.connect 'projects/:id/repository/:repository_id/revisions/:rev/:action/*path',
                                            :requirements => {
                                                :action => /(browse|show|entry|changes|annotate|diff)/,
                                                :rev    => /[a-z0-9\.\-_]+/
                                              }
                   repository_views.connect 'projects/:id/repository/:repository_id/raw/*path',
                                            :action => 'entry', :format => 'raw'
                   repository_views.connect 'projects/:id/repository/:repository_id/:action/*path',
                                            :requirements => { :action => /(browse|entry|changes|annotate|diff)/ }
                   repository_views.connect 'projects/:id/repository/:repository_id/show/*path',
                                            :requirements => { :path => /.+/ }
                   repository_views.connect 'projects/:id/repository/revisions',
                                            :action => 'revisions'
                   repository_views.connect 'projects/:id/repository/revisions.:format',
                                            :action => 'revisions'
                   repository_views.connect 'projects/:id/repository/revisions/:rev',
                                            :action => 'revision'
                   repository_views.connect 'projects/:id/repository/revisions/:rev/issues',
                                             :action => 'add_related_issue', :conditions => {:method => :post}
                   repository_views.connect 'projects/:id/repository/revisions/:rev/issues/:issue_id',
                                             :action => 'remove_related_issue', :conditions => {:method => :delete}
                   repository_views.connect 'projects/:id/repository/revisions/:rev/diff',
                                            :action => 'diff'
                   repository_views.connect 'projects/:id/repository/revisions/:rev/diff.:format',
                                            :action => 'diff'
                   repository_views.connect 'projects/:id/repository/revisions/:rev/raw/*path',
                                            :action => 'entry', :format => 'raw'
                   repository_views.connect 'projects/:id/repository/revisions/:rev/:action/*path',
                                            :requirements => {
                                                :action => /(browse|show|entry|changes|annotate|diff)/,
                                                :rev    => /[a-z0-9\.\-_]+/
                                              }
                   repository_views.connect 'projects/:id/repository/raw/*path',
                                            :action => 'entry', :format => 'raw'
                   repository_views.connect 'projects/:id/repository/:action/*path',
                                            :requirements => { :action => /(browse|show|entry|changes|annotate|diff)/ }
                   repository_views.connect 'projects/:id/repository/:repository_id',
                                            :action => 'show'
                 end
                 repositories.connect 'projects/:id/repository/revision',
                                      :action => 'revision',
                                      :conditions => {:method => [:get, :post]}
               end
               # additional routes for having the file name at the end of url
               map.connect 'attachments/:id/:filename', :controller => 'attachments',
                           :action => 'show', :id => /\d+/, :filename => /.*/,
                           :conditions => {:method => :get}
               map.connect 'attachments/download/:id/:filename', :controller => 'attachments',
                           :action => 'download', :id => /\d+/, :filename => /.*/,
                           :conditions => {:method => :get}
               map.connect 'attachments/download/:id', :controller => 'attachments',
                           :action => 'download', :id => /\d+/,
                           :conditions => {:method => :get}
               map.resources :attachments, :only => [:show, :destroy]
               map.resources :groups, :member => {:autocomplete_for_user => :get}
               map.group_users 'groups/:id/users', :controller => 'groups',
                               :action => 'add_users', :id => /\d+/,
                               :conditions => {:method => :post}
               map.group_user  'groups/:id/users/:user_id', :controller => 'groups',
                               :action => 'remove_user', :id => /\d+/,
                               :conditions => {:method => :delete}
               map.connect 'groups/destroy_membership/:id', :controller => 'groups',
                           :action => 'destroy_membership', :id => /\d+/,
                           :conditions => {:method => :post}
               map.connect 'groups/edit_membership/:id', :controller => 'groups',
                           :action => 'edit_membership', :id => /\d+/,
                           :conditions => {:method => :post}
               map.resources :trackers, :except => :show
               map.resources :issue_statuses, :except => :show, :collection => {:update_issue_done_ratio => :post}
               map.resources :custom_fields, :except => :show
               map.resources :roles, :except => :show, :collection => {:permissions => [:get, :post]}
               map.resources :enumerations, :except => :show
               map.connect 'search', :controller => 'search', :action => 'index', :conditions => {:method => :get}
               map.connect 'mail_handler', :controller => 'mail_handler',
                           :action => 'index', :conditions => {:method => :post}
               map.connect 'admin', :controller => 'admin', :action => 'index',
                           :conditions => {:method => :get}
               map.connect 'admin/projects', :controller => 'admin', :action => 'projects',
                           :conditions => {:method => :get}
               map.connect 'admin/plugins', :controller => 'admin', :action => 'plugins',
                           :conditions => {:method => :get}
               map.connect 'admin/info', :controller => 'admin', :action => 'info',
                           :conditions => {:method => :get}
               map.connect 'admin/test_email', :controller => 'admin', :action => 'test_email',
                           :conditions => {:method => :get}
               map.connect 'admin/default_configuration', :controller => 'admin',
                           :action => 'default_configuration', :conditions => {:method => :post}
               map.resources :auth_sources, :member => {:test_connection => :get}
               map.connect 'workflows', :controller => 'workflows',
                           :action => 'index', :conditions => {:method => :get}
               map.connect 'workflows/edit', :controller => 'workflows',
                           :action => 'edit', :conditions => {:method => [:get, :post]}
               map.connect 'workflows/copy', :controller => 'workflows',
                           :action => 'copy', :conditions => {:method => [:get, :post]}
               map.connect 'settings', :controller => 'settings',
                           :action => 'index', :conditions => {:method => :get}
               map.connect 'settings/edit', :controller => 'settings',
                           :action => 'edit', :conditions => {:method => [:get, :post]}
               map.connect 'settings/plugin/:id', :controller => 'settings',
                           :action => 'plugin', :conditions => {:method => [:get, :post]}
               map.with_options :controller => 'sys' do |sys|
                 sys.connect 'sys/projects.:format',
                             :action => 'projects',
                             :conditions => {:method => :get}
                 sys.connect 'sys/projects/:id/repository.:format',
                             :action => 'create_project_repository',
                             :conditions => {:method => :post}
                 sys.connect 'sys/fetch_changesets',
                             :action => 'fetch_changesets',
                             :conditions => {:method => :get}
               end
               map.connect 'uploads.:format', :controller => 'attachments', :action => 'upload', :conditions => {:method => :post}
               map.connect 'robots.txt', :controller => 'welcome',
                           :action => 'robots', :conditions => {:method => :get}
               # Used for OpenID
               map.root :controller => 'account', :action => 'login'
             end

public/stylesheets/application.css +6 0

             html {overflow-y:scroll;}
             body { font-family: Verdana, sans-serif; font-size: 12px; color:#484848; margin: 0; padding: 0; min-width: 900px; }
             h1, h2, h3, h4 { font-family: "Trebuchet MS", Verdana, sans-serif;}
             h1 {margin:0; padding:0; font-size: 24px;}
             h2, .wiki h1 {font-size: 20px;padding: 2px 10px 1px 0px;margin: 0 0 10px 0; border-bottom: 1px solid #bbbbbb; color: #444;}
             h3, .wiki h2 {font-size: 16px;padding: 2px 10px 1px 0px;margin: 0 0 10px 0; border-bottom: 1px solid #bbbbbb; color: #444;}
             h4, .wiki h3 {font-size: 13px;padding: 2px 10px 1px 0px;margin-bottom: 5px; border-bottom: 1px dotted #bbbbbb; color: #444;}
             /***** Layout *****/
             #wrapper {background: white;}
             #top-menu {background: #2C4056; color: #fff; height:1.8em; font-size: 0.8em; padding: 2px 2px 0px 6px;}
             #top-menu ul {margin: 0;  padding: 0;}
             #top-menu li {
               float:left;
               list-style-type:none;
               margin: 0px 0px 0px 0px;
               padding: 0px 0px 0px 0px;
               white-space:nowrap;
             }
             #top-menu a {color: #fff; margin-right: 8px; font-weight: bold;}
             #top-menu #loggedas { float: right; margin-right: 0.5em; color: #fff; }
             #account {float:right;}
             #header {height:5.3em;margin:0;background-color:#507AAA;color:#f8f8f8; padding: 4px 8px 0px 6px; position:relative;}
             #header a {color:#f8f8f8;}
             #header h1 a.ancestor { font-size: 80%; }
             #quick-search {float:right;}
             #main-menu {position: absolute;  bottom: 0px;  left:6px; margin-right: -500px;}
             #main-menu ul {margin: 0;  padding: 0;}
             #main-menu li {
               float:left;
               list-style-type:none;
               margin: 0px 2px 0px 0px;
               padding: 0px 0px 0px 0px;
               white-space:nowrap;
             }
             #main-menu li a {
               display: block;
               color: #fff;
               text-decoration: none;
               font-weight: bold;
               margin: 0;
               padding: 4px 10px 4px 10px;
             }
             #main-menu li a:hover {background:#759FCF; color:#fff;}
             #main-menu li a.selected, #main-menu li a.selected:hover {background:#fff; color:#555;}
             #admin-menu ul {margin: 0;  padding: 0;}
             #admin-menu li {margin: 0;  padding: 0 0 6px 0; list-style-type:none;}
             #admin-menu a { background-position: 0% 40%; background-repeat: no-repeat; padding-left: 20px; padding-top: 2px; padding-bottom: 3px;}
             #admin-menu a.projects { background-image: url(../images/projects.png); }
             #admin-menu a.users { background-image: url(../images/user.png); }
             #admin-menu a.groups { background-image: url(../images/group.png); }
             #admin-menu a.roles { background-image: url(../images/database_key.png); }
             #admin-menu a.trackers { background-image: url(../images/ticket.png); }
             #admin-menu a.issue_statuses { background-image: url(../images/ticket_edit.png); }
             #admin-menu a.workflows { background-image: url(../images/ticket_go.png); }
             #admin-menu a.custom_fields { background-image: url(../images/textfield.png); }
             #admin-menu a.enumerations { background-image: url(../images/text_list_bullets.png); }
             #admin-menu a.settings { background-image: url(../images/changeset.png); }
             #admin-menu a.plugins { background-image: url(../images/plugin.png); }
             #admin-menu a.info { background-image: url(../images/help.png); }
             #admin-menu a.server_authentication { background-image: url(../images/server_key.png); }
             #main {background-color:#EEEEEE;}
             #sidebar{ float: right; width: 22%; position: relative; z-index: 9; padding: 0; margin: 0;}
             * html #sidebar{ width: 22%; }
             #sidebar h3{ font-size: 14px; margin-top:14px; color: #666;  }
             #sidebar hr{ width: 100%; margin: 0 auto; height: 1px; background: #ccc; border: 0; }
             * html #sidebar hr{ width: 95%; position: relative; left: -6px; color: #ccc; }
             #sidebar .contextual { margin-right: 1em; }
             #content { width: 75%; background-color: #fff; margin: 0px; border-right: 1px solid #ddd; padding: 6px 10px 10px 10px; z-index: 10; }
             * html #content{ width: 75%; padding-left: 0; margin-top: 0px; padding: 6px 10px 10px 10px;}
             html>body #content { min-height: 600px; }
             * html body #content { height: 600px; } /* IE */
             #main.nosidebar #sidebar{ display: none; }
             #main.nosidebar #content{ width: auto; border-right: 0; }
             #footer {clear: both; border-top: 1px solid #bbb; font-size: 0.9em; color: #aaa; padding: 5px; text-align:center; background:#fff;}
             #login-form table {margin-top:5em; padding:1em; margin-left: auto; margin-right: auto; border: 2px solid #FDBF3B; background-color:#FFEBC1; }
             #login-form table td {padding: 6px;}
             #login-form label {font-weight: bold;}
             #login-form input#username, #login-form input#password { width: 300px; }
             #modalbg {position:absolute; top:0; left:0; width:100%; height:100%; background:#ccc; z-index:49; opacity:0.5;}
             html>body #modalbg {position:fixed;}
             div.modal { border-radius:5px; position:absolute; top:25%; background:#fff; border:2px solid #759FCF; z-index:50; padding:0px; padding:8px; box-shadow: 1px 1px 8px #888; }
             div.modal h3.title {background:#759FCF; color:#fff; border:0; padding-left:8px; margin:-8px; margin-bottom: 1em; border-top-left-radius:2px;border-top-right-radius:2px;}
             div.modal p.buttons {text-align:right; margin-bottom:0;}
             html>body div.modal {position:fixed;}
             input#openid_url { background: url(../images/openid-bg.gif) no-repeat; background-color: #fff; background-position: 0 50%; padding-left: 18px; }
             .clear:after{ content: "."; display: block; height: 0; clear: both; visibility: hidden; }
             /***** Links *****/
             a, a:link, a:visited{ color: #2A5685; text-decoration: none; }
             a:hover, a:active{ color: #c61a1a; text-decoration: underline;}
             a img{ border: 0; }
             a.issue.closed, a.issue.closed:link, a.issue.closed:visited { color: #999; text-decoration: line-through; }
             #sidebar a.selected {line-height:1.7em; padding:1px 3px 2px 2px; margin-left:-2px; background-color:#9DB9D5; color:#fff; border-radius:2px; -moz-border-radius:2px;}
             #sidebar a.selected:hover {text-decoration:none;}
             #admin-menu a {line-height:1.7em;}
             #admin-menu a.selected {padding-left: 20px !important; background-position: 2px 40%;}
             a.collapsible {padding-left: 12px; background: url(../images/arrow_expanded.png) no-repeat -3px 40%;}
             a.collapsible.collapsed {background: url(../images/arrow_collapsed.png) no-repeat -5px 40%;}
             a#toggle-completed-versions {color:#999;}
             /***** Tables *****/
             table.list { border: 1px solid #e4e4e4;  border-collapse: collapse; width: 100%; margin-bottom: 4px; }
             table.list th {  background-color:#EEEEEE; padding: 4px; white-space:nowrap; }
             table.list td { vertical-align: top; }
             table.list td.id { width: 2%; text-align: center;}
             table.list td.checkbox { width: 15px; padding: 2px 0 0 0; }
             table.list td.checkbox input {padding:0px;}
             table.list td.buttons { width: 15%; white-space:nowrap; text-align: right; }
             table.list td.buttons a { padding-right: 0.6em; }
             table.list caption { text-align: left; padding: 0.5em 0.5em 0.5em 0; }
             tr.project td.name a { white-space:nowrap; }
             tr.project.idnt td.name span {background: url(../images/bullet_arrow_right.png) no-repeat 0 50%; padding-left: 16px;}
             tr.project.idnt-1 td.name {padding-left: 0.5em;}
             tr.project.idnt-2 td.name {padding-left: 2em;}
             tr.project.idnt-3 td.name {padding-left: 3.5em;}
             tr.project.idnt-4 td.name {padding-left: 5em;}
             tr.project.idnt-5 td.name {padding-left: 6.5em;}
             tr.project.idnt-6 td.name {padding-left: 8em;}
             tr.project.idnt-7 td.name {padding-left: 9.5em;}
             tr.project.idnt-8 td.name {padding-left: 11em;}
             tr.project.idnt-9 td.name {padding-left: 12.5em;}
             tr.issue { text-align: center; white-space: nowrap; }
             tr.issue td.subject, tr.issue td.category, td.assigned_to, tr.issue td.string, tr.issue td.text { white-space: normal; }
             tr.issue td.subject { text-align: left; }
             tr.issue td.done_ratio table.progress { margin-left:auto; margin-right: auto;}
             tr.issue.idnt td.subject a {background: url(../images/bullet_arrow_right.png) no-repeat 0 50%; padding-left: 16px;}
             tr.issue.idnt-1 td.subject {padding-left: 0.5em;}
             tr.issue.idnt-2 td.subject {padding-left: 2em;}
             tr.issue.idnt-3 td.subject {padding-left: 3.5em;}
             tr.issue.idnt-4 td.subject {padding-left: 5em;}
             tr.issue.idnt-5 td.subject {padding-left: 6.5em;}
             tr.issue.idnt-6 td.subject {padding-left: 8em;}
             tr.issue.idnt-7 td.subject {padding-left: 9.5em;}
             tr.issue.idnt-8 td.subject {padding-left: 11em;}
             tr.issue.idnt-9 td.subject {padding-left: 12.5em;}
             tr.entry { border: 1px solid #f8f8f8; }
             tr.entry td { white-space: nowrap; }
             tr.entry td.filename { width: 30%; }
             tr.entry td.filename_no_report { width: 70%; }
             tr.entry td.size { text-align: right; font-size: 90%; }
             tr.entry td.revision, tr.entry td.author { text-align: center; }
             tr.entry td.age { text-align: right; }
             tr.entry.file td.filename a { margin-left: 16px; }
             tr.entry.file td.filename_no_report a { margin-left: 16px; }
             tr span.expander {background-image: url(../images/bullet_toggle_plus.png); padding-left: 8px; margin-left: 0; cursor: pointer;}
             tr.open span.expander {background-image: url(../images/bullet_toggle_minus.png);}
             tr.changeset { height: 20px }
             tr.changeset ul, ol { margin-top: 0px; margin-bottom: 0px; }
             tr.changeset td.revision_graph { width: 15%; background-color: #fffffb; }
             tr.changeset td.author { text-align: center; width: 15%; white-space:nowrap;}
             tr.changeset td.committed_on { text-align: center; width: 15%; white-space:nowrap;}
             table.files tr.file td { text-align: center; }
             table.files tr.file td.filename { text-align: left; padding-left: 24px; }
             table.files tr.file td.digest { font-size: 80%; }
             table.members td.roles, table.memberships td.roles { width: 45%; }
             tr.message { height: 2.6em; }
             tr.message td.subject { padding-left: 20px; }
             tr.message td.created_on { white-space: nowrap; }
             tr.message td.last_message { font-size: 80%; white-space: nowrap; }
             tr.message.locked td.subject { background: url(../images/locked.png) no-repeat 0 1px; }
             tr.message.sticky td.subject { background: url(../images/bullet_go.png) no-repeat 0 1px; font-weight: bold; }
             tr.version.closed, tr.version.closed a { color: #999; }
             tr.version td.name { padding-left: 20px; }
             tr.version.shared td.name { background: url(../images/link.png) no-repeat 0% 70%; }
             tr.version td.date, tr.version td.status, tr.version td.sharing { text-align: center; white-space:nowrap; }
             tr.user td { width:13%; }
             tr.user td.email { width:18%; }
             tr.user td { white-space: nowrap; }
             tr.user.locked, tr.user.registered { color: #aaa; }
             tr.user.locked a, tr.user.registered a { color: #aaa; }
             table.permissions td.role {color:#999;font-size:90%;font-weight:normal !important;text-align:center;vertical-align:bottom;}
             tr.wiki-page-version td.updated_on, tr.wiki-page-version td.author {text-align:center;}
             tr.time-entry { text-align: center; white-space: nowrap; }
             tr.time-entry td.subject, tr.time-entry td.comments { text-align: left; white-space: normal; }
             td.hours { text-align: right; font-weight: bold; padding-right: 0.5em; }
             td.hours .hours-dec { font-size: 0.9em; }
             table.plugins td { vertical-align: middle; }
             table.plugins td.configure { text-align: right; padding-right: 1em; }
             table.plugins span.name { font-weight: bold; display: block; margin-bottom: 6px; }
             table.plugins span.description { display: block; font-size: 0.9em; }
             table.plugins span.url { display: block; font-size: 0.9em; }
             table.list tbody tr.group td { padding: 0.8em 0 0.5em 0.3em; font-weight: bold; border-bottom: 1px solid #ccc; }
             table.list tbody tr.group span.count { color: #aaa; font-size: 80%; }
             tr.group a.toggle-all { color: #aaa; font-size: 80%; font-weight: normal; display:none;}
             tr.group:hover a.toggle-all { display:inline;}
             a.toggle-all:hover {text-decoration:none;}
             table.list tbody tr:hover { background-color:#ffffdd; }
             table.list tbody tr.group:hover { background-color:inherit; }
             table td {padding:2px;}
             table p {margin:0;}
             .odd {background-color:#f6f7f8;}
             .even {background-color: #fff;}
             a.sort { padding-right: 16px; background-position: 100% 50%; background-repeat: no-repeat; }
             a.sort.asc  { background-image: url(../images/sort_asc.png); }
             a.sort.desc { background-image: url(../images/sort_desc.png); }
             table.attributes { width: 100% }
             table.attributes th { vertical-align: top; text-align: left; }
             table.attributes td { vertical-align: top; }
             table.boards a.board, h3.comments { background: url(../images/comment.png) no-repeat 0% 50%; padding-left: 20px; }
             table.query-columns {
                 border-collapse: collapse;
                 border: 0;
             }
             table.query-columns td.buttons {
                 vertical-align: middle;
                 text-align: center;
             }
             td.center {text-align:center;}
             h3.version { background: url(../images/package.png) no-repeat 0% 50%; padding-left: 20px; }
             div.issues h3 { background: url(../images/ticket.png) no-repeat 0% 50%; padding-left: 20px; }
             div.members h3 { background: url(../images/group.png) no-repeat 0% 50%; padding-left: 20px; }
             div.news h3 { background: url(../images/news.png) no-repeat 0% 50%; padding-left: 20px; }
             div.projects h3 { background: url(../images/projects.png) no-repeat 0% 50%; padding-left: 20px; }
             #watchers ul {margin: 0;  padding: 0;}
             #watchers li {list-style-type:none;margin: 0px 2px 0px 0px; padding: 0px 0px 0px 0px;}
             #watchers select {width: 95%; display: block;}
             #watchers a.delete {opacity: 0.4;}
             #watchers a.delete:hover {opacity: 1;}
             #watchers img.gravatar {margin: 0 4px 2px 0;}
+            span#watchers_inputs {overflow:auto; display:block;}
+            span.search_for_watchers {display:block;}
+            span.search_for_watchers, span.add_attachment {font-size:80%; line-height:2.5em;}
+            span.search_for_watchers a, span.add_attachment a {padding-left:16px; background: url(../images/bullet_add.png) no-repeat 0 50%; }
             .highlight { background-color: #FCFD8D;}
             .highlight.token-1 { background-color: #faa;}
             .highlight.token-2 { background-color: #afa;}
             .highlight.token-3 { background-color: #aaf;}
             .box{
             padding:6px;
             margin-bottom: 10px;
             background-color:#f6f6f6;
             color:#505050;
             line-height:1.5em;
             border: 1px solid #e4e4e4;
             }
             div.square {
              border: 1px solid #999;
              float: left;
              margin: .3em .4em 0 .4em;
              overflow: hidden;
              width: .6em; height: .6em;
             }
             .contextual {float:right; white-space: nowrap; line-height:1.4em;margin-top:5px; padding-left: 10px; font-size:0.9em;}
             .contextual input, .contextual select {font-size:0.9em;}
             .message .contextual { margin-top: 0; }
             .splitcontent {overflow:auto;}
             .splitcontentleft{float:left; width:49%;}
             .splitcontentright{float:right; width:49%;}
             form {display: inline;}
             input, select {vertical-align: middle; margin-top: 1px; margin-bottom: 1px;}
             fieldset {border: 1px solid #e4e4e4; margin:0;}
             legend {color: #484848;}
             hr { width: 100%; height: 1px; background: #ccc; border: 0;}
             blockquote { font-style: italic; border-left: 3px solid #e0e0e0; padding-left: 0.6em; margin-left: 2.4em;}
             blockquote blockquote { margin-left: 0;}
             acronym  { border-bottom: 1px dotted; cursor: help; }
             textarea.wiki-edit { width: 99%; }
             li p {margin-top: 0;}
             div.issue {background:#ffffdd; padding:6px; margin-bottom:6px;border: 1px solid #d7d7d7;}
             p.breadcrumb { font-size: 0.9em; margin: 4px 0 4px 0;}
             p.subtitle { font-size: 0.9em; margin: -6px 0 12px 0; font-style: italic; }
             p.footnote { font-size: 0.9em; margin-top: 0px; margin-bottom: 0px; }
             div.issue div.subject div div { padding-left: 16px; }
             div.issue div.subject p {margin: 0; margin-bottom: 0.1em; font-size: 90%; color: #999;}
             div.issue div.subject>div>p { margin-top: 0.5em; }
             div.issue div.subject h3 {margin: 0; margin-bottom: 0.1em;}
             div.issue span.private { position:relative; bottom: 2px; text-transform: uppercase; background: #d22; color: #fff; font-weight:bold; padding: 0px 2px 0px 2px; font-size: 60%; margin-right: 2px; border-radius: 2px; -moz-border-radius: 2px;}
             div.issue .next-prev-links {color:#999;}
             div.issue table.attributes th {width:22%;}
             div.issue table.attributes td {width:28%;}
             #issue_tree table.issues, #relations table.issues { border: 0; }
             #issue_tree td.checkbox, #relations td.checkbox {display:none;}
             #relations td.buttons {padding:0;}
             fieldset.collapsible { border-width: 1px 0 0 0; font-size: 0.9em; }
             fieldset.collapsible legend { padding-left: 16px; background: url(../images/arrow_expanded.png) no-repeat 0% 40%; cursor:pointer; }
             fieldset.collapsible.collapsed legend { background-image: url(../images/arrow_collapsed.png); }
             fieldset#date-range p { margin: 2px 0 2px 0; }
             fieldset#filters table { border-collapse: collapse; }
             fieldset#filters table td { padding: 0; vertical-align: middle; }
             fieldset#filters tr.filter { height: 2em; }
             fieldset#filters td.field { width:200px; }
             fieldset#filters td.operator { width:170px; }
             fieldset#filters td.values { white-space:nowrap; }
             fieldset#filters td.values select {min-width:130px;}
             fieldset#filters td.values img { vertical-align: middle; margin-left:1px; }
             fieldset#filters td.add-filter { text-align: right; vertical-align: top; }
             .buttons { font-size: 0.9em; margin-bottom: 1.4em; margin-top: 1em; }
             div#issue-changesets {float:right; width:45%; margin-left: 1em; margin-bottom: 1em; background: #fff; padding-left: 1em; font-size: 90%;}
             div#issue-changesets div.changeset { padding: 4px;}
             div#issue-changesets div.changeset { border-bottom: 1px solid #ddd; }
             div#issue-changesets p { margin-top: 0; margin-bottom: 1em;}
             div#activity dl, #search-results { margin-left: 2em; }
             div#activity dd, #search-results dd { margin-bottom: 1em; padding-left: 18px; font-size: 0.9em; }
             div#activity dt, #search-results dt { margin-bottom: 0px; padding-left: 20px; line-height: 18px; background-position: 0 50%; background-repeat: no-repeat; }
             div#activity dt.me .time { border-bottom: 1px solid #999; }
             div#activity dt .time { color: #777; font-size: 80%; }
             div#activity dd .description, #search-results dd .description { font-style: italic; }
             div#activity span.project:after, #search-results span.project:after { content: " -"; }
             div#activity dd span.description, #search-results dd span.description { display:block; color: #808080; }
             #search-results dd { margin-bottom: 1em; padding-left: 20px; margin-left:0px; }
             div#search-results-counts {float:right;}
             div#search-results-counts ul { margin-top: 0.5em; }
             div#search-results-counts  li { list-style-type:none; float: left; margin-left: 1em; }
             dt.issue { background-image: url(../images/ticket.png); }
             dt.issue-edit { background-image: url(../images/ticket_edit.png); }
             dt.issue-closed { background-image: url(../images/ticket_checked.png); }
             dt.issue-note { background-image: url(../images/ticket_note.png); }
             dt.changeset { background-image: url(../images/changeset.png); }
             dt.news { background-image: url(../images/news.png); }
             dt.message { background-image: url(../images/message.png); }
             dt.reply { background-image: url(../images/comments.png); }
             dt.wiki-page { background-image: url(../images/wiki_edit.png); }
             dt.attachment { background-image: url(../images/attachment.png); }
             dt.document { background-image: url(../images/document.png); }
             dt.project { background-image: url(../images/projects.png); }
             dt.time-entry { background-image: url(../images/time.png); }
             #search-results dt.issue.closed { background-image: url(../images/ticket_checked.png); }
             div#roadmap .related-issues { margin-bottom: 1em; }
             div#roadmap .related-issues td.checkbox { display: none; }
             div#roadmap .wiki h1:first-child { display: none; }
             div#roadmap .wiki h1 { font-size: 120%; }
             div#roadmap .wiki h2 { font-size: 110%; }
             body.controller-versions.action-show div#roadmap .related-issues {width:70%;}
             div#version-summary { float:right; width:28%; margin-left: 16px; margin-bottom: 16px; background-color: #fff; }
             div#version-summary fieldset { margin-bottom: 1em; }
             div#version-summary fieldset.time-tracking table { width:100%; }
             div#version-summary th, div#version-summary td.total-hours { text-align: right; }
             table#time-report td.hours, table#time-report th.period, table#time-report th.total { text-align: right; padding-right: 0.5em; }
             table#time-report tbody tr.subtotal { font-style: italic; color:#777;}
             table#time-report tbody tr.subtotal td.hours { color:#b0b0b0; }
             table#time-report tbody tr.total { font-weight: bold; background-color:#EEEEEE; border-top:1px solid #e4e4e4;}
             table#time-report .hours-dec { font-size: 0.9em; }
             div.wiki-page .contextual a {opacity: 0.4}
             div.wiki-page .contextual a:hover {opacity: 1}
             form .attributes select { width: 60%; }
             input#issue_subject { width: 99%; }
             select#issue_done_ratio { width: 95px; }
             ul.projects { margin: 0; padding-left: 1em; }
             ul.projects.root { margin: 0;  padding: 0; }
             ul.projects ul.projects { border-left: 3px solid #e0e0e0; }
             ul.projects li.root { list-style-type:none; margin-bottom: 1em; }
             ul.projects li.child { list-style-type:none; margin-top: 1em;}
             ul.projects div.root a.project { font-family: "Trebuchet MS", Verdana, sans-serif; font-weight: bold; font-size: 16px; margin: 0 0 10px 0; }
             .my-project { padding-left: 18px; background: url(../images/fav.png) no-repeat 0 50%; }
             #tracker_project_ids ul { margin: 0;  padding-left: 1em; }
             #tracker_project_ids li { list-style-type:none; }
             #related-issues li img {vertical-align:middle;}
             ul.properties {padding:0; font-size: 0.9em; color: #777;}
             ul.properties li {list-style-type:none;}
             ul.properties li span {font-style:italic;}
             .total-hours { font-size: 110%; font-weight: bold; }
             .total-hours span.hours-int { font-size: 120%; }
             .autoscroll {overflow-x: auto; padding:1px; margin-bottom: 1.2em;}
             #user_login, #user_firstname, #user_lastname, #user_mail, #my_account_form select, #user_form select, #user_identity_url { width: 90%; }
             #workflow_copy_form select { width: 200px; }
             textarea#custom_field_possible_values {width: 99%}
             input#content_comments {width: 99%}
             .pagination {font-size: 90%}
             p.pagination {margin-top:8px;}
             /***** Tabular forms ******/
             .tabular p{
             margin: 0;
             padding: 3px 0 3px 0;
             padding-left: 180px; /* width of left column containing the label elements */
             min-height: 1.8em;
             clear:left;
             }
             html>body .tabular p {overflow:hidden;}
             .tabular label{
             font-weight: bold;
             float: left;
             text-align: right;
             /* width of left column */
             margin-left: -180px;
             /* width of labels. Should be smaller than left column to create some right margin */
             width: 175px;
             }
             .tabular label.floating{
             font-weight: normal;
             margin-left: 0px;
             text-align: left;
             width: 270px;
             }
             .tabular label.block{
             font-weight: normal;
             margin-left: 0px !important;
             text-align: left;
             float: none;
             display: block;
             width: auto;
             }
             .tabular label.inline{
             float:none;
             margin-left: 5px !important;
             width: auto;
             }
             label.no-css {
               font-weight: inherit;
               float:none;
               text-align:left;
               margin-left:0px;
               width:auto;
             }
             input#time_entry_comments { width: 90%;}
             #preview fieldset {margin-top: 1em; background: url(../images/draft.png)}
             .tabular.settings p{ padding-left: 300px; }
             .tabular.settings label{ margin-left: -300px; width: 295px; }
             .tabular.settings textarea { width: 99%; }
             .settings.enabled_scm table {width:100%}
             .settings.enabled_scm td.scm_name{ font-weight: bold; }
             fieldset.settings label { display: block; }
             fieldset#notified_events .parent { padding-left: 20px; }
             .required {color: #bb0000;}
             .summary {font-style: italic;}
             #attachments_fields input.description {margin-left: 8px; width:340px;}
             #attachments_fields span {display:block; white-space:nowrap;}
             #attachments_fields img {vertical-align: middle;}
             div.attachments { margin-top: 12px; }
             div.attachments p { margin:4px 0 2px 0; }
             div.attachments img { vertical-align: middle; }
             div.attachments span.author { font-size: 0.9em; color: #888; }
             p.other-formats { text-align: right; font-size:0.9em; color: #666; }
             .other-formats span + span:before { content: "| "; }
             a.atom { background: url(../images/feed.png) no-repeat 1px 50%; padding: 2px 0px 3px 16px; }
             em.info {font-style:normal;font-size:90%;color:#888;display:block;}
             em.info.error {padding-left:20px; background:url(../images/exclamation.png) no-repeat 0 50%;}
             /* Project members tab */
             div#tab-content-members .splitcontentleft, div#tab-content-memberships .splitcontentleft, div#tab-content-users .splitcontentleft { width: 64% }
             div#tab-content-members .splitcontentright, div#tab-content-memberships .splitcontentright, div#tab-content-users .splitcontentright { width: 34% }
             div#tab-content-members fieldset, div#tab-content-memberships fieldset, div#tab-content-users fieldset { padding:1em; margin-bottom: 1em; }
             div#tab-content-members fieldset legend, div#tab-content-memberships fieldset legend, div#tab-content-users fieldset legend { font-weight: bold; }
             div#tab-content-members fieldset label, div#tab-content-memberships fieldset label, div#tab-content-users fieldset label { display: block; }
             div#tab-content-members fieldset div, div#tab-content-users fieldset div { max-height: 400px; overflow:auto; }
             #users_for_watcher {height: 200px; overflow:auto;}
             #users_for_watcher label {display: block;}
             table.members td.group { padding-left: 20px; background: url(../images/group.png) no-repeat 0% 50%; }
             input#principal_search, input#user_search {width:100%}
             input#principal_search, input#user_search {
               background: url(../images/magnifier.png) no-repeat 2px 50%; padding-left:20px;
               border:1px solid #9EB1C2; border-radius:3px; height:1.5em; width:95%;
             }
             input#principal_search.ajax-loading, input#user_search.ajax-loading {
              background-image: url(../images/loading.gif);
             }
             * html div#tab-content-members fieldset div { height: 450px; }
             /***** Flash & error messages ****/
             #errorExplanation, div.flash, .nodata, .warning, .conflict {
                 padding: 4px 4px 4px 30px;
                 margin-bottom: 12px;
                 font-size: 1.1em;
                 border: 2px solid;
             }
             div.flash {margin-top: 8px;}
             div.flash.error, #errorExplanation {
                 background: url(../images/exclamation.png) 8px 50% no-repeat;
                 background-color: #ffe3e3;
                 border-color: #dd0000;
                 color: #880000;
             }
             div.flash.notice {
                 background: url(../images/true.png) 8px 5px no-repeat;
                 background-color: #dfffdf;
                 border-color: #9fcf9f;
                 color: #005f00;
             }
             div.flash.warning, .conflict {
                 background: url(../images/warning.png) 8px 5px no-repeat;
                 background-color: #FFEBC1;
                 border-color: #FDBF3B;
                 color: #A6750C;
                 text-align: left;
             }
             .nodata, .warning {
                 text-align: center;
                 background-color: #FFEBC1;
                 border-color: #FDBF3B;
                 color: #A6750C;
             }
             #errorExplanation ul { font-size: 0.9em;}
             #errorExplanation h2, #errorExplanation p { display: none; }
             .conflict-details {font-size:80%;}
             /***** Ajax indicator ******/
             #ajax-indicator {
             position: absolute; /* fixed not supported by IE */
             background-color:#eee;
             border: 1px solid #bbb;
             top:35%;
             left:40%;
             width:20%;
             font-weight:bold;
             text-align:center;
             padding:0.6em;
             z-index:100;
             opacity: 0.5;
             }
             html>body #ajax-indicator { position: fixed; }
             #ajax-indicator span {
             background-position: 0% 40%;
             background-repeat: no-repeat;
             background-image: url(../images/loading.gif);
             padding-left: 26px;
             vertical-align: bottom;
             }
             /***** Calendar *****/
             table.cal {border-collapse: collapse; width: 100%; margin: 0px 0 6px 0;border: 1px solid #d7d7d7;}
             table.cal thead th {width: 14%; background-color:#EEEEEE; padding: 4px; }
             table.cal thead th.week-number {width: auto;}
             table.cal tbody tr {height: 100px;}
             table.cal td {border: 1px solid #d7d7d7; vertical-align: top; font-size: 0.9em;}
             table.cal td.week-number { background-color:#EEEEEE; padding: 4px; border:none; font-size: 1em;}
             table.cal td p.day-num {font-size: 1.1em; text-align:right;}
             table.cal td.odd p.day-num {color: #bbb;}
             table.cal td.today {background:#ffffdd;}
             table.cal td.today p.day-num {font-weight: bold;}
             table.cal .starting a, p.cal.legend .starting {background: url(../images/bullet_go.png) no-repeat -1px -2px; padding-left:16px;}
             table.cal .ending a, p.cal.legend .ending {background: url(../images/bullet_end.png) no-repeat -1px -2px; padding-left:16px;}
             table.cal .starting.ending a, p.cal.legend .starting.ending {background: url(../images/bullet_diamond.png) no-repeat -1px -2px; padding-left:16px;}
             p.cal.legend span {display:block;}
             /***** Tooltips ******/
             .tooltip{position:relative;z-index:24;}
             .tooltip:hover{z-index:25;color:#000;}
             .tooltip span.tip{display: none; text-align:left;}
             div.tooltip:hover span.tip{
             display:block;
             position:absolute;
             top:12px; left:24px; width:270px;
             border:1px solid #555;
             background-color:#fff;
             padding: 4px;
             font-size: 0.8em;
             color:#505050;
             }
             /***** Progress bar *****/
             table.progress {
                 border-collapse: collapse;
                 border-spacing: 0pt;
                 empty-cells: show;
                 text-align: center;
                 float:left;
                 margin: 1px 6px 1px 0px;
             }
             table.progress td { height: 1em; }
             table.progress td.closed { background: #BAE0BA none repeat scroll 0%; }
             table.progress td.done { background: #D3EDD3 none repeat scroll 0%; }
             table.progress td.todo { background: #eee none repeat scroll 0%; }
             p.pourcent {font-size: 80%;}
             p.progress-info {clear: left; font-size: 80%; margin-top:-4px; color:#777;}
             #roadmap table.progress td { height: 1.2em; }
             /***** Tabs *****/
             #content .tabs {height: 2.6em; margin-bottom:1.2em; position:relative; overflow:hidden;}
             #content .tabs ul {margin:0; position:absolute; bottom:0; padding-left:0.5em; width: 2000px; border-bottom: 1px solid #bbbbbb;}
             #content .tabs ul li {
             float:left;
             list-style-type:none;
             white-space:nowrap;
             margin-right:4px;
             background:#fff;
             position:relative;
             margin-bottom:-1px;
             }
             #content .tabs ul li a{
             display:block;
             font-size: 0.9em;
             text-decoration:none;
             line-height:1.3em;
             padding:4px 6px 4px 6px;
             border: 1px solid #ccc;
             border-bottom: 1px solid #bbbbbb;
             background-color: #f6f6f6;
             color:#999;
             font-weight:bold;
             border-top-left-radius:3px;
             border-top-right-radius:3px;
             }
             #content .tabs ul li a:hover {
             background-color: #ffffdd;
             text-decoration:none;
             }
             #content .tabs ul li a.selected {
             background-color: #fff;
             border: 1px solid #bbbbbb;
             border-bottom: 1px solid #fff;
             color:#444;
             }
             #content .tabs ul li a.selected:hover {
             background-color: #fff;
             }
             div.tabs-buttons { position:absolute; right: 0; width: 48px; height: 24px; background: white; bottom: 0; border-bottom: 1px solid #bbbbbb; }
             button.tab-left, button.tab-right {
                 font-size: 0.9em;
                 cursor: pointer;
                 height:24px;
                 border: 1px solid #ccc;
                 border-bottom: 1px solid #bbbbbb;
                 position:absolute;
                 padding:4px;
                 width: 20px;
                 bottom: -1px;
             }
             button.tab-left {
                 right: 20px;
                 background: #eeeeee url(../images/bullet_arrow_left.png) no-repeat 50% 50%;
                 border-top-left-radius:3px;
             }
             button.tab-right {
                 right: 0;
                 background: #eeeeee url(../images/bullet_arrow_right.png) no-repeat 50% 50%;
                 border-top-right-radius:3px;
             }
             /***** Auto-complete *****/
             div.autocomplete {
               position:absolute;
               width:400px;
               margin:0;
               padding:0;
             }
             div.autocomplete ul {
               list-style-type:none;
               margin:0;
               padding:0;
             }
             div.autocomplete ul li {
               list-style-type:none;
               display:block;
               margin:-1px 0 0 0;
               padding:2px;
               cursor:pointer;
               font-size: 90%;
               border: 1px solid #ccc;
               border-left: 1px solid #ccc;
               border-right: 1px solid #ccc;
               background-color:white;
             }
             div.autocomplete ul li.selected { background-color: #ffb;}
             div.autocomplete ul li span.informal {
               font-size: 80%;
               color: #aaa;
             }
             #parent_issue_candidates ul li {width: 500px;}
             #related_issue_candidates ul li {width: 500px;}
             /***** Diff *****/
             .diff_out { background: #fcc; }
             .diff_out span { background: #faa; }
             .diff_in { background: #cfc; }
             .diff_in span { background: #afa; }
             .text-diff {
             padding: 1em;
             background-color:#f6f6f6;
             color:#505050;
             border: 1px solid #e4e4e4;
             }
             /***** Wiki *****/
             div.wiki table {
                 border-collapse: collapse;
                 margin-bottom: 1em;
             }
             div.wiki table, div.wiki td, div.wiki th {
                 border: 1px solid #bbb;
                 padding: 4px;
             }
             div.wiki .noborder, div.wiki .noborder td, div.wiki .noborder th {border:0;}
             div.wiki .external {
                 background-position: 0% 60%;
                 background-repeat: no-repeat;
                 padding-left: 12px;
                 background-image: url(../images/external.png);
             }
             div.wiki a.new {
                 color: #b73535;
             }
             div.wiki ul, div.wiki ol {margin-bottom:1em;}
             div.wiki pre {
                 margin: 1em 1em 1em 1.6em;
                 padding: 2px 2px 2px 0;
                 background-color: #fafafa;
                 border: 1px solid #dadada;
                 width:auto;
                 overflow-x: auto;
                 overflow-y: hidden;
             }
             div.wiki ul.toc {
                 background-color: #ffffdd;
                 border: 1px solid #e4e4e4;
                 padding: 4px;
                 line-height: 1.2em;
                 margin-bottom: 12px;
                 margin-right: 12px;
                 margin-left: 0;
                 display: table
             }
             * html div.wiki ul.toc { width: 50%; } /* IE6 doesn't autosize div */
             div.wiki ul.toc.right { float: right; margin-left: 12px; margin-right: 0; width: auto; }
             div.wiki ul.toc.left  { float: left; margin-right: 12px; margin-left: 0; width: auto; }
             div.wiki ul.toc ul { margin: 0; padding: 0; }
             div.wiki ul.toc li { list-style-type:none; margin: 0;}
             div.wiki ul.toc li li { margin-left: 1.5em; }
             div.wiki ul.toc li li li { font-size: 0.8em; }
             div.wiki ul.toc a {
                 font-size: 0.9em;
                 font-weight: normal;
                 text-decoration: none;
                 color: #606060;
             }
             div.wiki ul.toc a:hover { color: #c61a1a; text-decoration: underline;}
             a.wiki-anchor { display: none; margin-left: 6px; text-decoration: none; }
             a.wiki-anchor:hover { color: #aaa !important; text-decoration: none; }
             h1:hover a.wiki-anchor, h2:hover a.wiki-anchor, h3:hover a.wiki-anchor { display: inline; color: #ddd; }
             div.wiki img { vertical-align: middle; }
             /***** My page layout *****/
             .block-receiver {
             border:1px dashed #c0c0c0;
             margin-bottom: 20px;
             padding: 15px 0 15px 0;
             }
             .mypage-box {
             margin:0 0 20px 0;
             color:#505050;
             line-height:1.5em;
             }
             .handle {
             cursor: move;
             }
             a.close-icon {
             display:block;
             margin-top:3px;
             overflow:hidden;
             width:12px;
             height:12px;
             background-repeat: no-repeat;
             cursor:pointer;
             background-image:url('../images/close.png');
             }
             a.close-icon:hover {
             background-image:url('../images/close_hl.png');
             }
             /***** Gantt chart *****/
             .gantt_hdr {
               position:absolute;
               top:0;
               height:16px;
               border-top: 1px solid #c0c0c0;
               border-bottom: 1px solid #c0c0c0;
               border-right: 1px solid #c0c0c0;
               text-align: center;
               overflow: hidden;
             }
             .gantt_subjects { font-size: 0.8em; }
             .gantt_subjects div { line-height:16px;height:16px;overflow:hidden;white-space:nowrap;text-overflow: ellipsis; }
             .task {
               position: absolute;
               height:8px;
               font-size:0.8em;
               color:#888;
               padding:0;
               margin:0;
               line-height:16px;
               white-space:nowrap;
             }
             .task.label {width:100%;}
             .task.label.project, .task.label.version { font-weight: bold; }
             .task_late { background:#f66 url(../images/task_late.png); border: 1px solid #f66; }
             .task_done { background:#00c600 url(../images/task_done.png); border: 1px solid #00c600; }
             .task_todo { background:#aaa url(../images/task_todo.png); border: 1px solid #aaa; }
             .task_todo.parent { background: #888; border: 1px solid #888; height: 3px;}
             .task_late.parent, .task_done.parent { height: 3px;}
             .task.parent.marker.starting  { position: absolute; background: url(../images/task_parent_end.png) no-repeat 0 0; width: 8px; height: 16px; margin-left: -4px; left: 0px; top: -1px;}
             .task.parent.marker.ending { position: absolute; background: url(../images/task_parent_end.png) no-repeat 0 0; width: 8px; height: 16px; margin-left: -4px; right: 0px; top: -1px;}
             .version.task_late { background:#f66 url(../images/milestone_late.png); border: 1px solid #f66; height: 2px; margin-top: 3px;}
             .version.task_done { background:#00c600 url(../images/milestone_done.png); border: 1px solid #00c600; height: 2px; margin-top: 3px;}
             .version.task_todo { background:#fff url(../images/milestone_todo.png); border: 1px solid #fff; height: 2px; margin-top: 3px;}
             .version.marker { background-image:url(../images/version_marker.png); background-repeat: no-repeat; border: 0; margin-left: -4px; margin-top: 1px; }
             .project.task_late { background:#f66 url(../images/milestone_late.png); border: 1px solid #f66; height: 2px; margin-top: 3px;}
             .project.task_done { background:#00c600 url(../images/milestone_done.png); border: 1px solid #00c600; height: 2px; margin-top: 3px;}
             .project.task_todo { background:#fff url(../images/milestone_todo.png); border: 1px solid #fff; height: 2px; margin-top: 3px;}
             .project.marker { background-image:url(../images/project_marker.png); background-repeat: no-repeat; border: 0; margin-left: -4px; margin-top: 1px; }
             .version-behind-schedule a, .issue-behind-schedule a {color: #f66914;}
             .version-overdue a, .issue-overdue a, .project-overdue a {color: #f00;}
             /***** Icons *****/
             .icon {
             background-position: 0% 50%;
             background-repeat: no-repeat;
             padding-left: 20px;
             padding-top: 2px;
             padding-bottom: 3px;
             }
             .icon-add { background-image: url(../images/add.png); }
             .icon-edit { background-image: url(../images/edit.png); }
             .icon-copy { background-image: url(../images/copy.png); }
             .icon-duplicate { background-image: url(../images/duplicate.png); }
             .icon-del { background-image: url(../images/delete.png); }
             .icon-move { background-image: url(../images/move.png); }
             .icon-save { background-image: url(../images/save.png); }
             .icon-cancel { background-image: url(../images/cancel.png); }
             .icon-multiple { background-image: url(../images/table_multiple.png); }
             .icon-folder { background-image: url(../images/folder.png); }
             .open .icon-folder { background-image: url(../images/folder_open.png); }
             .icon-package { background-image: url(../images/package.png); }
             .icon-user { background-image: url(../images/user.png); }
             .icon-projects { background-image: url(../images/projects.png); }
             .icon-help { background-image: url(../images/help.png); }
             .icon-attachment  { background-image: url(../images/attachment.png); }
             .icon-history  { background-image: url(../images/history.png); }
             .icon-time  { background-image: url(../images/time.png); }
             .icon-time-add  { background-image: url(../images/time_add.png); }
             .icon-stats  { background-image: url(../images/stats.png); }
             .icon-warning  { background-image: url(../images/warning.png); }
             .icon-fav  { background-image: url(../images/fav.png); }
             .icon-fav-off  { background-image: url(../images/fav_off.png); }
             .icon-reload  { background-image: url(../images/reload.png); }
             .icon-lock  { background-image: url(../images/locked.png); }
             .icon-unlock  { background-image: url(../images/unlock.png); }
             .icon-checked  { background-image: url(../images/true.png); }
             .icon-details  { background-image: url(../images/zoom_in.png); }
             .icon-report  { background-image: url(../images/report.png); }
             .icon-comment  { background-image: url(../images/comment.png); }
             .icon-summary  { background-image: url(../images/lightning.png); }
             .icon-server-authentication { background-image: url(../images/server_key.png); }
             .icon-issue { background-image: url(../images/ticket.png); }
             .icon-zoom-in { background-image: url(../images/zoom_in.png); }
             .icon-zoom-out { background-image: url(../images/zoom_out.png); }
             .icon-passwd { background-image: url(../images/textfield_key.png); }
             .icon-test { background-image: url(../images/bullet_go.png); }
             .icon-file { background-image: url(../images/files/default.png); }
             .icon-file.text-plain { background-image: url(../images/files/text.png); }
             .icon-file.text-x-c { background-image: url(../images/files/c.png); }
             .icon-file.text-x-csharp { background-image: url(../images/files/csharp.png); }
             .icon-file.text-x-java { background-image: url(../images/files/java.png); }
             .icon-file.text-x-javascript { background-image: url(../images/files/js.png); }
             .icon-file.text-x-php { background-image: url(../images/files/php.png); }
             .icon-file.text-x-ruby { background-image: url(../images/files/ruby.png); }
             .icon-file.text-xml { background-image: url(../images/files/xml.png); }
             .icon-file.text-css { background-image: url(../images/files/css.png); }
             .icon-file.text-html { background-image: url(../images/files/html.png); }
             .icon-file.image-gif { background-image: url(../images/files/image.png); }
             .icon-file.image-jpeg { background-image: url(../images/files/image.png); }
             .icon-file.image-png { background-image: url(../images/files/image.png); }
             .icon-file.image-tiff { background-image: url(../images/files/image.png); }
             .icon-file.application-pdf { background-image: url(../images/files/pdf.png); }
             .icon-file.application-zip { background-image: url(../images/files/zip.png); }
             .icon-file.application-x-gzip { background-image: url(../images/files/zip.png); }
             img.gravatar {
                 padding: 2px;
                 border: solid 1px #d5d5d5;
                 background: #fff;
                 vertical-align: middle;
             }
             div.issue img.gravatar {
                 float: left;
                 margin: 0 6px 0 0;
                 padding: 5px;
             }
             div.issue table img.gravatar {
                 height: 14px;
                 width: 14px;
                 padding: 2px;
                 float: left;
                 margin: 0 0.5em 0 0;
             }
             h2 img.gravatar {
                 margin: -2px 4px -4px 0;
             }
             h3 img.gravatar {
                 margin: -4px 4px -4px 0;
             }
             h4 img.gravatar {
                 margin: -6px 4px -4px 0;
             }
             td.username img.gravatar {
                 margin: 0 0.5em 0 0;
                 vertical-align: top;
             }
             #activity dt img.gravatar {
                 float: left;
                 margin: 0 1em 1em 0;
             }
             /* Used on 12px Gravatar img tags without the icon background */
             .icon-gravatar {
               float: left;
               margin-right: 4px;
             }
             #activity dt,
             .journal {
                 clear: left;
             }
             .journal-link {
                 float: right;
             }
             h2 img { vertical-align:middle; }
             .hascontextmenu { cursor: context-menu; }
             /***** Media print specific styles *****/
             @media print {
               #top-menu, #header, #main-menu, #sidebar, #footer, .contextual, .other-formats { display:none; }
               #main { background: #fff; }
               #content { width: 99%; margin: 0; padding: 0; border: 0; background: #fff; overflow: visible !important;}
               #wiki_add_attachment { display:none; }
               .hide-when-print { display: none; }
               .autoscroll {overflow-x: visible;}
               table.list {margin-top:0.5em;}
               table.list th, table.list td {border: 1px solid #aaa;}
             }
             /* Accessibility specific styles */
             .hidden-for-sighted {
               position:absolute;
               left:-10000px;
               top:auto;
               width:1px;
               height:1px;
               overflow:hidden;
             }

test/functional/issues_controller_test.rb +15 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  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__)
             require 'issues_controller'
             class IssuesControllerTest < ActionController::TestCase
               fixtures :projects,
                        :users,
                        :roles,
                        :members,
                        :member_roles,
                        :issues,
                        :issue_statuses,
                        :versions,
                        :trackers,
                        :projects_trackers,
                        :issue_categories,
                        :enabled_modules,
                        :enumerations,
                        :attachments,
                        :workflows,
                        :custom_fields,
                        :custom_values,
                        :custom_fields_projects,
                        :custom_fields_trackers,
                        :time_entries,
                        :journals,
                        :journal_details,
                        :queries,
                        :repositories,
                        :changesets
               include Redmine::I18n
               def setup
                 @controller = IssuesController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
               def test_index
                 with_settings :default_language => "en" do
                   get :index
                   assert_response :success
                   assert_template 'index'
                   assert_not_nil assigns(:issues)
                   assert_nil assigns(:project)
                   assert_tag :tag => 'a', :content => /Can't print recipes/
                   assert_tag :tag => 'a', :content => /Subproject issue/
                   # private projects hidden
                   assert_no_tag :tag => 'a', :content => /Issue of a private subproject/
                   assert_no_tag :tag => 'a', :content => /Issue on project 2/
                   # project column
                   assert_tag :tag => 'th', :content => /Project/
                 end
               end
               def test_index_should_not_list_issues_when_module_disabled
                 EnabledModule.delete_all("name = 'issue_tracking' AND project_id = 1")
                 get :index
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_nil assigns(:project)
                 assert_no_tag :tag => 'a', :content => /Can't print recipes/
                 assert_tag :tag => 'a', :content => /Subproject issue/
               end
               def test_index_should_list_visible_issues_only
                 get :index, :per_page => 100
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_nil assigns(:issues).detect {|issue| !issue.visible?}
               end
               def test_index_with_project
                 Setting.display_subprojects_issues = 0
                 get :index, :project_id => 1
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_tag :tag => 'a', :content => /Can't print recipes/
                 assert_no_tag :tag => 'a', :content => /Subproject issue/
               end
               def test_index_with_project_and_subprojects
                 Setting.display_subprojects_issues = 1
                 get :index, :project_id => 1
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_tag :tag => 'a', :content => /Can't print recipes/
                 assert_tag :tag => 'a', :content => /Subproject issue/
                 assert_no_tag :tag => 'a', :content => /Issue of a private subproject/
               end
               def test_index_with_project_and_subprojects_should_show_private_subprojects
                 @request.session[:user_id] = 2
                 Setting.display_subprojects_issues = 1
                 get :index, :project_id => 1
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_tag :tag => 'a', :content => /Can't print recipes/
                 assert_tag :tag => 'a', :content => /Subproject issue/
                 assert_tag :tag => 'a', :content => /Issue of a private subproject/
               end
               def test_index_with_project_and_default_filter
                 get :index, :project_id => 1, :set_filter => 1
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 query = assigns(:query)
                 assert_not_nil query
                 # default filter
                 assert_equal({'status_id' => {:operator => 'o', :values => ['']}}, query.filters)
               end
               def test_index_with_project_and_filter
                 get :index, :project_id => 1, :set_filter => 1,
                   :f => ['tracker_id'],
                   :op => {'tracker_id' => '='},
                   :v => {'tracker_id' => ['1']}
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 query = assigns(:query)
                 assert_not_nil query
                 assert_equal({'tracker_id' => {:operator => '=', :values => ['1']}}, query.filters)
               end
               def test_index_with_short_filters
                 to_test = {
                   'status_id' => {
                     'o' => { :op => 'o', :values => [''] },
                     'c' => { :op => 'c', :values => [''] },
                     '7' => { :op => '=', :values => ['7'] },
                     '7|3|4' => { :op => '=', :values => ['7', '3', '4'] },
                     '=7' => { :op => '=', :values => ['7'] },
                     '!3' => { :op => '!', :values => ['3'] },
                     '!7|3|4' => { :op => '!', :values => ['7', '3', '4'] }},
                   'subject' => {
                     'This is a subject' => { :op => '=', :values => ['This is a subject'] },
                     'o' => { :op => '=', :values => ['o'] },
                     '~This is part of a subject' => { :op => '~', :values => ['This is part of a subject'] },
                     '!~This is part of a subject' => { :op => '!~', :values => ['This is part of a subject'] }},
                   'tracker_id' => {
                     '3' => { :op => '=', :values => ['3'] },
                     '=3' => { :op => '=', :values => ['3'] }},
                   'start_date' => {
                     '2011-10-12' => { :op => '=', :values => ['2011-10-12'] },
                     '=2011-10-12' => { :op => '=', :values => ['2011-10-12'] },
                     '>=2011-10-12' => { :op => '>=', :values => ['2011-10-12'] },
                     '<=2011-10-12' => { :op => '<=', :values => ['2011-10-12'] },
                     '><2011-10-01|2011-10-30' => { :op => '><', :values => ['2011-10-01', '2011-10-30'] },
                     '<t+2' => { :op => '<t+', :values => ['2'] },
                     '>t+2' => { :op => '>t+', :values => ['2'] },
                     't+2' => { :op => 't+', :values => ['2'] },
                     't' => { :op => 't', :values => [''] },
                     'w' => { :op => 'w', :values => [''] },
                     '>t-2' => { :op => '>t-', :values => ['2'] },
                     '<t-2' => { :op => '<t-', :values => ['2'] },
                     't-2' => { :op => 't-', :values => ['2'] }},
                   'created_on' => {
                     '>=2011-10-12' => { :op => '>=', :values => ['2011-10-12'] },
                     '<t-2' => { :op => '<t-', :values => ['2'] },
                     '>t-2' => { :op => '>t-', :values => ['2'] },
                     't-2' => { :op => 't-', :values => ['2'] }},
                   'cf_1' => {
                     'c' => { :op => '=', :values => ['c'] },
                     '!c' => { :op => '!', :values => ['c'] },
                     '!*' => { :op => '!*', :values => [''] },
                     '*' => { :op => '*', :values => [''] }},
                   'estimated_hours' => {
                     '=13.4' => { :op => '=', :values => ['13.4'] },
                     '>=45' => { :op => '>=', :values => ['45'] },
                     '<=125' => { :op => '<=', :values => ['125'] },
                     '><10.5|20.5' => { :op => '><', :values => ['10.5', '20.5'] },
                     '!*' => { :op => '!*', :values => [''] },
                     '*' => { :op => '*', :values => [''] }}
                 }
                 default_filter = { 'status_id' => {:operator => 'o', :values => [''] }}
                 to_test.each do |field, expression_and_expected|
                   expression_and_expected.each do |filter_expression, expected|
                     get :index, :set_filter => 1, field => filter_expression
                     assert_response :success
                     assert_template 'index'
                     assert_not_nil assigns(:issues)
                     query = assigns(:query)
                     assert_not_nil query
                     assert query.has_filter?(field)
                     assert_equal(default_filter.merge({field => {:operator => expected[:op], :values => expected[:values]}}), query.filters)
                   end
                 end
               end
               def test_index_with_project_and_empty_filters
                 get :index, :project_id => 1, :set_filter => 1, :fields => ['']
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 query = assigns(:query)
                 assert_not_nil query
                 # no filter
                 assert_equal({}, query.filters)
               end
               def test_index_with_query
                 get :index, :project_id => 1, :query_id => 5
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_nil assigns(:issue_count_by_group)
               end
               def test_index_with_query_grouped_by_tracker
                 get :index, :project_id => 1, :query_id => 6
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_not_nil assigns(:issue_count_by_group)
               end
               def test_index_with_query_grouped_by_list_custom_field
                 get :index, :project_id => 1, :query_id => 9
                 assert_response :success
                 assert_template 'index'
                 assert_not_nil assigns(:issues)
                 assert_not_nil assigns(:issue_count_by_group)
               end
               def test_index_with_query_id_and_project_id_should_set_session_query
                 get :index, :project_id => 1, :query_id => 4
                 assert_response :success
                 assert_kind_of Hash, session[:query]
                 assert_equal 4, session[:query][:id]
                 assert_equal 1, session[:query][:project_id]
               end
               def test_index_with_invalid_query_id_should_respond_404
                 get :index, :project_id => 1, :query_id => 999
                 assert_response 404
               end
               def test_index_with_cross_project_query_in_session_should_show_project_issues
                 q = Query.create!(:name => "test", :user_id => 2, :is_public => false, :project => nil)
                 @request.session[:query] = {:id => q.id, :project_id => 1}
                 with_settings :display_subprojects_issues => '0' do
                   get :index, :project_id => 1
                 end
                 assert_response :success
                 assert_not_nil assigns(:query)
                 assert_equal q.id, assigns(:query).id
                 assert_equal 1, assigns(:query).project_id
                 assert_equal [1], assigns(:issues).map(&:project_id).uniq
               end
               def test_private_query_should_not_be_available_to_other_users
                 q = Query.create!(:name => "private", :user => User.find(2), :is_public => false, :project => nil)
                 @request.session[:user_id] = 3
                 get :index, :query_id => q.id
                 assert_response 403
               end
               def test_private_query_should_be_available_to_its_user
                 q = Query.create!(:name => "private", :user => User.find(2), :is_public => false, :project => nil)
                 @request.session[:user_id] = 2
                 get :index, :query_id => q.id
                 assert_response :success
               end
               def test_public_query_should_be_available_to_other_users
                 q = Query.create!(:name => "private", :user => User.find(2), :is_public => true, :project => nil)
                 @request.session[:user_id] = 3
                 get :index, :query_id => q.id
                 assert_response :success
               end
               def test_index_csv
                 get :index, :format => 'csv'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_equal 'text/csv', @response.content_type
                 assert @response.body.starts_with?("#,")
                 lines = @response.body.chomp.split("\n")
                 assert_equal assigns(:query).columns.size + 1, lines[0].split(',').size
               end
               def test_index_csv_with_project
                 get :index, :project_id => 1, :format => 'csv'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_equal 'text/csv', @response.content_type
               end
               def test_index_csv_with_description
                 get :index, :format => 'csv', :description => '1'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_equal 'text/csv', @response.content_type
                 assert @response.body.starts_with?("#,")
                 lines = @response.body.chomp.split("\n")
                 assert_equal assigns(:query).columns.size + 2, lines[0].split(',').size
               end
               def test_index_csv_with_spent_time_column
                 issue = Issue.create!(:project_id => 1, :tracker_id => 1, :subject => 'test_index_csv_with_spent_time_column', :author_id => 2)
                 TimeEntry.create!(:project => issue.project, :issue => issue, :hours => 7.33, :user => User.find(2), :spent_on => Date.today)
                 get :index, :format => 'csv', :set_filter => '1', :c => %w(subject spent_hours)
                 assert_response :success
                 assert_equal 'text/csv', @response.content_type
                 lines = @response.body.chomp.split("\n")
                 assert_include "#{issue.id},#{issue.subject},7.33", lines
               end
               def test_index_csv_with_all_columns
                 get :index, :format => 'csv', :columns => 'all'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_equal 'text/csv', @response.content_type
                 assert @response.body.starts_with?("#,")
                 lines = @response.body.chomp.split("\n")
                 assert_equal assigns(:query).available_columns.size + 1, lines[0].split(',').size
               end
               def test_index_csv_with_multi_column_field
                 CustomField.find(1).update_attribute :multiple, true
                 issue = Issue.find(1)
                 issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
                 issue.save!
                 get :index, :format => 'csv', :columns => 'all'
                 assert_response :success
                 lines = @response.body.chomp.split("\n")
                 assert lines.detect {|line| line.include?('"MySQL, Oracle"')}
               end
               def test_index_csv_big_5
                 with_settings :default_language => "zh-TW" do
                   str_utf8  = "\xe4\xb8\x80\xe6\x9c\x88"
                   str_big5  = "\xa4@\xa4\xeb"
                   if str_utf8.respond_to?(:force_encoding)
                     str_utf8.force_encoding('UTF-8')
                     str_big5.force_encoding('Big5')
                   end
                   issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                     :status_id => 1, :priority => IssuePriority.all.first,
                                     :subject => str_utf8)
                   assert issue.save
                   get :index, :project_id => 1,
                               :f => ['subject'],
                               :op => '=', :values => [str_utf8],
                               :format => 'csv'
                   assert_equal 'text/csv', @response.content_type
                   lines = @response.body.chomp.split("\n")
                   s1 = "\xaa\xac\xbaA"
                   if str_utf8.respond_to?(:force_encoding)
                     s1.force_encoding('Big5')
                   end
                   assert lines[0].include?(s1)
                   assert lines[1].include?(str_big5)
                 end
               end
               def test_index_csv_cannot_convert_should_be_replaced_big_5
                 with_settings :default_language => "zh-TW" do
                   str_utf8  = "\xe4\xbb\xa5\xe5\x86\x85"
                   if str_utf8.respond_to?(:force_encoding)
                     str_utf8.force_encoding('UTF-8')
                   end
                   issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                     :status_id => 1, :priority => IssuePriority.all.first,
                                     :subject => str_utf8)
                   assert issue.save
                   get :index, :project_id => 1,
                               :f => ['subject'],
                               :op => '=', :values => [str_utf8],
                               :c => ['status', 'subject'],
                               :format => 'csv',
                               :set_filter => 1
                   assert_equal 'text/csv', @response.content_type
                   lines = @response.body.chomp.split("\n")
                   s1 = "\xaa\xac\xbaA" # status
                   if str_utf8.respond_to?(:force_encoding)
                     s1.force_encoding('Big5')
                   end
                   assert lines[0].include?(s1)
                   s2 = lines[1].split(",")[2]
                   if s1.respond_to?(:force_encoding)
                     s3 = "\xa5H?" # subject
                     s3.force_encoding('Big5')
                     assert_equal s3, s2
                   elsif RUBY_PLATFORM == 'java'
                     assert_equal "??", s2
                   else
                     assert_equal "\xa5H???", s2
                   end
                 end
               end
               def test_index_csv_tw
                 with_settings :default_language => "zh-TW" do
                   str1  = "test_index_csv_tw"
                   issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                     :status_id => 1, :priority => IssuePriority.all.first,
                                     :subject => str1, :estimated_hours => '1234.5')
                   assert issue.save
                   assert_equal 1234.5, issue.estimated_hours
                   get :index, :project_id => 1,
                               :f => ['subject'],
                               :op => '=', :values => [str1],
                               :c => ['estimated_hours', 'subject'],
                               :format => 'csv',
                               :set_filter => 1
                   assert_equal 'text/csv', @response.content_type
                   lines = @response.body.chomp.split("\n")
                   assert_equal "#{issue.id},1234.50,#{str1}", lines[1]
                   str_tw = "Traditional Chinese (\xe7\xb9\x81\xe9\xab\x94\xe4\xb8\xad\xe6\x96\x87)"
                   if str_tw.respond_to?(:force_encoding)
                     str_tw.force_encoding('UTF-8')
                   end
                   assert_equal str_tw, l(:general_lang_name)
                   assert_equal ',', l(:general_csv_separator)
                   assert_equal '.', l(:general_csv_decimal_separator)
                 end
               end
               def test_index_csv_fr
                 with_settings :default_language => "fr" do
                   str1  = "test_index_csv_fr"
                   issue = Issue.new(:project_id => 1, :tracker_id => 1, :author_id => 3,
                                     :status_id => 1, :priority => IssuePriority.all.first,
                                     :subject => str1, :estimated_hours => '1234.5')
                   assert issue.save
                   assert_equal 1234.5, issue.estimated_hours
                   get :index, :project_id => 1,
                               :f => ['subject'],
                               :op => '=', :values => [str1],
                               :c => ['estimated_hours', 'subject'],
                               :format => 'csv',
                               :set_filter => 1
                   assert_equal 'text/csv', @response.content_type
                   lines = @response.body.chomp.split("\n")
                   assert_equal "#{issue.id};1234,50;#{str1}", lines[1]
                   str_fr = "Fran\xc3\xa7ais"
                   if str_fr.respond_to?(:force_encoding)
                     str_fr.force_encoding('UTF-8')
                   end
                   assert_equal str_fr, l(:general_lang_name)
                   assert_equal ';', l(:general_csv_separator)
                   assert_equal ',', l(:general_csv_decimal_separator)
                 end
               end
               def test_index_pdf
                 ["en", "zh", "zh-TW", "ja", "ko"].each do |lang|
                   with_settings :default_language => lang do
                     get :index
                     assert_response :success
                     assert_template 'index'
                     if lang == "ja"
                       if RUBY_PLATFORM != 'java'
                         assert_equal "CP932", l(:general_pdf_encoding)
                       end
                       if RUBY_PLATFORM == 'java' && l(:general_pdf_encoding) == "CP932"
                         next
                       end
                     end
                     get :index, :format => 'pdf'
                     assert_response :success
                     assert_not_nil assigns(:issues)
                     assert_equal 'application/pdf', @response.content_type
                     get :index, :project_id => 1, :format => 'pdf'
                     assert_response :success
                     assert_not_nil assigns(:issues)
                     assert_equal 'application/pdf', @response.content_type
                     get :index, :project_id => 1, :query_id => 6, :format => 'pdf'
                     assert_response :success
                     assert_not_nil assigns(:issues)
                     assert_equal 'application/pdf', @response.content_type
                   end
                 end
               end
               def test_index_pdf_with_query_grouped_by_list_custom_field
                 get :index, :project_id => 1, :query_id => 9, :format => 'pdf'
                 assert_response :success
                 assert_not_nil assigns(:issues)
                 assert_not_nil assigns(:issue_count_by_group)
                 assert_equal 'application/pdf', @response.content_type
               end
               def test_index_atom
                 get :index, :project_id => 'ecookbook', :format => 'atom'
                 assert_response :success
                 assert_template 'common/feed'
                 assert_tag :tag => 'link', :parent =>  {:tag => 'feed', :parent => nil },
                     :attributes => {:rel => 'self', :href => 'http://test.host/projects/ecookbook/issues.atom'}
                 assert_tag :tag => 'link', :parent =>  {:tag => 'feed', :parent => nil },
                     :attributes => {:rel => 'alternate', :href => 'http://test.host/projects/ecookbook/issues'}
                 assert_tag :tag => 'entry', :child => {
                   :tag => 'link',
                   :attributes => {:href => 'http://test.host/issues/1'}}
               end
               def test_index_sort
                 get :index, :sort => 'tracker,id:desc'
                 assert_response :success
                 sort_params = @request.session['issues_index_sort']
                 assert sort_params.is_a?(String)
                 assert_equal 'tracker,id:desc', sort_params
                 issues = assigns(:issues)
                 assert_not_nil issues
                 assert !issues.empty?
                 assert_equal issues.sort {|a,b| a.tracker == b.tracker ? b.id <=> a.id : a.tracker <=> b.tracker }.collect(&:id), issues.collect(&:id)
               end
               def test_index_sort_by_field_not_included_in_columns
                 Setting.issue_list_default_columns = %w(subject author)
                 get :index, :sort => 'tracker'
               end
               def test_index_sort_by_assigned_to
                 get :index, :sort => 'assigned_to'
                 assert_response :success
                 assignees = assigns(:issues).collect(&:assigned_to).compact
                 assert_equal assignees.sort, assignees
               end
               def test_index_sort_by_assigned_to_desc
                 get :index, :sort => 'assigned_to:desc'
                 assert_response :success
                 assignees = assigns(:issues).collect(&:assigned_to).compact
                 assert_equal assignees.sort.reverse, assignees
               end
               def test_index_group_by_assigned_to
                 get :index, :group_by => 'assigned_to', :sort => 'priority'
                 assert_response :success
               end
               def test_index_sort_by_author
                 get :index, :sort => 'author'
                 assert_response :success
                 authors = assigns(:issues).collect(&:author)
                 assert_equal authors.sort, authors
               end
               def test_index_sort_by_author_desc
                 get :index, :sort => 'author:desc'
                 assert_response :success
                 authors = assigns(:issues).collect(&:author)
                 assert_equal authors.sort.reverse, authors
               end
               def test_index_group_by_author
                 get :index, :group_by => 'author', :sort => 'priority'
                 assert_response :success
               end
               def test_index_sort_by_spent_hours
                 get :index, :sort => 'spent_hours:desc'
                 assert_response :success
                 hours = assigns(:issues).collect(&:spent_hours)
                 assert_equal hours.sort.reverse, hours
               end
               def test_index_with_columns
                 columns = ['tracker', 'subject', 'assigned_to']
                 get :index, :set_filter => 1, :c => columns
                 assert_response :success
                 # query should use specified columns
                 query = assigns(:query)
                 assert_kind_of Query, query
                 assert_equal columns, query.column_names.map(&:to_s)
                 # columns should be stored in session
                 assert_kind_of Hash, session[:query]
                 assert_kind_of Array, session[:query][:column_names]
                 assert_equal columns, session[:query][:column_names].map(&:to_s)
                 # ensure only these columns are kept in the selected columns list
                 assert_tag :tag => 'select', :attributes => { :id => 'selected_columns' },
                                              :children => { :count => 3 }
                 assert_no_tag :tag => 'option', :attributes => { :value => 'project' },
                                                 :parent => { :tag => 'select', :attributes => { :id => "selected_columns" } }
               end
               def test_index_without_project_should_implicitly_add_project_column_to_default_columns
                 Setting.issue_list_default_columns = ['tracker', 'subject', 'assigned_to']
                 get :index, :set_filter => 1
                 # query should use specified columns
                 query = assigns(:query)
                 assert_kind_of Query, query
                 assert_equal [:project, :tracker, :subject, :assigned_to], query.columns.map(&:name)
               end
               def test_index_without_project_and_explicit_default_columns_should_not_add_project_column
                 Setting.issue_list_default_columns = ['tracker', 'subject', 'assigned_to']
                 columns = ['tracker', 'subject', 'assigned_to']
                 get :index, :set_filter => 1, :c => columns
                 # query should use specified columns
                 query = assigns(:query)
                 assert_kind_of Query, query
                 assert_equal columns.map(&:to_sym), query.columns.map(&:name)
               end
               def test_index_with_custom_field_column
                 columns = %w(tracker subject cf_2)
                 get :index, :set_filter => 1, :c => columns
                 assert_response :success
                 # query should use specified columns
                 query = assigns(:query)
                 assert_kind_of Query, query
                 assert_equal columns, query.column_names.map(&:to_s)
                 assert_tag :td,
                   :attributes => {:class => 'cf_2 string'},
                   :ancestor => {:tag => 'table', :attributes => {:class => /issues/}}
               end
               def test_index_with_multi_custom_field_column
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 issue = Issue.find(1)
                 issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
                 issue.save!
                 get :index, :set_filter => 1, :c => %w(tracker subject cf_1)
                 assert_response :success
                 assert_tag :td,
                   :attributes => {:class => /cf_1/},
                   :content => 'MySQL, Oracle'
               end
               def test_index_with_multi_user_custom_field_column
                 field = IssueCustomField.create!(:name => 'Multi user', :field_format => 'user', :multiple => true,
                   :tracker_ids => [1], :is_for_all => true)
                 issue = Issue.find(1)
                 issue.custom_field_values = {field.id => ['2', '3']}
                 issue.save!
                 get :index, :set_filter => 1, :c => ['tracker', 'subject', "cf_#{field.id}"]
                 assert_response :success
                 assert_tag :td,
                   :attributes => {:class => /cf_#{field.id}/},
                   :child => {:tag => 'a', :content => 'John Smith'}
               end
               def test_index_with_date_column
                 Issue.find(1).update_attribute :start_date, '1987-08-24'
                 with_settings :date_format => '%d/%m/%Y' do
                   get :index, :set_filter => 1, :c => %w(start_date)
                   assert_tag 'td', :attributes => {:class => /start_date/}, :content => '24/08/1987'
                 end
               end
               def test_index_with_done_ratio
                 Issue.find(1).update_attribute :done_ratio, 40
                 get :index, :set_filter => 1, :c => %w(done_ratio)
                 assert_tag 'td', :attributes => {:class => /done_ratio/},
                   :child => {:tag => 'table', :attributes => {:class => 'progress'},
                     :descendant => {:tag => 'td', :attributes => {:class => 'closed', :style => 'width: 40%;'}}
                   }
               end
               def test_index_with_spent_hours_column
                 get :index, :set_filter => 1, :c => %w(subject spent_hours)
                 assert_tag 'tr', :attributes => {:id => 'issue-3'},
                   :child => {
                     :tag => 'td', :attributes => {:class => /spent_hours/}, :content => '1.00'
                   }
               end
               def test_index_should_not_show_spent_hours_column_without_permission
                 Role.anonymous.remove_permission! :view_time_entries
                 get :index, :set_filter => 1, :c => %w(subject spent_hours)
                 assert_no_tag 'td', :attributes => {:class => /spent_hours/}
               end
               def test_index_with_fixed_version
                 get :index, :set_filter => 1, :c => %w(fixed_version)
                 assert_tag 'td', :attributes => {:class => /fixed_version/},
                   :child => {:tag => 'a', :content => '1.0', :attributes => {:href => '/versions/2'}}
               end
               def test_index_send_html_if_query_is_invalid
                 get :index, :f => ['start_date'], :op => {:start_date => '='}
                 assert_equal 'text/html', @response.content_type
                 assert_template 'index'
               end
               def test_index_send_nothing_if_query_is_invalid
                 get :index, :f => ['start_date'], :op => {:start_date => '='}, :format => 'csv'
                 assert_equal 'text/csv', @response.content_type
                 assert @response.body.blank?
               end
               def test_show_by_anonymous
                 get :show, :id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:issue)
                 assert_equal Issue.find(1), assigns(:issue)
                 # anonymous role is allowed to add a note
                 assert_tag :tag => 'form',
                            :descendant => { :tag => 'fieldset',
                                             :child => { :tag => 'legend',
                                                         :content => /Notes/ } }
                 assert_tag :tag => 'title',
                   :content => "Bug #1: Can't print recipes - eCookbook - Redmine"
               end
               def test_show_by_manager
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response :success
                 assert_tag :tag => 'a',
                   :content => /Quote/
                 assert_tag :tag => 'form',
                            :descendant => { :tag => 'fieldset',
                                             :child => { :tag => 'legend',
                                                         :content => /Change properties/ } },
                            :descendant => { :tag => 'fieldset',
                                             :child => { :tag => 'legend',
                                                         :content => /Log time/ } },
                            :descendant => { :tag => 'fieldset',
                                             :child => { :tag => 'legend',
                                                         :content => /Notes/ } }
               end
               def test_show_should_display_update_form
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response :success
                 assert_tag 'form', :attributes => {:id => 'issue-form'}
                 assert_tag 'input', :attributes => {:name => 'issue[is_private]'}
                 assert_tag 'select', :attributes => {:name => 'issue[project_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[tracker_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[subject]'}
                 assert_tag 'textarea', :attributes => {:name => 'issue[description]'}
                 assert_tag 'select', :attributes => {:name => 'issue[status_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[priority_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[assigned_to_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[category_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[fixed_version_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[parent_issue_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[start_date]'}
                 assert_tag 'input', :attributes => {:name => 'issue[due_date]'}
                 assert_tag 'select', :attributes => {:name => 'issue[done_ratio]'}
                 assert_tag 'input', :attributes => { :name => 'issue[custom_field_values][2]' }
                 assert_no_tag 'input', :attributes => {:name => 'issue[watcher_user_ids][]'}
                 assert_tag 'textarea', :attributes => {:name => 'notes'}
               end
               def test_show_should_display_update_form_with_minimal_permissions
                 Role.find(1).update_attribute :permissions, [:view_issues, :add_issue_notes]
                 Workflow.delete_all :role_id => 1
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response :success
                 assert_tag 'form', :attributes => {:id => 'issue-form'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[is_private]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[project_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[tracker_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[subject]'}
                 assert_no_tag 'textarea', :attributes => {:name => 'issue[description]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[status_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[priority_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[assigned_to_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[category_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[fixed_version_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[parent_issue_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[start_date]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[due_date]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[done_ratio]'}
                 assert_no_tag 'input', :attributes => { :name => 'issue[custom_field_values][2]' }
                 assert_no_tag 'input', :attributes => {:name => 'issue[watcher_user_ids][]'}
                 assert_tag 'textarea', :attributes => {:name => 'notes'}
               end
               def test_show_should_display_update_form_with_workflow_permissions
                 Role.find(1).update_attribute :permissions, [:view_issues, :add_issue_notes]
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response :success
                 assert_tag 'form', :attributes => {:id => 'issue-form'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[is_private]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[project_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[tracker_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[subject]'}
                 assert_no_tag 'textarea', :attributes => {:name => 'issue[description]'}
                 assert_tag 'select', :attributes => {:name => 'issue[status_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[priority_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[assigned_to_id]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[category_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[fixed_version_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[parent_issue_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[start_date]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[due_date]'}
                 assert_tag 'select', :attributes => {:name => 'issue[done_ratio]'}
                 assert_no_tag 'input', :attributes => { :name => 'issue[custom_field_values][2]' }
                 assert_no_tag 'input', :attributes => {:name => 'issue[watcher_user_ids][]'}
                 assert_tag 'textarea', :attributes => {:name => 'notes'}
               end
               def test_show_should_not_display_update_form_without_permissions
                 Role.find(1).update_attribute :permissions, [:view_issues]
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response :success
                 assert_no_tag 'form', :attributes => {:id => 'issue-form'}
               end
               def test_update_form_should_not_display_inactive_enumerations
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response :success
                 assert ! IssuePriority.find(15).active?
                 assert_no_tag :option, :attributes => {:value => '15'},
                                        :parent => {:tag => 'select', :attributes => {:id => 'issue_priority_id'} }
               end
               def test_update_form_should_allow_attachment_upload
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_tag :tag => 'form',
                   :attributes => {:id => 'issue-form', :method => 'post', :enctype => 'multipart/form-data'},
                   :descendant => {
                     :tag => 'input',
                     :attributes => {:type => 'file', :name => 'attachments[1][file]'}
                   }
               end
               def test_show_should_deny_anonymous_access_without_permission
                 Role.anonymous.remove_permission!(:view_issues)
                 get :show, :id => 1
                 assert_response :redirect
               end
               def test_show_should_deny_anonymous_access_to_private_issue
                 Issue.update_all(["is_private = ?", true], "id = 1")
                 get :show, :id => 1
                 assert_response :redirect
               end
               def test_show_should_deny_non_member_access_without_permission
                 Role.non_member.remove_permission!(:view_issues)
                 @request.session[:user_id] = 9
                 get :show, :id => 1
                 assert_response 403
               end
               def test_show_should_deny_non_member_access_to_private_issue
                 Issue.update_all(["is_private = ?", true], "id = 1")
                 @request.session[:user_id] = 9
                 get :show, :id => 1
                 assert_response 403
               end
               def test_show_should_deny_member_access_without_permission
                 Role.find(1).remove_permission!(:view_issues)
                 @request.session[:user_id] = 2
                 get :show, :id => 1
                 assert_response 403
               end
               def test_show_should_deny_member_access_to_private_issue_without_permission
                 Issue.update_all(["is_private = ?", true], "id = 1")
                 @request.session[:user_id] = 3
                 get :show, :id => 1
                 assert_response 403
               end
               def test_show_should_allow_author_access_to_private_issue
                 Issue.update_all(["is_private = ?, author_id = 3", true], "id = 1")
                 @request.session[:user_id] = 3
                 get :show, :id => 1
                 assert_response :success
               end
               def test_show_should_allow_assignee_access_to_private_issue
                 Issue.update_all(["is_private = ?, assigned_to_id = 3", true], "id = 1")
                 @request.session[:user_id] = 3
                 get :show, :id => 1
                 assert_response :success
               end
               def test_show_should_allow_member_access_to_private_issue_with_permission
                 Issue.update_all(["is_private = ?", true], "id = 1")
                 User.find(3).roles_for_project(Project.find(1)).first.update_attribute :issues_visibility, 'all'
                 @request.session[:user_id] = 3
                 get :show, :id => 1
                 assert_response :success
               end
               def test_show_should_not_disclose_relations_to_invisible_issues
                 Setting.cross_project_issue_relations = '1'
                 IssueRelation.create!(:issue_from => Issue.find(1), :issue_to => Issue.find(2), :relation_type => 'relates')
                 # Relation to a private project issue
                 IssueRelation.create!(:issue_from => Issue.find(1), :issue_to => Issue.find(4), :relation_type => 'relates')
                 get :show, :id => 1
                 assert_response :success
                 assert_tag :div, :attributes => { :id => 'relations' },
                                  :descendant => { :tag => 'a', :content => /#2$/ }
                 assert_no_tag :div, :attributes => { :id => 'relations' },
                                     :descendant => { :tag => 'a', :content => /#4$/ }
               end
               def test_show_should_list_subtasks
                 Issue.create!(:project_id => 1, :author_id => 1, :tracker_id => 1, :parent_issue_id => 1, :subject => 'Child Issue')
                 get :show, :id => 1
                 assert_response :success
                 assert_tag 'div', :attributes => {:id => 'issue_tree'},
                   :descendant => {:tag => 'td', :content => /Child Issue/, :attributes => {:class => /subject/}}
               end
               def test_show_should_list_parents
                 issue = Issue.create!(:project_id => 1, :author_id => 1, :tracker_id => 1, :parent_issue_id => 1, :subject => 'Child Issue')
                 get :show, :id => issue.id
                 assert_response :success
                 assert_tag 'div', :attributes => {:class => 'subject'},
                   :descendant => {:tag => 'h3', :content => 'Child Issue'}
                 assert_tag 'div', :attributes => {:class => 'subject'},
                   :descendant => {:tag => 'a', :attributes => {:href => '/issues/1'}}
               end
               def test_show_should_not_display_prev_next_links_without_query_in_session
                 get :show, :id => 1
                 assert_response :success
                 assert_nil assigns(:prev_issue_id)
                 assert_nil assigns(:next_issue_id)
                 assert_no_tag 'div', :attributes => {:class => /next-prev-links/}
               end
               def test_show_should_display_prev_next_links_with_query_in_session
                 @request.session[:query] = {:filters => {'status_id' => {:values => [''], :operator => 'o'}}, :project_id => nil}
                 @request.session['issues_index_sort'] = 'id'
                 with_settings :display_subprojects_issues => '0' do
                   get :show, :id => 3
                 end
                 assert_response :success
                 # Previous and next issues for all projects
                 assert_equal 2, assigns(:prev_issue_id)
                 assert_equal 5, assigns(:next_issue_id)
                 assert_tag 'div', :attributes => {:class => /next-prev-links/}
                 assert_tag 'a', :attributes => {:href => '/issues/2'}, :content => /Previous/
                 assert_tag 'a', :attributes => {:href => '/issues/5'}, :content => /Next/
                 count = Issue.open.visible.count
                 assert_tag 'span', :attributes => {:class => 'position'}, :content => "3 of #{count}"
               end
               def test_show_should_display_prev_next_links_with_saved_query_in_session
                 query = Query.create!(:name => 'test', :is_public => true,  :user_id => 1,
                   :filters => {'status_id' => {:values => ['5'], :operator => '='}},
                   :sort_criteria => [['id', 'asc']])
                 @request.session[:query] = {:id => query.id, :project_id => nil}
                 get :show, :id => 11
                 assert_response :success
                 assert_equal query, assigns(:query)
                 # Previous and next issues for all projects
                 assert_equal 8, assigns(:prev_issue_id)
                 assert_equal 12, assigns(:next_issue_id)
                 assert_tag 'a', :attributes => {:href => '/issues/8'}, :content => /Previous/
                 assert_tag 'a', :attributes => {:href => '/issues/12'}, :content => /Next/
               end
               def test_show_should_display_prev_next_links_with_query_and_sort_on_association
                 @request.session[:query] = {:filters => {'status_id' => {:values => [''], :operator => 'o'}}, :project_id => nil}
                 %w(project tracker status priority author assigned_to category fixed_version).each do |assoc_sort|
                   @request.session['issues_index_sort'] = assoc_sort
                   get :show, :id => 3
                   assert_response :success, "Wrong response status for #{assoc_sort} sort"
                   assert_tag 'div', :attributes => {:class => /next-prev-links/}, :content => /Previous/
                   assert_tag 'div', :attributes => {:class => /next-prev-links/}, :content => /Next/
                 end
               end
               def test_show_should_display_prev_next_links_with_project_query_in_session
                 @request.session[:query] = {:filters => {'status_id' => {:values => [''], :operator => 'o'}}, :project_id => 1}
                 @request.session['issues_index_sort'] = 'id'
                 with_settings :display_subprojects_issues => '0' do
                   get :show, :id => 3
                 end
                 assert_response :success
                 # Previous and next issues inside project
                 assert_equal 2, assigns(:prev_issue_id)
                 assert_equal 7, assigns(:next_issue_id)
                 assert_tag 'a', :attributes => {:href => '/issues/2'}, :content => /Previous/
                 assert_tag 'a', :attributes => {:href => '/issues/7'}, :content => /Next/
               end
               def test_show_should_not_display_prev_link_for_first_issue
                 @request.session[:query] = {:filters => {'status_id' => {:values => [''], :operator => 'o'}}, :project_id => 1}
                 @request.session['issues_index_sort'] = 'id'
                 with_settings :display_subprojects_issues => '0' do
                   get :show, :id => 1
                 end
                 assert_response :success
                 assert_nil assigns(:prev_issue_id)
                 assert_equal 2, assigns(:next_issue_id)
                 assert_no_tag 'a', :content => /Previous/
                 assert_tag 'a', :attributes => {:href => '/issues/2'}, :content => /Next/
               end
               def test_show_should_not_display_prev_next_links_for_issue_not_in_query_results
                 @request.session[:query] = {:filters => {'status_id' => {:values => [''], :operator => 'c'}}, :project_id => 1}
                 @request.session['issues_index_sort'] = 'id'
                 get :show, :id => 1
                 assert_response :success
                 assert_nil assigns(:prev_issue_id)
                 assert_nil assigns(:next_issue_id)
                 assert_no_tag 'a', :content => /Previous/
                 assert_no_tag 'a', :content => /Next/
               end
               def test_show_should_display_visible_changesets_from_other_projects
                 project = Project.find(2)
                 issue = project.issues.first
                 issue.changeset_ids = [102]
                 issue.save!
                 project.disable_module! :repository
                 @request.session[:user_id] = 2
                 get :show, :id => issue.id
                 assert_tag 'a', :attributes => {:href => "/projects/ecookbook/repository/revisions/3"}
               end
               def test_show_with_multi_custom_field
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 issue = Issue.find(1)
                 issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
                 issue.save!
                 get :show, :id => 1
                 assert_response :success
                 assert_tag :td, :content => 'MySQL, Oracle'
               end
               def test_show_with_multi_user_custom_field
                 field = IssueCustomField.create!(:name => 'Multi user', :field_format => 'user', :multiple => true,
                   :tracker_ids => [1], :is_for_all => true)
                 issue = Issue.find(1)
                 issue.custom_field_values = {field.id => ['2', '3']}
                 issue.save!
                 get :show, :id => 1
                 assert_response :success
                 # TODO: should display links
                 assert_tag :td, :content => 'Dave Lopper, John Smith'
               end
               def test_show_atom
                 get :show, :id => 2, :format => 'atom'
                 assert_response :success
                 assert_template 'journals/index'
                 # Inline image
                 assert_select 'content', :text => Regexp.new(Regexp.quote('http://test.host/attachments/download/10'))
               end
               def test_show_export_to_pdf
                 get :show, :id => 3, :format => 'pdf'
                 assert_response :success
                 assert_equal 'application/pdf', @response.content_type
                 assert @response.body.starts_with?('%PDF')
                 assert_not_nil assigns(:issue)
               end
               def test_get_new
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_response :success
                 assert_template 'new'
                 assert_tag 'input', :attributes => {:name => 'issue[is_private]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[project_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[tracker_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[subject]'}
                 assert_tag 'textarea', :attributes => {:name => 'issue[description]'}
                 assert_tag 'select', :attributes => {:name => 'issue[status_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[priority_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[assigned_to_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[category_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[fixed_version_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[parent_issue_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[start_date]'}
                 assert_tag 'input', :attributes => {:name => 'issue[due_date]'}
                 assert_tag 'select', :attributes => {:name => 'issue[done_ratio]'}
                 assert_tag 'input', :attributes => { :name => 'issue[custom_field_values][2]', :value => 'Default string' }
                 assert_tag 'input', :attributes => {:name => 'issue[watcher_user_ids][]'}
                 # Be sure we don't display inactive IssuePriorities
                 assert ! IssuePriority.find(15).active?
                 assert_no_tag :option, :attributes => {:value => '15'},
                                        :parent => {:tag => 'select', :attributes => {:id => 'issue_priority_id'} }
               end
               def test_get_new_with_minimal_permissions
                 Role.find(1).update_attribute :permissions, [:add_issues]
                 Workflow.delete_all :role_id => 1
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_response :success
                 assert_template 'new'
                 assert_no_tag 'input', :attributes => {:name => 'issue[is_private]'}
                 assert_no_tag 'select', :attributes => {:name => 'issue[project_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[tracker_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[subject]'}
                 assert_tag 'textarea', :attributes => {:name => 'issue[description]'}
                 assert_tag 'select', :attributes => {:name => 'issue[status_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[priority_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[assigned_to_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[category_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[fixed_version_id]'}
                 assert_no_tag 'input', :attributes => {:name => 'issue[parent_issue_id]'}
                 assert_tag 'input', :attributes => {:name => 'issue[start_date]'}
                 assert_tag 'input', :attributes => {:name => 'issue[due_date]'}
                 assert_tag 'select', :attributes => {:name => 'issue[done_ratio]'}
                 assert_tag 'input', :attributes => { :name => 'issue[custom_field_values][2]', :value => 'Default string' }
                 assert_no_tag 'input', :attributes => {:name => 'issue[watcher_user_ids][]'}
               end
               def test_get_new_with_list_custom_field
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_response :success
                 assert_template 'new'
                 assert_tag 'select',
                   :attributes => {:name => 'issue[custom_field_values][1]'},
                   :children => {:count => 4},
                   :child => {:tag => 'option', :attributes => {:value => 'MySQL'}, :content => 'MySQL'}
               end
               def test_get_new_with_multi_custom_field
                 field = IssueCustomField.find(1)
                 field.update_attribute :multiple, true
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_response :success
                 assert_template 'new'
                 assert_tag 'select',
                   :attributes => {:name => 'issue[custom_field_values][1][]', :multiple => 'multiple'},
                   :children => {:count => 3},
                   :child => {:tag => 'option', :attributes => {:value => 'MySQL'}, :content => 'MySQL'}
                 assert_tag 'input',
                   :attributes => {:name => 'issue[custom_field_values][1][]', :value => ''}
               end
               def test_get_new_with_multi_user_custom_field
                 field = IssueCustomField.create!(:name => 'Multi user', :field_format => 'user', :multiple => true,
                   :tracker_ids => [1], :is_for_all => true)
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_response :success
                 assert_template 'new'
                 assert_tag 'select',
                   :attributes => {:name => "issue[custom_field_values][#{field.id}][]", :multiple => 'multiple'},
                   :children => {:count => Project.find(1).users.count},
                   :child => {:tag => 'option', :attributes => {:value => '2'}, :content => 'John Smith'}
                 assert_tag 'input',
                   :attributes => {:name => "issue[custom_field_values][#{field.id}][]", :value => ''}
               end
               def test_get_new_without_default_start_date_is_creation_date
                 Setting.default_issue_start_date_to_creation_date = 0
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_response :success
                 assert_template 'new'
                 assert_tag :tag => 'input', :attributes => { :name => 'issue[start_date]',
                                                              :value => nil }
               end
               def test_get_new_with_default_start_date_is_creation_date
                 Setting.default_issue_start_date_to_creation_date = 1
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_response :success
                 assert_template 'new'
                 assert_tag :tag => 'input', :attributes => { :name => 'issue[start_date]',
                                                              :value => Date.today.to_s }
               end
               def test_get_new_form_should_allow_attachment_upload
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :tracker_id => 1
                 assert_tag :tag => 'form',
                   :attributes => {:id => 'issue-form', :method => 'post', :enctype => 'multipart/form-data'},
                   :descendant => {
                     :tag => 'input',
                     :attributes => {:type => 'file', :name => 'attachments[1][file]'}
                   }
               end
               def test_get_new_should_prefill_the_form_from_params
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1,
                   :issue => {:tracker_id => 3, :description => 'Prefilled', :custom_field_values => {'2' => 'Custom field value'}}
                 issue = assigns(:issue)
                 assert_equal 3, issue.tracker_id
                 assert_equal 'Prefilled', issue.description
                 assert_equal 'Custom field value', issue.custom_field_value(2)
                 assert_tag 'select',
                   :attributes => {:name => 'issue[tracker_id]'},
                   :child => {:tag => 'option', :attributes => {:value => '3', :selected => 'selected'}}
                 assert_tag 'textarea',
                   :attributes => {:name => 'issue[description]'}, :content => 'Prefilled'
                 assert_tag 'input',
                   :attributes => {:name => 'issue[custom_field_values][2]', :value => 'Custom field value'}
               end
               def test_get_new_without_tracker_id
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1
                 assert_response :success
                 assert_template 'new'
                 issue = assigns(:issue)
                 assert_not_nil issue
                 assert_equal Project.find(1).trackers.first, issue.tracker
               end
               def test_get_new_with_no_default_status_should_display_an_error
                 @request.session[:user_id] = 2
                 IssueStatus.delete_all
                 get :new, :project_id => 1
                 assert_response 500
                 assert_error_tag :content => /No default issue/
               end
               def test_get_new_with_no_tracker_should_display_an_error
                 @request.session[:user_id] = 2
                 Tracker.delete_all
                 get :new, :project_id => 1
                 assert_response 500
                 assert_error_tag :content => /No tracker/
               end
               def test_update_new_form
                 @request.session[:user_id] = 2
                 xhr :post, :new, :project_id => 1,
                                  :issue => {:tracker_id => 2,
                                             :subject => 'This is the test_new issue',
                                             :description => 'This is the description',
                                             :priority_id => 5}
                 assert_response :success
                 assert_template 'attributes'
                 issue = assigns(:issue)
                 assert_kind_of Issue, issue
                 assert_equal 1, issue.project_id
                 assert_equal 2, issue.tracker_id
                 assert_equal 'This is the test_new issue', issue.subject
               end
               def test_post_create
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 3,
                                         :status_id => 2,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :start_date => '2010-11-07',
                                         :estimated_hours => '',
                                         :custom_field_values => {'2' => 'Value for field 2'}}
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
                 issue = Issue.find_by_subject('This is the test_new issue')
                 assert_not_nil issue
                 assert_equal 2, issue.author_id
                 assert_equal 3, issue.tracker_id
                 assert_equal 2, issue.status_id
                 assert_equal Date.parse('2010-11-07'), issue.start_date
                 assert_nil issue.estimated_hours
                 v = issue.custom_values.find(:first, :conditions => {:custom_field_id => 2})
                 assert_not_nil v
                 assert_equal 'Value for field 2', v.value
               end
               def test_post_new_with_group_assignment
                 group = Group.find(11)
                 project = Project.find(1)
                 project.members << Member.new(:principal => group, :roles => [Role.givable.first])
                 with_settings :issue_group_assignment => '1' do
                   @request.session[:user_id] = 2
                   assert_difference 'Issue.count' do
                     post :create, :project_id => project.id,
                                   :issue => {:tracker_id => 3,
                                              :status_id => 1,
                                              :subject => 'This is the test_new_with_group_assignment issue',
                                              :assigned_to_id => group.id}
                   end
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
                 issue = Issue.find_by_subject('This is the test_new_with_group_assignment issue')
                 assert_not_nil issue
                 assert_equal group, issue.assigned_to
               end
               def test_post_create_without_start_date_and_default_start_date_is_not_creation_date
                 Setting.default_issue_start_date_to_creation_date = 0
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 3,
                                         :status_id => 2,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :estimated_hours => '',
                                         :custom_field_values => {'2' => 'Value for field 2'}}
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
                 issue = Issue.find_by_subject('This is the test_new issue')
                 assert_not_nil issue
                 assert_nil issue.start_date
               end
               def test_post_create_without_start_date_and_default_start_date_is_creation_date
                 Setting.default_issue_start_date_to_creation_date = 1
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 3,
                                         :status_id => 2,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :estimated_hours => '',
                                         :custom_field_values => {'2' => 'Value for field 2'}}
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
                 issue = Issue.find_by_subject('This is the test_new issue')
                 assert_not_nil issue
                 assert_equal Date.today, issue.start_date
               end
               def test_post_create_and_continue
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                     :issue => {:tracker_id => 3, :subject => 'This is first issue', :priority_id => 5},
                     :continue => ''
                 end
                 issue = Issue.first(:order => 'id DESC')
                 assert_redirected_to :controller => 'issues', :action => 'new', :project_id => 'ecookbook', :issue => {:tracker_id => 3}
                 assert_not_nil flash[:notice], "flash was not set"
                 assert flash[:notice].include?("<a href='/issues/#{issue.id}'>##{issue.id}</a>"), "issue link not found in flash: #{flash[:notice]}"
               end
               def test_post_create_without_custom_fields_param
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5}
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
               end
               def test_post_create_with_multi_custom_field
                 field = IssueCustomField.find_by_name('Database')
                 field.update_attribute(:multiple, true)
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :custom_field_values => {'1' => ['', 'MySQL', 'Oracle']}}
                 end
                 assert_response 302
                 issue = Issue.first(:order => 'id DESC')
                 assert_equal ['MySQL', 'Oracle'], issue.custom_field_value(1).sort
               end
               def test_post_create_with_empty_multi_custom_field
                 field = IssueCustomField.find_by_name('Database')
                 field.update_attribute(:multiple, true)
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :custom_field_values => {'1' => ['']}}
                 end
                 assert_response 302
                 issue = Issue.first(:order => 'id DESC')
                 assert_equal [''], issue.custom_field_value(1).sort
               end
               def test_post_create_with_multi_user_custom_field
                 field = IssueCustomField.create!(:name => 'Multi user', :field_format => 'user', :multiple => true,
                   :tracker_ids => [1], :is_for_all => true)
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :custom_field_values => {field.id.to_s => ['', '2', '3']}}
                 end
                 assert_response 302
                 issue = Issue.first(:order => 'id DESC')
                 assert_equal ['2', '3'], issue.custom_field_value(field).sort
               end
               def test_post_create_with_required_custom_field_and_without_custom_fields_param
                 field = IssueCustomField.find_by_name('Database')
                 field.update_attribute(:is_required, true)
                 @request.session[:user_id] = 2
                 assert_no_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5}
                 end
                 assert_response :success
                 assert_template 'new'
                 issue = assigns(:issue)
                 assert_not_nil issue
                 assert_error_tag :content => /Database can't be blank/
               end
               def test_post_create_with_watchers
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 assert_difference 'Watcher.count', 2 do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is a new issue with watchers',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :watcher_user_ids => ['2', '3']}
                 end
                 issue = Issue.find_by_subject('This is a new issue with watchers')
                 assert_not_nil issue
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => issue
                 # Watchers added
                 assert_equal [2, 3], issue.watcher_user_ids.sort
                 assert issue.watched_by?(User.find(3))
                 # Watchers notified
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert [mail.bcc, mail.cc].flatten.include?(User.find(3).mail)
               end
               def test_post_create_subissue
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is a child issue',
                                         :parent_issue_id => 2}
                 end
                 issue = Issue.find_by_subject('This is a child issue')
                 assert_not_nil issue
                 assert_equal Issue.find(2), issue.parent
               end
               def test_post_create_subissue_with_non_numeric_parent_id
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is a child issue',
                                         :parent_issue_id => 'ABC'}
                 end
                 issue = Issue.find_by_subject('This is a child issue')
                 assert_not_nil issue
                 assert_nil issue.parent
               end
               def test_post_create_private
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is a private issue',
                                         :is_private => '1'}
                 end
                 issue = Issue.first(:order => 'id DESC')
                 assert issue.is_private?
               end
               def test_post_create_private_with_set_own_issues_private_permission
                 role = Role.find(1)
                 role.remove_permission! :set_issues_private
                 role.add_permission! :set_own_issues_private
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 1,
                                         :subject => 'This is a private issue',
                                         :is_private => '1'}
                 end
                 issue = Issue.first(:order => 'id DESC')
                 assert issue.is_private?
               end
               def test_post_create_should_send_a_notification
                 ActionMailer::Base.deliveries.clear
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1,
                              :issue => {:tracker_id => 3,
                                         :subject => 'This is the test_new issue',
                                         :description => 'This is the description',
                                         :priority_id => 5,
                                         :estimated_hours => '',
                                         :custom_field_values => {'2' => 'Value for field 2'}}
                 end
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => Issue.last.id
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
               def test_post_create_should_preserve_fields_values_on_validation_failure
                 @request.session[:user_id] = 2
                 post :create, :project_id => 1,
                            :issue => {:tracker_id => 1,
                                       # empty subject
                                       :subject => '',
                                       :description => 'This is a description',
                                       :priority_id => 6,
                                       :custom_field_values => {'1' => 'Oracle', '2' => 'Value for field 2'}}
                 assert_response :success
                 assert_template 'new'
                 assert_tag :textarea, :attributes => { :name => 'issue[description]' },
                                       :content => 'This is a description'
                 assert_tag :select, :attributes => { :name => 'issue[priority_id]' },
                                     :child => { :tag => 'option', :attributes => { :selected => 'selected',
                                                                                    :value => '6' },
                                                                   :content => 'High' }
                 # Custom fields
                 assert_tag :select, :attributes => { :name => 'issue[custom_field_values][1]' },
                                     :child => { :tag => 'option', :attributes => { :selected => 'selected',
                                                                                    :value => 'Oracle' },
                                                                   :content => 'Oracle' }
                 assert_tag :input, :attributes => { :name => 'issue[custom_field_values][2]',
                                                     :value => 'Value for field 2'}
               end
+              def test_post_create_with_failure_should_preserve_watchers
+                assert !User.find(8).member_of?(Project.find(1))
+                @request.session[:user_id] = 2
+                post :create, :project_id => 1,
+                     :issue => {:tracker_id => 1,
+                                :watcher_user_ids => ['3', '8']}
+                assert_response :success
+                assert_template 'new'
+                assert_tag 'input', :attributes => {:name => 'issue[watcher_user_ids][]', :value => '2', :checked => nil}
+                assert_tag 'input', :attributes => {:name => 'issue[watcher_user_ids][]', :value => '3', :checked => 'checked'}
+                assert_tag 'input', :attributes => {:name => 'issue[watcher_user_ids][]', :value => '8', :checked => 'checked'}
+              end
               def test_post_create_should_ignore_non_safe_attributes
                 @request.session[:user_id] = 2
                 assert_nothing_raised do
                   post :create, :project_id => 1, :issue => { :tracker => "A param can not be a Tracker" }
                 end
               end
               def test_post_create_with_attachment
                 set_tmp_attachments_directory
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   assert_difference 'Attachment.count' do
                     post :create, :project_id => 1,
                       :issue => { :tracker_id => '1', :subject => 'With attachment' },
                       :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}}
                   end
                 end
                 issue = Issue.first(:order => 'id DESC')
                 attachment = Attachment.first(:order => 'id DESC')
                 assert_equal issue, attachment.container
                 assert_equal 2, attachment.author_id
                 assert_equal 'testfile.txt', attachment.filename
                 assert_equal 'text/plain', attachment.content_type
                 assert_equal 'test file', attachment.description
                 assert_equal 59, attachment.filesize
                 assert File.exists?(attachment.diskfile)
                 assert_equal 59, File.size(attachment.diskfile)
               end
               def test_post_create_with_failure_should_save_attachments
                 set_tmp_attachments_directory
                 @request.session[:user_id] = 2
                 assert_no_difference 'Issue.count' do
                   assert_difference 'Attachment.count' do
                     post :create, :project_id => 1,
                       :issue => { :tracker_id => '1', :subject => '' },
                       :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}}
                     assert_response :success
                     assert_template 'new'
                   end
                 end
                 attachment = Attachment.first(:order => 'id DESC')
                 assert_equal 'testfile.txt', attachment.filename
                 assert File.exists?(attachment.diskfile)
                 assert_nil attachment.container
                 assert_tag 'input', :attributes => {:name => 'attachments[p0][token]', :value => attachment.token}
                 assert_tag 'span', :content => /testfile.txt/
               end
               def test_post_create_with_failure_should_keep_saved_attachments
                 set_tmp_attachments_directory
                 attachment = Attachment.create!(:file => uploaded_test_file("testfile.txt", "text/plain"), :author_id => 2)
                 @request.session[:user_id] = 2
                 assert_no_difference 'Issue.count' do
                   assert_no_difference 'Attachment.count' do
                     post :create, :project_id => 1,
                       :issue => { :tracker_id => '1', :subject => '' },
                       :attachments => {'p0' => {'token' => attachment.token}}
                     assert_response :success
                     assert_template 'new'
                   end
                 end
                 assert_tag 'input', :attributes => {:name => 'attachments[p0][token]', :value => attachment.token}
                 assert_tag 'span', :content => /testfile.txt/
               end
               def test_post_create_should_attach_saved_attachments
                 set_tmp_attachments_directory
                 attachment = Attachment.create!(:file => uploaded_test_file("testfile.txt", "text/plain"), :author_id => 2)
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   assert_no_difference 'Attachment.count' do
                     post :create, :project_id => 1,
                       :issue => { :tracker_id => '1', :subject => 'Saved attachments' },
                       :attachments => {'p0' => {'token' => attachment.token}}
                     assert_response 302
                   end
                 end
                 issue = Issue.first(:order => 'id DESC')
                 assert_equal 1, issue.attachments.count
                 attachment.reload
                 assert_equal issue, attachment.container
               end
               context "without workflow privilege" do
                 setup do
                   Workflow.delete_all(["role_id = ?", Role.anonymous.id])
                   Role.anonymous.add_permission! :add_issues, :add_issue_notes
                 end
                 context "#new" do
                   should "propose default status only" do
                     get :new, :project_id => 1
                     assert_response :success
                     assert_template 'new'
                     assert_tag :tag => 'select',
                       :attributes => {:name => 'issue[status_id]'},
                       :children => {:count => 1},
                       :child => {:tag => 'option', :attributes => {:value => IssueStatus.default.id.to_s}}
                   end
                   should "accept default status" do
                     assert_difference 'Issue.count' do
                       post :create, :project_id => 1,
                                  :issue => {:tracker_id => 1,
                                             :subject => 'This is an issue',
                                             :status_id => 1}
                     end
                     issue = Issue.last(:order => 'id')
                     assert_equal IssueStatus.default, issue.status
                   end
                   should "ignore unauthorized status" do
                     assert_difference 'Issue.count' do
                       post :create, :project_id => 1,
                                  :issue => {:tracker_id => 1,
                                             :subject => 'This is an issue',
                                             :status_id => 3}
                     end
                     issue = Issue.last(:order => 'id')
                     assert_equal IssueStatus.default, issue.status
                   end
                 end
                 context "#update" do
                   should "ignore status change" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:status_id => 3}
                     end
                     assert_equal 1, Issue.find(1).status_id
                   end
                   should "ignore attributes changes" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:subject => 'changed', :assigned_to_id => 2}
                     end
                     issue = Issue.find(1)
                     assert_equal "Can't print recipes", issue.subject
                     assert_nil issue.assigned_to
                   end
                 end
               end
               context "with workflow privilege" do
                 setup do
                   Workflow.delete_all(["role_id = ?", Role.anonymous.id])
                   Workflow.create!(:role => Role.anonymous, :tracker_id => 1, :old_status_id => 1, :new_status_id => 3)
                   Workflow.create!(:role => Role.anonymous, :tracker_id => 1, :old_status_id => 1, :new_status_id => 4)
                   Role.anonymous.add_permission! :add_issues, :add_issue_notes
                 end
                 context "#update" do
                   should "accept authorized status" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:status_id => 3}
                     end
                     assert_equal 3, Issue.find(1).status_id
                   end
                   should "ignore unauthorized status" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:status_id => 2}
                     end
                     assert_equal 1, Issue.find(1).status_id
                   end
                   should "accept authorized attributes changes" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:assigned_to_id => 2}
                     end
                     issue = Issue.find(1)
                     assert_equal 2, issue.assigned_to_id
                   end
                   should "ignore unauthorized attributes changes" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:subject => 'changed'}
                     end
                     issue = Issue.find(1)
                     assert_equal "Can't print recipes", issue.subject
                   end
                 end
                 context "and :edit_issues permission" do
                   setup do
                     Role.anonymous.add_permission! :add_issues, :edit_issues
                   end
                   should "accept authorized status" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:status_id => 3}
                     end
                     assert_equal 3, Issue.find(1).status_id
                   end
                   should "ignore unauthorized status" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:status_id => 2}
                     end
                     assert_equal 1, Issue.find(1).status_id
                   end
                   should "accept authorized attributes changes" do
                     assert_difference 'Journal.count' do
                       put :update, :id => 1, :notes => 'just trying', :issue => {:subject => 'changed', :assigned_to_id => 2}
                     end
                     issue = Issue.find(1)
                     assert_equal "changed", issue.subject
                     assert_equal 2, issue.assigned_to_id
                   end
                 end
               end
               def test_new_as_copy
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :copy_from => 1
                 assert_response :success
                 assert_template 'new'
                 assert_not_nil assigns(:issue)
                 orig = Issue.find(1)
                 assert_equal 1, assigns(:issue).project_id
                 assert_equal orig.subject, assigns(:issue).subject
                 assert assigns(:issue).copy?
                 assert_tag 'form', :attributes => {:id => 'issue-form', :action => '/projects/ecookbook/issues'}
                 assert_tag 'select', :attributes => {:name => 'issue[project_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[project_id]'},
                   :child => {:tag => 'option', :attributes => {:value => '1', :selected => 'selected'}, :content => 'eCookbook'}
                 assert_tag 'select', :attributes => {:name => 'issue[project_id]'},
                   :child => {:tag => 'option', :attributes => {:value => '2', :selected => nil}, :content => 'OnlineStore'}
                 assert_tag 'input', :attributes => {:name => 'copy_from', :value => '1'}
               end
               def test_new_as_copy_with_attachments_should_show_copy_attachments_checkbox
                 @request.session[:user_id] = 2
                 issue = Issue.find(3)
                 assert issue.attachments.count > 0
                 get :new, :project_id => 1, :copy_from => 3
                 assert_tag 'input', :attributes => {:name => 'copy_attachments', :type => 'checkbox', :checked => 'checked', :value => '1'}
               end
               def test_new_as_copy_without_attachments_should_not_show_copy_attachments_checkbox
                 @request.session[:user_id] = 2
                 issue = Issue.find(3)
                 issue.attachments.delete_all
                 get :new, :project_id => 1, :copy_from => 3
                 assert_no_tag 'input', :attributes => {:name => 'copy_attachments', :type => 'checkbox', :checked => 'checked', :value => '1'}
               end
               def test_new_as_copy_with_invalid_issue_should_respond_with_404
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1, :copy_from => 99999
                 assert_response 404
               end
               def test_create_as_copy_on_different_project
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1, :copy_from => 1,
                     :issue => {:project_id => '2', :tracker_id => '3', :status_id => '1', :subject => 'Copy'}
                   assert_not_nil assigns(:issue)
                   assert assigns(:issue).copy?
                 end
                 issue = Issue.first(:order => 'id DESC')
                 assert_redirected_to "/issues/#{issue.id}"
                 assert_equal 2, issue.project_id
                 assert_equal 3, issue.tracker_id
                 assert_equal 'Copy', issue.subject
               end
               def test_create_as_copy_should_copy_attachments
                 @request.session[:user_id] = 2
                 issue = Issue.find(3)
                 count = issue.attachments.count
                 assert count > 0
                 assert_difference 'Issue.count' do
                   assert_difference 'Attachment.count', count do
                     assert_no_difference 'Journal.count' do
                       post :create, :project_id => 1, :copy_from => 3,
                         :issue => {:project_id => '1', :tracker_id => '3', :status_id => '1', :subject => 'Copy with attachments'},
                         :copy_attachments => '1'
                     end
                   end
                 end
                 copy = Issue.first(:order => 'id DESC')
                 assert_equal count, copy.attachments.count
                 assert_equal issue.attachments.map(&:filename).sort, copy.attachments.map(&:filename).sort
               end
               def test_create_as_copy_without_copy_attachments_option_should_not_copy_attachments
                 @request.session[:user_id] = 2
                 issue = Issue.find(3)
                 count = issue.attachments.count
                 assert count > 0
                 assert_difference 'Issue.count' do
                   assert_no_difference 'Attachment.count' do
                     assert_no_difference 'Journal.count' do
                       post :create, :project_id => 1, :copy_from => 3,
                         :issue => {:project_id => '1', :tracker_id => '3', :status_id => '1', :subject => 'Copy with attachments'}
                     end
                   end
                 end
                 copy = Issue.first(:order => 'id DESC')
                 assert_equal 0, copy.attachments.count
               end
               def test_create_as_copy_with_attachments_should_add_new_files
                 @request.session[:user_id] = 2
                 issue = Issue.find(3)
                 count = issue.attachments.count
                 assert count > 0
                 assert_difference 'Issue.count' do
                   assert_difference 'Attachment.count', count + 1 do
                     assert_no_difference 'Journal.count' do
                       post :create, :project_id => 1, :copy_from => 3,
                         :issue => {:project_id => '1', :tracker_id => '3', :status_id => '1', :subject => 'Copy with attachments'},
                         :copy_attachments => '1',
                         :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}}
                     end
                   end
                 end
                 copy = Issue.first(:order => 'id DESC')
                 assert_equal count + 1, copy.attachments.count
               end
               def test_create_as_copy_with_failure
                 @request.session[:user_id] = 2
                 post :create, :project_id => 1, :copy_from => 1,
                   :issue => {:project_id => '2', :tracker_id => '3', :status_id => '1', :subject => ''}
                 assert_response :success
                 assert_template 'new'
                 assert_not_nil assigns(:issue)
                 assert assigns(:issue).copy?
                 assert_tag 'form', :attributes => {:id => 'issue-form', :action => '/projects/ecookbook/issues'}
                 assert_tag 'select', :attributes => {:name => 'issue[project_id]'}
                 assert_tag 'select', :attributes => {:name => 'issue[project_id]'},
                   :child => {:tag => 'option', :attributes => {:value => '1', :selected => nil}, :content => 'eCookbook'}
                 assert_tag 'select', :attributes => {:name => 'issue[project_id]'},
                   :child => {:tag => 'option', :attributes => {:value => '2', :selected => 'selected'}, :content => 'OnlineStore'}
                 assert_tag 'input', :attributes => {:name => 'copy_from', :value => '1'}
               end
               def test_create_as_copy_on_project_without_permission_should_ignore_target_project
                 @request.session[:user_id] = 2
                 assert !User.find(2).member_of?(Project.find(4))
                 assert_difference 'Issue.count' do
                   post :create, :project_id => 1, :copy_from => 1,
                     :issue => {:project_id => '4', :tracker_id => '3', :status_id => '1', :subject => 'Copy'}
                 end
                 issue = Issue.first(:order => 'id DESC')
                 assert_equal 1, issue.project_id
               end
               def test_get_edit
                 @request.session[:user_id] = 2
                 get :edit, :id => 1
                 assert_response :success
                 assert_template 'edit'
                 assert_not_nil assigns(:issue)
                 assert_equal Issue.find(1), assigns(:issue)
                 # Be sure we don't display inactive IssuePriorities
                 assert ! IssuePriority.find(15).active?
                 assert_no_tag :option, :attributes => {:value => '15'},
                                        :parent => {:tag => 'select', :attributes => {:id => 'issue_priority_id'} }
               end
               def test_get_edit_should_display_the_time_entry_form_with_log_time_permission
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').update_attribute :permissions, [:view_issues, :edit_issues, :log_time]
                 get :edit, :id => 1
                 assert_tag 'input', :attributes => {:name => 'time_entry[hours]'}
               end
               def test_get_edit_should_not_display_the_time_entry_form_without_log_time_permission
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').remove_permission! :log_time
                 get :edit, :id => 1
                 assert_no_tag 'input', :attributes => {:name => 'time_entry[hours]'}
               end
               def test_get_edit_with_params
                 @request.session[:user_id] = 2
                 get :edit, :id => 1, :issue => { :status_id => 5, :priority_id => 7 },
                     :time_entry => { :hours => '2.5', :comments => 'test_get_edit_with_params', :activity_id => TimeEntryActivity.first.id }
                 assert_response :success
                 assert_template 'edit'
                 issue = assigns(:issue)
                 assert_not_nil issue
                 assert_equal 5, issue.status_id
                 assert_tag :select, :attributes => { :name => 'issue[status_id]' },
                                     :child => { :tag => 'option',
                                                 :content => 'Closed',
                                                 :attributes => { :selected => 'selected' } }
                 assert_equal 7, issue.priority_id
                 assert_tag :select, :attributes => { :name => 'issue[priority_id]' },
                                     :child => { :tag => 'option',
                                                 :content => 'Urgent',
                                                 :attributes => { :selected => 'selected' } }
                 assert_tag :input, :attributes => { :name => 'time_entry[hours]', :value => '2.5' }
                 assert_tag :select, :attributes => { :name => 'time_entry[activity_id]' },
                                     :child => { :tag => 'option',
                                                 :attributes => { :selected => 'selected', :value => TimeEntryActivity.first.id } }
                 assert_tag :input, :attributes => { :name => 'time_entry[comments]', :value => 'test_get_edit_with_params' }
               end
               def test_get_edit_with_multi_custom_field
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 issue = Issue.find(1)
                 issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
                 issue.save!
                 @request.session[:user_id] = 2
                 get :edit, :id => 1
                 assert_response :success
                 assert_template 'edit'
                 assert_tag 'select', :attributes => {:name => 'issue[custom_field_values][1][]', :multiple => 'multiple'}
                 assert_tag 'select', :attributes => {:name => 'issue[custom_field_values][1][]'},
                   :child => {:tag => 'option', :attributes => {:value => 'MySQL', :selected => 'selected'}}
                 assert_tag 'select', :attributes => {:name => 'issue[custom_field_values][1][]'},
                   :child => {:tag => 'option', :attributes => {:value => 'PostgreSQL', :selected => nil}}
                 assert_tag 'select', :attributes => {:name => 'issue[custom_field_values][1][]'},
                   :child => {:tag => 'option', :attributes => {:value => 'Oracle', :selected => 'selected'}}
               end
               def test_update_edit_form
                 @request.session[:user_id] = 2
                 xhr :put, :new, :project_id => 1,
                                          :id => 1,
                                          :issue => {:tracker_id => 2,
                                                     :subject => 'This is the test_new issue',
                                                     :description => 'This is the description',
                                                     :priority_id => 5}
                 assert_response :success
                 assert_template 'attributes'
                 issue = assigns(:issue)
                 assert_kind_of Issue, issue
                 assert_equal 1, issue.id
                 assert_equal 1, issue.project_id
                 assert_equal 2, issue.tracker_id
                 assert_equal 'This is the test_new issue', issue.subject
               end
               def test_update_edit_form_with_project_change
                 @request.session[:user_id] = 2
                 xhr :put, :new, :project_id => 1,
                                          :id => 1,
                                          :project_change => '1',
                                          :issue => {:project_id => 2,
                                                     :tracker_id => 2,
                                                     :subject => 'This is the test_new issue',
                                                     :description => 'This is the description',
                                                     :priority_id => 5}
                 assert_response :success
                 assert_template 'form'
                 issue = assigns(:issue)
                 assert_kind_of Issue, issue
                 assert_equal 1, issue.id
                 assert_equal 2, issue.project_id
                 assert_equal 2, issue.tracker_id
                 assert_equal 'This is the test_new issue', issue.subject
               end
               def test_put_update_without_custom_fields_param
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 issue = Issue.find(1)
                 assert_equal '125', issue.custom_value_for(2).value
                 old_subject = issue.subject
                 new_subject = 'Subject modified by IssuesControllerTest#test_post_edit'
                 assert_difference('Journal.count') do
                   assert_difference('JournalDetail.count', 2) do
                     put :update, :id => 1, :issue => {:subject => new_subject,
                                                      :priority_id => '6',
                                                      :category_id => '1' # no change
                                                     }
                   end
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue.reload
                 assert_equal new_subject, issue.subject
                 # Make sure custom fields were not cleared
                 assert_equal '125', issue.custom_value_for(2).value
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert mail.subject.starts_with?("[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}]")
                 assert_mail_body_match "Subject changed from #{old_subject} to #{new_subject}", mail
               end
               def test_put_update_with_project_change
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 assert_difference('Journal.count') do
                   assert_difference('JournalDetail.count', 3) do
                     put :update, :id => 1, :issue => {:project_id => '2',
                                                      :tracker_id => '1', # no change
                                                      :priority_id => '6',
                                                      :category_id => '3'
                                                     }
                   end
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue = Issue.find(1)
                 assert_equal 2, issue.project_id
                 assert_equal 1, issue.tracker_id
                 assert_equal 6, issue.priority_id
                 assert_equal 3, issue.category_id
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert mail.subject.starts_with?("[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}]")
                 assert_mail_body_match "Project changed from eCookbook to OnlineStore", mail
               end
               def test_put_update_with_tracker_change
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 assert_difference('Journal.count') do
                   assert_difference('JournalDetail.count', 2) do
                     put :update, :id => 1, :issue => {:project_id => '1',
                                                      :tracker_id => '2',
                                                      :priority_id => '6'
                                                     }
                   end
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue = Issue.find(1)
                 assert_equal 1, issue.project_id
                 assert_equal 2, issue.tracker_id
                 assert_equal 6, issue.priority_id
                 assert_equal 1, issue.category_id
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert mail.subject.starts_with?("[#{issue.project.name} - #{issue.tracker.name} ##{issue.id}]")
                 assert_mail_body_match "Tracker changed from Bug to Feature request", mail
               end
               def test_put_update_with_custom_field_change
                 @request.session[:user_id] = 2
                 issue = Issue.find(1)
                 assert_equal '125', issue.custom_value_for(2).value
                 assert_difference('Journal.count') do
                   assert_difference('JournalDetail.count', 3) do
                     put :update, :id => 1, :issue => {:subject => 'Custom field change',
                                                      :priority_id => '6',
                                                      :category_id => '1', # no change
                                                      :custom_field_values => { '2' => 'New custom value' }
                                                     }
                   end
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue.reload
                 assert_equal 'New custom value', issue.custom_value_for(2).value
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 assert_mail_body_match "Searchable field changed from 125 to New custom value", mail
               end
               def test_put_update_with_multi_custom_field_change
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 issue = Issue.find(1)
                 issue.custom_field_values = {1 => ['MySQL', 'Oracle']}
                 issue.save!
                 @request.session[:user_id] = 2
                 assert_difference('Journal.count') do
                   assert_difference('JournalDetail.count', 3) do
                     put :update, :id => 1,
                       :issue => {
                         :subject => 'Custom field change',
                         :custom_field_values => { '1' => ['', 'Oracle', 'PostgreSQL'] }
                       }
                   end
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 assert_equal ['Oracle', 'PostgreSQL'], Issue.find(1).custom_field_value(1).sort
               end
               def test_put_update_with_status_and_assignee_change
                 issue = Issue.find(1)
                 assert_equal 1, issue.status_id
                 @request.session[:user_id] = 2
                 assert_difference('TimeEntry.count', 0) do
                   put :update,
                        :id => 1,
                        :issue => { :status_id => 2, :assigned_to_id => 3 },
                        :notes => 'Assigned to dlopper',
                        :time_entry => { :hours => '', :comments => '', :activity_id => TimeEntryActivity.first }
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue.reload
                 assert_equal 2, issue.status_id
                 j = Journal.find(:first, :order => 'id DESC')
                 assert_equal 'Assigned to dlopper', j.notes
                 assert_equal 2, j.details.size
                 mail = ActionMailer::Base.deliveries.last
                 assert_mail_body_match "Status changed from New to Assigned", mail
                 # subject should contain the new status
                 assert mail.subject.include?("(#{ IssueStatus.find(2).name })")
               end
               def test_put_update_with_note_only
                 notes = 'Note added by IssuesControllerTest#test_update_with_note_only'
                 # anonymous user
                 put :update,
                      :id => 1,
                      :notes => notes
                 assert_redirected_to :action => 'show', :id => '1'
                 j = Journal.find(:first, :order => 'id DESC')
                 assert_equal notes, j.notes
                 assert_equal 0, j.details.size
                 assert_equal User.anonymous, j.user
                 mail = ActionMailer::Base.deliveries.last
                 assert_mail_body_match notes, mail
               end
               def test_put_update_with_note_and_spent_time
                 @request.session[:user_id] = 2
                 spent_hours_before = Issue.find(1).spent_hours
                 assert_difference('TimeEntry.count') do
                   put :update,
                        :id => 1,
                        :notes => '2.5 hours added',
                        :time_entry => { :hours => '2.5', :comments => 'test_put_update_with_note_and_spent_time', :activity_id => TimeEntryActivity.first.id }
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 issue = Issue.find(1)
                 j = Journal.find(:first, :order => 'id DESC')
                 assert_equal '2.5 hours added', j.notes
                 assert_equal 0, j.details.size
                 t = issue.time_entries.find_by_comments('test_put_update_with_note_and_spent_time')
                 assert_not_nil t
                 assert_equal 2.5, t.hours
                 assert_equal spent_hours_before + 2.5, issue.spent_hours
               end
               def test_put_update_with_attachment_only
                 set_tmp_attachments_directory
                 # Delete all fixtured journals, a race condition can occur causing the wrong
                 # journal to get fetched in the next find.
                 Journal.delete_all
                 # anonymous user
                 assert_difference 'Attachment.count' do
                   put :update, :id => 1,
                     :notes => '',
                     :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}}
                 end
                 assert_redirected_to :action => 'show', :id => '1'
                 j = Issue.find(1).journals.find(:first, :order => 'id DESC')
                 assert j.notes.blank?
                 assert_equal 1, j.details.size
                 assert_equal 'testfile.txt', j.details.first.value
                 assert_equal User.anonymous, j.user
                 attachment = Attachment.first(:order => 'id DESC')
                 assert_equal Issue.find(1), attachment.container
                 assert_equal User.anonymous, attachment.author
                 assert_equal 'testfile.txt', attachment.filename
                 assert_equal 'text/plain', attachment.content_type
                 assert_equal 'test file', attachment.description
                 assert_equal 59, attachment.filesize
                 assert File.exists?(attachment.diskfile)
                 assert_equal 59, File.size(attachment.diskfile)
                 mail = ActionMailer::Base.deliveries.last
                 assert_mail_body_match 'testfile.txt', mail
               end
               def test_put_update_with_failure_should_save_attachments
                 set_tmp_attachments_directory
                 @request.session[:user_id] = 2
                 assert_no_difference 'Journal.count' do
                   assert_difference 'Attachment.count' do
                     put :update, :id => 1,
                       :issue => { :subject => '' },
                       :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}}
                     assert_response :success
                     assert_template 'edit'
                   end
                 end
                 attachment = Attachment.first(:order => 'id DESC')
                 assert_equal 'testfile.txt', attachment.filename
                 assert File.exists?(attachment.diskfile)
                 assert_nil attachment.container
                 assert_tag 'input', :attributes => {:name => 'attachments[p0][token]', :value => attachment.token}
                 assert_tag 'span', :content => /testfile.txt/
               end
               def test_put_update_with_failure_should_keep_saved_attachments
                 set_tmp_attachments_directory
                 attachment = Attachment.create!(:file => uploaded_test_file("testfile.txt", "text/plain"), :author_id => 2)
                 @request.session[:user_id] = 2
                 assert_no_difference 'Journal.count' do
                   assert_no_difference 'Attachment.count' do
                     put :update, :id => 1,
                       :issue => { :subject => '' },
                       :attachments => {'p0' => {'token' => attachment.token}}
                     assert_response :success
                     assert_template 'edit'
                   end
                 end
                 assert_tag 'input', :attributes => {:name => 'attachments[p0][token]', :value => attachment.token}
                 assert_tag 'span', :content => /testfile.txt/
               end
               def test_put_update_should_attach_saved_attachments
                 set_tmp_attachments_directory
                 attachment = Attachment.create!(:file => uploaded_test_file("testfile.txt", "text/plain"), :author_id => 2)
                 @request.session[:user_id] = 2
                 assert_difference 'Journal.count' do
                   assert_difference 'JournalDetail.count' do
                     assert_no_difference 'Attachment.count' do
                       put :update, :id => 1,
                         :notes => 'Attachment added',
                         :attachments => {'p0' => {'token' => attachment.token}}
                       assert_redirected_to '/issues/1'
                     end
                   end
                 end
                 attachment.reload
                 assert_equal Issue.find(1), attachment.container
                 journal = Journal.first(:order => 'id DESC')
                 assert_equal 1, journal.details.size
                 assert_equal 'testfile.txt', journal.details.first.value
               end
               def test_put_update_with_attachment_that_fails_to_save
                 set_tmp_attachments_directory
                 # Delete all fixtured journals, a race condition can occur causing the wrong
                 # journal to get fetched in the next find.
                 Journal.delete_all
                 # Mock out the unsaved attachment
                 Attachment.any_instance.stubs(:create).returns(Attachment.new)
                 # anonymous user
                 put :update,
                      :id => 1,
                      :notes => '',
                      :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
                 assert_redirected_to :action => 'show', :id => '1'
                 assert_equal '1 file(s) could not be saved.', flash[:warning]
               end
               def test_put_update_with_no_change
                 issue = Issue.find(1)
                 issue.journals.clear
                 ActionMailer::Base.deliveries.clear
                 put :update,
                      :id => 1,
                      :notes => ''
                 assert_redirected_to :action => 'show', :id => '1'
                 issue.reload
                 assert issue.journals.empty?
                 # No email should be sent
                 assert ActionMailer::Base.deliveries.empty?
               end
               def test_put_update_should_send_a_notification
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 issue = Issue.find(1)
                 old_subject = issue.subject
                 new_subject = 'Subject modified by IssuesControllerTest#test_post_edit'
                 put :update, :id => 1, :issue => {:subject => new_subject,
                                                  :priority_id => '6',
                                                  :category_id => '1' # no change
                                                 }
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
               def test_put_update_with_invalid_spent_time_hours_only
                 @request.session[:user_id] = 2
                 notes = 'Note added by IssuesControllerTest#test_post_edit_with_invalid_spent_time'
                 assert_no_difference('Journal.count') do
                   put :update,
                        :id => 1,
                        :notes => notes,
                        :time_entry => {"comments"=>"", "activity_id"=>"", "hours"=>"2z"}
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_error_tag :descendant => {:content => /Activity can't be blank/}
                 assert_tag :textarea, :attributes => { :name => 'notes' }, :content => notes
                 assert_tag :input, :attributes => { :name => 'time_entry[hours]', :value => "2z" }
               end
               def test_put_update_with_invalid_spent_time_comments_only
                 @request.session[:user_id] = 2
                 notes = 'Note added by IssuesControllerTest#test_post_edit_with_invalid_spent_time'
                 assert_no_difference('Journal.count') do
                   put :update,
                        :id => 1,
                        :notes => notes,
                        :time_entry => {"comments"=>"this is my comment", "activity_id"=>"", "hours"=>""}
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_error_tag :descendant => {:content => /Activity can't be blank/}
                 assert_error_tag :descendant => {:content => /Hours can't be blank/}
                 assert_tag :textarea, :attributes => { :name => 'notes' }, :content => notes
                 assert_tag :input, :attributes => { :name => 'time_entry[comments]', :value => "this is my comment" }
               end
               def test_put_update_should_allow_fixed_version_to_be_set_to_a_subproject
                 issue = Issue.find(2)
                 @request.session[:user_id] = 2
                 put :update,
                      :id => issue.id,
                      :issue => {
                        :fixed_version_id => 4
                      }
                 assert_response :redirect
                 issue.reload
                 assert_equal 4, issue.fixed_version_id
                 assert_not_equal issue.project_id, issue.fixed_version.project_id
               end
               def test_put_update_should_redirect_back_using_the_back_url_parameter
                 issue = Issue.find(2)
                 @request.session[:user_id] = 2
                 put :update,
                      :id => issue.id,
                      :issue => {
                        :fixed_version_id => 4
                      },
                      :back_url => '/issues'
                 assert_response :redirect
                 assert_redirected_to '/issues'
               end
               def test_put_update_should_not_redirect_back_using_the_back_url_parameter_off_the_host
                 issue = Issue.find(2)
                 @request.session[:user_id] = 2
                 put :update,
                      :id => issue.id,
                      :issue => {
                        :fixed_version_id => 4
                      },
                      :back_url => 'http://google.com'
                 assert_response :redirect
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => issue.id
               end
               def test_get_bulk_edit
                 @request.session[:user_id] = 2
                 get :bulk_edit, :ids => [1, 2]
                 assert_response :success
                 assert_template 'bulk_edit'
                 assert_tag :select, :attributes => {:name => 'issue[project_id]'}
                 assert_tag :input, :attributes => {:name => 'issue[parent_issue_id]'}
                 # Project specific custom field, date type
                 field = CustomField.find(9)
                 assert !field.is_for_all?
                 assert_equal 'date', field.field_format
                 assert_tag :input, :attributes => {:name => 'issue[custom_field_values][9]'}
                 # System wide custom field
                 assert CustomField.find(1).is_for_all?
                 assert_tag :select, :attributes => {:name => 'issue[custom_field_values][1]'}
                 # Be sure we don't display inactive IssuePriorities
                 assert ! IssuePriority.find(15).active?
                 assert_no_tag :option, :attributes => {:value => '15'},
                                        :parent => {:tag => 'select', :attributes => {:id => 'issue_priority_id'} }
               end
               def test_get_bulk_edit_on_different_projects
                 @request.session[:user_id] = 2
                 get :bulk_edit, :ids => [1, 2, 6]
                 assert_response :success
                 assert_template 'bulk_edit'
                 # Can not set issues from different projects as children of an issue
                 assert_no_tag :input, :attributes => {:name => 'issue[parent_issue_id]'}
                 # Project specific custom field, date type
                 field = CustomField.find(9)
                 assert !field.is_for_all?
                 assert !field.project_ids.include?(Issue.find(6).project_id)
                 assert_no_tag :input, :attributes => {:name => 'issue[custom_field_values][9]'}
               end
               def test_get_bulk_edit_with_user_custom_field
                 field = IssueCustomField.create!(:name => 'Tester', :field_format => 'user', :is_for_all => true)
                 @request.session[:user_id] = 2
                 get :bulk_edit, :ids => [1, 2]
                 assert_response :success
                 assert_template 'bulk_edit'
                 assert_tag :select,
                   :attributes => {:name => "issue[custom_field_values][#{field.id}]"},
                   :children => {
                     :only => {:tag => 'option'},
                     :count => Project.find(1).users.count + 1
                   }
               end
               def test_get_bulk_edit_with_version_custom_field
                 field = IssueCustomField.create!(:name => 'Affected version', :field_format => 'version', :is_for_all => true)
                 @request.session[:user_id] = 2
                 get :bulk_edit, :ids => [1, 2]
                 assert_response :success
                 assert_template 'bulk_edit'
                 assert_tag :select,
                   :attributes => {:name => "issue[custom_field_values][#{field.id}]"},
                   :children => {
                     :only => {:tag => 'option'},
                     :count => Project.find(1).shared_versions.count + 1
                   }
               end
               def test_get_bulk_edit_with_multi_custom_field
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 @request.session[:user_id] = 2
                 get :bulk_edit, :ids => [1, 2]
                 assert_response :success
                 assert_template 'bulk_edit'
                 assert_tag :select,
                   :attributes => {:name => "issue[custom_field_values][1][]"},
                   :children => {
                     :only => {:tag => 'option'},
                     :count => 3
                   }
               end
               def test_bulk_edit_should_only_propose_statuses_allowed_for_all_issues
                 Workflow.delete_all
                 Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 1)
                 Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 3)
                 Workflow.create!(:role_id => 1, :tracker_id => 1, :old_status_id => 1, :new_status_id => 4)
                 Workflow.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 2, :new_status_id => 1)
                 Workflow.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 2, :new_status_id => 3)
                 Workflow.create!(:role_id => 1, :tracker_id => 2, :old_status_id => 2, :new_status_id => 5)
                 @request.session[:user_id] = 2
                 get :bulk_edit, :ids => [1, 2]
                 assert_response :success
                 statuses = assigns(:available_statuses)
                 assert_not_nil statuses
                 assert_equal [1, 3], statuses.map(&:id).sort
                 assert_tag 'select', :attributes => {:name => 'issue[status_id]'},
                   :children => {:count => 3} # 2 statuses + "no change" option
               end
               def test_bulk_edit_should_propose_target_project_open_shared_versions
                 @request.session[:user_id] = 2
                 post :bulk_edit, :ids => [1, 2, 6], :issue => {:project_id => 1}
                 assert_response :success
                 assert_template 'bulk_edit'
                 assert_equal Project.find(1).shared_versions.open.all.sort, assigns(:versions).sort
                 assert_tag 'select',
                   :attributes => {:name => 'issue[fixed_version_id]'},
                   :descendant => {:tag => 'option', :content => '2.0'}
               end
               def test_bulk_edit_should_propose_target_project_categories
                 @request.session[:user_id] = 2
                 post :bulk_edit, :ids => [1, 2, 6], :issue => {:project_id => 1}
                 assert_response :success
                 assert_template 'bulk_edit'
                 assert_equal Project.find(1).issue_categories.sort, assigns(:categories).sort
                 assert_tag 'select',
                   :attributes => {:name => 'issue[category_id]'},
                   :descendant => {:tag => 'option', :content => 'Recipes'}
               end
               def test_bulk_update
                 @request.session[:user_id] = 2
                 # update issues priority
                 post :bulk_update, :ids => [1, 2], :notes => 'Bulk editing',
                                                  :issue => {:priority_id => 7,
                                                             :assigned_to_id => '',
                                                             :custom_field_values => {'2' => ''}}
                 assert_response 302
                 # check that the issues were updated
                 assert_equal [7, 7], Issue.find_all_by_id([1, 2]).collect {|i| i.priority.id}
                 issue = Issue.find(1)
                 journal = issue.journals.find(:first, :order => 'created_on DESC')
                 assert_equal '125', issue.custom_value_for(2).value
                 assert_equal 'Bulk editing', journal.notes
                 assert_equal 1, journal.details.size
               end
               def test_bulk_update_with_group_assignee
                 group = Group.find(11)
                 project = Project.find(1)
                 project.members << Member.new(:principal => group, :roles => [Role.givable.first])
                 @request.session[:user_id] = 2
                 # update issues assignee
                 post :bulk_update, :ids => [1, 2], :notes => 'Bulk editing',
                                                  :issue => {:priority_id => '',
                                                             :assigned_to_id => group.id,
                                                             :custom_field_values => {'2' => ''}}
                 assert_response 302
                 assert_equal [group, group], Issue.find_all_by_id([1, 2]).collect {|i| i.assigned_to}
               end
               def test_bulk_update_on_different_projects
                 @request.session[:user_id] = 2
                 # update issues priority
                 post :bulk_update, :ids => [1, 2, 6], :notes => 'Bulk editing',
                                                  :issue => {:priority_id => 7,
                                                             :assigned_to_id => '',
                                                             :custom_field_values => {'2' => ''}}
                 assert_response 302
                 # check that the issues were updated
                 assert_equal [7, 7, 7], Issue.find([1,2,6]).map(&:priority_id)
                 issue = Issue.find(1)
                 journal = issue.journals.find(:first, :order => 'created_on DESC')
                 assert_equal '125', issue.custom_value_for(2).value
                 assert_equal 'Bulk editing', journal.notes
                 assert_equal 1, journal.details.size
               end
               def test_bulk_update_on_different_projects_without_rights
                 @request.session[:user_id] = 3
                 user = User.find(3)
                 action = { :controller => "issues", :action => "bulk_update" }
                 assert user.allowed_to?(action, Issue.find(1).project)
                 assert ! user.allowed_to?(action, Issue.find(6).project)
                 post :bulk_update, :ids => [1, 6], :notes => 'Bulk should fail',
                                                  :issue => {:priority_id => 7,
                                                             :assigned_to_id => '',
                                                             :custom_field_values => {'2' => ''}}
                 assert_response 403
                 assert_not_equal "Bulk should fail", Journal.last.notes
               end
               def test_bullk_update_should_send_a_notification
                 @request.session[:user_id] = 2
                 ActionMailer::Base.deliveries.clear
                 post(:bulk_update,
                      {
                        :ids => [1, 2],
                        :notes => 'Bulk editing',
                        :issue => {
                          :priority_id => 7,
                          :assigned_to_id => '',
                          :custom_field_values => {'2' => ''}
                        }
                      })
                 assert_response 302
                 assert_equal 2, ActionMailer::Base.deliveries.size
               end
               def test_bulk_update_project
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1, 2], :issue => {:project_id => '2'}
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook'
                 # Issues moved to project 2
                 assert_equal 2, Issue.find(1).project_id
                 assert_equal 2, Issue.find(2).project_id
                 # No tracker change
                 assert_equal 1, Issue.find(1).tracker_id
                 assert_equal 2, Issue.find(2).tracker_id
               end
               def test_bulk_update_project_on_single_issue_should_follow_when_needed
                 @request.session[:user_id] = 2
                 post :bulk_update, :id => 1, :issue => {:project_id => '2'}, :follow => '1'
                 assert_redirected_to '/issues/1'
               end
               def test_bulk_update_project_on_multiple_issues_should_follow_when_needed
                 @request.session[:user_id] = 2
                 post :bulk_update, :id => [1, 2], :issue => {:project_id => '2'}, :follow => '1'
                 assert_redirected_to '/projects/onlinestore/issues'
               end
               def test_bulk_update_tracker
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1, 2], :issue => {:tracker_id => '2'}
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook'
                 assert_equal 2, Issue.find(1).tracker_id
                 assert_equal 2, Issue.find(2).tracker_id
               end
               def test_bulk_update_status
                 @request.session[:user_id] = 2
                 # update issues priority
                 post :bulk_update, :ids => [1, 2], :notes => 'Bulk editing status',
                                                  :issue => {:priority_id => '',
                                                             :assigned_to_id => '',
                                                             :status_id => '5'}
                 assert_response 302
                 issue = Issue.find(1)
                 assert issue.closed?
               end
               def test_bulk_update_priority
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1, 2], :issue => {:priority_id => 6}
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook'
                 assert_equal 6, Issue.find(1).priority_id
                 assert_equal 6, Issue.find(2).priority_id
               end
               def test_bulk_update_with_notes
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1, 2], :notes => 'Moving two issues'
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook'
                 assert_equal 'Moving two issues', Issue.find(1).journals.sort_by(&:id).last.notes
                 assert_equal 'Moving two issues', Issue.find(2).journals.sort_by(&:id).last.notes
               end
               def test_bulk_update_parent_id
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1, 3],
                   :notes => 'Bulk editing parent',
                   :issue => {:priority_id => '', :assigned_to_id => '', :status_id => '', :parent_issue_id => '2'}
                 assert_response 302
                 parent = Issue.find(2)
                 assert_equal parent.id, Issue.find(1).parent_id
                 assert_equal parent.id, Issue.find(3).parent_id
                 assert_equal [1, 3], parent.children.collect(&:id).sort
               end
               def test_bulk_update_custom_field
                 @request.session[:user_id] = 2
                 # update issues priority
                 post :bulk_update, :ids => [1, 2], :notes => 'Bulk editing custom field',
                                                  :issue => {:priority_id => '',
                                                             :assigned_to_id => '',
                                                             :custom_field_values => {'2' => '777'}}
                 assert_response 302
                 issue = Issue.find(1)
                 journal = issue.journals.find(:first, :order => 'created_on DESC')
                 assert_equal '777', issue.custom_value_for(2).value
                 assert_equal 1, journal.details.size
                 assert_equal '125', journal.details.first.old_value
                 assert_equal '777', journal.details.first.value
               end
               def test_bulk_update_multi_custom_field
                 field = CustomField.find(1)
                 field.update_attribute :multiple, true
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1, 2, 3], :notes => 'Bulk editing multi custom field',
                                                  :issue => {:priority_id => '',
                                                             :assigned_to_id => '',
                                                             :custom_field_values => {'1' => ['MySQL', 'Oracle']}}
                 assert_response 302
                 assert_equal ['MySQL', 'Oracle'], Issue.find(1).custom_field_value(1).sort
                 assert_equal ['MySQL', 'Oracle'], Issue.find(3).custom_field_value(1).sort
                 # the custom field is not associated with the issue tracker
                 assert_nil Issue.find(2).custom_field_value(1)
               end
               def test_bulk_update_unassign
                 assert_not_nil Issue.find(2).assigned_to
                 @request.session[:user_id] = 2
                 # unassign issues
                 post :bulk_update, :ids => [1, 2], :notes => 'Bulk unassigning', :issue => {:assigned_to_id => 'none'}
                 assert_response 302
                 # check that the issues were updated
                 assert_nil Issue.find(2).assigned_to
               end
               def test_post_bulk_update_should_allow_fixed_version_to_be_set_to_a_subproject
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1,2], :issue => {:fixed_version_id => 4}
                 assert_response :redirect
                 issues = Issue.find([1,2])
                 issues.each do |issue|
                   assert_equal 4, issue.fixed_version_id
                   assert_not_equal issue.project_id, issue.fixed_version.project_id
                 end
               end
               def test_post_bulk_update_should_redirect_back_using_the_back_url_parameter
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1,2], :back_url => '/issues'
                 assert_response :redirect
                 assert_redirected_to '/issues'
               end
               def test_post_bulk_update_should_not_redirect_back_using_the_back_url_parameter_off_the_host
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1,2], :back_url => 'http://google.com'
                 assert_response :redirect
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => Project.find(1).identifier
               end
               def test_bulk_update_with_failure_should_set_flash
                 @request.session[:user_id] = 2
                 Issue.update_all("subject = ''", "id = 2") # Make it invalid
                 post :bulk_update, :ids => [1, 2], :issue => {:priority_id => 6}
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook'
                 assert_equal 'Failed to save 1 issue(s) on 2 selected: #2.', flash[:error]
               end
               def test_bulk_copy_to_another_project
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count', 2 do
                   assert_no_difference 'Project.find(1).issues.count' do
                     post :bulk_update, :ids => [1, 2], :issue => {:project_id => '2'}, :copy => '1'
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/issues'
               end
               def test_bulk_copy_should_allow_not_changing_the_issue_attributes
                 @request.session[:user_id] = 2
                 issue_before_move = Issue.find(1)
                 assert_difference 'Issue.count', 1 do
                   assert_no_difference 'Project.find(1).issues.count' do
                     post :bulk_update, :ids => [1], :copy => '1',
                          :issue => {
                            :project_id => '2', :tracker_id => '', :assigned_to_id => '',
                            :status_id => '', :start_date => '', :due_date => ''
                          }
                   end
                 end
                 issue_after_move = Issue.first(:order => 'id desc', :conditions => {:project_id => 2})
                 assert_equal issue_before_move.tracker_id, issue_after_move.tracker_id
                 assert_equal issue_before_move.status_id, issue_after_move.status_id
                 assert_equal issue_before_move.assigned_to_id, issue_after_move.assigned_to_id
               end
              def test_bulk_copy_should_allow_changing_the_issue_attributes
                 # Fixes random test failure with Mysql
                 # where Issue.all(:limit => 2, :order => 'id desc', :conditions => {:project_id => 2})
                 # doesn't return the expected results
                 Issue.delete_all("project_id=2")
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count', 2 do
                   assert_no_difference 'Project.find(1).issues.count' do
                     post :bulk_update, :ids => [1, 2], :copy => '1',
                          :issue => {
                            :project_id => '2', :tracker_id => '', :assigned_to_id => '4',
                            :status_id => '3', :start_date => '2009-12-01', :due_date => '2009-12-31'
                          }
                   end
                 end
                 copied_issues = Issue.all(:limit => 2, :order => 'id desc', :conditions => {:project_id => 2})
                 assert_equal 2, copied_issues.size
                 copied_issues.each do |issue|
                   assert_equal 2, issue.project_id, "Project is incorrect"
                   assert_equal 4, issue.assigned_to_id, "Assigned to is incorrect"
                   assert_equal 3, issue.status_id, "Status is incorrect"
                   assert_equal '2009-12-01', issue.start_date.to_s, "Start date is incorrect"
                   assert_equal '2009-12-31', issue.due_date.to_s, "Due date is incorrect"
                 end
               end
               def test_bulk_copy_should_allow_adding_a_note
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count', 1 do
                   post :bulk_update, :ids => [1], :copy => '1',
                        :notes => 'Copying one issue',
                        :issue => {
                          :project_id => '', :tracker_id => '', :assigned_to_id => '4',
                          :status_id => '3', :start_date => '2009-12-01', :due_date => '2009-12-31'
                        }
                 end
                 issue = Issue.first(:order => 'id DESC')
                 assert_equal 1, issue.journals.size
                 journal = issue.journals.first
                 assert_equal 0, journal.details.size
                 assert_equal 'Copying one issue', journal.notes
               end
               def test_bulk_copy_to_another_project_should_follow_when_needed
                 @request.session[:user_id] = 2
                 post :bulk_update, :ids => [1], :copy => '1', :issue => {:project_id => 2}, :follow => '1'
                 issue = Issue.first(:order => 'id DESC')
                 assert_redirected_to :controller => 'issues', :action => 'show', :id => issue
               end
               def test_destroy_issue_with_no_time_entries
                 assert_nil TimeEntry.find_by_issue_id(2)
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count', -1 do
                   delete :destroy, :id => 2
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil Issue.find_by_id(2)
               end
               def test_destroy_issues_with_time_entries
                 @request.session[:user_id] = 2
                 assert_no_difference 'Issue.count' do
                   delete :destroy, :ids => [1, 3]
                 end
                 assert_response :success
                 assert_template 'destroy'
                 assert_not_nil assigns(:hours)
                 assert Issue.find_by_id(1) && Issue.find_by_id(3)
                 assert_tag 'form',
                   :descendant => {:tag => 'input', :attributes => {:name => '_method', :value => 'delete'}}
               end
               def test_destroy_issues_and_destroy_time_entries
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count', -2 do
                   assert_difference 'TimeEntry.count', -3 do
                     delete :destroy, :ids => [1, 3], :todo => 'destroy'
                   end
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert !(Issue.find_by_id(1) || Issue.find_by_id(3))
                 assert_nil TimeEntry.find_by_id([1, 2])
               end
               def test_destroy_issues_and_assign_time_entries_to_project
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count', -2 do
                   assert_no_difference 'TimeEntry.count' do
                     delete :destroy, :ids => [1, 3], :todo => 'nullify'
                   end
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert !(Issue.find_by_id(1) || Issue.find_by_id(3))
                 assert_nil TimeEntry.find(1).issue_id
                 assert_nil TimeEntry.find(2).issue_id
               end
               def test_destroy_issues_and_reassign_time_entries_to_another_issue
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count', -2 do
                   assert_no_difference 'TimeEntry.count' do
                     delete :destroy, :ids => [1, 3], :todo => 'reassign', :reassign_to_id => 2
                   end
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert !(Issue.find_by_id(1) || Issue.find_by_id(3))
                 assert_equal 2, TimeEntry.find(1).issue_id
                 assert_equal 2, TimeEntry.find(2).issue_id
               end
               def test_destroy_issues_from_different_projects
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count', -3 do
                   delete :destroy, :ids => [1, 2, 6], :todo => 'destroy'
                 end
                 assert_redirected_to :controller => 'issues', :action => 'index'
                 assert !(Issue.find_by_id(1) || Issue.find_by_id(2) || Issue.find_by_id(6))
               end
               def test_destroy_parent_and_child_issues
                 parent = Issue.create!(:project_id => 1, :author_id => 1, :tracker_id => 1, :subject => 'Parent Issue')
                 child = Issue.create!(:project_id => 1, :author_id => 1, :tracker_id => 1, :subject => 'Child Issue', :parent_issue_id => parent.id)
                 assert child.is_descendant_of?(parent.reload)
                 @request.session[:user_id] = 2
                 assert_difference 'Issue.count', -2 do
                   delete :destroy, :ids => [parent.id, child.id], :todo => 'destroy'
                 end
                 assert_response 302
               end
               def test_default_search_scope
                 get :index
                 assert_tag :div, :attributes => {:id => 'quick-search'},
                                  :child => {:tag => 'form',
                                             :child => {:tag => 'input', :attributes => {:name => 'issues', :type => 'hidden', :value => '1'}}}
               end
             end

test/functional/watchers_controller_test.rb +19 0

             # Redmine - project management software
             # Copyright (C) 2006-2011  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__)
             require 'watchers_controller'
             # Re-raise errors caught by the controller.
             class WatchersController; def rescue_action(e) raise e end; end
             class WatchersControllerTest < ActionController::TestCase
               fixtures :projects, :users, :roles, :members, :member_roles, :enabled_modules,
                        :issues, :trackers, :projects_trackers, :issue_statuses, :enumerations, :watchers
               def setup
                 @controller = WatchersController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
               def test_watch
                 @request.session[:user_id] = 3
                 assert_difference('Watcher.count') do
                   xhr :post, :watch, :object_type => 'issue', :object_id => '1'
                   assert_response :success
                   assert @response.body.include?('$$(".issue-1-watcher")')
                 end
                 assert Issue.find(1).watched_by?(User.find(3))
               end
               def test_watch_should_be_denied_without_permission
                 Role.find(2).remove_permission! :view_issues
                 @request.session[:user_id] = 3
                 assert_no_difference('Watcher.count') do
                   xhr :post, :watch, :object_type => 'issue', :object_id => '1'
                   assert_response 403
                 end
               end
               def test_unwatch
                 @request.session[:user_id] = 3
                 assert_difference('Watcher.count', -1) do
                   xhr :post, :unwatch, :object_type => 'issue', :object_id => '2'
                   assert_response :success
                   assert @response.body.include?('$$(".issue-2-watcher")')
                 end
                 assert !Issue.find(1).watched_by?(User.find(3))
               end
               def test_new
                 @request.session[:user_id] = 2
                 xhr :get, :new, :object_type => 'issue', :object_id => '2'
                 assert_response :success
                 assert_select_rjs :replace_html, 'ajax-modal'
               end
+              def test_new_for_new_record
+                @request.session[:user_id] = 2
+                xhr :get, :new, :project_id => 1
+                assert_response :success
+                assert_select_rjs :replace_html, 'ajax-modal'
+              end
               def test_create
                 @request.session[:user_id] = 2
                 assert_difference('Watcher.count') do
                   xhr :post, :create, :object_type => 'issue', :object_id => '2', :watcher => {:user_id => '4'}
                   assert_response :success
                   assert_select_rjs :replace_html, 'watchers'
                   assert_select_rjs :replace_html, 'ajax-modal'
                 end
                 assert Issue.find(2).watched_by?(User.find(4))
               end
               def test_create_multiple
                 @request.session[:user_id] = 2
                 assert_difference('Watcher.count', 2) do
                   xhr :post, :create, :object_type => 'issue', :object_id => '2', :watcher => {:user_ids => ['4', '7']}
                   assert_response :success
                   assert_select_rjs :replace_html, 'watchers'
                   assert_select_rjs :replace_html, 'ajax-modal'
                 end
                 assert Issue.find(2).watched_by?(User.find(4))
                 assert Issue.find(2).watched_by?(User.find(7))
               end
+              def test_append
+                @request.session[:user_id] = 2
+                assert_no_difference 'Watcher.count' do
+                  xhr :post, :append, :watcher => {:user_ids => ['4', '7']}
+                  assert_response :success
+                  assert_select_rjs :insert_html, 'watchers_inputs' do
+                    assert_select 'input[name=?][value=4]', 'issue[watcher_user_ids][]'
+                    assert_select 'input[name=?][value=7]', 'issue[watcher_user_ids][]'
+                  end
+                end
+              end
               def test_remove_watcher
                 @request.session[:user_id] = 2
                 assert_difference('Watcher.count', -1) do
                   xhr :post, :destroy, :object_type => 'issue', :object_id => '2', :user_id => '3'
                   assert_response :success
                   assert_select_rjs :replace_html, 'watchers'
                 end
                 assert !Issue.find(2).watched_by?(User.find(3))
               end
             end

test/integration/routing/watchers_test.rb +4 0

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 RoutingWatchersTest < ActionController::IntegrationTest
               def test_watchers
                 assert_routing(
                     { :method => 'get', :path => "/watchers/new" },
                     { :controller => 'watchers', :action => 'new' }
                   )
                 assert_routing(
+                    { :method => 'post', :path => "/watchers/append" },
+                    { :controller => 'watchers', :action => 'append' }
+                  )
+                assert_routing(
                     { :method => 'post', :path => "/watchers" },
                     { :controller => 'watchers', :action => 'create' }
                   )
                 assert_routing(
                     { :method => 'post', :path => "/watchers/destroy" },
                     { :controller => 'watchers', :action => 'destroy' }
                   )
                 assert_routing(
                     { :method => 'get', :path => "/watchers/autocomplete_for_user" },
                     { :controller => 'watchers', :action => 'autocomplete_for_user' }
                   )
                 assert_routing(
                     { :method => 'post', :path => "/watchers/watch" },
                     { :controller => 'watchers', :action => 'watch' }
                   )
                 assert_routing(
                     { :method => 'post', :path => "/watchers/unwatch" },
                     { :controller => 'watchers', :action => 'unwatch' }
                   )
               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